El PHP 7.4 finalmente llegó! Esta nueva versión, lanzada el 28 de noviembre de 2019, ahora está disponible en todos los servidores Hostinger. Los desarrolladores pueden esperar mejoras en la legibilidad del código, el mantenimiento y la facilidad de uso. Echemos un vistazo a algunas de las nuevas características, ajustes de rendimiento y otras razones por las que debería cambiar a PHP 7.4.

¿Qué significa PHP 7.4 para usted?

PHP continúa evolucionando, lanzando su última actualización a PHP 7.4, llena de nuevas características. Como vimos en versiones anteriores de PHP 7, el rendimiento y la velocidad continúan mejorando.

Una de las nuevas características más interesantes es la precargar. Ayuda a acelerar la ejecución de guiones, además de tener la capacidad de tener un código más rápido y limpio, gracias a la simplificación de líneas de código comunes.

Los “ángeles” responsables de PHP escucharon los comentarios y solicitudes del público y respondieron con toda su fuerza. Desde entonces, cambian continuamente el código para que sea más intuitivo y más fácil cambiar entre lenguajes de programación.

PHP se usa en más del 78.9% de todos los sitios web. De acuerdo a W3techs, los sitios más populares que usan PHP son Wikipedia, Pinterest y Facebook.

Si observamos específicamente los sitios de WordPress que ejecutan PHP, comparando PHP 5 y 7, podemos ver un aumento de velocidad doble. Los sitios de WordPress definitivamente ganan cuando se usa la última versión de PHP. Los usuarios de Hostinger pueden impulsar sus sitios de WordPress a nuevas alturas con solo un clic.

¿Ves todas estas figuras? Este gráfico muestra un poco de verdad sobre los sitios que usan PHP activamente. Hizo 39,191,714 Qué sitios son suficientes para llamar su atención? Es el número total de sitios que actualmente usan PHP. Además, PHP 7.4 ya se ha probado y funciona mejor que PHP 7.3, lo que garantiza una mayor longevidad.

El siguiente gráfico muestra un prueba de referencia general en versiones nuevas y antiguas de PHP. Algunos de los criterios probados fueron la facilidad de uso, la velocidad y el rendimiento, entre otros.

Cambiar su versión de PHP

¿Estás listo para actualizar? Yo sabía. Hostinger hace que todo sea más fácil que nunca con estos cuatro simples pasos. Disfrutará de su nueva y mejorada versión de PHP en muy poco tiempo.

  • Inicie sesión en su cuenta de Hostinger y haga clic en Inicio.
  • En su página de inicio, desplácese hacia abajo hasta la sección Hospedaje y haga clic en el ícono Administrar.
  • En el campo de búsqueda, escriba Configuración PHP y haga clic
  • Seleccione PHP 7.4 y haga clic Guardar.

Felicidades Ahora tiene la mejor y más actualizada versión de PHP del mercado.

Para verificar su versión actual de PHP, todo lo que necesita hacer es acceder a la pestaña Hospedaje y verifique el Versión PHP en el lado izquierdo del panel. Si está por debajo de 7.4, solo continúe y actualice.

¿Qué hay de nuevo en PHP 7.4?

Desde 2016, PHP 7 ha lanzado actualizaciones anuales sin falta. Cada año, ofrecen nuevas funciones, adiciones y la posibilidad de escribir un código más limpio, lo que hace que el lenguaje sea más confiable y fácil de usar para aquellos que lo ejecutan en sus sitios web.

Profundicemos y echemos un vistazo más de cerca a algunos de los cambios realizados con la adición de PHP 7.4. Para obtener una lista completa, consulte el informe de cambios aqui.

Precarga

Hablemos del código. Cuando se usa un marco o bibliotecas, sus archivos deben cargarse y vincularse a cada solicitud. La precarga es cuando puedes cargar marcos y bibliotecas en OPCache. Permite al servidor cargar archivos PHP y almacenarlos en la memoria durante el inicio y ponerlos a disposición para futuras solicitudes. ¡Se trata de hacer que las cosas sucedan rápido!

La precarga es realizada por un específico php.ini: opache.preload. Tiene el guiones PHP y se ejecuta cuando se inicia el servidor. También se puede usar para precargar más archivos y elegir incluirlos o compilarlos.

Esto es impresionante Sin embargo, si se cambia la fuente de los archivos precargados, el servidor debe reiniciarse. Los archivos precargados también permanecen en caché en la memoria OPCache para siempre.

