Slik validerer du brukerkontodetaljer ved hjelp av regulære uttrykk

Regulære uttrykk er et integrert programmeringsverktøy som du kan bruke til mange praktiske daglige oppgaver. Du kan bruke regulære uttrykk for å søke, matche eller analysere tekst. Med de riktige mønstrene kan du validere noen av de vanligste brukerkontodetaljene.

Du kan bruke regulære uttrykk med mange språk eller verktøy, inkludert Python og JavaScript.

Regex for å validere et brukernavn

Vurder et brukernavn som bare er gyldig hvis det oppfyller følgende betingelser:

1. Antall tegn må være mellom 5 og 15. (Du kan spesifisere et annet område i henhold til dine krav, men gjør endringer i det regulære uttrykket tilsvarende.)
2. Strengen skal bare inneholde alfanumeriske tegn og/eller understreker (_).
instagram viewer
3. Det første tegnet i strengen skal være alfabetisk.

Følgende regulære uttrykk oppfyller betingelsene ovenfor og kan validere et brukernavn:

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

Hvis du ikke er komfortabel med uttrykket ovenfor, sjekk ut en nybegynnerguide til regulære uttrykk først. Dette er en Python-tilnærming for å validere et brukernavn:

import re
defsjekk Brukernavn(brukernavn):
 regex = "^[A-Za-z]\\w{4,14}$"
 r = re.compile (regex)
hvis (re.Søk(r, brukernavn)):
 skrive ut("Gyldig")
ellers:
 skrive ut("Ikke gyldig")
brukernavn1 = "yuvraj_chandra"
sjekkBrukernavn (brukernavn1)
brukernavn2 = "ja7&^%87"
sjekkBrukernavn (brukernavn2)

Å kjøre denne koden vil bekrefte at det første brukernavnet er gyldig, men det andre ikke er:

På samme måte kan du validere et brukernavn i JavaScript ved å bruke følgende kode:

funksjonsjekk Brukernavn(bruker) {
hvis(/^[A-Za-z][A-Za-z0-9_]{4,14}$/.test (bruker)) {
 console.log('Gyldig');
 } ellers {
 console.log('Ikke gyldig');
 }
}
sjekk brukernavn('yuvraj_chandra');
sjekk brukernavn('ja7&^%87'); 

Du kan bruke denne koden til å validere HTML-skjemaer ved hjelp av regulære uttrykk.

Regex for å validere en e-postadresse

Regex for å validere en e-postadresse er ikke perfekt. Det er ingen universelt avtalt regulær uttrykk for å validere en e-postadresse. Det koker helt ned til din definisjon av gyldig.

Nedenfor er en liste over forhold som kan validere de fleste e-postadresser:

1. Brukernavnet skal bare inneholde alfanumeriske, understrekings-, bindestrek- og/eller prikktegn.
2. E-post-ID-strengen må ha ett @-tegn.
3. Domenenavnet skal bare inneholde alfanumeriske tegn, understreking eller bindestrek.
4. Det må være en prikk etter domenenavnet.
5. Domeneutvidelsen skal bare inneholde alfanumeriske tegn, understreking eller bindestrek.
6. Lengden på domeneutvidelsen skal være mellom 2 og 4.

Følgende regulære uttrykk oppfyller vilkårene ovenfor og kan validere en e-postadresse:

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

Dette er en Python-tilnærming for å validere en e-postadresse:

import re
defcheckEmailId(e-post):
 regex = "^[\w.-]+@([\w-]+\.)+[\w-]{2,4}$"
 r = re.compile (regex)
hvis (re.Søk(r, e-post)):
 skrive ut("Gyldig")
ellers:
 skrive ut("Ikke gyldig")
epost1 = "[email protected]"
checkEmailId (email1)
e-post2 = "abc@def@gmail.kahscg"
checkEmailId (email2)

Igjen bekrefter utdata at den første e-postadressen er gyldig mens den andre er ugyldig:

Du kan validere en e-post i JavaScript ved å bruke følgende kode:

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

Sjekk passordstyrken ved å bruke regulære uttrykk

Sterke passord er avgjørende fra et sikkerhetsperspektiv. Du må sørge for at sluttbrukere har sterke nok passord slik at andre ikke får tilgang til kontoene deres.

Følgende regler sørger for at passordstyrken til applikasjonen din er sterk:

1. Minimum antall tegn må være 8.
2. Strengen må ha minst ett siffer.
3. Strengen må ha minst ett stort tegn.
4. Strengen må ha minst én liten bokstav.
5. Strengen må ha minst ett spesialtegn.

