PHP
Iteración de matriz

Sintaxis

• para ($ i = 0; $ i <count ($ array); $ i ++) {incremental_iteration (); }
• para ($ i = count ($ array) - 1; $ i> = 0; $ i--) {reverse_iteration (); }
• foreach ($ datos como $ dato) {}
• foreach ($ data como $ key => $ datum) {}
• foreach ($ data as & $ datum) {}

Observaciones

Iterando múltiples matrices juntas

A veces, dos matrices de la misma longitud deben repetirse juntas, por ejemplo:

$people = ['Tim', 'Tony', 'Turanga'];
$foods = ['chicken', 'beef', 'slurm'];

array_map es la forma más sencilla de lograr esto:

array_map(function($person, $food) {
    return "$person likes $food\n";
}, $people, $foods);

que dará salida:

Tim likes chicken
Tony likes beef
Turanga likes slurm

Esto se puede hacer a través de un índice común:

assert(count($people) === count($foods));
for ($i = 0; $i < count($people); $i++) {
    echo "$people[$i] likes $foods[$i]\n";
}

Si las dos matrices no tienen las claves incrementales, array_values($array)[$i] se puede usar para reemplazar $array[$i] .

Si ambas matrices tienen el mismo orden de claves, también puede usar un bucle foreach-with-key en una de las matrices:

foreach ($people as $index => $person) {
    $food = $foods[$index];
    echo "$person likes $food\n";
}

Las matrices separadas solo se pueden recorrer en bucle si tienen la misma longitud y también tienen el mismo nombre de clave. Esto significa que si no proporciona una clave y están numeradas, estará bien o si nombra las claves y las coloca en el mismo orden en cada matriz.

También puedes usar array_combine .

$combinedArray = array_combine($people, $foods);
// $combinedArray = ['Tim' => 'chicken', 'Tony' => 'beef', 'Turanga' => 'slurm'];

Luego puedes recorrer esto haciendo lo mismo que antes:

foreach ($combinedArray as $person => $meal) {
    echo "$person likes $meal\n";
}

Usando un índice incremental

Este método funciona al incrementar un número entero de 0 al índice más grande de la matriz.

$colors = ['red', 'yellow', 'blue', 'green'];
for ($i = 0; $i < count($colors); $i++) {
    echo 'I am the color ' . $colors[$i] . '<br>';
}

Esto también permite iterar una matriz en orden inverso sin usar array_reverse , lo que puede array_reverse sobrecarga si la matriz es grande.

$colors = ['red', 'yellow', 'blue', 'green'];
for ($i = count($colors) - 1; $i >= 0; $i--) {
    echo 'I am the color ' . $colors[$i] . '<br>';
}

Puede omitir o rebobinar el índice fácilmente utilizando este método.

$array = ["alpha", "beta", "gamma", "delta", "epsilon"];
for ($i = 0; $i < count($array); $i++) {
    echo $array[$i], PHP_EOL;
    if ($array[$i] === "gamma") {
        $array[$i] = "zeta";
        $i -= 2;
    } elseif ($array[$i] === "zeta") {
        $i++;
    }
}

Salida:

alpha
beta
gamma
beta
zeta
epsilon

Para matrices que no tienen índices incrementales (incluidas las matrices con índices en orden inverso, por ejemplo, [1 => "foo", 0 => "bar"] , ["foo" => "f", "bar" => "b"] ), esto no se puede hacer directamente. array_values o array_keys pueden usarse en su lugar:

$array = ["a" => "alpha", "b" => "beta", "c" => "gamma", "d" => "delta"];
$keys = array_keys($array);
for ($i = 0; $i < count($array); $i++) {
    $key = $keys[$i];
    $value = $array[$key];
    echo "$value is $key\n";
}

Usando punteros de matriz interna

Cada instancia de matriz contiene un puntero interno. Al manipular este puntero, diferentes elementos de una matriz se pueden recuperar de la misma llamada en diferentes momentos.

