Curso Regex

Os fundamentos do regex: padrões literais, classes básicas de caracteres, o curinga `.` e metacaracteres de escape.

1. 1.1Padrões literaisCaracteres normais, distinção entre maiúsculas e minúsculas e uma primeira execução: correspondência e índice.~8 min
2. 1.2Aulas básicas: \d \w \sAs classes predefinidas para dígitos, caracteres de palavras e espaços em branco (e suas versões negadas).~10 min
3. 1.3O curinga: o ponto `.`O caractere `.` corresponde a quase tudo: o que inclui, o que exclui e por que o sinalizador `s` é importante.~8 min
4. 1.4Escapando de metacaracteresOs 12 metacaracteres que precisam ser escapados com `\`, quando você precisa de uma barra invertida dupla e por quê.~10 min

Quanto repetir: `*`, `+`, `?`, intervalos `{n,m}` e a diferença entre ganancioso e preguiçoso.

1. 2.1`*`, `+`, `?`Zero ou mais, um ou mais, opcional: os três quantificadores básicos.~10 min
2. 2.2Quantidades exatas `{n,m}`Exatamente `n`, de `n` a `m`, pelo menos `n`: o quantificador numérico.~10 min
3. 2.3Ganancioso versus preguiçosoPor padrão, os quantificadores são gananciosos (`.*`); adicione `?` para a versão lenta (`.*?`).~10 min
4. 2.4Retrocesso: uma visão geralO que o mecanismo faz quando um quantificador ganancioso falha e por que pode ser caro.~12 min

Posição, não caracteres: ancoragem no início/fim da string, nos limites das palavras e no início/fim de cada linha com o sinalizador `m`.

1. 3.1Início e fim: `^` e `$`Ancorando um padrão ao primeiro ou último caractere da string.~8 min
2. 3.2Limites da palavra: `\b` `\B`A transição entre caracteres de palavras e não palavras; encontrar palavras inteiras.~10 min
3. 3.3O sinalizador `m`: multilinhaCom o sinalizador `m`, `^` e `$` ancoram no início/fim de cada linha.~10 min
4. 3.4Linhas vazias e cortesPadrões úteis: combinar linhas vazias, cortar espaços em branco no início/fim de uma linha.~10 min

Agrupe com `()`, escolha entre alternativas com `|`, evite capturar com `(?:...)`, nomeie grupos com `(?<nome>...)` e consulte uma captura anterior com referências anteriores.

1. 4.1Grupos de captura: `(...)`Parênteses para agrupar e capturar; acesse os grupos 1, 2, 3… nas partidas.~10 min
2. 4.2Alternação: `|`O tubo escolhe entre dois ou mais subpadrões; precedência e parênteses.~10 min
3. 4.3Grupos sem captura: `(?:...)`Agrupar sem criar captura: útil quando você só precisa quantificar ou alternar.~10 min
4. 4.4Grupos nomeados e referências anteriores`(?<nome>...)` para dar um nome; `\1` `\k<name>` para se referir à captura.~12 min

Defina conjuntos personalizados com `[...]`, use intervalos, negue com `[^...]` e alcance propriedades Unicode com `\p{...}` e o sinalizador `u`.

1. 5.1Conjuntos de caracteres: `[abc]`Colchetes definem um conjunto de caracteres permitidos em uma posição.~8 min
2. 5.2Intervalos dentro das classes: `[a-z0-9]`Intervalos através do traço; combinando intervalos e caracteres únicos.~8 min
3. 5.3Negação: `[^...]`Uma classe negada corresponde a qualquer coisa **exceto** aos caracteres listados.~8 min
4. 5.4Escapes de propriedade Unicode`\p{L}`, `\p{N}`, `\p{Script=...}` com o sinalizador `u`: classes Unicode semânticas.~12 min

Asserções de largura zero: olham para frente ou para trás na string sem consumir caracteres. Olhar à frente `(?=)` `(?!)`, olhar atrás `(?<=)` `(?<!)`.

1. 6.1Antecipação positiva: `(?=...)`Verifique se um determinado padrão segue a posição atual, sem consumi-la.~10 min
2. 6.2Antecipação negativa: `(?!...)`Verifique se um determinado padrão NÃO segue a posição atual.~10 min
3. 6.3Olhe atrás: `(?<=...)` `(?<!...)`As versões "olhar para trás" do lookaround; Suporte ES2018+.~12 min
4. 6.4Lookaround na práticaExtraia um valor sem incluir o contexto, valide senhas, analise números delimitados.~12 min

Todos os sinalizadores (incl. `d`, `v`), `String.prototype.replace`/`replaceAll`/`split` com regex, fazem referência a `$1`/`$<name>` na string de substituição e substituem retornos de chamada.

1. 7.1Todas as bandeiras em detalhes`g i m s u v y d`: o que cada um faz e como se combinam.~12 min
2. 7.2Substituição básica e `$1`Substitua as correspondências por uma string fixa ou por referências anteriores `$1` / `$<nome>`.~10 min
3. 7.3Substitua por um retorno de chamadaFunção de substituição: transformar cada partida com código JS arbitrário, acesso a grupos.~12 min
4. 7.4Dividir com regexDivida uma string em um padrão (CSV permissivo, tokenizador mínimo).~10 min

Junte tudo isso em problemas reais: valide e-mails, analise logs, extraia URLs/IPs, escreva padrões resistentes a ReDoS.

1. 8.1Validando um e-mailUm padrão “bom o suficiente” para e-mails, com as compensações explicadas.~12 min
2. 8.2Analisador de log do ApacheExtraia IP, método, caminho e código de status de uma linha de log usando grupos nomeados.~12 min
3. 8.3Extraindo URLs e IPsReconheça URLs http(s) e endereços IPv4 em texto de formato livre.~12 min
4. 8.4Escrevendo padrões seguros para ReDoSReconheça padrões catastróficos (`(a+)+b`), refatore-os e use quantificadores do tipo atômico.~14 min