PHP Anfänger 30 min

Arrays & assoziative Arrays

PHP-Arrays sind Liste und Dictionary in einem. Lerne die wichtigsten Operationen, Funktionen und Best Practices.

Aktualisiert:
Inhaltsverzeichnis

Arrays & assoziative Arrays

Arrays sind in PHP eine der wichtigsten Datenstrukturen. Anders als in den meisten Sprachen sind sie beides - Listen und Dictionaries - im selben Typ.

Indizierte Arrays (Listen)

$namen = ['Max', 'Anna', 'Leo'];
echo $namen[0];     // "Max"
echo count($namen); // 3

Indizes starten bei 0.

Elemente hinzufuegen

$namen[] = 'Tim';          // ans Ende anhaengen
$namen[] = 'Lea';
print_r($namen);
// Array ( [0] => Max [1] => Anna [2] => Leo [3] => Tim [4] => Lea )

// Mit array_push
array_push($namen, 'Jo', 'Sam');

// Am Anfang einfuegen
array_unshift($namen, 'Neu');

Elemente entfernen

$letztes = array_pop($namen);       // letztes Element raus
$erstes = array_shift($namen);      // erstes Element raus
unset($namen[1]);                    // beliebigen Index entfernen (erzeugt Luecke!)
$neu = array_values($namen);         // Indizes "aufruecken"

Assoziative Arrays (Dictionaries)

$person = [
    'name' => 'Anna',
    'alter' => 28,
    'aktiv' => true,
];

echo $person['name'];    // "Anna"
$person['email'] = 'anna@example.com';

// Existenz pruefen
if (isset($person['email'])) { /* ... */ }
if (array_key_exists('email', $person)) { /* ... */ }

Verschachtelt

$team = [
    'anna' => ['alter' => 28, 'rolle' => 'Dev'],
    'max'  => ['alter' => 34, 'rolle' => 'PM'],
];

echo $team['anna']['rolle'];  // "Dev"

Iterieren

foreach ($namen as $name) {
    echo $name . "\n";
}

foreach ($namen as $i => $name) {
    echo "{$i}: {$name}\n";
}

foreach ($person as $key => $value) {
    echo "{$key}: " . (is_bool($value) ? ($value ? 'ja' : 'nein') : $value) . "\n";
}

Destrukturierung

Wie in JavaScript:

$namen = ['Anna', 'Max', 'Leo'];
[$a, $b, $c] = $namen;
// $a = 'Anna', $b = 'Max', $c = 'Leo'

// Mit Schluesseln
['name' => $name, 'alter' => $alter] = $person;

Wichtige Array-Funktionen

Das array_*-Oekosystem ist riesig - hier die wichtigsten:

Filter, Map, Reduce

$zahlen = [1, 2, 3, 4, 5];

// array_map: jedes Element transformieren
$verdoppelt = array_map(fn($n) => $n * 2, $zahlen);
// [2, 4, 6, 8, 10]

// array_filter: Elemente filtern
$gerade = array_filter($zahlen, fn($n) => $n % 2 === 0);
// [1 => 2, 3 => 4]  - achtung: Indizes bleiben!

// array_values zum Neu-Indizieren
$gerade = array_values($gerade);
// [2, 4]

// array_reduce: auf einen Wert reduzieren
$summe = array_reduce($zahlen, fn($c, $n) => $c + $n, 0);
// 15

Sortieren

$namen = ['Max', 'Anna', 'Leo'];

sort($namen);             // aendert Original-Array, neu indiziert
// ['Anna', 'Leo', 'Max']

rsort($namen);            // umgekehrt
usort($namen, fn($a, $b) => strlen($a) - strlen($b)); // benutzerdefiniert

// Assoziative Arrays nach Schluessel
ksort($person);

// Nach Wert mit erhaltenen Schluesseln
asort($person);

Suchen

in_array('Anna', $namen);           // true
array_search('Anna', $namen);        // liefert Index oder false
array_key_exists('email', $person);  // true / false

Zusammenfuehren

$a = [1, 2, 3];
$b = [4, 5, 6];

array_merge($a, $b);       // [1, 2, 3, 4, 5, 6]
[...$a, ...$b];             // Spread-Operator (gleich)
array_combine(['a', 'b'], [1, 2]);  // ['a' => 1, 'b' => 2]

Transformieren

array_reverse($namen);             // umgedreht
array_unique([1, 2, 2, 3, 3]);     // Duplikate entfernen
array_keys($person);                // nur die Schluessel
array_values($person);              // nur die Werte
array_flip($person);                // Keys und Values tauschen

Abschnitte

array_slice($namen, 1, 2);   // 2 Elemente ab Index 1
array_chunk($namen, 2);       // in 2er-Gruppen aufteilen

list() und Destrukturierung

list($a, $b, $c) = [1, 2, 3];
// gleich wie: [$a, $b, $c] = [1, 2, 3];

Spread-Operator

$ersten = [1, 2, 3];
$letzten = [5, 6];
$alle = [...$ersten, 4, ...$letzten];
// [1, 2, 3, 4, 5, 6]

// Auch bei Funktionen:
function summe(int ...$zahlen): int {
    return array_sum($zahlen);
}

summe(...$ersten);  // 6

Strings zu Arrays und zurueck

$worte = explode(' ', 'Hallo schoene Welt');
// ['Hallo', 'schoene', 'Welt']

$satz = implode(' ', $worte);
// "Hallo schoene Welt"

$zeichen = str_split('Anna');
// ['A', 'n', 'n', 'a']

CSV lesen und schreiben

// Lesen
$csv = array_map('str_getcsv', file('daten.csv'));

// Mit Kopfzeile als Schluessel
$header = array_shift($csv);
$daten = array_map(fn($zeile) => array_combine($header, $zeile), $csv);

Assoziativ sortieren mit Stil

Beispiel: Produkte nach Preis sortieren:

$produkte = [
    ['name' => 'Buch', 'preis' => 19.99],
    ['name' => 'CD', 'preis' => 12.99],
    ['name' => 'DVD', 'preis' => 14.99],
];

usort($produkte, fn($a, $b) => $a['preis'] <=> $b['preis']);

Der <=> (Spaceship Operator) gibt -1, 0, 1 zurueck - perfekt fuer Vergleichsfunktionen.

Praktisches Beispiel

<?php
declare(strict_types=1);

$bestellungen = [
    ['kunde' => 'Anna', 'betrag' => 42.50, 'bezahlt' => true],
    ['kunde' => 'Max',  'betrag' => 15.99, 'bezahlt' => false],
    ['kunde' => 'Anna', 'betrag' => 22.00, 'bezahlt' => true],
    ['kunde' => 'Leo',  'betrag' => 88.00, 'bezahlt' => true],
];

// Alle bezahlten Bestellungen
$bezahlt = array_filter($bestellungen, fn($b) => $b['bezahlt']);

// Umsatz pro Kunde
$umsatzProKunde = [];
foreach ($bezahlt as $b) {
    $umsatzProKunde[$b['kunde']] = ($umsatzProKunde[$b['kunde']] ?? 0) + $b['betrag'];
}

// Nach Umsatz absteigend sortieren
arsort($umsatzProKunde);

print_r($umsatzProKunde);
/*
Array
(
    [Leo]  => 88
    [Anna] => 64.5
)
*/

Moderne Alternative: ArrayObject und Collections

Frameworks wie Laravel bringen Collection-Klassen mit, die fliessende API haben:

use Illuminate\Support\Collection;

$ergebnis = collect($bestellungen)
    ->filter(fn($b) => $b['bezahlt'])
    ->groupBy('kunde')
    ->map(fn($b) => $b->sum('betrag'))
    ->sortDesc();

Das ist eleganter - aber mit den Standard-Array-Funktionen kommst du auch weit.

Zusammenfassung

  • PHP-Arrays sind zugleich Listen und Dictionaries
  • $arr[] = ... haengt ans Ende an
  • foreach ($arr as $k => $v) ist der Alltag
  • array_map / array_filter / array_reduce fuer funktionalen Stil
  • sort, usort, <=> fuer Sortierung
  • Spread-Operator [...$a, ...$b] und Destrukturierung [$a, $b]

Damit hast du das Fundament, um mit PHP produktiv zu arbeiten. Im weiteren Kurs gehen wir auf Klassen, Namespaces, Exceptions und den Einstieg in Laravel ein.

Zurück zum PHP Kurs