************************************************ Count % of Text Symbols 1 caracteres 405 2.4 % 10 2 caractere 383 2.0 % 9 3 para 351 0.8 % 4 4 regex 286 0.8 % 5 5 exemplo 228 0.9 % 7 6 expressão 204 1.1 % 9 7 como 190 0.4 % 4 8 string 185 0.7 % 6 9 mais 181 0.4 % 4 10 regular 171 0.7 % 7 ******************************************** resultado google São caracteres que determinam funções especiais dentro de uma regex. Eles são os blocos de construção de um regex. Por exemplo: [ ] , ^ , ( ) , { } , $ , + , * , etc.7 de ago. de 2020 Expressões Regulares (RegEx) | Réulison Silva https://reulison.com.br › regex Sobre trechos em destaque • Feedback As pessoas também perguntam O que é padrão regex? Resultado de imagem para regex caracteres especiais - O que é padrão regex? Uma expressão regular, ou Regex, são padrões utilizados para identificar determinadas combinações ou cadeias de caracteres em uma string. Ela faz parte do dia a dia de todos os programadores e administradores de infra. RegEx: O que é, Como usar em Palavras e Números | Alura https://www.alura.com.br › expressoes-regulares Pesquisar: O que é padrão regex? O que são classes de caracteres em expressões regulares? Uma classe de caracteres define um conjunto de caracteres, qualquer dos quais pode ocorrer em uma cadeia de caracteres de entrada para que uma correspondência seja bem-sucedida. A linguagem de expressões regulares no . NET dá suporte às seguintes classes de caracteres: Grupos de caracteres positivos.23 de jun. de 2022 Classes de caracteres em expressões regulares do .NET https://docs.microsoft.com › pt-br › standard › base-types Pesquisar: O que são classes de caracteres em expressões regulares? Qual a função das expressões regulares regex )? Expressões regulares são padrões utilizados para selecionar combinações de caracteres em uma string. Em JavaScript, expressões regulares também são objetos. Elas podem ser utilizadas com os métodos exec e test do objeto RegExp , e com os métodos match , replace , search , e split do objeto String .22 de fev. de 2022 Expressões Regulares - JavaScript - MDN Web Docs https://developer.mozilla.org › ... › Guia JavaScript Pesquisar: Qual a função das expressões regulares regex )? O que é validação regex? Um RegEx, ou Expressão Regular, é uma sequência de caracteres que forma um padrão de texto. RegEx pode ser usado para verificar se uma cadeia de caracteres contém o padrão de busca especificado. Validação RegEx | QuestionPro Base de conhecimento https://www.questionpro.com › help › regex-validation Pesquisar: O que é validação regex? Como fazer um Regex? Part of a video titled Como usar RegEx? | Expressões Regulares - YouTube 2:02 10:31 Clipe sugerido · 58 segundos Como usar RegEx? | Expressões Regulares - YouTube https://www.youtube.com › watch Pesquisar: Como fazer um Regex? O que é uma Regex JavaScript? Uma expressão regular (regular expression ou Regex) é uma sequência de caracteres que forma um padrão de pesquisa. Ao procurar dados em um texto, você pode usar esse padrão de pesquisa para descrever o que está procurando. Uma expressão regular pode ser um único caractere ou um padrão mais complicado.14 de jun. de 2018 Como usar o Regex no JavaScript - MundoJS https://www.mundojs.com.br › 2018/06/14 › como-usar-o... Pesquisar: O que é uma Regex JavaScript? O que significa a expressão regular? Expressões Regulares são padrões de caracteres que associam sequências de caracteres no texto. Podemos usar expressões regulares para extrair ou substituir porções de texto, bem como, endereço ou link de imagens em uma página HTML, modificar formato de texto ou remover caracteres inválidos. Sintaxes Básicos em Expressões Regulares - DevMedia https://www.devmedia.com.br › iniciando-expressoes-reg... Pesquisar: O que significa a expressão regular? Como negar uma expressão regular? Qual a expressão regular deve ser aplicada para o formato correto de um CPF? Como usar expressão regular no Excel? Como validar uma string com Regex? Como validar o CPF no Google Forms? Como validar CPF em C#? Como validar CEP com javascript? Como fazer Regex php? Como usar Regex em Java? Como usar Regex em Python? O que é uma flag JavaScript? O que é em JavaScript? Como validar uma string em JavaScript? O que é um trabalho regular? O que é trabalhar regularmente? Feedback Expressões Regulares - JavaScript - MDN Web Docs https://developer.mozilla.org › ... › Guia JavaScript 22 de fev. de 2022 — Caracteres especiais utilizados em expressões regulares. ... Note que \1, \2, \n são utilizados na parte correspondente do regex. Você visitou esta página em 09/07/22. Sintaxes Básicos em Expressões Regulares - DevMedia https://www.devmedia.com.br › Artigos › .NET NET a classe Regex representa uma expressão regular imutável. ... Segue uma breve descrição dos caracteres especiais mais utilizados em expressão regular. Você visitou esta página em 09/07/22. RegEx: O que é, Como usar em Palavras e Números | Alura https://www.alura.com.br › expressoes-regulares é um caractere especial e significa qualquer caractere. Ou seja, a Regex não interpreta o ponto literalmente e sim faz um match para qualquer *char. *. Regex: Um guia prático para expressões regulares - Medium https://medium.com › xp-inc › regex-um-guia-pratico-... 31 de jan. de 2020 — Uma expressão regular é um método formal de se especificar um padrão de texto. Com ela podemos lidar com as seguintes situações: procura; ... Classes de caracteres em expressões regulares do .NET https://docs.microsoft.com › pt-br › standard › base-types 23 de jun. de 2022 — MatchCollection matches = Regex.Matches(input, pattern); foreach (Match match in matches) Console.WriteLine($"'{match. Você visitou esta página em 09/07/22. Linguagem de expressões regulares – referência rápida https://docs.microsoft.com › pt-br › standard › base-types 23 de jun. de 2022 — Um padrão tem um ou mais literais de caracteres, operadores ou ... da cadeia de caracteres original e, em seguida, é executado Regex. Regex caracteres especiais obrigatório - java - Stack Overflow https://pt.stackoverflow.com › questions › regex-caracte... 1 de dez. de 2018 — Este código exibe true no console quando for um padrão válido, e false para padrões inválidos. Você pode testar esse código no JavaFiddle como ... 2 respostas · Melhor resposta: Regex Usada Essa regex faz a validação, você pode testa-la aqui: (?=.*[}{,.^?~=+\-_\/*\-+.\|])( ... Regex - Remoção de Caracteres Especiais C# - Stack Overflow 19 de jul. de 2014 Verificar a existência de caracteres especiais em uma string ... 11 de nov. de 2018 Como validar com regex uma string contendo apenas letras ... 15 de nov. de 2015 Como extrair apenas a última sequência de palavras depois ... 22 de set. de 2021 Mais resultados de pt.stackoverflow.com Você visitou esta página em 09/07/22. Expressões regulares: introdução — Mini Tutorial RegEx http://turing.com.br › material › regex › introducao O termo em inglês é regular expression de onde vem as abreviações regex e re (o ... é um caractere ou sequência de caracteres com significado especial em ... Expressões Regulares (RegExp) - Documentação - GoCache https://docs.gocache.com.br › smart_rules-regexp RegExp. Expressões regulares, também conhecidas como RegEx ou RegExp são usadas para englobar um padrão de caracteres usando alguns caracteres especiais. Na ... As pessoas também perguntam Como validar uma string com Regex? Como usar Regex em Java? Como fazer Regex php? Feedback Pesquisas relacionadas regex caracteres especiais javascript regex espaço em branco regex caracteres especiais python regex exemplos regex para pegar um texto entre regex javascript regex documentation regex qualquer caractere 1 2 3 4 5 6 7 8 9 10 Mais Brasil Porto Alegre, RS - Com base na sua atividade anterior - Atualizar local AjudaEnviar feedbackPrivacidadeTermos ************************************************************************************** Neste artigo eu vou tentar explicar o básico sobre expressões regulares, vou direcionar o conteúdo para o uso no Google Analytics e Tag Manager. O que são Expressões Regulares? O que são Metacaracteres? Tipos de Expressões Regulares Quais são as vantagens de usar o REGEX no Google Analytics? Construindo uma expressão regular Detalhando as Expressões Regulares Invertendo Regex em JavaScript Testando as expressões regulares (RegEx) Muitos profissionais de Ciência de dados, Analistas e Programadores precisam lidar com expressões regulares em algum momento. Essa linguagem exótica é usada para encontrar padrões complexos de texto e pode parecer complicada e intimidadora no início. No entanto, as expressões regulares são uma ferramenta poderosa que requer apenas um pequeno investimento de tempo para aprender. Expressões Regulares são quase universais, e são capazes de lidar com quase todos os tipos de dados. Várias plataformas de análise de dados e linguagens de programação as suportam, incluindo SQL, Python, R, Alteryx, Tableau, LibreOffice, Java, Scala, .NET e Go. Os principais editores de texto e IDEs, como o Atom Editor, o Notepad ++, o Emacs, o Vim, o Intellij IDEA e o PyCharm também suportam a pesquisa de arquivos com expressões regulares. E ferramentas conhecidas como: Google Analytics, Tag Manager, Optimizer e muitas outras. O grande suporte das expressões regulares significa que elas pode ser usadas em quase todos os tipos de sistemas, surpreendentemente elas não têm uma curva de aprendizado muito grande. Se você se encontra escaneando documentos manualmente ou analisando substrings apenas para identificar padrões de texto, talvez seja legal aprender. Especialmente nas áreas de Ciência e Engenharia de dados, elas podem ajudar em muitas tarefas, desde organizar os dados, até qualificá-los e classificá-los. Neste artigo também irei comentar sobre alguns recursos das expressões regulares para ajudar na grande maioria das tarefas que você pode se deparar. O que são Expressões Regulares? Expressões Regulares são usadas para identificar um padrão em uma string. É uma forma matemática usada para calcular e identificar certos caracteres usados para definir padrões numa cadeira de caracteres, também chamadas de strings. As Expressões Regulares também são conhecidas como regex (regular expressions). Por exemplo, ^Flor?es$ é uma expressão regular que corresponde as duas strings: flor e flores. Um regex é composto de caracteres e metacaracteres. O regex usado neste artigo é para JavaScript. Se você desejar testar e aprender Expressões Regulares mais a fundo saiba mais neste link. O que são Metacaracteres? São caracteres que determinam funções especiais dentro de uma regex. Eles são os blocos de construção de um regex. Por exemplo: [ ], ^, ( ), { }, $, +, *, etc. Tipos de Expressões Regulares Os tipos de sintaxe usadas para construir expressões regulares são chamadas de regex engines (mecanismos de expressão regular), ou seja, são usadas na sua implementação. Existem muitos tipos de regex engines disponíveis. Os mais populares entre eles são: PCRE (PHP) JavaScript Python Golang Cada mecanismo interpreta e suporta diferentes formas de sintaxe e o significado dos metacaracteres pode mudar dependendo do mecanismo de regex que está sendo usado. O mecanismo de expressão regular no JavaScript define um conjunto específico de caracteres para serem interpretados como “palavras”. Qualquer caractere que não esteja neste conjunto é considerado uma “quebra de palavra”. Este conjunto de caracteres é bastante limitado: consiste apenas no alfabeto romano tanto maiúsculo como minúsculo, digítos decimais, e o caractere underline. Caracteres com acento, tal como “é” ou “ã” são, infelizmente, tratados como “palavras quebradas”. Portanto, uma expressão regular considerada válida em um regex engine pode não ser considerada válida em outro regex engine. Entendeu? Sempre que você testar uma regex usando uma ferramenta de teste para regex, terá a opção de selecionar o mecanismo com o qual você deseja testar sua expressão regular: Ferramenta de testes para expressões regulares O mecanismo de expressão regular usado pelo Google Analytics e pelo Tag Manager é o JavaScript, você deve sempre selecionar JavaScript para testar suas expressões regulares para o GA/GTM. Quais são as vantagens de usar o REGEX no Google Analytics? Existem muitos casos em que expressões regulares são úteis no Google Analytics. Alguns desses casos são: Configurar uma meta que deve corresponder a várias páginas: Expressão Regular como meta no Google Analytics Configurar um funil em que uma etapa deve corresponder a várias páginas Na verdade, quando você configura um funil, todas as URLs são tratadas como expressões regulares: Usando expressão regular para criar um funil de meta no Google Analytics Usando filtros para excluir tráfegos de IPs De fato, existem muitos filtros que exigem expressões regulares. Grandes empresas geralmente possuem um largo intervalo de endereços IP. Portanto, para filtrar o tráfego interno da empresa, você precisa especificar um intervalo de IP através de uma regex: Filtro interno de IP usando Regex Configurar segmentos personalizados complexos, como os segmentos que podem corresponder a palavras-chave de marca Segmento Customizado para palavras-chaves no Google Analytics Nesse segmento acima eu defino todas as buscas que contém apenas 1 palavra, ou seja, uma string. Entendendo o valor das palavras-chaves de cauda longa Segmento Customizado para palavras-chave de cauda longa Na imagem acima conseguimos ver o tráfego separado por número de strings na consulta, ou seja, podemos analisar a profundidade da cauda longa. Para funcionar é necessário excluir as strings (not set), (not provided) ou outras definidas por padrão no Googla Analytics da amostragem na hora de montar o segmento. Outra dica é você excluir as strings que contenham sua marca (branded search) e criar um outro segmento somente para consultas que contenham o nome de sua marca. Reescrevendo URLs nos relatórios do Google Analytics Por exemplo, incluindo o dominio (host) na URI da solicitação: filtro-dominio-uri Filtro para incluir o nome do host na URI de soliticação Você também pode reescrever URLs nos relatórios do Google Analytics com o filtro avançado Pesquisar e Substituir. Ele é útil quando seu website possui URLs dinâmicas muito longas e desagradáveis, e você não consegue descobrir sobre o que trata a página apenas observando a URL. Por exemplo, com o filtro avançado Pesquisar e substituir, você pode solicitar ao GA que substitua a seguinte URL: https://www.exemplo.com/produtos/?cat=2341&pid=428 Por: https://www.exemplo.com/jardim/vasos/ Assim o time de Marketing poderá identificar melhor as áreas do site na hora de criar relatórios. Filtrar dados baseados em padrões complexos nos relatórios do Google Analytics Por exemplo, a regex a seguir pode segmentar todo o tráfego de mídias sociais: twitter\.com|facebook\.com|linkedin\.com|plus\.google\.com|reddit\.com|instagram\.com|youtube\.com|stackoverflow\.com|quora\.com Filtro avançado usando regex para identificar algumas mídias sociais Encontrando a origem de SPAM no Google Analytics Por exemplo, você pode usar a seguinte regex (não é infalível) para filtrar todas as origens de SPAM no relatório Referrals: 127.0.0.1|justprofit.xyz|nexus.search-helper.ru|rankings-analytics.com|videos-for-your-business|adviceforum.info|video—production|success-seo|sharemyfile.ru|seo-platform|dbutton.net|wordpress-crew.net|rankscanner|doktoronline.no|o00.in Filtro avançado usando regex para identificar alguma origens de SPAMERS Bloquear origens de SPAM através de um Filtro personalizado no Google Analytics Se você conseguiu identificar as origens de alguns SPAMERS em seus relatórios você pode bloquear que essas referências para que não sejam contabilizadas nos relatórios do Google Analytics: Filtro excluindo a referência de spamers no Google Analytics Usando expressões regulares para criar grupos de conteúdo no Google Analytics Na imagem podemos usar uma regex na criação de uma grupo de conteúdo para acompanhar uma determinada categoria em um e-commerce. Usando regex para criar grupos de conteúdo no Google Analytics Usando expressões regulares para criar agrupamento de canais no Google Analytics No caso eu posso agrupar os canais parceiros de Link Building, mas também pode ser usado para outros vários propósitos. Agrupamento de canais usando expressão regular no Google Analytics Usando expressões regulares para rastrear pesquisas realizadas sem o parâmetro de consulta na URL Observe a seguinte URL: https://www.americanas.com.br/busca/tv-65-polegadas-4k Ao realizar uma busca nas Lojas Americanas o sistema não gera parâmetros de busca na URL, ela gera uma URL totalmente nova. Você poderia usar a seguinte expressão regular: \/busca\/(.*) Regex para selecionar apenas URLs geradas a partir de uma busca Para analisar todas as buscas seria necessário criar uma variável usando o Tag Manager e enviar para o Google Analytics, mas caso haja interesse eu escrevo sobre isso em um outro artigo. Quais são as vantagens de usar o REGEX no Tag Manager? Através de expressões regulares você pode configurar triggers (acionadores ou disparadores) avançados: Se você quiser ter um Trigger para vários eventos personalizados, poderá usar uma regex com o nome do evento. Aqui, a regex faz distinção entre maiúsculas e minúsculas, portanto, tenha cuidado com os valores inseridos. Usando regex para criar um “acionador” no Tag Manager Você pode usar esse Trigger para acionar um evento ou função para criar um Público de perfis compradores no seu e-commerce. Construindo uma expressão regular Classe de caracteres CARACTERE SIGNIFICADO . (O ponto) corresponde um único caracter qualquer exceto os caracteres de nova linha: \n, \r, \u2028 ou \u2029. Note que a flag MULTILINE m não muda o comportamento do ponto. Então para corresponder um padrão por múltiplas linhas, o conjunto de caracteres [^] pode ser usado, que corresponderá qualquer caractere, incluindo novas linhas. Por exemplo, /.y/ corresponde my e ay, mas não yes, em yes make my day. \d Corresponde um caractere de dígito no alfabeto (Latim). Equivalente a [0-9]. Por exemplo, /\d/ ou/[0-9]/ corresponde 2 em B2 é o número da suíte. \D Corresponde qualquer caractere que não é um dígito no alfabeto baseado no Latim. Equivalente a [^0-9]. Por exemplo, /\D/ ou /[^0-9]/ corresponde B em B2 é o número da suíte. \w Corresponde qualquer caractere alfanumérico do alfabeto baseado no Latim, incluindo o underline. Equivalente a [A-Za-z0-9_]. Por exemplo, /\w/ corresponde a em apple, 5 em $5.28, e 3 em 3D. \W Corresponde qualquer caractere que não é um alfanumérico do alfabeto baseado no Latim. Equivalente a [^A-Za-z0-9_]. Por exemplo, /\W/ ou /[^A-Za-z0-9_]/corresponde % em 50%. \s Corresponde um único caractere de espaço em branco, incluindo espaço, tabulação (tab), quebra de página, nova linha (LF) e outros espaços Unicode. Equivalente a: [\f\n\r\t\v​\u00a0\u1680​\u180e\u2000​\u2001\u2002​\u2003\u2004\u2005\u2006​\u2007\u2008​\u2009\u200a​\u2028\u2029​\u202f\u205f​\u3000]. Por exemplo, /\s\w*/ corresponde bar em foo bar. \S Corresponde um único caractere que não seja um espaço em branco. Equivalente a: [^\f\n\r\t\v​\u00a0\u1680​\u180e\u2000​\u2001\u2002​\u2003\u2004\u2005\u2006​\u2007\u2008​\u2009\u200a​\u2028\u2029​\u202f\u205f​\u3000]. Por exemplo, /\S\w*/ corresponde foo em foo bar. \t Corresponde uma tabulação. \r Corresponde uma quebra de linha. \n Corresponde uma nova linha. \v Corresponde uma tabulação vertical. \f Corresponde uma quebra de página. [\b] Corresponde um carácter backspace. (Não confundir com \b). \0 Corresponde um caractere NULL. Não coloque outro dígito seguinte a esse. \cX Onde X é uma letra de A-Z. Corresponde um caractere de controle em uma string. Por exemplo, /\cM/ corresponde control-M em uma string. \xhh Corresponde o caractere com o valor Unicode hh (dois dígitos hexadecimais). \uhhhh Corresponde o caractere com o valor Unicode hhhh (quatro dígitos hexadecimais). \ Para caracteres que são geralmente tratados literalmente, indica que o próximo caractere é especial e NÃO deve ser interpretado literalmente. Por exemplo,/b/ corresponde o caractere b. Colocando uma barra invertida antes do b, ou seja, usando /\b/, o caractere se torna especial, significando corresponder o limite de uma string. Para caracteres que são geralmente tratados especialmente, indica que o próximo caractere NÃO é especial e deve ser interpretado literalmente. Por exemplo, * é um caractere especial que corresponde a 0 ou mais ocorrências do caractere que o precede; por exemplo, /a*/ significa corresponder 0 ou mais ocorrências de a. Para corresponder * literalmente, preceda-o com uma barra invertida; por exemplo, /a\*/ corresponde a*. Conjunto de caracteres CARACTERE SIGNIFICADO [xyz] Um conjunto de caracteres. Corresponde qualquer um dos caracteres cercados. Você pode especificar uma extensão de caracteres usando um hífen. Por exemplo, [abcd] é o mesmo que [a-d]. Eles correspondem o b em banco e o c[cci] em [cci]cortar. [^xyz] Um conjunto de caracteres negativo ou complementado. Isto é, corresponde qualquer coisa que NÃO esteja cercada nos colchetes. Você pode especificar uma extensão de caracteres usando um hífen. Por exemplo, [^abc] é o mesmo que [^a-c]. Eles inicialmente correspondem n em banco e o em cortar. Limites CARACTERE SIGNIFICADO ^ Corresponde o início de uma entrada. Se a flag MULTILINE é utilizada, também corresponde imediatamente após um caractere de quebra de linha. Por exemplo, /^A/ não corresponde o A em an A, mas corresponde o primeiro A em An A. $ Corresponde o fim de uma entrada. Se a flag MULTILINE é utilizada, também corresponde imediatamente antes de um caractere de quebra de linha. Por exemplo, /o$/ não corresponde o o em cantor, mas corresponde em canto. \b Corresponde um limite de uma palavra sem espaço, como entre uma letra e um espaço (Não confundir com [\b]). Por exemplo, /\bno/ corresponde o no em de noite e /ly\b/ corresponde o ly em possibly yesterday. \B: Corresponde a um limite que não inclui palavras sem espaço, como entre duas letras ou entre dois espaços. Por exemplo: Antes do primeiro caractere de uma string; Depois do último caractere de uma string; Entre dois caracteres de uma palavra; Entre dois caracteres que NÃO contém palavras; Uma string vazia. Por exemplo, /\Bte/ corresponde de em de noite, e /on\B/ corresponde on em possivelmente ontem. Agrupamentos e Back References CARACTERE SIGNIFICADO (x) Corresponde x e memoriza o resultado da regex. Esses são chamados parênteses de captura. Por exemplo, /(foo)/ corresponde e memoriza foo em foo bar. A substring correspondida pode ser chamada novamente dos elementos do array resultante [1], …, [n] ou das propriedades predefinidas do objeto RegExp $1, …, $9. Grupos de captura têm uma falta na performance. Se você não necessita que a substring correspondida seja chamada novamente, prefira parênteses de não-captura (veja mais abaixo). \n Onde n é um número inteiro positivo. Uma referência posterior à última correspondência da substring n em uma expressão regular (contando parênteses esquerdos). Por exemplo, /apple(,)\sorange\1/ corresponde apple, orange, emapple, orange, cherry, peach. Um exemplo mais completo está a seguir nesta tabela. (?:x) Corresponde x mas não memoriza a correspondência. Esses são chamados parênteses de não-captura. A substring correspondida não pode ser chamada novamente dos elementos do array resultante [1], …, [n] ou das propriedades predefinidas do objeto RegExp $1, …, $9. Quantificadores CARACTERE SIGNIFICADO x* Corresponde o item precedente x zero ou mais vezes. Por exemplo, /assusto*/ corresponde assustoooo em Um fantasma assustooooue assust em Não me assustei, mas não corresponde em Um bode grunhiu. x+ Corresponde o item precedente x uma ou mais vezes. Equivalente a {1,}. Por exemplo, /o+/ corresponde o o em doce e todos os o em doooooooce. x? Corresponde o item precedente x nenhuma ou uma vez. Por exemplo, /e?le?/ corresponde o el em angel e o le em angle. Se usado imediatamente após qualquer dos quantificadores *,?, ou { }. Faz o quantificador (coincidindo com o número mínimo de vezes), como oposto ao padrão (correspondendo ao número máximo de vezes). Também usado em asserções lookahead, descritas em (? =), (?!), E (? :) nesta tabela. x(?=y) Corresponde x apenas se x é seguido por y. Por exemplo, /Jack(?=Sprat)/ corresponde Jack apenas se for seguido por Sprat. /Jack(?=Sprat|Frost)/ corresponde Jack apenas se for seguido por Sprat ou Frost. Porém, nem Sprat nem Frost são partes do resultado da correspondência. x(?!y) Corresponde x apenas se x NÃO é seguido por y. Por exemplo,/\d+(?!\.)/ corresponde um número apenas se não for seguido por um ponto./\d+(?!\.)/.exec('3.141') corresponde 141, mas não 3.141. x|y Corresponde ou x ou y. Por exemplo, /verde|vermelha/ corresponde verde emmaçã verde e vermelha em maçã vermelha. x{n} Onde n é um número inteiro positivo. Corresponde exatamente a ocorrências do item precedente x. Por exemplo, /a{2}/ NÃO corresponde o a em candy, mas ele é todos os a em caandy, e os dois primeiros a em caaandy. x{n,} Onde n é um número inteiro positivo. Corresponde pelo menos n ocorrências do item precedente de x. Por exemplo, /a{2,}/ NÃO corresponde o a em candy, mas corresponde a todos em caandy e em caaaaaaandy. x{n,m} Onde n e m são números inteiros positivos. Deve corresponder pelo menos n e no máximo m ocorrências do item precedente de x. Por exemplo, /a{1,3}/ NÃO corresponde nada em cndy, corresponde o a em candy, corresponde os dois a em caandy, e os primeiros três a em caaaaaaandy. Note que quando estiver combinando caaaaaaandy, a correspondência é aaa, mesmo que a string original tenha mais a. Detalhando as Expressões Regulares Caractere de Escape \ \ O caractere de escape é usado para determinar como um caractere subsequente será interpretado. Embora seja apenas um caractere de escape, você pode converter um caractere comum em metacaractere ou transformar um metacaractere meta em um caractere comum. Por exemplo: / tem um significado especial na regex. É usado para marcar o início e o fim de uma expressão regular. Por exemplo: var a = /colou?r/; Se você quiser uma regex para tratar barra como uma barra \ e não como um caractere especial, então você precisa usá-lo junto com o caractere de escape como este: \/ Então, se você quiser isolar a string /shop/ na string /shop/category/men/. Sua regex deve ser:\/shop Se você usar a regex /shop, ela não corresponderá à string /shop/category/men/ porque / será tratado como um caractere especial em vez de uma barra. Outro exemplo: n é um caractere normal. Mas se você adicionar um caractere de escape antes dele, ele se tornará um metacaractere: \n será um novo caractere. Então, se você quiser encontrar somente \n na string abcd\n3456. Sua regex deve ser: \\n Se você usar a regex abcd\n, não corresponderá à string abcd\n3456 porque \n seria tratado como um caractere especial em vez de um caractere normal. Outro exemplo: ? É um metacaractere. Para torná-lo em um caractere normal, você precisa adicionar um caractere de escape antes: \? Então se você quiser corresponder uma string com ponto de interrogação, por exemplo casar?. Sua regex deve ser: casar\? Se você usar casar? em uma regex, ela corresponderia somente à casar e não a string casar? pois ? será tratado como metacaractere. Acento ^ ^ = Isso é conhecido como acento circunflexo e é usado para marcar o início de uma expressão regular. ^\/Colou?r = Verifica se há um padrão que comece com /Color ou /Colour. Exemplo: /Colour/?proid=3456/review /Color-red/?proid=3456/review ^\/Nov(ember)? = Verifique se há um padrão que comece com /Nov ou /November. Exemplo: /November-sales/?proid=3456/review /Nov-sales/?proid=3456/review ^\/elearning\.html = Procura um padrão que comece com /elearning.html. Exemplo: /elearning.html/?proid=3456/review ^\/.*\.php = Verifica se há um padrão que comece com qualquer arquivo com a extensão .php. Exemplo: /elearning.php/color/?proid=3456/review /games.php/?proid=3456/ /a1.php/color/?proid=3456&gclid=153dwf3533 ^\/product-price\.php = Verifica se há um padrão que comece com /product-price.php. Exemplo: /product-price.php?proid=123&cid=2142 /product-price.php?cid=2142&gclid=442352df ^ também significa NÃO quando usado após um colchete de abertura [^a] = Verifica se existe algum caractere diferente da letra minúscula a. Por exemplo: a seguinte regex product-[^a] corresponderá: /shop/men/sales/product-b /shop/men/sales/product-c [^1] = Verifica se existe algum caractere diferente do número 1. Por exemplo: a regex proid=[^1] corresponderá: /men/product-b?proid=3456&gclid=153dwf3533 Mas não corresponde a: /men/product-b?proid=1456&gclid=153dwf3533 [^ab] = Verifica se existe algum caractere diferente das letras minúsculas a e b. Por exemplo: a seguinte regex location=[^ab] corresponderá: /shop/collection/prodID=141?location=canada Mas não corresponde a: /shop/collection/prodID=141?location=america /shop/collection/prodID=141?location=bermuda [^aB] = Verifique se existe algum caractere diferente da letra minúscula a e letra maiúscula B. [^1B] = Corresponde a qualquer caractere diferente do número 1 e da letra maiúscula B. [^Dog] = Corresponde a qualquer caractere diferente da seguinte sequência: letra maiúscula D, letra minúscula o e letra minúscula g. Por exemplo: A seguinte regex location=[^Dog] corresponderá: /shop/collection/prodID=141?location=canada /shop/collection/prodID=141?location=denmark Mas não corresponde a: /shop/collection/prodID=141?location=Denver /shop/collection/prodID=141?location=ontario /shop/collection/prodID=141?location=greenland [^123b] = Corresponde a qualquer caractere diferente dos seguintes caracteres: número 1, número 2, número 3 e letra minúscula b. [^1-3] = Corresponde a qualquer caractere diferente do seguinte: número 1, número 2 e número 3. Por exemplo: a seguinte regex prodID=[^1-3] corresponderá: /shop/collection/prodID=45321&cid=1313 /shop/collection/prodID=5321&cid=13442 Mas não corresponde: /shop/collection/prodID=12321&cid=1313 /shop/collection/prodID=2321&cid=1313 /shop/collection/prodID=321&cid=1313 [^0-9] = Verifica se há algum caractere diferente de um número. Por exemplo: a regex de\/[^0-9] corresponderá a todas as páginas do diretório de/ cujo a string não seja iniciado por um número: /de/school-london /de/general/ Mas não corresponde a: /de/12fggtyooo [^a-z] = Corresponde a qualquer caractere único que não seja uma letra minúscula. Por exemplo: a regex de\/[^a-z] corresponderá a todos os diretórios de/ cujo a string não comece com uma letra minúscula: /de/1london-school /de/?productid=423543 Mas não corresponde: /de/school/london [^A-Z] = Corresponde a qualquer caractere único que não seja uma letra maiúscula. Dólar $ $ é usado para expressar o fim de uma expressão regular ou o final de uma linha. Por exemplo: CARACTERE SIGNIFICADO Colou?r$ Verifica se há um padrão que termine com Color ou Colour. Nov(ember)?$ Verifica se há um padrão que termine com Nov ou November. elearning\.html$ Procura um padrão que termine em elearning.html. \.php$ Procura por um padrão que termine com .php. product-price\.php$ Verifica se há um padrão que termine com product-price.php. Colchetes [ ] [ ] = Este colchete é usado para verificar qualquer caractere único em um conjunto de caracteres especificado entre [ ]. Por exemplo: CARACTERE SIGNIFICADO [a] Verifica se existe um único caractere que seja uma letra minúscula “a”. [ab] Verifica se existe um único caractere que seja uma letra minúscula “a” ou “b”. [aB] Verifica se existe um único caractere que seja uma letra minúscula “a” ou letra maiúscula “B”. [1B] Verifica se existe um único caractere que seja um número “1” ou uma letra maiúscula “B”. [Dog] Verifica se existe um único caractere que pode ser qualquer um dos seguintes caracteres: letra maiúscula “D”, letra minúscula “o” ou letra minúscula “g”. [123b] Verifica se existe um único caractere que pode ser qualquer um dos seguintes caracteres: número “1”, número “2”, número “3” ou letra minúscula “b”. [1-3] Verifica se existe um único caractere que pode ser qualquer um dos números 1, 2 e 3. [0-9] Verifica se existe um único caractere que seja um numeral. [a-d] Verifica se existe um único caractere que pode ser qualquer uma das seguintes letras minúsculas: “a”, “b”, “c” ou “d”. [a-z] Verifica se existe um único caractere que seja uma letra minúscula. [A-Z] Verifica se existe um único caractere que seja uma letra maiúscula. [A-T] Verifica se há um único caractere que pode ser qualquer letra maiúscula de “A” à “T”. [home.php] Procure por um único caractere que pode ser qualquer um dos seguintes caracteres: letra minúscula “h”, letra minúscula “o”, letra minúscula “m”, letra minúscula “e”, caractere especial “.” , letra minúscula “p”, letra minúscula “h” ou letra minúscula “p”. Se você deseja verificar uma letra, independentemente do seu estado (maiúscula ou minúscula), use [a-zA-Z]. Parênteses ( ) ( ) = Mais conhecido como parênteses, é usado para selecionar e verificar uma string. Por exemplo: CARACTERE SIGNIFICADO (a) Verificar a correspondência da string “a” (ab) Verificar a correspondência da string “ab”. (dog) Verificar a correspondência da string “dog”. (dog123) Verificar a correspondência da string “dog123”. (0-9) Verificar a correspondência da string “0-9”. (A-Z) Verificar a correspondência da string “A-Z”. (a-z) Verificar a correspondência da string “a-z”. (123dog588) Verificar a correspondência da string “123dog588”. ( ) também é usado para criar e armazenar variáveis. Por exemplo, ^ (.*) $ Ponto de interrogação ? ? É usado para verificar zero (nenhuma ocorrência) ou uma ocorrência do caractere que o precede. Por exemplo: CARACTERE SIGNIFICADO [a]? Verifica se existe zero ou uma ocorrência de letra minúscula “a”. [dog]? Verifica se existe zero ou uma ocorrência das letras minúsculas “d”, “o” ou “g”. [^dog]? Verifique se existe zero ou uma ocorrência de um caractere que não sejam as letras minúscula “d”, “o” ou “g”. [0-9]? Verifica se existe zero ou uma ocorrência de um número. [^a-z]? Verifica se existe zero ou uma ocorrência de um caractere que não seja uma letra minúscula. ^casa?r$ Verifica a ocorrência da string “casa” ou “casar”. ^Nov(ember)28(th)?$ Verifica a ocorrência das seguintes strings “nov 28”, “november 28”, “Nov 28th” e “November 28th”. ? quando usado dentro de uma expressão regular, transforma uma letra ou um conjuntos de letras que o precede em opcional. Por exemplo, a expressão regular: ^casa?r$ corresponde tanto a “casa” como a “casar”. Da mesma forma, a expressão regular: ^Nov(ember)28(th)?$ corresponde a: “nov 28”, “november 28”, “Nov 28th” e “November 28th”. Sinal de + + É usado para verificar uma ou mais ocorrências do caractere que o precede. Por exemplo: CARACTERE SIGNIFICADO [a]+ Verifica uma ou mais ocorrências de letra minúscula “a”. [dog]+ Verifica uma ou mais ocorrências de letras “d”, “o” ou “g”. [548]+ Verifica uma ou mais ocorrências de números “5”, “4” ou “8”. [0-9]+ Verifica um ou mais números. [a-z]+ Verifica uma ou mais letras minúsculas. [^a-z]+ Procura por um ou mais caracteres que não sejam letras minúsculas. [a-zA-z]+ Procura por qualquer combinação de letras maiúsculas e minúsculas. [a-z0-9]+ Procura por qualquer combinação de letras minúsculas e números. [A-Z0-9]+ Procura por qualquer combinação de letras minúsculas e números. [^9]+ Procura por um ou mais caracteres que não sejam o número 9. Asterisco * * É usado para verificar qualquer número de ocorrências (incluindo zero ocorrências) do caractere que o precede. Por exemplo, 31* corresponderia a 3, 31, 311, 3111, 31111 etc. Ponto . . É usado para verificar um único caractere (qualquer caractere que possa ser digitado no teclado que não seja um caractere de quebra de linha (\n)). Por exemplo, a expressão regular: Action ., Scene2 corresponderia: Action 1, Scene2 Action A, Scene2 Action 9, Scene2 Action &, Scene2 Mas não corresponderia: Action 10,Scene2 Action AB,Scene2 Barra Vertical | | Numa expressão regular é interpretado por “OU” na lógica de uma regex. Por exemplo: (dele|dela) = Verifica a ocorrência da string “dele” ou “dela”. dele|dela = Verifica a ocorrência da string “dele” ou “dela”. Por exemplo, a regex dele|dela vai corresponder: Este é o livro dele Este é o livro dela Dele ou Dela Dela ou Dele Exclamação ! ! – Numa expressão regular é interpretado por “NÃO” na lógica de uma regex. Mas ao contrário de ^ (circunflexo), o ! é usado apenas no início de uma regra ou condição. Por exemplo: (!abc) = Procura por uma string que não seja a string “abc”. [!0-9] = Verifica se existe um único caractere que não seja um número. [!a-z] = Verifica se existe um único caractere que não seja uma letra minúscula. Sinal de chaves { } { } é usado para verificar uma ou mais ocorrências do caractere anterior. É como o metacaractere +, mas fornece controle sobre o número de ocorrências do caractere que você deseja corresponder na regex. Por exemplo: CARACTERE SIGNIFICADO 1{1} Verifica uma ocorrência do caractere “1”. Esta regex corresponderá a string “1”. 1{2} Verifica por duas ocorrências do caractere “1”. Este regex vai corresponder a string “11”. 1{3} Verifica por três ocorrências do caractere “1”. Este regex corresponderá a string “111”. 1{4} Verifica se existe quatro ocorrências do caractere “1”. Este regex corresponderá a string “1111”. 1{1,4} Verifica por 1 a 4 ocorrências do caractere “1”. Esta regex corresponderá a 1,11, 111, 1111. [0-9]{2} Verifica se há duas ocorrências de um número ou, em outras palavras, verifique se há dois dígitos como, por exemplo, o número “12”. [0-9]{3} Verifica por 3 ocorrências de um número ou em outras palavras, verifique se há três dígitos como, por exemplo, o número “123”. [0-9]{4} Verifica se há 4 dígitos como, por exemplo, o número “1234”. [0-9]{1,4} Procura um número de 1 a 4 dígitos. [a]{2} Verifica se há duas ocorrências do caractere “a”. Esta regex corresponderá a string “aa”. [a]{3} Procura por 3 ocorrências do caractere “a”. Este regex corresponderá a string “aaa”. [a]{4} Verifica se há 4 ocorrências do caractere “a”. Este regex corresponderá s tring “aaaa”. [a]{1,4} Procura de 1 à 4 ocorrências do caractere “a”. Esta regex corresponderá as strings “a”, “aa”, “aaa”, “aaaa”. [a-z]{2} Procura por 2 ocorrências de uma letra minúscula. Este regex vai corresponder as strings “aa”,”bb”, “cc” e etc. [A-Z]{3} Procura por 3 ocorrências de uma letra maiúscula. Este regex vai corresponder as strings “AAA”, “BBB”, “CCC” e etc. [a-zA-Z]{2} Procura por 2 ocorrências de uma letra (não importando se é maiúscula ou minúscula). Este regex vai corresponder a “aa”, “aA”, “Aa”, “AA” e etc. [a-zA-Z]{1,4} Procura de uma à 4 ocorrências de uma letra (não importando se é maiúscula ou minúscula). Este regex corresponderá: “aaaa”, “AAAA”, “aAAA”, “AAAa” e etc. (rock){1} Procura por uma ocorrência da string “rock”. Este regex irá corresponder a: “rock”. (rock){2} Procurar por duas ocorrências da string “rock”. Este regex corresponderá: “rockrock”. (rock){3} Procura por 3 ocorrências da string “rock” . Este regex corresponderá: “rockrockrock”. (rock){1,4} Verifica de 1 à 4 ocorrências da string “rock”. Este regex corresponderá: “rock”, “rockrock”, “rockrockrock”, “rockrockrockrock”. Espaço em branco ou vazio Para criar um espaço em branco em uma expressão regular, basta usar um espaço em branco. Por exemplo: (Chuck Norris) = Irá corresponder a string “Chuck Norris”. Invertendo Regex em JavaScript Inverter um regex significa inverter seu significado. Você pode inverter um regex em JavaScript usando lookaheads positivos e negativos. Use lookahead positivo se quiser corresponder a algo que é seguido por uma outra coisa. Use lookahead negativo**** se quiser corresponder a algo não seguido por uma outra coisa. Lookahead positivo começa com (?= seguido de). Lookahead negativo começa com (?! seguido de). Por exemplo: a regex de\/[^a-z] corresponderá a todas as URLs da pasta de/ cujo nome NÃO comece por uma letra minúscula. Exemplo: /de/1london-school /de/?productid=423543 Mas irá corresponder a: /de/school/london O inverso desta expressão regular seria: corresponder a todas as URLs na pasta de/ cujo nome começa com uma letra minúscula: Por exemplo: o regex de\/(?![^a-z]) corresponderá: /de/school/london Mas não corresponde: /de/1london-school /de/?productid=423543 A Regex do JavaScript suporta apenas lookaheads e não lookbehind. O Google Analytics não suporta lookahead ou lookbehind. Outros exemplos de Regex CARACTERE SIGNIFICADO ^(*\.html)$ Verifica qualquer ocorrência de caracteres que precede .html e os armazena em uma variável. ^dog$ Procura a string “dog”. ^a+$ Verifica a ocorrência de uma ou mais letras minúsculas “a”. ^(abc)+$ Verifica uma ou mais ocorrências da string “abc”. ^[a-z]+$ Verifica uma ou mais ocorrências de uma letra minúscula. ^(abc)*$ Verifica qualquer número de ocorrências da string “abc”. ^a*$ Verifica qualquer número de ocorrências da letra minúscula “a”. Com encontrar todos os arquivos que começam com “elearning” e que têm a extensão de arquivo .html. Regex: ^elearning*\.html$ Como encontrar todos os arquivos PHP. Regex: ^*\.php$ Testando as expressões regulares (RegEx) Se você se considera iniciante ou experiente no uso de regex, você deve sempre testar suas expressões regulares. Você pode testar expressões regulares através de: Extensão cromo do RegExp Tester; Ferramenta on-line Regex101.com; O filtro de tabela avançada na interface de relatórios no GA com a opção Regex; Recurso de visualização do seu segmento personalizado no GA; Janela de console de depuração do GTM para testar a regex usada em gatilhos e variáveis; Usando RegExpObject para testar o regex no GTM durante o tempo de execução. Testando a Regex #1: Extensão chrome RegExp Tester O RegExp Tester é uma extensão do Chrome usada para criar e validar expressões regulares: RegExp Tester Na expressão regular abaixo, o resultado da pesquisa destacada (ou seja, carros usados) é o padrão que corresponde a minha regex. A função da regex é filtrar dois conjuntos de strings separados por espaço. RegExp Tester Veja como usar esse filtro para filtrar keywords de cauda longa no Google Analytics. Testando a Regex #2: Ferramenta on-line Regex101.com Regex101.com é uma ferramenta online usada para criar e testar expressões regulares. Confira a interface da ferramenta Regex101: Regex101 usado para procurar com um conjunto de 3 strings separadas por espaço Use o “FLAVOR” como JavaScript, pois o Google Analytics aceita a expressão regular POSIX do JavaScript. Testando a Regex #3: Filtro avançado de relatórios no GA Você pode criar e testar o regex no Google Analytics usando o filtro avançado na interface de relatórios com a opção Regex: Filtro avançado no Google Analytics Testando a Regex #4: pré-visualização do recurso de segmento personalizado no GA Você pode criar e testar sua regex no Google Analytics usando o recurso de visualização em um segmento personalizado: Segmento personalizado no Google Analytics Testando a Regex #5: Janela do console de depuração do GTM Para o GTM, você pode usar a janela do console de depuração para testar o regex usado em gatilhos e variáveis: Ferramenta de teste e depuração do Tag Manager Testando a Regex #6: usando “RegExp” para testar o regex no GTM durante o tempo de execução RegExp é um objeto da expressão regular que é usado para armazenar uma expressão regular em JavaScript. Por exemplo: var regex = /^\/search\/(.*)/; Ou seja: “regex” (usada como uma variável) é um objeto de uma expressão regular que é usado para armazenar a expressão regular /^\/search\/(.*)/. Métodos .test e .exec do objeto RegExp: Tanto .test quanto .exec são os métodos do objeto RegExp e são usados com frequência no Tag Manager (Gerenciador de Tags do Google) para testar expressões regulares usando o tempo de execução. O método .test é usado para testar uma correspondência de uma regex em uma string. Ele retorna um valor booleano: true se encontrar uma correspondência, caso contrário, retorna false. Exemplo: RegExpObject.test (string a ser pesquisada) Por exemplo: function() { var regex = /^\/search\/(.*)/; var pagePath = '/search/enhanced ecommerce tracking/'; if(regex.test(pagePath) { var searchTerm = regex.exec(pagePath)[1]; var NewUri = "/search/?s=" + searchTerm; return NewUri; } return false; } O método exec (como em regex.exec) também testa uma correspondência em uma string. Mas ao contrário de test, ele retorna um array[^array] que contém o texto correspondente, se encontrar a correspondência. [^array]: Array é uma estrutura de dados que armazena uma coleção de elementos de tal forma que cada um dos elementos possa ser identificado por, pelo menos, um índice ou uma chave. Caso contrário, retorna um null. Exemplo: RegExpObject.exec (string a ser pesquisada). O método exec retorna um array de todo o texto correspondente. Então, para a regex: ^\/search\/(.*) // e pagePath = /search/enhanced ecommerce tracking/ regex.exec(pagePath) = [ ‘/search/enhanced ecommerce tracking/’, ‘enhanced ecommerce tracking/’]; regex.exec(pagePath)[0] = [ ‘/search/enhanced ecommerce tracking/’]; regex.exec(pagePath)[1] = [‘enhanced ecommerce tracking/’]; Então é isso! Se você gostou do artigo e achou útil para você, deixe seu comentário abaixo. *************************************************************************************************** Alura > Cursos de Front-end > Cursos de JavaScript > Conteúdos de JavaScript > Primeiras aulas do curso Expressões regulares: capturando textos de forma mágica Expressões regulares: capturando textos de forma mágica Começando com Regex - Começando a aprender Regex com Javascript Download do projeto Você pode fazer o DOWNLOAD completo do projeto inicial aqui. O que é uma Expressão Regular? Uma expressão regular, ou Regex, são padrões utilizados para identificar determinadas combinações ou cadeias de caracteres em uma string. Ela faz parte do dia a dia de todos os programadores e administradores de infra. Por meio dela, podemos validar a entrada de usuários ou encontrar alguma informação em logs, documentação ou saída de comando. O mais legal é que as Regex são escritas independentes de uma linguagem, como JavaScript ou C#. As expressões são definidas em sua própria linguagem formal e uma vez aprendida, podemos aplicar o conhecimento dentro da linguagem de nossa preferência. Em outras palavras, linguagens como Java, JavaScript, C# e várias outras possuem uma implementação das expressões regulares e sabem interpretá-la. Neste curso, vamos focar nessa linguagem formal, mas claro, também mostraremos como executá-la nas plataformas diversas. Onde queremos chegar? Entender, por exemplo, uma Regex assim: <(img)\s+src="(.+)"(?:>(?:.*)<\/\1>|\s+\/>) E saber executá-la utilizando a sua linguagem. No último capítulo desse curso mostraremos como executar uma Regex com Java, C#, PHP, Python, Ruby e JavaScript. Ambiente de execução Para testar as Regex durante o curso, preparamos uma página HTML e um código JavaScript que interpreta a Regex. Você pode baixar o projeto aqui. Basta extrair o ZIP e abrir o arquivo index.html. Ao abrir, podemos ver que a página mostra um formulário para executar e testar as regex. Vamos utilizar esse formulário para analisar as expressões. Repare que já estamos usando um vocabulário focado na Regex. A string que queremos usar na busca, no exemplo da imagem, a string imagem.png é chamada de alvo, ou target. A expressão regular, na imagem .*png, estamos chamando de pattern. Os resultados são os *matches. * Já estamos aplicando a primeira Regex, estamos procurando algum texto que termine com png. O ponto (.) é um caractere especial e significa qualquer caractere. Ou seja, a Regex não interpreta o ponto literalmente e sim faz um match para qualquer *char. * O asterisco (*) é outro meta-char com o significado "zero, um ou mais vezes". Ao adicionar o asterisco (*), conseguimos definir a quantidade, por isso ele também é chamado de quantifier. O ponto (.) e asterisco (*) fazem parte dos metacaracteres que veremos durante o curso. Apresentando o código Qualquer Regex precisa ser interpretada por meio de uma Regex engine. Esse motor é uma parte de software que processa a expressão, tentando achar o padrão dentro da string dada, devolvendo os resultados. Normalmente a Regex engine faz parte da aplicação maior, para executar uma validação ou busca de uma string. No nosso caso, usamos uma Regex engine baseada na linguagem JavaScript. No treinamento, veremos ainda como usar expressões regulares em outras linguagens, como Java, C# ou Ruby. Vamos dar uma olhada na função executaRegex, dentro do arquivo regex.js. Nela criamos o objeto que sabe interpretar a expressão regular. O JavaScript chama esse objeto de RegExp: var objetoRegex = new RegExp(textoPattern, 'g'); No construtor passamos o pattern, aquilo que colocamos no input Pattern da página index.html. A letra g é uma flag do mundo JavaScript e significa global, para aplicar a regex na string inteira (e não parar no primeiro match) . Após a inicialização do objeto regex, podemos executá-lo usando o método exec, que recebe como parâmetro o alvo: while (resultado = objetoRegex.exec(textoTarget)) { //codigo omitido } O método exec devolve um resultado que possui a string match *e outras informações, como a posição/index. *Repare que estamos fazendo um laço sempre pedindo o próximo resultado. O resto do código do arquivo regex.js se preocupa com a leitura, validação e apresentação dos dados. Começando com Regex - O nosso primeiro problema Já vimos um pequeno exemplo de regex e já sabemos que existem metacaracteres (meta-char) que possuem significados especiais, como o ponto (.) ou asterisco (*). No nosso primeiro exemplo para valor, vamos focar no CPF. Uma tarefa muito comum no dia a dia do desenvolvedor é parsear um arquivo linha a linha, onde cada linha representa um dado ou registro. Há vários tipos de arquivos, e nesse curso vamos usar o exemplo de arquivo CSV, ou Comma-separated Values, por exemplo: João Fulano,123.456.789-00,21 de Maio de 1993,(21) 3079-9987,Rua do Ouvidor,50,20040-030,Rio de Janeiro Maria Fulana, 98765432100,11 de Abril de 1995,(11) 933339871,Rua Vergueiro,3185,04101-300,São Paulo denise teste, 987.654.321.00,28 de Dezembro de 1991,(31)45562712,SCS Qd. 8 Bl. B-50,11,70333-900,Rio Grande Então, em cada linha temos vários valores separados pela vírgula, por exemplo: João Fulano,123.456.789-00,21 de Maio de 1093,(21) 3079-9987,Rua Buarque de Macedo,67,22220-232,Rio de Janeiro Encontrando números Repare que o segundo valor é um CPF que precisamos extrair dessa linha. Você conhece um CPF e sabe o padrão de caracteres dele, só falta traduzir o seu conhecimento para a linguagem que a regex engine entende! Um CPF são 9 números, separados em blocos de 3 números por um ponto, mais um hífen e mais dois números. Para representar um número, podemos utilizar uma caracter class, que é um símbolo especial para representar um conjunto de caracteres. No mundo de regex, um número é representado pelo \d. O primeiro quantifier Agora queremos que esse número apareça 3 vezes. Já vimos que o asterisco (*) significa 0, 1 ou mais vezes, ou seja, não atende. Queremos exatamente 3 números que podemos definir pela expressão \d{3}. Dentro das chaves definimos a quantidade que o caractere deve estar presente. Com isso, já podemos encontrar 3 dígitos. Agora vem o "ponto" só que aprendemos que esse caractere possui um significado especial. No entanto queremos procurar o ponto literalmente e não qualquer caractere. Para deixar claro que o ponto deve ser ponto apenas, é preciso escapar o caractere com \. Assim temos: \d{3}\. Sabendo disso podemos definir o resto do CPF: \d{3}\.\d{3}\.\d{3}\-\d{2} Repare que o usamos um hífen seguido por apenas 2 dígitos. Classes de caracteres - Entendendo Classes de Caracteres No último capítulo demos uma introdução às regex e vimos nossa primeira expressão para encontrar um CPF em uma linha de texto. Já criamos uma expressão regular, bastante simples ainda encontrando o CPF: \d{3}\.\d{3}\.\d{3}-\d{2} Olhando novamente no nosso arquivo CSV, percebemos que há uma pequena variação da formatação do CPF: 987.654.321.00 e 11122233300. A nossa regex falha e não "enxerga" esses CPFs. Para fazer ela funcionar, devemos usar o poder das classes de caracteres. Na aula anterior já vimos uma classe predefinida, o \d. Essa classe na verdade é apenas um atalho pra [0-9], ou seja qualquer dígito. Os colchetes definem uma classe de caracteres e nada impede que criemos nossa própria classe. Repare que na décima segunda posição do CPF pode vir um ponto OU hífen, que podemos declarar com a classe: [.-]. Perceba também que não escapamos o ponto (.), pois dentro dos colchetes o ponto já possui o seu valor literal. Importante também é que a ordem não importa, [.-] e [-.] são a mesma coisa. Caracteres opcionais A quantidade de vezes que essa classe de caracteres deve aparecer é definida por um quantifier, por exemplo, como já vimos: [.-]* - ponto ou hífen zero, uma ou mais vezes. [.-]{1} - ponto ou hífen uma vez. No nosso caso [.-] é opcional, pode ter ou não ter, mas uma vez apenas. Dentro da regex, isso é declarado através do meta-char ponto de interrogação (?). O ponto de interrogação (?), que significa zero ou uma vez, é mais um quantifier. Assim podemos combinar a classe [.-] com o quantifier ?: [.-]?- ponto ou hífen zero ou uma vez. Vamos aplicar isso na nossa regex: \d{3}[.-]?\d{3}[.-]?\d{3}[.-]?\d{2} Agora sim, os CPFs serão encontrados com ou sem hífen/ponto. Sabendo disso até podemos reescrever a classe \d (sim \d também é uma classe, já predefinida). Invés de usar \d podemos escrever: [0123456789] Ou mais curto: [0-9] Só cuidado, o hífen não possui um significado especial e define todos os números de 0 até 9. Sobre o curso Expressões regulares: capturando textos de forma mágica O curso Expressões regulares: capturando textos de forma mágica possui 134 minutos de vídeos, em um total de 81 atividades. Gostou? Conheça nossos outros cursos de JavaScript em Front-end, ou leia nossos artigos de Front-end. Matricule-se e comece a estudar com a gente hoje! Conheça outros tópicos abordados durante o curso: Começando com Expressões regulares Classes de caracteres Encontrando a posição certa com âncoras Trabalhando com grupos O que são grupos? Ganancioso ou preguiçoso Usando regex nas diversas linguagens Aprenda JavaScript acessando integralmente esse e outros cursos, comece hoje! ************************************************************************************** Expressões Regulares « Previous Next » Expressões regulares são padrões utilizados para selecionar combinações de caracteres em uma string. Em JavaScript, expressões regulares também são objetos. Elas podem ser utilizadas com os métodos exec e test do objeto RegExp, e com os métodos match, replace, search, e split do objeto String. Este capítulo descreve o uso de expressões regulares em JavaScript. Criando uma Expressão Regular Há duas maneiras de construir uma expressão regular: Usando uma expressão literal, que consiste em um padrão fechado entre barras, como o exemplo a seguir: const re = /ab+c/; As expressões regulares na forma literal são compiladas quando o script é carregado. Esta forma de construção possui melhor performace quando a expressão regular utilizada é uma constante, ou seja, não muda durante a execução. Ou chamando o construtor do objeto RegExp: let re = new RegExp("ab+c"); Usando o construtor, a compilação da expressão regular é realizada em tempo de execução. Use o construtor quando souber que o padrão da expressão regular irá mudar ou quando o padrão for desconhecido, oriundo de outra fonte, uma entrada de usuário por exemplo. Nota: Se você já está familiarizado com as formas de uma expressão regular, também pode ler o resumo para uma rápida pesquisa de um padrão específico. Escrevendo um padrão de expressão regular Um padrão de expressão é composto por um conjunto de caracteres simples, como /abc/, ou uma combinação de caracteres simples e especiais, como /ab*c/ ou /Capitulo (\d+)\.\d*/. O último exemplo contém parênteses, que são usados como um mecanismo de armazenamento. A correspondência feita por essa parte da expressão é armazenada para uso posterior, como descrito em: Using Parenthesized Substring Matches. Uso de Padrões Simples Padrões simples são construídos utilizando os caracteres que você deseja encontrar correspondências diretas. Por exemplo, o padrão /abc/ encontra combinações de caracteres em strings apenas quando os caracteres 'abc' forem encontrados juntos e na ordem especificada. Esse padrão será encontrado com sucesso nas strings "Olá, você conhece o abc?" e "Os mais recentes aviões evoluíram do slabcraft.". Em ambos os casos, a correspondência estará no subconjunto 'abc'. Porém, o padrão não será encontrado no texto "Grab crab" pois apesar de conter os mesmos caractes do padrão 'ab c', estes não aparecem na ordem especificada. Uso dos Caracteres Especiais Quando for necessário buscar algo além de uma correspondência direta, como encontrar uma ou mais ocorrências da letra 'b', ou encontrar espaços em branco, será necessário adicionar caracteres especiais ao padrão. Por exemplo, para encontrar uma única correspondência de 'a' seguido de nenhum ou mais 'b's seguido de 'c', o padrão a utilizar seria /ab*c/. O caractere * seleciona zero ou mais ocorrências do item que o precede. Se aplicada ao texto 'cbbabbbbcdebc', essa expressão regular encontraria o subconjunto grifado no texto. A tabela abaixo fornece uma lista completa dos caracteres especiais que podem ser utilizados nas expressões regulares, com sua respectiva descrição. Para testar os exemplos de expressão regular você pode usar o regExr. Caracteres especiais utilizados em expressões regulares. Caractere Descrição \ Aplicado conforme as seguintes regras: Uma barra invertida que preceda um caractere não especial significa que o caractere seguinte é especial e não deve ser interpretado de forma literal. Por exemplo, o caractere 'b' quando não precedido de uma barra invertida significará uma ocorrência do próprio caractere 'b' minúsculo, porém se precedido da barra invertida '\b' ele passará a significar a ocorrência do caractere especial fronteira do caractere. Quando a barra invertida preceder um caractere especial isso significará que o próximo caractere deve ser interpretado de forma literal. Por exemplo o padrão /a*/, que selecionará a ocorrência de zero ou mais caracteres 'a' quando utilizado sem a \ para escape. Por outro lado no padrão /a\*/ o asterisco deixa de ter seu significado especial, pois a '\' de escape fará com que o '*' seja interpretado de forma literal, passando o padrão a selecionar o caractere 'a' seguido do caractere '*'. Quando utilizar o construtor RegExp("padrao"), não se esqueça de fazer o escape do caractere \, já que esse caractere é também utilizado como caractere de escape em strings. ^ Corresponde ao início do texto. Se a flag multilinhas é setada para true, também se aplica imediatamente após um caractere de quebra de linha. Por exemplo, /^A/ não corresponde ao 'A' em "Um Alvo", mas corresponde ao 'A' em "Alvo Encontrado". Este caractere tem um significado diferente quando aparece como o primeiro caractere em um conjunto padrão de caracteres. Veja conjunto de caracteres negados ou complementados para detalhes e mais exemplos. $ Corresponde ao final do texto. Se a flag multilinhas é setada para true, também se aplica imediatamente antes de um caractere de quebra de linha. Por exemplo, /r$/ não corresponde ao 'r' em "corre", mas acha correspondência em "correr". * Corresponde a expressão que o precede repetida 0 ou mais vezes. Equivalente a {0,} Por exemplo, /bo*/ acha uma correspondência para 'boooo' em "Scoob doo" e 'b' em "A bird warbled", mas nenhuma em "A goat grunted". + Corresponde a expressão que o precede repetido 1 ou mais vezes. Equivalente a {1,}. Por exemplo, /a+/ acha correspondência para o 'a' em "candy" e todos os "as" em "caaaaaaandy", mas nâo encontra em "cndy". ? Corresponde a expressão que o precede repetido 0 ou 1 vez. Equivalente à {0,1}. Por exemplo, /e?le?/ encontra o 'el' em "angel" e o 'le' em "angle" e também o 'l' em "oslo". Se usado imediatamente após qualquer um dos quantificadores *, +, ? ou {}, faz o quantificador não guloso (combinando o número mínimo de vezes), como um oposto para o padrão que é guloso (combinar o número máximo possível). Por exemplo, aplicando /\d+/ em "123abc" encontra "123". Mas aplicando /\d+?/, apenas "1" será encontrado. Também usado em declarações lookahead, descritas sob x(?=y) e x(?!y)logo abaixo na tabela. . (O ponto decimal) corresponde com qualquer caracter, exceto o caracter de nova linha. Por exemplo, /.n/ acha correspondência para o 'an' e 'on' em "nove dias restantes para onze de agosto.", mas não encontra 'no' em 'nove'. (x) Pesquisa correspondência com o caractere 'x' e memoriza-o, como a o exemplo a seguir mostra. Os parênteses são chamados parênteses de captura. Por exemplo, o '(foo)' e '(bar)' no padrão /(foo) (bar) \1 \2/ encontra e memoriza a primeira das duas palavras na string "foo bar foo bar". O \1 e \2 no padrão combina as duas últimas palavras da string. Note que \1, \2, \n são utilizados na parte correspondente do regex. (?:x) Pesquisa correspondência com o caractere 'x' porém não o memoriza. Os parênteses são chamados de parênteses de não-captura e permitem que você defina uma subexpressão para operadores de expressão regular trabalhar com eles. Considere essa expressão de exemplo /(?:foo){1,2}/. Se a expressão era /foo{1,2}/, o {1,2} poderia ser aplicado apenas para o último 'o' em 'foo'. Com os parênteses de não-captura, o {1,2} é aplicado para toda a palavra 'foo'. x(?=y) Pesquisa correspondência em 'x' apenas se 'x' é seguido por 'y'. Isso é chamado de lookahead. Por exemplo, /Jack(?=Sprat)/ busca 'Jack' apenas se é seguido por 'Sprat'. /Jack(?=Sprat|Frost)/ busca 'Jack' apenas se ele é seguido por 'Sprat' ou 'Frost'. No entanto, 'Sprat' nem 'Frost' faz parte do resultado retornado. x(?!y) Pesquisa correspondência em 'x' apenas se 'x' não é seguido por 'y'. Isso é chamado negação lookahead. Por exemplo, /\d+(?!\.)/ encontra um número apenas se ele não for seguido por um ponto decimal. A expressão regular /\d+(?!\.)/.exec("3.141") encontra '141' mas não '3.141'. x|y Pesquisa correspondência em 'x' ou 'y'. Por exemplo, /verde|vermelha/ encontra 'verde' em "maçã verde" e 'vermelha' em "maçã vermelha." {n} Pesquisa n ocorrências correspondentes ao caracter precedido. Onde, n deve ser um inteiro positivo. Por exemplo, /a{2}/ não encontra o 'a' em "candy," mas encontra-o se houver a quantidade de a's informarda em "caandy," e os dois primeiros a's em "caaandy." {n,m} Pesquisa a n menor correspondência e a m maior correspondência do caractere precedido. Quando n ou m é zero, ele poderá ser omitido. Onde, n e m devem ser inteiros positivo. Por exemplo, /a{1,3}/ não encontra nada em "cndy", mas encontra o 'a' em "candy", encontra os dois primeiros a's em "caandy," e encontra os três primeiros a's em "caaaaaaandy". Observe que, ao fazer a correspondência de "caaaaaaandy", serão encontrados apenas os "aaa", mesmo que a string tenha mais a's. [xyz] Um conjunto de caracteres. Pesquisa correspondência para qualquer um dos caracteres entre colchetes. Você pode especificar um intervalo de caracteres usando hífen. Caracteres especiais (como o ponto (.) e o asterisco(*)) não tem significado algum quando está dentro de um conjunto de caracteres. Não necessita utilizar escape neles. Mas, se utilizar escape também irá funcionar. Por exemplo, [abcd] é o mesmo que [a-d]. Com a expressão será encontrado o 'b' em "beijo" e o 'c' em "chop". A expressão /[a-z.]+/ e /[\w.]+/ ambos encontraram as letras que formam "test.i.ng". [^xyz] Um conjunto de caracteres negados ou complementados. Isto é, combina com qualquer coisa que não esteja listado entre os colchetes. Você pode especificar um intervalo de caracteres usando hífen. Tudo que funciona no conjunto de caracteres (apresentado acima) também funciona aqui. Por exemplo, [^abc] é o mesmo que [^a-c]. Com a expressão será encontrado inicialmente 'e' em "beijo" e 'h' em "chop." [\b] Pesquisa correspondência com espaço em branco (U+0008). É preciso utilizar os colchetes se você quer encontrar um espaço em branco. (Não confunda-o com \b.) \b Pesquisa correspondência em uma fronteira de caractere. Uma fronteira de caractere corresponde a posição onde um caractere/palavra não é seguido ou antecedido por outro caractere/palavra. Isto é, em fronteira de caractere não pode haver nenhum caractere ou espaço, seu tamanho deve ser vazio. (não confunda-o com [\b].) Exemplos: /\bmoo/ encontra a substring 'moo' em "moon" ; /oo\b/ não encontra o 'oo' em "moon", devido o 'oo' ser seguido por 'n' que é um caractere; /oon\b/ encontra a substring 'oon' em "moon", devido 'oon' ser o fim da string, ou seja, não é seguido por nenhum caractere; /\w\b\w/ não encontrará nada, pois o caractere nunca será seguido por um não caractere e um caractere. Nota: O mecanismo de expressão regular no JavaScript define um conjunto específico de caracteres para serem caracteres "palavras". Qualquer caractere que não esteja neste conjunto é considerado uma quebra de palavra. Este conjunto de caractere é bastante limitado: consiste apenas no alfabeto romano tanto maiúsculo como minúsculo, digítos decimais, e o caractere sublinhado. Caracteres acentuados, tal como "é" ou "ã" são, infelizmente, tratados como palavras quebradas. \B Pesquisa correspondência que não seja em uma fronteira de caractere. Para a correspondência é associada uma posição onde o caractere anterior e o próximo tem as mesmas características: ambos são caractere/palavra, ou ambos não sejam caractere/palavra. O início e o fim de uma string não considerados como não caractere/palavra. Por exemplo, /\B../ encontra correspondente 'oo' em "boolean", e /y\B./ encontra correspondente 'ye' em "possibly yesterday." \cX Onde X é um caractere pertencente ao conjunto A-Z. Encontra correspondência de um caractere de controle em uma string. Por exemplo, /\cM/ encontra correspondente control-M (U+000D) em uma string. \d Encontra correspondência com um número. Equivalente a [0-9]. Por exemplo, /\d/ ou /[0-9]/ encontra correspondente '8' em "Dróide BB8". \D Encontra correspondência com um caractere que não seja número. Equivalente a [^0-9]. Por exemplo, /\D/ ou /[^0-9]/ econtra correspondente 'C' em "C3 está ativada." \f Encontra correspondência com um caractere de escape avanço de página (U+000C). \n Encontra correspondência com um caractere de escape quebra de linha (U+000A). \r Encontra correspondência com um caractere de escape retorno de carro (U+000D). \s Encontra correspondência com um único caractere de espaço em branco, espaço, tabulação, avanço de página, quebra de linha. Equivalente a [ \f\n\r\t\v​\u00A0\u1680​\u180e\u2000​\u2001\u2002​\u2003\u2004​\u2005\u2006​\u2007\u2008​\u2009\u200a​\u2028\u2029​\u2028\u2029​\u202f\u205f​\u3000]. Por exemplo, /\s\w*/ encontra correspondente ' bar' em "foo bar." \S Encontra correspondência em um único caractere que não seja espaço em branco. Equivalente a [^ \f\n\r\t\v​\u00A0\u1680​\u180e\u2000​\u2001\u2002​\u2003\u2004​\u2005\u2006​\u2007\u2008​\u2009\u200a​\u2028\u2029​\u2028\u2029​\u202f\u205f​\u3000]. Por exemplo, /\S\w*/ encontra correspondente 'foo' em "foo bar." \t Encontra correspondência em uma tabulação (U+0009). \v Encontra correspondência em uma tabulação vertical (U+000B). \w Encontra correspondência de qualquer caractere alfanumérico incluindo underline. Equivalente a [A-Za-z0-9_]. Por exemplo, /\w/ encontra correspondente 'a' em "apple," '5' em "$5.28," e '3' em "3D." \W Encontra correspondência em um não caractere. Equivalente a [^A-Za-z0-9_]. Por exemplo, /\W/ ou /[^A-Za-z0-9_]/ encontra correspondente '%' em "50%." \num Onde num é um inteiro positivo. Faz referência a substring pertencente à um grupo, um grupo é definido entre parênteses. Grupos são numerados de 1 até 9. Por exemplo, /(muito) (cacique) pra \2 \1/ encontra 'muito cacique pra cacique muito' em 'Na aldeia tem muito cacique pra cacique muito.' \0 Encontra correspondência em um caractere NULL (U+0000). Não adicione outro número após o zero, pois \0 é um escape para número octal. \xhh Encontra correspondência com o código hh (dois valores hexadecimal). \uhhhh Encontra correspondência com o código hhh (três valores hexadecimal). \u{hhhh} (funciona apenas com a flag u) Encontra correspondência com o valor Unicode hhhh (dígitos hexadecimais). Usando Parênteses Usar parênteses em volta de qualquer parte de uma expressão regular faz com que essa parte seja lembrada para ser usada depois, como descrito em Usando as Substrings entre Parênteses na Expressão Regular. Por Exemplo, a expressão /Capitulo (\d+)\.\d*/ ilustra caracteres adicionais escapados e especiais e indica que parte do padrão deve ser lembrado. Corresponde precisamente aos caracteres 'Capitulo ' seguidos por um ou mais caracteres numéricos (\d significa qualquer caracter numérico e + significa 1 ou mais vezes), seguidos por um ponto decimal (que é um caracter especial; preceder com um \ significa que a expressão regular deve buscar pelo caracter literal '.'), seguido por qualquer caracter numérico 0 ou mais vezes (\d significa caracter numérico, * significa 0 ou mais vezes). Além disso, os parenteses são usados para relembrar os primeiros caracteres numéricos correspondentes. Esse padrão é encontrado em "Abra o capitulo 4.3, parágrafo 6" o '4' é relembrado. O padrão não é encontrado em "Capitulo 3 e 4", porque essa string não tem um período após o '3'. Para encontrar uma substring sem que a correspondência seja relembrada, dentro dos parênteses inicie o padrão com ?:. Por exemplo, (?:\d+) corresponde a um ou mais caracteres numéricos mas não relembra os caracteres correspondentes. Trabalhando com expressões regulares Expressões Regulares são usadas com os metodos test e exec do objeto RegExp e com os metodos match, replace, search, e split do objeto String. Estes metodos são explicados em detalhe em JavaScript Reference. Tabela 4.2 Metodos que usam Expressões regulares Metodo Descrição exec Um método RegExp que execute uma pesquisa por uma correspondência em uma string. Retorna um array de informações. test Um método RegExp que testa uma correspondência em uma string. Retorna true ou false. match Um método String que executa uma pesquisa por uma correspondência em uma string. Retorna uma array de informações ou null caso não haja uma correspondência. search Um método String que testa uma correspondência em uma string. Retorna o indice da correspondência ou -1 se o teste falhar. replace Um método String que executa uma pesquisa por uma correspondência em uma string, e substitui a substring correspondênte por uma substring de substituição. split Um método String que usa uma expressão regular ou uma string fixa para quebrar uma string dentro de um array de substrings. Quando você quer saber se um padrão é encontrado em uma string, use o método test ou search; para mais informações (mas execução mais lenta) use o método exec ou match. Se você usar exec ou match e se houver correspondência, estes métodos retornam um array e atualizam as propriedades do objeto da expressão regular associada e também do objeto da expressão regular predfinada RegExp. Se não houver corespondência, o método exec retorna null (convertido para false). No seguinte exemplo, o script usa o método exec para encontrar uma correspondência em uma string. var myRe = /d(b+)d/g; var myArray = myRe.exec("cdbbdbsbz"); Se você não precisa acessar as propriedades da expressão regular, uma alternativa de criar myArray é com esse script: var myArray = /d(b+)d/g.exec("cdbbdbsbz"); Se você quiser construir a expressão regular a partir de uma string, outra alternativa é esse script: var myRe = new RegExp("d(b+)d", "g"); var myArray = myRe.exec("cdbbdbsbz"); Com esses scripts, a correspondência é encontrada o array é retornado e são atualizadas as propriedades mostradas na tabela a seguir. Table 4.3 Resultados da execução de expressões regulares. Objeto Propriedade or indice Descrição Nesse exemplo myArray A string correspondente e todas as substrings relembradas. ["dbbd", "bb"] index O índice do encontro em relação à string original. 1 input A string original. "cdbbdbsbz" [0] Os últimos caracteres encontrados. "dbbd" myRe lastIndex O índice no qual iniciar a próxima partida. (Esta propriedade é configurada apenas se a expressão regular usar a opção g, descrita em Advanced Searching With Flags.) 5 source O texto da expressão regular. Atualizado quando a expressão é criada, não executada. "d(b+)d" Como mostrado na segunda forma deste exemplo, você pode usar uma expressão regular criada com um inicializador de objeto sem atribuí-la à uma variável. Contudo, se você o fizer, toda ocorrência é uma nova expressão regular. Assim sendo, se você usar esta forma sem atribuí-la à uma variável, você não pode subsequentemente acessar as propriedades da expressão regular. Assumamos que tenha este script, por exemplo: var myRe = /d(b+)d/g; var myArray = myRe.exec("cdbbdbsbz"); console.log("O útltimo índice é " + myRe.lastIndex); Este script mostra: O último índice é 5 Contudo, se tem este script: var myArray = /d(b+)d/g.exec("cdbbdbsbz"); console.log("O último índice é " + /d(b+)d/g.lastIndex); Ele mostra: O último índice é 0 As ocorrências de /d(b+)d/g nas duas declarações são objetos expressões regulares diferentes e consequentemente têm diferentes valores para suas propriedades lastIndex. Se precisa acessar as propriedades de uma expressão regular criada com um inicializaor de objeto, você deve primeiro atribuí-la à uma variável. Usando as Substrings entre Parênteses na Expressão Regular A inclusão de parênteses em um padrão de expressão regular faz com que a sub-correspondência correspondente seja lembrada. Por exemplo, /a(b)c/ corresponde aos caracteres 'abc' e lembra 'b'. Para recuperar essas correspondências de substring entre parênteses, use o Arra[1], ..., [n]. O número de substring entre parênteses possíveis é ilimitado. A matriz retornada contém tudo o que foi encontrado. Os exemplos a seguir ilustram como usar parênteses entre parênteses. Exemplo 1 O script a seguir usa o método replace() para alternar as palavras na string. Para o texto de substituição, o script usa o $1 e $2 na substituição para indicar a primeira e a segunda correspondências de substring entre parênteses. var re = /(\w+)\s(\w+)/; var str = "John Smith"; var newstr = str.replace(re, "$2, $1"); console.log(newstr); Isto imprime "Smith, John". Pesquisa avançada com Flags As expressões regulares possuem quatro flags opcionais as quais se incluem a pesquisa global e case insensitive. Para realizar uma pesquisa global, utilize a flag g. Para realizar uma pesquisa sem diferenciar letras maiúsculas de minúsculas, utilize a flag i. Para realizar uma pesquisa multi-linhas, utilize a flag m. Ao realizar uma pesquisa "sticky", o ponto de partida será a posição corrente da string alvo, use com a flag y.Estas flags podem ser usadas separadamente ou juntas, em qualquer ordem, e serão inclusas como parte da expressão regular. Firefox 3 note: Suporte para o sinalizador y foi adicionado no Firefox 3. O sinalizador y falha se a correspondência não for bem-sucedida na posição atual na cadeia de destino. Para incluir um sinalizador com a expressão regular, use esta sintaxe: var re = /pattern/flags; ou var re = new RegExp("pattern", "flags"); Observe que os sinalizadores são parte integrante de uma expressão regular. Eles não podem ser adicionados ou removidos posteriormente. Por exemplo, re = /\w+\s/g cria uma expressão regular que procura um ou mais caracteres seguidos por um espaço e procura essa combinação em toda a cadeia. var re = /\w+\s/g; var str = "fee fi fo fum"; var myArray = str.match(re); console.log(myArray); Isso exibe ["fee ", "fi ", "fo "]. Neste exemplo, você pode substituir a linha var re = /\w+\s/g; por: var re = new RegExp("\\w+\\s", "g"); e obtenha o mesmo resultado. O sinalizador m é usado para especificar que uma sequência de entrada de múltiplas linhas deve ser tratada como várias linhas. Se o sinalizador m for usado, ^ e $ combinam no início ou no final de qualquer linha na sequência de entrada, em vez do início ou no final de toda a sequência. Exemplos Os exemplos que se seguem mostram mais usos expressões regulares. Alterando o pedido em uma string de entrada O exemplo a seguir ilustra a formação de expressões regulares e o uso de string.split() e string.replace(). Ela limpa uma string de entrada formatada com nomes (primeiro nome sobrenome) separados por espaço em branco, tabulações e exatamente um ponto e virgula. Por fim, inverte a ordem do nome (sobrenome e primeiro nome) e ordena a lista // A cadeia de nomes contém vários espaços e guias, // e pode ter vários espaços entre o nome e o sobrenome. var names = "Harry Trump ;Fred Barney; Helen Rigby ; Bill Abel ; Chris Hand "; var output = ["---------- String original\n", names + "\n"]; // Prepare dois padrões de expressão regular e armazenamento em array. // Divide a string em elementos da matriz. // pattern: possível espaço em branco, em seguida, ponto e vírgula, em seguida, possível espaço em branco var pattern = /\s*;\s*/; // Quebra string em pedaços separados pelo padrão acima e // armazene as partes em uma matriz chamada nameList var nameList = names.split(pattern); // new pattern: um ou mais caracteres, espaços e caracteres. // Use parênteses para "memorizar" partes do padrão. // As partes memorizadas são referenciadas mais tarde. pattern = /(\w+)\s+(\w+)/; // Nova matriz para armazenar nomes sendo processados. var bySurnameList = []; // Exibe a matriz de nomes e preenche a nova matriz // com nomes separados por vírgula, último primeiro. // // O método replace remove qualquer coisa que corresponda ao padrão // e substitui-o pela sequência memorizada - segunda parte memorizada // seguido por espaço de vírgula seguido pela primeira parte memorizada. // // As variáveis ​​$ 1 e $ 2 se referem às partes // memorizado enquanto corresponde ao padrão. output.push("---------- Após Separar pela Expressão Regular"); var i, len; for (i = 0, len = nameList.length; i < len; i++){ output.push(nameList[i]); bySurnameList[i] = nameList[i].replace(pattern, "$2, $1"); } // Exibe a nova matriz. output.push("---------- Nomes Invertidos"); for (i = 0, len = bySurnameList.length; i < len; i++){ output.push(bySurnameList[i]); } // Classifica pelo sobrenome e exibe a matriz classificada. bySurnameList.sort(); output.push("---------- Ordenado"); for (i = 0, len = bySurnameList.length; i < len; i++){ output.push(bySurnameList[i]); } output.push("---------- Fim"); console.log(output.join("\n")); Usando caracteres especiais para verificar entradas No exemplo a seguir, é esperado que o usuário informe um número de telefone. Quando o usuário pressionar o botão "Check", o script verificará a validade do número. Se o número for válido (a sequência de caracteres especificada corresponderá a expressão regular), então, o script exibe uma mensagem agradecendo o usuário e confirmando o seu número. Se o número for inválido, o script informa ao usuário que o número de telefone não é válido. A expressão regular procura por zero ou uma ocorrência de parênteses de abertura \(?, seguido de três dígitos \d{3}, seguido de zero ou uma ocorrência de parênteses de fechamento \)?, seguido de um hífen, barra ou ponto decimal e, quando encontrado, guarda o caractere ([-\/\.]), seguido de três dígitos \d{3}, seguido por um caractere de hífen, barra ou ponto decimal que fora guardado \1, seguido por quatro dígitos \d{4}. Com o evento Change ativo, quando o usuário pressionar Enter, o valor será capturado por RegExp.input.

Informe o seu número de telefone (com código de área) e então clique em "Check".
O formato esperado é ###-###-####.

Check

« Previous Next » Found a problem with this page? Edit on GitHub Source on GitHub Report a problem with this content on GitHub Want to fix the problem yourself? See our Contribution guide. Last modified: 22 de fev. de 2022, by MDN contributors ****************************************************************************************** rição 0:00 e não das Ferramentas mais antigas só 0:02 que muito poderosas para fazer 0:03 processamento de texto é o regex ou 0:06 regular Expression através dela você 0:08 consegue fazer detecção de padrões como 0:10 CPF e número de telefone nome de 0:12 usuários através de códigos como esse 0:15 daqui que parecem ser bem confusos 0:17 começaram para ele mas aprendendo tudo 0:18 que eu vou achar aqui nesse vídeo você 0:20 vai saber utilizar essa ferramenta Super 0:21 Poderosa que até pode ser utilizada em 0:23 conjunto com outras técnicas avançadas 0:25 com o nlp pnl e até imagino a sorriso 0:28 conversar contigo hoje falava não é que 0:30 o bairro eu sou engenheiro de sócio e 0:31 Chef bota de volta porque está aqui para 0:33 te ajudar que era soluções com 0:34 tecnologia e no vídeo de hoje eu vou 0:36 utilizar como essa ferramenta que é 0:37 super importante Então uso passar no 0:39 linguagem natural que é o e Jackson o 0:41 Brasil Express através dela a gente vai 0:43 conseguir resolver alguns desafios que 0:45 vão estar aqui nesse vídeo resolvendo o 0:47 caso e reagir é que são padrões mas 0:49 detectar nome de usuários e CPF visuais 0:52 utilizando Esses códigos que parece ser 0:54 bem complicado mas na verdade são muito 0:56 fácil para a gente entender se você 0:57 gosta de vídeos como esse sobre 0:59 tecnologia 1:00 em Osasco tecnologia para resolver 1:01 problemas Reais dá uma olhada aqui nos 1:03 outros que tem no canal e coceira que se 1:05 inscrever também porque esse vídeo deu 1:07 muito trabalho e isso aí dá um super 1:08 apoio para continuar fazendo vídeos como 1:10 esse daqui mas sem mais delongas vamos 1:12 embora a primeira coisa que a gente vai 1:13 fazer é abrir esse site daqui que é 1:15 muito legal ele é o e já que ser ele é 1:18 muito bom para gente poder brincar com 1:19 rigex e ver como é que tudo funciona E 1:22 aí para ele se ele coloque um texto 1:23 exemplo aí o Jeca exemplo no caso esse 1:25 Jackson aqui tá detectando palavras que 1:27 começa com a letra maiúscula né que você 1:29 pode vir aqui Jackson ser mídia tempo 1:31 tudo começa com letra maiúscula mas 1:32 talvez você ainda não esteja entendendo 1:34 ainda o que é que esse código aqui faz 1:35 então vamos entender tudo foi limpar que 1:37 esse código eu vou trocar esse texto 1:40 aqui embaixo para esse exemplo daqui eu 1:43 queria que tem aqui é um campo de texto 1:45 né com diversos nomes de pessoas de 1:47 usuários não tem Gilberto Reis Juliete 1:50 da Silva e Camila Correia e embaixo tem 1:52 CPF que são desses usuários entre a 1:55 primeira conectar o nome dele Certo 1:57 Então daquele detectar o nome da 2:00 Oi gente vai querer aquele junto tanto o 2:02 nome quanto sobrenome beleza como é que 2:04 a gente pode fazer isso vou mexer aqui 2:06 na parte da escrever assim Jackson a 2:09 escrever Nossa expressão e a gente pode 2:11 por exemplo se ele vai aqui diretamente 2:12 Gilberto aí tem procurando aqui então 2:15 por uma palavra literal a gente quer 2:17 encontrar ramente os textos que como 2:18 fazer aqui embaixo começa com g e depois 2:21 bakonyi depois o Wellington E aí que 2:23 está fazendo aqui aí eles também te 2:25 procurando pela palavra Gilberto Então 2:26 as ver que só tá encontrar essa parte 2:28 daqui mais né nosso caso a gente quer 2:30 contar também Juliet quer encontrar a 2:32 Camila como é que a gente pode fazer 2:34 isso e é a primeira coisa que eu vou te 2:35 mostrar e como encontrar um grupo de 2:37 caracteres ou seja um grupo de qualquer 2:39 caractere qualquer letra símbolo que 2:41 esteja definido aqui e parece só colocar 2:43 esses dois buracos aqui essas duas 2:46 características do tocando aqui que já 2:48 vai definir aqui embaixo um grupo de 2:49 caracteres e eu tenho colocar aqui 2:51 dentro e vai encontrar com um presente 2:52 só botar aqui no G ele vai encontrar 2:54 qualquer caractere G ele vai encontrar 2:55 com ficar RJ qualquer até cedo mas ele 2:58 pra gente conseguir encontrar qualquer 3:00 é né eu posso trocar a química para ser 3:02 entre a i z eu botei aqui entre a Easy 3:05 maiúsculo Então vai encontrar qualquer 3:07 letra que esteja entre as eu seja 3:10 qualquer uma e que seja maiúsculo caso 3:13 eu quero encontrar as minúsculas eu 3:15 posso trocar esse aqui ó tá entre as Z 3:17 aí ele encontrou todos os caracteres 3:19 aqui que estão em minúsculo e para 3:22 encontrar qualquer um maiúsculo e 3:23 minúsculo É só colocar esse aqui a a z 3:26 certo a maiúsculas e minúsculas e ele 3:29 vai pegar qualquer um deles agora a 3:31 gente fala aqui para ver cada um desses 3:34 caracteres aqui tá sendo um mete eu não 3:37 quero que a letra seja o quem tá 3:39 querendo procurar né a gente vai 3:40 encontrar realmente o nome do nosso 3:42 usuário então para isso eu vou colocar 3:44 aqui um mais o mais quer dizer que eu 3:46 preciso encontrar um ou mais instâncias 3:49 dessas caracteres aqui então aqui tá 3:52 vendo aqui o Gilberto todo virou mete o 3:55 a raiz toda virou um mete então Através 3:57 disso aqui é que eu consegui conectar né 4:00 em todas as letras e formar a nossa 4:02 palavra com esse a até Z e o mais aqui 4:04 no canal agora para conectar esse 4:07 Gilberto com um arranjo como é que não 4:09 vai fazer eu vou pegar aqui ó tem que 4:12 colocar um barra s no final o barra é 4:14 esse é o caractere de espaço Então vai 4:17 ser um grupo aqui é de letras né seguido 4:20 de um espaço e tá aqui então Gilberto 4:22 aqui gente tem um arraso Juliete da 4:25 Silva Sérgio Então tá pegando agora os 4:27 espaços e agora o que eu vou fazer é 4:30 pegar todas as vezes que isso aqui se 4:31 repete então fazer aqui um outro grupo e 4:34 aí para pegar esse grupo aqui todo vou 4:36 botar o parênteses eu posso botar um 4:38 mais aqui agora e ver que ele está agora 4:41 conectando todas as palavras porque aqui 4:45 a gente tá pegando somente um caso e 4:47 correto bota aqui o mais ele pega um ou 4:50 mais casos daquele nosso grupo então 4:52 agora tá querendo pegar o Gilberto a 4:54 raiz que é o nosso nome a Juliete da 4:56 Silva e a Camila Correia arretada então 4:59 a gente conseguiu 5:00 vou pegar o nome do nosso usuário usar 5:02 esse código aqui enrigex que parece 5:05 Complicado quando você olha mas agora 5:06 você entende que cada uma dessas 30 que 5:08 fazem agora então para o nosso segundo 5:10 desafio quer pegar o CPF Desse pessoal 5:13 então novamente né você pode pegar aqui 5:15 por exemplo 14 e aí tá pegando os 5:18 literais mas o que vou fazer é pegar 5:21 aqui qualquer número a gente pode fazer 5:23 novamente aqui um grupo de captura entre 5:26 0 e 9 por exemplo e ele pegou aqui cada 5:28 um dos nossos números então qualquer 5:30 caractere entre 0 e 9 e o que posso 5:34 fazer aqui por exemplo é colocar o mais 5:35 né aí tarde para pegar aqui os grupos 5:38 mas eu não posso deixar que seja 5:40 qualquer quantidade de números porque eu 5:41 quero que seja realmente tem o formato 5:42 de um CPF então por exemplo se eu fizer 5:44 aqui um certo isso aqui não é um CPF 5:50 porque porque tem muito mais número do 5:52 que devia ter o CPF mãe sabe né então 5:55 três números seguidos mais 3 número 5:57 depois mais três depois 2 6:00 e pode ter ou não esse pontinho aqui no 6:02 meio Pois também pode ter o dígito no 6:04 final fiz uma quem preciso provê-lo de 6:06 Juliet Ele só não temos pontinhas né mas 6:09 tem o dito EA da Camila não tem nem o 6:12 dígito certo mas não quer verificar 6:13 qualquer forma do usuário digitar esse 6:16 CPF Então o que eu posso fazer aqui ó em 6:19 vez de colocar esse mais eu vou definir 6:22 que eu quero que somente três números 6:24 Então em vez de botar o mais que é um ou 6:27 mais e aqui passei qualquer quantidade 6:29 eu tô botando aqui para ser só três 6:31 grupos emprestam um 41336 é outro 44 é 6:35 outro o 19 já não é porque não são três 6:38 números e era uma coisa que na julliard 6:40 ó um 43444 E aí de novo é o 19 aqui não 6:45 pega e aquele pegou também todos os 6:47 grupos Então bora tentar conectar esse 6:50 14 com o 333 para tentar juntar todos 6:53 CPF né para esse cliente ficar o 6:56 caractere do ponto é só botar o barra 6:58 aqui ao contrário 7:00 e quem vai pegar o caracter do ponto 7:02 para pegou aqui 14 pontos e pegou aqui o 7:04 33 pontos mas ver que ele tá mais 7:07 pegando nenhum daqui de baixo porque 7:08 eles não tem o ponto Então como é que eu 7:10 faço para que esse ponto seja opcional 7:12 ele pode existir ou não é só botar 7:14 interrogação aqui então agora e pega o 7:17 grupo né com três números seguidos ou 7:20 não de um ponto então aqui o 444 não tem 7:22 ponto ele detecta mesmo assim então bora 7:25 de novo a gente vai precisar vou copiar 7:27 aqui mesmo de outro grupo de três 7:30 números seguidos ou não de um ponto 7:32 então agora a gente vê que já tá 7:33 conectando mais aqui o nosso CPF Bora 7:36 mais uma vez Então eu comer aqui 0 a 9 7:40 certo e também agora vai ser três vezes 7:42 ele e a gente tá quase terminando agora 7:45 não precisa aqui nesse tracinho e tá só 7:48 botar aqui ó o traço e agora eu ver que 7:50 conectou aqui em cima mas aqui embaixo 7:53 não porque o traço ele é opcional e 7:56 agora mais dois números entre 0 e 9 8:00 Oi e a gente vai querer somente dois 8:02 deles e pronto a gente conseguiu 8:04 detectar aqui o nosso CPF esse aqui é o 8:07 nosso enrigex final e você pode pegar 8:10 ele agora e colocar no seu passador de 8:12 texto com por exemplo da logo flor a sua 8:14 ferramenta de mlp the machine learning 8:16 que tá construindo chatbots por exemplo 8:18 e inserir esse mesmo que Jackson aqui 8:20 para que seja afobado consciência até 8:22 que tá com o usuário inscreveram CPF 8:24 quando eu escrever o nome dele ou 8:26 qualquer coisa que você queira definir 8:27 os agora tem o potencial para fazer com 8:30 regex embora mais desafio vamos efe o 8:32 Extra agora fazer como detectar um 8:34 e-mail usando rigex Vou colocar aqui ó o 8:37 do Marquinhos underline é 55@gmail.com o 8:44 bairro Até que esse e-mail daqui eu vou 8:46 trazer aqui contigo esse sendo aqui 8:49 especial que me vender que tá qualquer 8:51 caractere alfanumérico ou uma delaine 8:54 Então já consegui pegar tanto as letras 8:56 como o número esse 55 aqui quanto o 8:59 underline 9:00 e vai tomar tá aqui mais olha vê que ele 9:02 pegou tudo isso agora conectar é só 9:05 adiciona aqui então o arroba@aqui barra 9:09 d'água de novo botar uma mais aqui para 9:11 pegar todo o Gmail barra ponto vai pegar 9:15 o Café do Ponto e agora de novo botar um 9:17 Barra W imagem de novo aqui e olha gente 9:20 tá pegando agora esse meio aqui veio 9:22 aqui embaixo corrente difícil agora um 9:23 Rex super simples para detectar qualquer 9:27 e-mail que cê usuário digitar aí na 9:28 ferramenta muito bacana né que é mais um 9:31 desafio Tá bom mas aqui é pra você 9:33 tentar fazer em casa beleza Tenta aí no 9:35 hijack sakyamuni Jackson você detectar 9:37 uma url ou seja pegar o https ou sem um 9:41 s né porque a tempo é de PS2 9:46 pontos//www.google.com por exemplo como 9:48 é que seria o rigex para vocês detectar 9:50 é um texto como esse aí na sua aplicação 9:53 chatbots no society colocar solução 9:55 tecnológica você tá do exame para fazer 9:57 a texto beleza e me conta nos 9:59 comentários se fazer o quê 10:00 O meu desafio vai até botar aí a 10:02 resolução se você acha que tá mais certa 10:04 a gente vai bater um papo aqui nos 10:05 comentários outro lugar bacana para 10:07 gente trocar uma ideia é número para mim 10:08 ver que eu tô colocando link aqui na 10:10 descrição lá nesse grupo a gente vai 10:12 poder conversar sobre nosso projeto e 10:14 tirar dúvidas sobre tecnologia em um 10:15 lugar muito bacana para construir a 10:17 comunidade aqui do canal esse vídeo tá 10:19 ficando por aqui mas eu tô muito animado 10:20 para te ver nos próximos até mais 10:27 E aí ************************************************************************ Artigo Invista em você! Saiba como a DevMedia pode ajudar sua carreira. Iniciando Expressões Regulares Apresenta as sintaxes básicas das Expressões Regulares e também a classe Regex. Suporte ao aluno Anotações Favoritar Concluído 25 Gostei 25 Artigos .NET Iniciando Expressões Regulares Expressões Regulares são padrões de caracteres que associam sequências de caracteres no texto. Podemos usar expressões regulares para extrair ou substituir porções de texto, bem como, endereço ou link de imagens em uma página HTML, modificar formato de texto ou remover caracteres inválidos. Não podemos esquecer que a sintaxe de Expressões Regulares são case-sensitive, ou seja, "abc" é diferente de "ABC". Neste artigo apresentaremos os métodos mais utilizados da classe Regex, trabalharemos as sintaxes de referência de expressões regulares mais utilizadas, seguida de práticas e validações úteis do dia-a-dia. Regex No .NET a classe Regex representa uma expressão regular imutável. Esta classe contém diversos métodos estáticos que nos permite trabalhar com expressões regulares. Para usarmos o objeto Regex devemos importar o namespace System.Text.RegularExpressions. Segue relação de métodos mais utilizados da classe Regex, a saber: Métodos Regex Framework Descrição Modelo Escape evita um conjunto de metacaracteres (\, *, +, ?, |, {, [, (,), ^, $,., #, e espaço em branco) substiuindo ele com seu código de escape Regex.Escape( input, pattern) IsMatch indica se a expressão regular encontrar a entrada de string associada Regex.IsMatch( input, pattern) Regex.IsMatch( input, pattern, options) Match pesquisa uma entrada de string para uma ocorrência de uma expressão regular e retorna resultado preciso como um objeto Match único Regex.Match( input, pattern) Regex.Match( input, pattern, options) Matches pesquisa uma entrada de string para todas as ocorrências de uma expressão regular e retorna todos os resultados com sucesso, executa Match várias vezes Regex.Matches( input, pattern) Regex.Matches( input, pattern, options) Replace dentro de uma entrada de string especificada, substitui string que associa com expressão regular por outra especificada para reposição Regex.Replace( input, pattern, replacement) Regex.Replace( input, pattern, replacement, options) Split divide uma string em um array de substrings nas posições definidas pela expressão regular Regex.Split( input, pattern) Regex.Split( input, pattern, options) Unescape substitui código de escape pelo caractere de escape Regex.Unescape( input, pattern) Opções de Execução Framework Caractere Inline Descrição None N/A nenhuma opção especificada IgnoreCase i associa case-insensitive Multiline m modo multi-linha; modifica o significado de ^ e $, assim ele executa associandoo inicio e fim, respectivamente, de alguma linha ExplicitCapture n somente capturas validas são explicitamente grupos nomeados ou numerados do formato(?...) SingleLine s modo linha simples; modifica o significado do caractere (.) assim ele associa todoscaracteres (em lugar de cada caractere exceto \n) IgnorePatternWhitespace x permite espaço em branco e comentários no pattern Compiled N/A expressões regulares seriam compilados para um assembly RightToLeft N/A procura mover da direita para esquerda em lugar da esquerda para direita Global (não contém na framework) g pesquisa global para todas as ocorrências do padrão Regex na Prática Framework Exemplo IsMatch Dim newBoolean1 As Boolean = Regex.IsMatch("Editora Wrox", "wrox") Dim newBoolean2 As Boolean = Regex.IsMatch("Editora Wrox", "wrox", _ RegexOptions.IgnoreCase) Dim myRegex As New Regex("wrox", RegexOptions.IgnoreCase) Dim newBoolean3 As Boolean = myRegex.IsMatch("Editora Wrox") Obs.: newBoolean1 retorna 'False' por causa que não contém 'IgnoreCase' (confira Opções de Execução) Match Dim newMatch1 As Match = Regex.Match("Editora Wrox", "wrox", RegexOptions.IgnoreCase) Response.Write(newMatch1.Success) Matches Dim newMatches As MatchCollection = Regex.Matches("Editora Wrox", "wrox", RegexOptions.IgnoreCase) For Each myMatch As Match In newMatches Response.Write(myMatch.Value) Next Replace Dim newString1 As String = Regex.Replace("Editora Wrox", "wrox", "o'relly") Dim newString2 As String = Regex.Replace("Editora Wrox", "wrox", "o'relly", _ RegexOptions.IgnoreCase) Dim myRegex As New Regex("wrox", RegexOptions.IgnoreCase) Dim newString3 As String = myRegex.Replace("Editora Wrox", "o'relly") Split Dim newString1() As String = Regex.Split("Editora Wrox", "wrox", RegexOptions.IgnoreCase) For Each str As String In newString1 Response.Write(str & " ") Next Referências Segue uma breve descrição dos caracteres especiais mais utilizados em expressão regular. Escape Caractere Descrição \ caractere de escape (usado para anular um efeito de um metacaractere; TOME CUIDADO AO UTILIZAR ESTE CARACTERE POIS "\d" REPRESENTA UM METACARACTERE DÍGITO E PARA ANULAR DEVE-SE ACRESCENTAR MAIS UM CARACTERE DE ESCAPE "\\d") . \a alarm \u0007 \b veja âncora. \t tab \u0009 \r retorno de carro \u000D \v tab vertical \u000B \f alimentação de formulário \u000C \n nova linha \u000A \e escape \u001B \040 caractere ASCII como octal (3 dígitos). Por exemplo, um caractere \040 representa um espaço \x20 caractere ASCII usando representação hexadecimal (3 dígitos) \cC caractere ASCII de controle. Por exemplo, \cC é equivalente a Ctrl-C \u0020 caractere ASCII usando representação hexadecimal (4 dígitos) Agrupamento Caractere Descrição [] usado para indicar o conjunto de caracteres que podem conter no texto pesquisado. (veja quantificadores) [^] usado para indicar o conjunto de caracteres que NÃO podem conter na pesquisa. (...) indica o início e o fim de um grupo; ex.: /(abc)+(def)/ encontra um ou mais ocorrencias de "abc" seguido por uma ocorrencia de "def". obs.: para usar o parêntese, literalmente, utilize o caractere de escape "\ (" ou "\ )", ou ainda, "[ ( ]" ou "[ ) ]" Âncora Caractere Descrição Modelo Representação Explicação ^ início da linha "^abc" "abcde" associa texto que inicia com a sequência "abc", embora não "yabc". $ fim da linha "abc$" "yzabc" associa texto que termina com a sequência "abc", embora não "abcde". \b fronteira do caractere "car\b" "car"; "tocar" associa a fronteira da palavra "car", embora não "carburador". \B não fronteira do caractere "car\B" "carburetor" não associa a fronteira da palavra "car", mas pode assegurar que a sequência ocorra no meio da palavra, como "carburador", embora não "tocar". \A início da string "\Apattern" "patterns" -- \Z fim da string "pattern\Z" "topattern" -- Quantificadores Caractere Descrição Modelo Representação Explicação * zero ou mais vezes "zo*" "z" ; "zoo" o caractere que precede o asterisco pode ser repetido 0 ou mais vezes (equivalente a "{0,}") + uma ou mais vezes "zo+" "zo" ; "zoo" o caractere que precede o sinal de (+) pode ocorrer 1 ou mais vezes (equivalente a "{1,}") ? zero ou uma vez "do(es)?" "do" ; "does" o caractere que precede o sinal de interrogação pode ocorrer 0 ou 1 vez (equivalente a "{0,1}") {n} n vezes "o{2}" "food" o caractere que precede o sinal pode ocorrerá n vezes {n,} pelo menos n vezes "o{2,}" "foooood" a sequência "{0,}" é equivalente a "o*"; a sequência "{1,}" é equivalente a "o+" {n,m} no mínimo n e no máximo m "o{1,3}" "foooood" associa aos três primeiros "ooo"; é equivalente a "o?" . um caractere simples, exceto "\n" "o." "oa" representa um carecteres simples, exceto "\n" ( para associá-lo utilize o padrão "[\s\S] " ) [xyz] um dos caracteres que está dentro dos colchetes "[abc]" "plain" associa "a" contido na palavra "plain" [a–z] um dos caracteres que está dentro dos colchetes "[a–z]" --- associa um dos caracteres de 'a' até 'z' em caixa baixa, lembre-se que expressões regulares são case-sensitive Alternador Caractere Descrição Modelo Representação Explicação "|" (pipe) uma ou outra ocorrência "(z|f)ood" "zood" ou "food" o caractere | (pipe) representa uma ocorrência ou outra Classes Classe Descrição [:digit:] dígito; equivalente a [0-9] [:alnum] letras e números ; equivalente a [A-Za-z0-9] [:space:] caracteres brancos ; equivalente a [ \t\n\r\f\v] [:alpha:] letras; equivalente a [A-Za-z] [:lower:] minúsculas; equivalente a [a-z] [:upper:] maiúsculas; equivalente a [A-Z] [:punct:] caracteres de pontuação; equivalente a [.,!?:...] [:xdigit:] números hexadecimais; equivalente a [0-9A-Fa-f] [:word:] qualquer caractere alfanumérico, mais underscore (_); equivalente a [[:alnum:]_] [:blank:] espaço em branco e TAB; equivalente a [\t] [:punct:] pontuação; equivalente a [!"#$%&'()*+,-./:;?@[\\\]_`{|}~] Caracteres de Classes Predefinidos Classe Caractere [:digit:] \d ^[:digit] \D [:space:] \s ^[:space:] \S [:word:] \w ^[:word:] \W Parâmetros BackReference Caracteres Descrição \number backreference que associa o conteúdo do grupo de mesmo número. Grupos são numerados iniciando de 1. Por exemplo, (.+) \1 associa 'abc abc' ou '777 777', embora não 'abc def'. O número máximo de backreferences é limitado para 9 (\1...\9). \k backreference nomeada. (http://msdn2.microsoft.com/en-us/library/ksz2azbh.aspx) Comentário Caractere Descrição # insere comentário dentro da expressão Praticando É interessante criarmos uma página .aspx (ou qualquer outra hosting application que desejar) para testarmos as expressões regulares. O código abaixo facilita bastante a execução das sintaxes, inclusive dos métodos da classe Regex (veja Métodos Regex). Protected Sub Button1_Click(ByVal sender As Object, ByVal e As System.EventArgs) Handles Button1.Click ' o padrão que utilizaremos será Regex.IsMatch( input, pattern) If (Regex.IsMatch(TextBox1.Text, "^\d+$")) Then Response.Write("Informação válida.") Else Response.Write("Informação inválida.") End If End Sub Perceba que o método IsMatch retorna um valor Booleano e é necessário informar, neste caso, apenas o texto e a sintaxe da expressão regular (veja Métodos Regex). Para qualquer teste que queira fazer basta colocar o pattern - sintaxe - da expressão regular e testar. Por exemplo, "^\d+$" valida somente dígitos, isso significa que se for digitado alguma coisa que não for número então retornará False. Abaixo segue uma lista de algumas das validações simples que utilizamos no dia a dia. Validações Úteis com Expressões Regulares Tipo de Validação Expressão Dígito ^\d+$ Decimal ^[+-]?((\d+|\d{1,3}(\.\d{3})+)(\,\d*)?|\,\d+)$ ^[-+]?([0-9]*\,[0-9]+|[0-9]+)$ Letra ^[[:alpha:]]+$ URL ^((http)|(https)|(ftp)):\/\/([\- \w]+\.)+\w{2,3}(\/ [%\-\w]+(\.\w{2,})?)*$ E-mail ^([\w\-]+\.)*[\w\- ]+@([\w\- ]+\.)+([\w\-]{2,3})$ Endereço IP \b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b Tempo (24 horas) ^([0|1|2]{1}\d):([0|1|2|3|4|5]{1} \d)$ Data (dd/mm/aaaa) ^((0[1-9]|[12]\d)\/(0[1-9]|1[0-2])|30\/(0[13-9]|1[0-2])|31\/(0[13578]|1[02])) \/\d{4}$ Telefone ^\(\d{3}\)-\d{4}-\d{4}$ Senha ^\w{4,10}$ ^[a-zA-Z]\w{3,9}$ ^[a-zA-Z]\w*\d+\w*$ Referências Microsoft Visual Basic .NET Programmer's Cookbook / by Matthew MacDonald; Sams Teach Yourself Regular Expressions in 10 Minutes / By Ben Forta; Mastering Regular Expressions, 3rd Edition / By Jeffrey E. F. Friedl; Beginning Regular Expressions / Andrew Watt; Microsoft .NET Framework 2.0 Application Development Foundation / byTony Northrup, Shawn WildermuthandBill Ryan. Saiu na DevMedia! React com Redux: Redux é uma biblioteca JavaScript criada pelo Facebook para resolver um problema inerente de aplicações front-end conforme elas crescem em tamanho e complexidade. Saiba mais sobre .NET ;) Linguagem C#: Neste guia de consulta você encontrará diversos conteúdos que podem ser usados ao longo dos seus estudos sobre a linguagem de programação C#. Consulte este guia para aprender mais sobre certos recursos da linguagem. ************************************************************************************ Regex: Um guia prático para expressões regulares Aprenda regex de forma simples e fácil! Photo by Fran . on Unsplash Em toda nossa vida como programadores estaremos lidando com regex em algum momento. Seja para coisas comuns como validar emails ou data e até mesmo para fazer parse em textos em busca de um determinado padrão. Nesse post, irei mostrar de forma simples e fácil como você pode criar suas próprias expressões regulares. Todos os exemplos serão feitos usando javascript, porém, muito das regex criadas aqui também funcionarão em outras linguagens como elixir, python, php ou ruby. O que é uma expressão regular? De forma simples: Uma expressão regular é um método formal de se especificar um padrão de texto. Com ela podemos lidar com as seguintes situações: procura; substituição; validação de formatos; filtragem de informações Criando nossas primeiras regex Usando javascript podemos optar por duas formas de se criar uma regex. Podemos criar usando um constructor: const regex = new RegExp('dog','gi'); Ou criando de forma literal: const regex = /dog/gi Podemos buscar por somente uma letra: pattern: /a/ string: A casa está limpa. matches: ^ Ou buscar por uma palavra: pattern: /celular/ string: O celular está tocando. matches: ^^^^^^^ Podemos ver que, na primeira regex, ela ignorou o primeiro A. Isso acontece porque as regex são case sensitive. Notamos também na primeira regex que só houve match na primeira ocorrência. Para lidar com isso, usaremos flags. Flags Elas adicionam comportamentos adicionais a nossas regras, como: g - indicar achar todas as ocorrências da regex i - ignora case sensitive m - multilinha, lida com caracteres de inicio e fim (^ e $) ao operar em múltiplas linhas. Podemos então obter todas as ocorrências com a flag g e em conjunto com a flag i podemos ignorar o case sensitive de uma busca: pattern: /ontem/gi string: Ontem faltou água, Anteontem faltou luz matches:^^^^^ ^^^^^ Operador pipe " | “ Algumas vezes precisamos dar match em mais de um termo, para isso usamos o operador pipe | . Ele funciona basicamente como nosso operador lógico OR || . Assim podemos escrever: pattern: /ver|distrai/gi string: Ver a linha do horizonte me distrai matches:^^^ ^^^^^^^pattern: /20|nove/gi string: Perdi 20 em 20 e nove amizades matches: ^^ ^^ ^^^^pattern: /e|m|²/gi string: E = mc² matches: ^ ^ ^ Conjuntos “ [ ] ” Com os conjuntos dizemos a regex que uma determinada casa pode ter diversos valores para dar match. Vejamos o seu uso: pattern: /[em²]/gi string: E = mc² matches: ^ ^ ^ Uma funcionalidade interessante é de adicionar range (invervalos) dentro dos nossos conjuntos. Podemos determinar um conjunto de match em letras que vão de A à Z ou pegue qualquer digito (0 à 9). pattern: /[a-z]/ string: João de Santo Cristo matches: ^ ^ ^^ ^^^^ ^^^^^pattern: /[A-Za-z]/ string: Açucar e Café matches: ^ ^^^^ ^ ^^pattern: /[0-9.,]/ string: Um ps4 custa R$ 1.600,00 matches: ^ ^^^^^^^^ Um detalhe a ser observado é que o range obedece a mesma ordem da tabela Unicode, sendo assim regex como [a-Z] ou [4-1] produziram erro, pois ambas não estão na ordem correta da tabela Unicode. Podemos também dar match em letras com acentos (é-à) ou (ç) usando: pattern: /[À-ü]/ string: Açaí é melhor matches: ^^^^ ^ ^^^^^^ Temos também os conjuntos negados, que como o nome sugere, dar match em tudo que não faça parte do conjunto. Para definí-lo iniciamos a regra do conjunto com ^ , por exemplo [^a-z] que aceita tudo que não seja entre a à z. Vejamos um exemplo: pattern: /[^aeiouí]/gi string: Paralelepípedo matches: ^ ^ ^ ^ ^ ^ ^ Metacaracteres Nas regex existem duas formas de caracteres, os literais, que representam o valor literal do caractere como abc123 e os metacaracteres que possuem funções distintas dentro de um contexto na regex. Dois exemplos que acabamos de ver são o uso do ^ iniciando um conjunto negado e o uso do - em uma regra de conjunto com range[1-9] . Um metacaractere bastante recorrente é o ponto . , ele funciona como um coringa, sendo capaz de dar match em qualquer caractere, vejamos um exemplo: pattern: /cas./gi string: Casa, caso, case matches: ^^^^ ^^^^ ^^^^ Visto isso, você deve estar se perguntando: Como pegar a forma literal do ponto? Eis que é muito simples bastando usar um escape \ mais o metacaractere desejado. Vejamos um exemplo: pattern: /[a\-o]/gi string: cachorro-quente. matches: ^ ^ ^^ Para simplificar a escrita e leitura das regex, possuímos algumas shorthands que são extremamente úteis para deixar ainda mais claro nosso código. Veja como podemos escrever esse conjunto [0-9] para \d ,[a-zA-Z0-9_] para \w ou para tratar espaços em branco [\r\n\t\f\v ] para \s simplificando ainda mais nossas regras. Vejamos alguns exemplos: pattern: /\(\d\d\)\s\d\d\d\d\d-\d\d\d\d/ string: (86) 95262-7297 matches: ^^^^^^^^^^^^^^^pattern: /\w\w\w\w\w@\w\w\.com/ string: ax_a5@5x.com matches: ^^^^^^^^^^^^ Para um guia de consulta, criei um gist contendo muitos metacaracteres e shorthands e seus respectivos significado. Quantificadores Uma maneira de deixar suas regras ainda mais simples é com o uso dos quantificadores. Com eles podemos dizer quantas vezes uma mesma regra pode aparecer em sequência. Vejamos elas: ? - zero ou um ocorrência; * - zero ou mais ocorrências; + - uma ou mais ocorrências; {n, m} - de n até m. Seu uso é simples, basta adicionar o quantificador após um caractere, metacaractere, conjunto ou mesmo um grupo (ainda veremos abaixo). Exemplo [0-9]? \w* a+ e (\d){1,3} . Digamos que queremos pegar um documento como o cpf, que contêm muitos números e pontuações(. e -) onde a validação pode aceitar o cpf com e sem pontuação, ficando deste modo: pattern: /\d{3}\.?\d{3}\.?\d{3}-?\d{2}/ string: 825.531.760-07 matches: ^^^^^^^^^^^^^^ string: 18646661024 matches: ^^^^^^^^^^^ Como podemos pegar uma repetição de caractere sem estipular algum limite, vejamos: pattern: /go+l+/gi string: Goolllll da Alemanha!!! matches: ^^^^^^^^ Âncoras Muitas vezes vamos precisar delimitar a ação da nossa regex. Desse modo podemos usar três metas para nos auxiliar nessa função. Quando queremos tratar uma palavra que em suas extremidades não possua outra letra ou palavra, usamos a shorthands \b. pattern: /\bpar\b/gi string: Parcela par Parcial paraíso matches: ^^^pattern: /\bpar[a-z]+/gi string: Parei parque topar matches: ^^^^^ ^^^^^^ pattern: /[a-z]+par\b/gi string: parodiado escapar equipar parasitar matches: ^^^^^^^ ^^^^^^^pattern: /\b[a-z]+par[a-z]+\b/gi string: limpar aparto aparta matches: ^^^^^^ ^^^^^^ Vale notar que caracteres com acentos ou - são considerados bordas. Podemos lidar com o início e fim de uma linha. Usamos a meta ^ para indicar o início de uma linha e $ indicando o fim de uma linha. Algo importante a se notar é que para as âncoras funcionarem a cada quebra de linha \n a flag m tem que estar habilitada. Segue uma estrofe usando a meta ^: pattern: /^[a-z]*\b/gmi Quantas chances desperdicei ^^^^^^^ Quando o que eu mais queria ^^^^^^ Era provar pra todo o mundo ^^^ Que eu não precisava provar nada pra ninguém ^^^ Confira também o uso do meta $ em uma estrofe: pattern: /[a-z]+nto$/gmi O tempo cobre o chão de verde manto ^^^^^ Que já coberto foi de neve fria, E em mim converte em choro o doce canto ^^^^^ Conseguimos tratar início e final de um texto ao mesmo tempo. Confira um exemplo: pattern: /^https:\/\/w{3}\.[a-z]+\.com$/gmi https://google.com.br https://www.facebook.com ^^^^^^^^^^^^^^^^^^^^^^^^ https://www.voxel.com.br Grupos “ () ” Por fim, temos os grupos que facilita ainda mais nossas regras. Eles nos possibilita a criação de regras isoladas, possibilita a criação de referencias (retrovisores) para o reuso da mesma regra em outro local dentro de uma mesmo regex e ainda cria a possibilidade de validações dentro da regex. Seu uso é muito diverso, dando muito poder ao programador na hora de escrever suas regras. Veja um exemplo: pattern: /(\d{2})\/?(\d{2})?\/(\d{4})/ string: Hoje é dia 20/01/2020 matches: ^^^^^^^^^^ Uma função muito interessante dos grupos é que quando criamos algum grupo, este grupo é criando uma referência, que podemos acessa-lo em funções como o método replace (que vamos ver a frente) ou usar como retrovisores (mirror words) para fazer reuso de algum grupo que deu match anteriormente. Vejamos um exemplo baseado no exemplo anterior: pattern: /\d{2}(\/?)\d{2}?\1\d{4}/g string: 20/01/2020 25091991 25-09/2000 matches: ^^^^^^^^^^ ^^^^^^^^ No exemplo acima, veja que criamos o grupo (\/?) e para não repetí-lo em outro momento que necessitamos da mesma regra, usamos o retrovisor \1 sendo 1 é ligado a ordem em que esse grupo foi criado. Podemos criar diversas referências para o reuso de regras. Uma dica é se por exemplo usamos um grupo (\w) o seu retrovisor será o caractere que deu match com \w. Ex: \w = R seu \1 sera R. Podemos definir grupos que podem ser ignorados (non-capturing groups) na hora do match usando a sintaxe (?:). Vejamos um exemplo: pattern: /([a-z]*)\s(?:ronaldo)/gi string: Cristiano Ronaldo matches: ^^^^^^^^^^^^^^^^^ No exemplo acima, só foi nomeado um grupo, no caso ([a-z]*) pois o grupo (?:ronaldo) foi definido usando (?:) e com isso não conseguimos manipulá-lo. Com os grupos podemos criar grupos aninhados (grupos dentro de grupos). Vejamos um exemplo: pattern: /((d[io])|(co))([a-z]{2})(do)/gi string: ditado colado dosado matches: ^^^^^^ ^^^^^^ ^^^^^^ Os grupos possuem grupos especiais. Como o positive lookahead (?=) e o seu oposto, negative lookahead (?!). Com o positive lookahead podemos verificar se existe um grupo a frente de uma expressão ou grupo. Vejamos um exemplo: pattern: /([a-z]+)(?=,)/gi string: Penso, logo existo matches: ^^^^^ Falamos acima que a regex só dá match em palavras que à sua frente possuam virgula. Já o negative lookahead é exatamente o contrário do positive lookahed, ele pegará todos que não fazem parte do grupo especial. Vejamos um exemplo: pattern: /([a-z]+)(?!,)\b/gi string: Penso, logo existo matches: ^^^^ ^^^^^^ Dentro dos grupos especiais ainda temos os positive lookbehind e negative lookbehind, porém como eles não possuem um bom suporte nos browsers decidi deixá-lo de fora deste post, porém pretendo abordá-los em post futuros. Métodos de regex no js O objeto regex possui dois métodos: exec e test. Já com string possui 4 métodos: match, replace, search e split. Porém neste post vou me ater somente a 3 métodos: test, match e replace. test Usado para verificar se uma regex da match com uma string. Ela retorna sempre valor boolean. Este método é ideal para fazer validações como por exemplo validar se um email, telefone ou data estão corretos. Vejamos um exemplo validando números de telefone: match Ele retorna um array, com as string que deram match com a regex. Se não houver valor, ele retorna null. Vejamos um exemplo procurando cep validos em um texto: Vejamos acima que o último número não foi pego no match, pois ele não é um cep válido. replace Usado para substituir strings que deram match por uma nova string. Segue um exemplo: Podemos ainda manipular grupos. Vejamos um exemplo: Um recurso legal do replace é que podemos passar uma função em vez da string de substituição. Isso ainda nos dá mais possibilidades de alteração em algum texto que queremos substituir algo. Vejamos um exemplo: Conclusão Chegamos ao fim, o estudo de regex é muito interessante, sendo que possível fazer muitas coisas em diferentes linguagens. Fiz uma extensa lista de diversos problemas resolvidos com regex, confira abaixo: 18 aplicações comuns de regex no dia a dia Você ainda pode testar suas regex de forma mais visual pelos sites: Regex101 Regulex Este é meu primeiro post, espero que tenha ajudado. Vlws. Referências: A guide to JavaScript Regular Expressions 20 Small Steps to Become a Regex Master Regex tutorial — A quick cheatsheet by examples More from Comunidade XP Aqui você vai encontrar os principais conteúdos de tecnologia, design, dados e produto da XP Inc. Italo Santana Italo Santana ·Jan 29, 2020 Design de Sistemas Distribuídos — Balanceamento de Carga (Load Balancing) Bem vindos ao terceiro artigo da série sobre Design de Sistemas e Sistemas Distribuídos! Você pode ler o artigo anterior da série aqui. Dando continuidade a série sobre sistemas distribuídos, hoje vamos abordar Balanceamento de Carga, tema bastante amplo e muito importante, tanto que dediquei um capítulo apenas para falar… Distributed Systems 7 min read Design de Sistemas Distribuídos — Balanceamento de Carga (Load Balancing) Share your ideas with millions of readers. Write on Medium Lennon Alves Dias Lennon Alves Dias ·Jan 22, 2020 Publicando meu site em Angular 8 no GitHub Pages com domínio customizado Utilizando a biblioteca angular-cli-ghpages para realizar o deploy da minha aplicação Angular no GitHub Pages diretamente do terminal. 💁‍♂ Considerações iniciais Neste artigo será abordada a instalação e configuração dos pacotes necessários assim como demonstrado o passo à passo do build e deploy da aplicação. Não será abordada a construção e/ou o desenvolvimento… Angular 3 min read Publicando meu site em Angular 8 no GitHub Pages com domínio customizado Jones Roberto Jones Roberto ·Jan 21, 2020 Design Patterns — Parte 20— Memento Intenção É um padrão de design comportamental que permite salvar e restaurar o estado anterior de um objeto sem revelar os detalhes de sua implementação. Problema Você precisa restaurar um objeto de volta ao seu estado anterior (por exemplo, operações “desfazer” ou “reverter”). Solução O cliente solicita um Memento do objeto de origem… Desing Pattern 4 min read Design Patterns — Parte 20— Memento Thiago S. Adriano Thiago S. Adriano ·Jan 19, 2020 Curso: Criando API’s RESTful utilizando TypeScript, Node.js, mongoDB, Redis e Docker no Azure 4-Parte: Criação da primeira rota do projeto Dando continuidade a liberação dos módulos do meu curso: Criando API’s RESTful utilizando TypeScript, Node e mongoDB, hoje eu irei demonstrar como criar a primeira rota do nosso projeto. Caso tenha interesse em ver os primeiros passos dessa serie, segue link de cada um deles abaixo: Primeiro módulo do curso Configurando o ambiente com Docker Criando a base da projeto Typescript 1 min read Fernando Mendes Fernando Mendes ·Jan 17, 2020 Executando comandos Docker em aplicações .Net Core 3 Olá pessoal, tudo bem? Você que é desenvolvedor muito provavelmente já mexeu com o Docker, e sabe para que serve. Hoje em dia, não consigo mais ficar sem o Docker. O utilizo muito principalmente para criar meus ambientes de desenvolvimento, baixo imagens como: Mongo, Sql Server, ElasticSearch, RabbitMq, Kafka e… Dotnet 3 min read Executando comandos Docker em aplicações .Net Core 3 *********************************************************************************** Classes de caracteres em expressões regulares Artigo 08/07/2022 36 minutos para o fim da leitura Uma classe de caracteres define um conjunto de caracteres, qualquer dos quais pode ocorrer em uma cadeia de caracteres de entrada para que uma correspondência seja bem-sucedida. A linguagem de expressões regulares no .NET dá suporte às seguintes classes de caracteres: Grupos de caracteres positivos. Um caractere na cadeia de caracteres de entrada deve corresponder a um de um conjunto especificado de caracteres. Para obter mais informações, consulte Grupo de Caracteres Positivo. Grupo de caracteres negativos. Um caractere na cadeia de caracteres de entrada não deve corresponder a um de um conjunto especificado de caracteres. Para obter mais informações, consulte Grupo de Caracteres Negativos. Qualquer caractere. O . (ponto) em uma expressão regular é um caractere curinga que corresponde a qualquer caractere, exceto \n. Para obter mais informações, consulte Qualquer Caractere. Uma categoria geral de Unicode ou bloco nomeado. Um caractere na cadeia de caracteres de entrada deve ser um membro de uma categoria de Unicode específica ou deve estar dentro de um intervalo contíguo de caracteres Unicode para que uma correspondência seja bem-sucedida. Para obter mais informações, consulte Categoria Unicode ou Bloco Unicode. Uma categoria geral de Unicode ou bloco nomeado negativos. Um caractere na cadeia de caracteres de entrada não deve ser um membro de uma categoria de Unicode específica ou não deve estar dentro de um intervalo contíguo de caracteres Unicode para que uma correspondência seja bem-sucedida. Para obter mais informações, consulte Categoria Unicode Negativa ou Bloco Unicode. Um caractere de palavra. Um caractere na cadeia de caracteres de entrada pode pertencer a qualquer uma das categorias Unicode que são apropriados para caracteres usados em palavras. Para obter mais informações, consulte o Caractere do Word. Um caractere não pertencente a palavras. Um caractere na cadeia de caracteres de entrada pode pertencer a qualquer categoria Unicode que não seja um caractere de palavra. Para obter mais informações, consulte Caractere não Word. Um caractere de espaço em branco. Um caractere na cadeia de caracteres de entrada pode ser qualquer caractere separador Unicode, bem como qualquer um entre vários caracteres de controle. Para obter mais informações, consulte Caractere de espaço em branco. Um caractere diferente de espaço em branco. Um caractere na cadeia de caracteres de entrada pode ser qualquer caractere que não seja um caractere de espaço em branco. Para obter mais informações, consulte Caracteres sem espaço em branco. Um dígito decimal. Um caractere na cadeia de caracteres de entrada pode ser qualquer um entre vários caracteres classificados como dígitos decimais Unicode. Para obter mais informações, consulte Caractere de dígito decimal. Um dígito não decimal. Um caractere na cadeia de caracteres de entrada pode ser qualquer coisa que não seja um dígito decimal Unicode. Para obter mais informações, consulte Caractere de dígito decimal. O .NET dá suporte a expressões de subtração de classes de caracteres, o que permite a você definir um conjunto de caracteres como resultado da exclusão de uma classe de caracteres de outra classe de caracteres. Para obter mais informações, consulte Subtração de classe de caractere. Observação Classes de caractere que fazem a correspondência de caracteres por categoria, como \w para a correspondência de caracteres de palavra ou \p{} para uma categoria de Unicode, dependem da classe CharUnicodeInfo para fornecer informações sobre categorias de caractere. No .NET Framework 4.6.2 e versões posteriores, as categorias de caracteres são baseadas no Unicode Standard, versão 8.0.0. Grupo de caracteres positivo: [ ] Um grupo de caracteres positivos especifica uma lista de caracteres, qualquer caractere dela pode aparecer em uma cadeia de caracteres de entrada para que uma correspondência ocorra. Essa lista de caracteres pode ser especificada individualmente, como um intervalo ou ambos. A sintaxe para especificar uma lista de caracteres individuais é a seguinte: [*character_group*] em que character_group é uma lista dos caracteres individuais que podem aparecer na cadeia de caracteres de entrada para que uma correspondência seja bem-sucedida. character_group pode consistir em qualquer combinação de um ou mais caracteres literais, caracteres de escape ou classes de caracteres. A sintaxe para especificar um intervalo de caracteres é a seguinte: [firstCharacter-lastCharacter] onde firstCharacter é o caractere que começa o intervalo e lastCharacter é o caractere que termina o intervalo. Um intervalo de caracteres é uma série contígua de caracteres definida pela especificação do primeiro caractere na série, um hífen (-) e o último caractere na série. Dois caracteres são contíguos se eles têm pontos de código Unicode adjacentes. firstCharacter precisa ser o caractere com o ponto de código menor, enquanto lastCharacter precisa ser o caractere com o ponto de código maior. Observação Visto que um grupo de caracteres positivos pode incluir um conjunto de caracteres e um intervalo de caracteres, um caractere de hífen (-) é sempre interpretado como o separador de intervalo, a menos que ele seja o primeiro ou último caractere do grupo. Alguns padrões de expressões regulares comuns que contêm classes de caracteres positivos são listados na tabela a seguir. Padrão Descrição [aeiou] Corresponder a todas as vogais. [\p{P}\d] Corresponder a todos os caracteres de pontuação e dígitos decimais. [\s\p{P}] Corresponder a todos os espaços em branco e à pontuação. O exemplo a seguir define um grupo de caracteres positivos que contém os caracteres “a” e “e” para que a cadeia de caracteres de entrada contenha as palavras “grey” ou “gray” seguida de outra palavra para que uma correspondência ocorra. C# using System; using System.Text.RegularExpressions; public class Example { public static void Main() { string pattern = @"gr[ae]y\s\S+?[\s\p{P}]"; string input = "The gray wolf jumped over the grey wall."; MatchCollection matches = Regex.Matches(input, pattern); foreach (Match match in matches) Console.WriteLine($"'{match.Value}'"); } } // The example displays the following output: // 'gray wolf ' // 'grey wall.' A expressão regular gr[ae]y\s\S+?[\s|\p{P}] é definida da seguinte forma: Padrão Descrição gr Corresponder aos caracteres literais “gr”. [ae] Corresponder a um "a" ou "e". y\s Corresponder ao caractere literal “y” seguido por um caractere de espaço em branco. \S+? Corresponder a um ou mais caracteres diferentes de espaço em branco, mas o mínimo possível. [\s\p{P}] Corresponder a um caractere de espaço em branco ou a um sinal de pontuação. O exemplo a seguir corresponde a palavras que começam com qualquer letra maiúscula. Ele usa a subexpressão [A-Z] para representar o intervalo de letras maiúsculas de A a Z. C# using System; using System.Text.RegularExpressions; public class Example { public static void Main() { string pattern = @"\b[A-Z]\w*\b"; string input = "A city Albany Zulu maritime Marseilles"; foreach (Match match in Regex.Matches(input, pattern)) Console.WriteLine(match.Value); } } // The example displays the following output: // A // Albany // Zulu // Marseilles A expressão regular \b[A-Z]\w*\b é definida conforme mostrado na tabela a seguir. Padrão Descrição \b Iniciar em um limite de palavra. [A-Z] Corresponder a qualquer caractere maiúsculo de A a Z. \w* Corresponder a zero ou mais caracteres de palavra. \b Corresponder a um limite de palavra. Grupo de caracteres negativos: [^] Um grupo de caracteres negativos especifica uma lista de caracteres que não devem aparecer em uma cadeia de caracteres de entrada para que uma correspondência ocorra. A lista de caracteres pode ser especificada individualmente, como um intervalo ou ambos. A sintaxe para especificar uma lista de caracteres individuais é a seguinte: [*^character_group*] em que character_group é uma lista dos caracteres individuais que não podem aparecer na cadeia de caracteres de entrada para que uma correspondência seja bem-sucedida. character_group pode consistir em qualquer combinação de um ou mais caracteres literais, caracteres de escape ou classes de caracteres. A sintaxe para especificar um intervalo de caracteres é a seguinte: [^*firstCharacter*-*lastCharacter*] onde firstCharacter é o caractere que começa o intervalo e lastCharacter é o caractere que termina o intervalo. Um intervalo de caracteres é uma série contígua de caracteres definida pela especificação do primeiro caractere na série, um hífen (-) e o último caractere na série. Dois caracteres são contíguos se eles têm pontos de código Unicode adjacentes. firstCharacter precisa ser o caractere com o ponto de código menor, enquanto lastCharacter precisa ser o caractere com o ponto de código maior. Observação Visto que um grupo de caracteres negativos pode incluir um conjunto de caracteres e um intervalo de caracteres, um caractere de hífen (-) é sempre interpretado como o separador de intervalo, a menos que ele seja o primeiro ou último caractere do grupo. Dois ou mais intervalos de caracteres podem ser concatenados. Por exemplo, para especificar o intervalo de dígitos decimais de "0 " a "9", o intervalo de letras minúsculas de "a" a "f" e o intervalo de letras maiúsculas "A" a "F", use [0-9a-fA-F]. O caractere de careta à esquerda (^) em um grupo de caracteres negativo é obrigatório e indica que o grupo de caracteres é um grupo de caracteres negativo em vez de um grupo de caracteres positivo. Importante Um grupo de caracteres negativos em uma expressão regular maior não é uma asserção de largura zero. Ou seja, depois de avaliar o grupo de caracteres negativos, o mecanismo de expressões regulares avança um caractere na cadeia de caracteres de entrada. Alguns padrões de expressões regulares comuns que contêm grupos de caracteres negativos são listados na tabela a seguir. Padrão Descrição [^aeiou] Corresponder a todos os caracteres, exceto vogais. [^\p{P}\d] Corresponder a todos os caracteres, exceto de pontuação e dígitos decimais. O exemplo a seguir corresponde a todas as palavras que começam com os caracteres “th” e não são seguidas por um “o”. C# using System; using System.Text.RegularExpressions; public class Example { public static void Main() { string pattern = @"\bth[^o]\w+\b"; string input = "thought thing though them through thus thorough this"; foreach (Match match in Regex.Matches(input, pattern)) Console.WriteLine(match.Value); } } // The example displays the following output: // thing // them // through // thus // this A expressão regular \bth[^o]\w+\b é definida conforme mostrado na tabela a seguir. Padrão Descrição \b Iniciar em um limite de palavra. th Corresponder aos caracteres literais “th”. [^o] Corresponder a qualquer caractere que não seja um “o”. \w+ Fazer a correspondência a um ou mais caracteres de palavra. \b Terminar em um limite de palavra. Qualquer caractere: . O caractere de ponto (.) corresponde a qualquer caractere, exceto \n (o caractere de nova linha, \u000A), com estas duas qualificações: Se um padrão de expressão regular é modificado pela opção RegexOptions.Singleline, ou se a parte do padrão que contém a classe de caracteres . é modificada pela opção s, . corresponde a qualquer caractere. Para obter mais informações, consulte Opções de Expressão Regular. O exemplo a seguir ilustra o comportamento diferente da classe de caracteres . por padrão e com a opção RegexOptions.Singleline. A expressão regular ^.+ começa no início da cadeia de caracteres e corresponde a todos os caracteres. Por padrão, a correspondência termina no final da primeira linha; o padrão de expressão regular corresponde ao caractere de retorno de carro, \r ou \ u000D, mas não corresponde a \n. Como a opção RegexOptions.Singleline interpreta toda a cadeia de caracteres de entrada como uma única linha, ela corresponde a cada caractere na cadeia de caracteres de entrada, incluindo \n. C# using System; using System.Text.RegularExpressions; public class Example { public static void Main() { string pattern = "^.+"; string input = "This is one line and" + Environment.NewLine + "this is the second."; foreach (Match match in Regex.Matches(input, pattern)) Console.WriteLine(Regex.Escape(match.Value)); Console.WriteLine(); foreach (Match match in Regex.Matches(input, pattern, RegexOptions.Singleline)) Console.WriteLine(Regex.Escape(match.Value)); } } // The example displays the following output: // This\ is\ one\ line\ and\r // // This\ is\ one\ line\ and\r\nthis\ is\ the\ second\. Observação Como ela corresponde a qualquer caractere, exceto \n, a classe de caracteres . também corresponde a \r (o caractere de retorno de carro, \u000D). Em um grupo de caracteres positivos ou negativos, um ponto é tratado como um caractere de ponto literal e não como uma classe de caracteres. Para saber mais, confira Grupo de caracteres positivos e Grupo de caracteres negativos anteriormente neste tópico. O exemplo a seguir fornece uma ilustração ao definir uma expressão regular que inclui o caractere de ponto (.) como uma classe de caracteres e como um membro de um grupo de caracteres positivos. A expressão regular \b.*[.?!;:](\s|\z) começa em um limite de palavra, corresponde a qualquer caractere até encontrar um de cinco sinais de pontuação, incluindo um ponto, e corresponde a um caractere de espaço em branco ou ao final da cadeia de caracteres. C# using System; using System.Text.RegularExpressions; public class Example { public static void Main() { string pattern = @"\b.*[.?!;:](\s|\z)"; string input = "this. what: is? go, thing."; foreach (Match match in Regex.Matches(input, pattern)) Console.WriteLine(match.Value); } } // The example displays the following output: // this. what: is? go, thing. Observação Como ele corresponde a qualquer caractere, o elemento de linguagem . é frequentemente usado com um quantificador lento se um padrão de expressão regular tenta corresponder a qualquer caractere várias vezes. Para saber mais, confira Quantificadores. Categoria de Unicode ou bloco Unicode: \p{} O padrão Unicode atribui a cada caractere uma categoria geral. Por exemplo, um caractere específico pode ser uma letra maiúscula (representada pela categoria Lu), um dígito decimal (a categoria Nd), um símbolo matemático (a categoria Sm) ou um separador de parágrafo (a categoria Zl). Os conjuntos de caracteres específicos no padrão Unicode também ocupam um intervalo específico ou um bloco de pontos de código consecutivos. Por exemplo, o conjunto de caracteres latinos básico é de \u0000 a \u007F, enquanto que o conjunto de caracteres árabe vai de \u0600 a \u06FF. A constructo da expressão regular \p{Nome} corresponde a qualquer caractere que pertence a uma categoria geral Unicode ou bloco nomeado, em que o nome é a abreviação de categoria ou nome do bloco nomeado. Para obter uma lista de abreviações de categoria, consulte a seção Categorias Gerais unicode com suporte mais adiante neste tópico. Para obter uma lista de blocos nomeados, consulte a seção Blocos Nomeados com Suporte mais adiante neste tópico. O exemplo a seguir usa o constructo de \p{nome} para corresponder a uma categoria geral Unicode (nesse caso, a Pdcategoria De pontuação, traço) e um bloco nomeado (blocos nomeados e estojos IsGreekIsBasicLatin ). C# using System; using System.Text.RegularExpressions; public class Example { public static void Main() { string pattern = @"\b(\p{IsGreek}+(\s)?)+\p{Pd}\s(\p{IsBasicLatin}+(\s)?)+"; string input = "Κατα Μαθθαίον - The Gospel of Matthew"; Console.WriteLine(Regex.IsMatch(input, pattern)); // Displays True. } } A expressão regular \b(\p{IsGreek}+(\s)?)+\p{Pd}\s(\p{IsBasicLatin}+(\s)?)+ é definida conforme mostrado na tabela a seguir. Padrão Descrição \b Iniciar em um limite de palavra. \p{IsGreek}+ Corresponder a um ou mais caracteres gregos. (\s)? Corresponder a zero ou a um caractere de espaço em branco. (\p{IsGreek}+(\s)?)+ Corresponder ao padrão de um ou mais caracteres gregos seguidos por zero ou um caractere de espaço em branco uma ou mais vezes. \p{Pd} Corresponder a um caractere de pontuação, traço. \s Corresponde a um caractere de espaço em branco. \p{IsBasicLatin}+ Corresponder a um ou mais caracteres latinos. (\s)? Corresponder a zero ou a um caractere de espaço em branco. (\p{IsBasicLatin}+(\s)?)+ Corresponder ao padrão de um ou mais caracteres latinos básicos seguidos por zero ou um caractere de espaço em branco uma ou mais vezes. Categoria Unicode negativa ou bloco Unicode: \P{} O padrão Unicode atribui a cada caractere uma categoria geral. Por exemplo, um caractere específico pode ser uma letra maiúscula (representada pela categoria Lu), um dígito decimal (a categoria Nd), um símbolo matemático (a categoria Sm) ou um separador de parágrafo (a categoria Zl). Os conjuntos de caracteres específicos no padrão Unicode também ocupam um intervalo específico ou um bloco de pontos de código consecutivos. Por exemplo, o conjunto de caracteres latinos básico é de \u0000 a \u007F, enquanto que o conjunto de caracteres árabe vai de \u0600 a \u06FF. A constructo da expressão regular \P{Nome} corresponde a qualquer caractere que não pertença a uma categoria geral de Unicode ou a um bloco nomeado, em que name é a abreviação da categoria ou o nome do bloco nomeado. Para obter uma lista de abreviações de categoria, consulte a seção Categorias Gerais unicode com suporte mais adiante neste tópico. Para obter uma lista de blocos nomeados, consulte a seção Blocos Nomeados com Suporte mais adiante neste tópico. O exemplo a seguir usa o constructo de \P{nome} para remover quaisquer símbolos de moeda (nesse caso, a Sccategoria , ou Símbolo, Moeda) de cadeias de caracteres numéricas. C# using System; using System.Text.RegularExpressions; public class Example { public static void Main() { string pattern = @"(\P{Sc})+"; string[] values = { "$164,091.78", "£1,073,142.68", "73¢", "€120" }; foreach (string value in values) Console.WriteLine(Regex.Match(value, pattern).Value); } } // The example displays the following output: // 164,091.78 // 1,073,142.68 // 73 // 120 O padrão de expressão regular (\P{Sc})+ corresponde a um ou mais caracteres que não são símbolos de moeda; ele remove efetivamente qualquer símbolo de moeda da cadeia de caracteres de resultado. Caractere de palavra: \w \w corresponde a qualquer caractere de palavra. Um caractere de palavra é um membro de qualquer uma das categorias Unicode listadas na tabela a seguir. Categoria Descrição Ll Carta, Lowercase Lu Letra, maiúscula Lt Letra, título Lo Letra, outra Lm Letra, modificador Mn Marca, sem espaçamento Nd Número, dígito decimal Pc Pontuação, conector. Essa categoria inclui dez caracteres, o mais comumente usado deles é o LOWLINE (_), u+005F. Se o comportamento compatível com ECMAScript for especificado, \w será equivalente a [a-zA-Z_0-9]. Para obter informações sobre expressões regulares ECMAScript, consulte a seção "Comportamento de Correspondência ECMAScript" nas Opções de Expressão Regular. Observação Como ele corresponde a qualquer caractere de palavra, o elemento de linguagem \w é frequentemente usado com um quantificador lento se um padrão de expressão regular tenta corresponder a qualquer caractere de palavra várias vezes, seguido por um caractere de palavra específico. Para saber mais, confira Quantificadores. O exemplo a seguir usa o elemento de linguagem \w para corresponder a caracteres duplicados em uma palavra. O exemplo define um padrão de expressão regular, (\w)\1, que pode ser interpretado como a seguir. Elemento Descrição (\w) Corresponder a um caractere de palavra. Este é o primeiro grupo de captura. \1 Corresponder ao valor da primeira captura. C# using System; using System.Text.RegularExpressions; public class Example { public static void Main() { string pattern = @"(\w)\1"; string[] words = { "trellis", "seer", "latter", "summer", "hoarse", "lesser", "aardvark", "stunned" }; foreach (string word in words) { Match match = Regex.Match(word, pattern); if (match.Success) Console.WriteLine("'{0}' found in '{1}' at position {2}.", match.Value, word, match.Index); else Console.WriteLine("No double characters in '{0}'.", word); } } } // The example displays the following output: // 'll' found in 'trellis' at position 3. // 'ee' found in 'seer' at position 1. // 'tt' found in 'latter' at position 2. // 'mm' found in 'summer' at position 2. // No double characters in 'hoarse'. // 'ss' found in 'lesser' at position 2. // 'aa' found in 'aardvark' at position 0. // 'nn' found in 'stunned' at position 3. Caractere não pertencente a palavras: \W \W corresponde a qualquer caractere que não seja uma palavra. O elemento de linguagem \W é equivalente à seguinte classe de caracteres: [^\p{Ll}\p{Lu}\p{Lt}\p{Lo}\p{Nd}\p{Pc}\p{Lm}] Em outras palavras, ele corresponde a qualquer caractere, com exceção dos listados nas categorias de Unicode na tabela a seguir. Categoria Descrição Ll Carta, Lowercase Lu Letra, maiúscula Lt Letra, título Lo Letra, outra Lm Letra, modificador Mn Marca, sem espaçamento Nd Número, dígito decimal Pc Pontuação, conector. Essa categoria inclui dez caracteres, o mais comumente usado deles é o LOWLINE (_), u+005F. Se o comportamento compatível com ECMAScript for especificado, \W será equivalente a [^a-zA-Z_0-9]. Para obter informações sobre expressões regulares ECMAScript, consulte a seção "Comportamento de Correspondência ECMAScript" nas Opções de Expressão Regular. Observação Como ele corresponde a qualquer caractere não pertencente a palavras, o elemento de linguagem \W é frequentemente usado com um quantificador lento se um padrão de expressão regular tenta corresponder a qualquer caractere não pertencente a palavras várias vezes, seguido por um caractere não pertencente a palavras específico. Para saber mais, confira Quantificadores. O exemplo a seguir ilustra a classe de caracteres \W. Ele define um padrão de expressão regular, \b(\w+)(\W){1,2}, que corresponde a uma palavra seguida por um ou dois caracteres não pertencentes a palavras, como espaço em branco ou pontuação. A expressão regular é interpretada conforme mostrado na tabela a seguir. Elemento Descrição \b Começar a correspondência em um limite de palavra. (\w+) Fazer a correspondência a um ou mais caracteres de palavra. Este é o primeiro grupo de captura. (\W){1,2} Corresponde a um caractere não pertencente a palavras uma ou duas vezes. Este é o segundo grupo de captura. C# using System; using System.Text.RegularExpressions; public class Example { public static void Main() { string pattern = @"\b(\w+)(\W){1,2}"; string input = "The old, grey mare slowly walked across the narrow, green pasture."; foreach (Match match in Regex.Matches(input, pattern)) { Console.WriteLine(match.Value); Console.Write(" Non-word character(s):"); CaptureCollection captures = match.Groups[2].Captures; for (int ctr = 0; ctr < captures.Count; ctr++) Console.Write(@"'{0}' (\u{1}){2}", captures[ctr].Value, Convert.ToUInt16(captures[ctr].Value[0]).ToString("X4"), ctr < captures.Count - 1 ? ", " : ""); Console.WriteLine(); } } } // The example displays the following output: // The // Non-word character(s):' ' (\u0020) // old, // Non-word character(s):',' (\u002C), ' ' (\u0020) // grey // Non-word character(s):' ' (\u0020) // mare // Non-word character(s):' ' (\u0020) // slowly // Non-word character(s):' ' (\u0020) // walked // Non-word character(s):' ' (\u0020) // across // Non-word character(s):' ' (\u0020) // the // Non-word character(s):' ' (\u0020) // narrow, // Non-word character(s):',' (\u002C), ' ' (\u0020) // green // Non-word character(s):' ' (\u0020) // pasture. // Non-word character(s):'.' (\u002E) Como o objeto Group do segundo grupo de captura contém apenas um único caractere capturado não pertencente a palavras, o exemplo recupera todos os caracteres capturados não pertencentes a palavras do objeto CaptureCollection retornado pela propriedade Group.Captures. Caractere de espaço em branco: \s \s corresponde a um caractere de espaço em branco. É equivalente às sequências de escape e às categorias de Unicode listadas na tabela a seguir. Categoria Descrição \f O caractere de avanço de página, \u000C. \n O caractere de nova linha, \u000A. \r O caractere de retorno de carro, \u000D. \t O caractere de tabulação, \u0009. \v O caractere de tabulação vertical, \u000B. \x85 A elipse ou o caractere NEXT LINE (NEL) (...), \u0085. \p{Z} Corresponde a qualquer caractere separador. Se o comportamento compatível com ECMAScript for especificado, \s será equivalente a [ \f\n\r\t\v]. Para obter informações sobre expressões regulares ECMAScript, consulte a seção "Comportamento de Correspondência ECMAScript" nas Opções de Expressão Regular. O exemplo a seguir ilustra a classe de caracteres \s. Ele define um padrão de expressão regular, \b\w+(e)?s(\s|$), que corresponde a uma palavra que termina em “s” ou em “es” seguida por um caractere de espaço em branco ou pelo final da cadeia de caracteres de entrada. A expressão regular é interpretada conforme mostrado na tabela a seguir. Elemento Descrição \b Começar a correspondência em um limite de palavra. \w+ Fazer a correspondência a um ou mais caracteres de palavra. (e)? Corresponder a um “e” zero ou uma vez. s Corresponder a um “s”. (\s|$) Corresponder a um caractere de espaço em branco ou ao fim da cadeia de caracteres de entrada. C# using System; using System.Text.RegularExpressions; public class Example { public static void Main() { string pattern = @"\b\w+(e)?s(\s|$)"; string input = "matches stores stops leave leaves"; foreach (Match match in Regex.Matches(input, pattern)) Console.WriteLine(match.Value); } } // The example displays the following output: // matches // stores // stops // leaves Caractere diferente de espaço em branco: \S \S corresponde a qualquer caractere que não seja um caractere de espaço em branco. Ele é equivalente ao padrão de expressão regular [^\f\n\r\t\v\x85\p{Z}] ou o oposto do padrão de expressão regular equivalente a \s, o qual corresponde a caracteres de espaço em branco. Para saber mais, confira Caractere de espaço em branco: \s. Se o comportamento compatível com ECMAScript for especificado, \S será equivalente a [^ \f\n\r\t\v]. Para obter informações sobre expressões regulares ECMAScript, consulte a seção "Comportamento de Correspondência ECMAScript" nas Opções de Expressão Regular. O exemplo a seguir ilustra o elemento de linguagem \S. O padrão de expressão regular \b(\S+)\s? corresponde a cadeias de caracteres que são delimitadas por caracteres de espaço em branco. O segundo elemento no objeto GroupCollection da correspondência contém a cadeia de caracteres correspondida. A expressão regular pode ser interpretada conforme mostrado na tabela a seguir. Elemento Descrição \b Começar a correspondência em um limite de palavra. (\S+) Corresponder a um ou mais caracteres diferentes de espaço em branco. Este é o primeiro grupo de captura. \s? Corresponder a zero ou a um caractere de espaço em branco. C# using System; using System.Text.RegularExpressions; public class Example { public static void Main() { string pattern = @"\b(\S+)\s?"; string input = "This is the first sentence of the first paragraph. " + "This is the second sentence.\n" + "This is the only sentence of the second paragraph."; foreach (Match match in Regex.Matches(input, pattern)) Console.WriteLine(match.Groups[1]); } } // The example displays the following output: // This // is // the // first // sentence // of // the // first // paragraph. // This // is // the // second // sentence. // This // is // the // only // sentence // of // the // second // paragraph. Caractere de dígito decimal: \d \d corresponde a qualquer dígito decimal. É equivalente ao padrão de expressão regular \p{Nd}, o qual inclui os dígitos decimais padrão 0-9, bem como os dígitos decimais de vários outros conjuntos de caracteres. Se o comportamento compatível com ECMAScript for especificado, \d será equivalente a [0-9]. Para obter informações sobre expressões regulares ECMAScript, consulte a seção "Comportamento de Correspondência ECMAScript" nas Opções de Expressão Regular. O exemplo a seguir ilustra o elemento de linguagem \d. Ele testa se uma cadeia de caracteres de entrada representa um número de telefone válido nos Estados Unidos e no Canadá. O padrão de expressão regular ^(\(?\d{3}\)?[\s-])?\d{3}-\d{4}$ é definido conforme mostrado na tabela a seguir. Elemento Descrição ^ Começar a correspondência no início da cadeia de caracteres de entrada. \(? Corresponder a zero ou a um caractere "(" literal. \d{3} Corresponder a três dígitos decimais. \)? Corresponder a zero ou a um caractere ")" literal. [\s-] Corresponder a um hífen ou a caractere de espaço em branco. (\(?\d{3}\)?[\s-])? Corresponder a um parêntese de abertura opcional seguido por três dígitos decimais, um parêntese de fechamento opcional e um caractere de espaço em branco ou um hífen zero ou uma vez. Este é o primeiro grupo de captura. \d{3}-\d{4} Corresponder aos três dígitos decimais seguidos por um hífen e mais quatro dígitos decimais. $ Corresponder ao final da cadeia de caracteres de entrada. C# using System; using System.Text.RegularExpressions; public class Example { public static void Main() { string pattern = @"^(\(?\d{3}\)?[\s-])?\d{3}-\d{4}$"; string[] inputs = { "111 111-1111", "222-2222", "222 333-444", "(212) 111-1111", "111-AB1-1111", "212-111-1111", "01 999-9999" }; foreach (string input in inputs) { if (Regex.IsMatch(input, pattern)) Console.WriteLine(input + ": matched"); else Console.WriteLine(input + ": match failed"); } } } // The example displays the following output: // 111 111-1111: matched // 222-2222: matched // 222 333-444: match failed // (212) 111-1111: matched // 111-AB1-1111: match failed // 212-111-1111: matched // 01 999-9999: match failed Caractere que não seja dígito: \D \D corresponde a qualquer caractere que não seja um dígito. É equivalente ao padrão de expressão regular \P{Nd}. Se o comportamento compatível com ECMAScript for especificado, \D será equivalente a [^0-9]. Para obter informações sobre expressões regulares ECMAScript, consulte a seção "Comportamento de Correspondência ECMAScript" nas Opções de Expressão Regular. O exemplo a seguir ilustra o elemento de linguagem \D. Ele testa se uma cadeia de caracteres, como um número de peça, consiste na combinação apropriada de caracteres decimais e não decimais. O padrão de expressão regular ^\D\d{1,5}\D*$ é definido conforme mostrado na tabela a seguir. Elemento Descrição ^ Começar a correspondência no início da cadeia de caracteres de entrada. \D Corresponder a um caractere que não seja um dígito. \d{1,5} Corresponder a um a cinco dígitos decimais. \D* Corresponder a zero ou a um ou mais caracteres não decimais. $ Corresponder ao final da cadeia de caracteres de entrada. C# using System; using System.Text.RegularExpressions; public class Example { public static void Main() { string pattern = @"^\D\d{1,5}\D*$"; string[] inputs = { "A1039C", "AA0001", "C18A", "Y938518" }; foreach (string input in inputs) { if (Regex.IsMatch(input, pattern)) Console.WriteLine(input + ": matched"); else Console.WriteLine(input + ": match failed"); } } } // The example displays the following output: // A1039C: matched // AA0001: match failed // C18A: matched // Y938518: match failed Categorias gerais Unicode com suporte O Unicode define as categorias gerais listadas na tabela a seguir. Para obter mais informações, consulte os subtópicos "Formato de Arquivo UCD" e "Valores de Categoria Geral" no Banco de Dados de Caracteres Unicode, s. 5.7.1, Tabela 12. Categoria Descrição Lu Letra, maiúscula Ll Carta, Lowercase Lt Letra, título Lm Letra, modificador Lo Letra, outra L Todos os caracteres de letras. Isso inclui os caracteres Lu, Ll, Lt, Lm e Lo. Mn Marca, sem espaçamento Mc Marca, combinação de espaçamento Me Marca, delimitador M Todas as marcas de combinação. Isso inclui as categorias Mn, Mc e Me. Nd Número, dígito decimal Nl Número, letra No Número, outro N Todos os números. Isso inclui as categorias Nd, Nl e No. Pc Pontuação, conector Pd Pontuação, traço Ps Pontuação, abertura Pe Pontuação, fechamento Pi Pontuação, aspas iniciais (podem se comportar como Ps ou Pe, dependendo do uso) Pf Pontuação, aspas finais (podem se comportar como Ps ou Pe, dependendo do uso) Po Pontuação, outros P Todos os caracteres de pontuação. Isso inclui as categorias Pc, Pd, Ps, Pe, Pi, Pf e Po. Sm Símbolo, matemático Sc Símbolo, moeda Sk Símbolo, modificador So Símbolo, outros S Todos os símbolos. Isso inclui as categorias Sm, Sc, Sk e So. Zs Separador, espaço Zl Separador, linha Zp Separador, parágrafo Z Todos os caracteres de separador. Isso inclui as categorias Zs, Zl e Zp. Cc Outros, controle Cf Outros, formato Cs Outros, substitutos Co Outros, uso privado Cn Outro não atribuído ou não gráfico C Todos os outros caracteres. Isso inclui as categorias Cc, Cf, Cs, Co e Cn. Você pode determinar a categoria Unicode de qualquer caractere específico ao passar esse caractere para o método GetUnicodeCategory. O exemplo a seguir usa o método GetUnicodeCategory para determinar a categoria de cada elemento em uma matriz que contém caracteres latinos selecionados. C# using System; using System.Text.RegularExpressions; public class Example { public static void Main() { char[] chars = { 'a', 'X', '8', ',', ' ', '\u0009', '!' }; foreach (char ch in chars) Console.WriteLine("'{0}': {1}", Regex.Escape(ch.ToString()), Char.GetUnicodeCategory(ch)); } } // The example displays the following output: // 'a': LowercaseLetter // 'X': UppercaseLetter // '8': DecimalDigitNumber // ',': OtherPunctuation // '\ ': SpaceSeparator // '\t': Control // '!': OtherPunctuation Blocos nomeados compatíveis O .NET fornece os blocos nomeados listados na tabela a seguir. O conjunto de blocos nomeados com suporte baseia-se no Unicode 4.0 e no Perl 5.6. Para obter uma expressão regular que usa blocos nomeados, consulte a categoria Unicode ou o bloco Unicode: \p{} seção. Intervalo de ponto de código Nome do bloco 0000 - 007F IsBasicLatin 0080 - 00FF IsLatin-1Supplement 0100 - 017F IsLatinExtended-A 0180 - 024F IsLatinExtended-B 0250 - 02AF IsIPAExtensions 02B0 - 02FF IsSpacingModifierLetters 0300 - 036F IsCombiningDiacriticalMarks 0370 - 03FF IsGreek -ou- IsGreekandCoptic 0400 - 04FF IsCyrillic 0500 - 052F IsCyrillicSupplement 0530 - 058F IsArmenian 0590 - 05FF IsHebrew 0600 - 06FF IsArabic 0700 - 074F IsSyriac 0780 - 07BF IsThaana 0900 - 097F IsDevanagari 0980 - 09FF IsBengali 0A00 - 0A7F IsGurmukhi 0A80 - 0AFF IsGujarati 0B00 - 0B7F IsOriya 0B80 - 0BFF IsTamil 0C00 - 0C7F IsTelugu 0C80 - 0CFF IsKannada 0D00 - 0D7F IsMalayalam 0D80 - 0DFF IsSinhala 0E00 - 0E7F IsThai 0E80 - 0EFF IsLao 0F00 - 0FFF IsTibetan 1000 - 109F IsMyanmar 10A0 - 10FF IsGeorgian 1100 - 11FF IsHangulJamo 1200 - 137F IsEthiopic 13A0 - 13FF IsCherokee 1400 - 167F IsUnifiedCanadianAboriginalSyllabics 1680 - 169F IsOgham 16A0 - 16FF IsRunic 1700 - 171F IsTagalog 1720 - 173F IsHanunoo 1740 - 175F IsBuhid 1760 - 177F IsTagbanwa 1780 - 17FF IsKhmer 1800 - 18AF IsMongolian 1900 - 194F IsLimbu 1950 - 197F IsTaiLe 19E0 - 19FF IsKhmerSymbols 1D00 - 1D7F IsPhoneticExtensions 1E00 - 1EFF IsLatinExtendedAdditional 1F00 - 1FFF IsGreekExtended 2000 - 206F IsGeneralPunctuation 2070 - 209F IsSuperscriptsandSubscripts 20A0 - 20CF IsCurrencySymbols 20D0 - 20FF IsCombiningDiacriticalMarksforSymbols -ou- IsCombiningMarksforSymbols 2100 - 214F IsLetterlikeSymbols 2150 - 218F IsNumberForms 2190 - 21FF IsArrows 2200 - 22FF IsMathematicalOperators 2300 - 23FF IsMiscellaneousTechnical 2400 - 243F IsControlPictures 2440 - 245F IsOpticalCharacterRecognition 2460 - 24FF IsEnclosedAlphanumerics 2500 - 257F IsBoxDrawing 2580 - 259F IsBlockElements 25A0 - 25FF IsGeometricShapes 2600 - 26FF IsMiscellaneousSymbols 2700 - 27BF IsDingbats 27C0 - 27EF IsMiscellaneousMathematicalSymbols-A 27F0 - 27FF IsSupplementalArrows-A 2800 - 28FF IsBraillePatterns 2900 - 297F IsSupplementalArrows-B 2980 - 29FF IsMiscellaneousMathematicalSymbols-B 2A00 - 2AFF IsSupplementalMathematicalOperators 2B00 - 2BFF IsMiscellaneousSymbolsandArrows 2E80 - 2EFF IsCJKRadicalsSupplement 2F00 - 2FDF IsKangxiRadicals 2FF0 - 2FFF IsIdeographicDescriptionCharacters 3000 - 303F IsCJKSymbolsandPunctuation 3040 - 309F IsHiragana 30A0 - 30FF IsKatakana 3100 - 312F IsBopomofo 3130 - 318F IsHangulCompatibilityJamo 3190 - 319F IsKanbun 31A0 - 31BF IsBopomofoExtended 31F0 - 31FF IsKatakanaPhoneticExtensions 3200 - 32FF IsEnclosedCJKLettersandMonths 3300 - 33FF IsCJKCompatibility 3400 - 4DBF IsCJKUnifiedIdeographsExtensionA 4DC0 - 4DFF IsYijingHexagramSymbols 4E00 - 9FFF IsCJKUnifiedIdeographs A000 - A48F IsYiSyllables A490 - A4CF IsYiRadicals AC00 - D7AF IsHangulSyllables D800 - DB7F IsHighSurrogates DB80 - DBFF IsHighPrivateUseSurrogates DC00 - DFFF IsLowSurrogates E000 - F8FF IsPrivateUse ou IsPrivateUseArea F900 - FAFF IsCJKCompatibilityIdeographs FB00 - FB4F IsAlphabeticPresentationForms FB50 - FDFF IsArabicPresentationForms-A FE00 - FE0F IsVariationSelectors FE20 - FE2F IsCombiningHalfMarks FE30 - FE4F IsCJKCompatibilityForms FE50 - FE6F IsSmallFormVariants FE70 - FEFF IsArabicPresentationForms-B FF00 - FFEF IsHalfwidthandFullwidthForms FFF0 - FFFF IsSpecials Subtração de classes de caractere: [base_group - [excluded_group]] Uma classe de caracteres define um conjunto de caracteres. A subtração de classes de caracteres fornece um conjunto de caracteres que é o resultado da exclusão dos caracteres em uma classe de caracteres em outra classe de caracteres. A expressão de subtração de classes de caracteres tem a seguinte forma: [-[ base_group excluded_group]] Os colchetes ([]) e hífen (-) são obrigatórios. O base_group é um grupo de caracteres positivo ou um grupo de caracteres negativo. O componente excluded_group é outro grupo de caracteres positivos ou negativos ou outra expressão de subtração de classes de caracteres (ou seja, você pode aninhar expressões de subtração de classes de caracteres). Por exemplo, suponha que você tenha um grupo base que consiste no intervalo de caracteres de "a" a "z". Para definir o conjunto de caracteres que consiste no grupo base, exceto pelo caractere "m", use [a-z-[m]]. Para definir o conjunto de caracteres que consiste no grupo base, exceto pelo conjunto de caracteres "d", "j" e "p", use [a-z-[djp]]. Para definir o conjunto de caracteres que consiste no base consiste, exceto pelo intervalo de "m" a "p", use [a-z-[m-p]]. Considere a expressão de subtração de classes de caracteres aninhada, [a-z-[d-w-[m-o]]]. A expressão é calculada do intervalo de caracteres mais interno para fora. Primeiro, o intervalo de caracteres de "m" a "o" é subtraído do intervalo de caractere de "d" a "w", o que produz o conjunto de caracteres de "d" a "l" e "p" a "w". Esse conjunto é subtraído do intervalo de caracteres de "a" a "z", o que produz o conjunto de caracteres [abcmnoxyz]. Você pode usar qualquer classe de caracteres com a subtração de classes de caracteres. Para definir o conjunto de caracteres que consiste em todos os caracteres Unicode de \u0000 a \uFFFF, exceto caracteres de espaço em branco (\s), os caracteres na categoria geral de pontuação (\p{P}), os caracteres no bloco nomeado IsGreek (\p{IsGreek}) e o caractere de controle Unicode NEXT LINE (\x85), utilize [\u0000-\uFFFF-[\s\p{P}\p{IsGreek}\x85]]. Escolha classes de caracteres para uma expressão de subtração de classes de caracteres que produza resultados úteis. Evite uma expressão que gere um conjunto de caracteres vazio, que não podem corresponder a nada ou uma expressão equivalente ao grupo base original. Por exemplo, o conjunto vazio é o resultado da expressão [\p{IsBasicLatin}-[\x00-\x7F]], que subtrai todos os caracteres do intervalo de caracteres IsBasicLatin da categoria geral IsBasicLatin. Da mesma forma, o grupo base original é o resultado da expressão [a-z-[0-9]]. Isso ocorre, porque o grupo base, que é o intervalo de caracteres de letras de "a" a "z", não contém quaisquer caracteres no grupo excluído, que é o intervalo de caracteres de dígitos decimais de "0" a "9". O exemplo a seguir define uma expressão regular, ^[0-9-[2468]]+$, que corresponde aos dígitos zero e ímpares em uma cadeia de caracteres de entrada. A expressão regular é interpretada conforme mostrado na tabela a seguir. Elemento Descrição ^ Começar a correspondência no início da cadeia de caracteres de entrada. [0-9-[2468]]+ Corresponder a uma ou mais ocorrências de qualquer caractere de 0 a 9, com exceção de 2, 4, 6 e 8. Em outras palavras, corresponder a uma ou mais ocorrências de zero ou de um dígito ímpar. $ Finalizar a correspondência no final da cadeia de caracteres de entrada. C# using System; using System.Text.RegularExpressions; public class Example { public static void Main() { string[] inputs = { "123", "13579753", "3557798", "335599901" }; string pattern = @"^[0-9-[2468]]+$"; foreach (string input in inputs) { Match match = Regex.Match(input, pattern); if (match.Success) Console.WriteLine(match.Value); } } } // The example displays the following output: // 13579753 // 335599901 Confira também GetUnicodeCategory Linguagem de expressões regulares – referência rápida Opções de expressão regular ********************************************************************** Linguagem de expressões regulares – referência rápida Artigo 23/06/2022 13 minutos para o fim da leitura Uma expressão regular é um padrão ao qual o mecanismo de expressões regulares tenta corresponder no texto de entrada. Um padrão consiste em um ou mais literais de caracteres, operadores ou constructos. Para ver uma breve introdução, confira Expressões regulares no .NET. Cada seção desta referência rápida lista uma categoria específica de caracteres, operadores e constructos que podem ser usados para definir expressões regulares. Também fornecemos essas informações em dois formatos que você pode baixar e imprimir para facilitar a referência: Baixar no formato Word (.docx) Baixar no formato PDF (.pdf) Escapes de caracteres O caractere de barra invertida (\) em uma expressão regular indica que o próximo caractere é um caractere especial (conforme mostrado na tabela a seguir) ou se ele deve ser interpretado literalmente. Para obter mais informações, consulte Escapes de Caracteres. Caractere com escape Descrição Padrão Correspondências \a Corresponde a um caractere de sino, \u0007. \a "\u0007" em "Error!" + '\u0007' \b Em uma classe de caractere, corresponde a um backspace, \ u0008. [\b]{3,} "\b\b\b\b" em "\b\b\b\b" \t Corresponde a uma tabulação, \u0009. (\w+)\t "item1\t" e "item2\t" em "item1\titem2\t" \r Corresponde a um retorno de carro, \u000D. (\r não é equivalente ao caractere newline, \n.) \r\n(\w+) "\r\nThese" em "\r\nThese are\ntwo lines." \v Corresponde a uma tabulação vertical, \u000B. [\v]{2,} "\v\v\v" em "\v\v\v" \f Corresponde a um avanço de página, \u000C. [\f]{2,} "\f\f\f" em "\f\f\f" \n Corresponde a uma nova linha, \u000A. \r\n(\w+) "\r\nThese" em "\r\nThese are\ntwo lines." \e Corresponde a um escape, \u001B. \e "\x001B" em "\x001B" \Nnn Usa representação octal para especificar um caractere (nnn consiste em dois ou três dígitos). \w\040\w "a b" e "c d" em "a bc d" \xNn Usa representação hexadecimal para especificar um caractere (nn consiste exatamente em dois dígitos). \w\x20\w "a b" e "c d" em "a bc d" \cX \cx Corresponde ao caractere de controle ASCII especificado por X ou x, em que X ou x é a letra do caractere de controle. \cC "\x0003" em "\x0003" (Ctrl-C) \unnnn Corresponde a um caractere Unicode usando representação hexadecimal (exatamente quatro dígitos, como representado por nnnn). \w\u0020\w "a b" e "c d" em "a bc d" \ Quando seguido por um caractere que não é reconhecido como um caractere de escape nesta e em outras tabelas deste tópico, corresponde a esse caractere. Por exemplo, \* é igual a \x2A, e \. é igual a \x2E. Isso permite que o mecanismo de expressão regular desambiguate elementos de linguagem (como * ou ?) e literais de caracteres (representados por \* ou \?). \d+[\+-x\*]\d+ "2+2" e "3*9" em "(2+2) * 3*9" Classes de caracteres Uma classe de caractere corresponde a qualquer um dos conjuntos de caracteres. As classes de caracteres incluem os elementos de linguagem listados na tabela a seguir. Para saber mais, confira Classes de caracteres. Classe de caractere Descrição Padrão Correspondências [character_group] Corresponde a qualquer caractere único em character_group. Por padrão, a correspondência diferencia maiúsculas de minúsculas. [ae] "a" em "gray" "a" e "e" em "lane" [^character_group] Negação: corresponde a qualquer caractere único que não esteja em character_group. Por padrão, caracteres em character_group diferenciam maiúsculas de minúsculas. [^aei] "r", "g" e "n" em "reign" [Primeiro-Última] Intervalo de caracteres: corresponde a qualquer caractere único no intervalo do primeiro ao último. [A-Z] "A" e "B" em "AB123" . Curinga: corresponde a qualquer caractere único, exceto \n. Para corresponder a um caractere de período literal (ou \u002E), você deve precedê-lo com o caractere de escape (\.). a.e "ave" em "nave" "ate" em "water" \p{Nome} Corresponde a qualquer caractere único na categoria geral Unicode ou bloco nomeado especificado pelo nome. \p{Lu} \p{IsCyrillic} "C" e "L" em "City Lights" "Д" e "Ж" em "ДЖem" \P{Nome} Corresponde a qualquer caractere único que não esteja na categoria geral Unicode ou bloco nomeado especificado pelo nome. \P{Lu} \P{IsCyrillic} "i", "t" e "y" em "City" "e" e "m" em "ДЖem" \w Corresponde a qualquer caractere de palavra. \w "I", "D", "A", "1" e "3" em "ID A1.3" \W Corresponde a qualquer caractere que não seja palavra. \W " " e "." em "ID A1.3" \s Corresponde a qualquer caractere de espaço em branco. \w\s "D " em "ID A1.3" \S Corresponde a qualquer caractere de espaço não branco. \s\S " _" em "int __ctr" \d Corresponde a qualquer dígito decimais. \d "4" em "4 = IV" \D Corresponde a qualquer caractere que não seja um dígito decimal. \D " ", "=", " ", "I" e "V" em "4 = IV" Âncoras Âncoras ou asserções atômicas de largura zero, fazem com que uma correspondência tenha êxito ou falha dependendo da posição atual na cadeia de caracteres, mas não fazem com que o mecanismo avance na cadeia de caracteres ou consuma caracteres. Os metacaracteres listados na tabela a seguir são âncoras. Para saber mais, confira Âncoras. Asserção Descrição Padrão Correspondências ^ Por padrão, a correspondência precisa começar no início da cadeia de caracteres. No modo multilinha, precisa começar no início da linha. ^\d{3} "901" em "901-333-" $ Por padrão, a correspondência deve ocorrer no fim da cadeia de caracteres ou antes de \n no fim da cadeia de caracteres. No modo multilinha, deve antes do fim da linha ou antes de \n no fim da linha. -\d{3}$ "-333" em "-901-333" \A A correspondência deve ocorrer no início da cadeia de caracteres. \A\d{3} "901" em "901-333-" \Z A correspondência deve ocorrer no final da cadeia de caracteres ou antes de \n no final da cadeia de caracteres. -\d{3}\Z "-333" em "-901-333" \z A correspondência deve ocorrer no final da cadeia de caracteres. -\d{3}\z "-333" em "-901-333" \G A correspondência deve ocorrer no ponto em que a partida anterior terminou, ou se não houve nenhuma correspondência anterior, na posição na cadeia de caracteres em que a correspondência foi iniciada. \G\(\d\) "(1)", "(3)" e "(5)" em "(1)(3)(5)[7](9)" \b A correspondência deve ocorrer em um limite entre um caractere \w (alfanumérico) e um caractere \W (não alfanumérico). \b\w+\s\w+\b "them theme" e "them them" em "them theme them them" \B A correspondência não deve ocorrer em um limite \b. \Bend\w*\b "ends" e "ender" em "end sends endure lender" Constructos de agrupamento Os constructos de agrupamento delineiam subexpressões de uma expressão regular e, em geral, capturam subcadeias de caracteres de uma cadeia de caracteres de entrada. Os constructos de agrupamento incluem os elementos de linguagem listados na tabela a seguir. Para saber mais, confira Constructos de agrupamento. Constructo de agrupamento Descrição Padrão Correspondências (Subexpressão) Captura a subexpressão correspondente e atribui a ela um número ordinal com base um. (\w)\1 "ee" em "deep" (?Subexpressão) ou (?'Nome'Subexpressão) Captura a subexpressão correspondente em um grupo nomeado. (?\w)\k "ee" em "deep" (?Subexpressão) ou (?'name1-name2'Subexpressão) Especifica uma definição de grupo de balanceamento. Para saber mais, confira a seção "Definição de grupo de balanceamento" em Constructos de agrupamento. (((?'Open'\()[^\(\)]*)+((?'Close-Open'\))[^\(\)]*)+)*(?(Open)(?!))$ "((1-3)*(3-1))" em "3+2^((1-3)*(3-1))" (?:Subexpressão) Define um grupo de não captura. Write(?:Line)? "WriteLine" em "Console.WriteLine()" "Write" em "Console.Write(value)" (?imnsx-imnsx:Subexpressão) Aplica ou desabilita as opções especificadas em subexpressão. Para obter mais informações, consulte Opções de Expressão Regular. A\d{2}(?i:\w+)\b "A12xl" e "A12XL" em "A12xl A12XL a12xl" (?=Subexpressão) Asserções lookahead positivas de largura zero. \b\w+\b(?=.+and.+) "cats", "dogs" em "cats, dogs and some mice." (?!Subexpressão) Asserções lookahead negativas de largura zero. \b\w+\b(?!.+and.+) "and", "some", "mice" em "cats, dogs and some mice." (?<=Subexpressão) Asserção lookbehind positiva de largura zero. \b\w+\b(?<=.+and.+) ——————————— \b\w+\b(?<=.+and.*) "some", "mice" em "cats, dogs and some mice." ———————————— "and", "some", "mice" em "cats, dogs and some mice." (?Subexpressão) Grupo atômico. (?>a|ab)c "ac" Em"ac" nada em"abc" Soluções alternativas em um relance Quando o mecanismo de expressão regular atinge uma expressão solução alternativa, ele usa uma subcadeia de caracteres que alcança da posição atual até o início (lookbehind) ou final (lookahead) da cadeia de caracteres original e, em seguida, é executado Regex.IsMatch nessa subcadeia de caracteres usando o padrão de pesquisa. O sucesso do resultado dessa subexpressão é então determinado por se é uma afirmação positiva ou negativa. Solução alternativa Nome Função (?=check) Lookahead positivo Afirma que o que segue imediatamente a posição atual na cadeia de caracteres é "verificar" (?<=check) Lookbehind positivo Afirma que o que precede imediatamente a posição atual na cadeia de caracteres é "verificar" (?!check) Lookahead negativo Afirma que o que segue imediatamente a posição atual na cadeia de caracteres não é "verificar" (? Referência inversa nomeada. Corresponde ao valor de uma expressão nomeada. (?\w)\k "ee" em "seek" Construtores de alternância Os constructos de alternância modificam uma expressão regular para habilitar uma correspondência do tipo um/ou outro. Esses constructos incluem os elementos de linguagem listados na tabela a seguir. Para saber mais, confira Constructos de alternância. Constructo de alternância Descrição Padrão Correspondências | Corresponde a qualquer elemento separado pelo caractere de barra vertical (|). th(e|is|at) "the" e "this" em "this is the day." (?(Expressão)Sim|Não) ou (?(Expressão)Sim) Corresponde a yes se o padrão de expressão regular designado por expression for correspondente. Do contrário, corresponde à parte no opcional. expressão é interpretado como uma asserção de largura zero. Para evitar ambiguidade com um grupo de captura nomeado ou numerado, você pode usar opcionalmente uma declaração explícita, como esta: (?( (?=Expressão) )Sim|Não) (?(A)A\d{2}\b|\b\d{3}\b) "A10" e "910" em "A10 C103 910" (?(Nome)Sim|Não) ou (?(Nome)Sim) Corresponde a yes se name, um grupo de captura nomeado ou numerado, apresenta uma correspondência. Do contrário, corresponde a no opcional. (?")?(?(quoted).+?"|\S+\s) "Dogs.jpg " e "\"Yiska playing.jpg\"" em "Dogs.jpg \"Yiska playing.jpg\"" Substituições As substituições são elementos de linguagem de expressões regulares com suporte em padrões de substituição. Para saber mais, confira Substituições. Os metacaracteres listados na tabela a seguir são asserções atômicas de largura zero. Caractere Descrição Padrão Padrão de substituição Cadeia de caracteres de entrada Cadeia de caracteres de resultado $Número Substitui a subcadeia de caracteres correspondida pelo grupo number. \b(\w+)(\s)(\w+)\b $3$2$1 "one two" "two one" ${Nome} Substitui a substring de caracteres correspondida pelo grupo chamado nome. \b(?\w+)(\s)(?\w+)\b ${word2} ${word1} "one two" "two one" $$ Substitui um literal "$". \b(\d+)\s?USD $$$1 "103 USD" "$103" $& Substitui uma cópia da correspondência inteira. \$?\d*\.?\d+ **$&** "$1.30" "**$1.30**" $` Substitui todo o texto da cadeia de caracteres de entrada antes da correspondência. B+ $` "AABBCC" "AAAACC" $' Substitui todo o texto da cadeia de caracteres de entrada após a correspondência. B+ $' "AABBCC" "AACCCC" $+ Substitui o último grupo que foi capturado. B+(C+) $+ "AABBCCDD" "AACCDD" $_ Substitui a cadeia de caracteres de entrada inteira. B+ $_ "AABBCC" "AAAABBCCCC" Opções de expressões regulares Você pode especificar opções que controlam como o mecanismo de expressões regulares interpreta uma expressão regular padrão. Muitas dessas opções podem ser especificadas de maneira embutida (no padrão da expressão regular) ou como uma ou mais constantes RegexOptions. Essa referência rápida lista somente as opções embutidas. Para obter mais informações sobre opções embutidas e RegexOptions, consulte o artigo Opções de expressões regulares. É possível especificar uma opção embutida de duas formas: Usando a construção(?imnsx-imnsx) diversa, em que um sinal de menos (-) antes de uma opção ou conjunto de opções desativa essas opções. Por exemplo, (?i-mn) ativa a correspondência sem diferenciação de maiúsculas e minúsculas (i), desativa o modo de várias linhas (m) e desativa capturas de grupo sem nome (n). A opção se aplica ao padrão de expressão regular no ponto em que a opção é definida e entra em vigor no final do padrão ou no ponto em que outro constructo inverte a opção. Usando asubexpressão de construção)(?imnsx-imnsx: de agrupamento, que define as opções somente para o grupo especificado. O mecanismo de expressão regular do .NET dá suporte às seguintes opções embutidas: Opção Descrição Padrão Correspondências i Use correspondência sem diferenciação de maiúsculas e minúsculas. \b(?i)a(?-i)a\w+\b "aardvark" e "aaaAuto" em "aardvark AAAuto aaaAuto Adam breakfast" m Use o modo multilinha. ^ e $ correspondem ao início e ao fim de uma linha em vez do início e fim de uma cadeia de caracteres. Para obter um exemplo, consulte a seção "Modo multilinha" nas Opções de Expressão Regular. n Não capture grupos sem nome. Para obter um exemplo, consulte a seção "Somente Capturas Explícitas" nas Opções de Expressão Regular. s Use o modo de linha única. Para obter um exemplo, consulte a seção "Modo de linha única" nas Opções de Expressão Regular. x Ignore espaços em branco sem escape no padrão da expressão regular. \b(?x) \d+ \s \w+ "1 aardvark" e "2 cats" em "1 aardvark 2 cats IV centurions" Constructos diversos Os constructos diversos modificam um expressão regular padrão ou fornecem informações sobre ela. A tabela a seguir lista os constructos diversos que têm suporte no .NET. Para saber mais, confira Constructos diversos. Constructo Definição Exemplo (?imnsx-imnsx) Define ou desabilita opções como não diferenciação de maiúsculas e minúsculas no meio de um padrão. Para saber mais, confira Opções de expressão regular. \bA(?i)b\w+\b corresponde a "ABA" e "Able" em "ABA Able Act" (?#Comentário) Comentário embutido. O comentário é encerrado no primeiro caractere de fechar parênteses. \bA(?#Matches words starting with A)\w+\b # [até o final da linha] Comentário do modo X. O comentário começa em um # sem escape e continua até o final da linha. (?x)\bA\w+\b#Matches words starting with A ********************************************************************************* Regex caracteres especiais obrigatório Perguntada 3 anos, 7 meses atrás Modified 1 ano, 3 meses atrás Vista 12mil vezes 0 Preciso criar um regex para validar senha. Ela deverá conter no mínimo 8 caracteres, dos quais deve possuir no mínimo 1 letra, 1 número e 1 caractere especial. java android regex Compartilhar Melhore esta pergunta Seguir editada 1/12/2018 às 10:03 user avatar hkotsubo 61mil2323 medalhas de ouro6969 medalhas de prata127127 medalhas de bronze perguntada 1/12/2018 às 0:20 user avatar Marcelo 1111 medalhas de ouro11 medalhas de prata44 medalhas de bronze 1 Marcelo, acredito que esse tipo de pergunta já tenha sido respondida dezenas de vezes e você pode encontrar a resposta no Google. Veja esse link – Andre 1/12/2018 às 1:18 2 Leitura obrigatória para quem é da área: xkcd.com/936 ; se deseja usar esse esquema de segurança, saiba que ele é falido por definição. O único jeito de garantir que a entropia da senha a torne forte contra ataques brutos é com o seu tamanho. A força para quebrar uma senha de d dígitos sobre um alfabeto de A caracteres distintos é O(A**d); daí, se você apenas subir o A, o quanto que você ganha de complexidade é minguante perante o aumento na quantidade de dígitos – Jefferson Quesado 1/12/2018 às 3:36 Não é exatamente o que vc quer (é quase) mas já dá pra ter uma ideia: pt.stackoverflow.com/a/337981/112052 - e sobre caracteres especiais: pt.stackoverflow.com/a/342737/112052 – hkotsubo 1/12/2018 às 10:01 o que você considera um caractere especial amigo? poderia listar alguns exemplos? – Paz 6/12/2018 às 15:08 Obrigado pessoal – Marcelo 14/08/2019 às 15:09 Adicione um comentário 2 Respostas Ordenado por: 1 Regex Usada Essa regex faz a validação, você pode testa-la aqui: (?=.*[}{,.^?~=+\-_\/*\-+.\|])(?=.*[a-zA-Z])(?=.*[0-9]).{8,} Lembrando que você deve usar duplo escape aonde tem o caractere \, então no código Java todos as barras invertidas devem ser duplas, ficando \\. Aplicação no código Java No código Java você pode fazer a validação com String.matches, do jeito que mostrei abaixo: public class JavaFiddle { public static void main(String[] args) { System.out.println("A{123456".matches("(?=.*[}{,.^?~=+\\-_\\/*\\-+.\\|])(?=.*[a-zA-Z])(?=.*[0-9]).{8,}")); //exemplo que passa System.out.println("ASD1ASDA".matches("(?=.*[}{,.^?~=+\\-_\\/*\\-+.\\|])(?=.*[a-zA-Z])(?=.*[0-9]).{8,}")); //exemplo que nao passa (falta caractere especial) System.out.println("ASDAS^^?".matches("(?=.*[}{,.^?~=+\\-_\\/*\\-+.\\|])(?=.*[a-zA-Z])(?=.*[0-9]).{8,}")); //exemplo que nao passa (falta numero) System.out.println("123^8542".matches("(?=.*[}{,.^?~=+\\-_\\/*\\-+.\\|])(?=.*[a-zA-Z])(?=.*[0-9]).{8,}")); //exemplo que nao passa (falta letra) System.out.println("WWEA^^1".matches("(?=.*[}{,.^?~=+\\-_\\/*\\-+.\\|])(?=.*[a-zA-Z])(?=.*[0-9]).{8,}")); //exemplo que nao passa (nao tem minimo de 8 caracteres) } } Este código exibe true no console quando for um padrão válido, e false para padrões inválidos. Você pode testar esse código no JavaFiddle como eu fiz também, só copiar e colar o código dessa resposta. OBS: Como não foi especificado quais seriam os caracteres especiais eu utilizei como válidos os seguintes caracteres (,.^?~=+-_/*\+) Você pode alterar os caracteres que entram como caracteres especiais nessa parte da regex: (?=.*[}{,.^?~=+\-_\/*\-+.\|]), só não retire a parte (?= ... ), pois isso sinaliza um positive lookahead, que é necessário para validar que existe pelo menos um dos caracteres sinalizados no grupo antes de iniciar a captura. Explicação da Regex (?=.*...) - É um positive lookahead que irá garantir que o grupo de caracteres a seguir DEVE estar na string para que ela seja validada. [}{,.^?~=+\-_\/*\-+.\|] - É o set que define quais caracteres podem ser capturados pelo positive lookahead. (?=.*...) - É um positive lookahead que irá garantir que o grupo de caracteres a seguir DEVE estar na string para que ela seja validada. [a-zA-Z] - É o set que caracteriza qualquer caractere de letra sendo maiúscula ou minúscula. (?=.*...) - É um positive lookahead que irá garantir que o grupo de caracteres a seguir DEVE estar na string para que ela seja validada. [0-9] - É o set que caracteriza qualquer número entre 0 e 9. .{8,} - Após essas validações, será capturado uma sequencia de qualquer caractere que não contenha quebra de linhas(sinalizado pelo .). E que seja de comprimento mínimo de 8 caracteres (sinalizado pelo {8,}), sem limite máximo (caso queira definir um limite você pode colocar o número máximo de caractere após a ,). EDITADO Obrigado ao usuário @hkotsubo por me avisar do meu erro Compartilhar Melhore esta resposta Seguir editada 6/12/2018 às 17:29 respondida 6/12/2018 às 16:17 user avatar Paz 3.14211 medalhas de ouro1111 medalhas de prata3838 medalhas de bronze Na verdade o . aceita espaços sim, veja aqui. E aceita qualquer outro caractere que não foi especificado anteriormente: regex101.com/r/8rtOcc/2 (não que isso seja problema, já que a pergunta não deixa claro o que é pra ter ou não) – hkotsubo 6/12/2018 às 16:47 1 @hkotsubo aí você me pegou kkk, eu quis dizer quebra de linha, erro meu. Vou corrigir. – Paz 6/12/2018 às 17:27 1 É, por padrão o . não considera quebras de linha. Mas - por curiosidade - é possível fazer com que considere, usando a opção DOTALL: ideone.com/rAxncr – hkotsubo 6/12/2018 às 17:34 Top muito obrigado! – Marcelo 14/08/2019 às 15:08 @Marcelo considere marcar a resposta como correta, se ela te respondeu a duvida inicial – Paz 14/08/2019 às 16:54 Adicione um comentário 0 Boa tarde. Estou usando o FluentValidation e fiz algumas validações para senha hoje. Vê se isso te ajuda (Caso tive alguma dúvida do código me fale): using FluentValidation; using System.Linq; using System.Text.RegularExpressions; namespace SaleTheaterTickets.Models.ViewModelValidators { public class RegisterViewModelValidator : AbstractValidator { public RegisterViewModelValidator() { RuleFor(x => x.Email) .NotEmpty().WithMessage("Informe o e-mail") .EmailAddress().WithMessage("Digite um e-mail válido (ana@gmail.com)"); RuleFor(x => x.Password) .NotEmpty().WithMessage("Informe a senha") .Length(6, 20).WithMessage("Senha deve ter no mínimo 6 e no máximo 20 caractéres") .Must(RequireDigit).WithMessage("Senha deve ter pelo menos 1 número") .Must(RequiredLowerCase).WithMessage("Senha deve ter pelo menos 1 caracter minúsculo") .Must(RequireUppercase).WithMessage("Senha deve ter pelo menos 1 caracter maiúsculo") .Must(RequireNonAlphanumeric).WithMessage("Digite pelo menos 1 caracter especial (@ ! & * ...)"); RuleFor(x => x.ConfirmPassword) .NotEmpty().WithMessage("Confirme a senha") .Equal(x => x.Password).WithMessage("Senhas não conferem"); } private bool RequireDigit(string password) { if (password.Any(x => char.IsDigit(x))) { return true; } return false; } private bool RequiredLowerCase(string password) { if (password.Any(x => char.IsLower(x))) { return true; } return false; } private bool RequireUppercase(string password) { if (password.Any(x => char.IsUpper(x))) { return true; } return false; } private bool RequireNonAlphanumeric(string password) { //if (password.Any(x => char.IsSymbol(x))) //{ // return true; //} //return false; if (Regex.IsMatch(password, "(?=.*[@#$%^&+=])")) { return true; } return false; } } } OBS: Os métodos estão inglês, mas eles servem para o seguinte: RequireDigit - pelo menos 1 número na senha RequiredLowerCase - pelo menos 1 letra minúscula na senha RequireUppercase - pelo menos 1 letra maiúscula na senha RequireNonAlphanumeric - pelo menos um caractere especial na senha OBS: O Asp.Net Core Identity já faz essas verificações, porém eu não estava conseguindo traduzir as mensagens que vinham como padrão, então peguei e criei cada validação por conta própria (seguindo as validações que vi na documentação que o Identity faz para senha) para poder gerar minhas frases em português. Espero que te ajude de alguma forma! ************************************************************************* Expressões regulares: introdução Idéia básica Uma expressão regular é uma notação para representar padrões em strings. Serve para validar entradas de dados ou fazer busca e extração de informações em textos. Por exemplo, para verificar se um dado fornecido é um número de 0,00 a 9,99 pode-se usar a expressão regular \d,\d\d, pois o símbolo \d é um curinga que casa com um dígito. O verbo casar aqui está sendo usado tradução para match, no sentido de combinar, encaixar, parear. Dizemos que a expressão \d,\d\d casa com 1,23 mas não casa com 123 (falta a vírgula) nem com 1,2c (“c” não casa com \d, porque não é um dígito). O termo em inglês é regular expression de onde vem as abreviações regex e re (o nome do módulo Python). Na ciência da computação, o termo tem um significado bem específico (veja expressão regular no Glossário). Algums exemplos Veja alguns exemplos com breves explicações para ter uma idéia geral: \d{5}-\d{3} O padrão de um CEP como 05432-001: 5 dígitos, um - (hífen) e mais 3 dígitos. A sequência \d é um metacaractere, um curinga que casa com um dígito (0 a 9). A sequência {5} é um quantificador: indica que o padrão precedente deve ser repetido 5 vezes, portanto \d{5} é o mesmo que \d\d\d\d\d. [012]\d:[0-5]\d Semelhante ao formato de horas e minutos, como 03:10 ou 23:59. A sequência entre colchetes [012] define um conjunto. Neste caso, o conjunto especifica que primeiro caractere deve ser 0, 1 ou 2. Dentro dos [] o hífen indica uma faixa de caracteres, ou seja, [0-5] é uma forma abreviada para o conjunto [012345]; o conjunto que representa todos os dígitos, [0-9] é o mesmo que \d. Note que esta expressão regular também aceita o texto 29:00 que não é uma hora válida (horas válidas serão o tema de um dos Exercícios). [A-Z]{3}-\d{4} É o padrão de uma placa de automóvel no Brasil: três letras de A a Z é seguidas de um - (hífen) seguido de quatro dígitos, como CKD-4592. Sobre os sinais «» usados neste texto Ao descrever de modo genérico alguma parte da sintaxe das expressões regulares usamos neste documento os símbolos «», para indicar uma parte que deve ser fornecida pelo usuário. Por exemplo, a referência a um grupo tem a sintaxe \«n» onde «n» é o número do grupo a ser recuperado. Os sinais «» não fazem parte da sintaxe, então a referência ao terceiro grupo escreve-se como \3. De modo semelhante, a sintaxe de quantificador moderado é «q»?, onde «q» é qualquer quantificador, como * em *? ou {1,3} no caso de {1,3}?. Metacaracteres Um metacaractere é um caractere ou sequência de caracteres com significado especial em expressões regulares. Os metacaracteres podem ser categorizados conforme seu uso. Especificadores Especificam o conjunto de caracteres a casar em uma posição. metacaractere conhecido como significado . curinga qualquer caractere, exceto a quebra de linha \n (ver flag_dotall) [...] conjunto qualquer caractere incluido no conjunto [^...] conjunto negado qualquer caractere não incluido no conjunto \d dígito o mesmo que [0-9] \D não-digíto o mesmo que [^0-9] \s branco espaço, quebra de linha, tabs etc.; o mesmo que [ \t\n\r\f\v] \S não-branco o mesmo que [^ \t\n\r\f\v] \w alfanumérico o mesmo que [a-zA-Z0-9_] (mas pode incluir caracteres Unicode; ver flag_unicode) \W não-alfanumérico o complemento de \w \ escape anula o significado especial do metacaractere seguinte; por exemplo, \. representa apenas um ponto, e não o curinga Quantificadores Definem o número permitido repetições da expressão regular precedente. metacaractere significado {n} exatamente n ocorrências {n,m} no mínimo n ocorrências e no máximo m {n,} no mínimo n ocorrências {,n} no máximo n ocorrências ? 0 ou 1 ocorrência; o mesmo que {,1} + 1 ou mais ocorrência; o mesmo que {1,} * 0 ou mais ocorrência «q»? modera qualquer um dos quantificadores acima (ver Gula × moderação) Veja o grupo de exercícios 1. Especificadores e quantificadores. Âncoras Estabelecem posições de referência para o casamento do restante da regex. Note que estes metacaracteres não casam com caracteres no texto, mas sim com posições antes, depois ou entre os caracteres. metacaractere significado ^ início do texto, ou de uma linha com o flag re.MULTILINE \A início do texto $ fim do texto, ou de uma linha com o flag re.MULTILINE; não captura o \n no fim do texto ou da linha \Z fim do texto \b posição de borda, logo antes do início de uma palavra, ou logo depois do seu término; o mesmo que a posição entre \W e \w ou vice-versa \B posição de não-borda Veja o grupo de exercícios 2. Âncoras. Agrupamento Definem ou grupos ou alternativas. metacaractere significado (...) define um grupo, para efeito de aplicação de quantificador, alternativa ou de posterir extração ou re-uso ...|... alternativa; casa a regex à direita ou à esquerda \«n» recupera o texto casado no n-ésimo grupo Gula × moderação Por default, todos os quantificadores são gulosos: tentam casar a maior quantidade possível de caracteres. Para entender o que isso significa, considere que desejamos capturar o nome do primeiro tag (h1) no fragmento de HTML abaixo: >>> html = '

