Arrays indexados

Los arrays indexados en PHP son una estructura de datos que permite almacenar múltiples valores en una única variable. Cada elemento está asociado a un índice numérico, comenzando por defecto en 0. Son muy útiles para manejar listas ordenadas de elementos sin necesidad de crear variables independientes para cada uno.

Para declarar un array indexado, podemos utilizar la sintaxis de corchetes [] o la función array(). Por ejemplo:

<?php

// Usando corchetes
$frutas = ["Manzana", "Plátano", "Cereza"];
print_r($frutas);

// Usando la función array()
$numeros = array(10, 20, 30);
print_r($numeros);

Los elementos de un array indexado se acceden mediante su índice numérico entre corchetes. El primer elemento tiene el índice 0, el segundo el 1, y así sucesivamente. Por ejemplo:

<?php

echo "$frutas[0]\n"; // Muestra "Manzana"
echo "$numeros[1]\n"; // Muestra "20"

Podemos añadir nuevos valores a un array indexado especificando el índice o dejando que PHP asigne el siguiente índice disponible automáticamente. Añadir un elemento sin especificar el índice:

<?php

$frutas[] = "Durazno"; // Se añade al final del array

Asignar un valor a un índice específico nos permite controlar la posición del elemento en el array:

<?php

$numeros[5] = 50; // Asigna el valor 50 al índice 5

Si asignamos un valor a un índice mayor que los existentes, PHP rellena los índices intermedios con NULL. Por ejemplo:

<?php

$letras = [];
$letras[3] = "D"; // $letras[0], $letras[1], $letras[2] son NULL

Es posible inicializar un array indexado con índices personalizados desde el inicio:

<?php

$meses = [
    1 => "Enero",
    2 => "Febrero",
    3 => "Marzo",
];

Cuando mezclamos asignaciones automáticas y manuales de índices, es importante comprender cómo PHP gestiona los índices. Si utilizamos índices numéricos no secuenciales, el siguiente índice automático será el mayor índice entero existente más uno.

Los arrays indexados pueden contener valores de distintos tipos, como enteros, cadenas o booleanos. Esto proporciona flexibilidad al manejar conjuntos de datos heterogéneos.

Para modificar el valor de un elemento existente en un array indexado, simplemente asignamos un nuevo valor al índice correspondiente:

<?php

$frutas[0] = "Mango"; // Reemplaza "Manzana" por "Mango"

Arrays asociativos

Los arrays asociativos en PHP son estructuras que permiten almacenar pares de clave y valor, donde las claves son identificadores únicos que pueden ser cadenas de texto o enteros. A diferencia de los arrays indexados que utilizan índices numéricos consecutivos, los arrays asociativos ofrecen una manera más descriptiva de acceder a los valores almacenados.

Para declarar un array asociativo, se puede utilizar la sintaxis de corchetes [] asignando cada clave a su correspondiente valor usando el operador =>. Por ejemplo:

<?php

$empleado = [
    "nombre" => "Carlos",
    "apellido" => "Pérez",
    "edad" => 28,
    "departamento" => "Ventas"
];

$precios = [
    "manzana" => 0.5,
    "naranja" => 0.75,
    "plátano" => 0.4
];

En el ejemplo anterior, $empleado y $precios son arrays asociativos donde las claves proporcionan una descripción clara del valor asociado. Esto mejora la legibilidad y facilita el mantenimiento del código.

Para acceder a los elementos de un array asociativo, se utiliza la clave correspondiente entre corchetes:

<?php

echo "{$empleado['nombre']}\n";      // Muestra "Carlos"
echo "{$precios['naranja']}\n";      // Muestra "0.75"

Es posible añadir nuevos elementos asignando un valor a una nueva clave:

<?php

$empleado["salario"] = 30000;
$precios["pera"] = 0.6;

Si se necesita modificar el valor de una clave existente, simplemente se reasigna un nuevo valor:

<?php

$empleado["edad"] = 29;
$precios["manzana"] = 0.55;

Para eliminar un elemento de un array asociativo, se utiliza la función unset() pasando la clave del elemento que se desea remover:

<?php

unset($empleado["departamento"]);
unset($precios["plátano"]);

Los arrays asociativos son especialmente útiles cuando se trabaja con datos que tienen una relación clave-valor evidente, como registros de bases de datos o configuraciones:

<?php

