Kā pārbaudīt lietotāja konta informāciju, izmantojot regulārās izteiksmes

Regulārās izteiksmes ir neatņemams programmēšanas rīks, ko varat izmantot daudziem praktiskiem ikdienas uzdevumiem. Varat izmantot regulārās izteiksmes, lai meklētu, saskaņotu vai parsētu tekstu. Izmantojot pareizos modeļus, varat apstiprināt dažas no visizplatītākajām lietotāja konta detaļām.

Regulārās izteiksmes var izmantot ar daudzām valodām vai rīkiem, tostarp Python un JavaScript.

Regex, lai apstiprinātu lietotājvārdu

Apsveriet lietotājvārdu, kas ir derīgs tikai tad, ja tas atbilst šādiem nosacījumiem:

1. Rakstzīmju skaitam ir jābūt no 5 līdz 15. (Varat norādīt citu diapazonu atbilstoši savām prasībām, taču veiciet attiecīgas izmaiņas regulārajā izteiksmē.)
instagram viewer
2. Virknē drīkst būt tikai burtciparu rakstzīmes un/vai pasvītras (_).
3. Virknes pirmajai rakstzīmei jābūt alfabētiskai.

Šis regex atbilst iepriekš minētajiem nosacījumiem un var apstiprināt lietotājvārdu:

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

Ja jūs neapmierina iepriekš minētais izteiciens, pārbaudiet regulāro izteiksmju ceļvedis iesācējiem vispirms. Šī ir Python pieeja lietotājvārda apstiprināšanai:

imports re
defpārbaudiet lietotājvārdu(lietotājvārds):
 regex = "^[A-Za-z]\\w{4,14}$"
 r = atkārtoti.kompilēšana (regulārais izteiksme)
ja (re.Meklēt(r, lietotājvārds)):
 drukāt ("Derīgs")
cits:
 drukāt ("Nav derīga")
lietotājvārds1 = "yuvraj_chandra"
checkUsername (lietotājvārds1)
lietotājvārds2 = "ja7&^%87"
checkUsername (lietotājvārds2)

Palaižot šo kodu, tiks apstiprināts, ka pirmais lietotājvārds ir derīgs, bet otrs nav:

Līdzīgi varat apstiprināt lietotājvārdu JavaScript, izmantojot šādu kodu:

funkcijupārbaudiet lietotājvārdu(lietotājs) {
ja(/^[A-Za-z][A-Za-z0-9_]{4,14}$/.test (lietotājs)) {
 console.log('Derīgs');
 } cits {
 console.log('Nav derīga');
 }
}
pārbaudiet lietotājvārdu('yuvraj_chandra');
pārbaudiet lietotājvārdu('ja7&^%87'); 

Varat izmantot šo kodu, lai pārbaudīt HTML veidlapas, izmantojot regulārās izteiksmes.

Regex, lai apstiprinātu e-pasta adresi

Regulārais formulējums e-pasta adreses apstiprināšanai nav ideāls. E-pasta adreses apstiprināšanai nav vispārpieņemta regulārā izteiksme. Tas pilnībā attiecas uz jūsu derīguma definīciju.

Tālāk ir saraksts ar nosacījumiem, kas var apstiprināt lielāko daļu e-pasta adrešu:

1. Lietotājvārdā drīkst būt tikai burtciparu, pasvītras, domuzīmes un/vai punktu rakstzīmes.
2. E-pasta ID virknē ir jābūt vienai @ rakstzīmei.
3. Domēna nosaukumā drīkst būt tikai burtciparu, pasvītras vai domuzīmes.
4. Pēc domēna nosaukuma ir jābūt punktam.
5. Domēna paplašinājumā drīkst būt tikai burtciparu, pasvītras vai domuzīmes.
6. Domēna paplašinājuma garumam ir jābūt no 2 līdz 4.

Šis regulārais izteiksmes veids atbilst iepriekš minētajiem nosacījumiem un var apstiprināt e-pasta adresi:

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

Šī ir Python pieeja e-pasta adreses apstiprināšanai:

imports re
defpārbaudiet e-pasta ID(e-pasts):
 regex = "^[\w.-]+@([\w-]+\.)+[\w-]{2,4}$"
 r = atkārtoti.kompilēšana (regulārais izteiksme)
ja (re.Meklēt(r, e-pasts)):
 drukāt ("Derīgs")
cits:
 drukāt ("Nav derīga")
e-pasts1 = "[email protected]"
checkEmailId (email1)
email2 = "abc@def@gmail.kahscg"
checkEmailId (email2)

Atkal, izvade apstiprina, ka pirmā e-pasta adrese ir derīga, bet otrā ir nederīga:

Varat apstiprināt e-pastu JavaScript, izmantojot šādu kodu:

funkcijupārbaudiet e-pasta ID(e-pasts) {
ja (/^[\w.-]+@([\w-]+\.)+[\w-]{2,4}$/.test (e-pasts)) {
konsole.log('Derīgs');
 } cits {
konsole.log('Nav derīgs');
 }
}
checkEmailId("[email protected]");
checkEmailId("abc@[email protected]");

Pārbaudiet paroles stiprumu, izmantojot regulārās izteiksmes

Spēcīgas paroles ir būtiskas no drošības viedokļa. Jums ir jāpārliecinās, vai galalietotājiem ir pietiekami spēcīgas paroles, lai citi nevarētu piekļūt saviem kontiem.

Šie noteikumi nodrošina, ka jūsu lietojumprogrammas paroles stiprums ir spēcīgs:

1. Minimālajam rakstzīmju skaitam jābūt 8.
2. Virknei ir jābūt vismaz vienam ciparam.
3. Virknē ir jābūt vismaz vienai lielajai rakstzīmei.
4. Virknei ir jābūt vismaz vienai mazajai rakstzīmei.
5. Virknei ir jābūt vismaz vienai īpašajai rakstzīmei.

Tālāk norādītais regulārais formulējums atbilst iepriekš minētajiem nosacījumiem un var palīdzēt nodrošināt spēcīgāku paroli:

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

Varat pārbaudīt paroles stiprumu programmā Python, izmantojot šādu kodu:

imports re
defpārbaudiet paroles stiprumu(parole):
 regex = "(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])(?=.*[^A-Za-z0-9])(?=.{101} 8,})"
 r = atkārtoti.kompilēšana (regulārais izteiksme)
ja (re.Meklēt(r, parole)):
 drukāt ("Spēcīga parole")
cits:
 drukāt ("Vāja parole")
parole1 = "Hiuahd $ 5 jawd"
checkPassword Strength (password1)
parole2 = "my_password"
checkPassword Strength (password2)

Palaižot šo kodu, tiks apstiprināts, ka pirmā parole ir spēcīga, bet otrā ir vāja:

Varat pārbaudīt JavaScript paroles stiprumu, izmantojot šādu kodu:

funkcijupārbaudiet paroles stiprumu(parole) {
ja (/(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])(?=.*[^A-Za-z0-9])(?=.{8,})/.test (parole)) {
 console.log('Spēcīga parole');
 } cits {
 console.log('Vāja parole');
 }
}
pārbaudītPassword Strength('Hiuahd $ 5 jawd');
pārbaudītPassword Strength('my_password');

Regulāra izteiksme, kas atbilst derīgam datumam

Ja vēlaties ātri pārbaudīt, vai norādītie datumi ir tradicionālajā datuma formātā, varat to izdarīt, izmantojot regulāro izteiksmi.

Tālāk norādītā regulārā izteiksme atbilst datumam mm/dd/gggg formāts:

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

Šis Python kods apstiprina datumu mm/dd/gggg formāts:

imports re
defcheckDateFormat(datums):
 regex = "^(0[1-9]|1[012])[- /.](0[1-9]|[12][0-9]|3[01])[- /.](19|20 )\d\d$"
 r = atkārtoti.kompilēšana (regulārais izteiksme)
ja(re.Meklēt(r, datums)):
 drukāt ("Derīgs")
