Comment valider les détails du compte utilisateur à l'aide d'expressions régulières

Les expressions régulières sont un outil de programmation intégral que vous pouvez utiliser pour de nombreuses tâches pratiques quotidiennes. Vous pouvez utiliser des expressions régulières pour rechercher, faire correspondre ou analyser du texte. Avec les bons modèles, vous pouvez valider certains des détails de compte d'utilisateur les plus courants.

Vous pouvez utiliser des expressions régulières avec de nombreux langages ou outils, notamment Python et JavaScript.

Regex pour valider un nom d'utilisateur

Considérez un nom d'utilisateur qui n'est valide que s'il remplit les conditions suivantes :

1. Le nombre de caractères doit être compris entre 5 et 15. (Vous pouvez spécifier une plage différente selon vos besoins, mais modifiez l'expression régulière en conséquence.)
2. La chaîne ne doit contenir que des caractères alphanumériques et/ou des traits de soulignement (_).
3. Le premier caractère de la chaîne doit être alphabétique.

L'expression régulière suivante satisfait les conditions ci-dessus et peut valider un nom d'utilisateur :

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

Si vous n'êtes pas à l'aise avec l'expression ci-dessus, consultez un guide du débutant sur les expressions régulières d'abord. Il s'agit d'une approche Python pour valider un nom d'utilisateur :

importer concernant
définitivementcheckUsername(nom d'utilisateur):
 expression régulière = "^[A-Za-z]\\w{4,14}$"
 r = re.compile (regex)
si (concernant.recherche(r, nom d'utilisateur)):
 imprimer("Valide")
autre:
 imprimer("Pas valide")
nom d'utilisateur1 = "yuvraj_chandra"
checkNom d'utilisateur (nom d'utilisateur1)
nom_utilisateur2 = "ja7&^%87"
checkNom d'utilisateur (nom d'utilisateur2)

L'exécution de ce code confirmera que le premier nom d'utilisateur est valide mais que le second ne l'est pas :

De même, vous pouvez valider un nom d'utilisateur en JavaScript à l'aide du code suivant :

fonctioncheckUsername(utilisateur) {
si(/^[A-Za-z][A-Za-z0-9_]{4,14}$/.test (utilisateur)) {
 console.log('Valide');
 } autre {
 console.log('Pas valide');
 }
}
checkNom d'utilisateur('yuvraj_chandra');
checkNom d'utilisateur('ja7&^%87'); 

Vous pouvez utiliser ce code pour valider des formulaires HTML à l'aide d'expressions régulières.

Regex pour valider une adresse e-mail

La regex pour valider une adresse email n'est pas parfaite. Il n'y a pas d'expression régulière universellement acceptée pour valider une adresse e-mail. Cela se résume complètement à votre définition de valide.

Vous trouverez ci-dessous une liste de conditions qui peuvent valider la plupart des adresses e-mail :

1. Le nom d'utilisateur ne doit contenir que des caractères alphanumériques, des traits de soulignement, des tirets et/ou des points.
2. La chaîne d'identifiant de messagerie doit avoir un caractère @.
3. Le nom de domaine ne doit contenir que des caractères alphanumériques, des traits de soulignement ou des tirets.
4. Il doit y avoir un point après le nom de domaine.
5. L'extension de domaine ne doit contenir que des caractères alphanumériques, des traits de soulignement ou des tirets.
6. La longueur de l'extension de domaine doit être comprise entre 2 et 4.

L'expression régulière suivante satisfait les conditions ci-dessus et peut valider une adresse e-mail :

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

Il s'agit d'une approche Python pour valider une adresse e-mail :

importer concernant
définitivementcheckEmailId(e-mail):
 expression régulière = "^[\w.-]+@([\w-]+\.)+[\w-]{2,4}$"
 r = re.compile (regex)
si (concernant.recherche(r, e-mail)):
 imprimer("Valide")
autre:
 imprimer("Pas valide")
e-mail1 = "[email protected]"
checkEmailId (email1)
email2 = "abc@def@Gmail.kahscg"
checkEmailId (email2)

Encore une fois, la sortie confirme que la première adresse e-mail est valide tandis que la seconde n'est pas valide :

Vous pouvez valider un email en JavaScript en utilisant le code suivant :

fonctioncheckEmailId(e-mail) {
si (/^[\w.-]+@([\w-]+\.)+[\w-]{2,4}$/.test (courriel)) {
console.log('Valide');
 } autre {
console.log('Non valide');
 }
}
checkEmailId("[email protected]");
checkEmailId("abc@[email protected]");

Vérifier la force du mot de passe à l'aide d'expressions régulières

Des mots de passe forts sont essentiels du point de vue de la sécurité. Vous devez vous assurer que les utilisateurs finaux disposent de mots de passe suffisamment forts pour que d'autres ne puissent pas accéder à leurs comptes.

Les règles suivantes garantissent que la force du mot de passe de votre application est forte :

1. Le nombre minimum de caractères doit être de 8.
2. La chaîne doit comporter au moins un chiffre.
3. La chaîne doit avoir au moins un caractère majuscule.
4. La chaîne doit contenir au moins un caractère minuscule.
5. La chaîne doit avoir au moins un caractère spécial.

L'expression régulière suivante satisfait les conditions ci-dessus et peut aider à garantir un mot de passe plus fort :

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

Vous pouvez vérifier la force du mot de passe dans Python à l'aide du code suivant :

importer concernant
définitivementcheckPasswordStrength(mot de passe):
 expression régulière = "(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])(?=.*[^A-Za-z0-9])(?=.{ 8,})"
 r = re.compile (regex)
si (concernant.recherche(r, mot de passe)):
 imprimer("Mot de passe fort")
autre:
 imprimer("Mot de passe faible")
mot de passe1 = "Hiuahd$5jawd"
checkPasswordStrength (password1)
mot de passe2 = "mon mot de passe"
checkPasswordStrength (password2)

L'exécution de ce code confirmera que le premier mot de passe est fort tandis que le second est faible :

Vous pouvez vérifier la force du mot de passe en JavaScript à l'aide du code suivant :

fonctioncheckPasswordStrength(mot de passe) {
si (/(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])(?=.*[^A-Za-z0-9])(?=.{8,})/.test (mot de passe)) {
 console.log('Mot de passe fort');
 } autre {
 console.log('Mot de passe faible');
 }
}
checkPasswordStrength('Hiuahd$5jawd');
checkPasswordStrength('mon mot de passe');

Expression régulière pour correspondre à une date valide

Si vous souhaitez vérifier rapidement si les dates données sont au format de date traditionnel ou non, vous pouvez le faire en utilisant regex.

L'expression régulière suivante correspond à une date dans mm/jj/aaaa format:

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

Le code Python suivant valide la date dans mm/jj/aaaa format:

importer concernant
définitivementcheckDateFormat(date):
 expression régulière = "^(0[1-9]|1[012])[- /.](0[1-9]|[12][0-9]|3[01])[- /.](19|20 )\d\d$"
 r = re.compile (regex)
si(concernant.recherche(r, date)):
 imprimer("Valide")
autre:
 imprimer("Pas valide")
date1 = "03/21/2002"
checkDateFormat (date1)
date2 = "15/21/2002"
checkDateFormat (date2)

Une fois de plus, la sortie confirme que le premier format de date est valide, mais que le second n'est pas valide :

Vous pouvez valider la date dans mm/jj/aaaa formater en JavaScript en utilisant le code suivant :

fonctioncheckDateFormat(date) {
si(/^(0[1-9]|1[012])[- /.](0[1-9]|[12][0-9]|3[01])[- /.](19| 20)\d\d$/.test (date)) {
 console.log('Valide');
 } autre {
 console.log('Pas valide');
 }
}
checkDateFormat('03/21/2002');
checkDateFormat('15/21/2002');

Validation de chaînes vides à l'aide d'expressions régulières

Vous pouvez vérifier si une chaîne est vide à l'aide de l'expression régulière suivante :

^$

Vous trouverez ci-dessous l'approche Python pour la validation des chaînes vides :

importer concernant
définitivementcheckEmptyString(str):
 expression régulière = "^$"
 r = re.compile (regex)
si (concernant.recherche(r, chaîne)):
imprimer("La chaîne donnée est vide")
autre:
imprimer("La chaîne donnée n'est pas vide")
chaîne1 = ""
checkChaîneVide (str1)
chaîne2 = "Ceci n'est pas une chaîne vide"
checkChaîneVide (str2)

La sortie suivante montre que la première chaîne donnée est vide alors que la seconde ne l'est pas :

Utilisez le code JavaScript suivant pour vérifier si la chaîne est vide ou non :

fonctioncheckEmptyString(chaîne) {
si (/^$/.test (str)) {
 console.log('La chaîne donnée est vide');
 } autre {
 console.log('La chaîne donnée n'est pas vide');
 }
}
checkChaîneVide('');
checkChaîneVide('Ceci n'est pas une chaîne vide'); 

RegEx pour valider le code postal (code postal américain)

Vous pouvez valider un code postal (code postal américain) aux formats à cinq et neuf chiffres (appelé ZIP+4) à l'aide de l'expression régulière suivante :

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

Ci-dessous le code Python pour valider les codes postaux :

importer concernant
définitivementvaliderZIPCode(code):
 expression régulière = "^[0-9]{5}(?:-[0-9]{4})?$"
 r = re.compile (regex)
si (concernant.recherche(r, code)):
 imprimer("Valide")
autre:
 imprimer("Pas valide")
code1 = "76309"
validerZIPCode (code1)
code2 = "83468-2348"
validerZIPCode (code2)
code3 = "234445"
validerZIPCode (code3)

L'exécution de ce code confirmera que les premier et deuxième codes postaux sont valides mais que le troisième ne l'est pas :

Utilisez le code JavaScript suivant pour valider le code postal à l'aide de regex :

fonctionvaliderZIPCode(code) {
si (/^[0-9]{5}(?:-[0-9]{4})?$/.test (code)) {
 console.log('Valide');
 } autre {
 console.log('Pas valide');
 }
}
validerZIPCode('76309');
validerZIPCode('83468-2348');
validerZIPCode('234445');

Vérifier l'entrée de l'utilisateur avec un code robuste

Vous avez appris à valider les détails d'un compte utilisateur à l'aide d'expressions régulières. La validation de ces détails rend le code robuste et aide à résoudre les problèmes de sécurité et les bogues indésirables. Un code robuste offre une expérience sûre et sécurisée à vos utilisateurs.

Vous devez vous assurer que vous validez les données d'entrée côté client ou côté serveur pour être toujours à l'abri des pirates.