PHP strrpos() meistern - Die letzte Position eines Substrings präzise finden

Wer mit Zeichenketten arbeitet, braucht früher oder später eine Möglichkeit, das letzte Vorkommen eines bestimmten Zeichens oder Teilstrings zu finden. PHPs strrpos() löst genau dieses Problem. Das klassische Beispiel ist das Parsen von Dateipfaden: Willst du aus mein_dokument.backup.pdf nur die Endung .pdf extrahieren, musst du den letzten Punkt finden. In diesem Guide lernst du die Funktion von Grund auf, inklusive Offset-Parameter, Stolperfallen und praxisnaher Anwendungsfälle.

Was ist strrpos() und wann brauchst du es?

Die Funktion strrpos() sucht in einer Zeichenkette nach dem letzten Vorkommen eines Zeichens oder Teilstrings und liefert dessen Position als Integer zurück. Findet die Funktion nichts, gibt sie false zurück.

Warum das letzte Vorkommen? In vielen Situationen ist es entscheidend, nicht das erste, sondern das letzte Auftreten zu kennen. Typische Beispiele sind das Extrahieren von Dateiendungen, das Isolieren des letzten URL-Segments oder das Prüfen von Suffixen. Dabei taucht immer wieder dasselbe Zwei-Schritt-Pattern auf: Erst die Position mit strrpos() finden, dann mit substr() den gewünschten Teil extrahieren.

Praxisbeispiel zum Einstieg:

$sDateiname = "mein_dokument.backup.pdf";



$iLetzterPunkt = strrpos($sDateiname, ".");



if ($iLetzterPunkt !== false) {

 $sEndung = substr($sDateiname, $iLetzterPunkt + 1);

 echo $sEndung; // Ausgabe: pdf

}

Hinweis zur Groß-/Kleinschreibung: strrpos() ist case-sensitive. Wenn du unabhängig von Groß- und Kleinschreibung suchen willst, nutze strripos().

Das strrpos() + substr() Pattern

Das mit Abstand häufigste Pattern mit strrpos() besteht aus zwei Schritten: Erst die Position finden, dann mit substr() den Teil davor oder danach extrahieren. Dieses Muster solltest du verinnerlichen, weil es auf viele Probleme anwendbar ist.

$sText = "bilder/uploads/foto.jpeg";

$iTrenner = strrpos($sText, "/");



/* Teil NACH dem Trenner */

$sDanach = substr($sText, $iTrenner + 1);

// Ergebnis: "foto.jpeg"



/* Teil VOR dem Trenner */

$sDavor = substr($sText, 0, $iTrenner);

// Ergebnis: "bilder/uploads"

Dieses Rezept funktioniert mit jedem Trennzeichen: Punkte, Slashes, Doppelpunkte oder beliebige Strings. Achte nur darauf, vorher mit === false zu prüfen, ob das Trennzeichen überhaupt gefunden wurde.

Die Syntax von strrpos() im Detail

Bevor du die Funktion in eigenen Projekten einsetzt, solltest du die Parameter und ihr Zusammenspiel genau kennen.

strrpos(

 string $sHeuhaufen,

 string $sNadel,

 int $iOffset = 0

): int|false

Parameter:

• $sHeuhaufen (string): Die zu durchsuchende Zeichenkette.
• $sNadel (string): Das zu suchende Zeichen oder der Teilstring. Ab PHP 8.0 ist auch ein leerer String erlaubt (gibt die Länge des Heuhaufens zurück).
• $iOffset (int, optional): Bestimmt den Suchbereich. Ein positiver Wert startet die Suche ab dieser Position. Ein negativer Wert begrenzt den Suchbereich auf die letzten |$iOffset| Zeichen.

Den Offset-Parameter verstehen

Der optionale dritte Parameter steuert, in welchem Bereich des Strings gesucht wird. Das ist besonders nützlich, wenn du gezielt nur einen Teil der Zeichenkette durchsuchen willst.

$sText = "abc.abc.abc";



/* Positiver Offset: Suche ab Position 4 */

echo strrpos($sText, ".", 4);

// Ausgabe: 7 (der Punkt vor dem dritten "abc")



/* Negativer Offset: Suchbereich begrenzen */

echo strrpos($sText, ".", -4);

// Ausgabe: 3 (nur im Bereich "abc.abc" gesucht)

Negative Offset-Visualisierung

