Suchen und Ersetzen innerhalb von PHP

Sie befinden sich: Home > Php > Suchen und Ersetzen innerhalb von PHP

Für das Suchen und Ersetzen gibt es verschiedene Möglichkeiten innerhalb von PHP. Wir möchten Ihnen vor allem folgende Methoden aufzeigen:

Wichtiger Hinweis: Die Funktion ereg_replace() wurde in PHP 7.0 entfernt und ist nicht mehr verfügbar. Verwenden Sie stattdessen preg_replace() oder str_replace(). Die folgenden Beispiele dienen nur noch der Dokumentation.

ereg_replace war eine Methode, welche innerhalb eines Textes ein von Ihnen bestimmtes Suchwort suchte und dieses gegen ein von Ihnen gewünschtes Wort ersetzene.

Beachten Sie bitte dabei folgende Aspekte: Es ist wichtig, dass man bei Benutzung dieser Methode auf die Groß- und Kleinschreibung des zu suchenden Wortes achtet, denn diese Funktion unterscheidet dazwischen. So wird bei dem Suchwort 'bin' jedes Großgeschriebene 'BIN' im Text übergangen. Als weiteres gilt, dass wenn sie Zahlen ausgetauscht haben möchten, dass Sie diese in Hochkommas setzen, damit das Programm die Zahl nicht als eigenständige Zahl, sondern als Zeichen erkennt, denn nur dann kann es dieses auch als Ersetzungsmöglichkeit anerkennen.

Die Function ereg_replace() wird wie folgt aufgerufen:

<?php
$neuer_text = ereg_replace('zu suchender Text',
'ersetzender Text', $alter_text);
?>

Quelltext-Beispiel:

<?php
echo 'Hier ein Beispiel, dass Zahlen
hier leider nicht so genutzt werden können<br>';
$zahl = 5;
$txt = 'Auf der Weide vor
meinem Haus stehen fünf Schafe<br>';
echo $txt;
$txt = ereg_replace('fünf', $zahl, $txt);
echo $txt;
?>

Ausgabe :

Hier ein Beispiel, dass Zahlen hier leider nicht so genutzen werden können
Auf der Weide vor meinem Haus stehen fünf Schafe
Auf der Weide vor meinem Haus stehen  Schafe

Schreiben wir nun die gewünschte Zahl in Hochkommas, damit sie als Zeichen und nicht als Zahl erkannt wird, wird das Wort fünf durch die Ziffer 5 ersetzen.

Beispiel :

<?php
echo 'Hier ein Beispiel, dass Zahlen
hier leider nicht so genutzt werden können<br>';
$zahl = '5';
$txt = 'Auf der Weide vor
meinem Haus stehen fünf Schafe<br>';
echo $txt;
$txt = ereg_replace('fünf', $zahl, $txt);
echo $txt;
?>

Auch str_replace sucht aus einer Ansammlung von Zeichen sich den gewünschten Wortlaut oder Buchstaben raus und ersetzen ihn durch einen Neuen. Auch hier gilt auf die genaue Groß- und Kleinschreibung zu achten, damit die Methode all die von Ihnen gewünschten Worte finden kann.

Die Syntax hierzu lautet :

<?php
$neuer_text = str_replace("gesuchter Text", "Ersetzung_durch", "Zeichenfolge");
?>

<?php
$wort = "Klettergerüst";
echo str_replace("Kletter", "Kinder", $wort);
?>

<?php
$text = "In diesen Test möchten wir die ";
$text .= "Wörter: Sonne, Flut und Erde ersetzen.<br>";
echo $text;

/**
* $array_suche zusammen bauen
*/
$array_suche[0] = "Erde";
$array_suche[1] = "Sonne";
$array_suche[2] = "Flut";

/**
* $array_ersetzen  zusammen bauen
*/
$array_ersetzen[0] = "Sand";
$array_ersetzen[1] = "Mond";
$array_ersetzen[2] = "Ebbe";

$neuer_text = str_replace($array_suche, $array_ersetzen,
$text);
echo $neuer_text;
?>

Ausgabe:

In diesen Test möchten wir die Wörter: Sonne, Flut und Erde ersetzen.
In diesen Test möchten wir die Wörter: Mond, Ebbe und Sand ersetzen.

