Sådan fungerer REGEX_REPLACE()-funktionen i MySQL

I MySQL er REGEXP_REPLACE() funktion erstatter forekomster af understrengen i en streng, der matcher det givne regulære udtryksmønster.

Hele strengen returneres sammen med erstatningerne.

Hvis der ikke er noget match (dvs. inputstrengen indeholder ikke understrengen), returneres hele strengen uændret.

Syntaks

Syntaksen ser sådan ud:

REGEXP_REPLACE(expr, pat, repl[, pos[, occurrence[, match_type]]])

Hvor expr er inputstrengen og pat er det regulære udtryksmønster for understrengen. repl argument er erstatningsstrengen.

Den valgfri pos argument giver dig mulighed for at angive en position i strengen for at starte søgningen. Hvis den udelades, starter den ved position 1.

Den valgfri forekomst argument giver dig mulighed for at angive, hvilken forekomst af matchet du skal søge efter. Hvis det udelades, erstattes alle forekomster.

Den valgfri match_type argument er en streng, der angiver, hvordan matchning udføres. Dette giver dig mulighed for at forfine det regulære udtryk. Du kan f.eks. bruge dette argument til at angive overensstemmelse mellem store og små bogstaver eller ej.

Eksempel 1 – Grundlæggende brug

Her er et grundlæggende eksempel:

SET @str = 'It was good';
SELECT 
  @str 'Original String',
  REGEXP_REPLACE(@str, 'good', 'great!') 'Result';

Resultat:

+-----------------+---------------+
| Original String | Result        |
+-----------------+---------------+
| It was good     | It was great! |
+-----------------+---------------+

I dette tilfælde er der et match, og strengen returneres med modifikationen.

Eksempel 2 – Flere kampe

Som standard, hvis der er flere matches i strengen, erstattes dem alle:

SET @str = 'Cat Dog Cat Dog Cat';
SELECT 
  @str 'Original String',
  REGEXP_REPLACE(@str, 'Cat', 'Tiger') 'Result';

Resultat:

+---------------------+---------------------------+
| Original String     | Result                    |
+---------------------+---------------------------+
| Cat Dog Cat Dog Cat | Tiger Dog Tiger Dog Tiger |
+---------------------+---------------------------+

Du har dog også mulighed for at angive, hvilken forekomst du vil erstatte (mere om dette senere).

Eksempel 3 – Ingen match

Her er et eksempel, hvor der ikke er nogen match:

SET @str = 'Cat Dog Cat Dog Cat';
SELECT 
  @str 'Original String',
  REGEXP_REPLACE(@str, 'Cow', 'Tiger') 'Result';

Resultat:

+---------------------+---------------------+
| Original String     | Result              |
+---------------------+---------------------+
| Cat Dog Cat Dog Cat | Cat Dog Cat Dog Cat |
+---------------------+---------------------+

Der er ingen match, så strengen returneres uændret.

Eksempel 4 – pos Argument

Her er et eksempel på angivelse af startpositionen:

SET @str = 'Cat Dog Cat Dog Cat';
SELECT 
  @str 'Original String',
  REGEXP_REPLACE(@str, 'Cat', 'Tiger', 2) 'Result';

Resultat:

+---------------------+-------------------------+
| Original String     | Result                  |
+---------------------+-------------------------+
| Cat Dog Cat Dog Cat | Cat Dog Tiger Dog Tiger |
+---------------------+-------------------------+

Vi startede ved position 2, som kommer efter starten af ​​den første forekomst, så udskiftningsoperationen påvirker kun de forekomster, der kommer efter den første.

Eksempel 5 – forekomsten Argument

Som nævnt erstattes alle forekomster som standard. Du har dog også mulighed for at angive en specifik forekomst, der skal erstattes ved at bruge forekomst argument. Her er et eksempel:

SET @str = 'Cat Dog Cat Dog Cat';
SELECT 
  @str 'Original String',
  REGEXP_REPLACE(@str, 'Cat', 'Tiger', 1, 2) 'Result';

Resultat:

+---------------------+-----------------------+
| Original String     | Result                |
+---------------------+-----------------------+
| Cat Dog Cat Dog Cat | Cat Dog Tiger Dog Cat |
+---------------------+-----------------------+

I dette tilfælde starter vi ved position 1. Men hvis vi starter på en anden position, er resultatet anderledes:

SET @str = 'Cat Dog Cat Dog Cat';
SELECT 
  @str 'Original String',
  REGEXP_REPLACE(@str, 'Cat', 'Tiger', 2, 2) 'Result';

Resultat:

+---------------------+-----------------------+
| Original String     | Result                |
+---------------------+-----------------------+
| Cat Dog Cat Dog Cat | Cat Dog Cat Dog Tiger |
+---------------------+-----------------------+

Dette skete, fordi vores startposition kom efter den første forekomst var startet. Derfor blev forekomst 2 til forekomst 1, og forekomst 3 blev til forekomst 2.

Standardværdien for forekomstargumentet er 0 , hvilket betyder, at alle forekomster erstattes. Med andre ord, hvis du udelader dette argument, erstattes alle forekomster (som vi har set i de foregående eksempler). Her er et eksempel på eksplicit specificering af alle forekomster:

SET @str = 'Cat Dog Cat Dog Cat';
SELECT 
  @str 'Original String',
  REGEXP_REPLACE(@str, 'Cat', 'Tiger', 1, 0) 'Result';

Resultat:

+---------------------+---------------------------+
| Original String     | Result                    |
+---------------------+---------------------------+
| Cat Dog Cat Dog Cat | Tiger Dog Tiger Dog Tiger |
+---------------------+---------------------------+

Eksempel 6 – match_type Argument

Du kan angive et ekstra argument for at bestemme matchtypen. Dette giver dig mulighed for at specificere ting som om matchet er skelet mellem store og små bogstaver, om der skal inkluderes linjeterminatorer osv.

Her er et eksempel på at angive et match, der skelner mellem store og små bogstaver, og et match, der skelner mellem store og små bogstaver:

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';

Resultat:

+---------------------+---------------------+---------------------------+
| Original String     | Case-Sensitive      | Case-Insensitive          |
+---------------------+---------------------+---------------------------+
| Cat Dog Cat Dog Cat | Cat Dog Cat Dog Cat | Tiger Dog Tiger Dog Tiger |
+---------------------+---------------------+---------------------------+

match_type argument kan indeholde følgende tegn:

c

Skaftfølsom match.

i

Tilpasning af store og små bogstaver.

m

Flere linjers tilstand. Genkend linjeterminatorer i strengen. Standardadfærden er kun at matche linjeterminatorer i starten og slutningen af ​​strengudtrykket.

n

. karakter matcher linjeterminatorer. Standard er for . matcher for at stoppe ved slutningen af ​​en linje.

u

Unix-kun linjeafslutninger. Kun tegnet for ny linje genkendes som en linje, der slutter med . , ^ og $ match operatører.