PHP
Itération de tableau

Syntaxe

• pour ($ i = 0; $ i <count ($ array); $ i ++) {incremental_iteration (); }
• for ($ i = count ($ array) - 1; $ i> = 0; $ i--) {reverse_iteration (); }
• foreach ($ data en $ datum) {}
• foreach ($ data en tant que $ key => $ datum) {}
• foreach ($ data as & $ datum) {}

Remarques

Itérer plusieurs tableaux ensemble

Parfois, deux tableaux de même longueur doivent être itérés ensemble, par exemple:

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

array_map est le moyen le plus simple d'y parvenir:

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

qui produira:

Tim likes chicken
Tony likes beef
Turanga likes slurm

Cela peut être fait via un index commun:

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

Si les deux tableaux n'ont pas les clés incrémentielles, array_values($array)[$i] peut être utilisé pour remplacer $array[$i] .

Si les deux tableaux ont le même ordre de clés, vous pouvez également utiliser une boucle foreach-with-key sur l'un des tableaux:

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

Les tableaux séparés ne peuvent être mis en boucle que s'ils ont la même longueur et ont le même nom de clé. Cela signifie que si vous ne fournissez pas de clé et que celles-ci sont numérotées, tout ira bien ou si vous nommez les clés et les mettez dans le même ordre dans chaque tableau.

Vous pouvez également utiliser array_combine .

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

Ensuite, vous pouvez parcourir ceci en procédant comme avant:

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

Utilisation d'un index incrémentiel

Cette méthode fonctionne en incrémentant un entier de 0 au plus grand index du tableau.

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

Cela permet également d'itérer un tableau dans l'ordre inverse sans utiliser array_reverse , ce qui peut entraîner une surcharge si le tableau est volumineux.

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

Vous pouvez ignorer ou rembobiner l'index facilement en utilisant cette méthode.

$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++;
    }
}

Sortie:

alpha
beta
gamma
beta
zeta
epsilon

Pour les tableaux sans index incrémentiel (y compris les tableaux avec des index dans l'ordre inverse, par exemple [1 => "foo", 0 => "bar"] , ["foo" => "f", "bar" => "b"] ), cela ne peut pas être fait directement. array_values ou array_keys peuvent être utilisés à la place:

$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";
}

Utilisation de pointeurs de tableau internes

Chaque instance de tableau contient un pointeur interne. En manipulant ce pointeur, différents éléments d’un tableau peuvent être extraits du même appel à des moments différents.

En utilisant each

Chaque appel à each() renvoie la clé et la valeur de l'élément de tableau en cours et incrémente le pointeur de tableau interne.

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

Utiliser next

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

Notez que cet exemple suppose qu'aucun élément du tableau n'est identique à booléen false . Pour éviter une telle hypothèse, utilisez la key pour vérifier si le pointeur interne a atteint la fin du tableau:

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

Cela facilite également l'itération d'un tableau sans boucle directe:

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;
    }
}

Utiliser foreach

Boucle directe

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

Boucle avec les clés

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

Boucle par référence

Dans les boucles foreach dans les exemples ci-dessus, la modification directe de la valeur ( $color ou $food ) ne change pas sa valeur dans le tableau. L'opérateur & est requis pour que la valeur soit un pointeur de référence sur l'élément du tableau.

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

Ceci est similaire à:

$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;
}

Concurrence

Les tableaux PHP peuvent être modifiés de quelque manière que ce soit pendant l'itération sans problèmes de concurrence (contrairement à la List Java par exemple). Si le tableau est itéré par référence, les itérations ultérieures seront affectées par les modifications apportées au tableau. Sinon, les modifications apportées au tableau n'affecteront pas les itérations ultérieures (comme si vous répétiez une copie du tableau). Comparer le bouclage par valeur:

$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";
}

Sortie:

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

Mais si le tableau est itéré avec référence,

$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";
}

Sortie:

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

L'ensemble valeur-clé de 4 => 5 n'est plus itéré et 6 => 7 est remplacé par 6 => 17 .

Utiliser ArterObject Iterator

Le arrayiterator de PHP vous permet de modifier et de désactiver les valeurs tout en itérant sur des tableaux et des objets.

Exemple:

$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>";
}

Sortie:

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