So kannst du dir in PHP Arrays ausgeben lassen

Oft speichern wir Daten innerhalb unserer Skripte in Arrays. Um diese auf einer Webseite auszugeben, haben wir vielfältige Möglichkeiten, allerdings auch das ein oder andere zu beachten.
Einige der Möglichkeiten um dir PHP Arrays ausgeben zu lassen, möchte ich dir hier näherbringen.

Einfache Ausgabe von PHP Array Elementen

Die nächstliegende Möglichkeit, ein Array als Text auszugeben, ist wohl echo. Allerdings funktioniert dies wider Erwarten mehr schlecht als recht.

$array = ['foo', 'bar', 'baz'];
echo $array;
// Array

Beim Versuch, dies zu tun, gibt PHP nämlich nur eine Warnung und den String “Array” aus.
Allerdings können wir einzelne Werte eines Arrays mittels Index, auch Schlüssel oder Key genannt, aufrufen und ausgeben.

echo $array[0];
// foo

Dazu steht uns noch die Funktion var_dump zur Verfügung, welche uns Details über das Array liefert.
Diese Funktion ist allerdings nur zur Fehlersuche geeignet, nicht zur Ausgabe für den Endnutzer unserer App.

var_dump($array);
// array(3) { [0]=> string(3) "foo" [1]=> string(3) "bar" [2]=> string(3) "baz" }

Dazu gibt es noch die Funktion print_r, welche mehr oder weniger das gleiche Ergebnis wie var_dump ausgibt, nur etwas lesbarer.

print_r($array);
// Array ( [0] => foo [1] => bar [2] => baz )

Wenn wir statt einem einfachen Array nun ein assoziatives Array übergeben, sieht die Textausgabe für var_dump und print_r wie folgt aus:

$array = ['foo'=>'asdf', 'bar'=>'wasd'];
echo $array;
var_dump($array);
// array(2) { ["foo"]=> string(4) "asdf" ["bar"]=> string(4) "wasd" }
print_r($array);
// Array ( [foo] => asdf [bar] => wasd )

Auch im assoziativen Array können wir einzelne Werte mit dem Index bzw. Schlüssel ausgeben.

echo $array['foo'];
// asdf

array_keys und array_values

Mit der Funktion array_keys kannst du aus einem bestehenden Array ein neues Array, das nur die Schlüssel enthält, erstellen.

$array = ['foo'=>'asdf', 'bar'=>'wasd'];
print_r(array_keys($array));
// Array ( [0] => foo [1] => bar )

Mit array_values kannst du das gleiche für die Werte eines Arrays tun.

$array = ['foo'=>'asdf', 'bar'=>'wasd'];
print_r(array_keys($array));
// Array ( [0] => asdf [1] => wasd )

Mit Schleifen jeden Wert des PHP Arrays ausgeben

Eine der nächstliegenden Herangehensweisen, um auf die Elemente eines Arrays zuzugreifen, ist die Verwendung von Schleifen. Im nächsten Abschnitt zeige ich dir ein paar Möglichkeiten, wie du die verschiedenen Arten von Arrays mit for und foreach durchlaufen kannst.

Einfache Arrays

Ein einfaches Array kannst du mit for durchlaufen, da PHP in diesem Fall für jeden Wert automatisch einen ganzzahligen Index erstellt, angefangen bei 0.
Dies lässt sich einfach mit der Funktion array_keys aus dem vorigen Abschnitt beweisen:

$array = ['foo', 'bar', 'baz'];
echo implode(', ', array_keys($array));
// 0, 1, 2

Demnach kannst du einfach folgendes tun:

for($i = 0; $i < count($array); $i++) {
    echo '<br>'.$array[$i];
}

Output:

foo
bar
baz

Mit foreach kannst du auf jedes Element zugreifen, ohne einen Schlüssel angeben zu müssen.

foreach($array as $element) {
      echo '<br>'.$element;
}

Output:

foo
bar
baz

Assoziative Arrays

Sogenannte assoziative Arrays sind Arrays, in denen wir den Schlüssel selbst festlegen. Das heißt auch, dass hier eine einfache for-Schleife mit Zähler nicht funktionieren würde.
Das lässt sich auch wieder mit array_keys beweisen.

$array = ['foo'=>'asdf', 'bar'=>'wasd'];
echo implode(', ', array_keys($array));
// foo, bar

Stattdessen können wir gleich foreach verwenden, um auf jedes Element zuzugreifen.

foreach($array as $element) {
    echo '<br>'.$element;
}

Output:

asdf
wasd

Mit foreach können wir sogar auf Schlüssel und Wert gleichzeitig zugreifen:

foreach($array as $key => $value) {
    echo '<br>'.$key.': '.$value;
}

