El lanzamiento de PHP 8 ha causado mucha curiosidad entre los programadores que usamos este lenguaje.

PHP es uno de los lenguajes más usados en la web y  es uno de los lenguajes de programación más fáciles de aprender. Con un buen tutorial de PHP y la motivación adecuada, puedes escribir tus primeros scripts y ejecutar comandos en pocas horas.

¿Aún no haz actualizado tu servidor Xampp a PHP 8? en este artículo te enseño cómo hacerlo

Te ensañaré lo que considero el TOP 10 de novedades en PHP 8 de acuerdo a la documentación oficial, comencemos:

1.Argumentos Nombrados

ANTES. Al momento de ejecutar un función con argumentos (parámetros), lo debíamos hacer en el respectivo orden que fueron declarados:

function parametros($uno,$dos,$tres){
	return $uno.", ".$dos.", ".$tres;
}

$paramUno = "uno";
$paramDos = "dos";
$paramTres = "tres";

echo parametros($paramUno,$paramDos,$paramTres);

 AHORA. PHP 8 permite nombrar los argumentos (parámetros) al momento de su ejecución sin tener que coincidir en el orden:

function parametros($uno,$dos,$tres){
	return $uno.", ".$dos.", ".$tres;
}

echo parametros(tres:"tres",uno:"uno",dos:"dos");

2.Atributos

ANTES. Hacíamos anotaciones en PHPDoc:

class MiClase{
	/**
	* Esto es una anotación en PHPDoc
	*/
	public function MiFuncion(){}
}

AHORA. En PHP 8 puedes usar metadatos estructurados con la sintaxis nativa de PHP:

class MiClase{
	#Esto es una anotación con metadato estructurado
	public function MiFuncion(){}
}

3.Promoción de Propiedades Constructivas

ANTES. Hacíamos código repetitivo para definir e inicializar una propiedad:

class MiClase1 {

  public $x;
  public $y;
  public $z;

  public function __construct(
    $x = 1,
    $y = 3,
    $z = 5
  ) {

    $this->x = $x;    
    $this->y = $y; 
    $this->z = $z;

  }

  public function MiFuncion1(){

  	echo $this->x;
  	echo $this->y;
  	echo $this->z;
  }

}

$variable1 = new MiClase1();
$variable1 -> MiFuncion1();

AHORA. En PHP 8 menos código repetitivo para definir e inicializar una propiedad:

class MiClase2 {

  public function __construct(
    public $x = 2,
    public $y = 4,    
    public $z = 6,    
  ) {}

  public function MiFuncion2(){

  	echo $this->x;
  	echo $this->y;
  	echo $this->z;
  
  }

}

$variable2 = new MiClase2();
$variable2 -> MiFuncion2();

4.Tipos de Unión

ANTES. Usábamos anotaciones en PHPDoc para combinar tipos, pero no valida en el momento de ejecución:

class Numero1 {
 
 /** @var int|float */
  private $numero1;

  /**
   * @param float|int $number
   */
  public function __construct($numero1) {
    $this->numero1 = $numero1;
    echo $this->numero1;
  }

}

new Numero1("hola"); //muestra la palabra "hola" así no sea número entero o flotante

AHORA. En PHP 8 puedes usar una declaración de tipo unión nativa que será validada en el momento de ejecución.

class Numero2 {

  private int|float $numero2;

  public function __construct(int|float $numero2) {
    $this->numero2 = $numero2;
    echo $this->numero2;
  }
}

new Numero2(10); //Estrictamente debes pasar un número entero o flotante como parámetro

5.Expresión Match

ANTES. Usábamos un Switch o una condición para validar una expresión:

switch (8) {
  case '8':
    $result = "Esto es un texto";
    break;
  case 8:
    $result = "Esto es un Numero";
    break;
}

echo $result; //devuelve "Esto es un texto" ya que no sucede una comparación estricta

AHORA. Match es una expresión; esto quiere decir que pueden ser almacenadas como variables o devueltas, además soporta expresiones de una línea y no necesitan romper declarar un break y finalmente hace comparaciones estrictas:

echo match (8) {
  '8' => "Esto es un texto",
  8 => "Esto es un número",
};

6.Operador NullSafe

ANTES. Para comprobar que una propiedad de un objeto o de un método no devuelve NULL hacíamos condición tras condición:

$objeto =(object) array(
	"propiedad1a" =>(object) [
		"propiedad2a" =>(object) [
			"propiedad3a" => "valor1a",
			"propiedad3b" => "valor1b"
		],
		"propiedad2b" =>(object) [
			"propiedad3a" => null,
			"propiedad3b" => null
		]
	],
    "propiedad1b" => null
);

$variable = null;
if($objeto->propiedad1a !== null){
	if($objeto->propiedad1a->propiedad2a !== null){
		if($objeto->propiedad1a->propiedad2a->propiedad3a !== null){
			$variable = $objeto->propiedad1a->propiedad2a->propiedad3a;		
		}
	}
} 

echo $variable;

 AHORA. Con el operador NullSafe si encuentra en cualquiera de las propiedades el valor Null anula la ejecución de toda la cadena:

$objeto =(object) array(
	"propiedad1a" =>(object) [
		"propiedad2a" =>(object) [
			"propiedad3a" => "valor1a",
			"propiedad3b" => "valor1b"
		],
		"propiedad2b" =>(object) [
			"propiedad3a" => null,
			"propiedad3b" => null
		]
	],
    "propiedad1b" => null
);

$variable = $objeto?->propiedad1b?->propiedad2a?->propiedad3a;

echo $variable;

7.Comparaciones Inteligentes

ANTES. Cuando comparabas el 0 con una cadena de texto devolvía un verdadero:

echo 0 == 'cualquier texto' ? "verdadero" : "falso"; //Devuelve "verdadero" (TRUE)

AHORA. En PHP 8 convierte la cadena de texto en número y si no es un valor numérico devuelve falso:

echo 0 == 'cualquier texto' ? "verdadero" : "falso"; //Devuelve "falso" (FALSE)

8.Última Coma

ANTES. Cuando comparabas el 0 con una cadena de texto devolvía un verdadero.

AHORA. PHP 8 permite una coma al final de una lista de parámetros:

function MiFuncion(
    $scheme,
    $user,
    $pass,
    $host,
    $port,
    $path,
    $query,
    $fragment, // <-- Ahora esto es permitido!
){}

9.Expresión Throw

ANTES. Se usaba Throw como una declaración:

function checkNum($number) {
  if($number>1) {
    throw new Exception("El valor debe ser menor a 1");
  }
  return true;
}

checkNum(2);

AHORA. Throw se considera una expresión y se puede usar en más casos:

$array = [];

$value = !empty($array)? reset($array): throw new Exception("Está vacía la matriz");
echo $value;

10.Compilador JIT

Se ha agregado a PHP 8 el compilador JIT (Just in Time) que permite compilar partes del código sobre la marcha, en tiempo de ejecución.

El compilador JIT podrá habilitarse en el archivo php.ini, permitirá almacenar el código nativo de los ficheros PHP en un apartado adicional de la memoria compartida OPcache de esta manera:

# Enabling JIT in php.ini
opcache.enable=1
opcache.jit_buffer_size=100M
opcache.jit=tracing

Y estas serian las novedades que considero más importantes de la nueva versión de PHP, no hay cambios que rompan nada de las versiones anteriores, es decir se programa exactamente igual, lo único es que han agregado mejoras a nivel de rendimiento y de sintaxis.

Si quieres aprender más de PHP te recomiendo este curso: El curso más completo de PHP en español.

¿Quieres ver este artículo en YouTube? haz clic en el botón de reproducción: