Destructuring y Spread Operator
El destructuring permite extraer valores de
arrays a variables individuales de forma
elegante. El spread operator (...)
permite expandir arrays en contextos donde se
esperan múltiples elementos.
Destructuring con list()
list() asigna valores de un array a
múltiples variables en una sola línea.
<?php
$coordenadas = [10, 20];
// Sin destructuring
$x = $coordenadas[0];
$y = $coordenadas[1];
// Con list()
list($x, $y) = $coordenadas;
echo "$x, $y"; // 10, 20
// Sintaxis corta [] (PHP 7.1+) - Recomendada
[$x, $y] = $coordenadas;
echo "$x, $y"; // 10, 20
// Útil con funciones que devuelven arrays
function dividir(int $a, int $b): array
{
return [intdiv($a, $b), $a % $b];
}
[$cociente, $resto] = dividir(17, 5);
echo "17 ÷ 5 = $cociente con resto $resto"; // 3 con resto 2
// Intercambiar variables
$a = 1;
$b = 2;
[$a, $b] = [$b, $a];
echo "$a, $b"; // 2, 1
Saltar elementos
<?php
$datos = ['Ana', 25, 'Madrid', 'España'];
// Tomar solo el primero y tercero
[$nombre, , $ciudad] = $datos;
echo "$nombre vive en $ciudad"; // Ana vive en Madrid
// Saltar los primeros
[, , , $pais] = $datos;
echo $pais; // España
// Tomar solo algunos
[$nombre] = $datos; // Solo el primero
echo $nombre; // Ana
// Ejemplo práctico: parsear fecha
$fecha = '2025-12-08';
[$año, $mes, $dia] = explode('-', $fecha);
echo "Día: $dia, Mes: $mes, Año: $año";
Destructuring con claves
Desde PHP 7.1 puedes usar destructuring con arrays asociativos especificando las claves.
<?php
$usuario = [
'nombre' => 'Carlos',
'email' => 'carlos@ejemplo.com',
'edad' => 28
];
// Extraer por clave
['nombre' => $nombre, 'email' => $email] = $usuario;
echo "$nombre: $email"; // Carlos: carlos@ejemplo.com
// El orden no importa con claves
['email' => $email, 'nombre' => $nombre] = $usuario;
// Renombrar variables
['nombre' => $userName, 'edad' => $userAge] = $usuario;
echo "$userName tiene $userAge años";
// Combinado con valores por defecto
$config = ['debug' => true];
['debug' => $debug, 'cache' => $cache] = $config + ['cache' => false];
echo $debug; // true
echo $cache; // false
// Muy útil en foreach
$usuarios = [
['nombre' => 'Ana', 'edad' => 25],
['nombre' => 'Luis', 'edad' => 30]
];
foreach ($usuarios as ['nombre' => $nombre, 'edad' => $edad]) {
echo "$nombre tiene $edad años\n";
}
El destructuring en
foreach es muy útil para
trabajar con arrays de registros. Hace
el código más legible al dar nombres
descriptivos a los valores.
Destructuring anidado
<?php
$respuesta = [
'status' => 200,
'data' => [
'user' => [
'id' => 1,
'name' => 'Carlos'
]
]
];
// Destructuring anidado
[
'status' => $status,
'data' => ['user' => ['id' => $userId, 'name' => $userName]]
] = $respuesta;
echo "Status: $status, User: $userName (ID: $userId)";
// Status: 200, User: Carlos (ID: 1)
// Con arrays indexados anidados
$matriz = [[1, 2], [3, 4]];
[[$a, $b], [$c, $d]] = $matriz;
echo "$a, $b, $c, $d"; // 1, 2, 3, 4
Spread Operator (...)
El spread operator expande un array en elementos individuales. Es muy útil para combinar arrays o pasar elementos como argumentos.
<?php
// Combinar arrays (PHP 7.4+)
$a = [1, 2, 3];
$b = [4, 5, 6];
$combinado = [...$a, ...$b];
print_r($combinado); // [1, 2, 3, 4, 5, 6]
// Añadir elementos
$nums = [2, 3, 4];
$conExtremos = [1, ...$nums, 5];
print_r($conExtremos); // [1, 2, 3, 4, 5]
// Copiar un array
$original = [1, 2, 3];
$copia = [...$original];
// Combinar con elementos adicionales
$frutas = ['manzana', 'pera'];
$masFrutas = [...$frutas, 'naranja', 'uva'];
// Con arrays asociativos (PHP 8.1+)
$defaults = ['color' => 'rojo', 'tamaño' => 'M'];
$custom = ['color' => 'azul'];
$config = [...$defaults, ...$custom];
print_r($config); // ['color' => 'azul', 'tamaño' => 'M']
Spread en llamadas a funciones
<?php
function sumar(int $a, int $b, int $c): int
{
return $a + $b + $c;
}
$numeros = [1, 2, 3];
// Sin spread
$resultado = sumar($numeros[0], $numeros[1], $numeros[2]);
// Con spread - mucho más elegante
$resultado = sumar(...$numeros);
echo $resultado; // 6
// Útil con funciones variádicas
$valores = [1, 2, 3, 4, 5];
echo max(...$valores); // 5
echo min(...$valores); // 1
// Combinar arrays para pasar a función
$masNumeros = [6, 7, 8];
echo max(...$valores, ...$masNumeros); // 8
// Con arrays asociativos y named arguments (PHP 8+)
function crearUsuario(string $nombre, int $edad, string $email): array
{
return compact('nombre', 'edad', 'email');
}
$datos = ['nombre' => 'Ana', 'edad' => 25, 'email' => 'ana@test.com'];
$usuario = crearUsuario(...$datos);
Parámetros variádicos
El spread también se usa en la definición de funciones para aceptar un número variable de argumentos.
<?php
// Función que acepta cualquier número de argumentos
function sumarTodos(int ...$numeros): int
{
return array_sum($numeros);
}
echo sumarTodos(1, 2); // 3
echo sumarTodos(1, 2, 3, 4, 5); // 15
// Combinar con parámetros normales
function registrarLog(string $nivel, string ...$mensajes): void
{
foreach ($mensajes as $mensaje) {
echo "[$nivel] $mensaje\n";
}
}
registrarLog('INFO', 'Inicio', 'Proceso', 'Fin');
// [INFO] Inicio
// [INFO] Proceso
// [INFO] Fin
// Con tipos
function procesarIds(int ...$ids): array
{
return array_map(fn($id) => $id * 2, $ids);
}
$resultado = procesarIds(1, 2, 3);
print_r($resultado); // [2, 4, 6]
Casos de uso prácticos
<?php
// 1. Extraer cabecera y resto de un array
$lineas = ['Título', 'Línea 1', 'Línea 2', 'Línea 3'];
[$titulo, ...$contenido] = $lineas;
echo $titulo; // Título
print_r($contenido); // ['Línea 1', 'Línea 2', 'Línea 3']
// 2. Procesar respuesta de API
$respuesta = [
'success' => true,
'data' => ['id' => 1, 'nombre' => 'Producto'],
'meta' => ['page' => 1, 'total' => 100]
];
['success' => $ok, 'data' => $datos] = $respuesta;
if ($ok) {
echo $datos['nombre'];
}
// 3. Merge de configuraciones
$configBase = [
'debug' => false,
'cache' => true,
'timeout' => 30
];
$configEnv = [
'debug' => true,
'api_key' => 'secret'
];
$config = [...$configBase, ...$configEnv];
// debug sobrescrito, api_key añadido
// 4. Clonar y modificar
$usuario = ['nombre' => 'Ana', 'edad' => 25];
$usuarioActualizado = [...$usuario, 'edad' => 26];
print_r($usuarioActualizado); // ['nombre' => 'Ana', 'edad' => 26]
// 5. Destructuring en función
function procesarPedido(array $pedido): void
{
['producto' => $producto, 'cantidad' => $cantidad, 'precio' => $precio] = $pedido;
$total = $cantidad * $precio;
echo "Pedido: $cantidad x $producto = $total€";
}
procesarPedido(['producto' => 'Laptop', 'cantidad' => 2, 'precio' => 999]);
El destructuring con
[] requiere PHP 7.1+. El
spread en arrays requiere PHP 7.4+. El
spread con arrays asociativos requiere
PHP 8.1+.
Ejercicios
Ejercicio 1: Destructuring basico
Dada la fecha
$fecha = '2025-12-08', usa explode
y destructuring para extraer el anio, mes y dia
en variables separadas. Imprime "Dia: X, Mes: Y,
Anio: Z".
Ver solucion
<?php
declare(strict_types=1);
$fecha = '2025-12-08';
[$anio, $mes, $dia] = explode('-', $fecha);
echo "Dia: $dia, Mes: $mes, Anio: $anio\n";
Ejercicio 2: Destructuring con claves
Dado el array asociativo, usa destructuring con claves para extraer solo el nombre y email a variables, e imprimilos.
$usuario = [
'id' => 1,
'nombre' => 'Carlos',
'email' => 'carlos@test.com',
'edad' => 30
];
Ver solucion
<?php
declare(strict_types=1);
$usuario = [
'id' => 1,
'nombre' => 'Carlos',
'email' => 'carlos@test.com',
'edad' => 30
];
['nombre' => $nombre, 'email' => $email] = $usuario;
echo "Nombre: $nombre\n";
echo "Email: $email\n";
Ejercicio 3: Combinar arrays con spread
Dados los arrays
$primeros = [1, 2, 3] y
$ultimos = [8, 9, 10], usa el
spread operator para crear un nuevo array que
contenga: los primeros, luego 4 y 5, y luego los
ultimos.
Ver solucion
<?php
declare(strict_types=1);
$primeros = [1, 2, 3];
$ultimos = [8, 9, 10];
$combinado = [...$primeros, 4, 5, ...$ultimos];
print_r($combinado);
// [1, 2, 3, 4, 5, 8, 9, 10]
¿Has encontrado un error o tienes una sugerencia para mejorar esta lección?
Escríbenos¿Te está gustando el curso?
Tenemos cursos premium con proyectos reales y soporte personalizado.
Descubrir cursos premium