Alan Turing: 100 anos

' Usando o quantificador guloso +, acabamos por capturar o elemento inteiro, e não apenas o tag: >>> res = re.match('<.+>', html) >>> res.group() '

Alan Turing: 100 anos

' O resultado acima ocorre porque o sinal > casa em duas posições no texto, e casando na segunda posição o curinga guloso .+ captura mais caracteres. Se usamos o quantificador moderado +?, a expressão .+? fica satisfeita em capturar apenas os caracteres até o primeiro casamento de >: >>> res = re.match('<.+?>', html) >>> res.group() '

' ************************************************************************************* Smart Rules RegExp Expressões regulares, também conhecidas como RegEx ou RegExp são usadas para englobar um padrão de caracteres usando alguns caracteres especiais. Na GoCache, é possível utilizas essas expressões em alguns critérios das smart rules para que elas possam englobar situações mais complexas. Caracteres especiais nas expressões regulares Asterisco *: O asterisco aceita qualquer caractere qualquer número de vezes, importante saber que a GoCache interpreta o * como seria interpretado um .* no regex comum, exemplos de uso: Critério URL: /* URLs aceitos: / , /teste1 , /qualquer/coisa , /13/21fas/nkfasfp4242 Critério URL: /abc/*/def/ URLs aceitos: /abc//def/ , /abc/xyz/def/ , /abc/g/e/p/def/ URLs não aceitos: /abc/def/ , /abcdef/ , /ac//df/ Ponto .: O ponto é usado para especificar qualquer caractere uma vez. Exemplos de uso: Critério URL: /. URLs aceitos: /a , /1 , // URLs não aceitos: / , /ab , /12 Critério URL: /.teste.. URLs aceitos: /1testeab , /oteste/a URLs não aceitos: /teste , /testeabc Colchetes []: Os colchetes são usados para especificar um grupo de caracteres que serão aceitos, esses grupos podem ser ou alguns caracteres especificados ou uma série de caracteres separados por um - como por exemplo [a-z] para ter todos os caracteres de a até z. Exemplos de uso: Critério URL: /[abc][A1p] URLs aceitos: /aA , /c1 , /bp , /cA URLs não aceitos: /Aa , /aa , /aAa Critério URL: /[a-z][1-9][A-Z] URLs aceitos: /b2T , /x1B , /t9Z URLs não aceitos: /A1a , /bds Parênteses (): Os parênteses definem um grupo com uma expressão, diferente dos colchetes, os grupos definidos pelos parênteses atuam como uma expressão completa. Exemplos de uso: Critério URL: /t(est)e URLs aceitos: /teste URLs não aceitos: /tse , /tee , /ttsee Pipe |: O pipe é usado como um OU, ele aceita qualquer uma das duas expressões separadas por ele, normalmente utilizado com os parenteses. Exemplos de uso: Critério URL: /(admin|wp-admin)/ URLs aceitos: /admin/ , /wp-admin/ URLs não aceitos: /adminwp-admin/ , /admin-wp/ Critério URL: /(teste1|admin|segredo|) URLs aceitos: /teste1 , /admin , /segredo , / URLs não aceitos: /teste1admin , /adminsegredo , /qualqueroutracoisa Chaves {}: As chaves definem quantas vezes uma expressão deve aparecer, podendo ser definida uma série de quantidades separadas por uma vírgula (,) como por exemplo {5,7}. Exemplos de uso: Critério URL: /(ab){1,3}/ URLs aceitos: /ab , /abab , /ababab URLs não aceitos: /abababab , /aaa Critério URL: /[a-z]{5} URLs aceitos: /abcde , /teste , /admin URLs não aceitos: /abc , /testee , /az Sinal de adição +: O sinal de adição define que uma expressão pode aparecer uma ou mais vezes. Exemplos de uso: Critério URL: /(ab)+/ URLs aceitos: /ab , /abab , /ababab , /ababababababababab URLs não aceitos: /abababa , / , /aaaaaaa Critério URL: /[a-z]+ URLs aceitos: /abcde , /testeteste , /adminaaaaaaa , /yz URLs não aceitos: /123 , /ABC Barra invertida \: A barra invertida é usada para usar o caractere literal, tirando a característica de caractere especial, por exemplo, ao usar o \. o ponto perde sua característica de aceitar qualquer caractere e aceita apenas um ponto mesmo. Exemplos de uso: Critério URL: /imagem\.jpg URLs aceitos: /imagem.jpg URLs não aceitos: /imagemajpg , /imagem1jpg Critério URL: /*\.(css|js) URLs aceitos: /script.js , /style.css URLs não aceitos: /scriptjs , /stylecss Ponto de interrogação ?: O ponto de interrogação é usado para definir que pode ter ou não uma expressão especificada. Exemplos de uso: Critério Cabeçalho de requisição: Teste:(te)?ste Cabeçalhos aceitos: Teste:ste , Teste:teste Cabeçalhos não aceitos: Teste:tste , Teste: Critério Cabeçalho de requisição: Referer:https?://(*\.)?exemplo.com/ Cabeçalhos aceitos: Referer:http://exemplo.com/ , Referer:https://www.exemplo.com/ Cabeçalhos não aceitos: Referer:httpa://exemplo.com/ , Referer:https://aaaexemplo.com/ Cifrão $: O Cifrão é usado em ações ao invés de critérios, o Cifrão pega uma expressão que foi encontrada no critério e aplica essa expressão como uma variável na ação, dependendo da ordem que foram encontradas as expressões. Exemplos de uso: Critério URL: http://exemplo.com/* Acão de redirecionamento: https://exemplo.com/$1 Nesse caso se o url for http://exemplo.com/teste o redirecionamento será para https://exemplo.com/teste Critério URL: http://exemplo.com/([a-z]+)([1-9]+) Acão de redirecionamento: https://exemplo.com/$2$1 Nesse caso se o url for http://exemplo.com/teste123 o redirecionamento será para https://exemplo.com/123teste Caracteres específicos Nulo -: Esse caractere significa um valor vazio, funciona apenas para os critérios: User Agent e Referer Host. Se esse caractere for definido em um desses dois critérios, significa que ele aceitará um User Agent ou Referer Host sem nada. Exemplo de uso: Critério User Agent: - User Agent aceito: Negação !: Esse caractere informa "tudo menos",funciona apenas para os critérios: User Agent; Referer Host e País. Exemplo de uso: Critério User Agent: !abc User Agent NÃO aceito: abc Ambos os caracteres podem ser usados em conjunto com outros caracteres regex conforme mostra o exemplo abaixo: Critério User Agent: !(abc[12]|-) User Agents NÃO aceitos: abc1 , , abc2 Funcionamento de caracteres por critério Importante reforçar que alguns caracteres não funcionam como expressões regulares para alguns critérios, aqui a lista de quais caracteres funcionam como expressões regulares para cada critério de smart rule: Caracteres especiais que funcionam como regex por critério (Critério - Caracteres): URL - Asterisco, Ponto, Colchetes, Parênteses, Pipe, Chaves, Sinal de adição e Barra invertida. Conteúdo de Cookie - Todos os caracteres comuns são aceitos (Nesse critério o asterisco é considerado como aceitar o último caractere qualquer número de vezes, para usá-lo como ele é usado em outros critérios use .*) Cookies - Ponto e Asterisco User Agent - Todos os caracteres funcionam HTTP Referer - Todos os caracteres funcionam Cabeçalho de requisição - Todos os caracteres comuns funcionam País de Origem - Pipe e negação Endereço de IP ou Range - Nenhum funciona Ações que aceitam o Cifrão($) como expressão regular: As seguintes ações aceitam o Cifrão($), como uma expressão regular conforme explicado anteriormente: URL de destino e Sobrescreve URI. Exemplos de uso de regex nas smart rules Alguns exemplos de como os caracteres especiais podem trabalhar em conjunto para criar algumas regras avançadas: Redirecionamento de http para https redirect Critério URL: http://exemplo.com.br Ação redirecionar URL: https://$1exemplo.com.br$2 Essa regra redireciona todo tráfego http de qualquer subdomínio para https. Os wildcards pegam qualquer subdomínio e qualquer caminho com os cifrões, as informações encontradas são recolocadas no url com https. CORS específico para algumas origens redirect Critério URL: /imagem.png Critério cabeçalho de requisição: Origin:https?://(*\.)?quero-uma\.imagem Ação Define Cross-Origin: * Essa regra retorna o wildcard para o cabeçalho CORS apenas para as origens que se encaixam no regex, o regex aceitará http ou https graças ao ? depois do s, além disso ele aceitará qualquer subdomínio de quero-uma.imagem graças ao (*\.), que aceita qualquer número de caracteres antes do ponto, além disso, é necessária uma \ antes do ponto para poder aceitar o ponto ao invés de qualquer caractere. ************************************************************************************************************
99-ganhar-dinheiro