Achten Sie nicht auf die Reihenfolge bei den Array`s, kann es dazu kommen, dass Sie nicht das erwünschte Ergebnis bekommen. Mann kann natürlich jedes Array Element einzeln ersetzen, das könnte man z.b. mit eine for() Schleife machen.

Dazu möchten wir Ihnen ein weiteres Beispiel aufzeigen:

<?php
$text = 'Wenn ich wüsste was ich möchte, ';
$text .= 'wäre die Entscheidung nur halb <br>';
echo $text;
$zeichen = array("ü", "ö", "ä");
$ersetzen = array("ue", "oe", "ae");
/**
* Mit einer for() Schleife jedes Zeichen
* einzeln ersetzten.
*/
for ($x = 0; $x < 3; $x++) {
    $text = str_replace($zeichen[$x], $ersetzen[$x],
$text);
    echo $text;
}
?>

Wenn ich wüsste was ich möchte, wäre die Entscheidung nur halb
Wenn ich wuesste was ich möchte, wäre die Entscheidung nur halb
Wenn ich wuesste was ich moechte, wäre die Entscheidung nur halb
Wenn ich wuesste was ich moechte, waere die Entscheidung nur halb
Wenn ich wuesste was ich moechte, waere die Entscheidung nur halb

Natürlich muss man nicht unbedingt eine for Schleife verwenden um z.B. mehrere Buchstaben zu ersetzen. Man hat bei der Funktion str_replace() mit der Verbindung array_keys() und array_values() die Möglichkeit, mehrere Buchstaben zu ersetzen. Nachfolgend finden sie ein Beispiel, womit man bei einem Dateinamen, alle Umlaute sowie Sonderzeichen ersetzen kann.

Beispiel für Umlaute im Dateinamen ersetzen:

<?php
$filename = 'ärger müller.jpg';
$umlaute = array(
'ä' => 'ae',
'Ä' => 'ae',
'ß' => 'ss',
'ö' => 'oe',
'Ö' => 'oe',
'ü' => 'ue',
'ü' => 'ue',
' ' => '-',
'à' => 'a',
'è' => 'e',
'ê' => 'e'
);
$filename = str_replace(array_keys($umlaute),
array_values($umlaute), $filename);
echo $filename;
?>

Ausgabe:

aerger-mueller.jpg

Eine weitere Erklärung der PHP-Funktion str_replace() finden Sie in unserer Tutorial Datenbank. Bei dieser Erklärung, wird erklärt wie man "Das Vorkommen eines Zeichens in einer Zeichenkette suchen und mit einer eigenen String ersetzen" kann.

<?php
$neuer_text = preg_match(
'Zu suchender Ausdruck',
'innerhalb dieses Textes',
$rueckgaben_array,
PREG_OFFSET_CAPTURE,
$offset);
?>

Quelltext-Beispiel mit der Angabe von PREG_OFFSET_CAPTURE:

<?php
$text = "Affenschaukel";
$suche = '/^schaukel/';
preg_match($suche, substr($text, 5), $array,
PREG_OFFSET_CAPTURE);
print_r($array);
?>

<?php
$text = "ersttextunddannzahl716767diesertextwirdnichtgefunden";
$suche = '/([a-zA-Z]{1,4})([0-9]{1,7})/is';
preg_match($suche, $text, $array);
print_r($array);
?>

Ausgabe:

Array
(
   [0] => zahl716767
   [1] => zahl
   [2] => 716767
)

Desweiteren möchten wir Sie auf Sonderzeichen aufmerksam machen. Unlesbare Sonderzeichen treten ungewollt auf, wenn man zum Beispiel beim Aufbau seiner Homepage auf das Charset UTF-8 benutzen. Dabei werden alle Umlaute oder andere Sonderzeichen, wie Punkte, Komma, Backslashs usw ,in “named entities” übersetzen werden und dadurch kaum noch zu lesen, sondern nur noch zu erraten werden für die Leser.

ä = ä , ö = ö ..usw. natürlich kann man dieses Problem beheben, wenn man zum Beispiel eine der oben genannten Methoden benutzen um diese Zeichen auszuwechseln. Man kann natürlich dann jeden Schritt einzeln vollziehen, dies jedoch führt zu einem sehr langen, möglicherweise unübersichtlichen Quelltext mit sehr viel Arbeit führt, oder man benutzen hier bei eine Schleifenfunktion und zwei Arrays.

In dem ersten Array sollten die gesuchten Zeichenfolgen enthalten sein, in dem zweiten Array die Richtigstellung dieser Zeichenfolgen. Die Schleife sollte dann genau darauf abgestimmt sein all diese Zeichen zu erreichen und zu ersetzen, damit Ihr Text wieder für jeden klar lesbar wird.

Anm.: Alternativ kann man auch noch den PHP Befehl strtr() für den austausch von Zeichen in einer Zeichenkette mit einer Austauschliste verwenden. Dieser eignet sich besonders gut, wenn man zum Beispiel kaputte Umlaute über ein Mehrdimensionales Array innerhalb eines Textes ersetzen möchte.

str_replace vs str_ireplace: Groß- und Kleinschreibung im Griff

Die klassische str_replace()-Funktion arbeitet immer streng nach Groß- und Kleinschreibung. Suchst Sie nach "PHP", findet sie keinen einzigen Treffer in einem Satz, der nur das Wort "php" enthält. Genau hier kommt str_ireplace() ins Spiel. Das kleine i im Namen steht für insensitive und sorgt dafür, dass die Funktion Groß- und Kleinschreibung ignoriert. Vom Verhalten her ist sie ansonsten identisch zur Schwesterfunktion. Die Wahl zwischen beiden ist im Alltag oft eine Frage der Datenqualität Ihrer Eingaben.

<?php
declare(strict_types=1);

$text = 'PHP ist toll, php auch, und PhP sowieso.';

/* Strenges Ersetzen: nur exakte Schreibweise wird getroffen. */
echo str_replace('PHP', 'Python', $text);
/* Ausgabe: Python ist toll, php auch, und PhP sowieso. */

echo "\n";

/* Case-insensitive: alle Varianten werden ersetzt. */
echo str_ireplace('PHP', 'Python', $text);
/* Ausgabe: Python ist toll, Python auch, und Python sowieso. */

Achten Sie darauf, dass str_ireplace() intern aufwendiger arbeitet, weil sie für jeden Vergleich die Groß- und Kleinschreibung normalisieren muss. Bei riesigen Texten und sehr vielen Aufrufen kann das einen messbaren Unterschied machen.

str_replace mit Arrays: mehrere Suchbegriffe in einem Aufruf

Eine der unterschätzten Stärken von str_replace() ist die Array-Variante. Sie können sowohl im Such- als auch im Ersetzungs-Parameter ein Array übergeben und damit mehrere Begriffe in einem einzigen Funktionsaufruf verarbeiten. Das ist deutlich schneller als eine Schleife mit vielen Einzelaufrufen, weil PHP intern den String nur einmal durchläuft.

<?php
declare(strict_types=1);

$text = 'Hallo Welt, schoenen Tag noch!';

$suche    = ['Hallo', 'Welt', 'Tag'];
$ersetze  = ['Hi',    'Erde', 'Morgen'];

echo str_replace($suche, $ersetze, $text);
/* Ausgabe: Hi Erde, schoenen Morgen noch! */

Ein Stolperstein lauert in der Reihenfolge der Ersetzungen. PHP arbeitet das Such-Array von vorn nach hinten ab und wendet jeden Treffer sichekt auf den bereits veränderten String an. Wenn ein späteres Suchwort durch eine frühere Ersetzung erst entsteht, wird es ebenfalls gefunden. In solchen Fällen ist strtr() mit einem assoziativen Array die sicherere Wahl, weil dort jede Ersetzung nur einmal greift und parallel statt sequentiell läuft.

preg_replace: Regex für Muster statt fester Begriffe

Sobald Sie nicht mehr nach festen Strings suchen, sondern nach Mustern, ist preg_replace() Ihr Werkzeug. Die Funktion akzeptiert einen regulären Ausdruck als Suchmuster und kann damit Dinge erledigen, an denen str_replace() scheitert. Das volle Spektrum zeigt das Tutorial zu preg_replace().

<?php
declare(strict_types=1);

$text = 'Telefon: 0211 / 123-456-789';

/* Alle nicht-Ziffern entfernen. */
echo preg_replace('/[^0-9]/', '', $text);
/* Ausgabe: 0211123456789 */

/* Mehrfach-Whitespace zu einem Leerzeichen normalisieren. */
$schmutz = "Hallo    Welt\n\n   PHP";
echo preg_replace('/\s+/', ' ', $schmutz);
/* Ausgabe: Hallo Welt PHP */

Achten Sie auf die Performance-Falle. Reguläre Ausdrücke sind mächtig, aber für simple Suchen deutlich langsamer als str_replace(). Für Validierung statt Ersetzung greifst Sie sinnvoller zu preg_match() oder zur Zerlegung mit preg_split().

preg_replace_callback: dynamische Ersetzung pro Treffer

Manchmal reicht ein statischer Ersetzungs-String nicht aus. Sie wollen pro Treffer eine eigene Logik laufen lassen, etwa eine Berechnung, eine Datenbankabfrage oder eine Formatierung. Genau dafür gibt es preg_replace_callback(). Statt eines festen Ersetzungstextes übergeben Sie eine Funktion, die für jeden Treffer aufgerufen wird und das Match-Array bekommt. Was sie zurückgibt, ersetzen den Treffer im Original-String. Die ausführliche Variante mit allen Optionen finden Sie im Tutorial zu preg_replace_callback().

<?php
declare(strict_types=1);

$text = 'Preise: 10 EUR, 25 EUR und 99 EUR.';

$brutto = preg_replace_callback(
    '/(\d+)\s+EUR/',
    static function (array $match): string {
        $netto  = (int) $match[1];
        $brutto = (int) round($netto * 1.19);
        return $brutto . ' EUR';
    },
    $text
);

echo $brutto;
/* Ausgabe: Preise: 12 EUR, 30 EUR und 118 EUR. */

Der Callback bekommt ein Match-Array, in dem Index 0 den kompletten Treffer und alle weiteren Indizes die Capture-Gruppen enthalten. Typische Anwendungen sind Markdown-Konvertierung, Template-Engines, Smiley-Ersetzung oder das Anonymisieren personenbezogener Daten.

strtr: blitzschnelles Multi-Replace ohne Reihenfolge-Stress

Wer mehrere Ersetzungen in einem Rutsch erledigen will und dabei Probleme mit der Reihenfolge umgehen möchte, greift zu strtr(). Die Funktion arbeitet mit einem assoziativen Array aus Such- zu Ersetzungswerten und läuft dabei intern sehr schnell. Der große Unterschied zu str_replace() mit Arrays: strtr() wendet jede Ersetzung nur ein einziges Mal pro Position an. Tiefer steigst Sie im Tutorial zu strtr() ein.

<?php
declare(strict_types=1);

$mapping = [
    'A' => 'B',
    'B' => 'C',
];
echo strtr('AB', $mapping);   /* Ausgabe: BC, wie erwartet */
echo str_replace(['A', 'B'], ['B', 'C'], 'AB'); /* Ausgabe: CC! */

Das letzte Beispiel zeigt anschaulich, warum strtr() bei Template-Engines und Variablen-Ersetzung die bessere Wahl ist. Aus A wird B, dieses neue B wird bei str_replace() dann erneut zu C umgeschrieben. strtr() dagegen ersetzen jede Position genau einmal, ganz unabhängig davon, was die Ersetzung produziert.

substr_replace: positionsbasiertes Ersetzen ohne Suchen

Manchmal wissen Sie genau, an welcher Position im String etwas geändert werden muss, und müssen gar nicht erst suchen. Genau hier setzen substr_replace() an. Die Funktion bekommt einen Start-Offset und eine Länge und ersetzen das Stück dazwischen durch Ihren neuen Wert.

<?php
declare(strict_types=1);

$kreditkarte = '4539123456789012';

/* Mittlere acht Ziffern durch Sterne ersetzen. */
$maskiert = substr_replace($kreditkarte, '********', 4, 8);
echo $maskiert;
/* Ausgabe: 4539********9012 */

/* Etwas einfuegen, ohne zu loeschen: Laenge auf 0 setzen. */
$satz = 'Hallo Welt';
echo substr_replace($satz, ' liebe', 5, 0);
/* Ausgabe: Hallo liebe Welt */

Die Funktion ist die mit Abstand schnellste der hier vorgestellten Replace-Varianten, weil sie weder suchen noch vergleichen muss. In Kombination mit strpos() oder strlen() entstehen daraus aber sehr effiziente Manipulations-Pipelines.

Performance-Vergleich: was wann am schnellsten ist

Die Frage nach der schnellsten Replace-Funktion lässt sich nicht pauschal beantworten, aber es gibt eine grobe Hierarchie. Ganz oben stehen strtr() mit assoziativem Array und substr_replace() bei bekannter Position. Beide arbeiten ohne aufwendige Suche und sind extrem schnell. Sichekt dahinter folgt str_replace(), das in C implementiert ist und kein Regex-Parsing benötigt. Deutlich langsamer sind die preg_*-Funktionen, weil sie Muster kompilieren und mit dem PCRE-Backend arbeiten müssen.

<?php
declare(strict_types=1);

$text  = str_repeat('Hallo Welt, das ist ein Test. ', 5000);
$start = hrtime(true);

$out = str_replace(['Hallo', 'Welt', 'Test'], ['Hi', 'Erde', 'Versuch'], $text);
$t1  = (hrtime(true) - $start) / 1e6;

$start = hrtime(true);
$out = strtr($text, [
    'Hallo' => 'Hi',
    'Welt'  => 'Erde',
    'Test'  => 'Versuch',
]);
$t2 = (hrtime(true) - $start) / 1e6;

echo sprintf("str_replace: %.2f ms\nstrtr: %.2f ms\n", $t1, $t2);

Wichtig ist die Aussage: Wenn Sie keine Muster brauchen, vermeide Regex. Sie verlierst dadurch nicht nur Geschwindigkeit, sondern auch Lesbarkeit, weil Regex-Patterns für Aussenstehende oft kryptisch wirken. Mehr zur Messung von Laufzeiten finden Sie im Tutorial zu microtime() und hrtime().

Mermaid: Wann welche Funktion?

Bei der Auswahl der richtigen Replace-Funktion hilft eine kleine Entscheidungsskizze. Die wichtigste Frage ist immer: Suchst Sie nach festen Begriffen oder nach einem Muster? Daran hängen alle weiteren Entscheidungen.

flowchart TD
    A[Was willst du ersetzen?] --> B{Festes Wort oder Muster?}
    B -- Festes Wort --> C{Eine oder mehrere?}
    B -- Muster --> D{Statisch oder dynamisch?}
    C -- Eine --> E[str_replace]
    C -- Mehrere --> F[strtr]
    D -- Statisch --> G[preg_replace]
    D -- Dynamisch --> H[preg_replace_callback]

Die Skizze deckt die häufigsten Fälle ab. Bei festen Suchbegriffen reicht str_replace() oder bei mehreren Ersetzungen strtr(). Sobald Muster ins Spiel kommen, wird Regex nötig. Statische Ersetzung übernimmt preg_replace(), dynamische Logik pro Treffer regelt preg_replace_callback().

Praxisbeispiel: Markdown-zu-HTML Mini-Konverter

Zum Abschluss bringen wir alle Konzepte in einem realen Mini-Projekt zusammen. Wir bauen einen einfachen Markdown-zu-HTML-Konverter, der die wichtigsten Auszeichnungen versteht und dabei alle vorgestellten Funktionen in ihrer typischen Rolle einsetzen.

<?php
declare(strict_types=1);

function markdownToHtml(string $md): string
{
    /* 1. Erst HTML-Sonderzeichen sicher escapen. */
    $html = htmlspecialchars($md, ENT_QUOTES | ENT_HTML5, 'UTF-8');

    /* 2. preg_replace_callback fuer Code-Bloecke (dynamisch). */
    $html = preg_replace_callback(
        '/```(.*?)```/s',
        static function (array $m): string {
            return '<pre><code>' . trim($m[1]) . '</code></pre>';
        },
        $html
    );

    /* 3. preg_replace fuer Inline-Muster (statisch, mit Backrefs). */
    $html = preg_replace('/\*\*(.+?)\*\*/', '<strong>$1</strong>', $html);
    $html = preg_replace('/\*(.+?)\*/',           '<em>$1</em>',     $html);

    /* 4. preg_replace fuer Header. */
    $html = preg_replace('/^### (.+)$/m', '<h3>$1</h3>', $html);
    $html = preg_replace('/^## (.+)$/m',  '<h2>$1</h2>', $html);
    $html = preg_replace('/^# (.+)$/m',   '<h1>$1</h1>', $html);

    /* 5. strtr fuer simple Smiley-Ersetzung (multi-replace). */
    $html = strtr($html, [':)' => 'happy', ':(' => 'sad']);

    /* 6. str_replace fuer Zeilenumbrueche zu br. */
    $html = str_replace("\n", "<br>\n", $html);

    return $html;
}

Der Konverter zeigt jede Funktion in ihrer Stärke. htmlspecialchars() sorgt für sichere Ausgabe, preg_replace_callback() übernimmt die dynamische Code-Block-Verarbeitung mit Trimming, preg_replace() erledigt die statischen Backreference-Muster für Bold, Italic und Headlines. strtr() ersetzen die Smileys parallel und ohne Reihenfolge-Probleme, und das abschliessende str_replace() ist die schnellste Wahl für die einfache Newline-zu-br-Konvertierung.

Wenn Sie diesen Konverter erweitern wollen, können Sie Listen, Links und Tabellen ergänzen, Bilder einbauen oder das Ergebnis durch strip_tags() mit einer Allowlist filtern. Wichtig ist nur, dass Sie sich bei jeder neuen Regel kurz die Frage aus der Mermaid-Skizze stellst. Festes Wort oder Muster, eine oder mehrere Ersetzungen, statisch oder dynamisch.