PHP Handbuch
Zurück | Kapitel 11. Typen | Weiter

# Arrays

Ein Array in PHP ist eigentlich eine geordnete Abbildung. Eine Abbildung ist ein Typ der Werte auf Schlüssel abbildet. Dieser Typ ist auf mehrere Arten optimiert, so dass Sie ihn auf verschiedene Weise benutzen können: als reales Array, als Liste (Vektor), als Hash-Tabelle (das ist eine praktische Anwendung einer Abbildung), als Verzeichnis, als Sammlung, als Stapel (Stack), als Warteschlange (Queue) und möglicherweise mehr. Da Sie ein weiteres PHP-Array als Wert benutzen können, ist es ziemlich einfach möglich Baumstrukturen zu simulieren.

Die Erklärung dieser Datenstrukturen sprengt den Rahmen dieses Handbuchs, aber Sie finden zumindest ein Beispiel für jede dieser Strukturen. Für weitergehende Informationen verweisen wir auf externe Literatur zu diesem breit gefächerten Thema.

## Syntax

### Angabe mit array()

Ein array kann mit Hilfe des Sparchkonstrukts array() erzeugt werden. Es benötigt eine bestimmte Anzahl von Komma-getrennten ``Schlüssel` => `Wert`` Paaren.

    array( [Schlüssel =>] Wert
         , ...
         )
    // Schlüssel kann ein Integer oder String sein
    // Wert kann irgendetwas sein

`<?php $arr = array("foo" => "bar", 12 => true); echo $arr["foo"]; // bar echo $arr[12]; // 1 ?>`

Ein `Schlüssel` kann entweder ein `integer` oder ein string sein. Wenn ein Schlüssel die Standard-Darstellung einer integer Zahl ist, wird es als solche interpretiert werden, (z.B. `"8"` wird als `8` interpretiert, während `"08"` als `"08"` interpretiert werden wird). Es gibt in PHP keine unterschiedlichen Typen indizierter oder assoziativer Arrays. Es gibt nur einen Array-Typ, der sowohl Integer- als auch String-Indizes enthalten kann.

Ein Wert kann jeder PHP-Typ sein.

`<?php $arr = array("einarray" => array(6 => 5, 13 => 9, "a" => 42)); echo $arr["einarray"][6]; // 5 echo $arr["einarray"][13]; // 9 echo $arr["einarray"]["a"]; // 42 ?>`

Falls Sie für einen Wert keinen Schlüssel angeben, wird der größte der Ganzzahl-Indizes genommen und der neue Schlüssel wird dieses Maximum + 1 sein. Falls Sie einen Schlüssel angeben dem schon ein Wert zugeordnet wurde, wird dieser Wert überschrieben.

`<?php // Dieses Array ist dasselbe wie ... array(5 => 43, 32, 56, "b" => 12); // ... dieses Array array(5 => 43, 6 => 32, 7 => 56, "b" => 12); ?>`

Warnung
Ab PHP 4.3.0 hat sich die oben beschriebene Generierung von Indizes geändert. Wenn Sie etwas an ein Array anhängen, in dem der größte Schlüssel negativ ist, wird der nächste Schlüssel jetzt Null (`0`) sein. Davor wäre der neue Index, genauso wie bei positiven Indizes, der größte vorhandene Schlüssel + 1 gewesen.

Wenn Sie `TRUE` als Schlüssel benutzen, wird dies als Schlüssel vom Typ integer `1` ausgewertet. Benutzen Sie `FALSE` als Schlüssel, wird dies als Schlüssel vom Typ integer `0` ausgewertet. Die Benutzung von `NULL` als Schlüssel führt dazu, dass der Schlüssel als leerer String gewertet wird. Verwenden Sie einen leeren String als Schlüssel, wird ein Schlüssel mit einem leeren String und seinem Wert erzeugt (oder überschrieben). Das entspricht nicht der Verwendung von leeren Klammern.

Sie können keine Arrays oder Objekte als Schlüssel benutzen. Der Versuch wird mit einer Warnung enden: `Illegal offset type`.

### Erzeugen / Verändern mit der eckigen Klammer-Syntax

Sie können ein bestehendes Array durch explizites Zuweisen von Werten verändern.

Weisen Sie dem Array Werte zu indem Sie den Schlüssel in eckigen Klammern angeben. Sie können den Schlüssel auch weglassen. In diesem Fall schreiben Sie einfach ein leeres Klammerpaar ("`[]`") hinter den Variablennamen.

    $arr[Schlüssel] = Wert;
    $arr[] = Wert;
    // Schlüssel kann ein integer oder ein string sein
    // Wert kann irgendetwas sein.

