## 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 descontinuadas) 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 estabelecidas 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.

`↑` and `↓` to navigate • `Enter` to select • `Esc` to close • `/` to open