🏗️ Deja de abusar de los Arrays en PHP

En el mundo de PHP tenemos la mala costumbre de usar Arrays para absolutamente todo. ¿Una lista? pues array nene, ¿unos resultaditos de una query? pos otro array, ¿unas patatas fritas? ¡OTRO ARRAY!

Pero PHP tiene una librería estándar llamada SPL (Standard PHP Library) que ofrece estructuras de datos específicas, implementadas en C, que son más eficientes y semánticamente correctas. Hoy vemos por encima algunas de ellas.

PHP SPL Stack and Queue Data Structures — Madre mía que imagenes más guapas me hace el lleminai nene.

🥞 SplStack: El concepto LIFO

SplStack implementa el principio LIFO (Last In, First Out). El último en entrar es el primero en salir. Imagina una pila de platos: pones uno encima de otro, y para quitar uno, tienes que quitar el de arriba primero.

¿Cómo se usa?

$pila = new SplStack();

// Añadir (Push)
$pila->push("Plato 1");
$pila->push("Plato 2");
$pila->push("Plato 3");

// El último añadido es el 'Top'
echo $pila->top(); // Salida: Plato 3

// Quitar (Pop)
echo $pila->pop(); // Salida: Plato 3
// Ahora el top es Plato 2

✅ Caso Real 1: Sistema “Deshacer” (Undo)

El ejemplo clásico que usamos a diario. Hoy en día tu cuando vas a meter la zarpa en un proyecto y la lías, cada liada que metes se apila. Cuando ulsas Ctrl+Z, deshaces la última liada. Ojala esto en la vida real eh, mano de santo.

$historial = new SplStack();

// Usuario escribe
$historial->push("Te emborrachaste");
$historial->push("Insultaste al camarero");
$historial->push("Le montaste un pollo a tu pareja");

// Usuario pulsa Deshacer (Ctrl+Z)
$accion = $historial->pop();
echo "Deshaciendo: " . $accion; // Tu pareja te vuelve a amar!

✅ Caso Real 2: Validar HMTL o Paréntesis

¿Cómo sabe tu IDE que te falta cerrar un </div>? Usando una pila. Cada vez que encuentras una etiqueta de apertura <div>, la metes a la pila. Cuando encuentras una de cierre </div>, sacas de la pila. Si al final la pila no está vacía, falta cerrar algo. O si intentas sacar y está vacía, has cerrado de más.

function validarParentesis(string $codigo): bool {
    $pila = new SplStack();

    foreach (str_split($codigo) as $char) {
        if ($char === '(') {
            $pila->push($char);
        } elseif ($char === ')') {
            if ($pila->isEmpty()) return false; // Cerrado sin abrir
            $pila->pop();
        }
    }

    return $pila->isEmpty();
}

var_dump(validarParentesis("((Hola))")); // true
var_dump(validarParentesis("((Hola)"));  // false

🚶‍♂️ SplQueue: El concepto FIFO

SplQueue implementa FIFO (First In, First Out). El primero en llegar es el primero en ser atendido. Como la cola del supermercado o del cine.

¿Cómo se usa?

$cola = new SplQueue();

// Encolar (Enqueue)
$cola->enqueue("Cliente 1");
$cola->enqueue("Cliente 2");

// Ver quién va primero (Bottom porque es donde empieza la cola)
echo $cola->bottom(); // Cliente 1

// Desencolar (Dequeue)
echo $cola->dequeue(); // Cliente 1

Ojo a la confusión: En SplQueue, enqueue añade al final y dequeue saca del principio. bottom() mira el principio (el siguiente en salir) y top() mira el final (el último que llegó).

✅ Caso Real 1: Procesamiento de Tareas (Jobs)

Tienes un sistema que envía emails. No quieres bloquear al usuario mientras se envía. Guardas la tarea en una cola y un “worker” la procesa en orden.

$colaEmails = new SplQueue();

// Añadimos tareas
$colaEmails->enqueue("email_bienvenida@usuario.com");
$colaEmails->enqueue("reporte_mensual@admin.com");

// Worker procesando
while (!$colaEmails->isEmpty()) {
    $email = $colaEmails->dequeue();
    enviarEmail($email);
    echo "Enviado a: $email\n";
}

✅ Caso Real 2: Chatbot con Respuestas en Espera

Imagina un chatbot de soporte. Los mensajes de los usuarios entran en orden. Debes procesarlos uno a uno, respetando quién llegó primero. Si usaras una pila, ¡contestarías al último que escribió primero! (Super injusto).

$chatServer = new SplQueue();

$chatServer->enqueue(['user' => 'Juan', 'msg' => 'Tengo un problema']);
$chatServer->enqueue(['user' => 'Ana', 'msg' => 'Quiero un reembolso']);

// Procesando tickets
$ticketActual = $chatServer->dequeue(); // Atendemos a Juan primero

🏎️ Bonus: SplFixedArray (El Array de verdad)

Si te preguntas si existe algo en SPL que actue como un array normal pero que sea más eficiente, pos si, existe, es SplFixedArray.

Los arrays de PHP son en realidad mapas ordenados (hash maps). Son super flexibles (puedes mezclar tipos, claves no numéricas…), pero esa flexibilidad tiene un coste de memoria y velocidad.

SplFixedArray es lo más parecido a un array de C.