Falls `$arr` bis dahin nicht existiert, wird es erzeugt. Das ist also eine alternative Syntax um ein Array zu erzeugen. Um einen bestimmten Wert zu ändern, weisen Sie einfach einem Element, das Sie mit seinem Schlüssel spezifizieren, einen neuen Wert zu. Wenn Sie ein Schlüssel/Wert Paar entfernen möchten, benutzen Sie unset().

`<?php $arr = array(5 => 1, 12 => 2); $arr[] = 56; // An dieser Stelle des Skrips ist das // dasselbe wie $arr[13] = 56; $arr["x"] = 42; // Fügt dem Array ein neues Element mit // dem Schlüssel "x" hinzu unset($arr[5]); // Entfernt das Element aus dem Array unset($arr); // Löscht das komplette Array ?>`

> Anmerkung: Wie weiter oben schon erwähnt, wird, falls Sie die Klammern setzen ohne einen Schlüssel anzugeben, der größte der Integer-Indizes genommen und der neue Schlüssel wird dieses Maximum + 1 sein. Falls es noch keine Integer-Indizes gibt, wird der Schlüssel zu `0` (Null). Falls Sie einen Schlüssel angeben dem schon ein Wert zugeordnet wurde, wird dieser Wert überschrieben.

> Warnung
> Ab PHP 4.3.0 hat sich die oben beschriebene Generierung von Indizes geändert. Wenn Sie etwas an ein Array anhängen, in dem der größte Schlüssel negativ ist, wird der nächste Schlüssel jetzt Null (`0`) sein. Davor wäre der neue Index, genauso wie bei positiven Indizes, der größte vorhandene Schlüssel + 1 gewesen.

> Beachten Sie, dass der hierbei verwendete größte Integer-Schlüssel im Array zu diesem Zeitpunkt nicht vorhanden sein muss. Er muss nur irgendwann im Array existiert haben, seitdem es zum letzten Mal neu indiziert wurde. Folgendes Beispiel zur Veranschaulichung:

> `<?php
> // Wir erzeugen ein einfaches Array
> $array = array(1, 2, 3, 4, 5);
> print_r($array);
> // Nun löschen wir alle Elemente, lassen das Array selbst
> // aber intakt:
> foreach ($array as $i => $wert) {
> unset($array[$i]);
> }
> print_r($array);
> // Wir hängen ein Element an (beachten Sie, dass der neue Schlüssel 5
> // ist, statt 0, wie sie vielleicht erwarten würden).
> $array[] = 6;
> print_r($array);
> // Neu indizieren:
> $array = array_values($array);
> $array[] = 7;
> print_r($array);
> ?>`

> Obiges Beispiel würde folgende Ausgabe erzeugen:

>     Array
>     (
>         [0] => 1
>         [1] => 2
>         [2] => 3
>         [3] => 4
>         [4] => 5
>     )
>     Array
>     (
>     )
>     Array
>     (
>         [5] => 6
>     )
>     Array
>     (
>         [0] => 6
>         [1] => 7
>     )

## Nützliche Funktionen

Es gibt viele nützliche Funktionen um mit Arrays zu arbeiten. Schauen Sie unter dem Abschnitt Array Funktionen nach.

> Anmerkung: Mit unset() können Sie Schlüssel eines Arrays löschen. Halten Sie sich vor Augen, dass das Array NICHT neu indiziert wird. Wenn Sie nur "gewöhnliche Integer-Indizes" (bei Null beginnend, jeweils um eins steigend) verwenden, erreichen Sie die Neuindizierung durch Verwendung von array_values().

> `<?php $a = array(1 => 'eins', 2 => 'zwei', 3 => 'drei'); unset($a[2]); /* erzeugt ein Array das wie folgt definiert worden wäre: $a = array(1 => 'eins', 3 => 'drei'); und NICHT $a = array(1 => 'eins', 2 => 'drei'); */ $b = array_values($a); // Jetzt ist $b array(1 => 'eins', 2 =>'drei') ?>`

Die foreach Kontrollstruktur gibt es speziell für Arrays. Damit ist es leicht ein Array zu durchlaufen.

## Array do's und don'ts

### Warum ist `$foo[bar]` falsch?

Sie sollten immer Anführungszeichen für einen String-Literal-Index eines Arrays benutzen. Zum Beispiel sollten Sie $foo['bar'] und nicht $foo[bar] benutzen. Aber warum ist $foo[bar] falsch? Vieleicht kennen Sie folgende Syntax aus alten Skripts:

