In MySQL der REGEXP_REPLACE() Die Funktion ersetzt Vorkommen des Teilstrings innerhalb eines Strings, der mit dem angegebenen regulären Ausdrucksmuster übereinstimmt.
Der gesamte String wird zusammen mit den Ersetzungen zurückgegeben.
Wenn es keine Übereinstimmung gibt (d. h. die Eingabezeichenfolge enthält die Teilzeichenfolge nicht), wird die gesamte Zeichenfolge unverändert zurückgegeben.
Syntax
Die Syntax lautet wie folgt:
REGEXP_REPLACE(expr, pat, repl[, pos[, occurrence[, match_type]]])
Wobei expr ist die Eingabezeichenfolge und pat ist das reguläre Ausdrucksmuster für die Teilzeichenfolge. Der repl Argument ist die Ersetzungszeichenfolge.
Die optionale pos Mit dem Argument können Sie eine Position innerhalb der Zeichenfolge angeben, an der die Suche gestartet werden soll. Wenn weggelassen, beginnt es an Position 1.
Das optionale occurrence Mit dem Argument können Sie angeben, nach welchem Vorkommen der Übereinstimmung gesucht werden soll. Wenn weggelassen, werden alle Vorkommen ersetzt.
Der optionale match_type Argument ist eine Zeichenfolge, die angibt, wie der Abgleich durchgeführt wird. Dadurch können Sie den regulären Ausdruck verfeinern. Beispielsweise können Sie dieses Argument verwenden, um die Groß-/Kleinschreibung zu bestimmen oder nicht.
Beispiel 1 – Grundlegende Verwendung
Hier ist ein einfaches Beispiel:
SET @str = 'It was good'; SELECT @str 'Original String', REGEXP_REPLACE(@str, 'good', 'great!') 'Result';
Ergebnis:
+-----------------+---------------+ | Original String | Result | +-----------------+---------------+ | It was good | It was great! | +-----------------+---------------+
In diesem Fall gibt es eine Übereinstimmung und der String wird mit der Änderung zurückgegeben.
Beispiel 2 – Mehrere Übereinstimmungen
Wenn es mehrere Übereinstimmungen innerhalb der Zeichenfolge gibt, werden standardmäßig alle ersetzt:
SET @str = 'Cat Dog Cat Dog Cat'; SELECT @str 'Original String', REGEXP_REPLACE(@str, 'Cat', 'Tiger') 'Result';
Ergebnis:
+---------------------+---------------------------+ | Original String | Result | +---------------------+---------------------------+ | Cat Dog Cat Dog Cat | Tiger Dog Tiger Dog Tiger | +---------------------+---------------------------+
Sie haben jedoch auch die Möglichkeit, anzugeben, welches Vorkommen Sie ersetzen möchten (dazu später mehr).
Beispiel 3 – Keine Übereinstimmung
Hier ist ein Beispiel, bei dem es keine Übereinstimmung gibt:
SET @str = 'Cat Dog Cat Dog Cat'; SELECT @str 'Original String', REGEXP_REPLACE(@str, 'Cow', 'Tiger') 'Result';
Ergebnis:
+---------------------+---------------------+ | Original String | Result | +---------------------+---------------------+ | Cat Dog Cat Dog Cat | Cat Dog Cat Dog Cat | +---------------------+---------------------+
Es gibt keine Übereinstimmung, daher wird die Zeichenfolge unverändert zurückgegeben.
Beispiel 4 – Die pos Argument
Hier ist ein Beispiel für die Angabe der Startposition:
SET @str = 'Cat Dog Cat Dog Cat'; SELECT @str 'Original String', REGEXP_REPLACE(@str, 'Cat', 'Tiger', 2) 'Result';
Ergebnis:
+---------------------+-------------------------+ | Original String | Result | +---------------------+-------------------------+ | Cat Dog Cat Dog Cat | Cat Dog Tiger Dog Tiger | +---------------------+-------------------------+
Wir haben an Position 2 begonnen, die nach dem Beginn des ersten Vorkommens kommt, also wirkt sich der Ersetzungsvorgang nur auf die Vorkommen aus, die nach dem ersten kommen.
Beispiel 5 – Das occurrence Argument
Wie bereits erwähnt, werden standardmäßig alle Vorkommen ersetzt. Sie haben jedoch auch die Möglichkeit, ein bestimmtes zu ersetzendes Vorkommen anzugeben, indem Sie den occurrence verwenden Streit. Hier ist ein Beispiel:
SET @str = 'Cat Dog Cat Dog Cat'; SELECT @str 'Original String', REGEXP_REPLACE(@str, 'Cat', 'Tiger', 1, 2) 'Result';
Ergebnis:
+---------------------+-----------------------+ | Original String | Result | +---------------------+-----------------------+ | Cat Dog Cat Dog Cat | Cat Dog Tiger Dog Cat | +---------------------+-----------------------+
In diesem Fall beginnen wir an Position 1. Wenn wir jedoch an einer anderen Position beginnen, ist das Ergebnis anders:
SET @str = 'Cat Dog Cat Dog Cat'; SELECT @str 'Original String', REGEXP_REPLACE(@str, 'Cat', 'Tiger', 2, 2) 'Result';
Ergebnis:
+---------------------+-----------------------+ | Original String | Result | +---------------------+-----------------------+ | Cat Dog Cat Dog Cat | Cat Dog Cat Dog Tiger | +---------------------+-----------------------+
Dies geschah, weil unsere Startposition kam, nachdem das erste Ereignis begonnen hatte. Daher wurde Ereignis 2 zu Ereignis 1 und Ereignis 3 wurde Ereignis 2.
Der Standardwert für das Vorkommensargument ist 0 , was bedeutet, dass alle Vorkommen ersetzt werden. Mit anderen Worten, wenn Sie dieses Argument weglassen, werden alle Vorkommen ersetzt (wie wir in den vorherigen Beispielen gesehen haben). Hier ist ein Beispiel für die explizite Angabe aller Vorkommen:
SET @str = 'Cat Dog Cat Dog Cat'; SELECT @str 'Original String', REGEXP_REPLACE(@str, 'Cat', 'Tiger', 1, 0) 'Result';
Ergebnis:
+---------------------+---------------------------+ | Original String | Result | +---------------------+---------------------------+ | Cat Dog Cat Dog Cat | Tiger Dog Tiger Dog Tiger | +---------------------+---------------------------+
Beispiel 6 – Der match_type Argument
Sie können ein zusätzliches Argument angeben, um den Übereinstimmungstyp zu bestimmen. Auf diese Weise können Sie beispielsweise angeben, ob bei der Übereinstimmung zwischen Groß- und Kleinschreibung unterschieden wird, ob Zeilenabschlüsse eingefügt werden sollen usw.
Hier ist ein Beispiel für die Angabe einer Übereinstimmung mit Berücksichtigung der Groß- und Kleinschreibung und einer Übereinstimmung ohne Berücksichtigung der Groß-/Kleinschreibung:
SET @str = 'Cat Dog Cat Dog Cat'; SELECT @str 'Original String', REGEXP_REPLACE(@str, 'cat', 'Tiger', 1, 0, 'c') 'Case-Sensitive', REGEXP_REPLACE(@str, 'cat', 'Tiger', 1, 0, 'i') 'Case-Insensitive';
Ergebnis:
+---------------------+---------------------+---------------------------+ | Original String | Case-Sensitive | Case-Insensitive | +---------------------+---------------------+---------------------------+ | Cat Dog Cat Dog Cat | Cat Dog Cat Dog Cat | Tiger Dog Tiger Dog Tiger | +---------------------+---------------------+---------------------------+
Der match_type Das Argument kann die folgenden Zeichen enthalten:
c- Groß-/Kleinschreibung beachten.
i- Übereinstimmung ohne Berücksichtigung der Groß-/Kleinschreibung.
m- Mehrzeiliger Modus. Zeilenabschlusszeichen innerhalb der Zeichenfolge erkennen. Das Standardverhalten besteht darin, Zeilenabschlusszeichen nur am Anfang und am Ende des Zeichenfolgenausdrucks abzugleichen.
n- Der
.Zeichen stimmt mit Zeilenabschlusszeichen überein. Der Standardwert ist.Anpassung, um am Ende einer Zeile zu stoppen. u- Nur Unix-Zeilenenden. Nur das Newline-Zeichen wird durch den
.als Zeilenende erkannt ,^, und$Übereinstimmungsoperatoren.