Características clave:

Tamaño fijo: Tienes que decirle cuántos elementos tendrá.
Índices numéricos: Solo acepta enteros como índices (0, 1, 2…).
Velocidad: Es más rápido y consume MUCHA menos memoria que un array normal.

¿Cuándo usarlo?

Cuando sepas de antemano el tamaño de tu colección y solo necesites índices numéricos (matrices, procesamiento de imágenes, datasets grandes).

// Un array normal de PHP
$array = [];
$array[0] = 3;
$array[100] = 5; // PHP tiene que gestionar este hueco, es un hash map

// SplFixedArray
$fixed = new SplFixedArray(5); // Tamaño 5
$fixed[0] = 1;
$fixed[1] = 2;
// $fixed[10] = 5; // ¡ERROR! RuntimeException: Index invalid or out of range

// Redimensionar si es necesario
$fixed->setSize(10);

⛔ ¡Cuidado con los bucles! Si no sabes el tamaño máximo de antemano, NO uses SplFixedArray redimensionando en cada iteración ($fixed->setSize($i + 1)). Esto destruye el rendimiento porque PHP tiene que reservar nueva memoria y copiar datos todo el rato.

Si no sabes el tamaño, usa un array normal o una SplDoublyLinkedList y, si al final necesitas la velocidad de lectura, conviértelo:
$fixed = SplFixedArray::fromArray($miArrayNormal);

⚡ Comparativa rápida de memoria

Si llenas un array con 1 millón de enteros:

Array PHP Normal: ~40 MB de RAM
SplFixedArray: ~8 MB de RAM

Una diferencia bastante considerable pue.

🌌 El Universo SPL es enorme

No solo existen esas SPL. PHP está repleto de estructuras ocultas que solucionan problemas complejos con mucha elegancia. Aquí tienes otras pocas más.

🏥 SplPriorityQueue (Cola de Urgencias)

En una cola normal (SplQueue), sale primero quien llega primero. Pero, ¿y si es un hospital? Si llega alguien con un ataque al corazón, debe pasar antes que el que tiene un resfriado, aunque haya llegado más tarde.

Para eso sirve SplPriorityQueue.

$urgencias = new SplPriorityQueue();

// Insertamos (Dato, Prioridad)
$urgencias->insert('Paciente Resfriado', 1); // Prioridad baja
$urgencias->insert('Paciente Infarto', 10);  // Prioridad ALTA
$urgencias->insert('Paciente Fiebre', 5);    // Prioridad media

// Al iterar, salen ordenados por PRIODIDAD, no por llegada
foreach ($urgencias as $paciente) {
    echo $paciente . PHP_EOL;
}

// Salida:
// Paciente Infarto
// Paciente Fiebre
// Paciente Resfriado

🌳 SplMinHeap (El más barato primero)

Imagina que tienes una lista de precios de vuelos y siempre quieres sacar el más barato rápidamente. SplMinHeap mantiene los datos ordenados en forma de árbol, donde el nodo superior siempre es el menor.

$precios = new SplMinHeap();
$precios->insert(150);
$precios->insert(50);
$precios->insert(300);

echo $precios->top(); // 50 (El más barato)

Ventaja: Si usaras un array, tendrías que hacer sort($array) cada vez que metes un precio nuevo (lento). SplMinHeap lo reordena internamente de forma súper eficiente al insertar.

🗺️ SplObjectStorage (Mapeando Objetos)

¿Alguna vez has querido asociar datos a un objeto pero sin “manchar” el objeto con propiedades nuevas? Los arrays normales de PHP NO permiten usar objetos como claves ($mapa[$usuario] = 'datos' da error).

SplObjectStorage es exactamente para esto: un mapa donde las claves son objetos.

$almacen = new SplObjectStorage();

$usuario1 = new User('Domin');
$usuario2 = new User('Pepe');

// Asociamos información extra a estos objetos
$almacen[$usuario1] = ['rol' => 'admin', 'ultimo_login' => 'ayer'];
$almacen[$usuario2] = ['rol' => 'invitado'];

// Podemos comprobar si un objeto está en el almacén
if ($almacen->contains($usuario1)) {
    echo "Datos de Domin: " . $almacen[$usuario1]['rol']; // admin
}

Es utilísimo para patrones como Data Mapper o para adjuntar metadatos temporales a entidades de Doctrine/ORM sin tocar la entidad.

🚀 ¿Por qué usar SPL en vez de Arrays?

Rendimiento: Están optimizadas en C. Para grandes volúmenes de datos, SplStack, SplQueue y SplFixedArray gestionan la memoria mejor que un array gigante de PHP al que le haces array_shift (que tiene que reindexar todo el array cada vez, ¡costoso!).
Semántica: Si ves new Splstack() en el código, sabes INSTANTÁNEAMENTE que es una pila. Si ves $arr = [], tienes que leer como se usa para saber qué es.
Encapsulamiento: Tienes métodos claros (push, pop, enqueue, setSize) en lugar de funciones genéricas de array.

Conclusión

Los arrays molan y molarán pero PHP tiene herramientas profesionales que igual también van bien y son más eficientes. La próxima vez que necesites procesar datos en orden (Colas) o deshacer acciones (Pilas), acuérdate de SPL.

¡EA! Nos beermos en los bares shavales!🍻