99pay-ou-sofisa

99pay

alimentos-inflamatorios

almoco-domingo-estado-mes-ano

alura-ou-udemy

alura

apenas-o-e-mail-dado-pessoal-lgpd

apostas-online

atualizacao-para-mysqli

aumentar-acessos-com-sites-similares

bootstrap-vs-wordpress

borda-tabela-css

buffer-logger

calcular-onde-investir-me-tempo-em-conteudo

cancelar-compra-multiproprieadade

caractere-invisivel-whatsapp

caracteres-especiais-html

centraliza-html

centralizar-icone-svg

coisas-de-manaus

colecionador-disco-vinil

colocar-site-google-discovery

concurso-publico-ti-2023

configurar-outlook-servidor

consulta-sql-php-8

conteudo-provas-clinicas

cores-html

corrigindo-erro-php

curiosidade

curriculo-programador-web

cursos

dar-permissao-pasta-remota-php

decoracao-com-disco-de-vinil

dinheiro-cartoes-investimentos-fintechs

disco-de-vinil-roberto-carlos

disco-de-vinil

disco-vinil-usado-antigo

discos-amazon

discos-antigos

discos-mais-procurados-colecionadores

disder

do-que-e-feito

editor-de-video-online-gratis

email-dado-pessoal-lgpd

