PHP7, Stay up to date !
TL;DR Full changelog http://php.net/ChangeLog-7.php
New features
[7.1] HTTP/2 server push support in ext/curl
Support for server push has been added to the CURL extension (requires version 7.46 and above). This can be leveraged through the curl_multi_setopt() function with the new CURLMOPT_PUSHFUNCTION constant. The constants CURL_PUSH_OK and CURL_PUSH_DENY have also been added so that the execution of the server push callback can either be approved or denied.
$mh = curl_multi_init();
curl_multi_setopt($mh, CURLMOPT_PIPELINING, CURLPIPE_MULTIPLEX);
curl_multi_setopt($mh, CURLMOPT_PUSHFUNCTION, $callback);
$callback = function($parent_ch, $pushed_ch, array $headers) {
return CURL_PUSH_OK;
};
[7.1] Asynchronous signal handling
A new function called pcntl_async_signals() has been introduced to enable asynchronous signal handling without using ticks (which introduce a lot of overhead).
pcntl_async_signals(true); // turn on async signals
pcntl_signal(SIGHUP, function($sig) {
echo "SIGHUP\n";
});
posix_kill(posix_getpid(), SIGHUP);
[7.1] Convert callables to Closures with Closure::fromCallable()
class Test
{
public function exposeFunction()
{
return Closure::fromCallable([$this, 'privateFunction']);
}
private function privateFunction($param)
{
var_dump($param);
}
}
$privFunc = (new Test)->exposeFunction();
$privFunc('some value');
[7.1] Support for negative string offsets
Support for negative string offsets has been added to the string manipulation functions accepting offsets, as well as to string indexing with [] or {}. In such cases, a negative offset is interpreted as being an offset from the end of the string.
var_dump("abcdef"[-2]);
var_dump(strpos("aabbcc", "b", -3));
$string = 'bar';
echo "The last character of '$string' is '$string[-1]'.\n";
string (1) "e"
int(3)
The last character of 'bar' is 'r'.
[7.1] Support for keys in list()
$data = [
["id" => 1, "name" => 'Tom'],
["id" => 2, "name" => 'Fred'],
];
// list() style
list("id" => $id1, "name" => $name1) = $data[0];
// [] style
["id" => $id1, "name" => $name1] = $data[0];
// list() style
foreach ($data as list("id" => $id, "name" => $name)) {
// logic here with $id and $name
}
// [] style
foreach ($data as ["id" => $id, "name" => $name]) {
// logic here with $id and $name
}
[7.1] Multi catch exception handling
try {
// some code
} catch (FirstException | SecondException $e) {
// handle first and second exceptions
}
[7.1] Iterable pseudo-type
function iterator(iterable $iter)
{
foreach ($iter as $val) {
//
}
}
[7.1] Class constant visibility
class ConstDemo
{
const PUBLIC_CONST_A = 1;
public const PUBLIC_CONST_B = 2;
protected const PROTECTED_CONST = 3;
private const PRIVATE_CONST = 4;
}
[7.1] Void functions
function swap(&$left, &$right) : void
{
if ($left === $right) {
return;
}
$tmp = $left;
$left = $right;
$right = $tmp;
}
$a = 1;
$b = 2;
var_dump(swap($a, $b), $a, $b);
[7.1] Symmetric array destructuring
$data = [
[1, 'Tom'],
[2, 'Fred'],
];
// list() style
list($id1, $name1) = $data[0];
// [] style
[$id1, $name1] = $data[0];
// list() style
foreach ($data as list($id, $name)) {
// logic here with $id and $name
}
// [] style
foreach ($data as [$id, $name]) {
// logic here with $id and $name
}
null
int(2)
int(1)
[7.1] Nullable types
function testReturn(): ?string
{
return 'elePHPant';
}
var_dump(testReturn());
function testReturn(): ?string
{
return null;
}
var_dump(testReturn());
function test(?string $name)
{
var_dump($name);
}
test('elePHPant');
test(null);
test();
string(10) "elePHPant"
NULL
string(10) "elePHPant"
NULL
Uncaught Error: Too few arguments to function test(), 0 passed in...
[7.0] Scalar type declarations
declare(strict_type=1);
function test(int $integer, bool $bool, floar $float, string $string)
{
}
[7.0] Return type declarations
function arraysSum(array ...$arrays): array
{
return array_map(function(array $array): int {
return array_sum($array);
}, $arrays);
}
[7.0] Null coalescing operator
$username = $_GET['user'] ?? $_POST['user'] ?? 'nobody';
[7.0] Spaceship operator
// Integers
echo 1 <=> 1; // 0
echo 1 <=> 2; // -1
echo 2 <=> 1; // 1
// Floats
echo 1.5 <=> 1.5; // 0
echo 1.5 <=> 2.5; // -1
echo 2.5 <=> 1.5; // 1
// Strings
echo "a" <=> "a"; // 0
echo "a" <=> "b"; // -1
echo "b" <=> "a"; // 1
?>
[7.0] Constant arrays using define()
define('ANIMALS', [
'dog',
'cat',
'bird'
]);
echo ANIMALS[1]; // outputs "cat"
?>
[7.0] Anonymous classes
$app = new Application;
$app->setLogger(new class implements Logger {
public function log(string $msg) {
echo $msg;
}
});
var_dump($app->getLogger());
?>
[7.0] Unicode codepoint escape syntax
This takes a Unicode codepoint in hexadecimal form, and outputs that codepoint in UTF-8 to a double-quoted string or a heredoc. Any valid codepoint is accepted, with leading 0’s being optional.
echo "\u{aa}";
echo "\u{0000aa}";
echo "\u{9999}";
ª
ª (same as before but with optional leading 0's)
香
[7.0] Closure::call()
Closure::call() is a more performant, shorthand way of temporarily binding an object scope to a closure and invoking it.
class A {private $x = 1;}
// Pre PHP 7 code
$getXCB = function() {return $this->x;};
$getX = $getXCB->bindTo(new A, 'A'); // intermediate closure
echo $getX();
// PHP 7+ code
$getX = function() {return $this->x;};
echo $getX->call(new A);
[7.0] Filtered unserialize()
This feature seeks to provide better security when unserializing objects on untrusted data. It prevents possible code injections by enabling the developer to whitelist classes that can be unserialized.
// converts all objects into __PHP_Incomplete_Class object
$data = unserialize($foo, ["allowed_classes" => false]);
// converts all objects into __PHP_Incomplete_Class object except those of MyClass and MyClass2
$data = unserialize($foo, ["allowed_classes" => ["MyClass", "MyClass2"]]);
// default behaviour (same as omitting the second argument) that accepts all classes
$data = unserialize($foo, ["allowed_classes" => true]);
[7.0] Group use declarations
use some\namespace\{ClassA, ClassB, ClassC as C};
use function some\namespace\{fn_a, fn_b, fn_c};
use const some\namespace\{ConstA, ConstB, ConstC};
[7.0] list() can always unpack objects implementing ArrayAccess
Previously, list() was not guaranteed to operate correctly with objects implementing ArrayAccess. This has been fixed.
[7.0] preg_replace_callback_array()
The new preg_replace_callback_array() function enables code to be written more cleanly when using the preg_replace_callback() function. Prior to PHP 7, callbacks that needed to be executed per regular expression required the callback function to be polluted with lots of branching.
Now, callbacks can be registered to each regular expression using an associative array, where the key is a regular expression and the value is a callback.
[7.0] Integer division with intdiv()
The new intdiv() function performs an integer division of its operands and returns it.
var_dump(intdiv(3, 2));
var_dump(3/2);
int(1)
float(1.5)
PHP Major migration
| Version | |
|---|---|
| 7.0 -> 7.1 | http://php.net/manual/fr/migration71.php |
| 5.6 -> 7.0 | http://php.net/manual/fr/migration70.php |
| 5.5 -> 5.6 | http://php.net/manual/fr/migration56.php |
Tips (There are micro optimizations)
[7] Packed arrays
Packed arrays is the first great PHP 7 optimization. Packed arrays consume less memory and are a bit faster in many operations than traditional arrays. A packed array must have the following characteristics:
- The keys are only integers;
- The keys are inserted into the array in growing only mode.
$a = ['foo', 'bar', 'baz'];
$a = [12 => 'baz', 42 => 'bar', 67 => [] ];
TIPS
$pdo->query("SELECT * FROM table LIMIT 10000")->fetchAll(PDO::FETCH_NUM)
[7] ints/floats are free
In PHP 7, the way variables are allocated in memory changed dramatically. They went from being stored on the heap to stack memory pools. As a side effect, you may reuse variable containers for free: no memory allocated. That’s impossible to do in PHP 5, where each variable creation/assignment requires some memory allocation (which is bad for performance).
for ($i=0; $i<10000; $i++) {
$$i = 'foo';
}
VS
for ($i=0; $i<10000; $i++) {
$$i = 42;
}
[7] References mismatch
Reference mismatch happens when you pass a non-ref variable to a function argument passed-by-ref, or the opposite. Something like this:
function foo(&$arg) { }
$var = 'str';
foo($var);
Do you know what horrible things happen under the hood in the PHP 5 engine? In PHP 5, whenever there is a reference mismatch, the engine is forced to duplicate the variable before passing it as an argument to a function. As you probably guessed, if the variable contains something big, like a several-thousands-entries array or a big chunk of string; the copy will take a lot of time.
This is because of the way variables and references used to work into PHP 5. When going into the body function, the engine doesn’t know yet if you will change the argument value. If you are, then as the argument is taken by reference, the change must be reflected outside if a reference variable were passed. What if it was not the case (as in our example)? The engine must then create a reference, from the non-reference variable you passed it in the function call. This procedure leads the engine to fully duplicate the variable content in PHP 5 (calling a lot of memcpy() on very sparse pointers, leading to tons of slow memory accesses).
In PHP 7, when the engine wants to create a reference from a non-reference variable, it just wraps the latter into the newly created former, that’s all. There is no memory copy, anywhere. This is because variables work in a very different way internally in PHP 7, and references have been deeply reworked.
Look at this piece of code:
function bar(&$a) { $f = $a; }
$var = range(1,1024);
for ($i=0; $i<1000; $i++) {
bar($var);
}
There is a double mismatch. When you call bar(), you force the engine to create a reference from $var to $a , as the signature says &$a. Then, now that $a is part of a reference set ($var-$a) into the bar() body, you affect it by value to $f: this is another mismatch. $f is not affected by reference, so $a-$f-$var must not be linked together, but $var-$a in one part, and $f alone in another part: you once more force the engine to perform some copies. In PHP 7, creating variables to/from references is pretty light, only copy-on-write may happen after that.
[7] Immutable arrays
Immutable arrays are a concept added to PHP 7, and part of the OPCache extension, which I assume you are using. An immutable array is an array full of immutable elements, which are compile-time known and fully resolved values: strings, integers, floats, or arrays containing those. In a word: no dynamic elements, no variables, like in this example:
$ar = [ 'foo', 42, 'bar', [1, 2, 3], 9.87 ];
Such arrays have been optimized in PHP 7. Under PHP 5, those are just plain arrays, there is no difference between an array containing dynamic members (such as $vars), and a static compile-time resolved array. In PHP 7, immutable arrays are not copied nor duplicated as soon as they stay read only.
Here is such an example:
for ($i = 0; $i < 1000; $i++) {
$var[] = [
0 => 'Symfony\\Bundle\\FrameworkBundle\\EventListener\\SessionListener',
1 => 'Symfony\\Component\\HttpFoundation\\Session\\Storage\\NativeSessionStorage',
/* ... go to many immutable items here */
];
}
The above code creates the same big array 1,000 times (truncated, think of it as being a hundred or thousand slots array).
In PHP 5, this array is duplicated in memory 1,000 times. A big array could weight at several hundreds of Kilobytes or even Megabytes, which in this code will be duplicated 1,000 times. Such a waste of memory.
In PHP 7, OPCache flags those arrays as being immutable: the array is created only once, and shares its memory pointer everywhere it is supposed to be used, ending in huge savings of overall memory, especially when dealing with big configuration arrays, like the one shown in the example (which is taken from the Symfony 3 framework).
Let’s see the performance impact:
Illustrated example with composer : https://github.com/composer/composer/pull/5174
comments powered by Disqus