Der negative Offset ist der verwirrendste Aspekt von strrpos(). Diese Darstellung macht den Suchbereich sichtbar:

/*

String: a b c . a b c . a b c

Position: 0 1 2 3 4 5 6 7 8 9 10



Offset -4: Suche nur bis Position 7

 [a b c . a b c .]

 Letzter Punkt im Bereich: Position 3



Offset -8: Suche nur bis Position 3

 [a b c .]

 Letzter Punkt im Bereich: Position 3

*/



$sText = "abc.abc.abc";

echo strrpos($sText, ".", -4); // 3

echo strrpos($sText, ".", -8); // 3

Leerer Suchstring ab PHP 8.0

Ab PHP 8.0 ist ein leerer String als Nadel erlaubt. Das Ergebnis ist die Länge des Heuhaufens:

echo strrpos("abc", ""); // Ausgabe: 3

echo strrpos("Hallo", ""); // Ausgabe: 5

Vor PHP 8.0 hat ein leerer Suchstring eine Warnung ausgelöst. Falls du Code für ältere PHP-Versionen schreibst, solltest du vorher prüfen, ob die Nadel leer ist.

Rückgabewert: Position oder false

Der Rückgabewert ist entweder ein Integer (die nullbasierte Position) oder false, wenn nichts gefunden wurde.

• Bei Fund: Integer, nullbasiert (Index startet bei 0).
• Bei Nicht-Fund: false

Wichtige Stolperfalle: 0 vs. false

Die Position 0 ist ein gültiger Treffer! Wenn du nur if ($iPos) schreibst, wertet PHP die Position 0 als false aus, und du übersiehst den Treffer an der ersten Stelle. Verwende deshalb immer den strikten Vergleich:

$iPos = strrpos(".htaccess", ".");



/* FALSCH: 0 wird als false gewertet */

if ($iPos) {

 echo "Gefunden"; // wird NICHT ausgefuehrt!

}



/* RICHTIG: Strikter Vergleich */

if ($iPos !== false) {

 echo "Gefunden bei Position $iPos"; // 0

}

Praxisbeispiele und typische Szenarien

Die folgenden Beispiele zeigen dir, wie du strrpos() in realen Projekten einsetzt.

Dateiendung extrahieren

$sPfad = "images/uploads/photo.jpeg";



$iLetzterPunkt = strrpos($sPfad, ".");

$sEndung = ($iLetzterPunkt !== false)

 ? substr($sPfad, $iLetzterPunkt + 1)

 : "";

Besser mit pathinfo(): Für das Extrahieren von Dateiendungen, Dateinamen und Verzeichnissen gibt es in PHP spezialisierte Funktionen. pathinfo($sPfad, PATHINFO_EXTENSION) liefert die Endung, basename() den Dateinamen. Diese sind sicherer, weil sie Betriebssystem-Unterschiede berücksichtigen, und lesbarer im Code:

$sPfad = "images/uploads/photo.jpeg";



/* Spezialisierte Funktionen (empfohlen) */

$sEndung = pathinfo($sPfad, PATHINFO_EXTENSION);

// Ergebnis: "jpeg"



$sDateiname = basename($sPfad);

// Ergebnis: "photo.jpeg"



$sVerzeichnis = dirname($sPfad);

// Ergebnis: "images/uploads"

strrpos() ist trotzdem wichtig zu kennen, weil es für allgemeine String-Suchen gebraucht wird, wo es keine spezialisierte Funktion gibt. Für Dateipfade greifst du aber besser zu pathinfo() und basename().

Dateiname aus Pfad isolieren

$sPfad = "/var/www/html/index.php";



$iLetzterSlash = strrpos($sPfad, "/");

$sDateiname = ($iLetzterSlash !== false)

 ? substr($sPfad, $iLetzterSlash + 1)

 : $sPfad;

// Ergebnis: "index.php"

Letztes URL-Segment extrahieren

$sUrl = "https://domain.de/user/12345";



$iLetzterSlash = strrpos($sUrl, "/");

$sSegment = ($iLetzterSlash !== false)

 ? substr($sUrl, $iLetzterSlash + 1)

 : $sUrl;

// Ergebnis: "12345"

Letztes Verzeichnis im Pfad

$sPfad = "/home/user/web/images/";



$sClean = rtrim($sPfad, "/");

$iLetzterSlash = strrpos($sClean, "/");

