Hur REGEX_REPLACE()-funktionen fungerar i MySQL

I MySQL, REGEXP_REPLACE() funktion ersätter förekomster av delsträngen i en sträng som matchar det givna reguljära uttrycksmönstret.

Hela strängen returneras tillsammans med ersättningarna.

Om det inte finns någon matchning (dvs. inmatningssträngen innehåller inte delsträngen), returneras hela strängen oförändrad.

Syntax

Syntaxen ser ut så här:

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

Där expr är inmatningssträngen och pat är det reguljära uttrycksmönstret för delsträngen. repl argument är ersättningssträngen.

Den valfria pos argument låter dig ange en position inom strängen för att starta sökningen. Om den utelämnas börjar den vid position 1.

Den valfria förekomsten argument låter dig ange vilken förekomst av matchningen du ska söka efter. Om det utelämnas ersätts alla förekomster.

Den valfria match_type argument är en sträng som anger hur matchning ska utföras. Detta låter dig förfina det reguljära uttrycket. Du kan till exempel använda detta argument för att ange skiftlägeskänslig matchning eller inte.

Exempel 1 – Grundläggande användning

Här är ett grundläggande exempel:

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 det här fallet finns det en matchning och strängen returneras med modifieringen.

Exempel 2 – Flera matchningar

Som standard, om det finns flera matchningar inom strängen, ersätts alla:

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 dock också möjlighet att ange vilken förekomst du vill ersätta (mer om detta senare).

Exempel 3 – Ingen matchning

Här är ett exempel där det inte finns någon matchning:

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 |
+---------------------+---------------------+

Det finns ingen matchning, så strängen returneras oförändrad.

Exempel 4 – pos Argument

Här är ett exempel på hur du anger 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 började på position 2, som kommer efter början av den första förekomsten, så ersättningsoperationen påverkar bara de händelser som kommer efter den första.

Exempel 5 – förekomsten Argument

Som nämnt ersätts alla förekomster som standard. Du har dock också möjlighet att ange en specifik förekomst som ska ersättas genom att använda förekomst argument. Här är ett exempel:

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 det här fallet börjar vi på position 1. Men om vi börjar på en annan position blir resultatet ett annat:

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 |
+---------------------+-----------------------+

Detta hände för att vårt startläge kom efter att den första händelsen hade startat. Därför blev förekomst 2 förekomst 1 och förekomst 3 blev förekomst 2.

Standardvärdet för förekomstargumentet är 0 , vilket innebär att alla förekomster ersätts. Med andra ord, om du utelämnar detta argument ersätts alla förekomster (som vi har sett i de tidigare exemplen). Här är ett exempel på att explicit specificera alla förekomster:

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 |
+---------------------+---------------------------+

Exempel 6 – match_type Argument

Du kan ange ytterligare ett argument för att bestämma matchningstypen. Detta låter dig specificera saker som om matchningen är skiftlägeskänslig eller inte, om linjeavslutare ska inkluderas eller inte, etc.

Här är ett exempel på hur du anger en skiftlägeskänslig matchning och en skiftlägesokänslig matchning:

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 innehålla följande tecken:

c

Skaftkänslig matchning.

i

Verkskiftsokänslig matchning.

m

Flerradsläge. Känn igen linjeavslutare i strängen. Standardbeteendet är att matcha linjeavslutare endast i början och slutet av stränguttrycket.

n

. tecken matchar radavslutare. Standard är för . matchar för att stanna i slutet av en rad.

u

Enbart Unix-radändelser. Endast nyradstecknet känns igen som en rad som slutar med . , ^ och $ matcha operatorer.