Cómo validar los detalles de la cuenta de usuario usando expresiones regulares

Las expresiones regulares son una herramienta de programación integral que puede utilizar para muchas tareas prácticas del día a día. Puede usar expresiones regulares para buscar, hacer coincidir o analizar texto. Con los patrones correctos, puede validar algunos de los detalles de cuenta de usuario más comunes.

Puede usar expresiones regulares con muchos lenguajes o herramientas, incluidos Python y JavaScript.

Regex para validar un nombre de usuario

Considere un nombre de usuario que solo es válido si cumple las siguientes condiciones:

1. El número de caracteres debe estar entre 5 y 15. (Puede especificar un rango diferente de acuerdo con sus requisitos, pero realice cambios en la expresión regular en consecuencia).
   instagram viewer
2. La cadena solo debe contener caracteres alfanuméricos y/o guiones bajos (_).
3. El primer carácter de la cadena debe ser alfabético.

La siguiente expresión regular satisface las condiciones anteriores y puede validar un nombre de usuario:

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

Si no se siente cómodo con la expresión anterior, consulte una guía para principiantes de expresiones regulares primero. Este es un enfoque de Python para validar un nombre de usuario:

importar re
definitivamentecomprobar nombre de usuario(nombre de usuario):
 expresión regular = "^[A-Za-z]\\w{4,14}$"
 r = recompilar (regex)
si (re.buscar(r, nombre de usuario)):
 imprimir("Válido")
demás:
 imprimir("No es válido")
nombre de usuario1 = "yuvraj_chandra"
checkUsuario (usuario1)
nombre de usuario2 = "ja7&^%87"
checkUsuario (usuario2)

Ejecutar este código confirmará que el primer nombre de usuario es válido pero el segundo no:

Del mismo modo, puede validar un nombre de usuario en JavaScript usando el siguiente código:

funcióncomprobar nombre de usuario(usuario) {
si(/^[A-Za-z][A-Za-z0-9_]{4,14}$/.prueba (usuario)) {
 consola.log('Válido');
 } demás {
 consola.log('No es válido');
 }
}
comprobar nombre de usuario ('yuvraj_chandra');
comprobar nombre de usuario ('ja7&^%87'); 

Puedes usar este código para validar formularios HTML usando expresiones regulares.

Regex para validar una dirección de correo electrónico

La expresión regular para validar una dirección de correo electrónico no es perfecta. No existe una expresión regular acordada universalmente para validar una dirección de correo electrónico. Se reduce completamente a su definición de válido.

A continuación se muestra una lista de condiciones que pueden validar la mayoría de las direcciones de correo electrónico:

1. El nombre de usuario solo debe contener caracteres alfanuméricos, guiones bajos, guiones y/o puntos.
2. La cadena de identificación del correo electrónico debe tener un carácter @.
3. El nombre de dominio solo debe contener caracteres alfanuméricos, guiones bajos o guiones.
4. Debe haber un punto después del nombre de dominio.
5. La extensión de dominio solo debe contener caracteres alfanuméricos, guiones bajos o guiones.
6. La longitud de la extensión del dominio debe estar entre 2 y 4.

La siguiente expresión regular satisface las condiciones anteriores y puede validar una dirección de correo electrónico:

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

Este es un enfoque de Python para validar una dirección de correo electrónico:

importar re
definitivamentecomprobar ID de correo electrónico(correo electrónico):
 expresión regular = "^[\w.-]+@([\w-]+\.)+[\w-]{2,4}$"
 r = recompilar (regex)
si (re.buscar(r, correo electrónico)):
 imprimir("Válido")
demás:
 imprimir("No es válido")
correo electrónico1 = "[email protected]"
comprobar ID de correo electrónico (correo electrónico 1)
correo2 = "abc@def@gmail.kahscg"
comprobar ID de correo electrónico (correo electrónico2)

De nuevo, el resultado confirma que la primera dirección de correo electrónico es válida mientras que la segunda no es válida:

Puede validar un correo electrónico en JavaScript usando el siguiente código:

funcióncomprobar ID de correo electrónico(correo electrónico) {
si (/^[\w.-]+@([\w-]+\.)+[\w-]{2,4}$/.Email de prueba)) {
consola.log('Válido');
 } demás {
consola.log('No válido');
 }
}
checkEmailId("[email protected]");
checkEmailId("abc@[email protected]");

Comprobar la solidez de la contraseña mediante expresiones regulares

Las contraseñas seguras son esenciales desde una perspectiva de seguridad. Debe asegurarse de que los usuarios finales tengan contraseñas lo suficientemente seguras para que otros no puedan acceder a sus cuentas.

Las siguientes reglas aseguran que la seguridad de la contraseña de su aplicación sea fuerte:

1. El número mínimo de caracteres debe ser 8.
2. La cadena debe tener al menos un dígito.
3. La cadena debe tener al menos un carácter en mayúscula.
4. La cadena debe tener al menos un carácter en minúscula.
5. La cadena debe tener al menos un carácter especial.

La siguiente expresión regular satisface las condiciones anteriores y puede ayudar a garantizar una contraseña más segura:

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

Puede verificar la seguridad de la contraseña en Python usando el siguiente código:

