Manejo de Arrays — parte 2

Arrays multidimensionales

Los arrays multidimensionales en PHP son arrays que contienen otros arrays como elementos. Esto permite crear estructuras de datos más complejas, como matrices o tablas, donde cada elemento se accede mediante múltiples índices. Los arrays multidimensionales son útiles para representar datos en formato tabular o para manejar estructuras anidadas.

Para declarar un array multidimensional, se anidan arrays dentro de otros arrays. Por ejemplo, para crear una matriz bidimensional que represente una tabla de valores:

<?php

$matriz = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
];

En este ejemplo, $matriz es un array que contiene tres arrays internos, cada uno representando una fila de la matriz. Para acceder a un elemento específico, utilizamos dos índices:

<?php

echo $matriz[0][1] . "\n"; // Muestra "2"
echo $matriz[2][2] . "\n"; // Muestra "9"

El primer índice ([0], [2]) selecciona la fila, y el segundo índice ([1], [2]) selecciona el valor dentro de esa fila. Es importante recordar que los índices comienzan en 0.

Los arrays multidimensionales pueden combinar arrays indexados y arrays asociativos. Por ejemplo, un array que almacena información sobre estudiantes:

<?php

$estudiantes = [
    [
        "nombre" => "Carlos",
        "edad" => 20,
        "cursos" => ["Matemáticas", "Física"]
    ],
    [
        "nombre" => "María",
        "edad" => 22,
        "cursos" => ["Biología", "Química"]
    ]
];

echo $estudiantes[1]["nombre"] . "\n";       // Muestra "María"
echo $estudiantes[0]["cursos"][0] . "\n";    // Muestra "Matemáticas"

En este caso, $estudiantes es un array indexado que contiene arrays asociativos. Cada estudiante tiene una clave "cursos" que es un array de sus asignaturas, demostrando la flexibilidad de los arrays anidados.

Para recorrer un array multidimensional, se pueden utilizar bucles foreach anidados:

<?php

foreach ($estudiantes as $estudiante) {
    echo "Nombre: " . $estudiante["nombre"] . "\n";
    echo "Edad: " . $estudiante["edad"] . "\n";
    echo "Cursos: ";
    foreach ($estudiante["cursos"] as $curso) {
        echo "$curso ";
    }
    echo "\n----------------\n";
}

Este código muestra la información de cada estudiante y recorre su lista de cursos. La utilización de bucles anidados es esencial para manejar correctamente los niveles múltiples de los arrays.

Es posible crear arrays con más de dos niveles de profundidad. Por ejemplo, un array tridimensional que represente un calendario:

<?php

$calendario = [
    "2024" => [
        "Enero" => [ "Evento1", "Evento2" ],
        "Febrero" => [ "Evento3" ]
    ],
    "2025" => [
        "Marzo" => [ "Evento4", "Evento5" ]
    ]
];

echo $calendario["2024"]["Enero"][0] . "\n"; // Muestra "Evento1"

Aquí, $calendario es un array asociativo donde el primer nivel son los años, el segundo nivel son los meses y el tercer nivel es una lista de eventos. Esta estructura permite organizar datos de manera jerárquica y accede a ellos mediante múltiples claves.

Para añadir elementos a un array multidimensional, se accede al nivel correspondiente y se asigna el nuevo valor:

<?php

$calendario["2024"]["Enero"][] = "Evento6";
$estudiantes[0]["cursos"][] = "Programación";

De esta forma, se agrega "Evento6" al mes de Enero de 2024 y se añade "Programación" a la lista de cursos del primer estudiante. La capacidad de modificar arrays multidimensionales dinámicamente es una característica util de PHP.

Al manipular arrays multidimensionales, es útil conocer funciones como array_merge_recursive() y array_replace_recursive(). Estas funciones permiten combinar o reemplazar elementos en arrays anidados:

<?php

$array1 = [
    "A" => ["a1", "a2"],
    "B" => ["b1"]
];

$array2 = [
    "A" => ["a3"],
    "C" => ["c1"]
];

$resultado = array_merge_recursive($array1, $array2);

print_r($resultado);