Følgende regulære uttrykk oppfyller betingelsene ovenfor og kan bidra til å sikre et sterkere passord:

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

Du kan sjekke passordstyrken i Python ved å bruke følgende kode:

import re
defcheckPasswordStrength(passord):
 regex = "(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])(?=.*[^A-Za-z0-9])(?=.{ 8,})"
 r = re.compile (regex)
hvis (re.Søk(r, passord)):
 skrive ut("Sterkt passord")
ellers:
 skrive ut("Svakt passord")
passord1 = "Hiuahd$5jawd"
checkPasswordStrength (password1)
passord2 = "mitt passord"
checkPasswordStrength (password2)

Å kjøre denne koden vil bekrefte at det første passordet er sterkt mens det andre er svakt:

Du kan sjekke passordstyrken i JavaScript ved å bruke følgende kode:

funksjoncheckPasswordStrength(passord) {
hvis (/(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])(?=.*[^A-Za-z0-9])(?=.{8,})/.test (passord)) {
 console.log('Sterkt passord');
 } ellers {
 console.log('Svakt passord');
 }
}
checkPasswordStrength('Hiuahd$5jawd');
checkPasswordStrength('mitt passord');

Regelmessig uttrykk for å matche en gyldig dato

Hvis du raskt vil sjekke om de gitte datoene er i det tradisjonelle datoformatet eller ikke, kan du gjøre det ved å bruke regulært uttrykk.

Følgende regulære uttrykk samsvarer med 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 bekrefter at datoen er inne mm/dd/åååå format:

import re
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(re.Søk(r, Dato)):
 skrive ut("Gyldig")
ellers:
 skrive ut("Ikke gyldig")
dato1 = "03/21/2002"
checkDateFormat (dato1)
dato 2 = "15/21/2002"
checkDateFormat (dato2)

Nok en gang bekrefter utdata at det første datoformatet er gyldig, men det andre er ugyldig:

Du kan validere datoen i mm/dd/åååå format i JavaScript ved å bruke følgende kode:

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

Validering av tom streng ved bruk av regulære uttrykk

Du kan sjekke om en streng er tom ved å bruke følgende regulære uttrykk:

^$

Nedenfor er Python-tilnærmingen for validering av tom streng:

import re
defcheckEmptyString(str):
 regex = "^$"
 r = re.compile (regex)
hvis (re.Søk(r, str)):
skrive ut("Den gitte strengen er tømme")
ellers:
skrive ut("Den gitte strengen er ikke tømme")
str1 = ""
checkEmptyString (str1)
str2 = "Dette er ikke en tom streng"
checkEmptyString (str2)

Følgende utdata viser at den første gitte strengen er tom mens den andre ikke er det:

Bruk følgende JavaScript-kode for å sjekke om strengen er tom eller ikke:

funksjoncheckEmptyString(str) {
hvis (/^$/.test (str)) {
 console.log('Den angitte strengen er tom');
 } ellers {
 console.log('Den angitte strengen er ikke tom');
 }
}
checkEmptyString('');
checkEmptyString('Dette er ikke en tom streng'); 

RegEx for å validere postnummer (US Postal Code)

Du kan validere et postnummer (amerikansk postnummer) i både femsifrede og nisifrede (kalt ZIP+4) formater ved å bruke følgende regulære uttrykk:

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

Nedenfor er Python-koden for å validere postnummer:

import re
defvalider Postnummer(kode):
 regex = "^[0-9]{5}(?:-[0-9]{4})?$"
 r = re.compile (regex)
hvis (re.Søk(r, kode)):
 skrive ut("Gyldig")
ellers:
 skrive ut("Ikke gyldig")
kode1 = "76309"
valider Postnummer (kode1)
kode2 = "83468-2348"
valider Postnummer (kode2)
kode3 = "234445"
valider Postnummer (kode3)

Å kjøre denne koden vil bekrefte at det første og andre postnummeret er gyldig, men det tredje er ikke:

Bruk følgende JavaScript-kode for å validere postnummeret ved hjelp av regulært uttrykk:

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

Bekreft brukerinndata med robust kode

Du lærte hvordan du validerer brukerkontodetaljer ved hjelp av regulære uttrykk. Validering av disse detaljene gjør koden robust og hjelper til med å takle sikkerhetsproblemer og uønskede feil. Robust kode gir en trygg og sikker opplevelse for brukerne dine.

Du bør sørge for at du validerer inndataene enten på klientsiden eller serversiden for alltid å være på den sikre siden fra hackere.