Sin embargo, estos archivos precargados aún estarán disponibles para futuras solicitudes, en caso de que necesite usarlos nuevamente.

Operador extendido en expresiones de Matriz

Cuando se lanzó PHP 5.6, PHP comenzó a admitir desembalaje de argumentos (operador de propagación), pero ahora, con 7.4, podemos usar esta función con una expresión de matriz. Argumento desempacando es una sintaxis para descomprimir matrices y Transitables en listas de argumento. Y para hacer eso, solo necesita ser precedido por … (3 puntos). Es eso.

Veamos el ejemplo:

$animals = ('dog', 'cat');
$animalkingdom = ('lion', 'elephant', ...$animals, 'giraffe');
// (‘lion’, ‘elephant’, ‘dog’, ‘cat’, ‘giraffe’);

Ahora podemos expandir un matriz en cualquier lugar que queramos en otro matriz, simplemente usando la sintaxis de Operador extendido.

Aquí hay un ejemplo:

$num1 = (1, 2, 3);
$num2 = (...$num1); // (1, 2, 3)
$num3 = (0, ...$num1); // (0, 1, 2, 3)
$num4 = array(...$num1, ...$num2, 111); // (1, 2, 3, 1, 2, 3, 111)
$num5 = (...$num1, ...$num1); // (1, 2, 3, 1, 2, 3)

No solo eso, sino que también puedes usarlo en un rol. Mira este ejemplo:

function getNum() {
  return ('a', 'b');
}
$num6 = (...getNum(), 'c'); // ('a', 'b', 'c')
 
$num7 = (...new NumIterator(('a', 'b', 'c'))); // ('a', 'b', 'c')
 
function arrGen() {
    for($i = 11; $i < 15; $i++) {
        yield $i;
    }
}
$num8 = (...arrGen()); // (11, 12, 13, 14)

Además, ahora puedes descomprimir matrices y generadores que son devueltos por una función directamente en un nuevo matriz.

Un ejemplo de código se vería así:

function getAnimals(){
 return ('dog', 'cat', 'elephant');
}
$num1 = (...getAnimals(), 'lion', 'tiger', 'giraffe');

Y con PHP 7.4, imprimiría:

array(6) {
 (0)=>
 string(3) "dog"
 (1)=>
 string(3) "cat"
 (2)=>
 string(8) "elephant"
 (3)=>
 string(4) "lion"
 (4)=>
 string(5) "tiger"
 (5)=>
 string(7) "giraffe"
}

Con esta nueva expresión de matrizel operadores de propagación debería funcionar mucho mejor que 7.3 array_merge. Esto es porque el Operador extendido es una estructura de lenguaje, mientras array_merge Es una función. También porque el Operador extendido apoya objetos implementando transitable y el array_merge solo soporta matrices.

Algunas cosas importantes a tener en cuenta, solo puede usar matrices indexado porque el teclas de cuerda No son compatibles. Si se usa, se mostrará un error recuperable en la pantalla tan pronto como clave de cuerda se encuentra

Otro beneficio glorioso para 7.4 es la eliminación de array_merge. Dile adiós a los temidos cambio de !

Por ejemplo, veamos esto combinar matriz abajo:

