1. Aufbau von Arrays
Arrays sind in PHP ein wichtiger Bestandteil. Formulardaten und URL-Parameter sind z.B. in Arrays abgelegt. Werte aus einer Datenbank werden in einem Array gespeichert. Alles was einer mathematischen Funktion entspricht wird in PHP mit einem Array dargestellt. Formal sind Arrays geordnete (nicht zu verwechseln mit sortiert) Paare von Schlüsseln und Werten. Die Schlüssel, endsprechend im englischen keys genannt, dürfen dabei nur aus Integer-Zahlen oder Strings bestehen. Die Werte sind hingegen nicht eingeschränkt, dürfen insbesondere auch ihrerseits Arrays enthalten. Ein einzelnes Element aus so einem Array verwendet man dann ganz normal wie Variablen.
2. Verwenden von Arrays
Arrays werden in PHP mit dem Sprachkonstrukt array erzeugt. Die Werte für das Array gibt man dann mit Kommatas getrennt als Parameter an.
<?php
$arr = array("foo", "bar", "bla", 5.6, false, -10, "foo", "foo", "bar", "foo");
?>
Dieses Array besitzt 10 Elemente. Die Schlüssel, oder auch Indizes (mehrzahl von Index), werden
dann automatisch bestimmt, beginnent bei 0 aufsteigend. Somit gehört zum
ersten aufgelisteten Arrayelement der Index 0, das letzte aufgelistete
Arrayelement besitzt den Index 9. Dies kann auch mit der var_dump
Funktion überprüft werden.
array(10) {
[0]=>
string(3) "foo"
[1]=>
string(3) "bar"
[2]=>
string(3) "bla"
[3]=>
float(5.6)
[4]=>
bool(false)
[5]=>
int(-10)
[6]=>
string(3) "foo"
[7]=>
string(3) "foo"
[8]=>
string(3) "bar"
[9]=>
string(3) "foo"
}
Auf ein spezielles Arrayelement greifen wir mit eckigen Klammern und dem Index zu.
<?php
$arr = array("foo", "bar", "bla", 5.6, false, -10, "foo", "foo", "bar", "foo");
echo $arr[0]; // gibt foo aus
echo $arr[3]; // gibt 5.6 aus
echo $arr[4]; // gibt nichts aus, das liegt daran das 'bool(false)' für echo zu 'string(0) ""' wird
var_dump($arr[4]); // gibt bool(false); aus
?>
Wie man sieht können gleiche Werte im Array vorhanden sein, da sie sich
im Schlüssel unterscheiden. So gibt es Arrayelemente mit dem Wert foo und
den Indizes 0, 6, 7 und 9.
Die Werte eines Arrayelements können beliebig verändert werden indem der neue Wert wie bei einer Variablen zugewiesen wird.
<?php
$arr = array("eins", "zwei");
$arr[1] = "fünf";
?>
Wenn es bereits ein Arrayelement mit dem angegebenen Index gibt so wird der alte Wert mit den neuen Wert überschrieben. Wenn es kein solches Arrayelement gibt wird ein neues Arrayelement an das Array angefügt, mit dem angegebenen Index und Wert. Damit ist es möglich zuerst ein leeres Array zu erzeugen und nachher dieses zu füllen.
<?php
$arr = array();
$arr[3] = "wert";
$arr[9] = "anderer wert";
var_dump($arr);
?>
Dieses var_dump erzeugt folgende Ausgabe.
array(2) {
[3]=>
string(4) "wert"
[9]=>
string(12) "anderer wert"
}
Hier sieht man die Arraygröße von 2, die Indizes 3 und 9
und die entsprechenden Werte wert und anderer wert. Wie
gesagt sind die Werte nicht sortiert. Aber es gibt genügend Sortierfunktionen
in PHP um Arrays zu sortieren.
Neben Zahlen können auch Strings als Schlüssel/Indizes verwendet werden.
<?php
$user = array();
$user['Name'] = 'Max Mustermann';
$user['Alter'] = 18;
$user['Wohnort'] = 'Deutschland';
echo 'Mein Name ist '.$user['Name'].', ich bin '.$user['Alter'].' Jahre alt und lebe in '.$user['Wohnort'].".\n";
var_dump($user);
?>
Die Ausgabe ist dabei wie folgt:
Mein Name ist Max Mustermann, ich bin 18 Jahre alt und lebe in Deutschland.
array(3) {
["Name"]=>
string(14) "Max Mustermann"
["Alter"]=>
int(18)
["Wohnort"]=>
string(11) "Deutschland"
}
Arrays die Strings als Indizes enthalten werden üblicherweise als assoziative Arrays bezeichnet. Im anderen Fall werden sie schlicht Array oder nummerische Arrays genannt.
Wenn bei einer Wertzuweisung der Index weggelassen wird (also nur $arr[]) so
wird automatisch als Index der bisher größte Zahlenindex +1 verwendet, jedoch minimal
der Wert 0, damit keine negativen Indizes erstellt werden (was jedoch möglich ist).
<?php
$foo = array();
$foo[] = "wert"; // Index 0 wird verwendet
$foo[] = "wert"; // Index 1 wird verwendet, höchster bisheriger Index ist 0
$foo[10] = "wert"; // Index 10, wurde angegeben
$foo[] = "wert"; // Index 11, höchster bisheriger Index ist 10
var_dump($foo);
$foo = array();
$foo[-5] = "wert"; // Index -5, wurde angegeben
$foo[] = "wert"; // Index 0, höchster bisheriger Index ist -5, neuer Index ist jedoch mindestens 0
var_dump($foo);
?>
Mit der entsprechenden Ausgabe zur Kontrolle.
array(4) {
[0]=>
string(4) "wert"
[1]=>
string(4) "wert"
[10]=>
string(4) "wert"
[11]=>
string(4) "wert"
}
array(2) {
[-5]=>
string(4) "wert"
[0]=>
string(4) "wert"
}
Die Indizes können auch innerhalb des array Konstrukts angegeben werden.
Statt dem einfachen Wert hinzuschreiben fügt man vorher noch x => ein,
wobei x der zu wählende Index ist.
<?php
$bar = array(5 => "bar", "foo");
// 2. Element bekommt den Index 6
$var = array(-10 => "abc", "xyz");
// 2. Element bekommt den Index 0, s.o.
$var = array("Name" => "Max Mustermann", "foobar");
// 2. Element bekommt den Index 0
?>
Um ein Arrayelement zu löschen wird die Funktion unset verwendet.
<?php
$arr = array();
$arr[] = "foo";
$arr[] = "bar";
$arr[] = "xyz";
unset ($arr[1]); // das Element "bar"
var_dump($arr);
?>
Die Ausgabe zeigt nun dass das Arrayelement mit dem Index 1 gelöscht
wurde, die Indizes 0 und 2 sind jedoch weiterhin vorhanden.
array(2) {
[0]=>
string(3) "foo"
[2]=>
string(3) "xyz"
}
Für Arrays können auch die Vergleichsoperatoren == und ===
verwendet werden, sowie der +-Operator. Zwei Arrays
sind gleich (==) wenn sie die selben Arrayelemente besitzen und
sind identisch (===) wenn die Arrayelemente in der selben
Reihenfolge sind und die selben Typen haben.
<?php
var_dump(array("x", "y") == array(1 => "y", 0 => "x")); // bool(true)
var_dump(array("x", "y") === array(1 => "y", 0 => "x")); // bool(false)
?>
Mit dem +-Operator können Arrays zusammengepackt werden. Bereits
verwendete Indizes werden nicht überschrieben. Wenn man alle Werte von mehrere
Arrays zusammenpacken will muss man die array_merge Funktion verwenden.
<?php
var_dump(array("x") + array("y"));
// Array mit einem Element 'x' und Index 0 (da beide Arrays den Index 0 benutzen)
var_dump(array_merge(array("x"), array("y")));
// Array mit beiden Elementen 'x' und 'y'
?>
3. Foreach-Schleifen
Für Arrays gibt es den speziellen Schleifentyp foreach. Mit diesem
Schleifentyp werden die einzelnen Arrayelemente eines Arrays durchlaufen. Eine
Foreach-Schleife beginnt mit dem Schlüsselwort foreach. Dann folgt
nach der öffnenen Klammer das Array bzw. die Variable die das Array
enthält welches durchlaufen werden soll. Danach folgt das Schlüsselwort
as und eine neue Variable. In dieser Variable wird für jeden
Schleifendurchlauf der neue Wert des nächsten Arrayelements gespeichert. Nach
der folgenden schließenden Klammer beginnt der Schleifenrumpf.
<?php
$a = array("foo", "bar", "bla");
foreach ($a as $value) {
echo $value."\n";
}
// gibt nacheinander die Werte aus dem Array aus
?>
Wenn man zusätzlich zu den Werten noch die entsprechenden Arrayindizes benötigt
muss man vor der Schleifenvariable noch $var => schreiben. Auch
hier kann der Variablennamen frei gewählt werden.
<?php
$user = array('Name' => "Max Mustermann",
'Alter' => 18,
'Wohnort' => 'Deutschland',
10 => 100);
foreach ($user as $k => $v) {
echo "Arrayelement mit dem Index '".$k."' enthält den Wert '".$v."'\n";
}
?>
Die Indizes werden z.B. dann gebraucht wenn in der Schleife Arrayelemente verändert
werden sollen. Die Schleifendurchlaufvariablen enthalten nur Kopien der
Arrayelemente. Wenn man nun ein Arrayelement verändern möchte muss man wie üblich
über array[index] zugreifen.
