Como validar detalhes da conta do usuário usando expressões regulares

As expressões regulares são uma ferramenta de programação integral que você pode usar para muitas tarefas práticas do dia a dia. Você pode usar expressões regulares para pesquisar, corresponder ou analisar texto. Com os padrões certos, você pode validar alguns dos detalhes mais comuns da conta do usuário.

Você pode usar expressões regulares com muitas linguagens ou ferramentas, incluindo Python e JavaScript.

Regex para validar um nome de usuário

Considere um nome de usuário que só é válido se satisfizer as seguintes condições:

1. O número de caracteres deve estar entre 5 e 15. (Você pode especificar um intervalo diferente de acordo com seus requisitos, mas faça alterações no regex de acordo.)
instagram viewer
2. A string deve conter apenas caracteres alfanuméricos e/ou sublinhados (_).
3. O primeiro caractere da string deve ser alfabético.

O seguinte regex satisfaz as condições acima e pode validar um nome de usuário:

^[A-Za-z]\\w{4,14}$

Se você não se sentir confortável com a expressão acima, confira um guia para iniciantes sobre expressões regulares primeiro. Esta é uma abordagem do Python para validar um nome de usuário:

importar ré
defcheckUsername(nome de usuário):
 regex = "^[A-Za-z]\\w{4,14}$"
 r = re.compile (regex)
se (ré.procurar(r, nome de usuário)):
 imprimir("Válido")
outro:
 imprimir("Inválido")
nome de usuário1 = "yuvraj_chandra"
checkUsername (username1)
nome de usuário2 = "ja7&^%87"
checkUsername (username2)

A execução deste código confirmará que o primeiro nome de usuário é válido, mas o segundo não é:

Da mesma forma, você pode validar um nome de usuário em JavaScript usando o seguinte código:

funçãocheckUsername(do utilizador) {
se(/^[A-Za-z][A-Za-z0-9_]{4,14}$/.teste (usuário)) {
 console.log('Válido');
 } outro {
 console.log('Inválido');
 }
}
checkUsername('yuvraj_chandra');
checkUsername('ja7&^%87'); 

Você pode usar este código para validar formulários HTML usando expressões regulares.

Regex para validar um endereço de e-mail

O regex para validar um endereço de e-mail não é perfeito. Não há regex universalmente aceito para validar um endereço de e-mail. Tudo se resume completamente à sua definição de válido.

Abaixo está uma lista de condições que podem validar a maioria dos endereços de e-mail:

1. O nome de usuário deve conter apenas caracteres alfanuméricos, sublinhado, traço e/ou ponto.
2. A string de id de e-mail deve ter um caractere @.
3. O nome de domínio deve conter apenas caracteres alfanuméricos, sublinhado ou traço.
4. Deve haver um ponto após o nome de domínio.
5. A extensão do domínio deve conter apenas caracteres alfanuméricos, sublinhado ou traço.
6. O comprimento da extensão do domínio deve estar entre 2 e 4.

O seguinte regex satisfaz as condições acima e pode validar um endereço de e-mail:

^[\w.-]+@([\w-]+\.)+[\w-]{2,4}$

Esta é uma abordagem Python para validar um endereço de e-mail:

importar ré
defcheckEmailId(e-mail):
 regex = "^[\w.-]+@([\w-]+\.)+[\w-]{2,4}$"
 r = re.compile (regex)
se (ré.procurar(r, e-mail)):
 imprimir("Válido")
outro:
 imprimir("Inválido")
email1 = "[email protected]"
checkEmailId (email1)
email2 = "abc@def@gmail.kahscg"
checkEmailId (email2)

Novamente, a saída confirma que o primeiro endereço de e-mail é válido enquanto o segundo é inválido:

Você pode validar um e-mail em JavaScript usando o seguinte código:

funçãocheckEmailId(e-mail) {
se (/^[\w.-]+@([\w-]+\.)+[\w-]{2,4}$/.teste (e-mail)) {
console.log('Válido');
 } outro {
console.log('Não Válido');
 }
}
checkEmailId("[email protected]");
checkEmailId("abc@[email protected]");

Verifique a força da senha usando expressões regulares

Senhas fortes são essenciais do ponto de vista da segurança. Você precisa garantir que os usuários finais tenham senhas fortes o suficiente para que outras pessoas não possam acessar suas contas.

As regras a seguir garantem que a força da senha do seu aplicativo seja forte:

1. O número mínimo de caracteres deve ser 8.
2. A string deve ter pelo menos um dígito.
3. A string deve ter pelo menos um caractere maiúsculo.
4. A string deve ter pelo menos um caractere minúsculo.
5. A string deve ter pelo menos um caractere especial.

O seguinte regex satisfaz as condições acima e pode ajudar a garantir uma senha mais forte:

(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])(?=.*[^A-Za-z0-9])(?=.{ 8,})

Você pode verificar a força da senha em Python usando o seguinte código:

importar ré
defcheckPasswordStrength(senha):
 regex = "(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])(?=.*[^A-Za-z0-9])(?=.{ 8,})"
 r = re.compile (regex)
se (ré.procurar(r, senha)):
 imprimir("Senha forte")
outro:
 imprimir("Senha fraca")
senha1 = "Hiuahd$5jawd"
checkPasswordStrength (senha1)
senha2 = "minha senha"
checkPasswordStrength (senha2)

Executar este código confirmará que a primeira senha é forte enquanto a segunda é fraca:

Você pode verificar a força da senha em JavaScript usando o seguinte código:

funçãocheckPasswordStrength(senha) {
se (/(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])(?=.*[^A-Za-z0-9])(?=.{8,})/.teste (senha)) {
 console.log('Senha forte');
 } outro {
 console.log('Senha fraca');
 }
}
checkPasswordStrength('Hiuahd$5jawd');
checkPasswordStrength('minha senha');

Expressão regular para corresponder a uma data válida

Se você deseja verificar rapidamente se as datas fornecidas estão no formato de data tradicional ou não, pode fazê-lo usando regex.

A expressão regular a seguir corresponde a uma data em mm/dd/aaaa formatar:

^(0[1-9]|1[012])[- /.](0[1-9]|[12][0-9]|3[01])[- /.](19|20 )\d\d$

O código Python a seguir valida se a data está em mm/dd/aaaa formatar:

importar ré
defcheckDateFormat(data):
 regex = "^(0[1-9]|1[012])[- /.](0[1-9]|[12][0-9]|3[01])[- /.](19|20 )\d\d$"
 r = re.compile (regex)
se(ré.procurar(r, data)):
 imprimir("Válido")
outro:
 imprimir("Inválido")
data1 = "03/21/2002"
checkDateFormat (data1)
data2 = "15/21/2002"
checkDateFormat (data2)

Mais uma vez, a saída confirma que o primeiro formato de data é válido, mas o segundo é inválido:

Você pode validar a data em mm/dd/aaaa formato em JavaScript usando o seguinte código:

funçãocheckDateFormat(data) {
se(/^(0[1-9]|1[012])[- /.](0[1-9]|[12][0-9]|3[01])[- /.](19| 20)\d\d$/.data do teste)) {
 console.log('Válido');
 } outro {
 console.log('Inválido');
 }
}
checkDateFormat('03/21/2002');
checkDateFormat('15/21/2002');

Validação de string vazia usando expressões regulares

Você pode verificar se uma string está vazia usando a seguinte expressão regular:

^$

Abaixo está a abordagem Python para validação de string vazia:

importar ré
defcheckEmptyString(str):
 regex = "^$"
 r = re.compile (regex)
se (ré.procurar(r, str)):
imprimir("A string fornecida é vazio")
outro:
imprimir("A string fornecida não é vazio")
str1 = ""
checkEmptyString (str1)
str2 = "Esta não é uma string vazia"
checkEmptyString (str2)

A saída a seguir demonstra que a primeira string fornecida está vazia enquanto a segunda não está:

Use o seguinte código JavaScript para verificar se a string está vazia ou não:

funçãocheckEmptyString(str) {
se (/^$/.teste (str)) {
 console.log('A string fornecida está vazia');
 } outro {
 console.log('A string fornecida não está vazia');
 }
}
checkEmptyString('');
checkEmptyString('Esta não é uma string vazia'); 

RegEx para validar o CEP (código postal dos EUA)

Você pode validar um CEP (código postal dos EUA) nos formatos de cinco e nove dígitos (chamado ZIP+4) usando a seguinte expressão regular:

^[0-9]{5}(?:-[0-9]{4})?$

Abaixo está o código Python para validar os CEPs:

importar ré
defvalidar CEP(código):
 regex = "^[0-9]{5}(?:-[0-9]{4})?$"
 r = re.compile (regex)
se (ré.procurar(r, código)):
 imprimir("Válido")
outro:
 imprimir("Inválido")
código1 = "76309"
validarZIPCode (código1)
código2 = "83468-2348"
validarZIPCode (code2)
código3 = "234445"
validarZIPCode (code3)

A execução deste código confirmará que o primeiro e o segundo CEP são válidos, mas o terceiro não:

Use o seguinte código JavaScript para validar o CEP usando regex:

funçãovalidar CEP(código) {
se (/^[0-9]{5}(?:-[0-9]{4})?$/.teste (código)) {
 console.log('Válido');
 } outro {
 console.log('Inválido');
 }
}
validarCódigoZIP('76309');
validarCódigoZIP('83468-2348');
validarCódigoZIP('234445');

Verifique a entrada do usuário com código robusto

Você aprendeu como validar os detalhes da conta do usuário usando expressões regulares. A validação desses detalhes torna o código robusto e ajuda a lidar com problemas de segurança e bugs indesejados. Código robusto fornece uma experiência segura e protegida para seus usuários.

Você deve certificar-se de que está validando os dados de entrada no lado do cliente ou no lado do servidor para estar sempre protegido contra hackers.