PHP 8.5 Complete Features, Deprecations & Updates (2025) | New Changes, Examples

PHP 8.5 brings a host of exciting new features, improvements, and several deprecations. From the highly anticipated Pipe Operator to better debugging tools and modern URL handling, this update provides a smoother experience for developers. In this guide, we will explore all the new features in PHP 8.5, provide real-world project examples, and also highlight deprecated features that you should avoid in your code.

What's New in PHP 8.5 image

PHP 8.5 focuses on improving code readability, modernizing syntax, better error handling, and introducing useful built-in functions. Alongside these improvements, there are also some deprecations you should be aware of, as they might affect your existing codebases and future development. In this article, we will provide a comprehensive breakdown of the key features and deprecated functions in PHP 8.5.

1. Pipe Operator (|>) – Cleaner Data Processing

The Pipe Operator is one of the most anticipated features in PHP 8.5. It allows functions to be chained together in a more readable way. This helps in writing cleaner code, especially when transforming data in a series of steps..

Real Project Example

For a user registration system where the username needs to be cleaned, transformed, and validated:

$username = $input
    |> str_replace("-", "_", ...)
    |> strtolower(...)
    |> trim(...);

This makes the code more readable and avoids long nested function calls, making it easier to follow the transformation process.

2. New Array Functions: array_first() and array_last()

PHP 8.5 introduces two new helper functions: array_first() and array_last(). These functions simplify accessing the first and last elements of an array, making your code cleaner and more intuitive. No more complex logic using reset() or end() functions to fetch the first and last items.

Real Project Example

In an eCommerce site, when you fetch a list of recommended products, you may want to access the first and last items for highlighting the highest and lowest priorities:

$recommended = ["Laptop", "Tablet", "Mouse"];
$first = array_first($recommended);
$last  = array_last($recommended);

This eliminates the need for using reset() or end(), which could be confusing in complex projects with shared array pointers.

3. New URI Extension for Modern URL Handling

PHP 8.5 introduces a new, object-oriented URI handling extension, making URL parsing and manipulation simpler and more predictable. This allows developers to work with URLs in a more structured manner.

Real Project Example

In an API project, you may need to dynamically build or validate URLs. For instance, extracting components of the URL, such as host, path, or query parameters:

$uri = new URI("https://example.com/products?page=4");

echo $uri->host;  // example.com
echo $uri->path;  // /products
echo $uri->query; // page=4

This allows you to safely extract and manipulate URL components in a more reliable and predictable manner, reducing potential bugs.

4. New Functions: get_error_handler() & get_exception_handler()

PHP 8.5 provides two new functions to retrieve the current error and exception handlers without replacing them. This is useful for frameworks, custom libraries, or middleware that needs to inspect or modify the existing error-handling logic.

Real Project Example

In a complex system, you may want to check the currently set error handler before making any changes. This can be done using:

$handler = get_error_handler();
var_dump($handler);

This is particularly helpful when debugging, logging, and inspecting error handling behavior across different parts of your application or framework.

6. New INI Directive: max_memory_limit

This new directive sets a hard limit on memory usage. This is especially useful in cloud environments, Docker containers, or shared hosting where you need to ensure memory limits are strictly enforced.

Real Project Example

In a complex system, you may want to check the currently set error handler before making any changes. This can be done using:

max_memory_limit = 512M

This prevents any scripts from exceeding a defined memory usage, thus preventing out-of-memory crashes that could affect your web application performance.

4. Final Property Promotion

PHP 8.5 allows you to mark promoted constructor properties as final, ensuring that they cannot be changed after initialization. This is useful for creating immutable objects or data structures in your application.

Real Project Example

If you're building a financial system, it's important that the transaction ID doesn't change once it's set:

class Transaction {
    public function __construct(
        public final string $transactionId,
        public string $user
    ) {}
}

This helps enforce data integrity and immutability, ensuring that critical values remain constant after object instantiation.

4. Closures & Callables Allowed in Constant Expressions

In PHP 8.5, closures and callables are allowed in constant expressions, enabling better reusability and functional programming patterns.

Real Project Example

In a data validation system, you may want to create reusable logic as a constant function:

const CLEAN = fn($v) => trim(strtolower($v));

This makes your application code more modular and keeps your constants dynamic, allowing you to centralize reusable functionality.

4. New Constant: PHP_BUILD_DATE

The PHP_BUILD_DATE constant provides the exact build date of the PHP version you are using. This is especially useful for debugging and version tracking in CI/CD pipelines or server environments.

Real Project Example

In a data validation system, you may want to create reusable logic as a constant function:

echo PHP_BUILD_DATE;

It is particularly useful in environments where tracking PHP's exact version is crucial for debugging or compatibility purposes.

4. Internationalization (i18n) Improvements

PHP 8.5 brings improvements to i18n functions, including better support for right-to-left languages like Arabic, Hebrew, etc. This is crucial for building multilingual applications that work across multiple regions and languages.

Real Project Example

In a multilingual application, you can now detect and adjust the UI for right-to-left languages:

if (locale_is_right_to_left("ar")) {
    // Change UI direction to RTL
}

4. php --ini=diff Command

PHP 8.5 introduces the php --ini=diff command, which shows the difference between the current PHP configuration and the default configuration.

Real Project Example

php --ini=diff

This is useful when debugging PHP configurations and ensuring that your environment matches your deployment configuration.

4. New Attribute: #[NoDiscard]

With the #[NoDiscard] attribute, PHP will prevent discarded attributes from being removed by the compiler. This is particularly helpful when working with attributes in a larger codebase, ensuring that essential attributes are not accidentally dropped.

Real Project Example

In a data validation system, you may want to create reusable logic as a constant function:

#[NoDiscard] class MyClass { ... }

Deprecations in PHP 8.5

With the #[NoDiscard] attribute, PHP will prevent discarded attributes from being removed by the compiler. This is particularly helpful when working with attributes in a larger codebase, ensuring that essential attributes are not accidentally dropped.

• Deprecated: each() Function - The each() function has been deprecated in favor of more modern iteration functions like foreach().
• Deprecated: mbstring.func_overload - The mbstring.func_overload directive has been deprecated and should be avoided.
• Deprecated: create_function() - This function is deprecated, and developers are encouraged to use anonymous functions instead.

Conclusion

PHP 8.5 introduces several game-changing features that enhance developer productivity, improve performance, and ensure cleaner, more readable code. However, developers must also be mindful of deprecated functions to keep their code up to date and future-proof. By integrating these new features and addressing deprecated functions, you'll be able to write more efficient, maintainable PHP code.