What's New in PHP 8.4: Key Enhancements and Updates

Introduction

PHP 8.4 introduces a range of exciting features and updates designed to enhance the way developers work with the language. This release focuses on making coding more efficient, secure, and intuitive.

With additions like Property Hooks, Auto-Capturing Closures, and Asymmetric Visibility, developers can enjoy cleaner and more flexible code. New array functions also simplify common tasks, saving time and reducing boilerplate.

Alongside these features, PHP 8.4 brings performance improvements that help your applications run faster.

Whether you’re a PHP expert or just starting out, these updates will make your coding experience smoother and more enjoyable. If you’re looking to leverage the full potential of PHP 8.4 for your project, hire a PHP developer to ensure your application is built with the latest features and best practices.

PHP 8.4 Release

With PHP 8.4, the evolution of one of the most popular server-side scripting languages continues, bringing a variety of tools and refinements to make developers’ lives easier. This release is packed with game-changing features that simplify coding and boost efficiency. Let’s explore all these updates in detail:

• Property Hooks

• Expanded Array Functionality

• Streamlined Class Instantiation

• Asymmetric Property Visibility for Fine-Grained Control

• Upgraded HTML5 Parsing and Serialization

1. Property Hooks

Property Hooks in PHP introduce a powerful way to manage class properties by allowing developers to attach specific behaviors when accessing or modifying them. This feature, introduced after read-only properties in PHP 8, provides hooks for “get” and “set” operations. 

These hooks are essentially small callables that execute custom logic when a property is retrieved or updated, offering a clean way to validate or process values dynamically. 

Unlike traditional methods that relied on boilerplate getters and setters or magic methods like __get and __set, property hooks streamline the process while maintaining clear and efficient code. 

This new approach is especially useful in scenarios where properties must remain mutable but enforce certain rules or transformations. By reducing the need for redundant code, Property Hooks improves both the maintainability and readability of PHP applications.

Example:

class User implements Named 

{ 

    private bool $isModified = false; 

    public function __construct(private string $first, private string $last) {} 

    public string $fullName { 

        // Override the “read” action with arbitrary logic. 

        get => $this->first . ” ” . $this->last; 

        // Override the “write” action with arbitrary logic. 

        set {  

            [$this->first, $this->last] = explode(‘ ‘, $value, 2); 

            $this->isModified = true; 

        } 

    } 

}

2. Latest array_*() Functions

The PHP 8.4 release isn’t just about enhancements to its object-oriented features; it also brings in several handy new array functions. These functions are designed to streamline the process of evaluating array values based on specific conditions. Here’s what they offer:

1. array_find: Retrieves the first element in an array that meets a given condition.
2. array_find_key: Identifies the first key in an array that satisfies a particular condition.
3. array_any: Determines if at least one element in the array matches a specified condition.
4. array_all: Confirms whether every element in the array adheres to a given condition.

Each function takes two parameters: the array to examine and a callback function that defines the condition. The callback is applied to each array element in sequence. If the condition is met, the function halts and returns the result immediately, except for array_all(), which continues until every element has been checked. Only if all elements pass the test does it return true.

These additions aim to make array operations more concise and expressive.

Example: 

$numbers = [1, 2, 3, 4, 5];

$found = array_find($numbers, fn($value) => $value > 3);

echo $found; // Output: 4

$foundKey = array_find_key($numbers, fn($value) => $value > 3);

echo $foundKey; // Output: 3

$anyEven = array_any($numbers, fn($value) => $value % 2 === 0);

echo $anyEven ? ‘Yes’ : ‘No’; // Output: Yes

$allPositive = array_all($numbers, fn($value) => $value > 0);

echo $allPositive ? ‘Yes’ : ‘No’;

3. Streamlined Class Instantiation

In PHP, developers frequently create objects and immediately call methods or access properties on them. Before PHP 8.4, achieving this required enclosing the instantiation in parentheses, sometimes resulting in unnecessarily verbose or cluttered code.

Example:

<?php

$session = (new Session())->start()->set(‘user’, ‘John Doe’);

?>

4. Asymmetric Property Visibility

PHP 8.4 introduces a new feature called asymmetric property visibility, which allows developers to set different access levels for reading and writing a property. This allows you to make a property publicly readable while restricting its modification to within the class or its child classes, providing better control over data.

Example:

In the following example, the $name property is accessible for reading by anyone, but it can only be modified inside the class itself or by its subclasses:

<?php

class User { 

    public private(set) string $name; 

    public function __construct(string $name) { 

        $this->name = $name; // Allowed since it’s within the class 

    }   

    public function changeName(string $newName) { 

        $this->name = $newName; // Also allowed within the class 

    } 

} 

$user = new User(“Alice”); 

echo $user->name;    // Outputs: Alice (public read access)   

$user->name = “Bob”; // Error: Cannot modify due to private(set)

?>

5. Upgraded HTML5 Parsing and Serialization

PHP has made a significant leap in web development by introducing the DOM\HTMLDocument class, providing native support for HTML5 parsing and serialization. This update resolves long-standing issues caused by PHP’s reliance on \DOMDocument, which uses libxml2 and is limited to HTML4.01. Previously, developers faced errors and malformed structures when working with HTML5 content due to outdated parsing capabilities.

Thanks to Niels Dossche’s implementation, the new DOM\HTMLDocument class integrates seamlessly into PHP’s DOM extension. 

It uses Lexbor, a high-performance and standard-compliant HTML5 parser, to accurately handle HTML5’s broader tag set and parsing rules. The integration fixes issues like handling semantic elements and JavaScript embedded in HTML, while ensuring compatibility with older HTML4 documents.

To avoid disrupting existing workflows, the \DOMDocument class remains unchanged, with the new DOM\HTMLDocument class dedicated to HTML5. This enhancement modernizes PHP’s DOM extension, aligning it with current web standards and making it more robust for modern web development tasks. 

If you’re looking for PHP web development services, this update ensures that developers can now leverage PHP’s full potential for handling contemporary web content.

PHP 8.4 Deprecations

PHP 8.4 introduces several updates, including the deprecation of implicit nullable types and GET/POST session handling. Here’s an overview of these changes and how they may affect your applications.

Implicit Nullable Types

Previously, you could create nullable types implicitly by assigning null as a default value:

function foo(T1 $a, T2 $b = null, T3 $c) {}  

While PHP later introduced explicit nullable types:

function bar(T1 $a, ?T2 $b = null, T3 $c) {}  

Or union types:

function test(T1 $a, T2|null $b = null, T3 $c) {}  

The implicit approach remained valid. However, starting with PHP 8.4, this implicit declaration is deprecated. Developers must now use explicit nullable types or union types that include null.

Deprecation of GET/POST Sessions

Tracking user states is often done via cookies, which is recommended. However, PHP also allowed session handling through GET and POST parameters using the session.use_only_cookies and session.use_trans_sid settings.

By default, session.use_only_cookies is enabled, and session.use_trans_sid is disabled. These settings were meant to support browsers that previously lacked cookie support. With PHP 8.4, altering these settings will trigger a deprecation warning. In PHP 9, they will be entirely removed.

Other Deprecations

In addition to the above, PHP 8.4 includes several other deprecations, some resulting from recent RFCs. These changes continue PHP’s focus on modernizing and streamlining functionality, making reviewing and updating legacy code essential.

Adapting to these updates will help ensure your applications remain compatible with future PHP versions.

Additional Features of PHP 8.4

Here are some standout features that users can look forward to:

• Expanded support for additional HTTP verbs in $_POST and $_FILES. 
• New multibyte trimming functions: mb_trim(), mb_ltrim(), and mb_rtrim(). 
• Enhanced precision in the round() function with new rounding modes. 
• PDO subclasses now offer driver-specific features for better functionality. 
• Improved support for DOM and XSL callbacks, allowing closures, first-class callables, and instance methods. 
• Lazy Object support, enabling efficient creation of ghost objects and proxies—perfect for frameworks and ORMs handling dependency injection and object hydration. 
• A new #[Deprecated] attribute to easily mark outdated functionality. 
• Upgrades to the BCMath, GMP, and DOM extensions for better performance and features.

PHP 8.4 Release Date Timeline (Snapshot)

Wrapping Up

The release of PHP 8.4 marks a significant milestone in PHP’s evolution. With enhanced features to boost security, performance, and overall developer experience, this update empowers developers to build faster and more resilient applications. 

While PHP 8.4 introduces exciting new features, it also builds upon the foundation laid by PHP 8.3, continuing to refine and improve upon the PHP 8.3 features. 

By addressing the needs of modern developers and businesses, PHP 8.4 underscores the language’s continued importance in web development and its commitment to staying relevant in an ever-evolving tech landscape.