Strings aufzuteilen gehört zu den häufigsten Aufgaben in PHP. Für einfache Fälle mit einem festen Trennzeichen reicht die Funktion explode() völlig aus. Sobald das Trennmuster aber variabel ist, zum Beispiel beliebig viele Leerzeichen, verschiedene Trennzeichen gleichzeitig oder komplexe Regeln, kommt preg_split() ins Spiel. Diese Funktion zerlegt einen String anhand eines regulären Ausdrucks und bietet deutlich mehr Flexibilität als explode().
Syntax und Parameter von preg_split()
Die Funktion erwartet mindestens zwei Parameter und gibt ein Array zurück:
array preg_split(
string $pattern, // Regex-Trennmuster
string $subject, // Der zu zerlegende String
int $limit = -1, // Maximale Anzahl Teile (-1 = unbegrenzt)
int $flags = 0 // Optionale Flags
)
Der Parameter $pattern ist ein regulärer Ausdruck mit Delimitern (meistens Schrägstriche). $subject ist der Eingabestring. Mit $limit kannst du die maximale Anzahl der Ergebnisteile begrenzen. Der letzte Teil enthält dann den gesamten Rest des Strings. Der Wert -1 bedeutet unbegrenzt.
Ein einfaches Beispiel
<?php
$text = "PHP ist eine serverseitige Sprache";
$woerter = preg_split('/\s+/', $text);
print_r($woerter);
/* Ausgabe:
Array
(
[0] => PHP
[1] => ist
[2] => eine
[3] => serverseitige
[4] => Sprache
)
*/
?>
Das Pattern /\s+/ steht für „ein oder mehr Whitespace-Zeichen“. Es erfasst Leerzeichen, Tabs und Zeilenumbrüche gleichermaßen. Im Vergleich dazu würde explode(' ', $text) bei doppelten Leerzeichen leere Array-Elemente erzeugen.
preg_split() vs. explode(): Wann brauche ich was?
Die Frage, ob explode() oder preg_split() die richtige Wahl ist, lässt sich mit einer einfachen Faustregel beantworten: Ist das Trennzeichen immer gleich, nimm explode(). Variiert es, nimm preg_split().
<?php
/* explode() reicht hier voellig aus:
festes Trennzeichen (Komma) */
$csv = "PHP,JavaScript,Python";
$sprachen = explode(',', $csv);
/* preg_split() wird noetig:
Trennung an Komma, Semikolon oder Pipe */
$eingabe = "PHP,JavaScript;Python|Ruby";
$sprachen = preg_split('/[,;|]/', $eingabe);
// Ergebnis: ["PHP", "JavaScript", "Python", "Ruby"]
/* preg_split() bei uneinheitlichem Whitespace */
$text = "Wort1 Wort2\tWort3\nWort4";
$woerter = preg_split('/\s+/', $text);
// Ergebnis: ["Wort1", "Wort2", "Wort3", "Wort4"]
?>
explode() ist deutlich schneller als preg_split(), weil kein regulärer Ausdruck kompiliert werden muss. Bei einfachen Trennzeichen solltest du deshalb immer explode() bevorzugen. Den Regex-Overhead lohnt sich nur, wenn das Trennmuster tatsächlich variabel ist.
Den limit-Parameter nutzen
Mit dem dritten Parameter begrenzt du die Anzahl der Ergebnisteile. Der letzte Teil enthält den gesamten Rest:
<?php
$pfad = "src/Controller/UserController.php";
$teile = preg_split('/\//', $pfad, 2);
print_r($teile);
/* Ausgabe:
Array
(
[0] => src
[1] => Controller/UserController.php
)
*/
?>
Hier wird der Pfad nur am ersten Schrägstrich getrennt. Das ist nützlich, wenn du nur den ersten Ordner vom Rest des Pfades trennen möchtest.
Die wichtigsten Flags
Der vierte Parameter von preg_split() akzeptiert Flags, die das Verhalten der Funktion steuern. Die Flags lassen sich mit dem bitweisen Oder-Operator (|) kombinieren.
PREG_SPLIT_NO_EMPTY
Dieses Flag entfernt leere Strings aus dem Ergebnis. Ohne das Flag erzeugen aufeinanderfolgende Trennzeichen leere Array-Elemente:
<?php
$text = "PHP,,JavaScript,,Python";
/* Ohne Flag: leere Elemente bei doppelten Kommas */
$ohneFlag = preg_split('/,/', $text);
// ["PHP", "", "JavaScript", "", "Python"]
/* Mit Flag: leere Elemente werden entfernt */
$mitFlag = preg_split('/,/', $text, -1, PREG_SPLIT_NO_EMPTY);
// ["PHP", "JavaScript", "Python"]
?>
In der Praxis brauchst du dieses Flag fast immer, wenn du an Whitespace trennst. Sonst erzeugen führende oder abschließende Leerzeichen unerwünschte leere Elemente.
PREG_SPLIT_DELIM_CAPTURE
Dieses Flag ist eines der mächtigsten Features von preg_split(). Es fügt die Treffer der Capturing Groups im Pattern als eigene Elemente ins Ergebnis-Array ein. Damit kannst du den String zerlegen und gleichzeitig die Trennzeichen behalten.
<?php
/* Template-Platzhalter erkennen und behalten */
$template = "Hallo {name}, du hast {count} Nachrichten";
$teile = preg_split(
'/(\{[a-z]+\})/',
$template,
-1,
PREG_SPLIT_DELIM_CAPTURE
);
print_r($teile);
/* Ausgabe:
Array
(
[0] => Hallo
[1] => {name}
[2] => , du hast
[3] => {count}
[4] => Nachrichten
)
*/
?>
Beachte die runden Klammern im Pattern: /(\{[a-z]+\})/. Nur was innerhalb einer Capturing Group steht, wird ins Ergebnis aufgenommen. Ohne die Klammern würden die Platzhalter beim Splitten verloren gehen.
Dieser Mechanismus eignet sich hervorragend für einfache Template-Engines, Syntax-Highlighter oder Parser, die den Text in seine Bestandteile zerlegen und dabei die Trennelemente behalten müssen.
PREG_SPLIT_OFFSET_CAPTURE
Dieses Flag verändert die Struktur des Ergebnis-Arrays: Statt einfacher Strings enthält jedes Element ein Array mit dem Teilstring und seiner Position im Originalstring.
<?php
$text = "PHP ist vielseitig";
$teile = preg_split(
'/\s+/',
$text,
-1,
PREG_SPLIT_OFFSET_CAPTURE
);
print_r($teile);
/* Ausgabe:
Array
(
[0] => Array ( [0] => PHP [1] => 0 )
[1] => Array ( [0] => ist [1] => 4 )
[2] => Array ( [0] => vielseitig [1] => 8 )
)
*/
?>
Die Positionsangabe ist nützlich für Textanalyse-Tools, Syntax-Highlighter oder Übersetzungssysteme, die wissen müssen, wo im Originaltext ein bestimmtes Wort steht.
Flags kombinieren
<?php
$text = " PHP ist vielseitig ";
$teile = preg_split(
'/\s+/',
$text,
-1,
PREG_SPLIT_NO_EMPTY | PREG_SPLIT_OFFSET_CAPTURE
);
/* Leere Elemente entfernt + Position angegeben */
?>
Häufige Regex-Pattern für preg_split()
Die folgenden Pattern decken die meisten Anwendungsfälle ab und lassen sich direkt übernehmen:
<?php
$text = "Beispieltext fuer verschiedene Splits";
/* An beliebigem Whitespace trennen */
$woerter = preg_split('/\s+/', $text);
/* An Zeilenumbruechen trennen
(Windows, Linux und macOS) */
$zeilen = preg_split('/\r?\n/', $mehrzeilig);
/* An mehreren Trennzeichen gleichzeitig */
$teile = preg_split('/[,;|\s]+/', $eingabe);
/* An Satzzeichen trennen (Punkt, Ausruf, Frage) */
$saetze = preg_split('/[.!?]+\s*/', $text, -1, PREG_SPLIT_NO_EMPTY);
/* CamelCase in einzelne Woerter zerlegen */
$woerter = preg_split('/(?=[A-Z])/', 'getUserName');
// ["get", "User", "Name"]
/* An Ziffernfolgen trennen */
$teile = preg_split('/(\d+)/', 'abc123def456', -1, PREG_SPLIT_DELIM_CAPTURE);
// ["abc", "123", "def", "456", ""]
?>
Das CamelCase-Pattern /(?=[A-Z])/ verwendet einen Lookahead. Es trennt an der Stelle vor einem Großbuchstaben, ohne den Buchstaben selbst zu verbrauchen. Das ist ein typischer Anwendungsfall, der mit explode() nicht möglich wäre.
Unicode und Multibyte-Sicherheit
Wenn du mit internationalen Texten arbeitest, die Umlaute, Akzente oder andere Nicht-ASCII-Zeichen enthalten, brauchst du das /u-Flag im Pattern. Es schaltet den UTF-8-Modus ein und sorgt dafür, dass Multibyte-Zeichen korrekt behandelt werden.
<?php
$text = "München ist schön";
/* Ohne /u: Umlaute koennten als zwei Bytes
interpretiert werden */
$falsch = preg_split('/\s+/', $text);
/* Mit /u: UTF-8-sichere Verarbeitung */
$korrekt = preg_split('/\s+/u', $text);
/* Unicode-Wortgrenzen nutzen */
$woerter = preg_split('/\b/u', "Café Müller");
?>
In deutschsprachigen Projekten solltest du das /u-Flag zur Gewohnheit machen. Ohne dieses Flag kann es bei Zeichen wie ä, ö, ü und ß zu unerwarteten Ergebnissen kommen, weil PHP die UTF-8-Kodierung nicht berücksichtigt.
Praxisbeispiel: Log-Dateien parsen
Ein häufiger Anwendungsfall für preg_split() ist das Zerlegen von Log-Zeilen. Apache- oder PHP-Error-Logs folgen einem festen Format, bei dem die einzelnen Felder durch unterschiedliche Trennzeichen getrennt sind.
<?php
$logZeile = '[2025-04-30 14:23:15] ERROR: Datei nicht gefunden - /uploads/bild.jpg';
/* Log-Zeile in Bestandteile zerlegen */
$teile = preg_split(
'/\[|\]\s*|:\s*|\s-\s/',
$logZeile,
-1,
PREG_SPLIT_NO_EMPTY
);
print_r($teile);
/* Ausgabe:
Array
(
[0] => 2025-04-30 14:23:15
[1] => ERROR
[2] => Datei nicht gefunden
[3] => /uploads/bild.jpg
)
*/
?>
Hier trennt das Pattern an eckigen Klammern, Doppelpunkten mit optionalem Whitespace und Bindestrichen mit umgebenden Leerzeichen. Mit explode() wäre das nicht möglich, weil mehrere verschiedene Trennzeichen gleichzeitig berücksichtigt werden müssen.
Praxisbeispiel: CSV mit Sonderzeichen
Bei CSV-Daten kann explode(',', $zeile) scheitern, wenn Felder selbst Kommas enthalten und in Anführungszeichen stehen. preg_split() kann auch damit umgehen:
<?php
$zeile = 'Max,"Müller, Schmidt",Berlin,"01234, 56789"';
$felder = preg_split(
'/,(?=(?:[^"]*"[^"]*")*[^"]*$)/',
$zeile
);
print_r($felder);
/* Ausgabe:
Array
(
[0] => Max
[1] => "Müller, Schmidt"
[2] => Berlin
[3] => "01234, 56789"
)
*/
?>
Das Pattern trennt nur an Kommas, die nicht innerhalb von Anführungszeichen stehen. Es verwendet einen Lookahead, der prüft, ob nach dem Komma eine gerade Anzahl von Anführungszeichen folgt.
Hinweis: Für echte CSV-Verarbeitung im Produktiveinsatz ist die PHP-Funktion str_getcsv() die bessere Wahl, da sie alle Sonderfälle des CSV-Formats korrekt behandelt. Das Beispiel zeigt aber die Mächtigkeit von preg_split() bei komplexen Trennregeln.
Fehlerbehandlung mit preg_last_error()
Wenn das Regex-Pattern ungültig ist oder die Verarbeitung fehlschlägt, gibt preg_split() den Wert false zurück. Den genauen Fehlergrund erfährst du über preg_last_error() beziehungsweise ab PHP 8.0 über preg_last_error_msg().
<?php
$pattern = '/[/'; // Ungueltiges Pattern
$ergebnis = @preg_split($pattern, "Testtext");
if ($ergebnis === false) {
$fehlerCode = preg_last_error();
echo "Regex-Fehler (Code $fehlerCode)";
/* Ab PHP 8.0: lesbare Fehlermeldung */
if (function_exists('preg_last_error_msg')) {
echo ": " . preg_last_error_msg();
}
}
?>
Die häufigsten Fehlercodes sind PREG_NO_ERROR (0, kein Fehler), PREG_INTERNAL_ERROR (1, interner Fehler) und PREG_BACKTRACK_LIMIT_ERROR (2, Backtracking-Limit überschritten). Das Backtracking-Limit tritt bei komplexen Pattern und langen Strings auf. Du kannst es mit ini_set('pcre.backtrack_limit', '1000000') erhöhen, solltest aber besser das Pattern optimieren.
Bei dynamisch erzeugten Pattern, zum Beispiel aus Benutzereingaben, ist die Fehlerprüfung besonders wichtig. Nutze in solchen Fällen preg_quote(), um Sonderzeichen im Suchmuster zu maskieren:
<?php
/* Benutzereingabe sicher als Pattern verwenden */
$trennzeichen = $_GET['separator'] ?? ',';
$sicheres_pattern = '/' . preg_quote($trennzeichen, '/') . '/';
$teile = preg_split($sicheres_pattern, $eingabe);
?>
Performance: preg_split() vs. explode()
Die Geschwindigkeit spielt vor allem in Schleifen über große Datenmengen eine Rolle. explode() ist bei einfachen Trennzeichen etwa zwei bis fünfmal schneller als preg_split(), weil kein regulärer Ausdruck kompiliert und ausgewertet werden muss.
<?php
$text = str_repeat("wort ", 10000);
/* explode(): schnell bei festem Trennzeichen */
$start = microtime(true);
for ($i = 0; $i < 100; $i++) {
explode(' ', $text);
}
$zeit_explode = microtime(true) - $start;
/* preg_split(): langsamer, aber flexibler */
$start = microtime(true);
for ($i = 0; $i < 100; $i++) {
preg_split('/\s+/', $text);
}
$zeit_preg = microtime(true) - $start;
echo "explode: " . round($zeit_explode, 4) . "s";
echo "preg_split: " . round($zeit_preg, 4) . "s";
?>
Die Faustregel lautet: Verwende explode() immer dann, wenn ein einzelnes, festes Trennzeichen ausreicht. Greife zu preg_split(), wenn das Trennmuster variabel ist, mehrere Trennzeichen gleichzeitig berücksichtigt werden müssen oder du die erweiterten Flags brauchst.
Verwandte Funktionen im Vergleich
PHP bietet mehrere Funktionen zum Aufteilen von Strings. Jede hat ihren eigenen Einsatzzweck:
explode() trennt an einem festen Trennzeichen. Schnell und einfach, aber nicht flexibel. Die richtige Wahl für CSV-Felder, URL-Parameter oder andere Strings mit bekanntem Trennzeichen.
str_split() zerlegt einen String in gleichlange Teile. Nützlich, wenn du einen String in Blöcke fester Länge aufteilen willst, zum Beispiel für die Darstellung langer Zahlen oder Codes.
preg_split() trennt anhand eines regulären Ausdrucks. Bietet die größte Flexibilität, ist aber langsamer. Die richtige Wahl, wenn das Trennmuster variabel ist.
str_getcsv() parst eine CSV-Zeile nach dem CSV-Standard. Berücksichtigt Anführungszeichen, Escape-Zeichen und Zeilenumbrüche innerhalb von Feldern. Für echte CSV-Daten immer die bessere Wahl als preg_split().
str_word_count() zählt Wörter oder gibt sie als Array zurück. Für einfache Worttrennung oft ausreichend, stößt aber bei Sonderzeichen oder gemischtsprachigen Texten an Grenzen.
Zusammenfassung
preg_split() ist die flexibelste Funktion zum Aufteilen von Strings in PHP. Sie spielt ihre Stärken dann aus, wenn feste Trennzeichen nicht mehr ausreichen: bei variablem Whitespace, mehreren Trennzeichen gleichzeitig oder komplexen Trennregeln. Die Flags PREG_SPLIT_NO_EMPTY, PREG_SPLIT_DELIM_CAPTURE und PREG_SPLIT_OFFSET_CAPTURE erweitern die Möglichkeiten zusätzlich. Für einfache Fälle mit festem Trennzeichen bleibt explode() die schnellere und einfachere Wahl. Denke bei internationalen Texten an das /u-Flag für korrekte UTF-8-Verarbeitung und prüfe bei dynamisch erzeugten Pattern immer den Rückgabewert auf false.