`<?php $foo[bar] = 'Feind'; echo $foo[bar]; // usw ?>`

Es ist falsch, funktioniert aber. Warum ist es dann falsch? Der Grund ist, dass dieser Code statt eines Strings ('bar'- beachten Sie die Anführungszeichen) eine undefinierte Konstante (bar) enthält und PHP in Zukunft Konstanten definieren könnte, die, unglücklicherweise für Ihren Code, den gleichen Namen verwenden. Es funktioniert, weil PHP einen bloßen String (ein String ohne Anführungszeichen, der keinem bekannten Symbol entpricht) automatisch in einen String umwandelt, der den bloßen String enthält. Wenn beispielsweise keine Konstante namens `bar` definiert ist, ersetzt es PHP durch den String `'bar'` und verwendet diesen.

> Anmerkung: Das bedeutet nicht, dass Schlüssel immer in Anführungszeichen gesetzt werden müssen. Wenn Sie nämlich Schlüssel, die Konstanten oder Variablen sind, in Anführungszeichen setzen, werden diese von PHP nicht ausgewertet.

> `<?php error_reporting(E_ALL); ini_set('display_errors', true); ini_set('html_errors', false); // Ein einfaches Array: $array = array(1, 2); $anzahl = count($array); for ($i = 0; $i < $anzahl; $i++) { echo "\nÜberprüfe $i: \n"; echo "Schlecht: " . $array['$i'] . "\n"; echo "Gut: " . $array[$i] . "\n"; echo "Schlecht: {$array['$i']}\n"; echo "Gut: {$array[$i]}\n"; } ?>`

> Anmerkung: Obiges Beispiel würde folgende Ausgabe erzeugen:

>     Überprüfe 0:
>     Notice: Undefined index:  $i in /path/to/script.html on line 9
>     Schlecht:
>     Gut: 1
>     Notice: Undefined index:  $i in /path/to/script.html on line 11
>     Schlecht:
>     Gut: 1

>     Überprüfe 1:
>     Notice: Undefined index:  $i in /path/to/script.html on line 9
>     Schlecht:
>     Gut: 2
>     Notice: Undefined index:  $i in /path/to/script.html on line 11
>     Schlecht:
>     Gut: 2

Weitere Beispiele zur Veranschaulichung dieses Sachverhalts:

`<?php
// Wir lassen uns alle Fehlermeldungen anzeigen
error_reporting(E_ALL);
$arr = array('obst' => 'Apfel', 'gemuese' => 'Karotte');
// Richtig
print $arr['obst']; // Apfel
print $arr['gemuese']; // Karotte
// Falsch. Es funktioniert, gibt aber wegen der undefinierten
// Konstante namens obst auch einen PHP-Fehler der Stufe E_NOTICE
// aus:
//
// Notice: Use of undefined constant obst - assumed 'obst' in...
print $arr[obst]; // Apfel
// Definieren wir nun eine Konstante um zu veranschaulichen was
// passiert. Wir weisen einer Konstanten namens obst den Wert
// 'gemuese' zu.
define('obst', 'gemuese');
// Beachten Sie jetzt den Unterschied
print $arr['obst']; // Apfel
print $arr[obst]; // Karotte
// Folgendes ist in Ordnung, weil es innerhalb eines Strings ist.
// Innerhalb eines Strings wird nicht nach Konstanten gesucht und
// deshalb gibt es hier auch keinen E_NOTICE-Fehler.
print "Hallo $arr[obst]"; // Hallo Apfel
// Eine Ausnahme: innerhalb von Strings ermöglichen {Klammern}
// um Arrays, dass nach Konstanten gesucht wird
print "Hallo {$arr[obst]}"; // Hallo Karotte
print "Hallo {$arr['obst']}"; // Hallo Apfel
// Das funktioniert nicht und ergibt in etwa folgenden Parser-Fehler:
// Parse error: parse error, expecting T_STRING' or T_VARIABLE' or T_NUM_STRING'
// Das gilt natürlich auch für die Verwendung von Autoglobalen in
// Strings
print "Hallo $arr['obst']";
print "Hallo $_GET['foo']";
// Eine andere Möglichkeit ist die Verkettung
print "Hallo " . $arr['obst']; // Hallo Apfel
?>`

