Wie oft steht ein Wort in einem Text? Wie viele Absätze hat ein HTML-Dokument? Solche Fragen tauchen im Backend ständig auf, beim Auswerten von Nachrichten genauso wie beim schnellen Prüfen importierter Daten. PHP beantwortet sie mit einer einzigen Funktion, die ohne reguläre Ausdrücke auskommt und direkt eine Zahl liefert. Dieses Tutorial zeigt ihre vier Parameter, zwei Eigenheiten, die regelmäßig für Fehler sorgen, und wann der Wechsel zu einer Regex-Lösung sinnvoll ist.
Was macht die Funktion PHP substr_count()?
Wer in PHP wissen will, wie oft ein bestimmtes Wort in einem String vorkommt, wie viele HTML-Tags ein Dokument enthält oder wie häufig ein Hashtag in einer Nachricht auftaucht, greift zu PHP substr_count. Die Funktion durchsucht einen String nach einem Suchmuster und liefert die Anzahl der Treffer als Integer zurück. Sie ist damit der Standard-Helfer, sobald die Frage "wie oft kommt X in Y vor" beantwortet werden muss.
Bevor Syntax und die optionalen Bereichs-Parameter folgen, lohnt sich ein Vergleich mit preg_match_all und ein Hinweis zu zwei Eigenheiten, die in der Praxis schnell zu Bugs führen.
Im Vergleich zu komplexeren Suchfunktionen wie preg_match_all hat PHP substr_count zwei Vorteile: Sie arbeitet ohne reguläre Ausdrücke, was sie schneller macht, und sie liefert direkt einen Integer statt eines Treffer-Arrays. Wer nur die Anzahl braucht, spart damit sowohl Code als auch Laufzeit. Allerdings hat die Funktion zwei Eigenheiten, die in der Praxis schnell zu Bugs führen: Sie ist case-sensitive, und sie zählt keine überlappenden Treffer.
Syntax und alle vier Parameter
Die Signatur akzeptiert zwei bis vier Argumente. Pflicht sind das durchsuchte String und der Needle, optional sind Offset und Length zur Begrenzung des Suchbereichs.
<?php
substr_count(
string $haystack,
string $needle,
int $offset = 0,
?int $length = null
): int
Der Rückgabewert ist immer ein Integer, auch bei null Treffern. Wer mit einem leeren Needle arbeitet, fängt sich seit PHP 8 einen ValueError ein, denn ein leerer Suchstring ergibt keine sinnvolle Zählung. Die Suche ist case-sensitive, das heißt 'PHP' und 'php' sind unterschiedliche Strings. Wer beides zählen möchte, kombiniert mit mb_strtolower() (siehe weiter unten).
Offset und Length zur Bereichsbegrenzung
Mit Offset und Length lässt sich die Suche auf einen Teilbereich des Haystack beschränken. Das ist nützlich, wenn etwa nur die ersten 1000 Zeichen einer Antwort durchsucht werden sollen, oder wenn die Prüfung erst nach einem Header-Bereich beginnen soll.
<?php
$text = 'PHP ist toll, PHP ist schnell, PHP rockt';
echo substr_count($text, 'PHP') . "\n";
/* 3 */
echo substr_count($text, 'PHP', 14) . "\n";
/* 2 - die ersten 14 Zeichen werden ignoriert */
echo substr_count($text, 'PHP', 14, 9) . "\n";
/* 1 - nur ein Bereich von 9 Zeichen ab Position 14 */
Negative Offsets sind seit PHP 7.1 erlaubt und zählen vom Ende des Strings. Wer in den letzten 100 Zeichen suchen will, gibt -100 als Offset und kein Length an. Achtung: Wenn Offset plus Length über das Ende des Strings hinaus geht, wirft PHP substr_count seit PHP 8 einen ValueError. Vorher gab es eine Warnung und das Ergebnis war ungenau.
Wichtig - keine überlappenden Treffer
Die wichtigste Stolperfalle: PHP substr_count zählt keine Überlappungen. Wer im String 'aaaa' nach 'aa' sucht, bekommt 2 zurück, nicht 3. Die Funktion arbeitet sequenziell: Sobald ein Treffer gefunden wurde, beginnt die nächste Suche unmittelbar nach diesem Treffer.
<?php
echo substr_count('aaaa', 'aa');
/* 2 - nicht 3 */
echo substr_count('abababab', 'abab');
/* 2 - nicht 3 */
Wer Überlappungen mitzählen muss, ist bei PHP substr_count an der falschen Adresse und sollte preg_match_all mit Lookahead nutzen. In der Praxis ist das aber selten relevant, weil Tag-Counter, Wortvorkommen und Hashtag-Statistiken naturgemäß keine Überlappung haben können.
Case-Sensitivity und stripos-Workaround
PHP substr_count unterscheidet zwischen Groß- und Kleinschreibung. Wer alle Varianten von 'php', 'PHP' und 'Php' zusammenfassen möchte, hat zwei Wege: einmal mit mb_strtolower() beide Strings auf Kleinschreibung normalisieren, oder direkt zu preg_match_all mit dem i-Flag wechseln.
<?php
$text = 'php ist toll, PHP ist schnell, Php rockt';
$strict = substr_count($text, 'PHP');
echo "Strikt: $strict" . "\n";
/* 1 - nur das mittlere PHP */
$lowered = substr_count(
mb_strtolower($text),
mb_strtolower('PHP')
);
echo "Case-Insensitive: $lowered";
/* 3 - alle Varianten */
Die Variante mit mb_strtolower() ist die schnelle, multibyte-sichere Lösung. Wer mit reinem ASCII arbeitet, kann auch strtolower() verwenden, riskiert dabei aber, dass Umlaute nicht korrekt klein geschrieben werden. Im deutschsprachigen Kontext ist die mb-Variante die robustere Wahl.
Multibyte mit mb_substr_count
Die Funktion mb_substr_count() ist die zeichenbasierte Schwester von PHP substr_count. Sie verhält sich identisch, arbeitet aber zeichenbasiert statt bytebasiert. Bei reinen ASCII-Texten ist der Unterschied unsichtbar, sobald aber Multibyte-Zeichen ins Spiel kommen, ist mb_substr_count die korrekte Wahl.
<?php
$text = 'für jüngere Mädchen';
echo strlen($text) . "\n";
/* 22 - byte-basiert, ä, ö, ü zaehlen je 2 Bytes */
echo mb_strlen($text) . "\n";
/* 19 - zeichenbasiert, korrekt */
echo substr_count($text, 'ä') . "\n";
/* 1 - byte-basierte Suche, zufaellig korrekt */
echo mb_substr_count($text, 'ä'). "\n";
/* 1 - zeichenbasiert, robust auch bei Mischzeichen */
Im Alltag macht der Unterschied vor allem bei Texten mit echten UTF-8-Sonderzeichen einen Unterschied, etwa beim Zählen von Emoji-Vorkommen oder bei chinesischen, japanischen oder arabischen Texten. Wer für ein Multilingual-System schreibt, sollte standardmäßig zur mb-Variante greifen.
Praxisbeispiel HTML-Tag-Counter
Ein klassischer Anwendungsfall ist die schnelle Statistik über HTML-Inhalte. PHP substr_count ist dafür perfekt geeignet, weil keine vollständige DOM-Analyse nötig ist und nur grobe Zählungen verlangt werden.
<?php
$html = file_get_contents('seite.html');
echo 'P-Absaetze: ' . substr_count($html, '<p') . "\n";
echo 'H2-Header: ' . substr_count($html, '<h2') . "\n";
echo 'Bilder: ' . substr_count($html, '<img') . "\n";
echo 'Links: ' . substr_count($html, '<a ') . "\n";
/* schnelle Statistik ohne DOM-Parser */
Die Methode ist nicht hundertprozentig genau, weil etwa selbstschließende Tags oder kommentierter Code mitgezählt werden. Für eine grobe Sektion-Übersicht im Backoffice oder einen Sanity-Check beim Import ist sie aber ausreichend. Wer eine exakte Auswertung braucht, wechselt zu DOMDocument.
substr_count vs preg_match_all
Die häufigste Frage im Code-Review ist, ob PHP substr_count oder preg_match_all genutzt werden soll. Die Antwort hängt von der Art des Suchmusters ab. Bei festen Strings ohne Variation ist substr_count die richtige Wahl, weil sie ohne Regex-Engine arbeitet und damit deutlich schneller ist. Sobald Variationen ins Spiel kommen (Wildcards, Fall-Insensitive in einer Operation, Zeichengruppen), ist preg_match_all die richtige Wahl.
<?php
$text = 'PHP, PHP-Backend, phpStorm, Vue.js';
$einfach = substr_count($text, 'PHP');
echo "substr_count: $einfach" . "\n";
/* 2 - nur exakte PHP-Treffer */
preg_match_all('/PHP/i', $text, $m);
echo "preg_match_all: " . count($m[0]);
/* 3 - case-insensitive durch /i */
Faustregel: PHP substr_count für feste Strings, preg_match_all für Muster. Wer nur die Anzahl braucht und kein Treffer-Array, sollte substr_count zumindest als ersten Versuch wagen, weil die Performance-Unterschiede bei großen Texten messbar sind.
Der folgende Ablauf zeigt, wie die Funktion einen Suchlauf abarbeitet.
flowchart TD
A[Haystack-String] --> B[Needle festlegen]
B --> C{Offset und Length gesetzt?}
C -->|nein| D[Vollstaendige Suche]
C -->|ja| E[Suche im Teilbereich]
D --> F[Anzahl als Integer]
E --> F
Fazit
Mit PHP substr_count steht ein einfacher und schneller Helfer für Vorkommens-Zählungen bereit. Die Funktion akzeptiert vier Parameter, ist case-sensitive, zählt keine Überlappungen und liefert immer einen Integer. Im Vergleich zu preg_match_all ist sie deutlich schneller, solange das Suchmuster ein fester String ist. Für multibyte-sichere Zählungen lohnt der Wechsel zu mb_substr_count(), für case-insensitive Treffer der Umweg über mb_strtolower() oder direkt zu preg_match_all mit dem i-Flag. Damit ist PHP substr_count die richtige Wahl für HTML-Tag-Counter, Hashtag-Statistiken, Wortvorkommen und alle anderen Fälle, in denen ein fester Teilstring schnell gezählt werden soll.
