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

As PHP 8.4's release on November 21, 2024, approaches, it's clear that PHP continues to evolve and delight its developer community. For those who have been coding with PHP since its earlier versions, each new release feels like a reunion with a familiar friend—one that keeps surprising you with their growth and transformation.

PHP 8.4 packs a punch with a slew of new features that promise to make coding more elegant, efficient, and expressive. Let's dive into what's new!

Native Array Operations: Introducing Array Find

PHP 8.4 delivers long-awaited built-in support for common array operations, including functions like array_find(), array_any(), and array_all(). This simplifies working with collections, making it more efficient and intuitive.

Example:

$recentOrder = array_find(
    $orders, fn($order) => $order->isRecent()
);

These native functions ensure optimized performance and reduce the need for external libraries.

Property Hooks: Reducing Redundancy

Gone are the days of repetitive getters and setters for every property. Property hooks allow properties to define their own get and set operations, making classes cleaner and more intuitive.

Example:

class Product
{
    public float $price {
        set (float $value) {
            $this->price = max($value, 0); // Ensures non-negative prices
        }

        get => $this->price;
    }
}

Developers can also define hooks in interfaces for even greater flexibility:

interface Editable
{
    public string $title { get; set; }
    public bool $published { get; }
}

Asymmetric Visibility: More Control Over Property Access

PHP 8.4 introduces asymmetric visibility, allowing different levels of access control for reading (get) and writing (set) properties. This change enables granular control and aligns PHP more closely with modern languages like Swift.

Example of a publicly readable but privately writable property:

class Order
{
    public private(set) int $status;
}

For write access within subclasses:

class Document
{
    public protected(set) string $content;
}

This enhancement extends to constructor-promoted properties as well:

public function __construct(
    public private(set) Customer $customer
) {}

Simplified Object Creation: No Parentheses on "New"

A small but significant change in PHP 8.4 is the ability to chain method calls on new objects without parentheses, resulting in cleaner and more readable code.

Old way:

phpCopy code$log = (new Logger($level))->write("System initialized");

New way:

phpCopy code$log = new Logger($level)->write("System initialized");

This improvement applies to methods, properties, static methods, and constants.

HTML5 Support: The \Dom\HTMLDocument Class

With PHP 8.4, developers can easily parse HTML5 using the new \Dom\HTMLDocument class, simplifying interactions with modern web structures.

Example:

$html = '<p>Welcome to PHP 8.4!</p>';
$doc = \Dom\HTMLDocument::createFromString($html);

This update reduces the challenges associated with handling complex HTML5 content.

Exit and Die Now Recognized as Functions

The exit and die commands are now recognized as proper functions in PHP 8.4. While their behavior remains consistent with previous versions, treating them as functions enhances readability and aligns them more closely with other PHP constructs.

Native Support for Lazy Object Initialization

PHP 8.4 introduces native support for lazy objects, deferring object initialization until needed and boosting performance in resource-heavy applications. This change is valuable for dependency injection, ORM entities, and more.

Example:

$initializer = static fn(User $proxy): User => new User('John Doe');
$reflector = new ReflectionClass(User::class);
$proxyObject = $reflector->newLazyProxy($initializer);

This reduces boilerplate code and enhances maintainability.

The #Deprecated Attribute: Cleaner Code Management

PHP 8.4 brings a new way to handle deprecation notices with the #Deprecated attribute, making it easier to manage legacy code.

Example:

#[Deprecated("Use newHandler() instead", since: "3.1")]
function oldHandler() { }

This clear, expressive approach replaces traditional docblocks.

Deprecating Implicit Nullable Types

Implicit nullable types are now deprecated in PHP 8.4. Previously, a typed variable with a default null value would be treated as implicitly nullable. Developers must now explicitly define nullable types.

Deprecated example:

function processUser(User $user = null) {}

Recommended approach:

function processUser(?User $user = null) {}

Conclusion

PHP 8.4’s new features simplify development, reduce boilerplate, and enhance readability. From improved array operations and property hooks to better HTML5 parsing, it’s clear that PHP continues to grow stronger and more refined.

Explore how these new capabilities can elevate your next project. Happy coding! 🚀

🔥 Supercharge Your Development with Ctrl+Alt+Cheat

👉 Download Ctrl+Alt+Cheat today and start coding like a pro!