Kako potrditi podrobnosti uporabniškega računa z uporabo regularnih izrazov

Regularni izrazi so sestavno programsko orodje, ki ga lahko uporabite za številna praktična vsakodnevna opravila. Za iskanje, ujemanje ali razčlenjevanje besedila lahko uporabite regularne izraze. S pravimi vzorci lahko preverite nekatere najpogostejše podrobnosti uporabniškega računa.

Regularne izraze lahko uporabljate s številnimi jeziki ali orodji, vključno s Pythonom in JavaScriptom.

Regex za preverjanje uporabniškega imena

Upoštevajte uporabniško ime, ki je veljavno le, če izpolnjuje naslednje pogoje:

1. Število znakov mora biti med 5 in 15. (Lahko podate drugačen obseg glede na vaše zahteve, vendar ustrezno spremenite regularni izraz.)
instagram viewer
2. Niz naj vsebuje samo alfanumerične znake in/ali podčrtaje (_).
3. Prvi znak niza mora biti abecedni.

Naslednji regularni izraz izpolnjuje zgornje pogoje in lahko potrdi uporabniško ime:

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

Če vam zgornji izraz ni všeč, preverite začetniški vodnik po regularnih izrazih prvi. To je pristop Python za preverjanje uporabniškega imena:

uvoz re
defpreveri uporabniško ime(uporabniško ime):
 regex = "^[A-Za-z]\\w{4,14}$"
 r = re.compile (regex)
če (re.Iskanje(r, uporabniško ime)):
 natisni("Veljavno")
drugače:
 natisni("Ni veljaven")
uporabniško ime1 = "yuvraj_chandra"
preveri uporabniško ime (uporabniško ime1)
uporabniško ime2 = "ja7&^%87"
preveri uporabniško ime (uporabniško ime2)

Zagon te kode bo potrdil, da je prvo uporabniško ime veljavno, drugo pa ne:

Podobno lahko potrdite uporabniško ime v JavaScriptu z naslednjo kodo:

funkcijopreveri uporabniško ime(uporabnik) {
če(/^[A-Za-z][A-Za-z0-9_]{4,14}$/.test (uporabnik)) {
 console.log('Veljavno');
 } drugače {
 console.log('Ni veljaven');
 }
}
preveri uporabniško ime('yuvraj_chandra');
preveri uporabniško ime('ja7&^%87'); 

To kodo lahko uporabite za preverjanje obrazcev HTML z uporabo regularnih izrazov.

Regex za preverjanje e-poštnega naslova

Regularni izraz za potrditev e-poštnega naslova ni popoln. Za potrditev e-poštnega naslova ni univerzalno dogovorjenega regularnega izraza. Popolnoma se skrči na vašo definicijo veljavnosti.

Spodaj je seznam pogojev, ki lahko potrdijo večino e-poštnih naslovov:

1. Uporabniško ime mora vsebovati samo alfanumerične znake, podčrtaj, pomišljaj in/ali piko.
2. Niz ID-ja e-pošte mora imeti en znak @.
3. Ime domene mora vsebovati samo alfanumerične znake, podčrtaj ali pomišljaj.
4. Za imenom domene mora biti pika.
5. Domenska končnica naj vsebuje le alfanumerične znake, podčrtaj ali pomišljaj.
6. Dolžina domenske končnice naj bo med 2 in 4.

Naslednji regularni izraz izpolnjuje zgornje pogoje in lahko potrdi e-poštni naslov:

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

To je pristop Pythona k preverjanju e-poštnega naslova:

uvoz re
defpreveriEmailId(E-naslov):
 regex = "^[\w.-]+@([\w-]+\.)+[\w-]{2,4}$"
 r = re.compile (regex)
če (re.Iskanje(r, E-naslov)):
 natisni("Veljavno")
drugače:
 natisni("Ni veljaven")
email1 = "[email protected]"
preveriEmailId (email1)
email2 = "abc@def@gmail.kahscg"
preveriEmailId (email2)

Ponovno izhod potrjuje, da je prvi e-poštni naslov veljaven, medtem ko je drugi neveljaven:

E-poštno sporočilo v JavaScriptu lahko potrdite z naslednjo kodo:

funkcijopreveriEmailId(E-naslov) {
če (/^[\w.-]+@([\w-]+\.)+[\w-]{2,4}$/.test (e-pošta)) {
konzola.log('Veljaven');
 } drugače {
konzola.log('Ni veljavno');
 }
}
checkEmailId("[email protected]");
checkEmailId("abc@[email protected]");

Preverite moč gesla z uporabo regularnih izrazov

Močna gesla so bistvena z varnostnega vidika. Zagotoviti morate, da imajo končni uporabniki dovolj močna gesla, da drugi ne morejo dostopati do njihovih računov.

Naslednja pravila zagotavljajo, da je moč gesla vaše aplikacije močna:

1. Najmanjše število znakov mora biti 8.
2. Niz mora imeti vsaj eno števko.
3. Niz mora imeti vsaj eno veliko črko.
4. Niz mora imeti vsaj eno malo črko.
5. Niz mora imeti vsaj en poseben znak.

Naslednji regularni izraz izpolnjuje zgornje pogoje in lahko pomaga zagotoviti močnejše geslo:

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