Wenn Sie error_reporting() auf Fehler der Stufe `E_NOTICE` einstellen (beispielsweise durch setzen auf `E_ALL`), werden Sie diese Fehlermeldungen zu sehen bekommen. Standardmäßig ist error_reporting so eingestellt, dass sie nicht angezeigt werden.

Wie im Abschnitt Syntax ausgeführt, muss zwischen den eckigen Klammern ('`[`' und '`]`') ein Ausdruck stehen. Das heißt, dass Sie Dinge ähnlich diesen schreiben können:

`<?php echo $arr[somefunc($bar)]; ?>`

Das ist ein Beispiel dafür, wie Sie den Rückgabewert einer Funktion als Array-Index verwenden können. Ebenso kennt PHP Konstanten. Vielleicht haben Sie die `E_*` Konstanten schon einmal gesehen.

`<?php $error_descriptions[E_ERROR] = "Ein schwerwiegender Fehler ist aufgetreten"; $error_descriptions[E_WARNING] = "PHP hat eine Warnung ausgegeben"; $error_descriptions[E_NOTICE] = "Das ist nur eine informelle Notiz"; ?>`

Beachten Sie, dass `E_ERROR` ebenso ein gültiger Bezeichner ist, genau wie `bar` im ersten Beispiel. Das letzte Beispiel entspricht aber tatsächlich dem folgendem Code:

`<?php $error_descriptions[1] = "Ein schwerwiegender Fehler ist aufgetreten"; $error_descriptions[2] = "PHP hat eine Warnung ausgegeben"; $error_descriptions[8] = "Das ist nur eine informelle Notiz"; ?>`

weil `E_ERROR` gleich `1` ist, usw.

Wie schon in den obigen Beispielen erklärt wurde, funktioniert `$foo[bar]` zwar, ist aber falsch. Es funktioniert, weil `bar` aufgrund seiner Syntax als Konstante ausgewertet wird. In diesem Fall jedoch existiert keine Konstane mit dem Namen `bar`. PHP nimmt an, dass Sie `bar` wörtlich gemeint haben, wie den String `'bar'`, aber vergessen haben, die Anführungszeichen zu setzen.

#### Aber warum ist es schlecht?

Eines Tages könnte sich das PHP-Team entscheiden eine weitere Konstante oder ein Schlüsselwort hinzuzufügen oder Sie könnten eine weitere Konstante in Ihre Anwendung einfügen. Und dann geraten Sie in Schwierigkeiten. Zum Beispiel können Sie bereits die Wörter `empty` und `default` auf diese Art nicht benutzen, weil es speziele Schlüsselwörter sind.

> Anmerkung: Um es nochmals zu wiederholen, innerhalb eines Strings in doppelten Anführungszeichen ist es zulässig, Array-Indizes ohne Anführungszeichen zu schreiben, weshalb `"$foo[bar]"` gültig ist. Schauen Sie sich für Einzelheiten darüber, warum das so ist, obige Beispiele und den Abschnitt über Variablen-Analyse in Strings an.

## Umwandlung nach array

Für die Typen Integer, Float, String, Boolean und Resource gilt: wenn Sie einen Wert in ein Array umwandeln, bekommen Sie ein Array mit einem Element (mit Index 0), das der skalare Wert ist, den Sie anfangs hatten.

Wenn Sie ein Objekt in ein Array umwandeln, bekommen Sie die Eigenschaften (Mitgliedsvariablen) des Objekts als Elemente des Arrays. Die Schlüssel sind die Namen der Mitgliedsvariablen.

Wenn Sie einen `NULL`-Wert in ein Array umwandeln, bekommen Sie ein leeres Array.

## Vergleiche

Arrays können Sie mit der Funktion array_diff() und mit den Array Operatoren vergleichen.

## Beispiele

Der Array-Typ in PHP ist sehr vielseitig. Hier folgen einige Beispiele um Ihnen die Mächtigkeit von Arrays zu veranschaulichen.

`<?php
// Das hier
$a = array('Farbe' => 'rot',
'Geschmack' => 'süß',
'Form' => 'rund',
'Name' => 'Apfel',
4 // Schlüssel ist 0
);
// ist komplett gleichwertig mit
$a['Farbe'] = 'rot';
$a['Geschmack'] = 'süß';
$a['Form'] = 'rund';
$a['Name'] = 'Apfel';
$a[] = 4; // Schlüssel ist 0
$b[] = 'a';
$b[] = 'b';
$b[] = 'c';
/* ergibt das Array: array(0 => 'a', 1 => 'b', 2 => 'c'),
oder einfacher: array('a', 'b', 'c')
*/
?>`

