En MySQL, REGEXP_REPLACE() La función reemplaza las ocurrencias de la subcadena dentro de una cadena que coincide con el patrón de expresión regular dado.
La cadena completa se devuelve junto con los reemplazos.
Si no hay ninguna coincidencia (es decir, la cadena de entrada no contiene la subcadena), la cadena completa se devuelve sin cambios.
Sintaxis
La sintaxis es así:
REGEXP_REPLACE(expr, pat, repl[, pos[, occurrence[, match_type]]])
Donde expr es la cadena de entrada y pat es el patrón de expresión regular para la subcadena. El repl argumento es la cadena de reemplazo.
El pos opcional El argumento le permite especificar una posición dentro de la cadena para iniciar la búsqueda. Si se omite, comienza en la posición 1.
La occurrence opcional El argumento le permite especificar qué ocurrencia de la coincidencia buscar. Si se omite, se reemplazan todas las apariciones.
El match_type opcional argumento es una cadena que especifica cómo realizar la coincidencia. Esto le permite refinar la expresión regular. Por ejemplo, puede usar este argumento para especificar si distingue entre mayúsculas y minúsculas o no.
Ejemplo 1:uso básico
He aquí un ejemplo básico:
SET @str = 'It was good'; SELECT @str 'Original String', REGEXP_REPLACE(@str, 'good', 'great!') 'Result';
Resultado:
+-----------------+---------------+ | Original String | Result | +-----------------+---------------+ | It was good | It was great! | +-----------------+---------------+
En este caso, hay una coincidencia y la cadena se devuelve con la modificación.
Ejemplo 2:coincidencias múltiples
De forma predeterminada, si hay varias coincidencias dentro de la cadena, se reemplazan todas:
SET @str = 'Cat Dog Cat Dog Cat'; SELECT @str 'Original String', REGEXP_REPLACE(@str, 'Cat', 'Tiger') 'Result';
Resultado:
+---------------------+---------------------------+ | Original String | Result | +---------------------+---------------------------+ | Cat Dog Cat Dog Cat | Tiger Dog Tiger Dog Tiger | +---------------------+---------------------------+
Sin embargo, también tiene la opción de especificar qué ocurrencia le gustaría reemplazar (más sobre esto más adelante).
Ejemplo 3:Sin coincidencia
Aquí hay un ejemplo donde no hay coincidencia:
SET @str = 'Cat Dog Cat Dog Cat'; SELECT @str 'Original String', REGEXP_REPLACE(@str, 'Cow', 'Tiger') 'Result';
Resultado:
+---------------------+---------------------+ | Original String | Result | +---------------------+---------------------+ | Cat Dog Cat Dog Cat | Cat Dog Cat Dog Cat | +---------------------+---------------------+
No hay coincidencia, por lo que la cadena se devuelve sin cambios.
Ejemplo 4:el pos Argumento
Aquí hay un ejemplo de cómo especificar la posición inicial:
SET @str = 'Cat Dog Cat Dog Cat'; SELECT @str 'Original String', REGEXP_REPLACE(@str, 'Cat', 'Tiger', 2) 'Result';
Resultado:
+---------------------+-------------------------+ | Original String | Result | +---------------------+-------------------------+ | Cat Dog Cat Dog Cat | Cat Dog Tiger Dog Tiger | +---------------------+-------------------------+
Comenzamos en la posición 2, que viene después del inicio de la primera ocurrencia, por lo que la operación de reemplazo solo afecta las ocurrencias que vienen después de la primera.
Ejemplo 5:la occurrence Argumento
Como se mencionó, por defecto, todas las ocurrencias son reemplazadas. Sin embargo, también tiene la opción de especificar una ocurrencia específica para reemplazar usando el occurrence argumento. He aquí un ejemplo:
SET @str = 'Cat Dog Cat Dog Cat'; SELECT @str 'Original String', REGEXP_REPLACE(@str, 'Cat', 'Tiger', 1, 2) 'Result';
Resultado:
+---------------------+-----------------------+ | Original String | Result | +---------------------+-----------------------+ | Cat Dog Cat Dog Cat | Cat Dog Tiger Dog Cat | +---------------------+-----------------------+
En este caso comenzamos en la posición 1. Sin embargo, si comenzamos en una posición diferente, el resultado es diferente:
SET @str = 'Cat Dog Cat Dog Cat'; SELECT @str 'Original String', REGEXP_REPLACE(@str, 'Cat', 'Tiger', 2, 2) 'Result';
Resultado:
+---------------------+-----------------------+ | Original String | Result | +---------------------+-----------------------+ | Cat Dog Cat Dog Cat | Cat Dog Cat Dog Tiger | +---------------------+-----------------------+
Esto sucedió porque nuestra posición inicial se produjo después de que comenzara la primera ocurrencia. Por lo tanto, la ocurrencia 2 se convirtió en la ocurrencia 1 y la ocurrencia 3 se convirtió en la ocurrencia 2.
El valor predeterminado para el argumento de ocurrencia es 0 , lo que significa que se reemplazan todas las ocurrencias. En otras palabras, si omite este argumento, todas las ocurrencias se reemplazan (como hemos visto en los ejemplos anteriores). Aquí hay un ejemplo de especificar explícitamente todas las ocurrencias:
SET @str = 'Cat Dog Cat Dog Cat'; SELECT @str 'Original String', REGEXP_REPLACE(@str, 'Cat', 'Tiger', 1, 0) 'Result';
Resultado:
+---------------------+---------------------------+ | Original String | Result | +---------------------+---------------------------+ | Cat Dog Cat Dog Cat | Tiger Dog Tiger Dog Tiger | +---------------------+---------------------------+
Ejemplo 6:el match_type Argumento
Puede proporcionar un argumento adicional para determinar el tipo de coincidencia. Esto le permite especificar cosas como si la coincidencia distingue entre mayúsculas y minúsculas o no, si debe incluir o no terminadores de línea, etc.
Este es un ejemplo de cómo especificar una coincidencia que distingue entre mayúsculas y minúsculas y una coincidencia que no distingue entre mayúsculas y minúsculas:
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';
Resultado:
+---------------------+---------------------+---------------------------+ | Original String | Case-Sensitive | Case-Insensitive | +---------------------+---------------------+---------------------------+ | Cat Dog Cat Dog Cat | Cat Dog Cat Dog Cat | Tiger Dog Tiger Dog Tiger | +---------------------+---------------------+---------------------------+
El match_type argumento puede contener los siguientes caracteres:
c- Coincidencia sensible a mayúsculas y minúsculas.
i- Coincidencia insensible a mayúsculas y minúsculas.
m- Modo de varias líneas. Reconocer los terminadores de línea dentro de la cadena. El comportamiento predeterminado es hacer coincidir los terminadores de línea solo al principio y al final de la expresión de cadena.
n- El
.el carácter coincide con los terminadores de línea. El valor predeterminado es para.coincidencia para detenerse al final de una línea. u- Finales de línea exclusivos de Unix. Solo el carácter de nueva línea se reconoce como una línea que termina con
.,^y$operadores de coincidencia.
