PHP/Arrays

Das Array ist eine der vielseitigsten Formen interner Datenspeicherung in fast allen Programmier- und Skriptsprachen. Kaum ein Skript kommt ohne sie aus und und kaum eine Sprache bietet eine so umfangreiche Unterstützung wie PHP.

Arrays bilden gewissermassen Sammlungen von Variablen ab und enthalten also viele Variablenwerte. Dabei kann unter PHP jedes Arrayelement seinen eigenen Datentyp haben und auch selber ein Array sein.

Anlegen von Arrays

Das einfachste Array besitzt nur eine Dimension. Es kann beliebig viele Elemente aufnehmen, die dann als Elemente bezeichnet werden. Diese Form kann man sich gut als Tabelle mit nur einer Spalte und beliebig vielen Zeilen vorstellen. Im Gegensatz zu Datenbanken haben die Spalten jedoch keinen Namen oder Nummern - jedes Element wird beim Lesen direkt angesprochen.

Um etwa die Namen der Mitarbeiter zu speichern, kann folgende Schreibweise einer Variablenzuweisung verwendet werden. Dabei entsteht ein sogenanntes indiziertes Array - ein eindimensionales Array, das intern indiziert ist. Ein Index ist ein Verweis auf ein Element, wobei Arrays bei 0 beginnend indiziert werden.

$mitarbeiter[] = "Jens Schmitt"; ## Index: 0 $mitarbeiter[] = "Olaf Zwicker"; ## Index: 1 $mitarbeiter[] = "Kundolf Gerngross"; ## Index: 2 $mitarbeiter[] = "Paul Burckhardt"; ## Index: 3

Bei Bedarf können auch gleich die Indexwerte mit angegeben werden. Das folgende Beispiel ist gleichwertig dem vorangehenden.

$mitarbeiter[0] = "Jens Schmitt"; ## Index: 0 $mitarbeiter[1] = "Olaf Zwicker"; ## Index: 1 $mitarbeiter[2] = "Kundolf Gerngross"; ## Index: 2 $mitarbeiter[3] = "Paul Burckhardt"; ## Index: 3

Die Angabe muss aber nicht in der Reihenfolge und auch nicht lückenlos erfolgen. Wird ein Element auf einen bestimmten Index gesetzt, so fährt PHP danach mit der nächsten Ganzzahl fort, falls keine Angabe erfolgt. Im folgenden Beispiel erhalten die Mitarbeiter die Indizes 5 bis 7 und 12.

$mitarbeiter[5] = "Jens Schmitt"; ## Index: 5 $mitarbeiter[] = "Olaf Zwicker"; ## Index: 6 $mitarbeiter[] = "Kundolf Gerngross"; ## Index: 7 $mitarbeiter[12] = "Paul Burckhardt"; ## Index: 12

Alternativ kann auch das Schlüsselwort "array" verwendet werden, mit dem sich ebenso Werte zuweisen lassen. Arrays können verschachtelt werden, um etwa Arrays von Arrays von Arrays zu erzeugen. Damit lassen sich auch sehr komplexe Datenstrukturen abbilden. Dies lässt sich zwar auch mit der Klammerndarstellung bewerkstelligen, die Verwendung der Anweisung "array" ist aber meist einfacher. Aus Darstellungsgründen werden grosse Arrays meist über mehrere Zeilen geschrieben, dem PHP-Parser ist die Schreibweise hingegen gleichgültig.

<?php $mitarbeiter = array("Jens Schmitt", "Olaf Zwicker", "Kundolf Gerngross", "Paul Burckhardt"); echo "Mitarbeiter 1: $mitarbeiter[0]<br />\n"; echo "Mitarbeiter 2: $mitarbeiter[1]<br />\n"; echo "Mitarbeiter 3: $mitarbeiter[2]<br />\n"; echo "Mitarbeiter 4: $mitarbeiter[3]"; ?>

Mitarbeiter 1: Jens Schmitt Mitarbeiter 2: Olaf Zwicker Mitarbeiter 3: Kundolf Gerngross Mitarbeiter 4: Paul Burckhardt

Arrays werden auch eingesetzt, wenn mit Schlüssel-/Wertpaaren gearbeitet wird. Anstatt der fortlaufenden Indizes können auch Schlüssel (z. B. Zeichenketten) als Merkmal angegeben werden. Solche Arrays werden assoziative Arrays genannt. Das vorige Beispiel könnte auch wie folgt geschrieben werden.

$mitarbeiter["M1"] = "Jens Schmitt"; ## Index: M1 $mitarbeiter["M2"] = "Olaf Zwicker"; ## Index: M2 $mitarbeiter["M3"] = "Kundolf Gerngross"; ## Index: M3 $mitarbeiter["M4"] = "Paul Burckhardt"; ## Index: M4

