Lección 19 de 75 12 min de lectura

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
<?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
<?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
<?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";
}
Destructuring en foreach

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
<?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
<?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
<?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
<?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
<?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]);
Versiones de PHP

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]

¿Te está gustando el curso?

Tenemos cursos premium con proyectos reales y soporte personalizado.

Descubrir cursos premium