PHP explode(): einen String in ein Array aufteilen

explode($separator, $string) teilt einen String an jedem Vorkommen von $separator und liefert die Teile als Array. explode(',', 'apple,banana,cherry') ergibt ['apple', 'banana', 'cherry'].

<?php
$csv = 'apple,banana,cherry';
$fruits = explode(',', $csv);

print_r($fruits);
echo $fruits[1], "\n";
echo count($fruits), " fruits\n";

Das Trennzeichen kann ein beliebiger String sein, nicht nur ein Zeichen: explode(' and ', 'tea and milk and sugar') funktioniert genauso. Die umgekehrte Operation, ein Array wieder zu einem String zu verbinden, ist implode().

Syntax und Rückgabewert

explode(string $separator, string $string, int $limit = PHP_INT_MAX): array

Es liefert immer ein Array. Kommt das Trennzeichen nicht vor, enthält das Array den ganzen String als einziges Element. Das gilt auch für den leeren String, der ein Array mit einem leeren String darin ergibt, eine häufige Quelle für Bugs nach dem Muster „meine Schleife läuft bei leerer Eingabe einmal“.

<?php
var_dump(explode(',', 'apple'));   // separator not found
var_dump(explode(',', ''));        // empty input
var_dump(explode(',', 'a,,b,'));   // empty pieces are kept

// If an empty string should mean "no items", check before splitting
$input = '';
$tags = $input === '' ? [] : explode(',', $input);
echo count($tags), "\n";

Die Anzahl der Teile begrenzen

Das dritte Argument, $limit, ändert, wie viele Teile du bekommst:

• Ein positives Limit liefert höchstens so viele Teile. Das letzte Teil enthält den Rest des Strings, mitsamt Trennzeichen.
• Ein negatives Limit liefert jedes Teil außer den letzten abs($limit).
• Ein Limit von 0 wird wie 1 behandelt.

<?php
$path = 'home/ada/projects/site/index.php';

print_r(explode('/', $path, 2));   // first piece, then the rest
print_r(explode('/', $path, -1));  // everything except the file name
print_r(explode('/', $path, 0));   // treated as 1

Ein positives Limit ist das richtige Werkzeug, wenn nur das erste Trennzeichen zählt, zum Beispiel bei einer Zeile key=value, in deren Wert auch = vorkommen kann: explode('=', 'query=a=b', 2) ergibt ['query', 'a=b']. Die nächsten Abschnitte verwenden es so.

Um nur das letzte Teil zu bekommen, speicherst du das Array zuerst in einer Variable: $parts = explode('/', $path); $file = end($parts);. end(explode('/', $path)) liefert zwar den richtigen Wert, aber PHP gibt Notice: Only variables should be passed by reference aus, weil end() sein Argument per Referenz nimmt.

Einen String nach Zeilenumbruch aufteilen

explode("\n", $text) teilt an Zeilenumbrüchen. Verwende doppelte Anführungszeichen: In einfachen ist '\n' ein Backslash gefolgt vom Buchstaben n, kein Zeilenumbruch. Text aus Windows-Dateien oder HTML-Formularen beendet Zeilen oft mit "\r\n", was am Ende jedes Teils ein verirrtes "\r" hinterlässt. preg_split('/\R/', $text) teilt an jeder Art von Zeilenumbruch.

<?php
$text = "first line\r\nsecond line\nthird line";

$pieces = explode("\n", $text);
var_dump($pieces[0]);   // still ends with \r

$lines = preg_split('/\R/', $text);
var_dump($lines);

Die Teile trimmen und leere verwerfen

Nutzereingaben wie "red, green , ,blue" haben Leerzeichen um die Einträge und einen leeren Eintrag in der Mitte. Schick die Teile mit array_map() durch trim() und entferne dann leere Strings mit array_filter(). array_values() nummeriert die Schlüssel danach neu, weil array_filter() die ursprünglichen behält.

<?php
$input = 'red, green , ,blue';

$colors = array_map('trim', explode(',', $input));
$colors = array_values(array_filter($colors, fn($c) => $c !== ''));

print_r($colors);

Der Callback fn($c) => $c !== '' behält den String "0". Ein bloßes array_filter($colors) würde ihn verwerfen, weil "0" falsy ist.

Einen String in ein assoziatives Array umwandeln

Einstellungen, Cookies und Strings nach Art eines Query-Strings werden oft als Paare key=value gespeichert. Ruf explode zweimal auf: einmal für die Paare und einmal für jedes Paar mit einem Limit von 2, wobei du die zwei Teile in Variablen entpackst (Array-Destructuring).

<?php
$settings = 'theme=dark;lang=ja;filter=a=b';

$result = [];
foreach (explode(';', $settings) as $pair) {
    [$key, $value] = explode('=', $pair, 2);
    $result[$key] = $value;
}

print_r($result);
echo $result['lang'], "\n";

Ein Paar ohne =, etwa debug, ergibt ein Array mit einem Element, und das Destructuring gibt Warning: Undefined array key 1 aus. Füll das Ergebnis auf zwei Elemente auf, um das zu vermeiden: [$key, $value] = explode('=', $pair, 2) + [1 => ''];.

Bei einem echten URL-Query-String erledigt parse_str() das für dich und dekodiert außerdem %20 und +.

An mehreren Trennzeichen aufteilen

explode() nimmt ein Trennzeichen. Um an Kommas, Semikolons oder Leerzeichen zu teilen, verwendest du preg_split() mit einer Zeichenklasse. PREG_SPLIT_NO_EMPTY verwirft die leeren Teile, die zwei Trennzeichen hintereinander erzeugen würden.

<?php
$input = 'php, javascript;python  go|rust';

$words = preg_split('/[\s,;|]+/', $input, -1, PREG_SPLIT_NO_EMPTY);
print_r($words);

Japanischer und anderer UTF-8-Text

explode() vergleicht Bytes, und in UTF-8 taucht ein vollständiges Zeichen nie in den Bytes eines anderen Zeichens auf, also funktioniert es korrekt, japanischen Text an einem japanischen Trennzeichen wie 、 oder einem vollbreiten Komma zu teilen.

<?php
$cities = '東京、大阪、京都';
print_r(explode('、', $cities));

// Split into single characters: mb_str_split counts characters, str_split counts bytes
print_r(mb_str_split('日本語'));

explode vs str_split vs preg_split

explode() macht keine Regex-Arbeit, ist also schneller als preg_split() und die erste Wahl, wann immer das Trennzeichen ein fester String ist.

Typischer Fehler: ein leeres Trennzeichen

Ein leeres Trennzeichen ist ein Fehler. Seit PHP 8.0 wirft explode('', 'abc') einen ValueError, statt false zu liefern, und das Skript stoppt:

PHP Fatal error:  Uncaught ValueError: explode(): Argument #1 ($separator) cannot be empty in /home/index.php:3

Um einen String in Zeichen zu teilen, verwendest du str_split('abc') für ASCII-Text oder mb_str_split($s) für alles, was Multibyte-Zeichen enthalten kann.