PHP/Arrays

Aus Mikiwiki
< PHP
Wechseln zu: Navigation, Suche

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)

Von «http://mikiwiki.org/mikiwiki/index.php?title=PHP/Arrays&oldid=301»