## Nuevas características

### Expresiones de constante

Ahora es posible proporcionar una expresión escalar que implique números y literales de string y/o constantes en contextos donde PHP previamente esperaba un valor estático, como una constante o una declaración de propiedades y los argumentos por defecto de función.

    <?php
    const UNO = 1;
    const DOS = UNO * 2;

    class C {
        const TRES = DOS + 1;
        const UN_TERCIO = UNO / self::TRES;
        const RESULTADO = 'El valor de TRES es '.self::TRES;

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

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

El ejemplo anterior mostrará:

    4
    El valor de TRES es 3

También es posible definir una constante array usando la palabra clave `const`:

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

    echo ARR[0];
    ?>

El ejemplo anterior mostrará:

    a

### Funciones variables vía el operador de descomposición `...`

Las funciones variables ahora pueden ser implementadas usando el operador de descomposición `...`, en lugar de usar la función func_get_args().

    <?php
    function f($req, $opt = null, ...$params) {
        // $params es un array que contiene los argumentos restantes.
        printf('$req: %d; $opt: %d; Número de argumentos: %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);
    ?>

El ejemplo anterior mostrará:

    $req: 1; $opt: 0; Número de argumentos: 0
    $req: 1; $opt: 2; Número de argumentos: 0
    $req: 1; $opt: 2; Número de argumentos: 1
    $req: 1; $opt: 2; Número de argumentos: 2
    $req: 1; $opt: 2; Número de argumentos: 3

### Descompresión de argumentos vía el operador de descomposición `...`

Los arrays y los objetos Traversable pueden ser descomprimidos en la lista de argumentos al llamar a una función usando el operador de descomposición `...`. Este método es conocido como el operador splat en otros lenguajes como Ruby, por ejemplo.

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

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

El ejemplo anterior mostrará:

    6

### Exponenciación vía el operador `**`

Se ha añadido un operador `**` asociativo a la derecha para soportar la exponenciación, en conjunción con el operador de asignación `**=`.

    <?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);
    ?>

El ejemplo anterior mostrará:

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

### `use function` y `use const`

El operador `use` ha sido extendido para soportar la importación de funciones y constantes además de clases. Esto se realiza usando las construcciones `use function` y `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();
    }
    ?>

El ejemplo anterior mostrará:

    42
    Name\Space\f

### phpdbg

PHP ahora incluye un depurador interactivo llamado phpdbg, implementado como un módulo SAPI. Para más información, visite la documentación phpdbg.

### Codificación de caracteres por defecto

default_charset ahora se usa como el conjunto de caracteres por defecto para las funciones htmlentities(), html_entity_decode() y htmlspecialchars(). Tenga en cuenta que si las configuraciones de codificación (ahora obsoletas) de iconv y mbstring están definidas, estas tendrán prioridad sobre la configuración de default_charset para las funciones iconv y mbstring, respectivamente.

El valor por defecto para esta configuración es `UTF-8`.

### `php://input` es reutilizable

`php://input` ahora puede ser reabierto y leído tantas veces como sea necesario. Este nuevo mecanismo también ha permitido reducir significativamente la cantidad de memoria requerida durante las operaciones POST.

### Subida de archivos grandes

Ahora se aceptan archivos de más de 2 Gigabytes.

### GMP soporta la sobrecarga de operadores

Los objetos GMP ahora soportan la sobrecarga de operadores y el cambio de tipo a tipos escalares. Esto permite un código más expresivo usando 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;
    }
    ?>

El ejemplo anterior mostrará:

    59
    59
    59

### hash_equals() para la comparación de string para evitar ataques de temporización

Se ha añadido la función hash_equals() para comparar dos string en tiempo constante. Esto debería usarse para evitar ataques de temporización, por ejemplo, al probar el hash de una contraseña creada vía la función crypt() (suponiendo que no pueda usar las funciones password_hash() y password_verify(), que no son sensibles a los ataques de temporización).

    <?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));
    ?>

El ejemplo anterior mostrará:

    bool(true)
    bool(false)

### `__debugInfo()`

Se ha añadido el método mágico __debugInfo() para permitir a los objetos cambiar las propiedades y valores que se muestran cuando el objeto se muestra usando la función 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));
    ?>

El ejemplo anterior mostrará:

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

### Algoritmo de hashing gost-crypto

Se ha añadido el algoritmo de hashing `gost-crypto`. Implementa la función de hashing GOST, usando las tablas CryptoPro S-box como se especifica en la » RFC 4357, sección 11.2.

### Mejoras SSL/TLS

Se ha realizado una amplia gama de mejoras en el soporte SSL/TLS en PHP 5.6. Esto incluye la activación de la verificación por pares por defecto, soportando la coincidencia de certificados de huellas digitales, permitiendo limitar los ataques de renegociación TLS, así como varias nuevas opciones de contexto SSL permitiendo un control más fino del protocolo y las verificaciones de configuración cuando se usan flujos cifrados.

Estos cambios se describen en detalle en la sección sobre los cambios OpenSSL en PHP 5.6.x de la guía de migración.

### Soporte async pgsql

La extensión pgsql ahora soporta conexiones y consultas asíncronas, habilitando un comportamiento no bloqueante al interactuar con una base de datos PostgreSQL. Las conexiones asíncronas pueden establecerse vía la constante `PGSQL_CONNECT_ASYNC`, y las nuevas funciones pg_connect_poll(), pg_socket(), pg_consume_input() y pg_flush() pueden ser usadas para manejar las conexiones y consultas asíncronas.

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