Um den gesamten Inhalt eines Arrays anzusehen kann die Funktion "print_r" verwendet werden, der das Array übergeben wird. Es ist eine Hilfsfunktion zur Fehlersuche, die jede Variable vollständig ausgibt.

echo "<pre>\n"; print_r($mitarbeiter); echo "</pre>\n";

Die Ausgabe könnte wie folgt aussehen.

Array ( [M1] => Jens Schmitt [M2] => Olaf Zwicker [M3] => Kundolf Gerngross [M4] => Paul Burckhardt )

Ein leeres Array sollte mit der Anweisung "array" erzeugt werden, um sicherzustellen, dass der PHP-Interpreter es erkennt. Das ist im Sinne guten Programmierstils sinnvoll, denn falls weitere Zuweisungen misslingen, hat die Variable wenigstens den richtigen Datentyp. Die Funktion "is_array" gibt dann den Wert "TRUE" zurück. Die Anzahl der Elemente (mit "count" ermittelt) ist 0. Danach werden die Werte zugewiesen.

$meinarray = array(); $meinarray[] = "Erster Wert"; $meinarray[] = "Zweiter Wert";

Wird die Anweisung "array" eingesetzt, um ein assoziatives Array zu erzeugen, so wird zur Angabe der Schlüsselwerte der zusätzliche Operator "=>" benötigt. Das bringt zwar keinen Leistungsgewinn, der Quelltext wird aber bei konsequenter Anwendung lesbarer.

<?php $mitarbeiter = array("M1" => "Jens Schmitt", "M2" => "Olaf Zwicker", "M3" => "Kundolf Gerngross", "M4" => "Paul Burckhardt"); echo "Mitarbeiter 1: {$mitarbeiter['M1']}<br />\n"; echo "Mitarbeiter 2: {$mitarbeiter['M2']}<br />\n"; echo "Mitarbeiter 3: {$mitarbeiter['M3']}<br />\n"; echo "Mitarbeiter 4: {$mitarbeiter['M4']}<br />\n"; ?>

Mitarbeiter 1: Jens Schmitt Mitarbeiter 2: Olaf Zwicker Mitarbeiter 3: Kundolf Gerngross Mitarbeiter 4: Paul Burckhardt

Echte Vorteile ergeben sich bei der Nutzung für Daten, deren Umfang und Struktur nicht genau bekannt ist. Werden indizierte Arrays mit Zählschleifen abgefragt, so kommen nur indizierte Arrays in Betracht. Der Zugriff auf ein bestimmtes Element, dessen Index unbekannt ist, bleibt dabei verwehrt. Allerdings gibt es einige Funktionen, die beim schrittweisen Durchlaufen numerischer Arrays helfen. Beispielsweise kann ein Array mit der foreach-Schleife durchgegangen werden.

$person = array("Edison", "Wankel", "Crapper"); foreach ($person as $name) { echo "Hallo, $name<br />\n"; } $erfinder = array("Glühlampe" => "Edison", "Wankelmotor" => "Wankel", "Toilette" => "Crapper"); foreach ($erfinder as $erfindung => $erfinder) { echo "$erfinder erfand: $erfindung<br />\n"; }

Hallo, Edison Hallo, Wankel Hallo, Crapper Edison erfand: Glühlampe Wankel erfand: Wankelmotor Crapper erfand: Toilette

Der Standardoperator "+" kann auch für ein Array eingesetzt werden. Damit werden zwei Arrays kombiniert, wobei gleichnamige Indizes nicht überschrieben werden. Der bereits vorhandene Index führt dazu, dass das hinzuzufügende Element des zweiten Arrays bei der Zuweisung nicht beachtet wird. Beim folgenden Beispiel ist zu beachten, dass der Index "1" im zweiten Array nicht den im ersten überschreiben kann.

<?php $mitarbeiter1 = array(0 => "Jens Schmitt", 1 => "Olaf Zwicker"); $mitarbeiter2 = array(2 => "Kundolf Gerngross", 1 => "Paul Burckhardt"); $mitarbeiter = $mitarbeiter1 + $mitarbeiter2; echo "Mitarbeiter 1: $mitarbeiter[0]<br />\n"; echo "Mitarbeiter 2: $mitarbeiter[1]<br />\n"; echo "Mitarbeiter 3: $mitarbeiter[2]<br />\n"; echo "Mitarbeiter 4: $mitarbeiter[3]<br />\n"; ?>

Mitarbeiter 1: Jens Schmitt Mitarbeiter 2: Olaf Zwicker Mitarbeiter 3: Kundolf Gerngross Mitarbeiter 4:

Arrays und Arrayelemente löschen

Um ein Array zu löschen wird "unset" verwendet.

unset($meinarray);

