PHP
Iteracja tablicy

Składnia

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

Uwagi

Iterowanie wielu tablic razem

Czasami trzeba razem iterować dwie tablice tej samej długości, na przykład:

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

array_map to najprostszy sposób na osiągnięcie tego:

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

który wyświetli:

Tim likes chicken
Tony likes beef
Turanga likes slurm

Można to zrobić za pomocą wspólnego indeksu:

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

Jeśli dwie tablice nie mają kluczy przyrostowych, można array_values($array)[$i] aby zastąpić $array[$i] .

Jeśli obie tablice mają tę samą kolejność kluczy, możesz także użyć pętli foreach z kluczem na jednej z tablic:

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

Oddzielne tablice można zapętlać tylko wtedy, gdy mają tę samą długość i mają tę samą nazwę klucza. Oznacza to, że jeśli nie podasz klucza i są one ponumerowane, wszystko będzie dobrze, lub jeśli nadasz nazwę kluczom i umieścisz je w tej samej kolejności w każdej tablicy.

Możesz także użyć array_combine .

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

Następnie możesz przejść przez to, robiąc to samo co poprzednio:

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

Korzystanie z indeksu przyrostowego

Ta metoda polega na zwiększaniu liczby całkowitej od 0 do największego indeksu w tablicy.

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

Pozwala to również na iterację tablicy w odwrotnej kolejności bez użycia array_reverse , co może spowodować obciążenie, jeśli tablica jest duża.

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

Za pomocą tej metody można łatwo pominąć lub przewinąć indeks.

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

Wynik:

alpha
beta
gamma
beta
zeta
epsilon

Dla tablic, które nie mają indeksów przyrostowych (w tym tablic z indeksami w odwrotnej kolejności, np. [1 => "foo", 0 => "bar"] , ["foo" => "f", "bar" => "b"] ), nie można tego zrobić bezpośrednio. array_values lub array_keys może być stosowany zamiast:

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

Używanie wewnętrznych wskaźników tablicy

Każda instancja tablicy zawiera wewnętrzny wskaźnik. Manipulując tym wskaźnikiem, różne elementy tablicy można pobrać z tego samego wywołania w różnym czasie.

Za pomocą each

Każde wywołanie each() zwraca klucz i wartość bieżącego elementu tablicy i zwiększa wewnętrzny wskaźnik tablicy.

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

Korzystanie z next

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

Zauważ, że w tym przykładzie założono, że żadne elementy w tablicy nie są identyczne z wartością logiczną false . Aby temu zapobiec, użyj key aby sprawdzić, czy wskaźnik wewnętrzny osiągnął koniec tablicy:

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

Ułatwia to także iterację tablicy bez bezpośredniej pętli:

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

Korzystanie z foreach

Pętla bezpośrednia

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

Pętla z kluczami

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

Pętla przez odniesienie

W pętlach foreach w powyższych przykładach modyfikowanie wartości ( $color lub $food ) bezpośrednio nie zmienia jej wartości w tablicy. Operator & jest wymagany, aby wartość była wskaźnikiem odniesienia do elementu w tablicy.

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

Jest to podobne do:

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

Konkurencja

Tablice PHP mogą być modyfikowane w dowolny sposób podczas iteracji bez problemów z współbieżnością (w przeciwieństwie do np. List Java). Jeśli tablica jest iterowana przez odwołanie, na późniejsze iteracje będą miały wpływ zmiany w tablicy. W przeciwnym razie zmiany w tablicy nie wpłyną na późniejsze iteracje (tak jak w przypadku iteracji kopii tablicy). Porównaj zapętlenie według wartości:

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

Wynik:

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

Ale jeśli tablica jest iterowana w odniesieniu do,

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

Wynik:

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

Zestaw klucz-wartość 4 => 5 nie jest już iterowany, a 6 => 7 zmienia się na 6 => 17 .

Korzystanie z ArrayObject Iterator

Phiter arrayiterator pozwala modyfikować i usuwać wartości podczas iteracji po tablicach i obiektach.

Przykład:

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

Wynik:

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