Creación y manipulación de arrays en PHP

Hola, ¿cómo están? Continuando con el curso de PHP, hoy veremos los arrays en profundidad. Es probablemente la estructura que más vas a usar: todo lo que llega de una base de datos, de un formulario o de una API llega como array.

¡Empecemos!

Qué es un array

Un array es una variable que almacena múltiples valores bajo un mismo nombre. Cada valor tiene una clave que permite acceder a él.

En PHP los arrays son especialmente flexibles: pueden crecer sin límite declarado, mezclar tipos de datos y usar claves numéricas o de texto.

Arrays indexados

Las claves son números que empiezan en 0:

<?php
$colores = ["rojo", "verde", "azul"];

echo $colores[0];   // rojo
echo $colores[2];   // azul
echo count($colores);   // 3

También existe la sintaxis antigua array("rojo", "verde"), que verás en código viejo. Usa siempre los corchetes.

Arrays asociativos

Las claves son texto, lo que hace el código mucho más legible:

<?php
$cliente = [
    "nombre" => "Ana Torres",
    "ciudad" => "Cochabamba",
    "activo" => true,
];

echo $cliente["nombre"];   // Ana Torres

Este es el formato en el que llega cada registro de una consulta a base de datos.

Arrays multidimensionales

Un array puede contener otros arrays:

<?php
$productos = [
    ["nombre" => "Teclado", "precio" => 120, "stock" => 8],
    ["nombre" => "Monitor", "precio" => 850, "stock" => 3],
    ["nombre" => "Mouse",   "precio" => 60,  "stock" => 15],
];

echo $productos[1]["nombre"];   // Monitor

Este es exactamente el resultado de una consulta que devuelve varias filas.

Agregar y quitar elementos

<?php
$colores = ["rojo", "verde"];

// Agregar al final
$colores[] = "azul";
array_push($colores, "amarillo", "negro");

// Agregar al inicio
array_unshift($colores, "blanco");

// Quitar el último
$ultimo = array_pop($colores);

// Quitar el primero
$primero = array_shift($colores);

// Eliminar por clave
unset($colores[1]);

Un detalle sobre unset(): no reordena las claves. Si eliminas el elemento 1 de un array de tres, quedan las claves 0 y 2. Para reindexar:

<?php
$colores = array_values($colores);

Es un error muy común y por eso array_values() aparece tanto.

Comprobar existencia

<?php
$cliente = ["nombre" => "Ana", "telefono" => null];

var_dump(isset($cliente["nombre"]));            // true
var_dump(isset($cliente["telefono"]));          // false ← ojo
var_dump(array_key_exists("telefono", $cliente)); // true
var_dump(in_array("Ana", $cliente));            // true

La diferencia importa: isset() devuelve false si la clave existe pero vale null. Si necesitas saber si la clave existe realmente, usa array_key_exists().

Para acceder con un valor por defecto:

<?php
$telefono = $cliente["telefono"] ?? "sin teléfono";

Recorrer arrays

Ya lo vimos en la lección de bucles, pero conviene recordarlo:

<?php
foreach ($productos as $producto) {
    echo $producto["nombre"];
}

foreach ($cliente as $campo => $valor) {
    echo "$campo: $valor\n";
}

Ordenar arrays

<?php
$numeros = [5, 3, 8, 1];

sort($numeros);     // ascendente, reindexa
rsort($numeros);    // descendente

$edades = ["ana" => 30, "luis" => 25, "eva" => 35];

asort($edades);     // por valor, conserva claves
arsort($edades);    // por valor, descendente
ksort($edades);     // por clave
krsort($edades);    // por clave, descendente

La distinción clave: sort() pierde las claves, asort() las conserva. Con arrays asociativos casi siempre quieres las versiones con a.

Para ordenar con tu propio criterio, usort() con una función anónima, como vimos en la lección de funciones anónimas:

<?php
usort($productos, fn($a, $b) => $a["precio"] <=> $b["precio"]);

Buscar en arrays

<?php
$colores = ["rojo", "verde", "azul"];

var_dump(in_array("verde", $colores));        // true
var_dump(array_search("verde", $colores));    // 1, la clave

Cuidado con array_search(): si encuentra el elemento en la posición 0, devuelve 0, que en una condición se evalúa como falso. Compara siempre de forma estricta:

<?php
if (array_search("rojo", $colores) !== false) {
    echo "Encontrado";
}

Es otro caso donde aplica lo que vimos sobre comparación estricta.