Ein Array kann auch mit "array()" geleert werden. Ist eine Funktion des Skripts auf den Datentyp "array" angewiesen, so führt "unset" zu Fehlverhalten, was folgendermassen vermieden werden kann.

$meinarray = array();

Ein einzelnes Arrayelement wird trotzdem mit "unset" entfernt.

unset($meinarray[14]);

Multidimensionale Arrays

Arrays können mehrere Dimensionen haben. Im Beispiel ist eine Trennung von Vor- und Nachnamen sinnvoll. Dazu wird einfach der Befehl "array" innerhalb eines übergeordneten "array"-Befehls verwendet. Weitere Dimensionen werden dabei einfach hinter die bestehende Dimension in eckige Klammern gesetzt. Im Beispiel werden sogar indizierte und assoziative Arrays gemischt. Dabei ist immer auch daran zu denken, dass Indizes Zeichenketten sind - es sind also einfache bzw. doppelte Anführungszeichen zu setzen!

<?php $mitarbeiter = array("M1" => array("Jens", "Schmitt"), "M2" => array("Olaf", "Zwicker"), "M3" => array("Kundolf", "Gerngross"), "M4" => array("Paul", "Burckhardt") ); echo "Mitarbeiter 1: ", $mitarbeiter["M1"][0], " ", $mitarbeiter["M1"][1], "<br />\n"; echo "Mitarbeiter 2: ", $mitarbeiter["M2"][0], " ", $mitarbeiter["M2"][1], "<br />\n"; echo "Mitarbeiter 3: ", $mitarbeiter["M3"][0], " ", $mitarbeiter["M3"][1], "<br />\n"; echo "Mitarbeiter 4: ", $mitarbeiter["M4"][0], " ", $mitarbeiter["M4"][1], "<br />\n"; ?>

Mitarbeiter 1: Jens Schmitt Mitarbeiter 2: Olaf Zwicker Mitarbeiter 3: Kundolf Gerngross Mitarbeiter 4: Paul Burckhardt

Zum Anhängen neuer Einträge an das Array liegt folgende Schreibweise nahe, die allerdings nicht funktionieren wird - denn damit würde das Array überschrieben.

