Kaip patvirtinti vartotojo abonemento informaciją naudojant reguliariuosius posakius

Reguliarios išraiškos yra integruotas programavimo įrankis, kurį galite naudoti atliekant daugelį praktinių kasdienių užduočių. Galite naudoti įprastus posakius norėdami ieškoti, suderinti arba analizuoti tekstą. Naudodami tinkamus šablonus galite patvirtinti kai kurias dažniausiai pasitaikančias vartotojo paskyros detales.

Galite naudoti reguliariąsias išraiškas su daugeliu kalbų ar įrankių, įskaitant Python ir JavaScript.

Regex, kad patvirtintumėte vartotojo vardą

Apsvarstykite naudotojo vardą, kuris galioja tik tada, kai atitinka šias sąlygas:

1. Simbolių skaičius turi būti nuo 5 iki 15. (Galite nurodyti kitą diapazoną pagal savo poreikius, bet atitinkamai pakeiskite reguliarųjį reiškinį.)
instagram viewer
2. Eilutėje turi būti tik raidiniai ir skaitmeniniai simboliai ir (arba) apatiniai brūkšniai (_).
3. Pirmasis eilutės simbolis turi būti abėcėlė.

Ši reguliarioji išraiška atitinka aukščiau nurodytas sąlygas ir gali patvirtinti naudotojo vardą:

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

Jei nesate patenkinti aukščiau pateikta išraiška, patikrinkite pradedančiųjų reguliarių posakių vadovas Pirmas. Tai yra Python metodas vartotojo vardui patvirtinti:

importuoti re
defpatikrinkite vartotojo vardą(Vartotojo vardas):
 reguliarioji išraiška = "^[A-Za-z]\\w{4,14}$"
 r = iš naujo.kompiliuoti (regex)
jeigu (re.Paieška(r, Vartotojo vardas)):
 spausdinti ("Galioja")
Kitas:
 spausdinti ("Negaliojantis")
vartotojo vardas1 = "yuvraj_chandra"
check Username (naudotojo vardas1)
vartotojo vardas2 = "ja7&^%87"
check Username (2 vartotojo vardas)

Vykdydami šį kodą patvirtinsite, kad pirmasis vartotojo vardas galioja, o antrasis ne:

Panašiai galite patvirtinti vartotojo vardą „JavaScript“ naudodami šį kodą:

funkcijapatikrinkite vartotojo vardą(Vartotojas) {
jeigu(/^[A-Za-z][A-Za-z0-9_]{4,14}$/.test (vartotojas)) {
 console.log('Galioja');
 } Kitas {
 console.log('Negaliojantis');
 }
}
checkVartotojo vardas ('yuvraj_chandra');
checkVartotojo vardas ('ja7&^%87'); 

Galite naudoti šį kodą patvirtinti HTML formas naudojant reguliariąsias išraiškas.

Regex, kad patvirtintumėte el. pašto adresą

Reguliarioji išraiška el. pašto adresui patvirtinti nėra tobula. El. pašto adresui patvirtinti nėra visuotinai priimto reguliaraus reiškinio. Tai visiškai susiveda į jūsų galiojančio apibrėžimą.

Toliau pateikiamas sąlygų, kuriomis galima patvirtinti daugumą el. pašto adresų, sąrašas:

1. Naudotojo varde turi būti tik raidiniai ir skaitiniai, apatinio brūkšnio, brūkšnelio ir (arba) taško simboliai.
2. El. pašto ID eilutėje turi būti vienas @ simbolis.
3. Domeno pavadinime turi būti tik raidiniai ir skaitiniai, apatinio brūkšnio arba brūkšnelio simboliai.
4. Po domeno pavadinimo turi būti taškas.
5. Domeno plėtinyje turi būti tik raidiniai ir skaitiniai, apatinio brūkšnio arba brūkšnio simboliai.
6. Domeno plėtinio ilgis turi būti nuo 2 iki 4.

Ši reguliarioji išraiška atitinka aukščiau nurodytas sąlygas ir gali patvirtinti el. pašto adresą:

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

Tai yra Python metodas el. pašto adreso patvirtinimui:

