Novas funcionalidades

Expressões constantes

Agora é possível fornecer uma expressão escalar envolvendo literais numéricos e strings e/ou constantes em contextos onde o PHP anteriormente esperava um valor estático, como declarações de constantes e propriedades e argumentos padrões para funções.

<?php
const UM = 1;
const
DOIS = UM * 2;

class
C {
const
TRES = DOIS + 1;
const
UM_TERCO = UM / self::TRES;
const
FRASE = 'O valor de TRES é '.self::TRES;

public function
f($a = UM + self::TRES) {
return
$a;
}
}

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

O exemplo acima produzirá:

4
O valor de TRES é 3

É possível também definir um array constante usando a palavra-chave const:

<?php
const ARR = ['a', 'b'];

echo
ARR[0];
?>

O exemplo acima produzirá:

a

Funções variádicas via ...

Funções Variádicas agora podem ser implementadas usando o operador ..., ao invés de depender da função func_get_args().

<?php
function f($req, $opt = null, ...$params) {
// $params é um array contendo os argumentos restantes.
printf('$req: %d; $opt: %d; número de parâmetros: %d'."\n",
$req, $opt, count($params));
}

f(1);
f(1, 2);
f(1, 2, 3);
f(1, 2, 3, 4);
f(1, 2, 3, 4, 5);
?>

O exemplo acima produzirá:

$req: 1; $opt: 0; número de parâmetros: 0
$req: 1; $opt: 2; número de parâmetros: 0
$req: 1; $opt: 2; número de parâmetros: 1
$req: 1; $opt: 2; número de parâmetros: 2
$req: 1; $opt: 2; número de parâmetros: 3

Desempacotamento de argumentos via ...

Arrays e objetos do tipo Traversable podem ser desempacotados em listas de argumentos ao chamar funções usando o operador .... Isto também é conhecido como operador 'splat' em outras linguagens, incluindo Ruby.

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

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

O exemplo acima produzirá:

6

Exponenciação via **

Um operador associativo à direita, **, foi adicionado para suportar exponenciação, juntamente com o operador curto de atribuição **=.

<?php
printf
("2 ** 3 == %d\n", 2 ** 3);
printf("2 ** 3 ** 2 == %d\n", 2 ** 3 ** 2);

$a = 2;
$a **= 3;
printf("a == %d\n", $a);
?>

O exemplo acima produzirá:

2 ** 3 ==      8
2 ** 3 ** 2 == 512
a ==           8

use function e use const

O operador use foi estendido para suportar importação de funções e constantes em adição à importação de classes. Isto pode ser realizado pelas construções use function e use const, respectivamente.

<?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 produzirá:

42
Name\Space\f

phpdbg

O PHP agora inclui um depurador interativo chamado phpdbg, implementado como um módulo SAPI. Para mais informações, visite a documentação sobre phpdbg.

Codificação padrão de caracteres

default_charset é agora usado como o conjunto de caracteres padrão para as funções htmlentities(), html_entity_decode() e htmlspecialchars(). Observe que se as configurações de codificação iconv e mbstring (agora defasadas) estiverem definidas, elas terão precedência sobre default_charset para funções iconv e mbstring, respectivamente.

O valor padrão para esta configuração é UTF-8.

php://input é reutilizável

php://input agora pode ser reaberto e lido quantas vezes for necessário. Isto tem resultado em uma grande redução de memória requerida para lidar com dados de POST.

Envio de grandes arquivos

Arquivos maiores que 2 gigabytes agora são aceitos.

GMP suporta sobrecarga de operadores

Objetos GMP agora suportam sobrecarga de operadores e conversão para tipos escalares. Isto permite mais expressividade no código que usa GMP:

<?php
$a
= gmp_init(42);
$b = gmp_init(17);