$array = (‘banana, ‘orange’);
$array(2) = ‘orange’;
$array(1) = ‘apple’; //shifting
var_dump($array); 
// prints 
array(3) {
 (0)=>
 string(6) "banana"
 (1)=>
 string(5) "apple"
 (2)=>
 string(6) "orange"

Otro beneficio de 7.4 es usar el generador de funciones. Uno generador de funciones Funciona igual que una función normal. Excepto, en lugar de devolver una zanjarun generador de funciones genera tantos valores como sea necesario.

Vea los ejemplos de código a continuación:

function generator() {
 for ($i = 3; $i <= 5; $i++) {
 yield $i;
 }
}
$num1 = (0, 1, 2, ...generator());

Referencias débiles

PHP 7.4 ahora tiene una clase Referencia débil, que no debe confundirse con la clase Rojo débil o la extensión Weakref.

El Referencias débiles permitir que el programador recupere un referencia a uno objeto. Esto es útil porque no evita que el objeto sea destruido. Son útiles para implementar el caché como estructuras.

WeakReference {
/* Methods */
public __construct ( void )
public static create ( object $referent ) : WeakReference
public get ( void ) : ?object
}

Parámetros contravariantes y Devoluciones covariantes

Actualmente, PHP usa principalmente tipos de parámetros invariantes y tipos de retorno. Es decir, si un método tiene un parámetro o tipo de retorno Xel parámetro de subtipo o tipo de retorno también debería ser tipo X.

Ahora, con PHP 7.4, propone permitir covariante (ordenado de específico a genérico) y contravariante (orden inverso) en parámetro y tipos de retorno.

Aquí hay ejemplos de ambos:

Ejemplo de tipo de retorno covariante:

Interfaz de fábrica {

 function make(): object;
}
class UserFactory implements Factory {
 function make(): User;
}

Ejemplo de tipo de parámetro contravariante:

interface Concatable {
 function concat(Iterator $input); 
}
class Collection implements Concatable {
 // accepts all iterables, not just Iterator
 function concat(iterable $input) {/* . . . */}
}

Propiedades tipificadas 2,0

Desde PHP 5, sugerencias de tipo ha sido una característica disponible, que le permite especificar el tipo de variable que se espera pasar a una función o clase. En las migraciones de PHP 7.2, agregar el objeto tipo de datos dio esperanza de que habría más disponible en el futuro. El futuro es ahora.

En el nuevo 7.4, PHP puede admitir la siguiente lista de tipo:

bool, int, float, string, array, object, iterable, self, parent
any class or interface name
?type // where "type" may be any of the above

Tenga en cuenta que el padre tipo se puede usar en clases y no necesita tener un padre consistente con el parámetro y el tipo de retorno.

Además, tenga en cuenta que nulo y invocable No son compatibles. El nulo se eliminó porque no era útil y tenía una semántica poco clara; Invocable, porque su comportamiento dependía del contexto.

Veamos algunos ejemplos más.

Aquí hay una clase, escrita para PHP 7.3:

class User {
    /** @var int $id */
    private $id;
    /** @var string $name */
    private $name;
 
    public function __construct(int $id, string $name) {
        $this->id = $id;
        $this->name = $name;
    }
 
    public function getId(): int {
        return $this->id;
    }
    public function setId(int $id): void {
        $this->id = $id;
    }
 
    public function getName(): string {
        return $this->name;
    }
    public function setName(string $name): void {
        $this->name = $name;
    }
}

En PHP 7.4, sin sacrificar ninguno seguridad de tipo, una clase ahora puede escribirse simplemente como:

class User {
    public int $id;
    public string $name;
 
    public function __construct(int $id, string $name) {
        $this->id = $id;
        $this->name = $name;
    }
}

Aquí hay algunos ejemplos de todos tipos que 7.4 ahora admite:

class Example {
  
    public int $scalarType;
    protected ClassName $classType;
    private ?ClassName $nullableClassType;
 
    // Types are also legal on static properties
    public static iterable $staticProp;
 
    // Types can also be used with the "var" notation
    var bool $flag;
 
    // Typed properties may have default values (more below)
    public string $str = "foo";
    public ?string $nullableStr = null;
 
    // The type applies to all properties in one declaration
    public float $x, $y;
    // equivalent to:
    public float $x;
    public float $y;
}

Funciones de flecha 2,0

Funciones anónimas (funciones anónimas) en PHP tienden a ser largos y extensos, incluso cuando se realizan operaciones simples.

Esto se debe en parte a una gran cantidad de cliché sintáctico y en parte a la necesidad de importar manualmente las variables utilizadas.

Esto hace que el código que uses cierres simple, confuso de leer e incluso más difícil de entender.

Echemos un vistazo a un código que usaría en PHP 7.3:

function array_values_from_keys($arr, $keys) {
    return array_map(function ($x) use ($arr) { return $arr($x); }, $keys);
}

Ahora, aquí está la sintaxis PHP 7.4 más concisa:

function array_values_from_keys($arr, $keys) {
    return array_map(fn($x) => $arr($x), $keys);
}

Por lo tanto, funciones de flecha ahora tiene este formato simple:

fn(parameter_list) => expr

A continuación, puede ver un ejemplo de dos funciones $ fn1 (7.3) y $ fn2 (7.4) lado a lado. Tienen el mismo resultado, pero se ven diferentes:

$y = 1;
$fn1 = fn($x) => $x + $y;
 
 
$fn2 = function ($x) use ($y) 
{
    return $x + $y;
};

Esto también funcionará si funciones de flecha están vinculados:

$z = 1;
$fn = fn($x) => fn($y) => $x * $y + $z;

Aquí la función externa captura $ z. Entonces, la función interna también captura $ z de la función externa. Con 7.4, el alcance externo puede estar disponible en la función interna. Esto es algo que 7.3 no pudo hacer.

La sintaxis de función de flecha permite una variedad de funciones, Variadics, valores por defecto, parámetro y tipos de retorno, y también paso por referencia y volviendo. Todo esto manteniendo un aspecto limpio y legible. Abajo están todos funciones de flecha válido y disponible ahora:

fn(array $x) => $x;
fn(): int => $x;
fn($x = 42) => $x;
fn(&$x) => $x;
fn&($x) => $x;
fn($x, ...$rest) => $rest;

Una cosa a tener en cuenta es que funciones de flecha tienen la menor prioridad. Mira el ejemplo:

fn($x) => $x + $y
// is
fn($x) => ($x + $y)
// not
(fn($x) => $x) + $y

Interrupciones

Hay muchas interrupciones que suceden con el cambio a 7.4. La siguiente lista es una breve descripción de las funciones indicadas para la interrupción. Puedes encontrar una explicación más detallada aqui:

  • El tipo real
  • Legado de citas mágicas
  • array_key_exists () con objetos
  • Filtro FILTER_SANITIZE_MAGIC_QUOTES
  • Métodos de reflexión export ()
  • mb_strrpos () codificado como 3er argumento
  • Mezcla de orden de parámetros implosionar ()
  • Desvincular $ esto de cierres no estático
  • Función hebrevc ()
  • Función convert_cyr_string ()
  • Función money_format ()
  • Función ezmlm_hash ()
  • Función restore_include_path ()
  • ini directiv allow_url_include

Algunos puntos importantes a tener en cuenta son las siguientes interrupciones en dos etapas.

Cambiar la precedencia del operador de concatenación

Actualmente, la precedencia de los operadores “.”, “+” Y “-” son todos iguales. Cualquier combinación de estos operadores simplemente se resolverá de izquierda a derecha.

Vamos a ver este código en PHP 7.3:

echo "sum: " . $a + $b; 
// would be evaluated left-to-right
echo ("sum: " . $a) + $b;
// could also look like this

Con PHP 7.4, ‘+’ y ‘-‘ tendrán prioridad sobre ‘.’ Por lo tanto, las sumas y restas siempre se realizarán antes cuerda. Se vería así:

echo "sum: " . $a + $b; 
// would be executed as if the code were as follows.
echo "sum :" . ($a + $b);

Esta propuesta de dos pasos pretende ser menos propensa a errores y más intuitiva. PHP 7.4 se encuentra actualmente en la primera etapa con un aviso para descontinuar expresiones sin paréntesis de “+”, “-” y “. En espera de que la decisión / cambio final ocurra en PHP 8.

Operador ternario asociativo a la izquierda

A diferencia de la mayoría de los otros lenguajes, el operador PHP ternario es asociativo a la izquierda, en lugar de asociativo a la derecha.

Además de ser inusual, también es confuso, es confuso para los programadores que cambian entre diferentes idiomas. PHP 7.4 propone eliminar la asociatividad de la izquierda y requiere el uso de paréntesis en su lugar.

Vea el código a continuación:

return $a == 1 ? 'one'
     : $a == 2 ? 'two'
     : $a == 3 ? 'three'
     : $a == 4 ? 'four'
               : 'other';

En la mayoría de los otros idiomas, se interpretaría de la siguiente manera:

return $a == 1 ? 'one'
     : ($a == 2 ? 'two'
     : ($a == 3 ? 'three'
     : ($a == 4 ? 'four'
               : 'other')))

En PHP, la interpretación es la siguiente:

return ((($a == 1 ? 'one'
     : $a == 2) ? 'two'
     : $a == 3) ? 'three'
     : $a == 4) ? 'four'
               : 'other';

Esto puede conducir a errores, ya que no era la intención. A través de una propuesta de dos pasos, PHP 7.4 implementó el uso explícito de paréntesis como advertencia de interrupción y se espera que se ejecute un error de tiempo de ejecución de compilación en futuras versiones.

Conclusión

Y en esta temporada de celebración, PHP 7.4 trae nuevas características y mejoras en la calidad de vida para todos los desarrolladores de PHP.

Definitivamente, los sitios de WordPress aprovecharán estas mejoras y sus usuarios pueden esperar tiempos de ejecución más rápidos y menos uso de memoria cuando usan PHP 7.4 en comparación con versiones anteriores.

Con las noticias de primera clase sobre declaraciones de tipo de propiedad y tipo de insinuación, la fusión de la flecha, y la velocidad increíblemente más rápida, 7.4 ciertamente mejorará tanto la velocidad como la calidad del flujo de trabajo.