PHP
Array-Iteration

Syntax

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

Bemerkungen

Mehrere Arrays zusammen iterieren

Manchmal müssen zwei Arrays der gleichen Länge zusammen iteriert werden, zum Beispiel:

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

array_map ist der einfachste Weg, dies zu erreichen:

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

welche ausgegeben werden:

Tim likes chicken
Tony likes beef
Turanga likes slurm

Dies kann über einen gemeinsamen Index erfolgen:

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

Wenn die beiden Arrays nicht über die inkrementellen Schlüssel verfügen, können array_values($array)[$i] verwendet werden, um $array[$i] zu ersetzen.

Wenn beide Arrays die gleiche Reihenfolge der Schlüssel haben, können Sie auch eine foreach-with-key-Schleife für eines der Arrays verwenden:

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

Separate Arrays können nur durchgeschleift werden, wenn sie dieselbe Länge haben und auch denselben Schlüsselnamen haben. Das bedeutet, wenn Sie keinen Schlüssel angeben und diese nummeriert sind, werden Sie in Ordnung sein, oder wenn Sie die Schlüssel benennen und in jedem Array in derselben Reihenfolge angeben.

Sie können auch array_combine .

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

Dann können Sie das wie folgt durchlaufen:

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

Verwenden eines inkrementellen Index

Bei dieser Methode wird eine Ganzzahl von 0 auf den größten Index im Array erhöht.

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

Dies ermöglicht auch die Iteration eines Arrays in umgekehrter Reihenfolge ohne die Verwendung von array_reverse Dies kann zu einem Overhead führen, wenn das Array groß ist.

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

Mit dieser Methode können Sie den Index problemlos überspringen oder zurückspulen.

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

Ausgabe:

alpha
beta
gamma
beta
zeta
epsilon

Bei Arrays, die keine inkrementale Indizes (einschließlich Arrays mit Indizes in umgekehrter Reihenfolge, beispielsweise [1 => "foo", 0 => "bar"] , ["foo" => "f", "bar" => "b"] ) kann dies nicht direkt erfolgen. array_values können array_values oder array_keys verwendet werden:

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

Verwendung interner Arrayzeiger

Jede Array-Instanz enthält einen internen Zeiger. Durch die Bearbeitung dieses Zeigers können verschiedene Elemente eines Arrays zu unterschiedlichen Zeitpunkten aus demselben Aufruf abgerufen werden.

Mit each

Jeder Aufruf von each() gibt den Schlüssel und den Wert des aktuellen Arrayelements zurück und inkrementiert den internen Arrayzeiger.

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

Mit next

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

Beachten Sie, dass in diesem Beispiel angenommen wird, dass keine Elemente im Array mit boolean false identisch sind. Um diese Annahme zu verhindern, verwenden Sie die key , um zu überprüfen, ob der interne Zeiger das Ende des Arrays erreicht hat:

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

Dies erleichtert auch die Iteration eines Arrays ohne direkte Schleife:

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

Foreach verwenden

Direkte Schleife

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

Schleife mit den Tasten

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

Nach Referenz durchlaufen

In den foreach Schleifen in den obigen Beispielen ändert das direkte Ändern des Werts ( $color oder $food ) seinen Wert im Array nicht. Der Operator & ist erforderlich, damit der Wert ein Referenzzeiger auf das Element im Array ist.

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

Das ist ähnlich wie:

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

Parallelität

PHP-Arrays können während der Iteration ohne Parallelitätsprobleme beliebig modifiziert werden (im Gegensatz zu Java- List ). Wenn das Array durch Verweis iteriert wird, werden spätere Iterationen durch Änderungen am Array beeinflusst. Andernfalls wirken sich Änderungen an dem Array nicht auf spätere Iterationen aus (als würden Sie stattdessen eine Kopie des Arrays durchlaufen). Vergleichen Sie die Schleife nach dem Wert:

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

Ausgabe:

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

Aber wenn das Array mit Bezug iteriert wird,

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

Ausgabe:

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

Der Schlüsselwertsatz von 4 => 5 wird nicht mehr iteriert und 6 => 7 wird in 6 => 17 geändert.

ArrayObject Iterator verwenden

Mit dem PHP-Arrayiterator können Sie die Werte ändern und die Einstellung aufheben, während Sie Arrays und Objekte durchlaufen.

Beispiel:

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

Ausgabe:

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