Moč gesla v Pythonu lahko preverite z naslednjo kodo:

uvoz re
defpreveriPasswordStrength(geslo):
 regex = "(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])(?=.*[^A-Za-z0-9])(?={ 8,})"
 r = re.compile (regex)
če (re.Iskanje(r, geslo)):
 natisni("Močno geslo")
drugače:
 natisni("Šibko geslo")
geslo1 = "Hiuahd $5jawd"
preveriPasswordStrength (geslo1)
geslo2 = "moje_geslo"
preveriPasswordStrength (geslo2)

Zagon te kode bo potrdil, da je prvo geslo močno, drugo pa šibko:

Moč gesla v JavaScriptu lahko preverite z naslednjo kodo:

funkcijopreveriPasswordStrength(geslo) {
če (/(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])(?=.*[^A-Za-z0-9])(?=.{8,})/.test (geslo)) {
 console.log('Močno geslo');
 } drugače {
 console.log('Šibko geslo');
 }
}
preveriPasswordStrength('Hiuahd $5jawd');
preveriPasswordStrength('moje_geslo');

Regularni izraz za ujemanje z veljavnim datumom

Če želite hitro preveriti, ali so dani datumi v tradicionalni obliki datuma ali ne, lahko to storite z regularnim izrazom.

Naslednji regularni izraz se ujema z datumom v mm/dd/llll format:

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

Naslednja koda Python potrdi, da je datum v mm/dd/llll format:

uvoz 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)
če(re.Iskanje(r, datum)):
 natisni("Veljavno")
drugače:
 natisni("Ni veljaven")
datum1 = "03/21/2002"
checkDateFormat (datum1)
datum2 = "15/21/2002"
checkDateFormat (datum2)

Še enkrat izhod potrdi, da je prvi format datuma veljaven, drugi pa neveljaven:

Datum lahko potrdite v mm/dd/llll formatirajte v JavaScript z naslednjo kodo:

funkcijocheckDateFormat(datum) {
če(/^(0[1-9]|1[012])[- /.](0[1-9]|[12][0-9]|3[01])[- /.](19| 20)\d\d$/.test (datum)) {
 console.log('Veljavno');
 } drugače {
 console.log('Ni veljaven');
 }
}
checkDateFormat('03/21/2002');
checkDateFormat('15/21/2002');

Preverjanje praznega niza z uporabo regularnih izrazov

Z naslednjim regularnim izrazom lahko preverite, ali je niz prazen:

^$

Spodaj je pristop Python za preverjanje praznega niza:

uvoz re
defpreveriEmptyString(str):
 regex = "^$"
 r = re.compile (regex)
če (re.Iskanje(r, str)):
tiskanje("Dani niz je prazno")
drugače:
tiskanje("Dani niz ni prazno")
str1 = ""
preveriEmptyString (str1)
str2 = "To ni prazen niz"
checkEmptyString (str2)

Naslednji izhod dokazuje, da je prvi podani niz prazen, medtem ko drugi ni:

Uporabite naslednjo kodo JavaScript, da preverite, ali je niz prazen ali ne:

funkcijopreveriEmptyString(str) {
če (/^$/.test (str)) {
 console.log('Dani niz je prazen');
 } drugače {
 console.log('Podani niz ni prazen');
 }
}
checkEmptyString('');
checkEmptyString('To ni prazen niz'); 

RegEx za preverjanje poštne številke (poštna številka ZDA)

Poštno številko (poštno številko ZDA) lahko potrdite v petmestni in devetmestni (imenovani ZIP+4) obliki z uporabo naslednjega regularnega izraza:

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

Spodaj je koda Python za preverjanje poštnih številk:

uvoz re
defvalidateZIPCode(Koda):
 regex = "^[0-9]{5}(?:-[0-9]{4})?$"
 r = re.compile (regex)
če (re.Iskanje(r, Koda)):
 natisni("Veljavno")
drugače:
 natisni("Ni veljaven")
koda1 = "76309"
validateZIPCode (code1)
koda2 = "83468-2348"
validateZIPCode (code2)
koda3 = "234445"
validateZIPCode (code3)

Zagon te kode bo potrdil, da sta prva in druga poštna številka veljavni, tretja pa ne:

Za preverjanje poštne številke z regularnim izrazom uporabite naslednjo kodo JavaScript:

funkcijovalidateZIPCode(Koda) {
če (/^[0-9]{5}(?:-[0-9]{4})?$/.test (koda)) {
 console.log('Veljavno');
 } drugače {
 console.log('Ni veljaven');
 }
}
validateZIPCode('76309');
validateZIPCode('83468-2348');
validateZIPCode('234445');

Preverite uporabniški vnos z robustno kodo

Naučili ste se preveriti podrobnosti uporabniškega računa z uporabo regularnih izrazov. Preverjanje teh podrobnosti naredi kodo robustno in pomaga pri reševanju varnostnih težav in neželenih napak. Robustna koda zagotavlja varno in zaščiteno izkušnjo za vaše uporabnike.

Prepričajte se, da preverjate vhodne podatke na strani odjemalca ali na strani strežnika, da boste vedno na varni strani pred hekerji.