PHP
Matrix iteratie

Syntaxis

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

Opmerkingen

Meerdere arrays samen herhalen

Soms moeten twee arrays van dezelfde lengte samen worden herhaald, bijvoorbeeld:

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

array_map is de eenvoudigste manier om dit te bereiken:

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

welke zal uitvoeren:

Tim likes chicken
Tony likes beef
Turanga likes slurm

Dit kan via een gemeenschappelijke index:

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

Als de twee arrays geen incrementele sleutels hebben, kunnen array_values($array)[$i] worden gebruikt om $array[$i] te vervangen.

Als beide arrays dezelfde volgorde van toetsen hebben, kunt u ook een foreach-with-key lus gebruiken op een van de arrays:

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

Afzonderlijke arrays kunnen alleen worden doorgelust als ze dezelfde lengte hebben en dezelfde sleutelnaam hebben. Dit betekent dat als u geen sleutel opgeeft en ze zijn genummerd, het goed komt, of als u de sleutels een naam geeft en ze in dezelfde volgorde in elke array plaatst.

U kunt ook array_combine .

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

Dan kun je dit herhalen door hetzelfde te doen als eerder:

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

Een incrementele index gebruiken

Deze methode werkt door een geheel getal te verhogen van 0 tot de grootste index in de array.

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

Dit maakt het ook mogelijk om een array in omgekeerde volgorde te herhalen zonder array_reverse , wat kan resulteren in overhead als de array groot is.

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

Met deze methode kunt u de index eenvoudig overslaan of terugspoelen.

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

Output:

alpha
beta
gamma
beta
zeta
epsilon

Voor arrays die geen incrementele indices hebben (inclusief arrays met indices in omgekeerde volgorde, bijvoorbeeld [1 => "foo", 0 => "bar"] , ["foo" => "f", "bar" => "b"] ), dit kan niet rechtstreeks worden gedaan. array_values of array_keys kunnen in plaats daarvan worden gebruikt:

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

Interne array-aanwijzers gebruiken

Elke arrayinstantie bevat een interne aanwijzer. Door deze aanwijzer te manipuleren, kunnen verschillende elementen van een array op verschillende tijdstippen uit dezelfde aanroep worden opgehaald.

Gebruik each

Elke aanroep van each() retourneert de sleutel en de waarde van het huidige array-element en verhoogt de interne array-aanwijzer.

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

next

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

Merk op dat in dit voorbeeld wordt aangenomen dat geen elementen in de array identiek zijn aan Boolean false . Om een dergelijke veronderstelling te voorkomen, gebruikt u de key om te controleren of de interne aanwijzer het einde van de array heeft bereikt:

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

Dit vergemakkelijkt ook het itereren van een array zonder een directe lus:

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 gebruiken

Directe lus

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

Lus met sleutels

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

Lus op referentie

In de foreach lussen in de bovenstaande voorbeelden verandert het wijzigen van de waarde ( $color of $food ) niet direct de waarde in de array. De operator & is vereist zodat de waarde een verwijzing naar het element in de array is.

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

Dit is vergelijkbaar met:

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

samenloop

PHP-arrays kunnen tijdens iteratie op elke manier worden gewijzigd zonder gelijktijdigheidsproblemen (in tegenstelling tot bijvoorbeeld Java- List ). Als de array wordt herhaald door verwijzing, worden latere iteraties beïnvloed door wijzigingen in de array. Anders hebben de wijzigingen in de array geen invloed op latere iteraties (alsof u in plaats daarvan een kopie van de array itereert). Vergelijk looping op waarde:

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

Output:

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

Maar als de array wordt herhaald met verwijzing,

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

Output:

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

De sleutel / waardenset van 4 => 5 wordt niet meer herhaald en 6 => 7 wordt gewijzigd in 6 => 17 .

ArrayObject Iterator gebruiken

Met Php-arrayiterator kunt u de waarden wijzigen en uitschakelen terwijl u over arrays en objecten itereert.

Voorbeeld:

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

Output:

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