$mitarbeiter = array("M5" => array("Vorname", "Nachname");

Ein bestehendes zweidimensionales Arrays kann erfolgreich erweitert werden, indem der neue Schlüssel als assoziativer Index genutzt wird.

$mitarbeiter["M5"] = array("Vorname", "Nachname");

Arrayfunktionen

Folgende Funktionen stehen zur Verfügung, wenn die Arrayelemente durchlaufen werden sollen.

Funktion	Beschreibung
each	Liefert alle Arrayelemente nacheinander.
list	Überführt alle Arrayelemente in skalare Variablen.
count sizeof	Liefert die Anzahl der Elemente eines Arrays.
current pos	Aktuelle Position des Arrayzeigers.
key	Liefert einen Schlüsselwert.
end	Setzt den internen Zeiger ans Ende.
next	Setzt den internen Zeiger eins weiter.
prev	Setzt den internen Zeiger eins zurück.
reset	Setzt den internen Zeiger an den Anfang zurück.

Folgende Funktionen dienen zum Sortieren von Arrayelementen. Alle Sortierfunktionen verändern das als Parameter übergebene Array direkt. Zurückgegeben wird im Erfolgsfall "TRUE", sonst "FALSE".

Funktion	Beschreibung
natsort	Sortiert ein Array natürlich, also "2" steht vor "10". Normalerweise sortiert ein Rechner zeichenweise, dann steht "10" vor "2", weil zuerst die erste Stelle verglichen wird.
natcasesort	Sortiert ein Array wie "natsort" natürlich, beachtet dabei aber die Gross- und Kleinschreibung nicht.
arsort	(associative reverse sort) Sortiert ein Array alphabetisch rückwärts und behält die Indexzuordnung bei.
asort	(associative sort) Sortiert ein Array alphabetisch vorwärts unter Beibehaltung der Indexzuordnung.
ksort	Sortiert ein Array anhand der Schlüsselwerte.
rsort	Sortiert ein eindimensionales Array alphabetisch rückwärts.
sort	Sortiert ein eindimensionales Array alphabetisch vorwärts.
uasort	Sortiert ein assoziatives Array unter Nutzung einer selbstdefinierten Sortierfunktion und behält dabei die Indexzuordnung bei.
uksort	Sortiert ein Array unter Nutzung einer selbstdefinierten Sortierfunktion anhand der Schlüsselwerte.
usort	Sortiert ein eindimensionales Array unter Nutzung einer selbstdefinierten Sortierfunktion.
range	Gibt ein Array aus Ganzzahlen zurück, die zwischen einem Anfangs- und einem Endwert liegen.
shuffle	Bringt ein Array "durcheinander".

Folgende Funktionen basieren nicht auf der internen Zeigerverwaltung und realisieren komplexere Operationen hauptsächlich mit eindimensionalen Arrays.

Funktion	Beschreibung
array_change_key_case	Wandelt alle Elemente des übergebenen Arrays in Klein- oder Grossbuchstaben um. Die Richtung bestimmt die als zweiter Parameter übergebene Konstante "CASE_LOWER" bzw. "CASE_UPPER".
array_chunk	Zerlegt ein Array in kleinere Arrays der angegebenen Grösse.
array_count_values	Erstellt ein Array, das die Elemente des übergebenen Arrays als Schlüssel und die Häufigkeit des Auftretens als Wert enthält.
array_combine	Erstellt ein assoziatives Array aus zwei einfachen Arrays, wobei das erste die Schlüssel und das zweite die Werte liefert.
array_diff array_diff_uassoc array_diff	Bestimmung der Differenzmenge zweier Arrays.
array_diff_assoc	Bestimmung der Differenzmenge zweier Arrays, wobei auch Indizes beachtet werden.
array_diff_uassoc	Bestimmung der Differenzmenge zweier Arrays unter Verwendung einer benutzerdefinierte Funktion zur Durchführung der Operation.
array_fill	Füllt ein Array mit Werten.
array_filter	Filtert die Elemente eines Arrays unter Verwendung einer selbstdefinierten Funktion (sogenannte Callback-Funktion).
array_flip	Vertauscht Schlüssel und Wert in einem assoziativen Array.
array_intersect	Ermittelt die Schnittmenge zweier Arrays.
array_intersect	Berechnet die Durchschnittsmenge mehrerer Arrays und gibt damit die gemeinsamen Elemente zurück.
array_intersect_assoc	Ermittelt die Schnittmenge zweier Arrays und prüft zusätzlich die Indizes eines assoziativen Arrays.
array_key_exists	Prüft ob ein Schlüssel (Indexwert) in einem Array existiert.
array_keys	Gibt den Schlüssel eines indizierten Arrays als eindimensionales Array zurück.
array_map	Verknüpft mehrere Arrays anhand einer selbstdefinierten Funktion.
array_merge	Verbindet zwei oder mehrere Arrays.
array_merge_recursive	Verbindet Arrays rekursiv, wobei gleiche Schlüssel zusammengeführt werden.
array_multisort	Sortiert mehrere oder mehrdimensionale Arrays.
array_pad	Vergrössert ein Array am Anfang oder am Ende. Dabei werden die neuen Elemente mit einem Standardwert aufgefüllt.
array_pop	Entfernt das letzte Element eines Arrays und gibt es zurück. Das Array ist danach ein Element kleiner.
array_push	Fügt ein Element am Ende des Arrays hinzu. Das Array ist danach ein Element grösser.
array_rand	Gibt zufallsgesteuert ein Element eines Arrays zurück.
array_reduce	Verarbeitet die Elemente eines Arrays zu einem skalaren Wert. Dabei muss eine eigene "Reduktionsfunktion" zur Verfügung gestellt werden.
array_reverse	Dreht ein Array um. Das erste Element des Arrays steht nun am Ende, das letzte am Anfang.
array_search	Durchsucht ein Array und gibt die Indizes der Fundstellen zurück.
array_shift	Entfernt ein Element vom Anfang des Arrays und gibt es zurück. Alle Elemente rutschen eine Position nach unten. Das Array ist nun um ein Element kleiner.
array_slice	Gibt einige (bestimmte) Elemente des Arrays zurück. Die Elemente werden anhand der Position im Array ausgewählt.
array_splice	Ersetzt einige (bestimmte) Elemente des Arrays. Die durch ihre Position im Array beschriebenen Elemente werden durch bestimmte Werte ersetzt. Kann auch verwendet werden, um einen Teil des Arrays zu entfernen. Mit dieser sehr universellen Funktion können auch einige Sonderfälle anderer Funktionen nachgebildet werden. array_splice($input, count($input), 0, array($x, $y)); entspricht array_push($input, $x, $y); array_splice($input, -1); entspricht array_pop($input); array_splice($input, 0, 1); entspricht array_shift($input); array_splice($input, 0, 0, array($x, $y)); entspricht array_unshift($input, $x, $y); array_splice($input, $x, 1, $y); entspricht $a[$x]
array_udiff	Berrechnet die Differenzmenge eines Arrays.
array_udiff_assoc	Berrechnet die Differenzmenge eines Arrays und berücksichtigt auch assoziative Arrays.
array_udiff_uassoc	Berrechnet die Differenzmenge eines Arrays unter Verwendung einer benutzerdefinierte Funktion zur Durchführung der Operation.
array_unshift	Fügt mehrere Elemente am Anfang eines Arrays ein. Die Elemente werden dabei einzeln und nicht als Array übergeben. Das Array wächst dabei um mehrere Elemente.
array_unique	Entfernt doppelte Elemente in einem Array.
array_values	Liefert ein eindimensionales Array mit den Werten eines assoziativen Arrays zurück.
array_walk	Wendet eine Funktion auf alle Elemente eines Arrays an.
compact	Überführt mehrere skalare Variablen in ein Array. Als Parameter werden die Namen der Variablen angegeben.
extract	Erstellt aus einem assoziativen Array Variablen. Dabei ergeben die Schlüssel die Namen und die Werte den Inhalt der Variablen.
in_array	Untersucht ein Array auf das Vorhandensein von Elementen mit bestimmten Eigenschaften und gibt einen Booleschen Wert zurück.

Arrayfunktionen für mehrere Elemente

Oft werden Funktionen genutzt, um Elemente zu bearbeiten. Um nun eine interne oder selbstdefinierte Funktion auf alle Elemente eines Arrays anzuwenden, wird die Funktion "array_walk" verwendet. Diese Funktion arbeitet immer mit der ersten Dimension und übergibt jedes Element, gleichgültig ob Array oder nicht, an die aufgerufene Funktion. Hier könnte erneut mit "array_walk" gearbeitet werden, um die nächste Dimension aufzulösen.

<?php function print_array($element) { echo "Mitarbeiter: $element[0] $element[1]<br />\n"; } $mitarbeiter = array("M1" => array("Jens", "Schmitt"), "M2" => array("Olaf", "Zwicker"), "M3" => array("Kundolf", "Gerngross"), "M4" => array("Paul", "Burckhardt")); $mitarbeiter["M5"] = array("Vorname", "Nachname"); array_walk($mitarbeiter, "print_array"); ?>

Mitarbeiter: Jens Schmitt Mitarbeiter: Olaf Zwicker Mitarbeiter: Kundolf Gerngross Mitarbeiter: Paul Burckhardt Mitarbeiter: Vorname Nachname

Mit Hilfe der Funktion "list" werden die Elemente eines Arrays auf einzelne Variablen übertragen, was unter Umständen die Weiterverarbeitung erleichtert. Das vorige Beispiel kann damit auch wie folgt geschrieben werden. Die Funktion "list" sucht hier nach Elementen mit numerischen Indizes; im Beispiel wird "$vorname" aus "[0]" und "$nachname" aus "[1]" entnommen. Wenn andere Indizes bestimmt werden, versagt das Beispiel.

<?php function print_array($element) { list($vorname, $nachname) = $element; echo "Mitarbeiter: $vorname $nachname<br />\n"; } $mitarbeiter = array("M1" => array("Jens", "Schmitt"), "M2" => array("Olaf", "Zwicker"), "M3" => array("Kundolf", "Gerngross"), "M4" => array("Paul", "Burckhardt")); $mitarbeiter["M5"] = array("Vorname", "Nachname"); array_walk($mitarbeiter, "print_array"); ?>

Mitarbeiter: Jens Schmitt Mitarbeiter: Olaf Zwicker Mitarbeiter: Kundolf Gerngross Mitarbeiter: Paul Burckhardt Mitarbeiter: Vorname Nachname

Intern arbeiten Arrays mit einem Zeiger, der auf ein bestimmtes Element (das sogenannt aktuelle) verweist.

Bei der Funktion "each" wird ein vollständiges Schlüssel-/Wertepaar an ein eindimensionales Array übergeben. Genauer werden vier Werte übergeben, die den Schlüsseln "0", "1", "key" und "value" entsprechen. Die Anwendung ist vor allem in Schleifen sinnvoll. Sind keine Werte mehr vorhanden, so gibt die Funktion "FALSE" zurück und die Schleife endet. Das Weitersetzen des internen Zeigers erledigt "each" dabei automatisch. Die numerischen Schlüssel und die mit den Namen "key" und "value" werden dabei nicht von "each" erzeugt, sondern stellen bei assoziativen Arrays generell zur Verfügung.

<?php $mitarbeiter = array("M1" => "Jens Schmitt", "M2" => "Olaf Zwicker", "M3" => "Kundolf Gerngross", "M4" => "Paul Burckhardt"); while ($ma = each($mitarbeiter)) { echo "0: ", $ma["0"], " - "; echo "1: ", $ma["1"], ", "; echo "key: ", $ma["key"], " - "; echo "value: ", $ma["value"], "<br />\n"; } ?>

0: M1 - 1: Jens Schmitt, key: M1 - value: Jens Schmitt 0: M2 - 1: Olaf Zwicker, key: M2 - value: Olaf Zwicker 0: M3 - 1: Kundolf Gerngross, key: M3 - value: Kundolf Gerngross 0: M4 - 1: Paul Burckhardt, key: M4 - value: Paul Burckhardt

Mit der Kombination von "each" und "list" lassen sich auch komplexe Arrays sehr einfach in ihre Bestandteile zerlegen. Die Ausgabe von "each" wird dabei direkt an "list" übergeben.

<?php $mitarbeiter = array("M1" => array("Jens", "Schmitt"), "M2" => array("Olaf", "Zwicker"), "M3" => array("Kundolf", "Gerngross"), "M4" => array("Paul", "Burckhardt")); list(, $ma) = each($mitarbeiter); list($vorname, $nachname) = $ma; echo "Vorname: $vorname<br />\n"; echo "Nachname: $nachname<br />\n"; ?>

Vorname: Jens Nachname: Schmitt

Wird "each" mehrfach angewendet, so werden nacheinander alle Elemente des Arrays ausgegeben. Der auf das aktuelle Element des Arrays zeigende Zeiger wandert im Array weiter, was unter Umständen nicht erwünscht ist. Mit den Funktionen "prev" und "next" kann der Zeiger gezielt vor und zurück gesetzt werden. Mit den Funktionen "reset" und "end" wird der Zeiger auf das erste bzw. das letzte Element des Arrays gesetzt.

<?php $mitarbeiter = array("M1" => "Jens Schmitt", "M2" => "Olaf Zwicker", "M3" => "Kundolf Gerngross", "M4" => "Paul Burckhardt"); list(, $name1) = each($mitarbeiter); echo "Name: ", $name1, "<br />\n"; next($mitarbeiter); ## Zeiger wird um eins nach vorn gesetzt list(, $name2) = each($mitarbeiter); echo "Name: ", $name2, "<br />\n"; end($mitarbeiter); ## Zeiger wird ans Arrayende gesetzt prev($mitarbeiter); ## Zeiger wird um eins zurück gesetzt list(, $name1) = each($mitarbeiter); echo "Name: ", $name1, "<br />\n"; list(, $name2) = each($mitarbeiter); echo "Name: ", $name2, "<br />\n"; reset($mitarbeiter); ## Zeiger wird an den Arrayanfang gesetzt list(, $name1) = each($mitarbeiter); echo "Name: ", $name1, "<br />\n"; ?>

Name: Jens Schmitt Name: Kundolf Gerngross Name: Kundolf Gerngross Name: Paul Burckhardt Name: Jens Schmitt

Das automatische Weitersetzen des Zeigers mit der Funktion "each" ist manchmal störend. In einem solchen Fall kann die Funktion "current" angewendet werden; die Anwendung von "next" ist dann zum Durchlaufen des Arrays zwingend. Dabei ist zu beachten, dass "current" keine zusätzlichen Elemente mit den Schlüsseln 0 und 1 wiedergibt, die Funktion "list" ist deshalb nicht erforderlich.

<?php $mitarbeiter = array("M1" => "Jens Schmitt", "M2" => "Olaf Zwicker", "M3" => "Kundolf Gerngross", "M4" => "Paul Burckhardt"); $name1 = current($mitarbeiter); echo "Name: ", $name1, "<br />\n"; next($mitarbeiter); ## Zeiger wird um eins nach vorn gesetzt $name2 = current($mitarbeiter); echo "Name: ", $name2, "<br />\n"; $name1 = current($mitarbeiter); echo "Name: ", $name1, "<br />\n"; prev($mitarbeiter); ## Zeiger wird um eins zurück gesetzt $name2 = current($mitarbeiter); echo "Name: ", $name2, "<br />\n"; ?>

Name: Jens Schmitt Name: Olaf Zwicker Name: Olaf Zwicker Name: Jens Schmitt

Mit der Funktion "key" kann der Schlüssel der aktuellen Position des Zeigers allein ermittelt werden.

<?php $mitarbeiter = array("M1" => "Jens Schmitt", "M2" => "Olaf Zwicker", "M3" => "Kundolf Gerngross", "M4" => "Paul Burckhardt"); $mykey = key($mitarbeiter); echo "Eintrag $mykey: " . $mitarbeiter[$mykey] . "<br />\n"; ?>

Eintrag M1: Jens Schmitt

Erweiterte Arrayfunktionen

Zur Bearbeitung von Arrays steht in PHP5 neben den Funktionen auch die besondere Schleife "foreach" zur Verfügung, die Standardfälle sehr vereinfacht.

Das folgende Beispiel zeigt, wie die Schlüssel mit konventionellen Methoden extrahiert werden. Auch die bereits gezeigte Kombination von "each" und "list" kommt dafür in Frage.

<?php $mitarbeiter = array("Name" => "Nolte", "Ort" => "Hamburg", "PLZ" => 10000); for(reset($mitarbeiter); $key = key($mitarbeiter); next($mitarbeiter)) { echo $mitarbeiter[$key] . "<br />\n"; } ?>

Nolte Hamburg 10000

Einfacher geht es mit der Funktion "array_keys", die ein eindimensionales Array aller Schlüssel zurückgibt.

<?php $mitarbeiter = array("Name" => "Nolte", "Ort" => "Hamburg", "PLZ" => 10000); $mykeys = array_keys($mitarbeiter); foreach ($mykeys as $keyname) { echo "$keyname<br />\n"; } ?>

Name Ort PLZ

Die Funktion "array_values" wird verwendet, wenn die Werte benötigt werden.

<?php $mitarbeiter = array("Name" => "Nolte", "Ort" => "Hamburg", "PLZ" => 10000); $myvalues = array_values($mitarbeiter); foreach ($myvalues as $value) { echo "$value<br />\n"; } ?>

Nolte Hamburg 10000

Die erweiterte Syntax der "foreach"-Schleife kann das aber auch ohne diese Funktionen. Wenn wirklich nur die Schlüssel benötigt werden, ist diese Variante allerdings unsauberer programmiert. Der Sinn der Sequenz ist nicht völlig klar, was die Funktion "array_keys" im Gegensatz dazu sicherstellen kann.

<?php $mitarbeiter = array("Name" => "Nolte", "Ort" => "Hamburg", "PLZ" => 10000); foreach ($mitarbeiter as $keyname => $value) { echo "$keyname<br />\n"; } ?>

Name Ort PLZ

Die Funktion "array_reverse" dreht ein Array um. Handelt es sich um ein assoziatives Array, so werden alle Elemente umgedreht.

$mitarbeiter1 = array("Name" => "Nolte", "Ort" => "Hamburg", "PLZ" => 10000); $mitarbeiter2 = array_reverse($mitarbeiter1); foreach ($mitarbeiter2 as $keyname => $value) { echo "$keyname: $value<br />\n"; } ?>

PLZ: 10000 Ort: Hamburg Name: Nolte

Für die Weiterverarbeitung von Arrays ist es oft notwendig, dass zwei Arrays dieselbe Länge aufweisen. Die Funktion "array_pad" füllt am Anfang oder am Ende ein Array mit Standardwerten auf. Der zweite Parameter bestimmt, wieviele Elemente aufgefüllt werden. Normalerweise werden diese am Ende angefügt; ist der Wert negativ, so werden sie dagegen am Anfang eingefügt.

<?php $array1 = array(1, 3, 5, 7, 9); $groesse1 = count($array1); $array2 = array(2, 4); $groesse2 = count($array2); if ($groesse1 > $groesse2) { $array2 = array_pad($array2, $groesse1, 0); } echo "Array 1: "; foreach ($array1 as $value) { echo "$value&nbsp;&nbsp;"; } echo "<br />"; echo "Array 2: "; foreach ($array2 as $value) { echo "$value&nbsp;&nbsp;"; } ?>

Array 1: 1  3  5  7  9 Array 2: 2  4  0  0  0

Anstelle von Standardwerten kann mit der Funktion "array_merge" auch ein anderes Array angehängt werden. Welche Konstruktion die Arrays haben, ist dabei gleichgültig. Die Funktion verkraftet ausserdem mehrere Argumente. Im Beispiel wird dem "$array1" das "$array2" als weiteres Element angehängt. Die Ausgabe des kombinierten Arrays erfolgt in zwei Schleifen, wobei in der inneren mit "is_array" überprüft wird, ob wirklich ein Array im Array auftritt. Andernfalls wird der skalare Wert ausgegeben.

<?php $array1 = array("Name" => "Krause", "Ort" => "Berlin", "PLZ" => 12683); $array2 = array("ISBN-Liste" => array("3-446-21301-5", "3-446-21098-9", "3-446-19378-2", "3-8273-1427-5") ); $arrTitles = array_merge($array1, $array2); foreach ($arrTitles as $key => $value) { echo "$key: "; if (is_array($value)) { foreach($value as $val) { echo "<br />&nbsp;&nbsp;&nbsp;$val"; } } else { echo " $value<br />\n"; } } ?>

Name: Krause Ort: Berlin PLZ: 12683 ISBN-Liste:    3-446-21301-5    3-446-21098-9    3-446-19378-2    3-8273-1427-5

Die Funktion "array_slice" gibt einige (bestimmte) Elemente des Arrays zurück. Die Elemente werden anhand der Position im Array ausgewählt. Der Parameter "offset" gibt an, ab welcher Position Elemente zurückgegeben werden. Der optionale Parameter "length" gibt an, wieviele Elemente zurückgegeben werden. Ist "offset" negativ, wird vom Arrayende gezählt. Ist "length" negativ, stoppt die Auswahl nach der angegebenen Anzahl, vom Arrayende her gezählt.

array array_slice(array <input>, int <offset> [, int <length>])

<?php function remove_element($array, $from, $to) { $left = array_slice($array, 0, --$from); $right = array_slice($array, $to); $array = array_merge($left, $right); unset ($left); unset ($right); return $array; } $myarray = array("A", "B", "C", "D", "E", "F"); foreach($myarray as $element) echo "$element "; echo "<br />\n"; $myarray = remove_element($myarray, 3, 4); foreach($myarray as $element) echo "$element "; ?>

A B C D E F A B E F

Die Funktion "array_splice" ersetzt einige (bestimmte) Elemente eines Arrays. Die durch die Position im Array bezeichneten Elemente werden durch bestimmte Werte ersetzt. Die Parameter "offset" und "length" bestimmen die Position und Anzahl der zu ersetzenden Elemente in "input". Ist "offset" negativ, wird vom Arrayende gezählt. Ist "length" negativ, stoppt die Auswahl nach der angegebenen Anzahl, vom Arrayende her gezählt. Wird "replacement" angegeben, so werden die Elemente ersetzt; ansonsten werden sie gelöscht. Haben die Parameter "offset" und "length" Werte, durch die keine Elemente ausgewählt sind, so wird "replacement" dem Array hinzugefügt. Die Funktion gibt die ersetzten Elemente als Array zurück und ändert "arrayvar" direkt.

array array_splice(array <arrayvar>, int <offset> [, int <length>], [array <replacement>])

Im folgenden Beispiel werden einem Array zwei Elemente aus der Mitte entnommen; "$array" enthält danach ein Array ohne diesen beiden Elemente.

<?php $array = array("A", "B", "C", "D", "E", "F"); list($a, $b) = array_splice($array, 3, 2); echo "$a, $b "; ?>

D, E

Daten in Arrays sortieren

Mit der Funktion "asort" kann ein assoziatives Array alphabetisch sortiert und ausgegeben werden.

<?php $mitarbeiter = array("M1" => "Jens Schmitt", "M2" => "Olaf Zwicker", "M3" => "Kundolf Gerngross", "M4" => "Paul Burckhardt" ); asort($mitarbeiter); for(reset($mitarbeiter); $key = key($mitarbeiter); next($mitarbeiter)) { echo "Mitarbeiter[$key] = " . $mitarbeiter[$key] . "<br />"; } ?>

Mitarbeiter[M1] = Jens Schmitt Mitarbeiter[M3] = Kundolf Gerngross Mitarbeiter[M2] = Olaf Zwicker Mitarbeiter[M4] = Paul Burckhardt

Die Funktion "arsort" sortiert alphabetisch rückwärts. Dies bedeutet, dass zu den Elementen assoziierte Schlüsselwerte assoziativer Arrays mit verschoben werden.

Bei indizierten Arrays werden die Funktionen "sort" und "rsort" entsprechend verwendet.

Um ein Array wieder in die ursprüngliche Reihenfolge zu bringen, wird die Funktion "ksort" verwendet; sie sortiert aufsteigend nach den Schlüsseln.

ksort($mitarbeiter);

Um nicht nur alphabetisch zu sortieren, können die Funktionen "usort", "ursort" und "uksort" verwendet werden. Gegenüber den bereits beschriebenen Sortierbefehlen kann diesen Funktionen als zusätzlicher Parameter eine sogenannte Rückruffunktion (engl. callback) übergeben werden, die bestimmte Sortiermerkmale festlegt. Die Funktion muss den Sortiervorgang nach folgendem Schema durch Rückgabe eines bestimmten Codes steuern.

0	Zwei miteinander verglichenen Werte sind gleich.
1	Der zweite Parameter ist grösser als der erste.
-1	Der erste Parameter ist grösser als der zweite.

Entsprechend interpretiert PHP beim Sortiervorgang dies als Einordnungskriterium. Das folgende Skript zeigt eine Anwendung, die Einträge in einem Array nach ihrer Länge sortiert.

<?php function lencompare($a, $b) { if (strlen($a) == strlen($b)) return 0; return (strlen($a) > strlen($b)) ? -1 : 1; } $testarray = array("M1" => "Längstes Wort", "M2" => "Kurz", "M3" => "Länger", "M4" => "Weiss nicht"); usort($testarray, lencompare); while(list($key,$value) = each($testarray)) { echo "$key: $value (", strlen($value), ")<br />\n"; } ?>

0: Längstes Wort (14) 1: Weiss nicht (11) 2: Länger (7) 3: Kurz (4)