El resultado es un array donde las claves comunes se fusionan:

Array
(
    [A] => Array
        (
            [0] => a1
            [1] => a2
            [2] => a3
        )
    [B] => Array
        (
            [0] => b1
        )
    [C] => Array
        (
            [0] => c1
        )
)

Cuando se trabaja con arrays multidimensionales grandes, puede ser útil utilizar referencias para acceder y modificar elementos en niveles profundos sin tener que escribir toda la cadena de índices:

<?php

$referencia =& $calendario["2024"]["Enero"];
$referencia[] = "Evento7";

En este ejemplo, $referencia es una referencia al array de eventos de Enero de 2024, lo que permite agregar "Evento7" sin repetir toda la ruta de acceso.

La función array_walk_recursive() es útil para aplicar una función a cada elemento de un array multidimensional:

<?php

function mostrar_elemento($valor, $clave)
{
    echo "$clave: $valor\n";
}

array_walk_recursive($estudiantes, "mostrar_elemento");

Esta función recorrerá todos los elementos, incluso en niveles anidados, y aplicará la función mostrar_elemento a cada uno.

Es importante manejar con cuidado los arrays multidimensionales para evitar errores comunes, como acceder a índices inexistentes o confundir el orden de los índices. Utilizar herramientas como isset() o array_key_exists() puede ayudar a verificar la existencia de una clave o índice antes de acceder a él:

<?php

if (isset($estudiantes[1]["cursos"][2])) {
    echo $estudiantes[1]["cursos"][2] . "\n";
} else {
    echo "El curso no existe.\n";
}

Al modificar estructuras complejas, es recomendable mantener un código claro y bien documentado, ya que los arrays multidimensionales pueden volverse complicados rápidamente. Considerar la refactorización a objetos o utilizar estructuras de datos más adecuadas en casos de alta complejidad.

En resumen, los arrays multidimensionales proporcionan una forma flexible de manejar datos estructurados y permiten almacenar información en múltiples niveles. Comprender cómo declararlos, acceder a sus elementos y manipularlos es esencial para desarrollar aplicaciones PHP robustas y eficientes.

Funciones comunes para manipular arrays

Utilizar las funciones integradas para manipular arrays es esencial en la programación con PHP, ya que proporcionan métodos eficientes y flexibles para manejar estructuras de datos. Las funciones de arrays facilitan tareas como añadir, eliminar, buscar y ordenar elementos, optimizando el código y evitando la implementación manual de algoritmos comunes.

Empecemos con funciones para añadir elementos a un array. La función array_push() permite agregar uno o más elementos al final de un array existente:

<?php

$frutas = ["Manzana", "Banana"];
array_push($frutas, "Cereza", "Durazno");
print_r($frutas);

Este código agrega "Cereza" y "Durazno" al array $frutas, resultando en:

Array
(
    [0] => Manzana
    [1] => Banana
    [2] => Cereza
    [3] => Durazno
)

Para añadir elementos al inicio de un array, se utiliza array_unshift(). Esta función inserta los valores al comienzo del array y desplaza los índices existentes hacia adelante:

<?php

$numeros = [3, 4, 5];
array_unshift($numeros, 1, 2);
print_r($numeros);

El resultado es:

Array
(
    [0] => 1
    [1] => 2
    [2] => 3
    [3] => 4
    [4] => 5
)

Para eliminar elementos de un array, PHP ofrece array_pop() y array_shift(). La función array_pop() elimina y devuelve el último elemento del array:

<?php

$colores = ["Rojo", "Verde", "Azul"];
$ultimoColor = array_pop($colores);
echo "El último color era: $ultimoColor\n";
print_r($colores);

Salida:

El último color era: Azul
Array
(
    [0] => Rojo
    [1] => Verde
)

Por otro lado, array_shift() elimina y devuelve el primer elemento del array:

<?php

$letras = ["A", "B", "C"];
$primeraLetra = array_shift($letras);
echo "La primera letra era: $primeraLetra\n";
print_r($letras);

Salida:

La primera letra era: A
Array
(
    [0] => B
    [1] => C
)

