Vamos aprender sobre quantificadores em expressões regulares. Considere um cenário onde você deseja corresponder a um código de identificação de quatro dígitos. Você sabe que pode usar a classe de caracteres \d, então você pode escrever isso quatro vezes. E para evitar quaisquer caracteres extras, você deve incluir tanto os âncoras de início quanto de fim:

const regex = /^\d\d\d\d$/;

E isso funciona – ele irá corresponder a quatro caracteres numéricos. Mas em vez de ter que escrever a mesma classe várias vezes, você pode atribuir a ela um quantificador. Quantificadores são definidos por chaves contendo um ou dois números. Vamos usar um quantificador no nosso padrão:

const regex = /^\d{4}$/;

Note como nosso quantificador contém apenas o número 4. Esta sintaxe significa "combinar o caractere anterior exatamente quatro vezes". Vamos ver como isso se comporta:

const regex = /^\d{4}$/;
console.log(regex.test("123")); // false
console.log(regex.test("1234")); // true
console.log(regex.test("12345")); // false
console.log(regex.test("123456")); // false
console.log(regex.test("1234567")); // false

O padrão corresponde apenas à string com exatamente quatro dígitos, porque usamos os âncoras e nosso quantificador permite apenas exatamente quatro dígitos. Mas talvez o código de identificação precise ter no mínimo quatro dígitos. Para permitir quatro ou mais dígitos, adicione uma vírgula após o número no seu quantificador:

const regex = /^\d{4,}$/;

Agora, nossa sintaxe permite que o padrão corresponda a quatro ou mais dígitos. Vamos testar:

const regex = /^\d{4,}$/;
console.log(regex.test("123")); // false
console.log(regex.test("1234")); // true
console.log(regex.test("12345")); // true
console.log(regex.test("123456")); // true
console.log(regex.test("1234567")); // true

Um identificador de sete dígitos é bastante longo. Esses identificadores devem ter no máximo 6 dígitos e no mínimo 4 dígitos. Para conseguir isso, você pode adicionar um segundo número ao seu quantificador após a vírgula:

const regex = /^\d{4,6}$/;

E agora nosso padrão não corresponde mais ao identificador de sete dígitos, porque ele é maior do que nosso máximo de seis dígitos.

const regex = /^\d{4,6}$/;
console.log(regex.test("123")); // false
console.log(regex.test("1234")); // true
console.log(regex.test("12345")); // true
console.log(regex.test("123456")); // true
console.log(regex.test("1234567")); // false

Observe que você não pode usar essa sintaxe para definir apenas um máximo – você deve sempre definir um mínimo. Mas se você definir o mínimo como 1, você pode efetivamente alcançar o mesmo resultado. Recebemos requisitos atualizados dos nossos usuários. Identificadores agora podem opcionalmente começar com uma letra. Já sabemos a classe de caracteres para isso, então vamos adicioná-la à nossa expressão regular:

const regex = /^[a-zA-Z]\d{4,6}$/;

Mas agora exigimos a presença de uma letra. Como podemos tornar isso opcional? Você pode usar a sintaxe do quantificador com 0 como mínimo e 1 como máximo:

const regex = /^[a-zA-Z]{0,1}\d{4,6}$/;

Mas na verdade existe um quantificador especial abreviado para um único caractere opcional – o ponto de interrogação (?). Vamos substituir nosso quantificador pelo ponto de interrogação:

const regex = /^[a-zA-Z]?\d{4,6}$/;

Devemos validar o resultado:

const regex = /^[a-zA-Z]?\d{4,6}$/;
console.log(regex.test("123")); // false
console.log(regex.test("a1234")); // true
console.log(regex.test("12345")); // true
console.log(regex.test("az12345")); // false
console.log(regex.test("X123456")); // true
console.log(regex.test("1234567")); // false

Nosso padrão agora permite uma única letra opcional, seguida por quatro a seis dígitos. Infelizmente, acabamos de perceber que lemos os requisitos errado. Precisamos permitir qualquer número de letras antes dos números. Podemos usar nosso quantificador com um mínimo de 0 e sem máximo definido:

const regex = /^[a-zA-Z]{0,}\d{4,6}$/;

Mas nosso padrão está ficando longo novamente. Felizmente, existe outra forma abreviada para "combinar o caractere anterior zero ou mais vezes" – o símbolo asterisco (*). Vamos substituir nosso quantificador por aquele no padrão e testá-lo:

const regex = /^[a-zA-Z]*\d{4,6}$/;
console.log(regex.test("123")); // false
console.log(regex.test("a1234")); // true
console.log(regex.test("12345")); // true
console.log(regex.test("az12345")); // true
console.log(regex.test("X123456")); // true
console.log(regex.test("1234567")); // false

Agora correspondemos com sucesso a qualquer identificador com zero ou mais letras seguidas por quatro a seis números. Mas acontece que isso está travando nosso sistema – na verdade, temos que exigir pelo menos uma letra. Novamente, poderíamos usar um quantificador com um mínimo de um e sem máximo definido, ou poderíamos usar outra sintaxe especial – o símbolo mais (+):

const regex = /^[a-zA-Z]+\d{4,6}$/;
console.log(regex.test("123")); // false
console.log(regex.test("a1234")); // true
console.log(regex.test("12345")); // false
console.log(regex.test("az12345")); // true
console.log(regex.test("X123456")); // true
console.log(regex.test("1234567")); // false

Agora os identificadores que não começam com pelo menos uma letra falham, independentemente de quantos números houver. Você pode usar quantificadores para aumentar muito a brevidade e a legibilidade das suas expressões regulares.