In this article, we will briefly review the changes in PHP v7.x versions in 15 minutes.

After the release of PHP 7.3, to better understand the new features and optimizations of this widely popular programming language, I decided to study PHP development in detail: what is being developed and its direction.

After reviewing a brief list of features implemented during the development of PHP 7.x versions, I decided to compile this list as a good supplement that I believe others will find useful.

We will start from PHP 5.6 as a baseline and examine what has been added or changed. At the same time, I have added direct links to the relevant official documentation for each mentioned feature, so feel free to dive deeper if you’re interested.

PHP 7.0

Support for Anonymous Classes Anonymous classes can be used in named classes in the following two cases:

• When the class does not need to be documented.

• When the class is only used once during program execution.

new class($i) {
    public function __construct($i) {
        $this->i = $i;
    }
}

Integer Division Function — Safe Division (even when divided by 0) This function returns the integer part of the result of the first parameter divided by the second parameter. When the divisor (the second parameter) is 0, this function throws an E_WARNING error and returns FALSE.

intdiv(int $numerator, int $divisor)

New Null Coalescing Assignment Operator — which is “??”

$x = NULL;
$y = NULL;
$z = 3;
var_dump($x ?? $y ?? $z); // int(3)

$x = ["c" => "meaningful_value"];
var_dump($x["a"] ?? $x["b"] ?? $x["c"]); // string(16) "meaningful_value"

New Operator — Spaceship Operator (<=>)The spaceship operator is used to optimize and simplify comparison operations.

// Using <=> (spaceship operator) before
function order_func($a, $b) {
    return ($a < $b) ? -1 : (($a > $b) ? 1 : 0);
}
// Using <=> (spaceship operator) after
function order_func($a, $b) {
    return $a <=> $b;
}

Scalar Type Declarations This is the first step in implementing stronger typed programming language features in PHP — v0.5.

function add(float $a, float $b): float {
    return $a + $b;
}

add(1, 2); // float(3)

Return Type Declarations Added the ability to return types other than scalar classes, including inheritance. Somehow it was not set as an optional feature (to be explained in v7.1)

interface A {
    static function make(): A;
}
class B implements A {
    static function make(): A {
        return new B();
    }
}

Grouped Use Declarations

// Explicit use syntax:
use FooLibrary\Bar\Baz\ClassA;
use FooLibrary\Bar\Baz\ClassB;
use FooLibrary\Bar\Baz\ClassC;
use FooLibrary\Bar\Baz\ClassD as Fizbo;

// Grouped use syntax:
use FooLibrary\Bar\Baz\{ ClassA, ClassB, ClassC, ClassD as Fizbo };

Generator Delegation

New syntax allowed in generator function bodies:

yield from <expr>

Performance Improvements

PHP 7 is twice as fast as PHP 5.6.

Significantly Reduced Memory Usage

From the charts, it can be seen that PHP 7.0 has made significant improvements in performance and (reduced) memory usage. For pages with database queries, version 7.0.0 is 3 times faster than version 5.6 with opcache enabled, and 2.7 times faster without opcache. The difference in memory usage between the two is also very significant.

Throwable Interface The refactored exception classes have non-intuitive naming schemes and can reduce confusion, especially for beginners.

Errors and Exceptions now implement Throwable.

This is the Throwable hierarchy:

interface Throwable
  |- Error implements Throwable
      |- ArithmeticError extends Error
          |- DivisionByZeroError extends ArithmeticError
      |- AssertionError extends Error
      |- ParseError extends Error
      |- TypeError extends Error
          |- ArgumentCountError extends TypeError
  |- Exception implements Throwable
      |- ClosedGeneratorException extends Exception
      |- DOMException extends Exception
      |- ErrorException extends Exception
      |- IntlException extends Exception
      |- LogicException extends Exception
          |- BadFunctionCallException extends LogicException
              |- BadMethodCallException extends BadFunctionCallException
          |- DomainException extends LogicException
          |- InvalidArgumentException extends LogicException
          |- LengthException extends LogicException
          |- OutOfRangeException extends LogicException
      |- PharException extends Exception
      |- ReflectionException extends Exception
      |- RuntimeException extends Exception
          |- OutOfBoundsException extends RuntimeException
          |- OverflowException extends RuntimeException
          |- PDOException extends RuntimeException
          |- RangeException extends RuntimeException
          |- UnderflowException extends RuntimeException
          |- UnexpectedValueException extends RuntimeException

*⚠ Warning! You can only implement Throwable by inheriting from Error and Exception, meaning an interface that inherits from Throwable can only be implemented by subclasses of Exception or Error.