cits:
 drukāt ("Nav derīga")
datums1 = "03/21/2002"
checkDateFormat (date1)
datums2 = "15/21/2002"
checkDateFormat (date2)

Vēlreiz izvade apstiprina, ka pirmais datuma formāts ir derīgs, bet otrais ir nederīgs:

Jūs varat apstiprināt datumu mm/dd/gggg formātā JavaScript, izmantojot šādu kodu:

funkcijucheckDateFormat(datums) {
ja(/^(0[1-9]|1[012])[- /.](0[1-9]|[12][0-9]|3[01])[- /.](19| 20)\d\d$/.test (datums)) {
 console.log('Derīgs');
 } cits {
 console.log('Nav derīga');
 }
}
checkDateFormat('03/21/2002');
checkDateFormat('15/21/2002');

Tukšas virknes validācija, izmantojot regulārās izteiksmes

Varat pārbaudīt, vai virkne ir tukša, izmantojot šādu regulāro izteiksmi:

^$

Tālāk ir norādīta Python pieeja tukšas virknes validācijai:

imports re
defcheckEmptyString(str):
 regex = "^$"
 r = atkārtoti.kompilēšana (regulārais izteiksme)
ja (re.Meklēt(r, str)):
drukāt("Dotā virkne ir tukšs")
cits:
drukāt("Dotā virkne nav tukšs")
str1 = ""
checkEmptyString (str1)
str2 = "Šī nav tukša virkne"
checkEmptyString (str2)

Šī izvade parāda, ka pirmā norādītā virkne ir tukša, bet otrā nav:

Izmantojiet šo JavaScript kodu, lai pārbaudītu, vai virkne ir tukša vai nav:

funkcijucheckEmptyString(str) {
ja (/^$/.test (str)) {
 console.log('Dotā virkne ir tukša');
 } cits {
 console.log('Dotā virkne nav tukša');
 }
}
checkEmptyString('');
checkEmptyString('Šī nav tukša virkne'); 

RegEx, lai apstiprinātu pasta indeksu (ASV pasta indekss)

Varat apstiprināt pasta indeksu (ASV pasta indeksu) gan piecu ciparu, gan deviņu ciparu (ko sauc par ZIP+4) formātā, izmantojot šādu regulāro izteiksmi:

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

Tālāk ir norādīts Python kods pasta indeksu apstiprināšanai:

imports re
defvalidētZIPCode(kods):
 regex = "^[0-9]{5}(?:-[0-9]{4})?$"
 r = atkārtoti.kompilēšana (regulārais izteiksme)
ja (re.Meklēt(r, kodu)):
 drukāt ("Derīgs")
cits:
 drukāt ("Nav derīga")
kods1 = "76309"
validētZIPCode (kods1)
kods2 = "83468-2348"
validētZIPCode (kods2)
kods3 = "234445"
validētZIPCode (kods3)

Palaižot šo kodu, tiks apstiprināts, ka pirmais un otrais pasta indekss ir derīgs, bet trešais nav:

Izmantojiet šādu JavaScript kodu, lai apstiprinātu pasta indeksu, izmantojot regulāro izteiksmi:

funkcijuvalidētZIPCode(kodu) {
ja (/^[0-9]{5}(?:-[0-9]{4})?$/.test (kods)) {
 console.log('Derīgs');
 } cits {
 console.log('Nav derīga');
 }
}
valideZIPCode('76309');
valideZIPCode('83468-2348');
valideZIPCode('234445');

Pārbaudiet lietotāja ievadi, izmantojot stabilu kodu

Jūs uzzinājāt, kā pārbaudīt lietotāja konta informāciju, izmantojot regulārās izteiksmes. Šīs informācijas apstiprināšana padara kodu stabilu un palīdz novērst drošības problēmas un nevēlamas kļūdas. Robusts kods nodrošina drošu un drošu pieredzi jūsu lietotājiem.

Jums jāpārliecinās, vai ievades datus validējat vai nu klienta, vai servera pusē, lai vienmēr būtu drošībā no hakeriem.