Dans MySQL, le REGEXP_REPLACE() La fonction remplace les occurrences de la sous-chaîne dans une chaîne qui correspond au modèle d'expression régulière donné.
La chaîne entière est renvoyée avec les remplacements.
S'il n'y a pas de correspondance (c'est-à-dire que la chaîne d'entrée ne contient pas la sous-chaîne), la chaîne entière est renvoyée inchangée.
Syntaxe
La syntaxe ressemble à ceci :
REGEXP_REPLACE(expr, pat, repl[, pos[, occurrence[, match_type]]])
Où expr est la chaîne d'entrée et pat est le modèle d'expression régulière pour la sous-chaîne. Le repl l'argument est la chaîne de remplacement.
Le pos facultatif L'argument vous permet de spécifier une position dans la chaîne pour lancer la recherche. S'il est omis, il commence à la position 1.
L'option occurrence L'argument vous permet de spécifier l'occurrence de la correspondance à rechercher. Si omis, toutes les occurrences sont remplacées.
Le match_type facultatif argument est une chaîne qui spécifie comment effectuer la correspondance. Cela vous permet d'affiner l'expression régulière. Par exemple, vous pouvez utiliser cet argument pour spécifier ou non une correspondance sensible à la casse.
Exemple 1 - Utilisation de base
Voici un exemple de base :
SET @str = 'It was good'; SELECT @str 'Original String', REGEXP_REPLACE(@str, 'good', 'great!') 'Result';
Résultat :
+-----------------+---------------+ | Original String | Result | +-----------------+---------------+ | It was good | It was great! | +-----------------+---------------+
Dans ce cas, il y a correspondance et la chaîne est renvoyée avec la modification.
Exemple 2 – Plusieurs correspondances
Par défaut, s'il existe plusieurs correspondances dans la chaîne, elles sont toutes remplacées :
SET @str = 'Cat Dog Cat Dog Cat'; SELECT @str 'Original String', REGEXP_REPLACE(@str, 'Cat', 'Tiger') 'Result';
Résultat :
+---------------------+---------------------------+ | Original String | Result | +---------------------+---------------------------+ | Cat Dog Cat Dog Cat | Tiger Dog Tiger Dog Tiger | +---------------------+---------------------------+
Cependant, vous avez également la possibilité de spécifier l'occurrence que vous souhaitez remplacer (nous en reparlerons plus tard).
Exemple 3 – Aucune correspondance
Voici un exemple où il n'y a pas de correspondance :
SET @str = 'Cat Dog Cat Dog Cat'; SELECT @str 'Original String', REGEXP_REPLACE(@str, 'Cow', 'Tiger') 'Result';
Résultat :
+---------------------+---------------------+ | Original String | Result | +---------------------+---------------------+ | Cat Dog Cat Dog Cat | Cat Dog Cat Dog Cat | +---------------------+---------------------+
Il n'y a pas de correspondance, donc la chaîne est retournée inchangée.
Exemple 4 – Le pos Argumentation
Voici un exemple de spécification de la position de départ :
SET @str = 'Cat Dog Cat Dog Cat'; SELECT @str 'Original String', REGEXP_REPLACE(@str, 'Cat', 'Tiger', 2) 'Result';
Résultat :
+---------------------+-------------------------+ | Original String | Result | +---------------------+-------------------------+ | Cat Dog Cat Dog Cat | Cat Dog Tiger Dog Tiger | +---------------------+-------------------------+
Nous avons commencé à la position 2, qui vient après le début de la première occurrence, donc l'opération de remplacement n'affecte que les occurrences qui viennent après la première.
Exemple 5 – L'occurrence Argumentation
Comme mentionné, par défaut, toutes les occurrences sont remplacées. Cependant, vous avez également la possibilité de spécifier une occurrence spécifique à remplacer en utilisant le occurrence argument. Voici un exemple :
SET @str = 'Cat Dog Cat Dog Cat'; SELECT @str 'Original String', REGEXP_REPLACE(@str, 'Cat', 'Tiger', 1, 2) 'Result';
Résultat :
+---------------------+-----------------------+ | Original String | Result | +---------------------+-----------------------+ | Cat Dog Cat Dog Cat | Cat Dog Tiger Dog Cat | +---------------------+-----------------------+
Dans ce cas, nous commençons à la position 1. Cependant, si nous commençons à une position différente, le résultat est différent :
SET @str = 'Cat Dog Cat Dog Cat'; SELECT @str 'Original String', REGEXP_REPLACE(@str, 'Cat', 'Tiger', 2, 2) 'Result';
Résultat :
+---------------------+-----------------------+ | Original String | Result | +---------------------+-----------------------+ | Cat Dog Cat Dog Cat | Cat Dog Cat Dog Tiger | +---------------------+-----------------------+
Cela s'est produit parce que notre position de départ est survenue après le début de la première occurrence. Par conséquent, l'occurrence 2 est devenue l'occurrence 1 et l'occurrence 3 est devenue l'occurrence 2.
La valeur par défaut de l'argument d'occurrence est 0 , ce qui signifie que toutes les occurrences sont remplacées. En d'autres termes, si vous omettez cet argument, toutes les occurrences sont remplacées (comme nous l'avons vu dans les exemples précédents). Voici un exemple de spécification explicite de toutes les occurrences :
SET @str = 'Cat Dog Cat Dog Cat'; SELECT @str 'Original String', REGEXP_REPLACE(@str, 'Cat', 'Tiger', 1, 0) 'Result';
Résultat :
+---------------------+---------------------------+ | Original String | Result | +---------------------+---------------------------+ | Cat Dog Cat Dog Cat | Tiger Dog Tiger Dog Tiger | +---------------------+---------------------------+
Exemple 6 – Le match_type Argumentation
Vous pouvez fournir un argument supplémentaire pour déterminer le type de correspondance. Cela vous permet de spécifier des choses comme si la correspondance est ou non sensible à la casse, s'il faut ou non inclure des fins de ligne, etc.
Voici un exemple de spécification d'une correspondance sensible à la casse et d'une correspondance insensible à la casse :
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';
Résultat :
+---------------------+---------------------+---------------------------+ | Original String | Case-Sensitive | Case-Insensitive | +---------------------+---------------------+---------------------------+ | Cat Dog Cat Dog Cat | Cat Dog Cat Dog Cat | Tiger Dog Tiger Dog Tiger | +---------------------+---------------------+---------------------------+
Le match_type l'argument peut contenir les caractères suivants :
c- Correspondance sensible à la casse.
i- Correspondance insensible à la casse.
m- Mode multiligne. Reconnaître les terminaisons de ligne dans la chaîne. Le comportement par défaut consiste à faire correspondre les fins de ligne uniquement au début et à la fin de l'expression de chaîne.
n- Le
.caractère correspond aux fins de ligne. La valeur par défaut est pour.correspondant à s'arrêter à la fin d'une ligne. u- Fin de ligne UNIX uniquement. Seul le caractère de nouvelle ligne est reconnu comme une ligne se terminant par le
.,^, et$opérateurs de correspondance.
