Nuevas funcionalidades

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 resultado del ejemplo sería:

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 resultado del ejemplo sería:

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 resultado del ejemplo sería:

$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 resultado del ejemplo sería:

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 resultado del ejemplo sería:

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 resultado del ejemplo sería:

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 resultado del ejemplo sería:

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 resultado del ejemplo sería:

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 resultado del ejemplo sería:

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.

add a note

User Contributed Notes

There are no user contributed notes for this page.
To Top