Unicode Codepoint Escape Syntax — “\u{xxxxx}”

echo "\u{202E}Reversed text"; // Outputs reversed text
echo "mañana"; // "ma\u{00F1}ana"
echo "mañana"; // "man\u{0303}ana" "n" combines with ~ character (U+0303)

Context-Sensitive Syntax Parser Globally reserved words have become semi-reserved:

callable  class  trait  extends  implements  static  abstract  final  public  protected  private  const
enddeclare  endfor  endforeach  endif  endwhile  and  global  goto  instanceof  insteadof  interface
namespace  new  or  xor  try  use  var  exit  list  clone  include  include_once  throw  array
print  echo  require  require_once  return  else  elseif  default  break  continue  switch  yield
function  if  endswitch  finally  for  foreach  declare  case  do  while  as  catch  die  self parent

Except for still prohibiting the definition of a class constant named class due to class name resolution ::class.

Generator Return Expressions

Unified Variable Syntax

Level Support for dirname () Function

PHP 7.1

Nullable Types

function answer(): ?int  {
    return null; // Success
}

function answer(): ?int  {
    return 42; // Success
}

function answer(): ?int {
    return new stdclass(); // Error
}
function say(?string $msg) {
    if ($msg) {
        echo $msg;
    }
}

say('hello'); // Success -- Prints hello
say(null); // Success -- Does not print
say(); // Error -- Parameter missing
say(new stdclass); // Error -- Wrong type

Void Return

function should_return_nothing(): void {
    return 1; // Fatal error: void function cannot have a return value
}

Unlike other return types enforced during function calls, this type is checked at compile time, meaning errors will occur before the function is called.

Functions with void return type or void function can implicitly return and can use a return statement without a value:

function lacks_return(): void {
    // valid
}

Iterable Pseudo-Type **

** Functions typically accept or return array or implement a Traversable object for use with foreach. However, since array is a primitive type and Traversable is an interface, it is currently not possible to use type declarations to indicate that a value is iterable on parameters or return types.

function foo(iterable $iterable) {
    foreach ($iterable as $value) {
        // ...
    }
}

iterable can also be used as a return type, indicating that the function will return an iterable value. If the returned value is not an array or instance of Traversable, a TypeError will be thrown.

function bar(): iterable {
    return [1, 2, 3];
}

Parameters declared as iterable can use null or an array as a default value.

function foo(iterable $iterable = []) {
    // ...
}

* Callable Closures

class Closure {
    ...
    public static function fromCallable(callable $callable) : Closure {...}
    ...
}

Array Structure Assignment Bracket Syntax

$array = [1, 2, 3];
// Assigning values of $array elements to $a, $b, and $c starting from key 0
[$a, $b, $c] = $array;

// Using “a”, “b”, and “c” keys to assign values of array elements in $array to $a, $b, and $c
["a" => $a, "b" => $b, "c" => $c] = $array;

list() Bracket Syntax

$powersOfTwo = [1 => 2, 2 => 4, 3 => 8];
list(1 => $oneBit, 2 => $twoBit, 3 => $threeBit) = $powersOfTwo;

Visibility of Class Constants

class Token {
    // Constants default to public
    const PUBLIC_CONST = 0;

        // Constants can also define visibility
        private const PRIVATE_CONST = 0;
        protected const PROTECTED_CONST = 0;
        public const PUBLIC_CONST_TWO = 0;

        // Constants can only have one visibility declaration list
        private const FOO = 1, BAR = 2;
}

Catching Multiple Exception Types

try {
   // Some code...
} catch (ExceptionType1 | ExceptionType2 $e) {
   // Code to handle the exception
} catch (\Exception $e) {
   // ...
}

PHP 7.2

Parameter Type Widening

<?php

class ArrayClass {
  public function foo(array $foo) { /* ... */ }
}

// This RFC proposes allowing types to be widened to untyped, meaning any type.
// Types can be passed as parameters.
// Any type restrictions can be implemented by user-written code in the method body.
class EverythingClass extends ArrayClass {
  public function foo($foo) { /* ... */ }
}

Counting Uncountable Objects When a scalar or an object that does not implement the Countable interface calls the count() method, it will return 1 (illogical).

In PHP 7.2 version, a WARNING has been added for cases where the count() method is called with a scalar, null, or an object that does not implement the Countable interface.

Using Trailing Commas in Namespace List Usage

use Foo\Bar\{ Foo, Bar, Baz, };

Argon2 Password Hashing Algorithm The existing password functions provide a simple interface for hashing passwords that is forward-compatible. This RFC proposes implementing password functions with Argon2i (v1.3) to replace the Bcrypt password hashing algorithm.