$configuracion = [
    "base_datos" => "mi_basedatos",
    "usuario" => "admin",
    "contraseña" => "secreto"
];

Al utilizar arrays asociativos, se mejora la claridad en el acceso y manipulación de los datos, ya que las claves proporcionan un contexto significativo.

Para recorrer un array asociativo, se puede emplear el bucle foreach, que facilita la iteración sobre cada par clave-valor:

<?php

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

Este código mostrará:

nombre: Carlos
apellido: Pérez
edad: 29
salario: 30000

Es importante notar que las claves de un array asociativo son sensibles a mayúsculas y minúsculas, lo que significa que "Nombre" y "nombre" se consideran claves diferentes.

Algunas funciones útiles para trabajar con arrays asociativos incluyen:

• array_keys(): retorna un array con todas las claves.
• array_values(): retorna un array con todos los valores.
• array_key_exists(): verifica si una clave específica existe en el array.
• isset(): determina si una clave está definida y su valor no es NULL.

Ejemplo de uso de estas funciones:

<?php

$claves = array_keys($precios);
$valores = array_values($precios);

if (array_key_exists("pera", $precios)) {
    echo "El precio de la pera es: {$precios['pera']}\n";
}

if (isset($empleado["departamento"])) {
    echo "Departamento: {$empleado['departamento']}\n";
} else {
    echo "El departamento no está definido.\n";
}

Los arrays asociativos pueden ser combinados con arrays multidimensionales para crear estructuras de datos más complejas y anidadas. Esto permite representar datos en forma de tablas o registros con múltiples niveles de profundidad.

Por ejemplo, un array asociativo dentro de otro array asociativo:

<?php

$usuarios = [
    "usuario1" => [
        "nombre" => "Laura",
        "correo" => "laura@example.com"
    ],
    "usuario2" => [
        "nombre" => "José",
        "correo" => "jose@example.com"
    ]
];

echo "{$usuarios['usuario1']['correo']}\n"; // Muestra "laura@example.com"

En resumen, los arrays asociativos ofrecen una forma flexible y potente de manejar conjuntos de datos donde las claves descriptivas mejoran la comprensión y manipulación de la información en las aplicaciones PHP.

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 potente 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);

Resultado:

Array
(
    [0] => Array
        (
            [nombre] => Pedro
            [edad] => 22
        )

    [1] => Array
        (
            [nombre] => Ana
            [edad] => 28
        )

    [2] => Array
        (
            [nombre] => Luis
            [edad] => 35
        )

)

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.

Iteración y recorrido de arrays

La iteración y el recorrido de arrays son fundamentales en PHP para procesar y manipular eficientemente los datos almacenados en arrays. PHP proporciona varias estructuras y funciones que facilitan el acceso y modificación de cada elemento de un array de manera sencilla.

El bucle foreach es la manera más común de recorrer los elementos de un array. Este bucle itera automáticamente sobre cada elemento, asignando su valor a una variable temporal. Por ejemplo:

<?php

$frutas = ["Manzana", "Banana", "Cereza"];

foreach ($frutas as $fruta) {
    echo "Fruta: $fruta\n";
}

En cada iteración, la variable $fruta contiene el valor del elemento actual. La salida será:

Fruta: Manzana
Fruta: Banana
Fruta: Cereza

Si es necesario acceder tanto a la clave como al valor de cada elemento, se puede utilizar la siguiente sintaxis:

<?php

$precios = [
    "manzana" => 0.5,
    "naranja" => 0.75,
    "plátano" => 0.4
];

foreach ($precios as $fruta => $precio) {
    echo "El precio de $fruta es $precio euros\n";
}

Esto es especialmente útil al trabajar con arrays asociativos. La salida será:

El precio de manzana es 0.5 euros
El precio de naranja es 0.75 euros
El precio de plátano es 0.4 euros

Para modificar directamente los valores de un array durante su recorrido, es necesario utilizar una referencia en el bucle foreach. Al anteponer & a la variable de valor, se puede alterar el array original:

<?php

$numeros = [1, 2, 3, 4, 5];

foreach ($numeros as &$numero) {
    $numero *= 2;
}

unset($numero); // Es recomendable eliminar la referencia después del bucle

print_r($numeros);

La salida será:

Array
(
    [0] => 2
    [1] => 4
    [2] => 6
    [3] => 8
    [4] => 10
)

