Arrays

Eine Liste aller Array-Funktionen findet sich im Kapitel Array-Funktionen der Dokumentation.

Ein Array ist in PHP in Wirklichkeit eine geordnete Map (Abbildung). Eine Map ist ein Typ, der Werte zu Schlüsseln zuordnet. Dieser Typ ist für einige verschiedene Nutzungsarten optimiert. Er kann als ein Array verwendet werden, als Liste (Vektor), Hash-Tabelle (eine Implementierung einer Map), Wörterbuch, Sammlung, Stack, Queue (Warteschlange) und wahrscheinlich noch als vieles anderes. Da ein Wert eines Arrays ein weiteres Array sein kann, sind auch Bäume und mehrdimensionale Arrays möglich.

Die Erläuterung dieser Datenstrukturen liegt nicht im Rahmen dieses Handbuchs, aber wenigstens ein Beispiel für jede ist hier angegeben. Um weitere Informationen zu erhalten wird auf die immense Literatur zu diesem weiten Feld verwiesen.

Syntax

Spezifizierung mittels array()

Ein Array kann durch das Sprachkonstrukt array() erzeugt werden. Dies nimmt eine beliebige Anzahl kommaseparierter Schlüssel => Wert-Paare als Parameter entgegen.

array(
    Schlüssel  => Wert,
    Schlüssel2 => Wert2,
    Schlüssel3 => Wert3,
    ...
)

Das Komma nach dem letzten Array-Element ist optional und kann weggelassen werden. Dies wird üblicherweise in einzeiligen Arrays getan, d. h.. array(1, 2) wird der Schreibweise array(1, 2, ) vorgezogen. Andererseits wird bei mehrzeiligen Arrays das Komma am Ende üblicherweise genutzt, da dies ein einfaches Hinzufügen weiterer Elemente am Ende erlaubt.

Hinweis:
Es gibt eine Kurzform der Array-Syntax, die array() durch [] ersetzt.

Beispiel #1 Ein einfaches Array

<?php
$array1 = array(
    "foo" => "bar",
    "bar" => "foo",
);

// Verwendung der verkürzten Array-Syntax
$array2 = [
    "foo" => "bar",
    "bar" => "foo",
];

var_dump($array1, $array2);
?>

Der Schlüssel kann entweder ein Integer oder ein String sein. Der Wert kann beliebige Datentypen annehmen.

Zusätzlich werden die folgenden Typkonvertierungen auf den Schlüssel angewendet:

Strings, die einen gültigen dezimalen Int enthalten, werden zum entsprechenden Int umgewandelt, es sei denn, der Zahl ist ein +-Zeichen vorangestellt. Beispielsweise wird der Schlüssel "8" tatsächlich unter 8 gespeichert. Andererseits wird "08" nicht umgewandelt, da dies kein gültiger Ganzzahlwert ist.
Floats werden ebenfalls zu Int umgewandelt, was ein Abschneiden des Dezimalbruchs zur Folge hat. Beispielsweise wird der Schlüssel 8.7 als 8 gespeichert.
Bools werden ebenfalls zu Int umgewandelt, d. h. der Schlüssel true wird unter 1 gespeichert und der Schlüssel false unter 0.
Null wird zu einem leeren String umgewandelt, d. h. der Schlüssel null wird tatsächlich unter "" gespeichert.
Werte vom Typ Array oder Objekt können nicht als Schlüssel verwendet werden. Ein Versuch, dies zu tun, wird die Warnung Illegal offset type zur Folge haben.

Wenn mehrere Elemente in einer Array-Deklaration den gleichen Schlüssel verwenden, dann wird nur der letzte verwendet und alle weiteren werden überschrieben.

Beispiel #2 Beispiel für Typumwandlung und Überschreibung

<?php
$array = array(
    1    => "a",
    "1"  => "b",
    1.5  => "c",
    true => "d",
);
var_dump($array);
?>

Das oben gezeigte Beispiel erzeugt folgende Ausgabe:

array(1) {
  [1]=>
  string(1) "d"
}

Da alle Schlüssel im obigen Beispiel zu 1 umgewandelt werden, wird der Wert dieses Elements durch jeden angegebenen Wert überschrieben und nur der letzte zugewiesene Wert "d" bleibt übrig.

Arrays können in PHP gleichzeitig Schlüssel der Typen Int und String enthalten, da PHP nicht zwischen indizierten und assoziativen Arrays unterscheidet.

Beispiel #3 Gemischte Int- und String-Schlüssel

<?php
$array = array(
    "foo" => "bar",
    "bar" => "foo",
    100   => -100,
    -100  => 100,
);
var_dump($array);
?>

