PHP Mehrdimensionale Arrays verstehen

Ein mehrdimensionales Array in PHP ist ein Array, dessen Elemente selbst wieder Arrays sind. Während ein normales (indiziertes oder assoziatives) Array jeden Schlüssel einem einzelnen Wert zuordnet, ordnet ein mehrdimensionales Array jeden Schlüssel einem ganzen verschachtelten Array zu — so lassen sich Zeilen-und-Spalten-Daten, Gitter, Bäume und gruppierte Datensätze modellieren.

Dieses Kapitel behandelt, wie zwei- und tieferdimensionale Arrays erstellt werden, wie einzelne Zellen gelesen und aktualisiert werden, wie sie mit foreach durchlaufen werden und welche gebräuchlichsten Funktionen zur Transformation bereitstehen. Außerdem werden die typischen Fallstricke erläutert, über die man beim Wechsel von flachen zu verschachtelten Arrays stolpert.

Was ist ein mehrdimensionales Array?

Ein Array wird mehrdimensional, sobald einer seiner Werte ein weiteres Array ist. Die Dimension (oder Tiefe) ist die Anzahl der Indexoperationen, die nötig sind, um einen skalaren Wert zu erreichen:

• $a[0] erreicht einen Wert → eindimensional
• $a[0][1] erreicht einen Wert → zweidimensional
• $a[0][1][2] erreicht einen Wert → dreidimensional, und so weiter.

Ein zweidimensionales Array wird oft als Tabelle visualisiert: Das äußere Array enthält Zeilen, und jedes innere Array enthält die Spalten dieser Zeile. Dieses mentale Modell ist nützlich, aber denken Sie daran, dass PHP-Arrays geordnete Maps und keine starren Gitter sind — Zeilen können unterschiedliche Längen haben, und die Schlüssel können strings statt 0, 1, 2 sein. Es gibt keine feste Tiefenbegrenzung, obwohl tief verschachtelte Daten oft ein Zeichen dafür sind, dass Objekte oder eine Datenbank besser geeignet wären.

Ein mehrdimensionales Array erstellen

Die häufigste Methode ist das Verschachteln von Array-Literalen. Jedes innere Array ist ein Element des äußeren Arrays.

Ein 2D-Array aus Strings (ein Gitter)

$grid = [
    ["value1", "value2", "value3"],
    ["value4", "value5", "value6"],
    ["value7", "value8", "value9"],
];

Im echten Code sind die inneren Arrays meist assoziativ, sodass jede Zeile wie ein Datensatz gelesen werden kann:

Eine Liste von Datensätzen

$employees = [
    ["name" => "Ann",  "title" => "Engineer", "salary" => 65000],
    ["name" => "Bob",  "title" => "Designer", "salary" => 58000],
    ["name" => "Cara", "title" => "Manager",  "salary" => 72000],
];

Sie können ein Array auch schrittweise aufbauen, was praktisch ist, wenn die Daten aus einer Schleife oder einer Datenbankabfrage stammen:

$matrix = [];
$matrix[0][0] = 1;
$matrix[0][1] = 2;
$matrix[1][0] = 3;
$matrix[1][1] = 4;
// $matrix is now [[1, 2], [3, 4]]

Auf Elemente zugreifen

Fügen Sie pro Dimension ein Klammerpaar hinzu. Der erste Index wählt das äußere Element (die Zeile) aus, der zweite das innere Element (die Spalte):

echo $grid[1][2];          // "value6" — row 1, column 2
echo $employees[2]["name"]; // "Cara"

PHP ist nullbasiert, daher ist die zweite Zeile [1] und die dritte Spalte [2]. Das Lesen eines nicht vorhandenen Schlüssels erzeugt eine Warnung und liefert null; verwenden Sie isset() oder den Null-Koaleszenz-Operator, um auf der sicheren Seite zu sein:

$salary = $employees[5]["salary"] ?? 0; // no warning if the row is missing

Über ein mehrdimensionales Array iterieren

Verschachtelte foreach-Schleifen sind der idiomatische Weg, ein 2D-Array zu durchlaufen — die äußere Schleife besucht jede Zeile, die innere Schleife die Werte dieser Zeile:

$employees = [
    ["name" => "Ann",  "salary" => 65000],
    ["name" => "Bob",  "salary" => 58000],
];

foreach ($employees as $row) {
    foreach ($row as $key => $value) {
        echo "$key: $value\n";
    }
    echo "---\n";
}

Bei tabellarischen Datensätzen ist es oft sauberer, die inneren Schlüssel direkt zu destrukturieren:

foreach ($employees as $emp) {
    echo "{$emp['name']} earns {$emp['salary']}\n";
}
// Ann earns 65000
// Bob earns 58000

Elemente ändern

Weisen Sie über den vollständigen Indexpfad zu, um eine einzelne Zelle zu aktualisieren, und fügen Sie eine neue Zeile mit [] oder array_push() an:

$employees[0]["salary"] = 70000;        // update one field
$employees[] = ["name" => "Dan", "salary" => 60000]; // add a row
array_pop($employees);                   // remove the last row

array_pop() entfernt die letzte Zeile und gibt sie zurück, sodass die beiden obigen Operationen sich gegenseitig aufheben.

Transformation mit array_map und array_column

array_map() wendet einen Callback auf jedes Element an. Um jede Zelle zu transformieren, wird ein inneres array_map über jede Zeile gemappt:

Jeden Wert in einem 2D-Array in Großbuchstaben umwandeln

$grid = [["a", "b"], ["c", "d"]];

$upper = array_map(function ($row) {
    return array_map("strtoupper", $row);
}, $grid);
// $upper is [["A", "B"], ["C", "D"]]

Wenn die inneren Arrays Datensätze sind, extrahiert array_column() ein einzelnes Feld aus jeder Zeile in ein flaches Array — ideal zum Extrahieren einer Spalte:

$employees = [
    ["name" => "Ann", "salary" => 65000],
    ["name" => "Bob", "salary" => 58000],
];

$names = array_column($employees, "name"); // ["Ann", "Bob"]
$total = array_sum(array_column($employees, "salary")); // 123000

Häufige Fallstricke

• Off-by-one-Indizes. $grid[1][2] ist die zweite Zeile, dritte Spalte — beide Indizes sind nullbasiert.
• Indexreihenfolge verwechseln. $employees[0]["name"] funktioniert; $employees["name"][0] nicht, da das äußere Array mit Ganzzahlen indiziert ist.
• Undefinierte Schlüssel. Der Zugriff auf eine fehlende Zeile oder Spalte erzeugt eine Warnung und gibt null zurück. Schützen Sie sich mit isset() oder ?? default.
• Funktionen, die Rekursion benötigen. count($arr) zählt nur die oberste Ebene — verwenden Sie count($arr, COUNT_RECURSIVE). Um jedes Blatt zu durchlaufen, verwenden Sie array_walk_recursive() statt array_walk().
• Kopiersemantik. PHP-Arrays werden als Wert kopiert, daher ändert $copy = $original; gefolgt von einer Änderung an $copy[0][0] das $original nicht — anders als bei Objektreferenzen.

Fazit

Mehrdimensionale Arrays ermöglichen es, Tabellen, Gitter und gruppierte Datensätze darzustellen, indem ein Array in einem anderen verschachtelt wird. Lesen und schreiben Sie einzelne Zellen mit verketteten []-Indizes, iterieren Sie mit verschachtelten foreach-Schleifen, und transformieren Sie Daten mit array_map(), array_column() und den rekursiven Array-Funktionen. Für einen umfassenderen Überblick über PHPs Array-Werkzeugkasten, siehe PHP Arrays.

Übungen