Debugging PDO Prepared Statement Simulation

$db = new PDO(...);

// Generate a statement without bound values
$stmt = $db->query('SELECT 1');
var_dump($stmt->activeQueryString()); // => string(8) "SELECT 1"

$stmt = $db->prepare('SELECT :string');
$stmt->bindValue(':string', 'foo');

// Returns the unresolved query before execution
var_dump($stmt->activeQueryString()); // => string(14) "SELECT :string"

// Returns the resolved query after execution
$stmt->execute();
var_dump($stmt->activeQueryString()); // => string(11) "SELECT 'foo'"

PHP 7.3

JSON_THROW_ON_ERROR

For a long time, there was insufficient ways to handle errors when using JSON, and developers around the world considered this a significant drawback of the language.

Before PHP v7.2, we needed a way to get errors from JSON that was neither reliable nor sophisticated;

Examples are as follows:

json_decode("{");
json_last_error() === JSON_ERROR_NONE // Result is error
json_last_error_msg() // Result is "Syntax Error"

Now let’s see how to use this new syntactic sugar:

use JsonException;

try {
    $json = json_encode("{", JSON_THROW_ON_ERROR);
    return base64_encode($json);
} catch (JsonException $e) {
    throw new EncryptException('Could not encrypt the data.', 0, $e);
}

From the above code, it can be seen that the json_encode function now has an optional parameter JSON_THROW_ON_ERROR — which will capture errors and display them using the following exception methods:

$e->getMessage(); // Equivalent to json_last_error_msg()
$e->getCode(); // Equivalent to json_last_error()

Adding is_countable Function

// Before:
if (is_array($foo) || $foo instanceof Countable) {
    // $foo is countable
}
// After
if (is_countable($foo)) {
    // $foo is countable
}

Adding Array Functions array_key_first(), array_key_last()

$firstKey = array_key_first($array);
$lastKey = array_key_last($array);

Native Support for Same-Site Cookie Detection There are two ways to use Same-Site cookie detection: Lax and Strict. Their difference lies in the accessibility of cookies in cross-origin HTTP GET requests. Cookies using Lax allow cross-origin GET access, while cookies using Strict do not allow cross-origin GET access. The POST method has no difference: because browsers do not allow access to cookies in cross-origin POST requests.

Set-Cookie: key=value; path=/; domain=example.org; HttpOnly; SameSite=Lax|Strict

Migration from PCRE to PCRE2

Enhancements to Argon2 Hash Password Functionality The existing password_* functions provide a forward-compatible simplified interface for hashing passwords. This RFC recommends implementing Argon2id in password_* functions as a secure alternative to the initially proposed Argon2i.

Allowing Trailing Commas in Function Calls

$newArray = array_merge(
    $arrayOne,
    $arrayTwo,
    ['foo', 'bar'], // Allows trailing commas in function calls
);

Reference for list () Usage

$array = [1, 2];
list($a, &$b) = $array;

Equivalent to:

$array = [1, 2];
$a = $array[0];
$b = &$array[1];

Discouraging Case-Insensitive Constants

PHP 7.4 (In Development)

Typed Properties

class User {
    public int $id;
    public string $name;

    public function __construct(int $id, string $name) {
        $this->id = $id;
        $this->name = $name;
    }
}

Foreign Function Interface The Foreign Function Interface (FFI) is one of the very useful features in rapid prototyping in Python and LuaJIT. FFI allows pure scripting languages to directly call C language functions and data types, thus developing “system code” more efficiently. PHP has opened a way to write PHP extensions in PHP language and bind them to C language libraries in FFI.

Null Coalescing Assignment Operator

// The following lines of code perform the same function
$this->request->data['comments']['user_id'] = $this->request->data['comments']['user_id'] ?? 'value';
// Using null coalescing assignment operator, replacing the above method
$this->request->data['comments']['user_id'] ??= 'value';

Preloading PHP has been using opcode caches (APC, Turck MMCache, Zend OpCache) for a long time. They achieve significant performance improvements by almost completely eliminating the overhead of recompiling PHP code. The new preloading feature can be implemented with just a new php.ini configuration — opcache.preload. Specify a PHP file that will perform preloading tasks, and then preload other files by including them or using the opcache_compile_file() function.

Always Available Hash Extension This will make the hash extension (ext/hash) always available, similar to date. The hash extension provides very rich functionality and hash algorithms, which is beneficial not only for PHP developers but also for the development of PHP itself.

On the Journey to PHP 8.0

JIT.