erro-arquivo-xml-atom

espaco-imagem-css

explicando-dinheiro-cartao-de-credito

faixa-etaria-viagem

fazer-agrupamento-sql-por-todos-campos-com-mesmo-termo

fazer-antes-de-viajar

fechar-modal

filtro-psl152

forcar-arquivo-pdf-abrir-apenas-em-iframe

forcar-pdf-apenas-iframe

formulario-lead-autorizacao-lgpd

formulario-para-registro-de-lead

foto-smartwatch

frases-curiosas

front-end-linguagens

funcao-mysql

furada

gerencia-de-projetos-2015

google-ad-manager

htaccess-nao-funciona-no-host

icone-svg

if-ternario-php

imagem-escondida

impedir-link-form

include-dentro-echo-php

inteligencia-artificial

iron-man-black-sabbath

jogo-do-tigrinho

joinads

legendas-youtube

limitar-numeros-input-python

link-interno-seo

links-do-adsense-que-as-pessoas-estao-clicando

matrix-internet

matrix-reserva

matrix

medicamentos

melhores-a-piores-praias-de-salvador

melhores-capitais-para-viajar

melhores-destinos-para-viajar-baixa-temporada-brasil

micronicho-investimento-infinitas-possibilidades

monarx

multipropriedade-vale-a-pena

