New features

Constant scalar expressions

It is now possible to provide a scalar expression involving numeric and string literals and/or constants in contexts where PHP previously expected a static value, such as constant and property declarations and default function arguments.

<?php
const ONE 1;
const 
TWO ONE 2;

class 
{
    const 
THREE TWO 1;
    const 
ONE_THIRD ONE self::THREE;
    const 
SENTENCE 'The value of THREE is '.self::THREE;

    public function 
f($a ONE self::THREE) {
        return 
$a;
    }
}

echo (new 
C)->f()."\n";
echo 
C::SENTENCE;
?>

O exemplo acima irá imprimir:

4
The value of THREE is 3

Variadic functions via ...

Variadic functions can now be implemented using the ... operator, instead of relying on func_get_args().

<?php
function f($req$opt null, ...$params) {
    
// $params is an array containing the remaining arguments.
    
printf('$req: %d; $opt: %d; number of params: %d'."\n",
           
$req$optcount($params));
}

f(1);
f(12);
f(123);
f(1234);
f(12345);
?>

O exemplo acima irá imprimir:

$req: 1; $opt: 0; number of params: 0
$req: 1; $opt: 2; number of params: 0
$req: 1; $opt: 2; number of params: 1
$req: 1; $opt: 2; number of params: 2
$req: 1; $opt: 2; number of params: 3

Argument unpacking via ...

Arrays and Traversable objects can be unpacked into argument lists when calling functions by using the ... operator. This is also known as the splat operator in other languages, including Ruby.

<?php
function add($a$b$c) {
    return 
$a $b $c;
}

$operators = [23];
echo 
add(1, ...$operators);
?>

O exemplo acima irá imprimir:

6

use function and use const

The use operator has been extended to support importing functions and constants in addition to classes. This is achieved via the use function and use const constructs, respectively.

<?php
namespace Name\Space {
    const 
FOO 42;
    function 
f() { echo __FUNCTION__."\n"; }
}

namespace {
    use const 
Name\Space\FOO;
    use function 
Name\Space\f;

    echo 
FOO."\n";
    
f();
}
?>

O exemplo acima irá imprimir:

42
Name\Space\f

phpdbg

PHP now includes an interactive debugger called phpdbg implemented as a SAPI module. For more information, please visit the » phpdbg documentation.

Default character encoding

default_charset is used as default character encoding of PHP. Default value is changed to "UTF-8" from empty. mbstring and iconv module uses default_charset setting if its own settings are not specified. Functions like htmlspecialchars() that accepts encoding parameter uses default_charset as default encoding.

php://input is reusable

php://input may now be reopened and read as many times as required. This work has also resulted in a major reduction in the amount of memory required to deal with POST data.

Large file uploads

Files larger than 2 gigabytes in size are now accepted.

GMP supports operator overloading

GMP objects now support operator overloading and casting to scalar types. This allows for more expressive code using GMP:

<?php
$a 
gmp_init(42);
$b gmp_init(17);
 
// Pre-5.6 code:
var_dump(gmp_add($a$b));
var_dump(gmp_add($a17));
var_dump(gmp_add(42$b));

// New code:
var_dump($a $b);
var_dump($a 17);
var_dump(42 $b);
?>

gost-crypto hash algorithm

The gost-crypto hash algorithm has been added. This implements the GOST hash function using the CryptoPro S-box tables as specified by » RFC 4357, section 11.2.

SSL/TLS improvements

The OpenSSL extension has been extended to include support for extracting and verifying certificate fingerprints. openssl_x509_fingerprint() has been added to extract a fingerprint from an X.509 certificate, and two SSL stream context options have been added: capture_peer_cert to capture the peer's X.509 certificate, and peer_fingerprint to assert that the peer's certificate should match the given fingerprint.

Additionally, a specific crypto method such as SSLv3 or TLS may now be selected by setting the crypto_method SSL stream context option. Possible options include STREAM_CRYPTO_METHOD_SSLv2_CLIENT, STREAM_CRYPTO_METHOD_SSLv3_CLIENT, STREAM_CRYPTO_METHOD_SSLv23_CLIENT (the default), or STREAM_CRYPTO_METHOD_TLS_CLIENT.

add a note add a note

User Contributed Notes 6 notes

up
115
tr0y
8 months ago
It is also possible ( in 5.6.0alpha ) to typehint the ...-operator

function foo (stdclass ... $inbound) {
   var_dump($inbound);
}

// ok:
foo( (object)['foo' => 'bar'], (object)['bar' => 'foo'] );

// fails:
foo( 1, 2, 3, 4 );
up
27
ashnazg at php dot net
6 months ago
Note the order of operations in that exponentiation operator, as it was opposite of what my first expectation was:

<?php
// what I had expected,
// evaluating left to right,
// since no parens were used to guide the order of operations
2 ** 3 ** 2 == 64; // (2 ** 3) ** 2 = 8 ** 2 = 64

// the given example,
// which appears to evaluate right to left
2 ** 3 ** 2 == 512; // 2 ** (3 ** 2) = 2 ** 9 = 512
?>
up
3
ciachn
1 month ago
Having 2 ** 3 ** 2 = 512 is actually that is the exact correct behavior for a right-associative operator just as specified in the "**" documentation.
up
16
Anonymous
3 months ago
Remember, that

    ($a ** $b) ** $c === $a ** ($b * $c)

Thats why exponent operator** is RIGHT associative.
up
8
gmblar+php at gmail dot com
8 months ago
<?php

function array_zip(...$arrays) {
    return
array_merge(...array_map(NULL, ...$arrays));
}

$a = array(1, 4, 7);
$b = array(2, 5, 8);
$c = array(3, 6, 9);

var_dump(implode(', ', array_zip($a, $b, $c)));

// Output
string(25) "1, 2, 3, 4, 5, 6, 7, 8, 9"
up
0
bivoc
1 month ago
You have probably thought that the `use` keyword would help you import function from within classes. That is not true. The use keyword will only import plain constants and functions only defined inside a namespace. Not classes.
To Top