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 |
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 |
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 |
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 |
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 |
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_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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 ";
}
echo "<br />";
echo "Array 2: ";
foreach ($array2 as $value)
{
echo "$value ";
}
?>
|
Array 1: 1 3 5 7 9 |
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 /> $val";
}
}
else
{
echo " $value<br />\n";
}
}
?>
|
Name: Krause |
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 |
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 |
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) |