Come convalidare i dettagli dell'account utente utilizzando le espressioni regolari

Le espressioni regolari sono uno strumento di programmazione integrale che puoi utilizzare per molte attività pratiche quotidiane. Puoi utilizzare le espressioni regolari per cercare, abbinare o analizzare il testo. Con i modelli giusti, puoi convalidare alcuni dei dettagli dell'account utente più comuni.

Puoi utilizzare le espressioni regolari con molti linguaggi o strumenti, inclusi Python e JavaScript.

Regex per convalidare un nome utente

Considera un nome utente valido solo se soddisfa le seguenti condizioni:

1. Il numero di caratteri deve essere compreso tra 5 e 15. (Puoi specificare un intervallo diverso in base alle tue esigenze, ma apporta modifiche alla regex di conseguenza.)
   instagram viewer
2. La stringa deve contenere solo caratteri alfanumerici e/o underscore (_).
3. Il primo carattere della stringa deve essere alfabetico.

La seguente espressione regolare soddisfa le condizioni di cui sopra e può convalidare un nome utente:

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

Se non ti senti a tuo agio con l'espressione sopra, dai un'occhiata una guida per principianti alle espressioni regolari Primo. Questo è un approccio Python per convalidare un nome utente:

importare Rif
defcheckNome utente(nome utente):
 espressione regolare = "^[A-Za-z]\\w{4,14}$"
 r = ricompilare (regex)
Se (Rif.ricerca(R, nome utente)):
 stampa("Valido")
altro:
 stampa("Non valido")
nomeutente1 = "yuvraj_chandra"
checkNomeutente (nomeutente1)
nomeutente2 = "ja7&^%87"
checkNomeutente (nomeutente2)

L'esecuzione di questo codice confermerà che il primo nome utente è valido ma il secondo no:

Allo stesso modo, puoi convalidare un nome utente in JavaScript utilizzando il seguente codice:

funzionecheckNome utente(utente) {
Se(/^[A-Za-z][A-Za-z0-9_]{4,14}$/.test (utente)) {
 console.log('Valido');
 } altro {
 console.log('Non valido');
 }
}
checkNomeutente('yuvraj_chandra');
checkNomeutente('ja7&^%87'); 

Puoi usare questo codice per convalidare moduli HTML utilizzando espressioni regolari.

Regex per convalidare un indirizzo e-mail

La regex per convalidare un indirizzo email non è perfetta. Non esiste una regex universalmente concordata per convalidare un indirizzo email. Si riduce completamente alla tua definizione di valido.

Di seguito è riportato un elenco di condizioni che possono convalidare la maggior parte degli indirizzi e-mail:

1. Il nome utente deve contenere solo caratteri alfanumerici, trattini bassi, trattini e/o punti.
2. La stringa ID e-mail deve contenere un carattere @.
3. Il nome di dominio deve contenere solo caratteri alfanumerici, trattini bassi o trattini.
4. Ci deve essere un punto dopo il nome di dominio.
5. L'estensione del dominio deve contenere solo caratteri alfanumerici, trattini bassi o trattini.
6. La lunghezza dell'estensione del dominio deve essere compresa tra 2 e 4.

La seguente regex soddisfa le condizioni di cui sopra e può convalidare un indirizzo email:

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

Questo è un approccio Python alla convalida di un indirizzo email:

importare Rif
defcheckEmailId(e-mail):
 espressione regolare = "^[\w.-]+@([\w-]+\.)+[\w-]{2,4}$"
 r = ricompilare (regex)
Se (Rif.ricerca(R, e-mail)):
 stampa("Valido")
altro:
 stampa("Non valido")
e-mail1 = "[email protected]"
checkEmailId (email1)
email2 = "abc@def@gmail.kahscg"
checkEmailId (email2)

Ancora una volta, l'output conferma che il primo indirizzo email è valido mentre il secondo non è valido:

Puoi convalidare un'e-mail in JavaScript utilizzando il seguente codice:

funzionecheckEmailId(e-mail) {
Se (/^[\w.-]+@([\w-]+\.)+[\w-]{2,4}$/.test (e-mail)) {
consolare.log('Valido');
 } altro {
consolare.log('Non valido');
 }
}
checkEmailId("[email protected]");
checkEmailId("abc@[email protected]");

Controlla la sicurezza della password usando le espressioni regolari

Le password complesse sono essenziali dal punto di vista della sicurezza. È necessario assicurarsi che gli utenti finali dispongano di password sufficientemente complesse da impedire ad altri di accedere ai propri account.

Le seguenti regole assicurano che la sicurezza della password della tua applicazione sia forte:

1. Il numero minimo di caratteri deve essere 8.
2. La stringa deve contenere almeno una cifra.
3. La stringa deve contenere almeno un carattere maiuscolo.
4. La stringa deve contenere almeno un carattere minuscolo.
5. La stringa deve contenere almeno un carattere speciale.

La seguente espressione regolare soddisfa le condizioni di cui sopra e può aiutare a garantire una password più sicura:

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

Puoi controllare la sicurezza della password in Python usando il seguente codice:

importare Rif
defcheckPasswordStrength(parola d'ordine):
 espressione regolare = "(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])(?=.*[^A-Za-z0-9])(?=.{ 8,})"
 r = ricompilare (regex)
Se (Rif.ricerca(R, parola d'ordine)):
 stampa("Password sicura")
altro:
 stampa("Password Debole")
password1 = "Hiuahd $ 5jawd"
checkPasswordStrength (password1)
password2 = "la mia password"
checkPasswordStrength (password2)

L'esecuzione di questo codice confermerà che la prima password è forte mentre la seconda è debole:

Puoi verificare la sicurezza della password in JavaScript utilizzando il seguente codice:

funzionecheckPasswordStrength(parola d'ordine) {
Se (/(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])(?=.*[^A-Za-z0-9])(?=.{8,})/.test (password)) {
 console.log('Password sicura');
 } altro {
 console.log('Password Debole');
 }
}
checkPasswordStrength('Hiuahd $ 5jawd');
checkPasswordStrength('la mia password');

Espressione regolare per abbinare una data valida

Se vuoi verificare rapidamente se le date specificate sono nel formato di data tradizionale o meno, puoi farlo usando regex.

La seguente espressione regolare corrisponde a una data in mm/gg/aaaa formato:

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

Il seguente codice Python convalida la data in mm/gg/aaaa formato:

importare Rif
defcheckDateFormat(data):
 espressione regolare = "^(0[1-9]|1[012])[- /.](0[1-9]|[12][0-9]|3[01])[- /.](19|20 )\d\d$"
 r = ricompilare (regex)
Se(Rif.ricerca(R, data)):
 stampa("Valido")
altro:
 stampa("Non valido")
data1 = "03/21/2002"
checkDateFormat (data1)
data2 = "15/21/2002"
checkDateFormat (data2)

Ancora una volta, l'output conferma che il primo formato della data è valido, ma il secondo non è valido:

Puoi convalidare la data in mm/gg/aaaa formato in JavaScript utilizzando il seguente codice:

funzionecheckDateFormat(data) {
Se(/^(0[1-9]|1[012])[- /.](0[1-9]|[12][0-9]|3[01])[- /.](19| 20)\d\d$/.data del test)) {
 console.log('Valido');
 } altro {
 console.log('Non valido');
 }
}
checkDateFormat('03/21/2002');
checkDateFormat('15/21/2002');

Convalida di stringhe vuote mediante espressioni regolari

Puoi controllare se una stringa è vuota usando la seguente espressione regolare:

^$

Di seguito è riportato l'approccio Python per la convalida di stringhe vuote:

importare Rif
defcheckEmptyString(str):
 espressione regolare = "^$"
 r = ricompilare (regex)
Se (Rif.ricerca(R, str)):
stampa("La stringa data è vuoto")
altro:
stampa("La stringa data non lo è vuoto")
str1 = ""
checkEmptyString (str1)
str2 = "Questa non è una stringa vuota"
checkEmptyString (str2)

Il seguente output dimostra che la prima stringa data è vuota mentre la seconda no:

Utilizzare il seguente codice JavaScript per verificare se la stringa è vuota o meno:

funzionecheckEmptyString(str) {
Se (/^$/.test (str)) {
 console.log('La stringa data è vuota');
 } altro {
 console.log('La stringa data non è vuota');
 }
}
checkEmptyString('');
checkEmptyString('Questa non è una stringa vuota'); 

RegEx per convalidare il codice postale (codice postale degli Stati Uniti)

È possibile convalidare un codice postale (codice postale degli Stati Uniti) in entrambi i formati a cinque cifre e nove cifre (denominati ZIP+4) utilizzando la seguente espressione regolare:

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

Di seguito è riportato il codice Python per convalidare i codici postali:

importare Rif
defvalidateZIPCode(codice):
 espressione regolare = "^[0-9]{5}(?:-[0-9]{4})?$"
 r = ricompilare (regex)
Se (Rif.ricerca(R, codice)):
 stampa("Valido")
altro:
 stampa("Non valido")
codice1 = "76309"
validateZIPCode (codice1)
codice2 = "83468-2348"
validateZIPCode (codice2)
codice3 = "234445"
validateZIPCode (codice3)

L'esecuzione di questo codice confermerà che il primo e il secondo codice postale sono validi ma il terzo no:

Utilizza il seguente codice JavaScript per convalidare il codice postale utilizzando regex:

funzionevalidateZIPCode(codice) {
Se (/^[0-9]{5}(?:-[0-9]{4})?$/.test (codice)) {
 console.log('Valido');
 } altro {
 console.log('Non valido');
 }
}
validateCAP('76309');
validateCAP('83468-2348');
validateCAP('234445');

Verifica l'input dell'utente con un codice affidabile

Hai imparato a convalidare i dettagli dell'account utente utilizzando le espressioni regolari. La convalida di questi dettagli rende il codice robusto e aiuta ad affrontare problemi di sicurezza e bug indesiderati. Il codice robusto offre un'esperienza sicura e protetta per i tuoi utenti.

Dovresti assicurarti di convalidare i dati di input sul lato client o sul lato server per essere sempre al sicuro dagli hacker.