importuoti re
defpatikrinkite el. pašto ID(el. paštas):
 reguliarioji išraiška = "^[\w.-]+@([\w-]+\.)+[\w-]{2,4}$"
 r = iš naujo.kompiliuoti (regex)
jeigu (re.Paieška(r, paštu)):
 spausdinti ("Galioja")
Kitas:
 spausdinti ("Negaliojantis")
email1 = "[email protected]"
checkEmailId (email1)
email2 = "abc@def@gmail.kahscg"
checkEmailId (email2)

Vėlgi, išvestis patvirtina, kad pirmasis el. pašto adresas yra galiojantis, o antrasis neteisingas:

Galite patvirtinti el. laišką „JavaScript“ naudodami šį kodą:

funkcijapatikrinkite el. pašto ID(paštu) {
jeigu (/^[\w.-]+@([\w-]+\.)+[\w-]{2,4}$/.test (el. paštas)) {
konsolė.log('Galioja');
 } Kitas {
konsolė.log('Negalioja');
 }
}
checkEmailId("[email protected]");
checkEmailId("abc@[email protected]");

Patikrinkite slaptažodžio stiprumą naudodami reguliariąsias išraiškas

Stiprūs slaptažodžiai yra būtini saugumo požiūriu. Turite įsitikinti, kad galutiniai vartotojai turi pakankamai stiprius slaptažodžius, kad kiti negalėtų pasiekti savo paskyrų.

Šios taisyklės užtikrina, kad jūsų programos slaptažodžio stiprumas būtų stiprus:

1. Mažiausias simbolių skaičius turi būti 8.
2. Eilutę turi sudaryti bent vienas skaitmuo.
3. Eilutėje turi būti bent viena didžioji raidė.
4. Eilutėje turi būti bent viena mažoji raidė.
5. Eilutėje turi būti bent vienas specialusis simbolis.

Ši reguliarioji išraiška atitinka aukščiau nurodytas sąlygas ir gali padėti užtikrinti stipresnį slaptažodį:

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

Python slaptažodžio stiprumą galite patikrinti naudodami šį kodą:

importuoti re
defpatikrinkite slaptažodžio stiprumą(Slaptažodis):
 reguliarioji išraiška = "(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])(?=.*[^A-Za-z0-9])(?=.{101} 8,})"
 r = iš naujo.kompiliuoti (regex)
jeigu (re.Paieška(r, Slaptažodis)):
 spausdinti ("Stiprus slaptažodis")
Kitas:
 spausdinti ("Silpnas slaptazodis")
slaptažodis1 = "Hiuahd $5 jawd"
checkPassword Strength (password1)
slaptažodis2 = "mano_slaptažodis"
checkPassword Strength (password2)

Vykdydami šį kodą patvirtinsite, kad pirmasis slaptažodis yra stiprus, o antrasis silpnas:

„JavaScript“ slaptažodžio stiprumą galite patikrinti naudodami šį kodą:

funkcijapatikrinkite slaptažodžio stiprumą(Slaptažodis) {
jeigu (/(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])(?=.*[^A-Za-z0-9])(?=.{8,})/.test (slaptažodis)) {
 console.log('Stiprus slaptažodis');
 } Kitas {
 console.log('Silpnas slaptazodis');
 }
}
checkPassword Strength('Hiuahd $5 jawd');
checkPassword Strength('mano_slaptažodis');

Įprasta išraiška, atitinkanti galiojančią datą

Jei norite greitai patikrinti, ar nurodytos datos yra tradicinio datos formato, galite tai padaryti naudodami reguliarųjį reiškinį.

Šis reguliarusis posakis atitinka datą mm/dd/yyyy formatas:

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

Šis Python kodas patvirtina datą mm/dd/yyyy formatas:

importuoti re
defcheckDateFormat(data):
 reguliarioji išraiška = "^(0[1-9]|1[012])[- /.](0[1-9]|[12][0-9]|3[01])[- /.](19|20 )\d\d$"
 r = iš naujo.kompiliuoti (regex)
jeigu(re.Paieška(r, data)):
 spausdinti ("Galioja")
Kitas:
 spausdinti ("Negaliojantis")
data1 = "03/21/2002"
checkDateFormat (data1)
data2 = "15/21/2002"
checkDateFormat (data2)

Dar kartą išvestis patvirtina, kad pirmasis datos formatas galioja, bet antrasis neteisingas:

Galite patvirtinti datą mm/dd/yyyy formatu JavaScript naudojant šį kodą:

funkcijacheckDateFormat(data) {
jeigu(/^(0[1-9]|1[012])[- /.](0[1-9]|[12][0-9]|3[01])[- /.](19| 20)\d\d$/.test (data)) {
 console.log('Galioja');
 } Kitas {
 console.log('Negaliojantis');
 }
}
checkDateFormat('03/21/2002');
checkDateFormat('15/21/2002');

Tuščios eilutės patvirtinimas naudojant reguliariąsias išraiškas

Galite patikrinti, ar eilutė tuščia, naudodami šią reguliariąją išraišką:

^$

Žemiau yra Python metodas, skirtas tuščios eilutės patvirtinimui:

importuoti re
defcheckEmptyString(str):
 reguliarioji išraiška = "^$"
 r = iš naujo.kompiliuoti (regex)
jeigu (re.Paieška(r, g)):
spausdinti(„Duota eilutė yra tuščia")
Kitas:
spausdinti(„Duota eilutė nėra tuščia")
str1 = ""
checkEmptyString (str1)
str2 = "Tai nėra tuščia eilutė"
checkEmptyString (str2)

Ši išvestis parodo, kad pirmoji nurodyta eilutė yra tuščia, o antroji - ne:

Norėdami patikrinti, ar eilutė tuščia, ar ne, naudokite šį „JavaScript“ kodą:

funkcijacheckEmptyString(g) {
jeigu (/^$/.test (str)) {
 console.log('Pateikta eilutė tuščia');
 } Kitas {
 console.log('Pateikta eilutė nėra tuščia');
 }
}
checkEmptyString('');
checkEmptyString('Tai nėra tuščia eilutė'); 

RegEx, kad patvirtintumėte pašto kodą (JAV pašto kodas)

Galite patvirtinti pašto kodą (JAV pašto kodą) tiek penkių, tiek devynių skaitmenų (vadinamu ZIP+4) formatu, naudodami šią reguliariąją išraišką:

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

Žemiau yra Python kodas, skirtas pašto kodams patvirtinti:

importuoti re
defpatvirtinkite pašto kodą(kodas):
 reguliarioji išraiška = "^[0-9]{5}(?:-[0-9]{4})?$"
 r = iš naujo.kompiliuoti (regex)
jeigu (re.Paieška(r, kodas)):
 spausdinti ("Galioja")
Kitas:
 spausdinti ("Negaliojantis")
kodas1 = "76309"
patvirtinti pašto kodą (kodas1)
kodas2 = "83468-2348"
patvirtinti pašto kodą (code2)
kodas3 = "234445"
patvirtinti pašto kodą (code3)

Vykdydami šį kodą patvirtinsite, kad pirmasis ir antrasis pašto kodai galioja, o trečiasis – ne:

Naudokite šį „JavaScript“ kodą, kad patvirtintumėte pašto kodą naudodami regex:

funkcijapatvirtinkite pašto kodą(kodas) {
jeigu (/^[0-9]{5}(?:-[0-9]{4})?$/.test (kodas)) {
 console.log('Galioja');
 } Kitas {
 console.log('Negaliojantis');
 }
}
patvirtintiZIPCode('76309');
patvirtintiZIPCode('83468-2348');
patvirtintiZIPCode('234445');

Patvirtinkite vartotojo įvestį naudodami patikimą kodą

Sužinojote, kaip patvirtinti vartotojo abonemento informaciją naudojant įprastus posakius. Patvirtinus šią informaciją, kodas tampa tvirtas ir padeda išspręsti saugumo problemas bei nepageidaujamas klaidas. Tvirtas kodas suteikia naudotojams saugią patirtį.

Turėtumėte įsitikinti, kad patvirtinate įvesties duomenis kliento arba serverio pusėje, kad visada būtumėte apsaugoti nuo įsilaužėlių.