Usando each

Cada llamada a each() devuelve la clave y el valor del elemento de la matriz actual, e incrementa el puntero interno de la matriz.

$array = ["f" => "foo", "b" => "bar"];
while (list($key, $value) = each($array)) {
    echo "$value begins with $key";
}

Usando next

$array = ["Alpha", "Beta", "Gamma", "Delta"];
while (($value = next($array)) !== false) {
    echo "$value\n";
}

Tenga en cuenta que este ejemplo supone que ningún elemento de la matriz es idéntico a booleano false . Para evitar tal suposición, use la key para verificar si el puntero interno ha llegado al final de la matriz:

$array = ["Alpha", "Beta", "Gamma", "Delta"];
while (key($array) !== null) {
    echo current($array) . PHP_EOL;
    next($array);
}

Esto también facilita la iteración de una matriz sin un bucle directo:

class ColorPicker {
    private $colors = ["#FF0064", "#0064FF", "#64FF00", "#FF6400", "#00FF64", "#6400FF"];
    public function nextColor() : string {
        $result = next($colors);
        // if end of array reached
        if (key($colors) === null) {
            reset($colors);
        }
        return $result;
    }
}

Usando foreach

Bucle directo

foreach ($colors as $color) {
    echo "I am the color $color<br>";
}

Lazo con llaves

$foods = ['healthy' => 'Apples', 'bad' => 'Ice Cream'];
foreach ($foods as $key => $food) {
    echo "Eating $food is $key";
}

Bucle por referencia

En los bucles foreach de los ejemplos anteriores, la modificación del valor ( $color o $food ) no cambia directamente su valor en la matriz. Se requiere el operador & para que el valor sea un puntero de referencia al elemento en la matriz.

$years = [2001, 2002, 3, 4];
foreach ($years as &$year) {
    if ($year < 2000) $year += 2000;
}

Esto es similar a:

$years = [2001, 2002, 3, 4];
for($i = 0; $i < count($years); $i++) { // these two lines
    $year = &$years[$i];                // are changed to foreach by reference
    if($year < 2000) $year += 2000;
}

Concurrencia

Arrays PHP pueden ser modificados en cualquier forma durante la iteración y sin problemas de concurrencia (a diferencia por ejemplo de Java List s). Si la matriz se itera por referencia, las iteraciones posteriores se verán afectadas por los cambios en la matriz. De lo contrario, los cambios en la matriz no afectarán a las iteraciones posteriores (como si en su lugar estuviera iterando una copia de la matriz). Comparar bucles por valor:

$array = [0 => 1, 2 => 3, 4 => 5, 6 => 7];
foreach ($array as $key => $value) {
    if ($key === 0) {
        $array[6] = 17;
        unset($array[4]);
    }
    echo "$key => $value\n";
}

Salida:

0 => 1
2 => 3
4 => 5
6 => 7

Pero si la matriz se itera con referencia,

$array = [0 => 1, 2 => 3, 4 => 5, 6 => 7];
foreach ($array as $key => &$value) {
    if ($key === 0) {
        $array[6] = 17;
        unset($array[4]);
    }
    echo "$key => $value\n";
}

Salida:

0 => 1
2 => 3
6 => 17

El conjunto de valores-clave de 4 => 5 ya no se itera, y 6 => 7 se cambia a 6 => 17 .

Usando ArrayObject Iterator

Php arrayiterator le permite modificar y desarmar los valores mientras itera sobre matrices y objetos.

Ejemplo:

$array = ['1' => 'apple', '2' => 'banana', '3' => 'cherry'];

$arrayObject = new ArrayObject($array);

$iterator = $arrayObject->getIterator();

for($iterator; $iterator->valid(); $iterator->next()) {
    echo $iterator->key() . ' => ' . $iterator->current() . "</br>";
}

Salida:

1 => apple
2 => banana
3 => cherry