Sådan validerer du brugerkontooplysninger ved hjælp af regulære udtryk

Regulære udtryk er et integreret programmeringsværktøj, som du kan bruge til mange praktiske daglige opgaver. Du kan bruge regulære udtryk til at søge, matche eller analysere tekst. Med de rigtige mønstre kan du validere nogle af de mest almindelige brugerkontodetaljer.

Du kan bruge regulære udtryk med mange sprog eller værktøjer, inklusive Python og JavaScript.

Regex for at validere et brugernavn

Overvej et brugernavn, der kun er gyldigt, hvis det opfylder følgende betingelser:

1. Antallet af tegn skal være mellem 5 og 15. (Du kan angive et andet interval i henhold til dine krav, men foretag ændringer i regex i overensstemmelse hermed.)
2. Strengen må kun indeholde alfanumeriske tegn og/eller understregninger (_).
instagram viewer
3. Det første tegn i strengen skal være alfabetisk.

Følgende regex opfylder ovenstående betingelser og kan validere et brugernavn:

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

Hvis du ikke er tryg ved ovenstående udtryk, så tjek ud en begynderguide til regulære udtryk først. Dette er en Python-tilgang til at validere et brugernavn:

importere vedr
defcheck Brugernavn(brugernavn):
 regex = "^[A-Za-z]\\w{4,14}$"
 r = re.compile (regex)
hvis (vedr.Søg(r, brugernavn)):
 Print("Gyldig")
andet:
 Print("Ikke gyldig")
brugernavn1 = "yuvraj_chandra"
checkBrugernavn (brugernavn1)
brugernavn2 = "ja7&^%87"
checkBrugernavn (brugernavn2)

At køre denne kode vil bekræfte, at det første brugernavn er gyldigt, men det andet er ikke:

På samme måde kan du validere et brugernavn i JavaScript ved hjælp af følgende kode:

fungerecheck Brugernavn(bruger) {
hvis(/^[A-Za-z][A-Za-z0-9_]{4,14}$/.test (bruger)) {
 console.log('Gyldig');
 } andet {
 console.log('Ikke gyldig');
 }
}
checkBrugernavn('yuvraj_chandra');
checkBrugernavn('ja7&^%87'); 

Du kan bruge denne kode til validere HTML-formularer ved hjælp af regulære udtryk.

Regex for at validere en e-mail-adresse

Regex til at validere en e-mailadresse er ikke perfekt. Der er ingen universelt aftalt regex til at validere en e-mailadresse. Det koger fuldstændig ned til din definition af gyldig.

Nedenfor er en liste over betingelser, der kan validere de fleste e-mailadresser:

1. Brugernavnet må kun indeholde alfanumeriske tegn, understregningstegn, bindestreg og/eller prikker.
2. E-mail-id-strengen skal have ét @-tegn.
3. Domænenavnet må kun indeholde alfanumeriske tegn, understregningstegn eller bindestreg.
4. Der skal være en prik efter domænenavnet.
5. Domæneudvidelsen må kun indeholde alfanumeriske tegn, understregningstegn eller bindestreg.
6. Domæneudvidelseslængden skal være mellem 2 og 4.

Følgende regulære udtryk opfylder ovenstående betingelser og kan validere en e-mailadresse:

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

Dette er en Python-tilgang til at validere en e-mailadresse:

importere vedr
defcheckEmailId(e-mail):
 regex = "^[\w.-]+@([\w-]+\.)+[\w-]{2,4}$"
 r = re.compile (regex)
hvis (vedr.Søg(r, e-mail)):
 Print("Gyldig")
andet:
 Print("Ikke gyldig")
email1 = "[email protected]"
checkEmailId (email1)
email2 = "abc@def@gmail.kahscg"
checkEmailId (email2)

Igen bekræfter outputtet, at den første e-mailadresse er gyldig, mens den anden er ugyldig:

Du kan validere en e-mail i JavaScript ved hjælp af følgende kode:

fungerecheckEmailId(e-mail) {
hvis (/^[\w.-]+@([\w-]+\.)+[\w-]{2,4}$/.test (e-mail)) {
konsol.log('Gyldig');
 } andet {
konsol.log('Ikke gyldig');
 }
}
checkEmailId("[email protected]");
checkEmailId("abc@[email protected]");

Tjek adgangskodestyrke ved hjælp af regulære udtryk

Stærke adgangskoder er afgørende ud fra et sikkerhedsperspektiv. Du skal sikre dig, at slutbrugere har stærke nok adgangskoder, så andre ikke kan få adgang til deres konti.

Følgende regler sikrer, at din applikations adgangskodestyrke er stærk:

1. Minimumsantallet af tegn skal være 8.
2. Strengen skal have mindst ét ​​ciffer.
3. Strengen skal have mindst ét ​​stort tegn.
4. Strengen skal have mindst ét ​​lille bogstav.
5. Strengen skal have mindst ét ​​specialtegn.

Følgende regex opfylder ovenstående betingelser og kan hjælpe med at sikre en stærkere adgangskode:

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

Du kan kontrollere adgangskodestyrken i Python ved hjælp af følgende kode:

importere vedr
defcheckPasswordStrength(adgangskode):
 regex = "(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])(?=.*[^A-Za-z0-9])(?=.{ 8,})"
 r = re.compile (regex)
hvis (vedr.Søg(r, adgangskode)):
 Print("Stærk adgangskode")
andet:
 Print("Svagt kodeord")
adgangskode1 = "Hiuahd$5jawd"
checkPasswordStrength (adgangskode1)
adgangskode2 = "mit_adgangskode"
checkPasswordStrength (adgangskode2)

Kørsel af denne kode vil bekræfte, at den første adgangskode er stærk, mens den anden er svag:

Du kan kontrollere adgangskodens styrke i JavaScript ved hjælp af følgende kode:

fungerecheckPasswordStrength(adgangskode) {
hvis (/(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])(?=.*[^A-Za-z0-9])(?=.{8,})/.test (adgangskode)) {
 console.log('Stærk adgangskode');
 } andet {
 console.log('Svagt kodeord');
 }
}
checkPasswordStrength('Hiuahd$5jawd');
checkPasswordStrength('mit_adgangskode');

Regulært udtryk for at matche en gyldig dato

Hvis du hurtigt vil tjekke, om de givne datoer er i det traditionelle datoformat eller ej, kan du gøre det ved hjælp af regex.

Følgende regulære udtryk matcher en dato i mm/dd/åååå format:

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

Følgende Python-kode validerer datoen er inde mm/dd/åååå format:

importere vedr
defcheckDateFormat(dato):
 regex = "^(0[1-9]|1[012])[- /.](0[1-9]|[12][0-9]|3[01])[- /.](19|20 )\d\d$"
 r = re.compile (regex)
hvis(vedr.Søg(r, dato)):
 Print("Gyldig")
andet:
 Print("Ikke gyldig")
dato1 = "03/21/2002"
checkDateFormat (dato1)
dato 2 = "15/21/2002"
checkDateFormat (dato2)

Endnu en gang bekræfter outputtet, at det første datoformat er gyldigt, men det andet er ugyldigt:

Du kan validere datoen i mm/dd/åååå format i JavaScript ved hjælp af følgende kode:

fungerecheckDateFormat(dato) {
hvis(/^(0[1-9]|1[012])[- /.](0[1-9]|[12][0-9]|3[01])[- /.](19| 20)\d\d$/.test (dato)) {
 console.log('Gyldig');
 } andet {
 console.log('Ikke gyldig');
 }
}
checkDateFormat('03/21/2002');
checkDateFormat('15/21/2002');

Validering af tomme strenge ved hjælp af regulære udtryk

Du kan kontrollere, om en streng er tom ved at bruge følgende regulære udtryk:

^$

Nedenfor er Python-tilgangen til tom strengvalidering:

importere vedr
defcheckEmptyString(str):
 regex = "^$"
 r = re.compile (regex)
hvis (vedr.Søg(r, str)):
Print("Den givne streng er tom")
andet:
Print("Den givne streng er ikke tom")
str1 = ""
checkEmptyString (str1)
str2 = "Dette er ikke en tom streng"
checkEmptyString (str2)

Følgende output viser, at den første givne streng er tom, mens den anden ikke er det:

Brug følgende JavaScript-kode til at kontrollere, om strengen er tom eller ej:

fungerecheckEmptyString(str) {
hvis (/^$/.test (str)) {
 console.log('Den angivne streng er tom');
 } andet {
 console.log('Den angivne streng er ikke tom');
 }
}
checkEmptyString('');
checkEmptyString('Dette er ikke en tom streng'); 

RegEx for at validere postnummer (US Postal Code)

Du kan validere et postnummer (amerikansk postnummer) i både de fem-cifrede og ni-cifrede (kaldet ZIP+4) formater ved hjælp af følgende regulære udtryk:

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

Nedenfor er Python-koden til at validere postnumre:

importere vedr
defvalider postnummer(kode):
 regex = "^[0-9]{5}(?:-[0-9]{4})?$"
 r = re.compile (regex)
hvis (vedr.Søg(r, kode)):
 Print("Gyldig")
andet:
 Print("Ikke gyldig")
kode1 = "76309"
valider postnummer (kode1)
kode2 = "83468-2348"
valider postnummer (kode2)
kode3 = "234445"
valider postnummer (kode3)

Hvis du kører denne kode, bekræftes det, at det første og andet postnummer er gyldigt, men det tredje er ikke:

Brug følgende JavaScript-kode til at validere postnummeret ved hjælp af regex:

fungerevalider postnummer(kode) {
hvis (/^[0-9]{5}(?:-[0-9]{4})?$/.test (kode)) {
 console.log('Gyldig');
 } andet {
 console.log('Ikke gyldig');
 }
}
valider postnummer('76309');
valider postnummer('83468-2348');
valider postnummer('234445');

Bekræft brugerinput med robust kode

Du lærte, hvordan du validerer brugerkontooplysninger ved hjælp af regulære udtryk. Validering af disse detaljer gør koden robust og hjælper med at tackle sikkerhedsproblemer og uønskede fejl. Robust kode giver en sikker og sikker oplevelse for dine brugere.

Du bør sikre dig, at du validerer inputdata enten på klientsiden eller serversiden for altid at være på den sikre side fra hackere.