Si necesitamos combinar arrays, la función array_merge() es muy útil. Combina los elementos de uno o más arrays en uno solo:

<?php

$array1 = ["Clave1" => "Valor1", "Clave2" => "Valor2"];
$array2 = ["Clave3" => "Valor3", "Clave4" => "Valor4"];
$combinado = array_merge($array1, $array2);
print_r($combinado);

Resultado:

Array
(
    [Clave1] => Valor1
    [Clave2] => Valor2
    [Clave3] => Valor3
    [Clave4] => Valor4
)

Es importante notar que si los arrays tienen claves numéricas, array_merge() las reindexa comenzando desde cero. Para preservar las claves, se puede usar el operador de suma +:

<?php

$arrayA = [0 => "Manzana", 1 => "Banana"];
$arrayB = [1 => "Cereza", 2 => "Durazno"];
$union = $arrayA + $arrayB;
print_r($union);

Resultado:

Array
(
    [0] => Manzana
    [1] => Banana
    [2] => Durazno
)

Otra función para cortar arrays es array_slice(), que extrae una porción de un array sin modificar el original:

<?php

$animales = ["Perro", "Gato", "Ratón", "Elefante", "León"];
$mamíferos = array_slice($animales, 1, 3);
print_r($mamíferos);

Salida:

Array
(
    [0] => Gato
    [1] => Ratón
    [2] => Elefante
)

Para eliminar y reemplazar elementos, array_splice() permite modificar el array original:

<?php

$nombres = ["Ana", "Luis", "Pedro", "María"];
array_splice($nombres, 2, 1, ["Juan", "Carmen"]);
print_r($nombres);

Resultado:

Array
(
    [0] => Ana
    [1] => Luis
    [2] => Juan
    [3] => Carmen
    [4] => María
)

En este ejemplo, se elimina "Pedro" (índice 2) y se insertan "Juan" y "Carmen" en su lugar.

Para buscar valores dentro de un array, in_array() verifica si un valor existe:

<?php

$paises = ["España", "Francia", "Italia"];
if (in_array("Italia", $paises)) {
    echo "Italia está en la lista.\n";
}

Si además necesitamos conocer la clave de un valor, array_search() devuelve la primera clave encontrada:

<?php

$edades = ["Juan" => 25, "Ana" => 30, "Luis" => 28];
$nombre = array_search(30, $edades);
echo "La persona de 30 años es: $nombre\n";

Salida:

La persona de 30 años es: Ana

Cuando trabajamos con arrays, es común necesitar filtrar elementos según ciertas condiciones. La función array_filter() aplica un callback a cada elemento y devuelve un nuevo array con los elementos que cumplen la condición:

<?php

$numeros = [1, 2, 3, 4, 5, 6];
$pares = array_filter($numeros, function($numero) {
    return $numero % 2 === 0;
});
print_r($pares);

Resultado:

Array
(
    [1] => 2
    [3] => 4
    [5] => 6
)

Para transformar cada elemento de un array, array_map() aplica una función a cada valor y devuelve un nuevo array con los resultados:

<?php

$valores = [1, 2, 3];
$cuadrados = array_map(function($valor) {
    return $valor ** 2;
}, $valores);
print_r($cuadrados);

Salida:

Array
(
    [0] => 1
    [1] => 4
    [2] => 9
)

La función array_reduce() permite reducir un array a un solo valor acumulando los resultados:

<?php

$numeros = [1, 2, 3, 4];
$suma = array_reduce($numeros, function($acumulador, $numero) {
    return $acumulador + $numero;
}, 0);
echo "La suma es: $suma\n";

Resultado:

La suma es: 10

En situaciones donde necesitamos ordenar arrays, PHP proporciona varias funciones. La función sort() ordena un array en orden ascendente y reindexa las claves:

<?php

$letras = ["d", "a", "c", "b"];
sort($letras);
print_r($letras);

Resultado:

Array
(
    [0] => a
    [1] => b
    [2] => c
    [3] => d
)

Para mantener la asociación entre claves y valores en arrays asociativos, se utiliza asort():

<?php

$notas = ["Juan" => 8, "Ana" => 9, "Luis" => 7];
asort($notas);
print_r($notas);

