# Regular Expressions (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. _(MDN)
- .test() -> true/false
- exec() -> array
- .match() -> array/null
- search() -> índice/-1
- replace() -> procura e substitui
- split -> usa a regex 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. _(MDN)
## Modificadores
- i -> /code/i : ignora se é maiúscula ou minúscula
- g -> /code/g : encontra todas as compatibilidades
- m -> /code/m : verificação multilinha
## Alcance [ ]
- `/[abc]/` : busca por qualquer um dos caracteres entre [] (ou seja, procura por 'a', 'b', 'c')
- `/[x-y]/` : busca por caracteres entre a primeira letra e a segunda -> exemplo: de 'a' a 'z' -> a-z
- `/[0-9]/` : busca por qualquer caracteres entre os números estipulados
- `/[x|y]/` : busca por x ou y..
- `/[^code]/` : busca por caracteres diferentes dos informados -> exemplo: `/[^aeiou]/` -> procura por caracteres que não sejam vogais
- `/[code+]/` : busca por uma ou mais ocorrências -> exemplo:
```js
/[o+]/
* ['ovo'] // => ['o', 'o']
* ['voo'] // => ['oo']
* ['voa'] // => ['o']
```
- `/[code*]/` : busca por ou mais ocorrências
- `/[code]?/` : busca pela menor ocorrência (trecho)
exemplo
`'economia'.match(/o[a-z]*?o/) => 'ono'`
## Quantificadores
- n+ : busca por pelo menos uma ocorrência
- n* : busca por qualquer string que contenha 0 ou mais ocorrências de n
- n? : busca por 0 ou 1 ocorrência de n
- n{X} : busca a ocorrência de uma sequência de 'X' vezes -> ex: '1000, 10, 100, 1000'.match(/\d{4}/g)
TODO...cont
## Caracteres especiais
- \ : 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. _(MDN)
- ^: procura por todos os caracteres que não sejam os informadaos.
TODO...cont
## literal
```js
/code/
```
ex:
```js
console.log(/comp/.test('computador')); // true
```
## Ou -> |
```js
/code1 | code2 | code3/
```
ex:
```js
console.log(/ball | dog | cat/.test('I see a dog.')); // false, pois considera o espaço em branco
console.log(/ball|dog|cat/.test('I see a dog')); // true
```
## Trecho
```js
/.code/
```
e
```js
/code./
`
ex:
```js
'brasileiro'.match(/br./)
```
## Procurar caracteres diferentes dos informados
```js
/[^code]/
```
## Procurar por ocorrência no início (^)
```js
/^code/
```
ex:
```js
let greeting = "Hello World!";
let greetRegex = /^Hello/;
let result = greetRegex.test(greeting); => true
```
## Procurar por ocorrência no final ($)
```js
/code$/
```
ex:
```js
let greeting = "Hello World!";
let greetRegex = /World$/;
let result = greetRegex.test(greeting); => true
```
## Procurar por mais de uma ocorrência seguida
```js
/code+/
```
Ex:
```js
'voo'.match(/o+/g)
// => 'oo'
```
## Atalho: procurar todas as letras (maiúsculas e minúsculas), números e _ (\w)
```js
[A-Za-z0-9_] = /\w/g
```
## Atalho: procurar todos os símbolos menos as letras (maiúsculas e minúsculas), números e _ (\W)
```js
[^A-Za-z0-9_] = /\W/g
```
## Atalho: procurar todas ocorrências de números (\d)
```js
[0-9_] = /\d/g
```
ex
```js
let numString = "Ganhamos um aumento de 10%";
let noNumRegex = /\D/g; // Change this line
let result = numString.match(noNumRegex).length;
// => 24
```
## Atalho: procurar por espaços em branco (\s)
```js
/\s/g
```
## Atalho: procurar por caracteres que não são espaços em branco (\S)
```js
/\S/g
```
## Especificador de quantidade ({n,n})
(Procura ocorrência entre quantidade de um nº ao outro de vezes)
```js
/code{n,n}code/
```
```js
/code{n,}code/
```
ex:
```js
/ola{3,}a/.test('olaaaaa') // => true
```
## Especificador exato de quantidade ({n})
```js
/code{n}code/
```
## Procurar 0 ou 1 ocorrência de caractére (?)
```js
/code?/
```
ex:
```js
/ama?/.test('ama') // => true
/ama?/.test('amar') // => true
/ama?/.test('amora') // => false
```
## Positive lookahead (?=...)
```js
/(?=code)/
```
ex: checar se a senha tem entre 3 e 6 caracteres e pelo menos um número.
```
let senha = "ola321";
let checarSenha = /(?=\w{3,6})(?=\D*\d)/;
checarSenha.test(senha); // => true
```
## Negative lookahead (?=!...)
```js
/(?=!code)/
```
## Repetição de grupo (()\número de vezes)
(funciona com .test e .match)
```js
/(code)\número de vezes/
```
ex:
```js
/(\w+)\s\1/;
```
## Capturar ocorrência e substituir (.replace)
ex:
```js
'Hello mundo!'.replace(/Hello/, 'Olá') // => "Olá mundo!"`
`'bem tudo'.replace(/(\w+)\s(\w+)/, '$2 $1'); // => "tudo bem"`
`'99991111'.replace(/(\d{4})(\d{4})/, '$1-$2'); // => "9999-1111"
```
Sign in with Wallet
Connect another wallet