V MySQL, REGEXP_REPLACE() funkce nahradí výskyty podřetězce v řetězci, který odpovídá danému vzoru regulárního výrazu.
Celý řetězec se vrátí spolu s náhradami.
Pokud neexistuje žádná shoda (tj. vstupní řetězec neobsahuje podřetězec), vrátí se celý řetězec beze změny.
Syntaxe
Syntaxe vypadá takto:
REGEXP_REPLACE(expr, pat, repl[, pos[, occurrence[, match_type]]])
Kde expr je vstupní řetězec a pat je vzor regulárního výrazu pro podřetězec. repl argument je náhradní řetězec.
Volitelný pos argument umožňuje zadat pozici v řetězci pro zahájení vyhledávání. Pokud je vynechán, začíná na pozici 1.
Volitelný occurrence argument umožňuje určit, který výskyt shody se má hledat. Pokud je vynechán, budou nahrazeny všechny výskyty.
Volitelný match_type argument je řetězec, který určuje, jak provést párování. To vám umožní upřesnit regulární výraz. Tento argument můžete například použít k určení shody rozlišující malá a velká písmena.
Příklad 1 – Základní použití
Zde je základní příklad:
SET @str = 'It was good'; SELECT @str 'Original String', REGEXP_REPLACE(@str, 'good', 'great!') 'Result';
Výsledek:
+-----------------+---------------+ | Original String | Result | +-----------------+---------------+ | It was good | It was great! | +-----------------+---------------+
V tomto případě existuje shoda a řetězec je vrácen s úpravou.
Příklad 2 – Více shod
Ve výchozím nastavení, pokud je v řetězci více shod, všechny jsou nahrazeny:
SET @str = 'Cat Dog Cat Dog Cat'; SELECT @str 'Original String', REGEXP_REPLACE(@str, 'Cat', 'Tiger') 'Result';
Výsledek:
+---------------------+---------------------------+ | Original String | Result | +---------------------+---------------------------+ | Cat Dog Cat Dog Cat | Tiger Dog Tiger Dog Tiger | +---------------------+---------------------------+
Máte však také možnost určit, který výskyt chcete nahradit (více o tom později).
Příklad 3 – Žádná shoda
Zde je příklad, kdy neexistuje žádná shoda:
SET @str = 'Cat Dog Cat Dog Cat'; SELECT @str 'Original String', REGEXP_REPLACE(@str, 'Cow', 'Tiger') 'Result';
Výsledek:
+---------------------+---------------------+ | Original String | Result | +---------------------+---------------------+ | Cat Dog Cat Dog Cat | Cat Dog Cat Dog Cat | +---------------------+---------------------+
Neexistuje žádná shoda, takže řetězec je vrácen beze změny.
Příklad 4 – pos Argument
Zde je příklad zadání počáteční pozice:
SET @str = 'Cat Dog Cat Dog Cat'; SELECT @str 'Original String', REGEXP_REPLACE(@str, 'Cat', 'Tiger', 2) 'Result';
Výsledek:
+---------------------+-------------------------+ | Original String | Result | +---------------------+-------------------------+ | Cat Dog Cat Dog Cat | Cat Dog Tiger Dog Tiger | +---------------------+-------------------------+
Začali jsme na pozici 2, která následuje po začátku prvního výskytu, takže operace nahrazení ovlivní pouze ty výskyty, které následují po prvním výskytu.
Příklad 5 – occurrence Argument
Jak již bylo zmíněno, ve výchozím nastavení jsou nahrazeny všechny výskyty. Máte však také možnost určit konkrétní výskyt, který chcete nahradit, pomocí occurrence argument. Zde je příklad:
SET @str = 'Cat Dog Cat Dog Cat'; SELECT @str 'Original String', REGEXP_REPLACE(@str, 'Cat', 'Tiger', 1, 2) 'Result';
Výsledek:
+---------------------+-----------------------+ | Original String | Result | +---------------------+-----------------------+ | Cat Dog Cat Dog Cat | Cat Dog Tiger Dog Cat | +---------------------+-----------------------+
V tomto případě začínáme na pozici 1. Pokud však začneme na jiné pozici, výsledek je jiný:
SET @str = 'Cat Dog Cat Dog Cat'; SELECT @str 'Original String', REGEXP_REPLACE(@str, 'Cat', 'Tiger', 2, 2) 'Result';
Výsledek:
+---------------------+-----------------------+ | Original String | Result | +---------------------+-----------------------+ | Cat Dog Cat Dog Cat | Cat Dog Cat Dog Tiger | +---------------------+-----------------------+
Stalo se to proto, že naše výchozí pozice přišla poté, co začala první událost. Proto se výskyt 2 stal výskytem 1 a výskyt 3 se stal výskytem 2.
Výchozí hodnota pro argument výskytu je 0 , což znamená, že všechny výskyty budou nahrazeny. Jinými slovy, pokud tento argument vynecháte, budou nahrazeny všechny výskyty (jak jsme viděli v předchozích příkladech). Zde je příklad explicitního zadání všech výskytů:
SET @str = 'Cat Dog Cat Dog Cat'; SELECT @str 'Original String', REGEXP_REPLACE(@str, 'Cat', 'Tiger', 1, 0) 'Result';
Výsledek:
+---------------------+---------------------------+ | Original String | Result | +---------------------+---------------------------+ | Cat Dog Cat Dog Cat | Tiger Dog Tiger Dog Tiger | +---------------------+---------------------------+
Příklad 6 – match_type Argument
Pro určení typu shody můžete zadat další argument. To vám umožňuje určit věci, jako je, zda se ve shodě rozlišují velká a malá písmena, zda mají či nemají obsahovat zakončovací znaky atd.
Zde je příklad zadání shody rozlišující malá a velká písmena a nerozlišující malá a velká písmena:
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';
Výsledek:
+---------------------+---------------------+---------------------------+ | Original String | Case-Sensitive | Case-Insensitive | +---------------------+---------------------+---------------------------+ | Cat Dog Cat Dog Cat | Cat Dog Cat Dog Cat | Tiger Dog Tiger Dog Tiger | +---------------------+---------------------+---------------------------+
match_type argument může obsahovat následující znaky:
c- Rozlišování velkých a malých písmen.
i- Shoda nerozlišující malá a velká písmena.
m- Režim více řádků. Rozpoznejte zakončení řádku v řetězci. Výchozí chování je přiřazovat zakončení řádků pouze na začátek a konec řetězcového výrazu.
n- The
.znak se shoduje se zakončením řádku. Výchozí hodnota je pro.párování se zastaví na konci řádku. u- Koncovky řádků pouze pro Unix. Pouze znak nového řádku je rozpoznán jako řádek končící znakem
.,^a$operátory shody.