Los bucles for y while también pueden utilizarse para recorrer arrays, especialmente cuando se trabaja con índices numéricos. Por ejemplo, utilizando for:

<?php

$letras = ["A", "B", "C", "D"];
$longitud = count($letras);

for ($i = 0; $i < $longitud; $i++) {
    echo "Índice $i: " . $letras[$i] . "\n";
}

La salida será:

Índice 0: A
Índice 1: B
Índice 2: C
Índice 3: D

Al utilizar un bucle while, se pueden aprovechar las funciones de manejo de arrays como current(), next(), reset() y key() para controlar la posición del puntero interno del array:

<?php

$animales = ["Perro", "Gato", "Ratón"];

while (($animal = current($animales)) !== false) {
    echo $animal . "\n";
    next($animales);
}

La salida será:

Perro
Gato
Ratón

Para recorrer arrays multidimensionales, se utilizan bucles anidados. Por ejemplo, para iterar sobre un array bidimensional:

<?php

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

foreach ($matriz as $fila) {
    foreach ($fila as $valor) {
        echo $valor . " ";
    }
    echo "\n";
}

La salida será:

1 2 
3 4 
5 6 

PHP proporciona funciones como array_walk() y array_map() para aplicar una función a cada elemento de un array. La función array_walk() permite ejecutar una función de usuario sobre cada par clave-valor:

<?php

$edades = ["Juan" => 25, "Ana" => 30, "Luis" => 28];

array_walk($edades, function($edad, $nombre) {
    echo "$nombre tiene $edad años\n";
});

La salida será:

Juan tiene 25 años
Ana tiene 30 años
Luis tiene 28 años

Por otro lado, array_map() devuelve un nuevo array con los resultados de aplicar una función a cada elemento:

<?php

$numeros = [1, 2, 3, 4];

$cuadrados = array_map(function($n) {
    return $n * $n;
}, $numeros);

print_r($cuadrados);

La salida será:

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

Es posible interrumpir un bucle durante la iteración utilizando las sentencias break y continue. La sentencia break termina el bucle, mientras que continue salta a la siguiente iteración:

<?php

$numeros = [1, 2, 3, 4, 5];

foreach ($numeros as $numero) {
    if ($numero == 3) {
        continue; // Salta el número 3
    }
    if ($numero == 5) {
        break; // Termina el bucle al llegar a 5
    }
    echo "Número: $numero\n";
}

La salida será:

Número: 1
Número: 2
Número: 4

Cuando es necesario asignar múltiples variables a partir de los elementos de un array durante la iteración, se puede utilizar la función list():

<?php

$coordenadas = [[1, 2], [3, 4], [5, 6]];

foreach ($coordenadas as list($x, $y)) {
    echo "X: $x, Y: $y\n";
}

La salida será:

X: 1, Y: 2
X: 3, Y: 4
X: 5, Y: 6

Para recorrer un array en orden inverso, se puede utilizar array_reverse() o ajustar el bucle para iterar desde el final:

<?php

$letras = ["A", "B", "C", "D"];
$letrasInvertidas = array_reverse($letras);

foreach ($letrasInvertidas as $letra) {
    echo "Letra: $letra\n";
}

La salida será:

Letra: D
Letra: C
Letra: B
Letra: A

Al iterar parcialmente un array, array_slice() permite extraer una porción específica:

<?php

$numeros = [10, 20, 30, 40, 50];

$subset = array_slice($numeros, 1, 3);

foreach ($subset as $numero) {
    echo "Número: $numero\n";
}

La salida será:

Número: 20
Número: 30
Número: 40

Los iteradores del SPL (Standard PHP Library) ofrecen una forma avanzada de recorrer arrays y objetos. La clase ArrayIterator permite tratar un array como un objeto que implementa la interfaz Iterator:

<?php

$frutas = new ArrayIterator(["Manzana", "Banana", "Cereza"]);

foreach ($frutas as $fruta) {
    echo "Fruta: $fruta\n";
}

Además, es importante tener en cuenta las mejores prácticas al iterar arrays, como evitar modificar la estructura del array mientras se recorre, o liberar referencias después de usarlas para prevenir problemas de memoria o comportamiento inesperado.

La comprensión profunda de las distintas formas de iterar y recorrer arrays en PHP permite manejar estructuras de datos de manera eficiente y escribir código más claro y mantenible.