Das oben gezeigte Beispiel erzeugt folgende Ausgabe:

array(4) {
  ["foo"]=>
  string(3) "bar"
  ["bar"]=>
  string(3) "foo"
  [100]=>
  int(-100)
  [-100]=>
  int(100)
}

Die Angabe des Schlüssels ist optional. Ist keiner angegeben, so wird PHP den bisher größten angegebenen Int-Schlüssel erhöhen und das Ergebnis als Schlüssel verwenden.

Beispiel #4 Indizierte Arrays ohne Schlüssel

<?php
$array = array("foo", "bar", "hello", "world");
var_dump($array);
?>

Das oben gezeigte Beispiel erzeugt folgende Ausgabe:

array(4) {
  [0]=>
  string(3) "foo"
  [1]=>
  string(3) "bar"
  [2]=>
  string(5) "hello"
  [3]=>
  string(5) "world"
}

Es ist auch möglich, den Schlüssel nur bei einigen Elementen anzugeben und bei anderen auszulassen:

Beispiel #5 Schlüssel nicht bei allen Elementen

<?php
$array = array(
         "a",
         "b",
    6 => "c",
         "d",
);
var_dump($array);
?>

Das oben gezeigte Beispiel erzeugt folgende Ausgabe:

array(4) {
  [0]=>
  string(1) "a"
  [1]=>
  string(1) "b"
  [6]=>
  string(1) "c"
  [7]=>
  string(1) "d"
}

Hier ist zu erkennen, dass dem letzten Wert "d" der Schlüssel 7 zugewiesen wurde. Dies erfolgte, da der größte vorherige ganzzahlige Schlüssel 6 war.

Beispiel #6 Beispiel für komplexe Typumwandlung und Überschreibung

Dieses Beispiel enthält alle Variationen der Typumwandlung von Schlüsseln und des Überschreibens von Elementen.

<?php
$array = array(
    1    => 'a',
    '1'  => 'b', // der Wert "a" wird mit "b" überschrieben
    1.5  => 'c', // der Wert "b" wird mit "c" überschrieben
    -1 => 'd',
    '01'  => 'e', // da dies kein Integer-String ist, wird der Schlüssel
                  // für 1 NICHT überschrieben
    '1.5' => 'f', // da dies kein Integer-String ist, wird der Schlüssel
                  // für 1 NICHT überschrieben
    true => 'g', // der Wert "c" wird mit "g" überschrieben
    false => 'h',
    '' => 'i',
    null => 'j', // der Wert "i" wird mit "j" überschrieben
    'k', // dem Wert "k" wird der Schlüssel 2 zugewiesen. Das liegt daran,
         // dass der größte ganzzahlige Schlüssel davor 1 war
    2 => 'l', // der Wert "k" wird mit "l" überschrieben
);

var_dump($array);
?>

Das oben gezeigte Beispiel erzeugt folgende Ausgabe:

array(7) {
  [1]=>
  string(1) "g"
  [-1]=>
  string(1) "d"
  ["01"]=>
  string(1) "e"
  ["1.5"]=>
  string(1) "f"
  [0]=>
  string(1) "h"
  [""]=>
  string(1) "j"
  [2]=>
  string(1) "l"
}

Beispiel #7 Beispiel mit negativem Index

Wenn ein negativer ganzzahliger Schlüssel n zugewiesen wird, stellt PHP sicher, dass als nächstes der Schlüssel n+1 zugewiesen wird.

<?php
$array = [];

$array[-5] = 1;
$array[] = 2;

var_dump($array);
?>

Das oben gezeigte Beispiel erzeugt folgende Ausgabe:

array(2) {
  [-5]=>
  int(1)
  [-4]=>
  int(2)
}

Warnung

Vor PHP 8.3.0 würde die Zuweisung eines negativen ganzzahligen Schlüssels n dazu führen, dass als nächstes der Schlüssel 0 zugewiesen wird, sodass das obige Beispiel zu diesem Ergebnis führen würde:

array(2) {
  [-5]=>
  int(1)
  [0]=>
  int(2)
}

Zugriff auf Elemente mit eckigen Klammern

Auf Elemente eines Arrays kann durch Verwendung der Syntax array[Schlüssel] zugegriffen werden.

Beispiel #8 Zugriff auf Array-Elemente

<?php
$array = array(
    "foo" => "bar",
    42    => 24,
    "multi" => array(
         "dimensional" => array(
             "array" => "foo"
         )
    )
);

var_dump($array["foo"]);
var_dump($array[42]);
var_dump($array["multi"]["dimensional"]["array"]);
?>

Das oben gezeigte Beispiel erzeugt folgende Ausgabe:

string(3) "bar"
int(24)
string(3) "foo"

Hinweis:
Vor PHP 8.0.0 konnten sowohl eckige als auch geschweifte Klammern verwendet werden, um auf die Elemente eines Arrays zuzugreifen (z. B. werden im obigen Beispiel $array[42] und array{42} auf das gleiche Element zugreifen). Die Syntax für geschweifte Klammern ist seit PHP 7.4.0 veraltet und wird seit PHP 8.0.0 nicht mehr unterstützt.

Beispiel #9 Array-Dereferenzierung

<?php
function getArray() {
    return array(1, 2, 3);
}

$secondElement = getArray()[1];

var_dump($secondElement);
?>

Hinweis:
Der Versuch, auf einen nicht definierten Arrayschlüssel zuzugreifen, entspricht dem Zugriff auf jede andere undefinierte Variable: ein Fehler der Stufe E_WARNING (der Stufe E_NOTICE vor PHP 8.0.0) wird ausgegeben und das Ergebnis ist null.

Hinweis:
Die Array-Dereferenzierung eines skalaren Werts, der kein String ist, ergibt null. Vor PHP 7.4.0 verursachte dies keine Fehlermeldung. Seit PHP 7.4.0 wird ein Fehler der Stufe E_NOTICE ausgegeben; seit PHP 8.0.0 ein Fehler der Stufe E_WARNING.

Anlegen/Ändern mit eckigen Klammern

Ein bestehendes Array kann verändert werden, indem man explizit Werte darin setzt.

Dies wird getan, indem man dem Array Werte zuweist und dabei den Schlüssel in eckigen Klammern angibt. Der Schlüssel kann dabei weggelassen werden, was ein leeres Klammernpaar ([]) ergibt.

$arr[Schlüssel] = Wert;
$arr[] = Wert;
// Schlüssel kann ein Int oder String sein
// Wert kann einen beliebigen Typen haben

Falls $arr noch nicht existiert oder auf null oder false gesetzt ist, wird es erzeugt; dies ist also eine alternative Methode, um ein Array zu erzeugen. Dieses Vorgehen wird jedoch nicht empfohlen, da, falls $arr bereits einen Wert enthält (z. B. ein String aus einer Requestvariable), dieser Wert bestehen bleibt und [] tatsächlich für den String-Zugriffs-Operator stehen kann. Es ist immer besser, eine Variable durch direkte Zuweisung zu initialisieren.

Hinweis: Seit PHP 7.1.0 löst die Anwendung des leeren Index-Operators auf eine Zeichenkette einen fatalen Fehler aus. Zuvor wurde die Zeichenkette stillschweigend in ein Array umgewandelt.

Hinweis: Seit PHP 8.1.0 ist das Erstellen eines neuen Arrays aus false-Werten veraltet. Es ist weiterhin erlaubt, ein neues Array aus null- und undefinierten Werten zu erstellen.

Um einen bestimmten Wert zu ändern, kann man dem Element anhand seines Schlüssels einen Wert zuweisen. Um ein Schlüssel-Wert-Paar zu entfernen, kann man die Funktion unset() darauf anwenden.

Beispiel #10 Verwenden von eckigen Klammern bei Arrays

<?php
$arr = array(5 => 1, 12 => 2);

$arr[] = 56;    // Dies ist dasselbe wie $arr[13] = 56;
                // an dieser Stelle im Programmablauf

$arr["x"] = 42; // Dies fügt ein neues Element zum Array
                // mit dem Schlüssel "x" hinzu

unset($arr[5]); // Dies entfernt das Element aus dem Array

var_dump($arr);

unset($arr);    // Dies löscht das gesamte Array

var_dump($arr);
?>

Hinweis:
Wie vorher bereits erwähnt, wird, wenn kein Schlüssel angegeben ist, das Maximum der bestehenden Schlüssel vom Typ Int verwendet und der neue Schlüssel wird das Maximum plus 1 sein (aber mindestens 0). Wenn noch kein Int-Schlüssel existiert wird der Schlüssel 0 (Null) verwendet.

Zu beachten ist, dass der Maximalwert der Integer-Schlüssel dafür aktuell nicht im Array existieren muss. Er muss nur zu irgendeinem Zeitpunkt im Array existiert haben, seitdem das Array zuletzt neu indiziert wurde. Das folgende Beispiel erläutert dies:
<?php // Create a simple array. $array = array(1, 2, 3, 4, 5); print_r($array); // Nun wird jeder Wert gelöscht, aber das Array selbst bleibt bestehen foreach ($array as $i => $value) { unset($array[$i]); } print_r($array); // Ein Element wird hinzugefügt // (Beachten Sie, dass der neue Schlüssel 5 ist statt 0) $array[] = 6; print_r($array); // Neue Indizierung $array = array_values($array); $array[] = 7; print_r($array); ?>

Das oben gezeigte Beispiel erzeugt folgende Ausgabe:
Array
(
    [0] => 1
    [1] => 2
    [2] => 3
    [3] => 4
    [4] => 5
)
Array
(
)
Array
(
    [5] => 6
)
Array
(
    [0] => 6
    [1] => 7
)

Destrukturierung (Zerlegung) von Arrays

Arrays können mit den Sprachkonstrukten [] (seit PHP 7.1.0) oder list() destrukuriert werden. Diese Konstrukte können verwendet werden, um ein Array in einzelne Variablen zu zerlegen.

Beispiel #11 Destrukturieren eines Arrays

<?php
$source_array = ['foo', 'bar', 'baz'];

[$foo, $bar, $baz] = $source_array;

echo $foo, PHP_EOL;    // gibt "foo" aus
echo $bar, PHP_EOL;    // gibt "bar" aus
echo $baz, PHP_EOL;    // gibt "baz" aus
?>

Die Destrukturierung von Arrays kann in foreach verwendet werden, um ein mehrdimensionales Array zu zerlegen, während darüber iteriert wird.

Beispiel #12 Destrukturieren eines Arrays in foreach

<?php
$source_array = [
    [1, 'John'],
    [2, 'Jane'],
];

foreach ($source_array as [$id, $name]) {
    echo "{$id}: '{$name}'\n";
}
?>

Array-Elemente werden ignoriert, wenn die Variable nicht angegeben wird. Die Destrukturierung von Arrays beginnt immer beim Index 0.

Beispiel #13 Ignoren von Elementen

<?php
$source_array = ['foo', 'bar', 'baz'];

// Zuweisen des Elements bei Index 2 an die Variable $baz
[, , $baz] = $source_array;

echo $baz;    // gibt "baz" aus
?>

Seit PHP 7.1.0 können auch assoziative Arrays destrukturiert werden. Da der Index explizit angegeben werden kann, ermöglicht dies auch in numerisch indizierten Arrays eine einfachere Auswahl des richtigen Elements.

Beispiel #14 Destrukturieren von assoziativen Arrays

<?php
$source_array = ['foo' => 1, 'bar' => 2, 'baz' => 3];

// Zuweisen des Elements bei Index 'baz' an die Variable $three
['baz' => $three] = $source_array;

echo $three, PHP_EOL;  // gibt 3 aus

$source_array = ['foo', 'bar', 'baz'];

// Zuweisen des Elements bei Index 2 an die Variable $baz
[2 => $baz] = $source_array;

echo $baz, PHP_EOL;    // gibt "baz" aus
?>

Array-Destrukturierung kann verwendet werden, um auf einfache Weise zwei Variablen zu vertauschen.

Beispiel #15 Vertauschen von zwei Variablen

<?php
$a = 1;
$b = 2;

[$b, $a] = [$a, $b];

echo $a, PHP_EOL;    // gibt 2 aus
echo $b, PHP_EOL;    // gibt 1 aus
?>

Hinweis:
Der Spread-Operator (...) wird bei Zuweisungen nicht unterstützt.

Hinweis:
Wird versucht, auf einen nicht definierten Array-Schlüssel zuzugreifen, so ist dies dasselbe wie der Zugriff auf eine andere undefinierte Variable: Eine Fehlermeldung der Stufe E_WARNING (der Stufe E_NOTICE vor PHP 8.0.0) wird ausgegeben und das Ergebnis ist null.

Hinweis:
Bei der Destrukturierung eines skalaren Werts wird allen Variablen null zugewiesen.

Nützliche Funktionen

Es gibt einige nützliche Funktionen für die Arbeit mit Arrays, die im Abschnitt Array-Funktionen nachgeschlagen werden können.

Hinweis:
Die Funktion unset() erlaubt es, Schlüssel aus einem Array zu entfernen. Zu beachten ist dabei, dass das Array nicht neu indiziert wird. Falls ein echtes Verhalten von "Entfernen und Verschieben" gewünscht ist, dann kann das Array mittels array_values() neu indiziert werden.

Beispiel #16 Entfernen von Zwischenelementen

<?php $a = array(1 => 'one', 2 => 'two', 3 => 'three'); /* dies wird ein Array erzeugen, das wie folgt definiert worden wäre $a = array(1 => 'one', 3 => 'three'); und NICHT so $a = array(1 => 'one', 2 =>'three'); */ unset($a[2]); var_dump($a); $b = array_values($a); // Nun ist $b array(0 => 'one', 1 =>'three') var_dump($b); ?>

Die Kontrollstruktur foreach existiert speziell für Arrays. Sie bietet eine einfache Möglichkeit, ein Array zu durchlaufen.

Dos und Dont's für Arrays (was man tun sollte und was nicht)

Wieso ist `$foo[bar]` falsch?

Verwenden Sie immer Anführungszeichen um ein Arrayindex-Zeichenkettenliteral. Beispielsweise ist $foo['bar'] richtig, $foo[bar] hingegen nicht. Aber wieso? Es ist üblich, die folgende Schreibweise in alten Skripten zu finden:

<?php
$foo[bar] = 'enemy';
echo $foo[bar];
// etc
?>

Dies ist falsch, funktioniert aber. Der Grund dafür ist, dass dieser Code eine undefinierte Konstante (bar) anstatt eines Strings verwendet ('bar' - beachten Sie die Anführungszeichen). Dies funktioniert, da PHP einen nackten String (ein String ohne Anführungszeichen, der keinem bekannten Symbol entspricht) automatisch in einen String umwandelt, welcher den nackten String enthält. Beispielsweise wird PHP, wenn keine Konstante namens bar definiert ist, diese automatisch durch den String 'bar' ersetzen und verwenden.

Warnung

Das Rückfallverhalten, eine nicht definierte Konstante als nackte Zeichenkette zu interpretieren, löst einen Fehler der Stufe E_NOTICE aus. Dies ist seit PHP 7.2.0 missbilligt und löst einen Fehler der Stufe E_WARNING aus. Mit PHP 8.0.0 wurde es entfernt und löst eine Error-Exception aus.

Dies bedeutet nicht, dass man den Schlüssel immer in Anführungszeichen setzen muss. Setzen Sie keine Schlüssel in Anführungszeichen, welche Konstanten oder Variablen sind, da dies PHP daran hindern wird, diese zu interpretieren.

Beispiel #17 Anführungszeichen bei Schlüsseln

<?php
error_reporting(E_ALL);
ini_set('display_errors', true);
ini_set('html_errors', false);

// Ein simples Array:
$array = array(1, 2);
$count = count($array);

for ($i = 0; $i < $count; $i++) {
    echo "\nPrüfe $i: \n";
    echo "Schlecht: " . $array['$i'] . "\n";
    echo "Gut: " . $array[$i] . "\n";
    echo "Schlecht: {$array['$i']}\n";
    echo "Gut: {$array[$i]}\n";
}
?>

Das oben gezeigte Beispiel erzeugt folgende Ausgabe:

Prü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

Prü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 Erläuterung dieses Verhaltens:

Beispiel #18 Weitere Beispiele

<?php
// Alle Fehler anzeigen
error_reporting(E_ALL);

$arr = array('fruit' => 'apple', 'veggie' => 'carrot');

// Korrekt
echo $arr['fruit'], PHP_EOL;  // apple
echo $arr['veggie'], PHP_EOL; // carrot

// Inkorrekt. Dies Funktioniert nicht und PHP löst löst einen Error aus,
// da eine undefinierte Konstante namens fruit verwendet wird
//
// Error: Undefined constant "fruit"
try {
    echo $arr[fruit];
} catch (Error $e) {
    echo get_class($e), ': ', $e->getMessage(), PHP_EOL;
}

// Dies definiert eine Konstante, um darzustellen, was hier passiert. Der Wert
// 'veggie' wird einer Konstanten namens fruit zugewiesen
define('fruit', 'veggie');

// Beachten Sie nun den Unterschied
echo $arr['fruit'], PHP_EOL;  // apple
echo $arr[fruit], PHP_EOL;    // carrot

// Hier ist es in Ordnung, da dies innerhalb eines Strings ist. Innerhalb eines
// Strings wird nicht nach Konstanten gesucht, weshalb kein Fehler auftritt
echo "Hello $arr[fruit]", PHP_EOL;      // Hello apple

// Mit einer Ausnahme: Klammern um ein Array sorgen dafür, dass Konstanten
// interpretiert werden
echo "Hello {$arr[fruit]}", PHP_EOL;    // Hello carrot
echo "Hello {$arr['fruit']}", PHP_EOL;  // Hello apple

// Konkatenation (Verkettung) ist eine weitere Möglichkeit
echo "Hello " . $arr['fruit'], PHP_EOL; // Hello apple
?>

<?php
// Dies wird nicht funktionieren und zu einem Parse-Fehler führen:
// Parse error: parse error, expecting T_STRING' or T_VARIABLE' or T_NUM_STRING'
// Dies gilt natürlich ebenso für superglobale Werte innerhalb von Strings
print "Hello $arr['fruit']";
print "Hello $_GET['foo']";
?>

Wie im Abschnitt zur Syntax gezeigt, muss der Inhalt der eckigen Klammern '[' und ']') ein Ausdruck sein. Das bedeutet, dass folgendes funktioniert:

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

Dieses Beispiel zeigt, wie der Rückgabewert einer Funktion als Arrayindex verwendet wird. PHP kann auch Konstanten auflösen:

<?php
$error_descriptions[E_ERROR]   = "Ein fataler Fehler ist aufgetreten";
$error_descriptions[E_WARNING] = "PHP hat eine Warnung ausgegeben";
$error_descriptions[E_NOTICE]  = "Dies ist nur ein informeller Hinweis";
?>

Es ist zu beachten, dass E_ERROR ein gültiger Bezeichner ist, genau wie bar im ersten Beispiel. Das vorherige Beispiel ist gleichbedeutend mit:

<?php
$error_descriptions[1] = "Ein fataler Fehler ist aufgetreten";
$error_descriptions[2] = "PHP hat eine Warnung ausgegeben";
$error_descriptions[8] = "Dies ist nur ein informeller Hinweis";
?>

da E_ERROR gleich 1 ist usw.

Wieso ist es also schlecht?

Irgendwann in der Zukunft könnte das PHP-Team eine weitere Konstante oder ein Schlüsselwort hinzufügen oder eine Konstante in anderem Code könnte Einfluss nehmen. Es ist beispielsweise bereits falsch, die Wörter empty oder default so zu schreiben, da dies reservierte Schlüsselwörter sind.

Hinweis: Zur Wiederholung: innerhalb eines Strings in doppelten Anführungszeichen ist es korrekt, einen Arrayschlüssel ohne Anführungszeichen zu schreiben, weswegen "$foo[bar]" zulässig ist. Die obigen Beispiele erklären dies ebenso, wie der Abschnitt zum Parsen von Variablen in Strings.

Konvertierung in ein Array

Für jeden der Typen Integer, Float, String, Boolean und Ressource führt eine Konvertierung eines Wertes in ein Array zu einem Array mit einem einzigen Wert mit dem Index Null und dem Wert des Skalaren, der konvertiert wurde. Anders ausgedrückt ist (array) $scalarValue exakt identisch mit array($scalarValue).

Wenn ein Objekt in ein Array konvertiert wird, so ist das Ergebnis ein Array, dessen Werte die Eigenschaften des Objekts sind. Die Schlüssel sind die Namen der Eigenschaften des Objektes mit ein paar nennenswerten Ausnahmen: Eigenschaften mit Ganzzahl-Namen sind nicht zugreifbar, privaten Variablen wird der Name der Klasse vorangestellt und protected Variablen wird dem Variablennamen ein '*' vorangestellt. Diese vorangestellten Werte haben NUL-Bytes auf beiden Seiten. Nicht-initialisierte typisierte Eigenschaften werden stillschweigend verworfen.

Beispiel #19 Konvertierung in ein Array

<?php

class A {
    private $B;
    protected $C;
    public $D;
    function __construct()
    {
        $this->{1} = null;
    }
}

var_export((array) new A());
?>

Das oben gezeigte Beispiel erzeugt folgende Ausgabe:

array (
  '' . "\0" . 'A' . "\0" . 'B' => NULL,
  '' . "\0" . '*' . "\0" . 'C' => NULL,
  'D' => NULL,
  1 => NULL,
)

Diese NUL-Bytes können zu einem unerwarteten Verhalten führen:

Beispiel #20 Umwandeln eines Objekts in ein Array

<?php

class A {
    private $A; // Dies wird zu '\0A\0A'
}

class B extends A {
    private $A; // Dies wird zu '\0B\0A'
    public $AA; // Dies wird zu 'AA'
}

var_dump((array) new B());
?>

Das oben gezeigte Beispiel erzeugt folgende Ausgabe:

array(3) {
  ["BA"]=>
  NULL
  ["AA"]=>
  NULL
  ["AA"]=>
  NULL
}

Im obigen Beispiel scheint es zwei Schlüssel namens 'AA' zu geben, obwohl einer davon eigentlich '\0A\0A' ist.

Die Konvertierung von null in ein Array führt zu einem leeren Array.

Vergleiche

Mit der Funktion array_diff() und mit Array-Operatoren ist es möglich, Arrays zu vergleichen.

Entpacken von Arrays

Ein Array, dem ein ... vorangestellt ist, wird bei der Definition des Arrays an Ort und Stelle expandiert (entpackt). Nur Arrays und Objekte, die Traversable implementieren, können entpackt werden. Das Entpacken von Arrays mit ... ist seit PHP 7.4.0 verfügbar. Dies wird auch als Spread-Operator bezeichnet.

Es ist möglich, ein Array mehrmals zu entpacken und normale Elemente vor oder nach dem Operator ... hinzuzufügen:

Beispiel #21 Einfaches Entpacken von Arrays

<?php
// Verwendung der kurzen Array-Syntax.
// Funktioniert auch mit der array()-Syntax.
$arr1 = [1, 2, 3];
$arr2 = [...$arr1]; // [1, 2, 3]
$arr3 = [0, ...$arr1]; // [0, 1, 2, 3]
$arr4 = [...$arr1, ...$arr2, 111]; // [1, 2, 3, 1, 2, 3, 111]
$arr5 = [...$arr1, ...$arr1]; // [1, 2, 3, 1, 2, 3]

function getArr() {
  return ['a', 'b'];
}
$arr6 = [...getArr(), 'c' => 'd']; // ['a', 'b', 'c' => 'd']

var_dump($arr1, $arr2, $arr3, $arr4, $arr5, $arr6);
?>

Das Entpacken eines Arrays mit dem Operator ... folgt der Syntax der Funktion array_merge(). Das heißt, nachfolgende Zeichenketten-Schlüssel überschreiben vorherige und Integer-Schlüssel werden neu nummeriert:

Beispiel #22 Entpacken eines Arrays mit doppeltem Schlüssel

<?php
// Zeichenketten-Schlüssel
$arr1 = ["a" => 1];
$arr2 = ["a" => 2];
$arr3 = ["a" => 0, ...$arr1, ...$arr2];
var_dump($arr3); // ["a" => 2]

// Integer-Schlüssel
$arr4 = [1, 2, 3];
$arr5 = [4, 5, 6];
$arr6 = [...$arr4, ...$arr5];
var_dump($arr6); // [1, 2, 3, 4, 5, 6]
// Das ergibt [0 => 1, 1 => 2, 2 => 3, 3 => 4, 4 => 5, 5 => 6]
// wobei die ursprünglichen Integer-Schlüssel nicht beibehalten wurden.
?>

Hinweis:
Schlüssel, die weder Integer noch Zeichenketten sind, lösen einen TypeError aus. Solche Schlüssel können nur von einem Traversable-Objekt erzeugt werden.

Hinweis:
Vor PHP 8.1 wird das Entpacken eines Arrays, das einen String-Schlüssel enthält, nicht unterstützt:

<?php $arr1 = [1, 2, 3]; $arr2 = ['a' => 4]; $arr3 = [...$arr1, ...$arr2]; // Fatal error: Uncaught Error: Cannot unpack array with string keys in example.php:5 $arr4 = [1, 2, 3]; $arr5 = [4, 5]; $arr6 = [...$arr4, ...$arr5]; // works. [1, 2, 3, 4, 5] ?>

Beispiele

Der Array-Typ in PHP ist sehr vielseitig. Hier sind einige Beispiele:

Beispiel #23 Vielseitigkeit von Arrays

<?php
// Dies:
$a = array( 'color' => 'red',
            'taste' => 'sweet',
            'shape' => 'round',
            'name'  => 'apple',
            4        // der Schlüssel wird 0 sein
          );

$b = array('a', 'b', 'c');

var_dump($a, $b);

// . . .ist komplett gleichbedeutend mit:
$a = array();
$a['color'] = 'red';
$a['taste'] = 'sweet';
$a['shape'] = 'round';
$a['name']  = 'apple';
$a[]        = 4;        // der Schlüssel wird 0 sein

$b = array();
$b[] = 'a';
$b[] = 'b';
$b[] = 'c';

// Nachdem der obige Code ausgeführt wurde, wird $a das Array
// array('color' => 'red', 'taste' => 'sweet', 'shape' => 'round',
// 'name' => 'apple', 0 => 4) sein und $b wird das Array
// array(0 => 'a', 1 => 'b', 2 => 'c') oder einfach array('a', 'b', 'c')
// sein

var_dump($a, $b);
?>

Beispiel #24 Verwendung von array()

<?php
// Array als Zuordnung von Eigenschaften
$map = array( 'version'    => 4,
              'OS'         => 'Linux',
              'lang'       => 'englisch',
              'short_tags' => true
            );
var_dump($map);

// Streng numerische Schlüssel
// Das ist gleichbedeutend mit array(0 => 7, 1 => 8, ...)
$array = array( 7,
                8,
                0,
                156,
                -10
              );
var_dump($array);

$switching = array(         10, // Schlüssel = 0
                    5    =>  6,
                    3    =>  7,
                    'a'  =>  4,
                            11, // Schlüssel = 6 (das Maximum der Integer-Schlüssel war 5)
                    '8'  =>  2, // Schlüssel = 8 (Integer!)
                    '02' => 77, // Schlüssel = '02'
                    0    => 12  // Der Wert 10 wird mit 12 überschrieben
                  );
var_dump($switching);

// Leeres array
$empty = array();
var_dump($empty);
?>

Beispiel #25 Sammlung

<?php
$farben = array('rot', 'blau', 'grün', 'gelb');

foreach ($farben as $farbe) {
    echo "Mögen sie $farbe?\n";
}

?>

Das oben gezeigte Beispiel erzeugt folgende Ausgabe:

Mögen sie rot?
Mögen sie blau?
Mögen sie grün?
Mögen sie gelb?

Die Veränderung der Werte eines Arrays ist mit der Übergabe als Referenz direkt möglich.

Beispiel #26 Elemente in der Schleife verändern

<?php
$colors = array('red', 'blue', 'green', 'yellow');

foreach ($colors as &$color) {
    $color = mb_strtoupper($color);
}
unset($color); /* Sicherstellen, dass nachfolgende
Zugriffe auf $color nicht das letzte Element ändern */

print_r($colors);
?>

Das oben gezeigte Beispiel erzeugt folgende Ausgabe:

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

Dieses Beispiel erzeugt ein Array mit erstem Schlüssel 1.

Beispiel #27 1-basierte Indizes

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

Das oben gezeigte Beispiel erzeugt folgende Ausgabe:

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

Beispiel #28 Füllen eines Arrays

<?php
// Dies füllt ein Array mit allen Einträgen eines Verzeichnisses
$handle = opendir('.');
while (false !== ($file = readdir($handle))) {
    $files[] = $file;
}
closedir($handle);

var_dump($files);
?>

Arrays sind geordnet. Die Reihenfolge kann durch verschiedene Sortierfunktionen verändert werden. Siehe Array-Funktionen für mehr Informationen. Die Funktion count() kann verwendet werden, um die Anzahl der Elemente eines Arrays zu ermitteln.

Beispiel #29 Ein Array sortieren

<?php
sort($files);
print_r($files);
?>

Da die Werte eines Arrays beliebig sein können, können diese auch andere Arrays sein. Dies ermöglicht die Erzeugung von rekursiven und mehrdimensionalen Arrays.

Beispiel #30 Rekursive und mehrdimensionale Arrays

<?php
$fruits = array ( "fruits"  => array ( "a" => "orange",
                                       "b" => "banana",
                                       "c" => "apple"
                                     ),
                  "numbers" => array ( 1,
                                       2,
                                       3,
                                       4,
                                       5,
                                       6
                                     ),
                  "holes"   => array (      "first",
                                       5 => "second",
                                            "third"
                                     )
                );
var_dump($fruits);

// Einige Beispiele für den Zugriff auf die Werte in den obigen Beispielen
echo $fruits["holes"][5];    // gibt "second" aus
echo $fruits["fruits"]["a"]; // gibt "orange" aus
unset($fruits["holes"][0]);  // entfernt "first"

// Ein neues mehrdimensionales Array erzeugen
$juices["apple"]["green"] = "good";
var_dump($juices);
?>

Die Zuweisung eines Arrays beinhaltet immer eine Kopie der Werte. Verwenden Sie den Referenz-Operator, um ein Array per Referenz zu kopieren.

Beispiel #31 Kopieren eines Arrays

<?php
$arr1 = array(2, 3);
$arr2 = $arr1;
$arr2[] = 4; // $arr2 wurde geändert,
             // $arr1 ist weiterhin array(2, 3)

$arr3 = &$arr1;
$arr3[] = 4; // nun sind $arr1 und $arr3 identisch

var_dump($arr1, $arr2, $arr3);
?>

Arrays

Syntax

Spezifizierung mittels array()

Zugriff auf Elemente mit eckigen Klammern

Anlegen/Ändern mit eckigen Klammern

Destrukturierung (Zerlegung) von Arrays

Nützliche Funktionen

Dos und Dont's für Arrays (was man tun sollte und was nicht)

Wieso ist $foo[bar] falsch?

Wieso ist es also schlecht?

Konvertierung in ein Array

Vergleiche

Entpacken von Arrays

Beispiele

Wieso ist `$foo[bar]` falsch?