PHP 7.1: Overview of New Features

On Habré, there was already a translation with a review a few months ago, but the first release candidate PHP 7.1 recently came out, which means there will be no more significant changes and you can tell what exactly the changes will be in the release. I decided to revive a little dry “changelog” with my free translation of the changes that the new minor version of 7.x branches will bring us.

New functionality

Added “void” return type ( RFC )

Now functions and methods that should not return anything can be marked with a void return type:

function someNethod(): void { //   return  //   return; //    return null; //    return 123; } 

Returning a value from a method / function that is marked void will generate a Fatal Error level exception. Please note that NULL value is not equal to void (no value), that is, you cannot return NULL .

By the way, this does not mean that $ x = someNethod (); will not return anything. As before, $ x will be NULL . Also, void cannot be used as a type to a parameter.
')

 function bar(void $foo) {} // : Fatal error: void cannot be used as a parameter type in.... 

Added new pseudo-type: “iterable” ( RFC )

 function walkList(iterable $list): iterable { foreach ($list as $value) { yield $value['id']; } } 

This type essentially combines the primitive type of the array and the interface Traversable (and hence its derivatives: Iterator , Generator , etc). The problem arose from the fact that, for example, foreach can work with both types, but the function with the type array will not accept an object with the Traversable interface and vice versa.

Also, within the framework of this RFC, a new function, is_iterable () , has been added, which works similarly to other is_ * functions.

Now it is possible to resolve null in typed and returned parameters ( Nullable RFC )

 function callMethod(?Bar $bar): ?Bar {} $this->callMethod($bar); //  $this->callMethod(null); //  $this->callMethod(); //   

Note that the use of "?" and the default value of null is not the same

 function callMethod(int $bar = null) {} $this->callMethod(1); //  $this->callMethod(null); //  $this->callMethod(); //   

And the addition of "?" leaves the behavior backwards compatible

 function callMethod(?Bar $bar = null) {} //       “?” 

Also an important point to inherit:

 interface Fooable { function foo(int $i): ?Fooable; } interface StrictFooable extends Fooable { function foo(?int $i): Fooable; // valid } 

In the heir, you can make a “stricter” return type (that is, prohibit nullable ), and expand the parameter to the contrary to nullable , but not vice versa!

Added the ability to use a negative value for offset in rows ( RFC )

 echo $msg[-1]; //    echo $msg{-3}; //  RFC     $str{}   $str[]            . 

Negative values are also allowed in some steel string functions: strpos, stripos, substr_count, grapheme_strpos , grapheme_stripos, grapheme_extract, iconv_strpos, file_get_contents, mb_strimwidth, mb_ereg_search_setpos, mb_strpos, mb_stripos.

Everywhere this means counting the offset from the end of the line.

Allowed to use string keys in the list () ( RFC ) construction

A short syntax for list ( RFC ) has also been added.

 ["test" => $a, "name" => $b] = ["name" => "Hello", "test" => "World!"]; var_dump($a); // World! var_dump($b); // Hello 

Features:

• mixed syntax cannot be used (if we specify keys, then we specify them everywhere, if not, then the usual indices 0, 1, 2 are used ... as usual):
  
  

   // Parse error: syntax error, ... ["a" => $a, $b] = ["a" => 1, 2] 

  
  
• empty items with keys are also not allowed:
  
  

   // Parse error: syntax error, ... list(,,,, "key" => $keyed) = $array; 

  
  
• if there is no key in the source array, the warning Notice: Undefined index: name will be thrown, and the variable will be NULL
  
  
• when using the nested list construct, methods can be combined
  
  

   $points = [ ["x" => 1, "y" => 2], ["x" => 2, "y" => 1] ]; [["x" => $x1, "y" => $y1], ["x" => $x2, "y" => $y2]] = $points; 

Converting callable closure expressions ( RFC )

 Closure::fromCallable(callable $calback); 

Here is a clear example of application:

 class A { public function getValidator(string $name = 'byDefault') { return Closure::fromCallable([$this, $name]); } private function byDefault(...$options) { echo "Private default with:".print_r($options, true); } public function __call ( string $name , array $args ) { echo "Call $name with:".print_r($args, true); } } $a = new A(); $a->getValidator("test")(1,2,3); // Call test with: Array ( [0] => 1 [1] => 2 [2] => 3 ) $a->getValidator()('p1', 'p2'); // Private default with: Array ( [0] => 'p1', [1] => 'p2') //  Closure::fromCallable   ($this)     ,        //    return [$this, $name];  $a->getValidator()('p1', 'p2'); //  // Call byDefault with:Array ( [0] => p1 [1] => p2 ) //                

Visibility modifier support for class constants ( RFC )

 class Token { //      “public” const PUBLIC_CONST = 0; //      private const PRIVATE_CONST = 0; protected const PROTECTED_CONST = 0; public const PUBLIC_CONST_TWO = 0; //       private const FOO = 1, BAR = 2; } 

You can catch exceptions by combining several types of exceptions into one block ( RFC )

 try { echo "OK"; } catch (Exception | DomainException $e) { // ...  2    } catch (TypeError $e) { // ... } 

Emissions of E_NOTICE and E_WARNING level errors during arithmetic operations on strings containing non-valid numbers ( RFC )

 $numberOfApples = "10 apples" + "5 pears"; //  // Notice: A non well formed numeric string encountered in example.php on line 3 // Notice: A non well formed numeric string encountered in example.php on line 3 $numberOfPears = 5 * "orange"; // Warning: A non-numeric string encountered in example.php on line 3 

This is quite an important change that theoretically can break the backward compatibility of an application if its error handlers are used to intercept warnings.

And there is an interesting feature: the space at the beginning of the lines “5” + “3” will not give errors. But “5” + “3” - a space at the end will give warnings.

To bypass the consequences of implicit conversion and ejection of warnings, you can explicitly specify a “cast” to the desired type: (int) “5” + (int) “3” or force all to be suppressed @ (“5” + “3”).

Other changes and backward incompatibilities

• In connection with new types, new reserved words void , iterable have been added , and the code that contains classes, interfaces, traits with such names will give an error in 7.1
  
  
• Changed the behavior in php extensions, which continued to throw out Fatal Error instead of generating Error exceptions (like the current kernel 7.0), plus errors of the E_ERROR or E_RECOVERABLE_ERROR level, too, began to throw exceptions where possible (understandably, if there is not enough memory, the script is irreversibly falling ( RFC )).
  
  
• The behavior when calling functions / methods without passing the required arguments has changed. Now instead of the usual Warning warning, the ArgumentCountError exception will be thrown (inheriting from the Error RFC type):
  
  

   function foo($a) { var_dump($a); //        $a   NULL } foo(); // Fatal error: Uncaught ArgumentCountError: Too few arguments to function foo(), 0 passed in... 

  
  
• The following functions can no longer be called dynamically via: $ func (), call_user_func (), array_map (), and so on:
  
  
  1. extract ()
  2. compact ()
  3. get_defined_vars ()
  4. func_get_args ()
  5. func_get_arg ()
  6. func_num_args ()
  7. parse_str () with one argument
  8. mb_parse_str () with one argument
  9. assert () can no longer use a string as an argument
  
  
• The rand () and srand () functions are now simply aliases to the mt_rand () and mt_srand () functions.
  This in turn will affect the output of such functions:
  
  
  1. rand ()
  2. shuffle ()
  3. str_shuffle ()
  4. array_rand ()
  
  
• Added session_gc () function. Now you can clean old sessions directly from scripts.
  
  
• The session_create_id () function has been added, which allows you to generate a valid automatic session id without starting a new session, which can be used in session_id () to start a session with the previously generated ID.
  
  
• Accelerated session ID generation 2+ times, removing hashing and using a new function from 7.0 php_random_bytes ()
  
  

   Speed ​​to: Requests per second: 899.36 [# / sec]
   Speed ​​after: Requests per second: 2278.59 [# / sec]
  

  
  
• Removed inconsistent behavior over the $ this variable
  
  

   function foo($this) { // Fatal error: Cannot use $this as parameter } static $this; // Fatal error: Cannot use $this as static variable global $this; // Fatal error: Cannot use $this as global variable try { ... } catch (Exception $this) { // Fatal error: Cannot re-assign $this } foreach ($a as $this) { // Fatal error: Cannot re-assign $this } unset($this); // Fatal error: Cannot unset $this $a = "this"; $$a = 42; // throw new Error("Cannot re-assign $this") function foo() { var_dump($this); // throws "Using $this when not in object context" // php-7.0 emitted "Undefined variable: this" and printed NULL } foo(); //    

  
  
• The mcrypt extension is marked as obsolete and all mcrypt_ * functions will throw out E_DEPRECATED .
  
  
• The curl extension has added support for HTTP / 2 Server Push , as well as the new curl_multi_errno (), curl_share_errno (), curl_share_strerror () functions have been added.
  
  
• The option 'e' for the functions mb_ereg_replace () and mb_eregi_replace () is deprecated.

On this, we probably dwell, although there are still a lot of small changes, mainly in extensions. And for us for holivar this list is quite enough. )

Total

Personally, my opinion about this minor release: everything fits very organically, this is precisely what was missing in the majority in the new PHP 7.0 and these changes only emphasize and strengthen the features of 7.x branches.
I recommend waiting for 7.1.1 and you can upgrade without fear, break something (unless of course you have already moved to 7.0).

This article does not pretend to a complete description of ALL changes and I could miss something important, I recommend to get acquainted with the original sources anyway:
» Https://wiki.php.net/rfc#php_71
» Https://github.com/php/php-src/blob/php-7.1.0RC1/UPGRADING

PS Examples can be experienced in the online sandbox - 3v4l.org/#version=7.1.0RC1