$sVerzeichnis = ($iLetzterSlash !== false)

 ? substr($sClean, $iLetzterSlash + 1)

 : $sClean;

// Ergebnis: "images"

Suffix-Prüfung: strrpos() vs. str_ends_with()

Ein häufiger Anwendungsfall ist die Prüfung, ob ein String mit einem bestimmten Suffix endet. Mit strrpos() sieht das so aus:

/* Umstaendlich: Suffix-Pruefung mit strrpos() */

$sDateiname = "beispiel.php";

$sSuffix = ".php";

$bIstPhp = (

 strrpos($sDateiname, $sSuffix)

 === strlen($sDateiname) - strlen($sSuffix)

);

Ab PHP 8.0 gibt es dafür str_ends_with(), das den gleichen Check in einer einzigen, lesbaren Zeile erledigt:

/* Modern: str_ends_with() ab PHP 8.0 */

$bIstPhp = str_ends_with($sDateiname, ".php");



/* Weitere Beispiele */

$bIstBild = str_ends_with($sDatei, ".jpg")

 || str_ends_with($sDatei, ".png");



$bIstArchiv = str_ends_with($sDatei, ".zip");

Empfehlung: Wenn du PHP 8.0 oder neuer einsetzt, verwende str_ends_with() für Suffix-Prüfungen. Es ist lesbarer, kürzer und du brauchst keine Längenberechnung. strrpos() bleibt das richtige Werkzeug, wenn du die tatsächliche Position brauchst, nicht nur ein Ja/Nein.

Das vorletzte Vorkommen finden

Wie findest du nicht das letzte, sondern das vorletzte Vorkommen? Dafür nutzt du den Offset-Parameter mit einem negativen Wert:

$sText = "a.b.c.d";



/* Letzter Punkt */

$iLetzte = strrpos($sText, ".");

// Ergebnis: 5



/* Vorletzter Punkt: negativen Offset setzen,

 der den letzten Treffer ausschliesst */

$iVorletzte = strrpos(

 $sText, ".",

 -(strlen($sText) - $iLetzte + 1)

);

// Ergebnis: 3



/* Drittletzter Punkt */

$iDrittletzte = strrpos(

 $sText, ".",

 -(strlen($sText) - $iVorletzte + 1)

);

// Ergebnis: 1

Das Pattern funktioniert so: Du berechnest einen negativen Offset, der den Suchbereich so begrenzt, dass der zuletzt gefundene Treffer nicht mehr enthalten ist. So arbeitest du dich Treffer für Treffer von hinten nach vorne durch.

Vergleich mit verwandten String-Funktionen

PHP bietet mehrere Funktionen für die Suche in Strings. Die folgende Übersicht zeigt die Unterschiede auf einen Blick.

Wann welche Funktion?

• strrpos() und strpos(): Wenn du die genaue Position brauchst.
• str_contains() (PHP 8.0): Wenn du nur wissen willst, ob ein Substring enthalten ist. Lesbarer als strrpos($s, $nadel) !== false.
• str_ends_with() (PHP 8.0): Für Suffix-Prüfungen.
• strrchr(): Wenn du nicht die Position brauchst, sondern den String-Teil ab dem letzten Vorkommen.

Multibyte-Strings: mb_strrpos() verwenden

strrpos() arbeitet bytebasiert. Bei Multibyte-Zeichen wie Umlauten, Emojis oder asiatischen Schriftzeichen kann das zu falschen Positionen führen. Verwende in solchen Fällen mb_strrpos() aus der mbstring-Extension.

$sText = "naïve façade";



/* Bytebasiert: kann falsche Position liefern */

$iPos = strrpos($sText, "a");



/* Zeichenbasiert: korrekte Position */

$iPosMB = mb_strrpos($sText, "a");



echo $iPosMB; // korrekte Position

Faustregel: Wenn du mit UTF-8 arbeitest und Sonderzeichen in deinen Daten vorkommen können, verwende immer mb_strrpos().

Best Practices und Performance

Für die meisten Anwendungsfälle ist strrpos() schnell genug. Trotzdem gibt es einige Tipps, die deinen Code robuster und lesbarer machen.

