No MySQL, o
REGEXP_REPLACE() A função substitui as ocorrências da substring dentro de uma string que corresponde ao padrão de expressão regular fornecido. A string inteira é retornada junto com as substituições.
Se não houver correspondência (ou seja, a string de entrada não contém a substring), a string inteira é retornada inalterada.
Sintaxe
A sintaxe fica assim:
REGEXP_REPLACE(expr, pat, repl[, pos[, occurrence[, match_type]]])
Onde
expr é a string de entrada e pat é o padrão de expressão regular para a substring. O repl argumento é a string de substituição. O opcional
pos O argumento permite que você especifique uma posição dentro da string para iniciar a pesquisa. Se omitido, começa na posição 1. A
occurrence opcional O argumento permite especificar qual ocorrência da correspondência procurar. Se omitido, todas as ocorrências são substituídas. O opcional
match_type argumento é uma string que especifica como realizar a correspondência. Isso permite refinar a expressão regular. Por exemplo, você pode usar esse argumento para especificar ou não a correspondência com distinção entre maiúsculas e minúsculas. Exemplo 1 – Uso básico
Segue um exemplo 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! | +-----------------+---------------+
Nesse caso, há uma correspondência e a string é retornada com a modificação.
Exemplo 2 – Várias correspondências
Por padrão, se houver várias correspondências na string, todas elas serão substituídas:
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 | +---------------------+---------------------------+
No entanto, você também tem a opção de especificar qual ocorrência deseja substituir (mais sobre isso posteriormente).
Exemplo 3 – Sem correspondência
Aqui está um exemplo em que não há correspondência:
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 | +---------------------+---------------------+
Não há correspondência, então a string é retornada inalterada.
Exemplo 4 – O pos Argumento
Aqui está um exemplo de especificação da posição 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 | +---------------------+-------------------------+
Começamos na posição 2, que vem após o início da primeira ocorrência, portanto, a operação de substituição afeta apenas as ocorrências que vêm após a primeira.
Exemplo 5 – A occurrence Argumento
Como mencionado, por padrão, todas as ocorrências são substituídas. No entanto, você também tem a opção de especificar uma ocorrência específica para substituir usando o
occurrence argumento. Aqui está um exemplo: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 | +---------------------+-----------------------+
Neste caso, começamos na posição 1. No entanto, se começarmos em uma posição diferente, o resultado é 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 | +---------------------+-----------------------+
Isso aconteceu porque nossa posição inicial veio depois que a primeira ocorrência começou. Portanto, a ocorrência 2 tornou-se a ocorrência 1 e a ocorrência 3 tornou-se a ocorrência 2.
O valor padrão para o argumento de ocorrência é
0 , o que significa que todas as ocorrências são substituídas. Em outras palavras, se você omitir esse argumento, todas as ocorrências serão substituídas (como vimos nos exemplos anteriores). Aqui está um exemplo de especificação explícita de todas as ocorrências: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 | +---------------------+---------------------------+
Exemplo 6 – O match_type Argumento
Você pode fornecer um argumento adicional para determinar o tipo de correspondência. Isso permite que você especifique coisas como se a correspondência diferencia maiúsculas de minúsculas, se deve ou não incluir terminadores de linha, etc.
Aqui está um exemplo de especificação de uma correspondência que diferencia maiúsculas de minúsculas e uma correspondência que não diferencia maiúsculas de 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 | +---------------------+---------------------+---------------------------+
O
match_type argumento pode conter os seguintes caracteres:c- Correspondência com distinção entre maiúsculas e minúsculas.
i- Correspondência sem distinção entre maiúsculas e minúsculas.
m- Modo de várias linhas. Reconhecer terminadores de linha dentro da string. O comportamento padrão é combinar terminadores de linha apenas no início e no final da expressão de string.
n- O
.caractere corresponde aos terminadores de linha. O padrão é para.correspondência para parar no final de uma linha. u- Finalizações de linha somente para Unix. Apenas o caractere de nova linha é reconhecido como uma linha que termina com
.,^e$operadores de correspondência.