Resultado:

Array
(
    [Luis] => 7
    [Juan] => 8
    [Ana] => 9
)

Si queremos ordenar un array asociativo por claves, ksort() es la función adecuada:

<?php

$datos = ["b" => 2, "a" => 1, "c" => 3];
ksort($datos);
print_r($datos);

Resultado:

Array
(
    [a] => 1
    [b] => 2
    [c] => 3
)

Para invertir el orden de los elementos en un array, array_reverse() devuelve un nuevo array con los elementos en orden inverso:

<?php

$numeros = [1, 2, 3, 4, 5];
$invertido = array_reverse($numeros);
print_r($invertido);

Resultado:

Array
(
    [0] => 5
    [1] => 4
    [2] => 3
    [3] => 2
    [4] => 1
)

Cuando necesitamos eliminar duplicados, array_unique() devuelve un array sin valores repetidos:

<?php

$repetidos = [1, 2, 2, 3, 3, 3];
$unicos = array_unique($repetidos);
print_r($unicos);

Resultado:

Array
(
    [0] => 1
    [1] => 2
    [3] => 3
)

La función array_walk() permite aplicar una función a cada elemento de un array, modificándolo directamente. Es útil para tareas que requieren una modificación en sitio:

<?php

$frutas = ["manzana", "naranja", "plátano"];
array_walk($frutas, function(&$fruta) {
    $fruta = strtoupper($fruta);
});
print_r($frutas);

Resultado:

Array
(
    [0] => MANZANA
    [1] => NARANJA
    [2] => PLÁTANO
)

Para obtener todas las claves de un array, array_keys() devuelve un array con las claves, y array_values() retorna un array con los valores:

<?php

$persona = ["nombre" => "Carlos", "edad" => 30, "ciudad" => "Madrid"];
$claves = array_keys($persona);
$valores = array_values($persona);
print_r($claves);
print_r($valores);

Resultado:

Array
(
    [0] => nombre
    [1] => edad
    [2] => ciudad
)
Array
(
    [0] => Carlos
    [1] => 30
    [2] => Madrid
)

Para verificar si una clave existe en un array asociativo, array_key_exists() es la función adecuada:

<?php

if (array_key_exists("edad", $persona)) {
    echo "La edad es " . $persona["edad"] . "\n";
}

En caso de necesitar aplicar una función de usuario para ordenar arrays, usort() permite definir un criterio personalizado:

<?php

$empleados = [
    ["nombre" => "Ana", "edad" => 28],
    ["nombre" => "Luis", "edad" => 35],
    ["nombre" => "Pedro", "edad" => 22],
];

usort($empleados, function($a, $b) {
    return $a["edad"] <=> $b["edad"];
});

print_r($empleados);

La comparación utiliza el operador de nave espacial <=>, que retorna -1, 0 o 1 dependiendo de la comparación.

En situaciones donde se requiere contar elementos, count() devuelve el número de elementos en un array:

<?php

$elementos = ["a", "b", "c", "d"];
echo "El array tiene " . count($elementos) . " elementos.\n";

Para contar de manera recursiva en arrays multidimensionales, count() acepta un segundo parámetro:

<?php

$multiArray = [[1, 2], [3, 4, 5], [6]];
$total = count($multiArray, COUNT_RECURSIVE);
echo "El array multidimensional tiene $total elementos.\n";

Para dividir un array en fragmentos más pequeños, array_chunk() es útil:

<?php

$numeros = [1, 2, 3, 4, 5, 6, 7];
$pedazos = array_chunk($numeros, 3);
print_r($pedazos);

Resultado:

Array
(
    [0] => Array
        (
            [0] => 1
            [1] => 2
            [2] => 3
        )

    [1] => Array
        (
            [0] => 4
            [1] => 5
            [2] => 6
        )

    [2] => Array
        (
            [0] => 7
        )

)

Conocer y utilizar las funciones comunes para manipular arrays en PHP permite escribir código más limpio, eficiente y mantenible. Estas herramientas facilitan la gestión de datos y resuelven problemas comunes de forma efectiva.