Ինչպես վավերացնել օգտատիրոջ հաշվի տվյալները՝ օգտագործելով կանոնավոր արտահայտություններ

Սովորական արտահայտությունների համար որոշակի ընտելացում է պահանջվում, ուստի սկսեք այս օրինակներով՝ օգտատիրոջ մանրամասները ստուգելու համար:

Կանոնավոր արտահայտությունները ինտեգրալ ծրագրավորման գործիք են, որը դուք կարող եք օգտագործել բազմաթիվ գործնական առօրյա խնդիրների համար: Դուք կարող եք օգտագործել կանոնավոր արտահայտություններ տեքստը որոնելու, համապատասխանելու կամ վերլուծելու համար: Ճիշտ նախշերով դուք կարող եք վավերացնել օգտվողի հաշվի ամենատարածված մանրամասները:

Դուք կարող եք օգտագործել կանոնավոր արտահայտություններ բազմաթիվ լեզուներով կամ գործիքներով, ներառյալ Python-ը և JavaScript-ը:

Regex՝ օգտանունը վավերացնելու համար

Հաշվի առեք օգտվողի անուն, որը վավեր է միայն այն դեպքում, եթե այն բավարարում է հետևյալ պայմաններին.

1. Նիշերի թիվը պետք է լինի 5-ից 15-ի միջև: (Դուք կարող եք նշել այլ տիրույթ՝ ըստ ձեր պահանջների, բայց համապատասխանաբար փոփոխություններ կատարեք ռեգեքսում):
2. Տողը պետք է պարունակի միայն այբբենական նիշ և/կամ ընդգծում (_):
3. Տողի առաջին նիշը պետք է լինի այբբենական:

Հետևյալ ռեգեքսը բավարարում է վերը նշված պայմաններին և կարող է վավերացնել օգտվողի անունը.

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

Եթե ձեզ դուր չի գալիս վերը նշված արտահայտությունը, նախ ստուգեք կանոնավոր արտահայտությունների սկսնակների ուղեցույցը: Սա Python-ի մոտեցում է՝ օգտանունը վավերացնելու համար.

import re
  
def checkUsername(username):
    regex = "^[A-Za-z]\\w{4,14}$"
    r = re.compile(regex)
 
    if (re.search(r, username)):
        print("Valid")
    else:
        print("Not Valid")
  
username1 = "yuvraj_chandra"
checkUsername(username1)
  
username2 = "ja7&^%87"
checkUsername(username2)

Այս կոդը գործարկելը կհաստատի, որ առաջին օգտանունը վավեր է, բայց երկրորդը՝

Նմանապես, դուք կարող եք վավերացնել օգտվողի անունը JavaScript-ում՝ օգտագործելով հետևյալ կոդը.

function checkUsername(user) {
    if(/^[A-Za-z][A-Za-z0-9_]{4,14}$/.test(user)) {
        console.log('Valid');
    } else {
        console.log('Not Valid');
    }
}
 
checkUsername('yuvraj_chandra');
checkUsername('ja7&^%87'); 

Դուք կարող եք օգտագործել այս կոդը HTML ձևերը հաստատելու համար՝ օգտագործելով կանոնավոր արտահայտություններ:

Regex էլփոստի հասցեն վավերացնելու համար

Էլփոստի հասցեն վավերացնելու ռեգեքսը կատարյալ չէ: Էլփոստի հասցեն վավերացնելու համար համընդհանուր համաձայնեցված ռեգեքս չկա: Այն ամբողջությամբ բխում է վավերականության ձեր սահմանումից:

Ստորև բերված է պայմանների ցանկ, որոնք կարող են վավերացնել էլփոստի հասցեների մեծ մասը.

1. Օգտվողի անունը պետք է պարունակի միայն այբբենական, ընդգծված, գծիկ և/կամ կետային նիշեր:
2. Էլփոստի id տողը պետք է ունենա մեկ @ նիշ:
3. Դոմենի անունը պետք է պարունակի միայն այբբենական, ընդգծված կամ գծիկ նիշեր:
4. Դոմենի անունից հետո պետք է լինի կետ:
5. Դոմեյնի ընդլայնումը պետք է պարունակի միայն այբբենական, ընդգծված կամ գծիկ նիշեր:
6. Դոմենի ընդլայնման երկարությունը պետք է լինի 2-ից 4-ի միջև:

