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 );
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
User Contributed Notes 7 notes
tr0y ¶
10 years ago
Anonymous ¶
10 years ago
Remember, that
($a ** $b) ** $c === $a ** ($b * $c)
Thats why exponent operator** is RIGHT associative.
ashnazg at php dot net ¶
10 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
?>
ciachn ¶
10 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.
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"
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,
]))
?>