importar re
definitivamentecomprobar la fuerza de la contraseña(contraseña):
 expresión regular = "(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])(?=.*[^A-Za-z0-9])(?=.{ 8,})"
 r = recompilar (regex)
si (re.buscar(r, contraseña)):
 imprimir("Contraseña segura")
demás:
 imprimir("Contraseña debil")
contraseña1 = "Hiuahd$5jawd"
comprobarFuerza de la contraseña (contraseña1)
contraseña2 = "mi contraseña"
comprobarFuerza de la contraseña (contraseña2)

Ejecutar este código confirmará que la primera contraseña es segura mientras que la segunda es débil:

Puede verificar la seguridad de la contraseña en JavaScript usando el siguiente código:

funcióncomprobar la fuerza de la contraseña(contraseña) {
si (/(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])(?=.*[^A-Za-z0-9])(?=.{8,})/.prueba (contraseña)) {
 consola.log('Contraseña segura');
 } demás {
 consola.log('Contraseña debil');
 }
}
comprobar la fuerza de la contraseña ('Hiuahd$5jawd');
comprobar la fuerza de la contraseña ('mi contraseña');

Expresión regular para coincidir con una fecha válida

Si desea verificar rápidamente si las fechas dadas están en el formato de fecha tradicional o no, puede hacerlo usando expresiones regulares.

La siguiente expresión regular coincide con una fecha en mm/dd/aaaa formato:

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

El siguiente código de Python valida la fecha en mm/dd/aaaa formato:

importar re
definitivamentecomprobar formato de fecha(fecha):
 expresión regular = "^(0[1-9]|1[012])[- /.](0[1-9]|[12][0-9]|3[01])[- /.](19|20 )\d\d$"
 r = recompilar (regex)
si(re.buscar(r, fecha)):
 imprimir("Válido")
demás:
 imprimir("No es válido")
fecha1 = "03/21/2002"
comprobar formato de fecha (fecha 1)
fecha2 = "15/21/2002"
comprobar formato de fecha (fecha 2)

Una vez más, el resultado confirma que el primer formato de fecha es válido, pero el segundo no es válido:

Puede validar la fecha en mm/dd/aaaa formato en JavaScript usando el siguiente código:

funcióncomprobar formato de fecha(fecha) {
si(/^(0[1-9]|1[012])[- /.](0[1-9]|[12][0-9]|3[01])[- /.](19| 20)\d\d$/.fecha de la prueba)) {
 consola.log('Válido');
 } demás {
 consola.log('No es válido');
 }
}
comprobar formato de fecha ('03/21/2002');
comprobar formato de fecha ('15/21/2002');

Validación de cadenas vacías mediante expresiones regulares

Puede verificar si una cadena está vacía usando la siguiente expresión regular:

^$

A continuación se muestra el enfoque de Python para la validación de cadenas vacías:

importar re
definitivamentecomprobarCadenaVacía(calle):
 expresión regular = "^$"
 r = recompilar (regex)
si (re.buscar(r, calle)):
imprimir("La cadena dada es vacío")
demás:
imprimir("La cadena dada no es vacío")
str1 = ""
comprobarCadenaVacía (str1)
str2 = "Esta no es una cadena vacía."
verificarCadenaVacía (str2)

El siguiente resultado demuestra que la primera cadena dada está vacía mientras que la segunda no lo está:

Utilice el siguiente código JavaScript para comprobar si la cadena está vacía o no:

funcióncomprobarCadenaVacía(calle) {
si (/^$/.prueba (cadena)) {
 consola.log('La cadena dada está vacía');
 } demás {
 consola.log('La cadena dada no está vacía');
 }
}
comprobarCadenaVacía('');
comprobarCadenaVacía('Esta no es una cadena vacía.'); 

RegEx para validar el código postal (código postal de EE. UU.)

Puede validar un código postal (código postal de EE. UU.) en formato de cinco y nueve dígitos (llamado ZIP+4) mediante la siguiente expresión regular:

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

A continuación se muestra el código de Python para validar códigos postales:

importar re
definitivamentevalidar código postal(código):
 expresión regular = "^[0-9]{5}(?:-[0-9]{4})?$"
 r = recompilar (regex)
si (re.buscar(r, código)):
 imprimir("Válido")
demás:
 imprimir("No es válido")
código1 = "76309"
validar código postal (código1)
código2 = "83468-2348"
validar código postal (código 2)
código3 = "234445"
validar código postal (código 3)

Ejecutar este código confirmará que el primer y el segundo código postal son válidos, pero el tercero no:

Use el siguiente código JavaScript para validar el código postal usando expresiones regulares:

funciónvalidar código postal(código) {
si (/^[0-9]{5}(?:-[0-9]{4})?$/.prueba (código)) {
 consola.log('Válido');
 } demás {
 consola.log('No es válido');
 }
}
validar código postal ('76309');
validar código postal ('83468-2348');
validar código postal ('234445');

Verifique la entrada del usuario con un código robusto

Aprendió a validar los detalles de la cuenta de usuario mediante expresiones regulares. La validación de estos detalles fortalece el código y ayuda a abordar los problemas de seguridad y los errores no deseados. El código robusto proporciona una experiencia segura para sus usuarios.

Debe asegurarse de que está validando los datos de entrada en el lado del cliente o en el lado del servidor para estar siempre a salvo de los piratas informáticos.