Jak ověřit podrobnosti uživatelského účtu pomocí regulárních výrazů

Regulární výrazy jsou nedílným programovacím nástrojem, který můžete použít pro mnoho praktických každodenních úkolů. Pomocí regulárních výrazů můžete vyhledávat, porovnávat nebo analyzovat text. Pomocí správných vzorů můžete ověřit některé z nejběžnějších podrobností o uživatelském účtu.

Regulární výrazy můžete používat s mnoha jazyky nebo nástroji, včetně Pythonu a JavaScriptu.

Regex pro ověření uživatelského jména

Zvažte uživatelské jméno, které je platné pouze v případě, že splňuje následující podmínky:

1. Počet znaků musí být mezi 5 a 15. (Můžete zadat jiný rozsah podle svých požadavků, ale podle toho proveďte změny v regulárním výrazu.)
instagram viewer
2. Řetězec by měl obsahovat pouze alfanumerické znaky a/nebo podtržítka (_).
3. První znak řetězce by měl být abecední.

Následující regulární výraz splňuje výše uvedené podmínky a může ověřit uživatelské jméno:

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

Pokud vám výše uvedený výraz nevyhovuje, podívejte se průvodce regulárními výrazy pro začátečníky První. Toto je přístup Pythonu k ověření uživatelského jména:

import re
defcheckUsername(uživatelské jméno):
 regulární výraz = "^[A-Za-z]\\w{4,14}$"
 r = re.compile (regulární výraz)
-li (re.Vyhledávání(r, uživatelské jméno)):
 tisk("Platný")
jiný:
 tisk("Neplatný")
uživatelské jméno1 = "yuvraj_chandra"
checkUsername (username1)
uživatelské jméno2 = "ja7&^%87"
checkUsername (username2)

Spuštěním tohoto kódu potvrdíte, že první uživatelské jméno je platné, ale druhé nikoli:

Podobně můžete ověřit uživatelské jméno v JavaScriptu pomocí následujícího kódu:

funkcecheckUsername(uživatel) {
-li(/^[A-Za-z][A-Za-z0-9_]{4,14}$/.test (uživatel)) {
 console.log('Platný');
 } jiný {
 console.log('Neplatný');
 }
}
checkUsername('yuvraj_chandra');
checkUsername('ja7&^%87'); 

Tento kód můžete použít k ověřovat formuláře HTML pomocí regulárních výrazů.

Regex pro ověření e-mailové adresy

Regulární výraz pro ověření e-mailové adresy není dokonalý. Neexistuje žádný univerzálně dohodnutý regulární výraz pro ověření e-mailové adresy. Úplně se to scvrkává na vaši definici platného.

Níže je uveden seznam podmínek, které mohou ověřit většinu e-mailových adres:

1. Uživatelské jméno by mělo obsahovat pouze alfanumerické znaky, podtržítko, pomlčku a/nebo tečku.
2. Řetězec ID e-mailu musí mít jeden znak @.
3. Název domény by měl obsahovat pouze alfanumerické znaky, podtržítko nebo pomlčku.
4. Za názvem domény musí být tečka.
5. Přípona domény by měla obsahovat pouze alfanumerické znaky, podtržítka nebo pomlčky.
6. Délka rozšíření domény by měla být mezi 2 a 4.

Následující regulární výraz splňuje výše uvedené podmínky a může ověřit e-mailovou adresu:

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

Toto je přístup Pythonu k ověření e-mailové adresy:

import re
defcheckEmailId(e-mailem):
 regulární výraz = "^[\w.-]+@([\w-]+\.)+[\w-]{2,4}$"
 r = re.compile (regulární výraz)
-li (re.Vyhledávání(r, e-mailem)):
 tisk("Platný")
jiný:
 tisk("Neplatný")
email1 = "[email protected]"
checkEmailId (e-mail1)
email2 = "abc@def@gmail.kahscg"
checkEmailId (e-mail2)

Výstup opět potvrzuje, že první e-mailová adresa je platná, zatímco druhá je neplatná:

E-mail můžete ověřit v JavaScriptu pomocí následujícího kódu:

funkcecheckEmailId(e-mailem) {
-li (/^[\w.-]+@([\w-]+\.)+[\w-]{2,4}$/.test (e-mail)) {
řídicí panel.log('Platné');
 } jiný {
řídicí panel.log('Neplatný');
 }
}
checkEmailId("[email protected]");
checkEmailId("abc@[email protected]");

Zkontrolujte sílu hesla pomocí regulárních výrazů

Silná hesla jsou z hlediska bezpečnosti nezbytná. Musíte se ujistit, že koncoví uživatelé mají dostatečně silná hesla, aby ostatní neměli přístup k jejich účtům.

Následující pravidla zajišťují, že síla hesla vaší aplikace je silná:

1. Minimální počet znaků musí být 8.
2. Řetězec musí mít alespoň jednu číslici.
3. Řetězec musí mít alespoň jedno velké písmeno.
4. Řetězec musí mít alespoň jedno malé písmeno.
5. Řetězec musí mít alespoň jeden speciální znak.

Následující regulární výraz splňuje výše uvedené podmínky a může pomoci zajistit silnější heslo:

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

Sílu hesla v Pythonu můžete zkontrolovat pomocí následujícího kódu:

import re
defcheckPasswordStrength(Heslo):
 regulární výraz = "(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])(?=.*[^A-Za-z0-9])(?=.{ 8,})"
 r = re.compile (regulární výraz)
-li (re.Vyhledávání(r, Heslo)):
 tisk("Silné heslo")
jiný:
 tisk("Slabé heslo")
heslo1 = "Hiuahd $ 5 čelistí"
checkPasswordStrength (heslo1)
heslo2 = "moje heslo"
checkPasswordStrength (heslo 2)

Spuštění tohoto kódu potvrdí, že první heslo je silné, zatímco druhé je slabé:

Sílu hesla v JavaScriptu můžete zkontrolovat pomocí následujícího kódu:

funkcecheckPasswordStrength(Heslo) {
-li (/(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])(?=.*[^A-Za-z0-9])(?=.{8,})/.test (heslo)) {
 console.log('Silné heslo');
 } jiný {
 console.log('Slabé heslo');
 }
}
checkPasswordStrength('Hiuahd $ 5 čelistí');
checkPasswordStrength('moje heslo');

Regulární výraz, který odpovídá platnému datu

Pokud chcete rychle zkontrolovat, zda jsou daná data v tradičním formátu data nebo ne, můžete tak učinit pomocí regulárního výrazu.

Následující regulární výraz odpovídá datu v mm/dd/rrrr formát:

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

Následující kód Pythonu ověřuje, zda je datum zadáno mm/dd/rrrr formát:

import re
defcheckDateFormat(datum):
 regulární výraz = "^(0[1-9]|1[012])[- /.](0[1-9]|[12][0-9]|3[01])[- /.](19|20 )\d\d$"
 r = re.compile (regulární výraz)
-li(re.Vyhledávání(r, datum)):
 tisk("Platný")
jiný:
 tisk("Neplatný")
datum 1 = "03/21/2002"
checkDateFormat (date1)
datum 2 = "15/21/2002"
checkDateFormat (date2)

Výstup ještě jednou potvrdí, že první formát data je platný, ale druhý je neplatný:

Datum můžete ověřit v mm/dd/rrrr formát v JavaScriptu pomocí následujícího kódu:

funkcecheckDateFormat(datum) {
-li(/^(0[1-9]|1[012])[- /.](0[1-9]|[12][0-9]|3[01])[- /.](19| 20)\d\d$/.test (datum)) {
 console.log('Platný');
 } jiný {
 console.log('Neplatný');
 }
}
checkDateFormat('03/21/2002');
checkDateFormat('15/21/2002');

Ověření prázdného řetězce pomocí regulárních výrazů

Zda je řetězec prázdný, můžete zkontrolovat pomocí následujícího regulárního výrazu:

^$

Níže je uveden přístup Pythonu pro ověření prázdného řetězce:

import re
defcheckEmptyString(str):
 regulární výraz = "^$"
 r = re.compile (regulární výraz)
-li (re.Vyhledávání(r, str)):
tisk(„Daný řetězec je prázdný")
jiný:
tisk(„Daný řetězec není prázdný")
str1 = ""
checkEmptyString (str1)
str2 = "Toto není prázdný řetězec"
checkEmptyString (str2)

Následující výstup ukazuje, že první daný řetězec je prázdný, zatímco druhý není:

Pomocí následujícího kódu JavaScript zkontrolujte, zda je řetězec prázdný nebo ne:

funkcecheckEmptyString(str) {
-li (/^$/.test (str)) {
 console.log('Daný řetězec je prázdný');
 } jiný {
 console.log('Daný řetězec není prázdný');
 }
}
checkEmptyString('');
checkEmptyString('Toto není prázdný řetězec'); 

RegEx k ověření PSČ (US PSČ)

PSČ (PSČ USA) můžete ověřit v pětimístném i devítimístném formátu (tzv. ZIP+4) pomocí následujícího regulárního výrazu:

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

Níže je uveden kód Pythonu pro ověření PSČ:

import re
defvalidateZIPCode(kód):
 regulární výraz = "^[0-9]{5}(?:-[0-9]{4})?$"
 r = re.compile (regulární výraz)
-li (re.Vyhledávání(r, kód)):
 tisk("Platný")
jiný:
 tisk("Neplatný")
kód1 = "76309"
validateZIPCode (kód1)
kód2 = "83468-2348"
validateZIPCode (kód2)
kód3 = "234445"
validateZIPCode (code3)

Spuštěním tohoto kódu potvrdíte, že první a druhé PSČ jsou platné, ale třetí nikoli:

K ověření PSČ pomocí regulárního výrazu použijte následující kód JavaScript:

funkcevalidateZIPCode(kód) {
-li (/^[0-9]{5}(?:-[0-9]{4})?$/.test (kód)) {
 console.log('Platný');
 } jiný {
 console.log('Neplatný');
 }
}
validateZIPCode('76309');
validateZIPCode('83468-2348');
validateZIPCode('234445');

Ověřte uživatelský vstup pomocí robustního kódu

Naučili jste se, jak ověřit podrobnosti uživatelského účtu pomocí regulárních výrazů. Ověření těchto podrobností činí kód robustním a pomáhá řešit bezpečnostní problémy a nežádoucí chyby. Robustní kód poskytuje uživatelům bezpečné a zabezpečené prostředí.

Měli byste se ujistit, že ověřujete vstupní data buď na straně klienta, nebo na straně serveru, abyste byli vždy v bezpečí před hackery.