Ein exakter Vergleich zweier Zeichenketten kennt nur zwei Antworten: gleich oder ungleich. Sobald aber Tippfehler, Schreibvarianten oder Dubletten ins Spiel kommen, braucht es ein Maß für Ähnlichkeit. Genau dafür bringt PHP mit levenshtein() eine eingebaute Funktion mit, die in einer einzigen Zahl ausdrückt, wie weit zwei Strings voneinander entfernt sind.
Was macht die Funktion PHP levenshtein()?
Wer in PHP eine "Meinten Sie?"-Suche bauen, Dubletten in einer Adressliste erkennen oder Bot-Kommandos tolerant gegenüber Tippfehlern machen will, greift zu PHP levenshtein. Die Funktion berechnet die sogenannte Edit-Distanz zwischen zwei Strings: die Mindestanzahl an Einfüge-, Lösch- und Ersetzungs-Operationen, die nötig sind, um den ersten String in den zweiten zu überführen. Je kleiner die Distanz, desto ähnlicher sind die Strings. Der Rückgabewert ist ein Integer, der genau diese Anzahl an Zeichen-Operationen ausdrückt.
Bevor Syntax, das 255-Zeichen-Limit und Praxis-Patterns wie Suchvorschläge an die Reihe kommen, ein kurzer Blick auf die Aussagekraft der Edit-Distanz im Alltag.
Im Backend-Alltag ist das eine erstaunlich vielseitige Information. Eine Distanz von 1 bedeutet einen einzigen Tippfehler, eine Distanz von 0 bedeutet identische Strings. Damit eignet sich PHP levenshtein perfekt für Suchvorschläge, Daten-Bereinigung und Auto-Korrekturen, ohne dass eine externe Bibliothek nötig wäre.
Edit-Distanz an einem Beispiel verstehen
Das klassische Beispiel ist die Umwandlung von 'kitten' in 'sitting'. Drei Operationen sind dazu nötig: ein Replace (k zu s), ein Replace (e zu i) und ein Insert (g am Ende). PHP levenshtein liefert genau diese 3.
<?php
echo levenshtein('kitten', 'sitting') . "\n";
/* 3 */
echo levenshtein('PHP', 'PHB') . "\n";
/* 1 - ein Replace */
echo levenshtein('php', 'PHP') . "\n";
/* 3 - alle drei Buchstaben unterscheiden sich (case-sensitive!) */
Wichtig zu wissen: PHP levenshtein ist case-sensitive. 'PHP' und 'php' haben eine Distanz von 3, weil jedes der drei Zeichen ersetzt werden muss. Wer Groß- und Kleinschreibung gleich behandeln möchte, ruft die Funktion auf den mit mb_strtolower() normalisierten Strings auf. Diese kleine Vorbereitung ist in fast jedem produktiven Anwendungsfall sinnvoll.
Syntax und das 255-Zeichen-Limit
Die Funktion gibt es in zwei Varianten. Die einfache Variante akzeptiert nur die beiden Strings, die erweiterte Variante zusätzlich drei Cost-Parameter für Insert, Replace und Delete.
<?php
levenshtein(string $string1, string $string2): int
levenshtein(
string $string1,
string $string2,
int $insert,
int $replace,
int $delete
): int
Die wichtigste Einschränkung ist das interne Limit von 255 Zeichen pro String. Sobald die Länge eines der beiden Strings darüber hinausgeht, liefert PHP levenshtein -1 zurück. Das gilt für beide Varianten und ist eine Folge der intern verwendeten Datentypen. Wer mit längeren Strings arbeitet, muss entweder vorher kürzen oder auf eine eigene Implementierung in PHP wechseln. Im Composer-Universum gibt es Pakete wie mb_levenshtein, die diese Begrenzung umgehen.
Custom Cost-Parameter für Insert, Delete, Replace
Die erweiterte Variante erlaubt es, jede Edit-Operation mit einem eigenen Gewicht zu versehen. Das ist sinnvoll, wenn ein Replace teurer sein soll als ein Insert+Delete oder umgekehrt.
<?php
/* Standard: alle Operationen kosten 1 */
echo levenshtein('PHP', 'PHB', 1, 1, 1) . "\n";
/* 1 */
/* Replace teurer machen */
echo levenshtein('PHP', 'PHB', 1, 5, 1) . "\n";
/* 5 - der eine Replace zaehlt jetzt 5 */
/* Insert teurer als Delete */
echo levenshtein('Test', 'Tests', 3, 1, 1) . "\n";
/* 3 - der Insert kostet 3 */
In der Praxis lohnt die Standard-Variante in 90 Prozent der Fälle. Die Custom-Cost-Parameter sind dann hilfreich, wenn fachspezifische Annahmen ins Spiel kommen, etwa wenn Anhängen einer Endung weniger gewichtet werden soll als ein Buchstabentausch im Wortinneren.
Praxis-Schwelle: ab wann sind Strings ähnlich?
PHP levenshtein liefert eine konkrete Zahl, doch die Frage "ab wann sind zwei Strings ähnlich genug?" hängt vom Anwendungsfall ab. Für Bot-Befehle reicht oft eine Distanz von 1 oder 2, für Adressdaten ist eine Distanz von 3 bis 4 üblich. Wer die Stringlänge mit ins Verhältnis setzt, gewinnt eine prozentuale Ähnlichkeit.
<?php
$eingabe = 'stratus';
$bekannt = ['status', 'start', 'stop', 'restart'];
$kandidaten = [];
foreach ($bekannt as $cmd) {
$d = levenshtein($eingabe, $cmd);
if ($d <= 2) {
$kandidaten[$cmd] = $d;
}
}
asort($kandidaten);
print_r($kandidaten);
/* [status => 1] */
Eine empfehlenswerte Faustregel für kurze Strings: Distanz darf maximal 25 Prozent der Stringlänge betragen. Bei einem 8-stelligen String wären also 2 Operationen tolerierbar. Wer das in einer Helper-Funktion kapselt, schafft eine wiederverwendbare Ähnlichkeits-Logik für das ganze Projekt.
Suchvorschläge "Meinten Sie?"
Eines der häufigsten Anwendungsbeispiele ist die "Meinten Sie?"-Funktion in einer Suche. PHP levenshtein vergleicht die Eingabe mit allen bekannten Begriffen und liefert den nächstliegenden Kandidaten zurück.
<?php
function vorschlag(string $eingabe, array $woerter): ?string
{
$eingabe = mb_strtolower($eingabe);
$beste = null;
$minDist = PHP_INT_MAX;
foreach ($woerter as $w) {
$d = levenshtein($eingabe, mb_strtolower($w));
if ($d < $minDist) {
$minDist = $d;
$beste = $w;
}
}
/* nur vorschlagen, wenn nicht zu weit entfernt */
return $minDist <= 3 ? $beste : null;
}
echo vorschlag('Telephon', ['Telefon', 'Tablet', 'Tasse']);
/* Telefon */
Diese Variante läuft in O(n*m*l), wobei n die Anzahl der bekannten Wörter und m, l die Stringlängen sind. Bei einem Backend-Vokabular von einigen Hundert Einträgen ist das problemlos, bei mehreren Tausend lohnt der Pre-Filter (siehe weiter unten).
Vergleich mit similar_text und soundex
PHP bietet drei Funktionen für Stringähnlichkeit, die sich in ihrer Methodik unterscheiden. PHP levenshtein zählt Edit-Operationen, similar_text() zählt gemeinsame Zeichen und liefert optional einen Prozentwert, soundex() berechnet einen phonetischen Code.
<?php
$a = 'Mueller';
$b = 'Mueler';
echo levenshtein($a, $b) . "\n";
/* 1 - ein Insert */
similar_text($a, $b, $prozent);
echo number_format($prozent, 1) . ' %' . "\n";
/* ca. 92 % gemeinsame Zeichen */
echo soundex($a) . ' vs ' . soundex($b);
/* gleicher phonetischer Code */
Faustregel: PHP levenshtein für Tippfehler-Erkennung mit klarer Operations-Zählung, similar_text für prozentuale Auswertungen, soundex für phonetische Ähnlichkeit (Mueller vs. Miller). Die drei lassen sich kombinieren: Erst soundex als grober Pre-Filter, dann levenshtein zur Präzisierung.
Performance-Tipps für große Datenmengen
Bei mehreren Tausend Einträgen lohnt es sich, die Liste vor dem Aufruf von PHP levenshtein zu reduzieren. Der zugrundeliegende Algorithmus arbeitet mit einer Matrix der Längen beider Eingaben, was bei vielen Aufrufen schnell teuer wird. Klassische Pre-Filter sind der Anfangsbuchstabe oder ein soundex-Code. Damit reduziert sich die Anzahl der teuren Levenshtein-Berechnungen drastisch.
<?php
function suche(string $q, array $alle): array
{
$q1 = mb_substr($q, 0, 1);
/* Pre-Filter nach Anfangsbuchstaben */
$candidates = array_filter(
$alle,
fn($w) => mb_substr($w, 0, 1) === $q1
);
$treffer = [];
foreach ($candidates as $c) {
$d = levenshtein($q, $c);
if ($d <= 2) {
$treffer[$c] = $d;
}
}
asort($treffer);
return $treffer;
}
In der Praxis führt das zu Beschleunigungen um Faktor 10 bis 100, je nach Datenverteilung. Wer noch mehr will, kombiniert mit einem Trigramm-Index oder einer datenbankseitigen Pre-Filterung über FULLTEXT-Indexe in MySQL und schränkt die Kandidatenliste schon vor dem PHP-Aufruf ein.
Bevor das Fazit die wichtigsten Punkte bündelt, fasst das folgende Diagramm den Entscheidungsweg von zwei Strings bis zur Ähnlichkeits-Aussage zusammen.
flowchart TD
A[String 1] --> C[levenshtein]
B[String 2] --> C
C --> D{Beide unter 255 Zeichen?}
D -->|nein| E[Rueckgabe -1]
D -->|ja| F[Edit-Distanz berechnen]
F --> G{Distanz unter Schwelle?}
G -->|ja| H[Aehnlich]
G -->|nein| I[Nicht aehnlich]
Fazit
Mit PHP levenshtein steht ein vielseitiges Werkzeug für die Berechnung von Stringähnlichkeit bereit. Die Funktion liefert die Edit-Distanz, also die Mindestanzahl der nötigen Insert-, Delete- und Replace-Operationen, und macht damit Tippfehler- und Ähnlichkeitslogik in wenigen Zeilen möglich. Wer das 255-Zeichen-Limit, die Case-Sensitivity und die Multibyte-Schwäche kennt, kann PHP levenshtein gezielt einsetzen. Im Vergleich zu similar_text (prozentuale Ähnlichkeit) und soundex (phonetisch) bleibt sie das richtige Werkzeug, sobald exakte Operations-Zählung gewünscht ist. Mit einem klugen Pre-Filter läuft die Funktion auch bei größeren Datenmengen performant und gehört damit ins feste Toolset jeder Suche, die mehr leisten will als reines exaktes Matching.
