PHP 8.4: Breaking Down the Big Updates (With Examples)

PHP continues to evolve, and the PHP 8.4 release is packed with powerful new features that make coding simpler, safer, and faster. From Property Hooks to Auto-Capturing Closures, Asymmetric Visibility, and New Array Functions, PHP 8.4 is all about improving the developer experience.

In this blog, we’ll explore PHP 8.4’s most exciting features, provide examples to help you understand how to use them, and highlight performance improvements. Whether you’re a seasoned developer or just starting, these updates are sure to make your PHP projects more efficient and enjoyable.

Table of Contents

1. Property Hooks
2. Asymmetric Visibility
3. Auto-Capturing Closures
4. Read-Only Properties
5. Improved DOM API
6. New array_*() Functions
7. Performance Improvements
8. Bug Fixes and Cleanup
9. Final Thoughts

1. Property Hooks

Property Hooks allow developers to define custom behaviors when accessing or modifying class properties. This eliminates the need for complex magic methods like __get() and __set().

Example:

class Product
{
    private array $data = [];

    public function __get(string $name)
    {
        echo "Accessing property: $name\n";
        return $this->data[$name] ?? null;
    }

    public function __set(string $name, $value)
    {
        echo "Setting property: $name to $value\n";
        $this->data[$name] = $value;
    }
}

$product = new Product();
$product->price = 100; // Output: Setting property: price to 100
echo $product->price;  // Output: Accessing property: price

2. Asymmetric Visibility

With Asymmetric Visibility, you can define separate visibility rules for reading (get) and writing (set) class properties. For example, you can make a property publicly readable but only writable within the class.

Example:

class Account
{
    private int $balance = 100;

    public function getBalance(): int
    {
        return $this->balance; // Publicly readable
    }

    private function setBalance(int $amount)
    {
        $this->balance = $amount; // Privately writable
    }
}

$account = new Account();
echo $account->getBalance(); // Output: 100
$account->setBalance(200);   // Error: Cannot access private method

3. Auto-Capturing Closures

In PHP 8.4, closures automatically capture variables from the parent scope, removing the need for manually declaring them with use().

Example:

$discount = 20;
$applyDiscount = fn($price) => $price - $discount; // Automatically captures $discount

echo $applyDiscount(100); // Output: 80

This feature makes closures cleaner and reduces boilerplate code.

4. Read-Only Properties

Read-only properties can only be assigned once. They’re perfect for properties like IDs or configurations that shouldn’t be changed after initialization.

Example:

class Config
{
    public readonly string $appName;

    public function __construct(string $name)
    {
        $this->appName = $name;
    }
}

$config = new Config('MyApp');
echo $config->appName; // Output: MyApp
$config->appName = 'NewApp'; // Error: Cannot modify readonly property

5. Improved DOM API

The DOM API now makes it easier and faster to parse and manipulate XML and HTML documents.

Example:

$dom = new DOMDocument();
$dom->loadHTML('<div id="main">Hello World</div>');
$element = $dom->getElementById('main');

echo $element->nodeValue; // Output: Hello World

$element->nodeValue = 'Updated Content';
echo $dom->saveHTML(); // Output: <div id="main">Updated Content</div>

6. New array_*() Functions

PHP 8.4 introduces new array functions to simplify common operations:

• array_find(): Finds the first value that satisfies a condition.
• array_find_key(): Finds the first key that satisfies a condition.
• array_any(): Checks if any element satisfies a condition.
• array_all(): Checks if all elements satisfy a condition.

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'; // Output: Yes

7. Performance Improvements

PHP 8.4 is faster and more memory-efficient, thanks to:

• Just-In-Time (JIT) Compiler Optimizations: Enhances performance for CPU-intensive tasks.
• Reduced Memory Usage: Makes PHP applications lighter and more responsive.

These improvements ensure that your applications load quicker and handle more tasks without slowing down.

8. Bug Fixes and Cleanup

Long-standing bugs have been addressed, and deprecated features have been removed in PHP 8.4. This cleanup makes PHP cleaner, more reliable, and ready for future enhancements.

9. Final Thoughts

PHP 8.4 is a game-changer, introducing features like Property Hooks, Auto-Capturing Closures, and New Array Functions that simplify coding and boost performance. Whether you’re building small projects or enterprise applications, upgrading to PHP 8.4 ensures you’re using the most powerful and efficient tools available.

Explore these features, and start implementing them in your projects today. PHP 8.4 makes coding smoother, faster, and more fun!

For a deeper dive, check out the official PHP 8.4 Release Notes.

Happy coding! 🎉