What’s New in PHP 7.4

PHP 7.4, the next PHP 7 minor release, has been released for General Availability as of November 28th, 2019. So it’s time for us to dive into some of the most exciting additions and new features that will have made PHP faster and more reliable.

PHP 7.4 (official release) is available to all KubeServers clients.

Even if PHP 7.4 significantly boosts performance and improves code readability, PHP 8 will be the big milestone for PHP performance, as the proposal for JIT inclusion has already been approved.

Anyway, today we’re going through some of the most interesting features and changes we’re expecting with PHP 7.4. Just for the record, these were the important dates for the 7.4 version:

• June 6th, 2019: PHP 7.4 Alpha 1
• July 18th, 2019: PHP 7.4 Beta 1 – Feature freeze
• November 28th, 2019: PHP 7.4 GA Release

You can check out the full list of features and additions on the official RFC page.

What’s New in PHP with PHP 7.4?

Forget array_merge: PHP 7.4 Brings Spread Operator in Array Expression

Available since PHP 5.6, argument unpacking is a syntax for unpacking arrays and Traversables into argument lists. To unpack an array or a Traversable, it has to be prepended by … (3 dots), as shown in the following example:

Now this PHP 7.4 RFC proposes to extend this feature to array definitions:

The first declared benefit of Spread Operator in array expression is all about performance. In fact, the RFC doc states:

Spread operator should have better performance than array_merge. That’s not only because the spread operator is a language structure while array_merge is a function, but also because compile time optimization can be performant for constant arrays.

A significant advantage of Spread operator is that it supports any traversable objects, while the array_merge function only supports arrays.

Here is an example of argument unpacking in array expression:

If you run this code with in PHP 7.3 or earlier, PHP throws a Parse error:

Instead, PHP 7.4 would return an array:

The RFC states that we can expand the same array multiple times. Moreover, we can use the Spread Operator syntax everywhere in the array, as normal elements can be added before or after the spread operator. So the following code will work as we may expect:

It’s also possible to unpack arrays returned by a function directly into a new array:

PHP 7.4 outputs the following array:

We can also use the generator syntax:

But we are not allowed to unpack arrays passed by reference. Consider the following example:

If we’d try to unpack an array by reference, PHP throws the following Parse error:

Anyway, if the elements of the first array are stored by reference, they are stored by reference in the second array, as well. Here is an example:

And here is what we get with PHP 7.4:

The Spread operator proposal passed with 43 to 1 votes.

Arrow Functions 2.0 (Short Closures)

In PHP, anonymous functions are considered to be quite verbose and difficult to implement and maintain. This RFC proposes the introduction of the shorter and clearer syntax of the arrow functions (or short closures), that should allow us to clean up significantly our PHP code.

Consider the following example:

PHP 7.4 allows to use a more concise syntax, and the function above could be rewritten as follows:

Currently, anonymous functions (closures) can inherit variables defined in the parent scope thanks to the use language construct, as shown below:

But with PHP 7.4, variables defined in the parent scope are implicitly captured by value (implicit by-value scope binding). So we can write the whole function seen above on a single line:

The variable defined in the parent scope can be used in the arrow function exactly as if we were using use($var), and it’s not possible to modify a variable from the parent scope.

The new syntax is a great improvement to the language as it allows us to build more readable and maintainable code. We can also use parameter and return types, default values, variable-length argument lists (variadic functions), we can pass and return by reference, etc. Finally, short closures can also be used in class methods, and they can make use of the $this variable just like regular closures.

This RFC has been approved with 51 to 8 votes, so we can expect it to be part of PHP 7.4 additions.

Null Coalescing Assignment Operator

Added with PHP 7, the coalesce operator (??) comes in handy when we need to use a ternary operator in conjunction with isset(). It returns the first operand if it exists and is not NULL. Otherwise, it returns the second operand. Here is an example:

What this code does is pretty straightforward: it fetches the request parameter and sets a default value if it doesn’t exist. The meaning of that line is clear, but what if we had much longer variable names as in this example from the RFC?

In the long run, this code could be a bit difficult to maintain. So, aiming to help developers to write more intuitive code, this RFC proposes the introduction of the null coalescing assignment operator (??=). So, instead of writing the previous code, we could write the following:

If the value of the left-hand parameter is null, then the value of the right-hand parameter is used.
Note that, while the coalesce operator is a comparison operator, ??= is an assignment operator.

This proposal has been approved with 37 to 4 votes.

Typed Properties 2.0

Argument type declarations, or type hints, allow to specify the type of a variable that is expected to be passed to a function or a class method. Type hints are a feature available since PHP 5, and since PHP 7.2 we can use them with the object data type. Now PHP 7.4 brings type hinting a step forward by adding support for first-class property type declarations. Here is a very basic example:

All types are supported, with the exception of void and callable:

The RFC explains the reason why void and callable are not supported:

The void type is not supported, because it is not useful and has unclear semantics.

The callable type is not supported, because its behavior is context dependent.

So we can safely use bool, int, float, string, array, object, iterable, self, parent, any class or interface name, and nullable types (?type).

Types can be used on static properties:

They are also allowed with the var notation:

It’s possible to set default property values, which of course must match the declared property type, but only nullable properties can have a default null value:

The same type applies to all properties in a single declaration: