PHP Array: Alles was du wissen musst

Um größere Mengen an Daten in Variablen zur späteren Verarbeitung zu speichern, sind PHP Arrays bestens geeignet. Wie du diese erstellst, wie sich diese voneinander Unterscheiden und ein paar weitere Funktionen stelle ich dir in diesem Beitrag vor.

So erstellst du ein Array in PHP

Am einfachsten kannst du ein Array erstellen, indem du eine Variable mit [] initialisierst, wie hier.

$array = [];

Vor der Einführung der eckigen Klammern zum Erstellen von Arrays in PHP, war der Aufruf von array() üblich.

$array = array();

Um das Array gleich mit Werten zu erstellen, kannst du diese einfach zwischen den Klammern angeben.

$array = [1, 2, 3];

So kannst du dir ein PHP Array anzeigen lassen

Strings lassen sich einfach mit echo anzeigen. Wenn du dasselbe mit Arrays versuchst, wird nur der String „Array“ ausgegeben und eine Warnung.

$array = [1, 2];
echo $array;
// Notice: Array to string conversion in C:\...\arrays.php on ...
// Array

Im Folgenden werden wir für Arrays hauptsächlich print_r verwenden, da es die am einfachsten zu lesende Textausgabe erzeugt.

print_r($array);
// Array ( [0] => 1 [1] => 2 )

Wenn du mehr über die Ausgabe von Arrays wissen willst, kannst du dir gerne unseren Artikel dazu ansehen.

Einfache, assoziative und gemischte Arrays

Bis jetzt haben wir uns nur mit einfachen Arrays beschäftigt. Assoziative Arrays nennt man sie, wenn sie aus selbst erstellten Schlüssel-Wert-Paaren bestehen. Einfache Arrays haben ebenfalls Schlüssel, von PHP automatisch erstellt. Diese sind basierend auf der Zahl 0. Das heißt, der erste Wert hat den Schlüssel 0, der Zweite 1, der Dritte 2, usw.
Ein assoziatives Array kannst du so erstellen:

$array = ['code'=>'citrus', 'foo'=>'bar'];
print_r($array);
// Array ( [code] => citrus [foo] => bar )

Jeder Schlüssel kann in einem Array nur einmal verwendet werden.
Ein Schlüssel kann nur entweder ein String oder ein Integer sein.
Das heißt im Umkehrschluss, dass alles, was du als Schlüssel angibst, sollte es weder String noch Integer sein, in einen solchen umgewandelt wird.

$array = [1.1 => "1", true => "2", 1 => "3", "1" => "4"];
print_r($array);
// Array ( [1] => 4 )

Im vorigen Beispiel waren nur Schlüssel angegeben, die bei einer Umwandlung in einen ganzzahligen Datentypen 1 ergeben. Das resultiert darin, dass jeder Wert mit dem Nachfolgenden überschrieben wird und nur der Letzte beibehalten wird.

Du kannst einen einzelnen Wert abrufen, indem du den Schlüssel angibst.

$array = ['foo'=>1, 'bar'=>2];
echo $array['foo'];
// 1

Der Schlüssel sollte als String angegeben werden. Du könntest zwar den Schlüssel einfach so schreiben, jedoch solltest du das vermeiden.

echo $array[foo];
// Warning: Use of undefined constant foo - assumed 'foo' (this will throw an Error in a future version of PHP) in C:\...\arrays.php on …
// 1

Das vorige Beispiel warnt davor, dass eine undefinierte Konstante mit Namen foo verwendet wird und nimmt an, dass der String ‚foo‘ verwendet werden sollte.
Wenn die Konstante foo nun tatsächlich definiert wäre, würde echo ein anderes Ergebnis ausgeben.

define('foo', 'bar');
echo $array['foo'];
// 1
echo $array[foo];
// 2

Du kannst auch automatisch erstellte mit selbst erstellten Schlüsseln vermischen.
Dabei entstehen sogenannte gemischte Arrays.
Beachte, dass wenn du selbst numerische Schlüssel festlegst, die automatisch erstellten Schlüssel danach größer sind als dein zuletzt festgelegter.

$array = [21=>"a", "b", "c", "d"];
var_dump($array);
// Array ( [21] => a [22] => b [23] => c [24] => d )

Dies funktioniert auch, wenn du dazwischen Schlüssel als String angibst.

$array = ["a", "y"=>"b", 21=>"c", "d"];
print_r($array);
// Array ( [0] => a [y] => b [21] => c [22] => d )

Mehrdimensionaler PHP Array

Mehrdimensionale Arrays sind Arrays deren Werte selbst Arrays sind. Das heißt, du kannst mehrere Arrays in einem Array speichern.

$array = [
    [1, 2, 3],
    'foo'=>['bar'=>'baz']
];
print_r($array);
/* Array (
    [0] => Array ( [0] => 1 [1] => 2 [2] => 3 )
    [foo] => Array ( [bar] => baz )
) /**/

Auf die Werte innerhalb multidimensionaler Arrays kannst du auch mit den Schlüsseln zugreifen.

echo $array[0][2];
// 3
echo $array['foo']['bar'];
// baz

Mit PHP is_array prüfen, ob eine Variable ein Array ist

is_array lässt dich einfach überprüfen, ob eine Variable ein Array ist oder nicht. Wenn ja, gibt die Funktion true zurück, wenn nicht, false.

$array = [1, 2];
var_dump(is_array($array));
// bool(true)
$string = 'asdf';
var_dump(is_array($string));
// bool(false)

Wenn du diese Funktion mit einer undefinierten Variablen ausführst, erhältst du als Rückgabewert false.
Jedoch wird ebenfalls eine Warnung von PHP produziert.

var_dump(is_array($nicht_gesetzt));
// Notice: Undefined variable: nicht_gesetzt in C:\...\arrays.php on ...
// bool(false)

Anzahl der enthaltenen Werte eines PHP Arrays ermitteln

Um alle Werte in einem Array zu zählen, kannst du einfach die Funktion count mit dem Array als Parameter aufrufen.

$array = [1, 2, 3];
echo count($array);
// 3

Mehr dazu findest du in unserem Artikel zu count.

Vorgefüllte Arrays mit PHP array_fill und range erstellen

Die Funktion array_fill lässt dich einfach Arrays erstellen, die mehrfach denselben Wert enthalten. Dabei kannst du den Anfangsschlüssel und die Gesamtanzahl der Elemente festlegen. Der erste Parameter gibt dabei den ersten Schlüssel an, der Zweite die Gesamtanzahl der Elemente.
Der dritte Parameter gibt das Element, das verwendet wird, an.

$array = array_fill(3, 3, 'foo');
print_r($array);
// Array ( [3] => foo [4] => foo [5] => foo )

range lässt dich ein Array mit aufeinanderfolgenden Werten erstellen.
Dafür musst du nur Anfangs- und Endwert festlegen.

$zahlen = range(7, 13);
print_r($zahlen);
/* Array (
    [0] => 7
    [1] => 8
    [2] => 9
    [3] => 10
    [4] => 11
    [5] => 12
    [6] => 13
) /**/

Dasselbe kannst du auch mit Buchstaben machen.
Zusätzlich kannst du auch noch einen dritten Parameter angeben, der die Schrittgröße angibt.
Das folgende Beispiel generiert ein Array, das von a beginnend jeden fünften Buchstaben des Alphabets zurückgibt.

$buchstaben = range('a', 'z', 5);
print_r($buchstaben);
// Array ( [0] => a [1] => f [2] => k [3] => p [4] => u [5] => z )

Werte zu einem PHP Array hinzufügen und entfernen

Weitere Elemente zu Arrays hinzufügen ist einfach. Du kannst dies einfach mit eckigen Klammern tun.

$array = [];
$array[] = 'asdf';
print_r($array);
// Array ( [1] => 0 [bar] => foo )

So kannst du auch Elemente mit eigenen Schlüsseln hinzufügen.

$array = [];
$array['foo'] = 'bar';
print_r($array);
// Array ( [foo] => bar )

Mehr über das Hinzufügen von Werten in Arrays kannst du auch in unserem Artikel dazu erfahren.

Mit unset kannst du Elemente aus Arrays anhand ihres Schlüssels löschen.

$array = ['foo'];
unset($array[0]);
print_r($array);
// Array ( )

Dies funktioniert genauso mit selbst erstellten Schlüsseln.

$array = ['foo'=>'bar'];
unset($array['foo']);
print_r($array);
// Array ( )

Schlüssel und Werte innerhalb eines PHP Arrays finden

Mit isset kannst du prüfen, ob ein Schlüssel in einem Array existiert.

$array = ['code'=>'citrus', 'foo'=>'bar'];
var_dump(isset($array['not_set']));
// bool(false)
var_dump(isset($array['code']));
// bool(true)

Mit array_key_exists kannst du dies ebenfalls überprüfen.

var_dump(array_key_exists('not_set', $array));
// bool(false)
var_dump(array_key_exists('code', $array));
// bool(true)

Um zu prüfen, ob ein Wert in einem Array vorhanden ist, kannst du in_array verwenden.

var_dump(in_array('citrus', $array));
// bool(true)
var_dump(in_array('coffee', $array));
// bool(true)

Genaueres dazu kannst du in unserem Artikel (CodeCitrus: Die PHP in_array Funktion) dazu lesen.

Schlüssel und Werte innerhalb eines Arrays tauschen

Eine weitere interessante Funktion ist array_flip.
Diese Funktion gibt ein Array zurück, in dem die Schlüssel den Werten und die Werte den Schlüsseln aus dem ursprünglichen Array entsprechen.

$array = [1, 'foo'=>'bar'];
print_r(array_flip($array));
// Array ( [1] => 0 [bar] => foo )

Allerdings kann diese Funktion nur auf Strings und Integer angewendet werden.
Bei mehrdimensionalen Arrays wird eine Warnung ausgegeben und die inneren Arrays ignoriert.

$array = [1, 'foo'=>'bar', 'asdf'=>[32, 64]];
print_r(array_flip($array));
// Warning: array_flip(): Can only flip STRING and INTEGER values! in C:\...\arrays.php on ...
// Array ( [1] => 0 [bar] => foo )

Alle Schlüssel-Wert-Paare manipulieren

Mit einer simplen foreach-Schleife kannst du jedes Element eines Arrays aufrufen.

$array = [1, 2, 3];
foreach ($array as $wert) {
    echo $wert.'<br>';
}
// 1
// 2
// 3

Du kannst auch jedes Schlüssel-Wert-Paar auf diese Weise aufrufen.

$array = ['code'=>'citrus', 'foo'=>'bar'];
foreach ($array as $schluessel => $wert) {
    echo "{$schluessel}: {$wert}<br>";
}
// code: citrus
// foo: bar

array_map ermöglicht es dir, eine Funktion auf jedes Element eines Arrays anzuwenden. Du kannst den Namen der Funktion als String angeben.

$array = ['foo', 'bar', 'baz'];
$grossgeschrieben = array_map('strtoupper', $array);
print_r($grossgeschrieben);
// Array ( [0] => FOO [1] => BAR [2] => BAZ )

Du kannst auch anonyme Funktionen übergeben.
Das folgende Beispiel multipliziert alle Werte eines Arrays mit sich selbst und gibt das Ergebnis als neues Array aus.

$zahlen = [-2, 1, 10, 64];
$quadrate = array_map(function($zahl) {
    return $zahl * $zahl;
}, $zahlen);
print_r($quadrate);
// Array ( [0] => 4 [1] => 1 [2] => 100 [3] => 4096 )

Du kannst mit array_map auch mehrere Arrays angeben.
Die Funktion array_keys gibt ein Array zurück, das nur die Schlüssel eines Arrays enthält. Auf diese Weise kannst du eine Funktion erstellen, die Schlüssel und Wert eines Paares verwertet.

$personen = ['name' => 'Paul', 'alter'=>27];
$funktion = function($schluessel, $wert) {
    return "{$schluessel}: {$wert}";
};
$ergebnis = array_map($funktion, array_keys($personen), $personen);
print_r($ergebnis);
// Array ( [0] => name: Paul [1] => alter: 27 )

Mit array_walk kannst du ebenfalls auf jedes Schlüssel-Wert-Paar eines Arrays zugreifen.

$array = ['code'=>'citrus', 'foo'=>'bar'];
array_walk($array, function($wert, $schluessel) {
    echo "{$schluessel}: {$wert}";
});
// code: citrus
// foo: bar

So wandelst du PHP Variablen in Arrays und Arrays in Variablen um

Mit der Funktion list kannst du Werte aus einem Array Variablen einfacher zuweisen.

$array = ['foo', 42, 'bar'];
list($a, $b) = $array;
echo $a;
// foo
echo $b;
// 42

extract erstellt die Variablen für assoziative Arrays sogar automatisch. Allerdings funktioniert das nur mit Werten, deren Schlüssel Strings sind.

$array = [21=>42, 'foo'=>'bar'];
extract($array);
echo $foo;
// bar

compact wandelt einzelne Variablen in assoziative Arrays um.
Dafür musst du die Variablennamen allerdings als Strings angeben.

$foo = 'bar';
$code = 'citrus';
$array = compact('foo', 'code');
print_r($array);
// Array ( [foo] => bar [code] => citrus )

Filter-Funktionen für Arrays in PHP

array_unique gibt ein neues Array mit einmaligen Werten aus einem Bestehenden zurück.

$array = [1, 1, 1, 2, 3, 3, 5, 5];
$einmalige = array_unique($einmalige);
print_r($einmalige);
// Array ( [0] => 1 [3] => 2 [4] => 3 [6] => 5 )

array_diff lässt dich aus zwei Arrays ein neues Array erstellen, das nur Elemente enthält, die im zweiten übergebenen Array nicht enthalten sind.

$array1 = ['foo', 'bar', 'baz', 'code', 'citrus'];
$array2 = ['bar', 'baz', 0, 'citrus'];
$diff = array_diff($array1, $array2);
print_r($diff);
// Array ( [0] => foo [3] => code )
$diff = array_diff($array2, $array1);
//  Array ( [2] => 0 )

array_intersect erstellt ein neues Array aus zwei Arrays, welches nur Werte enthält, die in beiden Arrays vorhanden sind.
Dabei wird der Schlüssel des zuerst übergebenen Arrays beibehalten.

$intersect = array_intersect($array1, $array2);
print_r($intersect);
// Array ( [1] => bar [2] => baz [4] => citrus )
$intersect = array_intersect($array2, $array1);
print_r($intersect);
// Array ( [0] => bar [1] => baz [3] => citrus )

Du kannst auch eigene Filter-Funktionen mit array_filter angeben.
Das folgende Beispiel gibt aus einem Array aus Zahlen nur gerade Zahlen zurück.

$zahlen = [2, 21, 1024, 3, 50, 51];
$gerade = array_filter($zahlen, function($zahl) {
    return $zahl % 2 == 0;
});
print_r($gerade);
// Array ( [0] => 2 [2] => 1024 [4] => 50 )

Mit array_column kannst du aus mehrdimensionalen Arrays alle Elemente der inneren Arrays mit dem selben Schlüssel ausgeben. Die Ausgabe erfolgt in einem neuen Array.

$array = [
    ['name'=>'Paul', 'mail'=>'paul@example.com'],
    ['name'=>'Hans', 'mail'=>'hans@example.com'],
    ['name'=>'Peter', 'mail'=>'peter@example.com']
];
$namen = array_column($array, 'name');
print_r($namen);
// Array ( [0] => Paul [1] => Hans [2] => Peter )

Rechnen mit einem PHP Array

Die Funktion array_sum zählt alle Werte eines numerischen Arrays zusammen.

$zahlen = [1, 2, 4, 8, 16, 32, 64, 128];
echo array_sum($zahlen);
// 255

array_product multipliziert alle Werte miteinander.

$zahlen = [2, 4, 8, 16];
echo array_product($zahlen);
// 1024

array_reduce lässt dich eigene Funktionen definieren, um mit den Werten eines Arrays zu rechnen. Das folgende Beispiel zieht jeden Wert ab und liefert dann das Ergebnis.

$zahlen = [512, 256, 128, 64];
$funktion = function($uebertragener_wert, $zahl) {
    return $uebertragener_wert - $zahl;
};
$ergebnis = array_reduce($zahlen, $funktion);
echo $ergebnis;
// -960

Mit einem dritten Parameter kannst du den Startwert, auf den die Funktion angewendet wird, festlegen.

$ergebnis = array_reduce($zahlen, $funktion, 1024);
echo $ergebnis;
// 64

PHP Array sortieren

Die Funktion sort ist ein einfaches Werkzeug, um die Elemente von Arrays zu sortieren.

$array = ['foo', 'bar', 'baz'];
sort($array);
print_r($array);
// Array ( [0] => bar [1] => baz [2] => foo )

Mit asort kannst du das gleiche tun, jedoch werden die ursprünglichen Schlüssel des Arrays hierbei beibehalten.

$array = ['foo', 'bar', 'baz'];
asort($array);
print_r($array);
// Array ( [1] => bar [2] => baz [0] => foo )

rsort lässt dich in umgekehrter Reihenfolge sortieren.

$array = ['foo', 'bar', 'baz'];
rsort($array);
print_r($array);
// Array ( [0] => foo [1] => baz [2] => bar )

ksort macht es dir möglich, Arrays nach ihrem Schlüssel zu sortieren.

$array = [1=>'foo', 2=>'bar', 0=>'baz'];
ksort($array);
print_r($array);
// Array ( [0] => baz [1] => foo [2] => bar )

Die meisten dieser Funktionen akzeptieren einen zusätzlichen Parameter, der dich die Sortierung genauer bestimmen lässt. Die möglichen Optionen findest du hier: https://www.php.net/manual/de/function.sort.php#refsect1-function.sort-parameters

Fazit

Arrays in PHP sind sehr flexibel und nützlich. Du kannst einfach Werte hinzufügen und entfernen. Es gibt weiterhin viele eingebaute Funktionen, um alle Werte zu zählen, bestimmte Werte oder Schlüssel zu finden und viel mehr. Auch von den hier präsentierten Funktionen gibt es noch viele weitere Variationen und optionale Parameter, welche du nutzen kannst.

Wenn du noch Fragen, Anmerkungen, Anregungen, Lob oder Kritik hast, lass es mich bitte in den Kommentaren wissen.