PHP 8.4: What's New and How to Use It
PHP 8.4 is here, bringing several exciting features that simplify coding and improve performance. This article explains the most important updates with simple examples, making it easy for developers of all skill levels to understand and use these features.
1. Property Hooks
Property hooks let you customise what happens when you get or set a property. This removes the need for separate getter and setter methods.
Example:
class User {
private string $firstName;
private string $lastName;
public function __construct(string $firstName, string $lastName) {
$this->firstName = $firstName;
$this->lastName = $lastName;
}
// This property combines first and last name
public string $fullName {
get => $this->firstName . ' ' . $this->lastName;
set => [$this->firstName, $this->lastName] = explode(' ', $value, 2);
}
}
$user = new User('John', 'Doe');
echo $user->fullName; // Output: John Doe
$user->fullName = 'Jane Smith'; // Updates first and last names
echo $user->fullName; // Output: Jane Smith
Why it's useful:
Property hooks make your code cleaner and reduce boilerplate.
2. Asymmetric Visibility
You can now set different levels of visibility for reading and writing a property. For example, a property can be readable by everyone but only writable by the class itself.
Example:
class BankAccount {
public private(set) float $balance; // Public read, private write
public function __construct(float $initialBalance) {
$this->balance = $initialBalance; // Allowed here
}
public function deposit(float $amount): void {
$this->balance += $amount; // Allowed here
}
}
$account = new BankAccount(100.0);
echo $account->balance; // Output: 100
$account->deposit(50.0); // Adds 50 to the balance
echo $account->balance; // Output: 150
// The following line will cause an error:
// $account->balance = 200.0;
Why it's useful:
This feature makes it easier to control how a property is accessed and updated.
3. New Array Functions
PHP 8.4 adds new array functions that save you from writing manual loops.
Example:
$numbers = [1, 2, 3, 4, 5];
// Find the first even number
$firstEven = array_find($numbers, fn($n) => $n % 2 === 0);
echo $firstEven; // Output: 2
// Check if any number is greater than 4
$hasBigNumber = array_any($numbers, fn($n) => $n > 4);
var_dump($hasBigNumber); // Output: bool(true)
// Check if all numbers are positive
$allPositive = array_all($numbers, fn($n) => $n > 0);
var_dump($allPositive); // Output: bool(true)
Why it's useful:
These functions make array operations faster to write and easier to understand.
4. Simplified Object Instantiation
You can now create an object and call a method on it immediately, without wrapping the instantiation in parentheses.
Example:
class Logger {
public function log(string $message): void {
echo $message;
}
}
// Create an object and call a method in one step
new Logger()->log('Logging a message'); // Output: Logging a message
Why it's useful:
It reduces unnecessary syntax, making your code cleaner.
5. Deprecation of Implicit Nullable Types
PHP 8.4 requires you to explicitly declare when a parameter can be null. This makes code easier to understand and maintain.
Example:
// PHP 8.4 (Recommended):
function process(?string $data = null) {
echo $data ?? 'No data provided';
}
Why it's useful:
Explicit declarations prevent confusion and reduce potential bugs.
6. Lazy Objects
Lazy objects let you delay creating an object until it's actually used, which can save resources.
Example:
class ExpensiveResource {
public function __construct() {
// Simulate a time-consuming setup
sleep(2);
}
public function doWork(): void {
echo 'Working...';
}
}
// Use a lazy object to delay creation
$initializer = fn() => new ExpensiveResource();
$reflector = new ReflectionClass(ExpensiveResource::class);
$resource = $reflector->newLazyProxy($initializer);
// The object isn't created yet
$resource->doWork(); // Now the object is created and "Working..." is printed
Why it's useful:
This is especially helpful when dealing with expensive operations or large systems.
Conclusion
PHP 8.4 introduces several features that make coding simpler and more powerful:
- Property Hooks: Replace getter and setter functions.
- Asymmetric Visibility: Better control over property access.
- New Array Functions: Simplify common array operations.
- Simplified Object Instantiation: Cleaner object creation.
- Deprecation of Implicit Nullable Types: Safer and clearer code.
- Lazy Objects: Save resources by delaying object creation.
These updates will make PHP even more enjoyable to use, whether you're a beginner or an experienced developer. Start exploring PHP 8.4 today!
Top comments (0)