Las funciones que más vas a usar

Transformar, filtrar y reducir

<?php
$precios = [100, 250, 80];

$conIva = array_map(fn($p) => round($p * 1.13, 2), $precios);
$caros = array_filter($precios, fn($p) => $p > 90);
$total = array_reduce($precios, fn($t, $p) => $t + $p, 0);

Extraer una columna

array_column() es una joya poco conocida y utilísima con resultados de base de datos:

<?php
$nombres = array_column($productos, 'nombre');
// ["Teclado", "Monitor", "Mouse"]

// Con clave personalizada
$porNombre = array_column($productos, 'precio', 'nombre');
// ["Teclado" => 120, "Monitor" => 850, "Mouse" => 60]

Esa segunda forma —indexar por un campo— evita muchísimos bucles.

Claves y valores

<?php
$claves = array_keys($cliente);
$valores = array_values($cliente);
$invertido = array_flip($cliente);

Combinar arrays

<?php
$a = ["rojo", "verde"];
$b = ["azul", "negro"];

$todos = array_merge($a, $b);
$todos = [...$a, ...$b];   // sintaxis moderna, PHP 7.4+

Cuidado: con claves de texto, array_merge() sobrescribe las repetidas; con claves numéricas, reindexa. Si quieres conservar las claves del primero:

<?php
$resultado = $a + $b;

Sumas y estadísticas

<?php
$precios = [100, 250, 80];

echo array_sum($precios);      // 430
echo array_product($precios);  // 2000000
echo max($precios);            // 250
echo min($precios);            // 80
echo count($precios);          // 3

Otras útiles

<?php
$unicos = array_unique([1, 2, 2, 3, 3]);      // quita duplicados
$parte = array_slice($productos, 0, 2);        // primeros 2
$invertido = array_reverse($colores);
$aplanado = array_merge(...$arrayDeArrays);    // aplanar un nivel
$troceado = array_chunk($productos, 2);        // grupos de 2

Desestructurar arrays

Permite extraer valores en variables de una vez:

<?php
[$primero, $segundo] = ["rojo", "verde"];

// Con arrays asociativos
["nombre" => $nombre, "ciudad" => $ciudad] = $cliente;

// En un foreach
foreach ($coordenadas as [$x, $y]) {
    echo "($x, $y)";
}

Un ejemplo práctico

Procesemos un inventario completo:

<?php
declare(strict_types=1);

$productos = [
    ["nombre" => "Teclado", "precio" => 120, "stock" => 8,  "categoria" => "accesorios"],
    ["nombre" => "Monitor", "precio" => 850, "stock" => 3,  "categoria" => "pantallas"],
    ["nombre" => "Mouse",   "precio" => 60,  "stock" => 0,  "categoria" => "accesorios"],
    ["nombre" => "Webcam",  "precio" => 300, "stock" => 12, "categoria" => "accesorios"],
];

// 1. Solo con stock
$disponibles = array_values(
    array_filter($productos, fn($p) => $p["stock"] > 0)
);

// 2. Valor total del inventario
$valorTotal = array_reduce(
    $disponibles,
    fn($total, $p) => $total + ($p["precio"] * $p["stock"]),
    0
);

// 3. Agrupar por categoría
$porCategoria = [];
foreach ($disponibles as $p) {
    $porCategoria[$p["categoria"]][] = $p["nombre"];
}

// 4. El más caro
usort($disponibles, fn($a, $b) => $b["precio"] <=> $a["precio"]);
$masCaro = $disponibles[0]["nombre"];

echo "Valor del inventario: " . number_format($valorTotal, 2) . "\n";
echo "Producto más caro: $masCaro\n";
print_r($porCategoria);

Ese patrón de agrupar creando claves sobre la marcha —$porCategoria[$clave][] = $valor— aparece constantemente al armar reportes.

Errores comunes

• Olvidar array_values() después de array_filter(), y encontrarte con claves salteadas.
• Usar isset() con valores null. Usa array_key_exists().
• Comparar array_search() con false sin usar !==.
• Confundir sort() con asort() y perder las claves de un array asociativo.
• Llamar a count() dentro de la condición de un bucle largo.

Para cerrar

Los arrays son la estructura central de PHP. Si tuviera que quedarme con cinco funciones para el día a día serían array_map, array_filter, array_column, array_reduce y usort: con esas cinco resuelves la mayoría del trabajo con datos.

En la siguiente lección veremos la gestión de errores.

Saludos y éxitos.