In short, when you start a PHP program, the Zend Engine parses the code into an abstract syntax tree (AST) and converts it into opcode. Opcodes are the execution units of the Zend Virtual Machine (Zend VM). Opcodes are quite low-level, and converting them to machine code is much faster than the original PHP code. PHP has an extension called OPcache in its core that caches these opcodes.

“JIT” is a technique for compiling parts of the code at runtime, allowing the use of the compiled version.

This is one of the latest and greatest PHP optimization strategies still under discussion. PHP engineers are looking forward to seeing how much performance can be squeezed out of this new feature in their applications. I am personally eager to see this firsthand.

Consistent Type Errors for Internal Functions If parameter parsing fails, the internal parameter parsing API should always generate TypeError errors. It should be noted that these errors also include ArgumentCountError (a subclass of TypeError) that indicates too few/many parameters were passed.

Performance Comparison

I wrote a simple test to help easily compare the performance of different PHP versions (using Docker). This can even be easily checked by adding a new container name to test the performance of new PHP versions.

Running on a MacBook Pro, 2.5 GHz Intel Core i7.

PHP Version : 5.6.40
--------------------------------------
test_math                 : 1.101 sec.
test_stringmanipulation   : 1.144 sec.
test_loops                : 1.736 sec.
test_ifelse               : 1.122 sec.
Mem: 429.4609375 kb Peak mem: 687.65625 kb
--------------------------------------
Total time:               : 5.103

PHP Version : 7.0.33
--------------------------------------
test_math                 : 0.344 sec.
test_stringmanipulation   : 0.516 sec.
test_loops                : 0.477 sec.
test_ifelse               : 0.373 sec.
Mem: 421.0859375 kb Peak mem: 422.2109375 kb
--------------------------------------
Total time:               : 1.71

PHP Version : 7.1.28
--------------------------------------
test_math                 : 0.389 sec.
test_stringmanipulation   : 0.514 sec.
test_loops                : 0.501 sec.
test_ifelse               : 0.464 sec.
Mem: 420.9375 kb Peak mem: 421.3828125 kb
--------------------------------------
Total time:               : 1.868

PHP Version : 7.2.17
--------------------------------------
test_math                 : 0.264 sec.
test_stringmanipulation   : 0.391 sec.
test_loops                : 0.182 sec.
test_ifelse               : 0.252 sec.
Mem: 456.578125 kb Peak mem: 457.0234375 kb
--------------------------------------
Total time:               : 1.089

PHP Version : 7.3.4
--------------------------------------
test_math                 : 0.233 sec.
test_stringmanipulation   : 0.317 sec.
test_loops                : 0.171 sec.
test_ifelse               : 0.263 sec.
Mem: 459.953125 kb Peak mem: 460.3984375 kb
--------------------------------------
Total time:               : 0.984

PHP Version : 7.4.0-dev
--------------------------------------
test_math                 : 0.212 sec.
test_stringmanipulation   : 0.358 sec.
test_loops                : 0.205 sec.
test_ifelse               : 0.228 sec.
Mem: 459.6640625 kb Peak mem: 460.109375 kb
--------------------------------------
Total time:               : 1.003

If you’re interested in testing yourself, you can find the relevant code in the repository meskis/php-bench.

Benchmarking PHP 5.6 and Higher Versions

I really enjoy visual performance comparisons of all major versions from 5.6 and above on servebolt.com. Please check the table below for results.

Performance Summary

PHP 7.0.0 is a significant milestone that significantly improves performance and reduces memory usage, but PHP maintainers can no longer improve it. The remaining point is JIT (Just in time) compilation. It is part of PHP 8.0.

Development Direction

Throughout the PHP 7.x versions, there is a visible path toward more typing (and more object-oriented) and modern programming languages. Nevertheless, PHP still prefers to adopt concise and useful features from other programming languages.

We will soon see some better features, such as:

• Named Parameters

• Nullsafe Calls

• Enum Types (ENUMs)

• Arrow Functions

With these, PHP developers will join the ranks of adopters of modern programming languages. No language is perfect, but PHP has paved the way for its future.

Too Long; Didn’t Read

To make the length shorter, I have listed the relatively important changes based on the latest version of PHP 7.3. They are:

• Added a new null coalescing operator

• Scalar Type Declarations

• Return Type Declarations

• Throwable Interface

• Nullable Types

• Void Returns

• Bracket Syntax for Array Destructuring

• Visibility of Class Constants

References

https://wiki.php.net/rfc
https://www.cloudways.com/blog/php-5-6-vs-…
https://servebolt.com/articles/wordpress-5…

Click to view the original text for more information~