Հետևյալ ռեգեքսը բավարարում է վերը նշված պայմաններին և կարող է վավերացնել էլփոստի հասցեն.

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

Սա Python-ի մոտեցում է՝ էլփոստի հասցեն վավերացնելու համար.

import re
  
def checkEmailId(email):
    regex = "^[\w.-]+@([\w-]+\.)+[\w-]{2,4}$"
    r = re.compile(regex)
    if (re.search(r, email)):
        print("Valid")
    else:
        print("Not Valid")
  
email1 = "abc@gmail.com"
checkEmailId(email1)
  
email2 = "abc@def@gmail.kahscg"
checkEmailId(email2)

Կրկին, ելքը հաստատում է, որ առաջին էլփոստի հասցեն վավեր է, մինչդեռ երկրորդը անվավեր է.

Դուք կարող եք վավերացնել նամակը JavaScript-ում՝ օգտագործելով հետևյալ կոդը.

function checkEmailId(email) {
    if (/^[\w.-]+@([\w-]+\.)+[\w-]{2,4}$/.test(email)) {
        console.log('Valid');
    } else {
        console.log('Not Valid');
    }
}
 
checkEmailId("abc@gmail.com");
checkEmailId("abc@def@gmail.kahscg");

Ստուգեք գաղտնաբառի ուժը՝ օգտագործելով կանոնավոր արտահայտություններ

Ուժեղ գաղտնաբառերը կարևոր են անվտանգության տեսանկյունից: Դուք պետք է համոզվեք, որ վերջնական օգտվողներն ունեն բավականաչափ ուժեղ գաղտնաբառեր, որպեսզի մյուսները չկարողանան մուտք գործել իրենց հաշիվներ:

Հետևյալ կանոնները երաշխավորում են, որ ձեր հավելվածի գաղտնաբառի հզորությունը ուժեղ է.

1. Նիշերի նվազագույն քանակը պետք է լինի 8:
2. Տողը պետք է ունենա առնվազն մեկ թվանշան:
3. Տողը պետք է ունենա առնվազն մեկ մեծատառ:
4. Տողը պետք է ունենա առնվազն մեկ փոքրատառ նիշ:
5. Տողը պետք է ունենա առնվազն մեկ հատուկ նիշ:

Հետևյալ ռեգեքսը բավարարում է վերը նշված պայմաններին և կարող է օգնել ապահովել ավելի ուժեղ գաղտնաբառ.

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

Դուք կարող եք ստուգել գաղտնաբառի ուժը Python-ում՝ օգտագործելով հետևյալ կոդը.

import re
  
def checkPasswordStrength(password):
    regex = "(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])(?=.*[^A-Za-z0-9])(?=.{8,})"
    r = re.compile(regex)
 
    if (re.search(r, password)):
        print("Strong Password")
    else:
        print("Weak Password")
  
password1 = "Hiuahd$5jawd"
checkPasswordStrength(password1)
  
password2 = "my_password"
checkPasswordStrength(password2)

Այս ծածկագրի գործարկումը կհաստատի, որ առաջին գաղտնաբառը ուժեղ է, իսկ երկրորդը՝ թույլ.

Դուք կարող եք ստուգել գաղտնաբառի ուժը JavaScript-ում՝ օգտագործելով հետևյալ կոդը.

function checkPasswordStrength(password) {
    if (/(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])(?=.*[^A-Za-z0-9])(?=.{8,})/.test(password)) {
        console.log('Strong Password');
    } else {
        console.log('Weak Password');
    }
}
checkPasswordStrength('Hiuahd$5jawd');
checkPasswordStrength('my_password');

Վավեր ամսաթվին համապատասխանող կանոնավոր արտահայտություն

Եթե ցանկանում եք արագ ստուգել՝ արդյոք տվյալ ամսաթվերը ավանդական ամսաթվերի ձևաչափով են, թե ոչ, կարող եք դա անել՝ օգտագործելով regex:

Հետևյալ կանոնավոր արտահայտությունը համընկնում է մմ/dd/yyyy ձևաչափի ամսաթվին.

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

Հետևյալ Python կոդը հաստատում է, որ ամսաթիվը մմ/dd/yyyy ձևաչափով է.

import re
  
def checkDateFormat(date):
    regex = "^(0[1-9]|1[012])[- /.](0[1-9]|[12][0-9]|3[01])[- /.](19|20)\d\d$"
    r = re.compile(regex)
    if(re.search(r, date)):
        print("Valid")
    else:
        print("Not Valid")
  