• Strikter Vergleich: Verwende immer === false statt == false, um die Stolperfalle mit Position 0 zu vermeiden.
• Offset gezielt nutzen: Begrenze den Suchbereich, wenn du weißt, dass relevante Daten nur in einem bestimmten Abschnitt liegen.
• Spezialisierte Funktionen bevorzugen: Für Dateipfade pathinfo() und basename(), für Suffix-Checks str_ends_with() (PHP 8.0+), für Existenzprüfungen str_contains() (PHP 8.0+).
• Lesbare Variablennamen: Schreibe $iLetzterPunkt statt $p, damit der Code selbsterklärend bleibt.

Reguläre Ausdrücke als Alternative

Wenn du nicht nach einem festen String, sondern nach einem Muster suchst, ist preg_match() die Alternative. Mit einem gierigen Quantor findest du automatisch das letzte Vorkommen:

$sText = "Fehler in Zeile 12, Fehler in Zeile 45";



/* Letztes Wort vor einem Doppelpunkt:

 greedy .* springt ans Ende */

preg_match('/.*Fehler in Zeile (\d+)/', $sText, $aM);

echo $aM[1]; // Ausgabe: 45

Für feste Strings bleibt strrpos() schneller und einfacher. Regex lohnt sich erst, wenn du nach variablen Mustern suchst.

Troubleshooting: Häufige Fehler vermeiden

Die meisten Probleme mit strrpos() entstehen durch den Rückgabewert oder falsche Annahmen über den Offset.

• 0 als false interpretiert: Immer === false verwenden, nie == false oder if ($iPos).
• Negativer Offset falsch verstanden: Ein negativer Offset begrenzt den Suchbereich vom Ende her. Er ändert nicht die Suchrichtung.
• Multibyte-Fehler: Bei UTF-8-Daten mit Sonderzeichen mb_strrpos() verwenden.
• Case-Sensitivity vergessen: Für Suche ohne Beachtung der Groß-/Kleinschreibung strripos() verwenden.
• Leerer Suchstring: Vor PHP 8.0 löst ein leerer Suchstring eine Warnung aus. Ab PHP 8.0 wird die String-Länge zurückgegeben.

Häufige Fragen (FAQ)

Hier findest du Antworten auf typische Fragen rund um strrpos().

Was ist der Unterschied zwischen strpos() und strrpos()?

strpos() findet das erste Vorkommen eines Substrings, strrpos() das letzte. Bei einem String mit mehreren Treffern liefern beide unterschiedliche Positionen. Gibt es nur einen Treffer, liefern beide dasselbe Ergebnis.

Wann strrpos() und wann strrchr()?

strrpos() gibt die Position (einen Integer) zurück. strrchr() gibt den String-Teil ab dem letzten Fund zurück. Wenn du nur den Rest ab dem letzten Trennzeichen brauchst, ist strrchr() kürzer. Wenn du die Position für weitere Berechnungen brauchst, nimm strrpos().

Muss ich immer mb_strrpos() verwenden?

Nein. Wenn du nur mit ASCII-Zeichen arbeitest (Buchstaben A-Z, Ziffern, einfache Satzzeichen), reicht strrpos() völlig aus. mb_strrpos() brauchst du erst, wenn Multibyte-Zeichen wie Umlaute, Emojis oder asiatische Schriftzeichen in deinen Daten vorkommen können.

Wie finde ich alle Vorkommen eines Substrings?

Dafür ist strrpos() nicht gedacht. Verwende eine Schleife mit strpos() und dem Offset-Parameter oder nutze preg_match_all() für einen Regex-basierten Ansatz.

Zusammenfassung

strrpos() findet die letzte Position eines Substrings in einem String. Die wichtigsten Punkte:

• Case-sensitive: Für case-insensitive Suche strripos() verwenden.
• Strikter Vergleich: Immer === false prüfen, weil Position 0 gültig ist.
• Kombination mit substr(): Das Standard-Pattern für das Extrahieren von Teilen vor oder nach dem letzten Vorkommen.
• Spezialisierte Alternativen: pathinfo() für Dateipfade, str_ends_with() für Suffix-Checks, str_contains() für Existenzprüfungen.
• Multibyte: Bei UTF-8 und Sonderzeichen mb_strrpos() nutzen.
• Verwandte Funktionen: strpos(), strrchr() und ab PHP 8.0 str_ends_with() und str_contains().

Wer die Stolperfallen kennt (besonders den Rückgabewert 0 vs. false), kann mit strrpos() flexibel Dateiendungen, URL-Segmente und Suffixe extrahieren oder prüfen.