Beispiel 11-4. Verwenden von array()

`<?php
// Array als (Eigenschafts-)Abbildung
$map = array('version' => 4,
'OS' => 'Linux',
'Sprache' => 'englisch',
'short_tags' => true
);
// strikt numerische Schlüssel
$array = array(7,
8,
0,
156,
-10,
);
// Dies entspricht: array(0 => 7, 1 => 8, ...)
// wechselnde Schlüssel
$wechselnd = array( 10, // Schlüssel: 0
5 => 6,
3 => 7,
'a' => 4,
11, // Schlüssel: 6 (Maximum der Integer-Indices war 5)
'8' => 2, // Schlüssel: 8 (integer!)
'02' => 77, // Schlüssel: '02'
0 => 12 // 10 wird mit dem neuen Wert 12 überschrieben
);
// leeres Array
$leer = array();
?>`

Beispiel 11-5. Sammlung

`<?php $farben = array('rot', 'blau', 'grün', 'gelb'); foreach ($farben as $farbe) { echo "Gefällt Ihnen $farbe?\n"; } ?>`

Ausgabe:

    Gefällt Ihnen rot?
    Gefällt Ihnen blau?
    Gefällt Ihnen grün?
    Gefällt Ihnen gelb?

Beachten Sie, dass es gegenwärtig nicht möglich ist die Werte eines Arrays direkt in einer solchen Schleife zu ändern. Eine Lösung ist folgendes:

Beispiel 11-6. Sammlung

`<?php foreach ($farben as $schluessel => $farbe) { // funktioniert nicht: //$farbe = strtoupper($farbe); // funktioniert: $farben[$schluessel] = strtoupper($farbe); } print_r($farben); ?>`

Ausgabe:

    Array
    (
        [0] => ROT
        [1] => BLAU
        [2] => GRÜN
        [3] => GELB
    )

Dieses Beispiel erzeugt ein Array, dessen Schlüssel bei eins beginnt.

Beispiel 11-7. 1-basierter Index

`<?php $erstes_viertel = array(1 => 'Januar', 'Februar', 'März'); print_r($erstes_viertel); ?>`

Ausgabe:

    Array
    (
        [1] => 'Januar'
        [2] => 'Februar'
        [3] => 'März'
    )

Beispiel 11-8. Füllen eines Arrays

`<?php // Füllen eines Arrays mit allen Inhalten eines Verzeichnisses $handle = opendir('.'); while (false !== ($datei = readdir($handle))) { $dateien[] = $datei; } closedir($handle); ?>`

Arrays sind geordnet. Diese Ordnung können Sie mit Hilfe verschiedener Sortierfunktionen verändern. Für mehr Informationen schauen Sie unter dem Abschnitt zu den Array Funktionen nach. Die Anzahl der Elemente in einem Array können Sie mit der Funktion count() zählen.

Beispiel 11-9. Sortieren eines Arrays

`<?php sort($dateien); print_r($dateien); ?>`

Weil der Wert eines Arrays alles sein kann, kann dieser Wert wiederum ein Array sein. Somit können Sie rekursive und multidimensionale Arrays erzeugen.

Beispiel 11-10. Rekursive and multidimensionale Arrays

`<?php
$fruits = array ("früchte" => array("a" => "Orange",
"b" => "Banane",
"c" => "Apfel"
),
"nummern" => array(1,
2,
3,
4,
5,
6
),
"löcher" => array( "erstens",
5 => "zweitens",
"drittens"
)
);
// Ein paar Beispiele zum Ansprechen der Werte aus obigem Array
echo $fruits["löcher"][5]; // gibt "zweitens" aus
echo $fruits["früchte"]["a"]; // gibt "Orange" aus
unset($fruits["löcher"][0]); // entfernt "erstens"
// Erzeugen eines neuen mehrdimensionalen Arrays
$saefte["Apfel"]["gruen"] = "gut";
?>`

Sie sollten wissen, dass beim Zuweisen eines Arrays die Werte immer kopiert werden. Um ein Array als Referenz zu kopieren, müssen Sie den Referenz-Operator verwenden.

`<?php $arr1 = array(2, 3); $arr2 = $arr1; $arr2[] = 4; // $arr2 wird verändert, // $arr1 ist immer noch array(2, 3) $arr3 = &$arr1; $arr3[] = 4; // nun sind $arr1 und $arr3 gleich ?>`

Zurück | Zum Anfang | Weiter
Strings / Zeichenketten | Nach oben | Objekte