Hur man validerar användarkontouppgifter med hjälp av reguljära uttryck

Reguljära uttryck är ett integrerat programmeringsverktyg som du kan använda för många praktiska dagliga uppgifter. Du kan använda reguljära uttryck för att söka, matcha eller analysera text. Med rätt mönster kan du validera några av de vanligaste användarkontodetaljerna.

Du kan använda reguljära uttryck med många språk eller verktyg, inklusive Python och JavaScript.

Regex för att validera ett användarnamn

Överväg ett användarnamn som endast är giltigt om det uppfyller följande villkor:

1. Antalet tecken måste vara mellan 5 och 15. (Du kan ange ett annat intervall enligt dina krav, men gör ändringar i regexet i enlighet med detta.)
instagram viewer
2. Strängen ska endast innehålla alfanumeriska tecken och/eller understreck (_).
3. Det första tecknet i strängen ska vara alfabetiskt.

Följande regex uppfyller ovanstående villkor och kan validera ett användarnamn:

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

Om du inte är bekväm med uttrycket ovan, kolla in en nybörjarguide till reguljära uttryck först. Detta är en Python-metod för att validera ett användarnamn:

importera re
defkontrollera Användarnamn(Användarnamn):
 regex = "^[A-Za-z]\\w{4,14}$"
 r = re.compile (regex)
om (re.Sök(r, Användarnamn)):
 skriva ut("Giltig")
annan:
 skriva ut("Inte giltig")
användarnamn1 = "yuvraj_chandra"
checkUsername (användarnamn1)
användarnamn2 = "ja7&^%87"
checkAnvändarnamn (användarnamn2)

Att köra den här koden kommer att bekräfta att det första användarnamnet är giltigt men att det andra inte är:

På samma sätt kan du validera ett användarnamn i JavaScript med följande kod:

fungerakontrollera Användarnamn(användare) {
om(/^[A-Za-z][A-Za-z0-9_]{4,14}$/.test (användare)) {
 console.log('Giltig');
 } annan {
 console.log('Inte giltig');
 }
}
kontrollera användarnamn('yuvraj_chandra');
kontrollera användarnamn('ja7&^%87'); 

Du kan använda den här koden för att validera HTML-formulär med reguljära uttryck.

Regex för att validera en e-postadress

Regexet för att validera en e-postadress är inte perfekt. Det finns inget allmänt överenskommet regex för att validera en e-postadress. Det kokar helt ner till din definition av giltig.

Nedan finns en lista över villkor som kan validera de flesta e-postadresser:

1. Användarnamnet ska bara innehålla alfanumeriska tecken, understreck, bindestreck och/eller prickar.
2. E-post-id-strängen måste ha ett @-tecken.
3. Domännamnet ska bara innehålla alfanumeriska tecken, understreck eller bindestreck.
4. Det måste finnas en prick efter domännamnet.
5. Domäntillägget ska bara innehålla alfanumeriska tecken, understreck eller bindestreck.
6. Domänförlängningens längd bör vara mellan 2 och 4.

Följande regex uppfyller ovanstående villkor och kan validera en e-postadress:

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

Detta är en Python-metod för att validera en e-postadress:

importera re
defcheckEmailId(e-post):
 regex = "^[\w.-]+@([\w-]+\.)+[\w-]{2,4}$"
 r = re.compile (regex)
om (re.Sök(r, e-post)):
 skriva ut("Giltig")
annan:
 skriva ut("Inte giltig")
email1 = "[email protected]"
checkEmailId (email1)
email2 = "abc@def@gmail.kahscg"
checkEmailId (email2)

Återigen bekräftar utdata att den första e-postadressen är giltig medan den andra är ogiltig:

Du kan validera ett e-postmeddelande i JavaScript med följande kod:

fungeracheckEmailId(e-post) {
om (/^[\w.-]+@([\w-]+\.)+[\w-]{2,4}$/.test (e-post)) {
trösta.log('Giltigt');
 } annan {
trösta.log('Inte giltig');
 }
}
checkEmailId("[email protected]");
checkEmailId("abc@[email protected]");

Kontrollera lösenordsstyrkan med hjälp av reguljära uttryck

Starka lösenord är viktiga ur ett säkerhetsperspektiv. Du måste se till att slutanvändare har tillräckligt starka lösenord så att andra inte kan komma åt deras konton.

Följande regler ser till att lösenordsstyrkan för din applikation är stark:

1. Minsta antal tecken måste vara 8.
2. Strängen måste ha minst en siffra.
3. Strängen måste ha minst en versal.
4. Strängen måste ha minst ett gement tecken.
5. Strängen måste ha minst ett specialtecken.

Följande regex uppfyller ovanstående villkor och kan hjälpa till att säkerställa ett starkare lösenord:

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

Du kan kontrollera lösenordets styrka i Python med följande kod:

importera re
defcheckPasswordStrength(Lösenord):
 regex = "(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])(?=.*[^A-Za-z0-9])(?=.{ 8,})"
 r = re.compile (regex)
om (re.Sök(r, Lösenord)):
 skriva ut("Starkt lösenord")
annan:
 skriva ut("Svagt lösenord")
lösenord1 = "Hiuahd $5jawd"
checkPasswordStrength (lösenord1)
lösenord2 = "mitt lösenord"
checkPasswordStrength (lösenord2)

Att köra den här koden kommer att bekräfta att det första lösenordet är starkt medan det andra är svagt:

Du kan kontrollera lösenordsstyrkan i JavaScript med följande kod:

fungeracheckPasswordStrength(Lösenord) {
om (/(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])(?=.*[^A-Za-z0-9])(?=.{8,})/.test (lösenord)) {
 console.log('Starkt lösenord');
 } annan {
 console.log('Svagt lösenord');
 }
}
checkPasswordStrength('Hiuahd $5jawd');
checkPasswordStrength('mitt lösenord');

Reguljära uttryck för att matcha ett giltigt datum

Om du snabbt vill kontrollera om de givna datumen är i det traditionella datumformatet eller inte, kan du göra det med regex.

Följande reguljära uttryck matchar ett datum i mm/dd/åååå formatera:

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

Följande Python-kod bekräftar att datumet är inne mm/dd/åååå formatera:

importera re
defcheckDateFormat(datum):
 regex = "^(0[1-9]|1[012])[- /.](0[1-9]|[12][0-9]|3[01])[- /.](19|20 )\d\d$"
 r = re.compile (regex)
om(re.Sök(r, datum)):
 skriva ut("Giltig")
annan:
 skriva ut("Inte giltig")
datum1 = "03/21/2002"
checkDateFormat (datum1)
datum 2 = "15/21/2002"
checkDateFormat (date2)

Än en gång bekräftar utdata att det första datumformatet är giltigt, men det andra är ogiltigt:

Du kan validera datumet i mm/dd/åååå formatera i JavaScript med följande kod:

fungeracheckDateFormat(datum) {
om(/^(0[1-9]|1[012])[- /.](0[1-9]|[12][0-9]|3[01])[- /.](19| 20)\d\d$/.testdatum)) {
 console.log('Giltig');
 } annan {
 console.log('Inte giltig');
 }
}
checkDateFormat('03/21/2002');
checkDateFormat('15/21/2002');

Validering av tom sträng med hjälp av reguljära uttryck

Du kan kontrollera om en sträng är tom med följande reguljära uttryck:

^$

Nedan är Python-metoden för validering av tomma strängar:

importera re
defcheckEmptyString(str):
 regex = "^$"
 r = re.compile (regex)
om (re.Sök(r, str)):
skriva ut("Den givna strängen är tömma")
annan:
skriva ut("Den givna strängen är inte tömma")
str1 = ""
checkEmptyString (str1)
str2 = "Detta är inte en tom sträng"
checkEmptyString (str2)

Följande utdata visar att den första givna strängen är tom medan den andra inte är det:

Använd följande JavaScript-kod för att kontrollera om strängen är tom eller inte:

fungeracheckEmptyString(str) {
om (/^$/.test (str)) {
 console.log('Den angivna strängen är tom');
 } annan {
 console.log('Den angivna strängen är inte tom');
 }
}
checkEmptyString('');
checkEmptyString('Detta är inte en tom sträng'); 

RegEx för att validera postnummer (US Postal Code)

Du kan validera ett postnummer (amerikanskt postnummer) i både femsiffrigt och niosiffrigt (kallat ZIP+4) format med hjälp av följande reguljära uttryck:

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

Nedan finns Python-koden för att validera postnummer:

importera re
defvalidera Postnummer(koda):
 regex = "^[0-9]{5}(?:-[0-9]{4})?$"
 r = re.compile (regex)
om (re.Sök(r, koda)):
 skriva ut("Giltig")
annan:
 skriva ut("Inte giltig")
kod1 = "76309"
validera Postnummer (kod1)
kod2 = "83468-2348"
validera Postnummer (kod2)
kod3 = "234445"
validera Postnummer (kod3)

Att köra den här koden kommer att bekräfta att det första och andra postnumret är giltigt men att det tredje inte är:

Använd följande JavaScript-kod för att validera postnumret med regex:

fungeravalidera Postnummer(koda) {
om (/^[0-9]{5}(?:-[0-9]{4})?$/.test (kod)) {
 console.log('Giltig');
 } annan {
 console.log('Inte giltig');
 }
}
validera Postnummer('76309');
validera Postnummer('83468-2348');
validera Postnummer('234445');

Verifiera användarinmatning med robust kod

Du lärde dig hur du validerar användarkontodetaljer med hjälp av reguljära uttryck. Att validera dessa detaljer gör koden robust och hjälper till att hantera säkerhetsproblem och oönskade buggar. Robust kod ger en säker och säker upplevelse för dina användare.

Du bör se till att du validerar indata antingen på klientsidan eller serversidan för att alltid vara på den säkra sidan från hackare.