musica-tela

musicas-brasileiras-viajar

musicas-criticas-a-tecnologia

musicas-que-falam-de-discos

musicas-viajar

o-colorib-sabe-que-o-template-e-dele

oceano-azul-seo

paginas-amp

palavras-bomba-hidraulica

palavras-chaves-multipropriedade

pdf-para-html

perguntas-em-vagas-de-emprego

permissao-pasta-remota-php

pesquisas-abril-22-p254

picpay-vs-nubank

pilates-penteadeira

pipe-angular-cpf

png-para-jpg

pontos-negativos-contidos-livro-mulipropriedade

prioridade-matrizes

prioridade

priorizacao-de-conteudo-para-site-e-blog

priorizar-conteudo-nos-sites

que-roupa-usar

quebra-linha-whatsapp

query-artigo-800-palavras

query-php-um-campo

questoes-clinicas-2017

questoes-sprint

reclame-aqui-ganha-dinheiro

reclame-aqui

redirect-html

regex

remover-o-s-de-uma-palavra-plural-singular-php

remover-pontos-tracos-excel

rende-mais-cdi-agosto-de-2023

retirar-linha-excel

samurai-x

seo-local

serie-explicando-dinheiro-netflix-cartao-de-credito

sexta-temporada-black-mirror

simular-colunas-tabela-html

sinal-maior-menor

sistema-multipropriedade

snake-case

sugestao-dominio-feminino

taboola-o-joao-kleber-da-internet

termos-direto-ao-ponto

tipos-join

tirar-espaco-excel

trocar-foto-smartwatchs-em-alta

usar-ad-manager

usar-adsense-em-arquivo-pdf

usar-no-sobre

valor-unico-mysqli-php

varios-sites-de-prefeituras-direcionam-para-sites-de-aposta

vinil-anos-90-dificil-achar

vinil-para-depois

viver-de-blog-monetizacao

webstories-videos-texto

whatsapp-direto

whatsapp