Output:

foo: asdf
bar: wasd

Gemischte Arrays

Gemischte Arrays enthalten sowohl Werte, für die wir selbst einen Schlüssel angelegt haben, als auch von PHP angelegte Schlüssel.

$array = ['foo'=>'asdf', 'bar'=>'wasd', 'baz'];
echo implode(', ', array_keys($array));
// foo, bar, 0

Demnach haben wir hier ein ähnliches Problem wie mit assoziativen Arrays, wenn wir eine for-Schleife verwenden.
Die von PHP selbst festgelegten Schlüssel werden gefunden, allerdings wird statt dem Schlüssel “foo” nach “1” und statt “bar” nach “2” gesucht.
Dies resultiert natürlich in einer Fehlermeldung.

for($i = 0; $i < count($array); $i++) {
    echo '<br>'.$array[$i];
}

Output:

baz
Notice: Undefined offset: 1 in C:\xampp\htdocs\codecitrus\array_ausgeben.php on line 54
Notice: Undefined offset: 2 in C:\xampp\htdocs\codecitrus\array_ausgeben.php on line 54

Dieses Problem können wir erneut umgehen, indem wir foreach verwenden:

foreach($array as $element) {
      echo '<br>'.$element;
}  

Output:

asdf
wasd
baz

Auch hier ist es wieder möglich, Schlüssel und Wert per foreach ausgeben zu lassen:

foreach($array as $key => $value) {
    echo $key.': '.$value.'<br>';
}

Output:

foo: asdf
bar: wasd
0: baz

Mehrdimensionale Arrays

Mehrdimensionale Arrays sind Arrays, die selbst Arrays als Werte enthalten können.
Das nächste Beispiel ist ein zweidimensionales Array.
Das heißt, dass es ein äußeres Array gibt. Dieses äußere Array hat als jeden Wert ein Array.
Um nun auch alle Werte innerhalb der inneren Arrays zu erhalten, müssen wir in der foreach-Schleife eine weitere foreach-Schleife ausführen:

$aussen['foo-1'] = ['bar-1' => 'a', 'bar-2' => 'b'];  
$aussen['foo-2'] = ['baz-1' => 'aa', 'baz-2' => 'bb'];  

foreach($aussen as $schluessel => $innen) {
  echo $schluessel . '<br>';
  foreach($innen as $innerer_schluessel => $wert) {
    echo $innerer_schluessel . ': ' . $wert . '<br>';
  }
}

Output:

foo-1
bar-1: a
bar-2: b
foo-2
baz-1: aa
baz-2: bb

array_walk

Mit der Funktion array_walk kannst du ebenfalls für jedes Element eines Arrays eine Routine ausführen. Hierfür musst du nur das Array selbst übergeben und den Namen der Funktion, die verwendet werden soll.

$array = ['foo'=>'asdf', 'bar'=>'wasd', 'baz'];
function print_array($value, $key) {
    echo '<br>' . $key . ': ' . $value;
}
array_walk($array, 'print_array');

Output:

foo: asdf
bar: wasd
0: baz

array_walk akzeptiert auch noch einen dritten Parameter, der dann ebenfalls von deiner Funktion verwendet werden kann.

function print_array_1($value, $key, $more_value) {
    echo '<br>' . $key . ': ' . $value . ', ' . $more_value;
}
array_walk($array, 'print_array_1', 'CodeCitrus');

Output:

foo: asdf, CodeCitrus
bar: wasd, CodeCitrus
0: baz, CodeCitrus

Du kannst den dritten Parameter ebenfalls per Referenz übergeben. So könntest du zum Beispiel einen zusätzlichen Zähler in deine Funktion einbauen.

function print_array_2($value, $key, &$zaehler) {
    echo '<br>' . $key . ': ' . $value . ', ' . $zaehler++;
}
$i = 0;
array_walk($array, 'print_array_2', $i);

Output:

foo: asdf, 0
bar: wasd, 1
0: baz, 2

Fazit – So kannst du PHP Arrays ausgeben

Unsere Möglichkeiten, auf Schlüssel und Werte zuzugreifen sind in PHP sehr vielfältig.
Mit var_dump und print_r haben wir sehr gute Möglichkeiten zur Fehlersuche. for, foreach und array_walk machen es uns einfach, mit jedem Schlüssel und jedem Wert des Arrays zu interagieren. array_keys und array_values lassen uns ganz einfach aus einem bestehenden Array ein neues erstellen, welches nur Schlüssel oder Werte enthält.

Wenn du noch Lob, Kritik, Fragen oder Anmerkungen hast, würde ich mir wünschen, dass du mir das mit einem Kommentar mitteilst.