if (
version_compare(PHP_VERSION, '5.6', '<')) {
echo
gmp_intval(gmp_add($a, $b)), PHP_EOL;
echo
gmp_intval(gmp_add($a, 17)), PHP_EOL;
echo
gmp_intval(gmp_add(42, $b)), PHP_EOL;
} else {
echo
$a + $b, PHP_EOL;
echo
$a + 17, PHP_EOL;
echo
42 + $b, PHP_EOL;
}
?>

O exemplo acima produzirá:

59
59
59

hash_equals() para comparação de strings segura contra ataque de temporização

A função hash_equals() foi adicionada para comparar dois strings em tempo constante. Isto deve ser usado para mitigar ataques de temporização; por exemplo, ao testar hashes de senha crypt() (assumindo que não seja possível usar password_hash() e password_verify(), que não são suscetíveis a ataques de temporização).

<?php
$expected
= crypt('12345', '$2a$07$usesomesillystringforsalt$');
$correct = crypt('12345', '$2a$07$usesomesillystringforsalt$');
$incorrect = crypt('1234', '$2a$07$usesomesillystringforsalt$');

var_dump(hash_equals($expected, $correct));
var_dump(hash_equals($expected, $incorrect));
?>

O exemplo acima produzirá:

bool(true)
bool(false)

__debugInfo()

O método mágico __debugInfo() foi adicionado para permitir que objetos alterem suas propriedades e seus valores que são mostrados quando estes objetos são argumentos da função var_dump().

<?php
class C {
private
$prop;

public function
__construct($val) {
$this->prop = $val;
}

public function
__debugInfo() {
return [
'propSquared' => $this->prop ** 2,
];
}
}

var_dump(new C(42));
?>

O exemplo acima produzirá:

object(C)#1 (1) {
  ["propSquared"]=>
  int(1764)
}

Algoritmo de hash gost-crypto

O algoritmo de hash gost-crypto foi adicionado. Ele implementa a função de hash GOST usando as tabelas S-box da CryptoPro S-box como especificado pela » RFC 4357, section 11.2.

Melhorias SSL/TLS

Uma ampla gama de melhorias foi aplicada no suporte a SSL/TLS no PHP 5.6. Estas incluem habilitação de verificação de servidor por padrão, suporte a correspondência de impressão digital de certificado, mitigação contra ataques de renegociação TLS, e muitas novas opções de contexto SSL para permitir um controle mais fino sobre o protocolo e configurações de verificação ao usar fluxos criptografados.

Estas mudanças estão descritas com maior detalhe na seção Mudanças do OpenSSL no PHP 5.6.x deste guia de migração.

Suporte a pgsql assíncrono

A extensão pgsql agora suporta conexões e consultas assíncronas, assim habilitando comportamento sem bloqueio ao interagir com banco de dados PostgreSQL. Conexões assíncronas podem ser estabalacidas através da constante PGSQL_CONNECT_ASYNC. As novas funções pg_connect_poll(), pg_socket(), pg_consume_input() e pg_flush() podem ser usadas para lidar com conexões e consultas assíncronas.

add a note add a note

User Contributed Notes 7 notes

up
163
tr0y
10 years 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
36
Anonymous
9 years ago
Remember, that

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

Thats why exponent operator** is RIGHT associative.
up
38
ashnazg at php dot net
9 years 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
7
ciachn
9 years 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
13
gmblar+php at gmail dot com
10 years 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
-1
stocki dot r at gmail dot com
3 years ago
You can create a self-documented, named argument workaround in PHP 5.6-7 with ... operator:

<?php
htmlspecialchars
($string, ...array_values([
   
'flags'         => ENT_COMPAT | ENT_HTML401,
   
'encoding'      => 'UTF-8',
   
'double_encode' => false,
]))
?>
up
-3
BernieV
4 years ago
The splat operator (...) is documented everywhere with no space after it.
But it seems to work just as well with whitespace between ... and what follows.
My IDE line-wrapped, introducing white-space, immediately after the ...
To Top