date1 = "03/21/2002"
checkDateFormat(date1)
  
date2 = "15/21/2002"
checkDateFormat(date2)

Եվս մեկ անգամ, ելքը հաստատում է, որ առաջին ամսաթվի ձևաչափը վավեր է, բայց երկրորդն անվավեր է.

Դուք կարող եք վավերացնել ամսաթիվը մմ/դդ/տարեկան ձևաչափով JavaScript-ում՝ օգտագործելով հետևյալ կոդը.

function checkDateFormat(date) {
    if(/^(0[1-9]|1[012])[- /.](0[1-9]|[12][0-9]|3[01])[- /.](19|20)\d\d$/.test(date)) {
        console.log('Valid');
    } else {
        console.log('Not Valid');
    }
}
 
checkDateFormat('03/21/2002');
checkDateFormat('15/21/2002');

Դատարկ տողի վավերացում՝ օգտագործելով կանոնավոր արտահայտություններ

Դուք կարող եք ստուգել, թե արդյոք տողը դատարկ է, օգտագործելով հետևյալ կանոնավոր արտահայտությունը.

^$

Ստորև բերված է Python մոտեցումը դատարկ տողերի վավերացման համար.

import re
 
def checkEmptyString(str):
   regex = "^$"
   r = re.compile(regex)
 
   if (re.search(r, str)):
       print("The given string is empty")
   else:
       print("The given string is not empty")
 
str1 = ""
checkEmptyString(str1)
 
str2 = "This is not an empty string"
checkEmptyString(str2)

Հետևյալ ելքը ցույց է տալիս, որ առաջին տրված տողը դատարկ է, իսկ երկրորդը՝ ոչ.

Օգտագործեք հետևյալ JavaScript կոդը՝ ստուգելու համար՝ տողը դատարկ է, թե ոչ.

function checkEmptyString(str) {
    if (/^$/.test(str)) {
        console.log('The given string is empty');
    } else {
        console.log('The given string is not empty');
    }
}
 
checkEmptyString('');
checkEmptyString('This is not an empty string'); 

RegEx՝ փոստային կոդը (ԱՄՆ փոստային կոդը) վավերացնելու համար

Դուք կարող եք հաստատել փոստային ինդեքսը (ԱՄՆ փոստային ինդեքսը) ինչպես հնգանիշ, այնպես էլ ինըանիշ (կոչվում է ZIP+4) ձևաչափով՝ օգտագործելով հետևյալ կանոնավոր արտահայտությունը.

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

Ստորև բերված է Python կոդը՝ փոստային կոդերը վավերացնելու համար.

import re
  
def validateZIPCode(code):
    regex = "^[0-9]{5}(?:-[0-9]{4})?$"
    r = re.compile(regex)
 
    if (re.search(r, code)):
        print("Valid")
    else:
        print("Not Valid")
  
code1 = "76309"
validateZIPCode(code1)
  
code2 = "83468-2348"
validateZIPCode(code2)
  
code3 = "234445"
validateZIPCode(code3)

Այս ծածկագրի գործարկումը կհաստատի, որ առաջին և երկրորդ փոստային ինդեքսները վավեր են, իսկ երրորդը՝ ոչ՝

Օգտագործեք հետևյալ JavaScript կոդը՝ փոստային կոդը ռեգեքսի միջոցով վավերացնելու համար.

function validateZIPCode(code) {
    if (/^[0-9]{5}(?:-[0-9]{4})?$/.test(code)) {
        console.log('Valid');
    } else {
        console.log('Not Valid');
    }
}
 
validateZIPCode('76309');
validateZIPCode('83468-2348');
validateZIPCode('234445');

Ստուգեք օգտատիրոջ մուտքագրումը ամուր կոդով

Դուք սովորել եք, թե ինչպես հաստատել օգտատիրոջ հաշվի տվյալները՝ օգտագործելով կանոնավոր արտահայտություններ: Այս մանրամասների վավերացումը կոդն ամուր է դարձնում և օգնում է լուծել անվտանգության խնդիրները և անցանկալի սխալները: Կայուն կոդը ապահովում է անվտանգ և ապահով փորձ ձեր օգտատերերի համար:

Դուք պետք է համոզվեք, որ վավերացնում եք մուտքագրված տվյալները կա՛մ հաճախորդի կողմից, կա՛մ սերվերի կողմից, որպեսզի միշտ ապահով լինեք հաքերներից: