In MySQL is de REGEXP_REPLACE() functie vervangt de subtekenreeks binnen een tekenreeks die overeenkomt met het gegeven patroon voor reguliere expressies.
De hele string wordt geretourneerd samen met de vervangingen.
Als er geen overeenkomst is (d.w.z. de invoertekenreeks bevat niet de subtekenreeks), wordt de hele tekenreeks ongewijzigd geretourneerd.
Syntaxis
De syntaxis gaat als volgt:
REGEXP_REPLACE(expr, pat, repl[, pos[, occurrence[, match_type]]])
Waar expr is de invoerreeks en pat is het reguliere expressiepatroon voor de subtekenreeks. De repl argument is de vervangende string.
De optionele pos argument stelt u in staat om een positie in de tekenreeks op te geven om de zoekopdracht te starten. Indien weggelaten, begint het op positie 1.
Het optionele occurrence argument stelt u in staat om te specificeren naar welk exemplaar van de overeenkomst moet worden gezocht. Indien weggelaten, worden alle voorkomens vervangen.
Het optionele match_type argument is een tekenreeks die specificeert hoe matching moet worden uitgevoerd. Hiermee kunt u de reguliere expressie verfijnen. U kunt dit argument bijvoorbeeld gebruiken om hoofdlettergevoelige overeenkomsten op te geven of niet.
Voorbeeld 1 – Basisgebruik
Hier is een eenvoudig voorbeeld:
SET @str = 'It was good'; SELECT @str 'Original String', REGEXP_REPLACE(@str, 'good', 'great!') 'Result';
Resultaat:
+-----------------+---------------+ | Original String | Result | +-----------------+---------------+ | It was good | It was great! | +-----------------+---------------+
In dit geval is er een overeenkomst en wordt de tekenreeks geretourneerd met de wijziging.
Voorbeeld 2 – Meerdere overeenkomsten
Als er meerdere overeenkomsten in de tekenreeks zijn, worden ze standaard allemaal vervangen:
SET @str = 'Cat Dog Cat Dog Cat'; SELECT @str 'Original String', REGEXP_REPLACE(@str, 'Cat', 'Tiger') 'Result';
Resultaat:
+---------------------+---------------------------+ | Original String | Result | +---------------------+---------------------------+ | Cat Dog Cat Dog Cat | Tiger Dog Tiger Dog Tiger | +---------------------+---------------------------+
U heeft echter ook de mogelijkheid om aan te geven welk exemplaar u wilt vervangen (hierover later meer).
Voorbeeld 3 – Geen overeenkomst
Hier is een voorbeeld waarbij er geen overeenkomst is:
SET @str = 'Cat Dog Cat Dog Cat'; SELECT @str 'Original String', REGEXP_REPLACE(@str, 'Cow', 'Tiger') 'Result';
Resultaat:
+---------------------+---------------------+ | Original String | Result | +---------------------+---------------------+ | Cat Dog Cat Dog Cat | Cat Dog Cat Dog Cat | +---------------------+---------------------+
Er is geen overeenkomst, dus de tekenreeks wordt ongewijzigd geretourneerd.
Voorbeeld 4 – De pos Argument
Hier is een voorbeeld van het specificeren van de startpositie:
SET @str = 'Cat Dog Cat Dog Cat'; SELECT @str 'Original String', REGEXP_REPLACE(@str, 'Cat', 'Tiger', 2) 'Result';
Resultaat:
+---------------------+-------------------------+ | Original String | Result | +---------------------+-------------------------+ | Cat Dog Cat Dog Cat | Cat Dog Tiger Dog Tiger | +---------------------+-------------------------+
We zijn begonnen op positie 2, die na het begin van de eerste gebeurtenis komt, dus de vervangingsbewerking heeft alleen invloed op die gebeurtenissen die na de eerste komen.
Voorbeeld 5 – Het occurrence Argument
Zoals vermeld, worden standaard alle exemplaren vervangen. U hebt echter ook de mogelijkheid om een specifieke instantie op te geven die u wilt vervangen door de occurrence te gebruiken. argument. Hier is een voorbeeld:
SET @str = 'Cat Dog Cat Dog Cat'; SELECT @str 'Original String', REGEXP_REPLACE(@str, 'Cat', 'Tiger', 1, 2) 'Result';
Resultaat:
+---------------------+-----------------------+ | Original String | Result | +---------------------+-----------------------+ | Cat Dog Cat Dog Cat | Cat Dog Tiger Dog Cat | +---------------------+-----------------------+
In dit geval beginnen we op positie 1. Als we echter op een andere positie beginnen, is het resultaat anders:
SET @str = 'Cat Dog Cat Dog Cat'; SELECT @str 'Original String', REGEXP_REPLACE(@str, 'Cat', 'Tiger', 2, 2) 'Result';
Resultaat:
+---------------------+-----------------------+ | Original String | Result | +---------------------+-----------------------+ | Cat Dog Cat Dog Cat | Cat Dog Cat Dog Tiger | +---------------------+-----------------------+
Dit gebeurde omdat onze startpositie kwam nadat het eerste voorval was begonnen. Daarom werd voorval 2 voorval 1 en voorval 3 werd voorval 2.
De standaardwaarde voor het voorkomen-argument is 0 , wat betekent dat alle gebeurtenissen worden vervangen. Met andere woorden, als u dit argument weglaat, worden alle exemplaren vervangen (zoals we in de vorige voorbeelden hebben gezien). Hier is een voorbeeld van het expliciet specificeren van alle instanties:
SET @str = 'Cat Dog Cat Dog Cat'; SELECT @str 'Original String', REGEXP_REPLACE(@str, 'Cat', 'Tiger', 1, 0) 'Result';
Resultaat:
+---------------------+---------------------------+ | Original String | Result | +---------------------+---------------------------+ | Cat Dog Cat Dog Cat | Tiger Dog Tiger Dog Tiger | +---------------------+---------------------------+
Voorbeeld 6 – Het match_type Argument
U kunt een extra argument opgeven om het zoektype te bepalen. Hiermee kunt u dingen specificeren zoals of de overeenkomst hoofdlettergevoelig is, of u lijnafsluitingen wilt opnemen, enz.
Hier is een voorbeeld van het specificeren van een hoofdlettergevoelige overeenkomst en een hoofdletterongevoelige overeenkomst:
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';
Resultaat:
+---------------------+---------------------+---------------------------+ | Original String | Case-Sensitive | Case-Insensitive | +---------------------+---------------------+---------------------------+ | Cat Dog Cat Dog Cat | Cat Dog Cat Dog Cat | Tiger Dog Tiger Dog Tiger | +---------------------+---------------------+---------------------------+
Het match_type argument kan de volgende tekens bevatten:
c- Hoofdlettergevoelige overeenkomst.
i- Hoofdletterongevoelige overeenkomst.
m- Modus met meerdere regels. Herken lijnafsluitingen binnen de string. Het standaardgedrag is om regelafsluitingen alleen aan het begin en einde van de tekenreeksuitdrukking te laten overeenkomen.
n- De
.karakter komt overeen met regelafsluitingen. De standaard is voor.overeenkomend om te stoppen aan het einde van een regel. u- Alleen Unix regeleindes. Alleen het teken van de nieuwe regel wordt herkend als een regel die eindigt met de
.,^, en$match operators.