it-swarm.it

Regex per password deve contenere almeno otto caratteri, almeno un numero e lettere maiuscole e minuscole e caratteri speciali

Voglio un'espressione regolare per verificare che:

Una password contiene almeno otto caratteri, incluso almeno un numero e include sia lettere maiuscole che maiuscole e caratteri speciali, ad esempio #, ?, !.

Non può essere la tua vecchia password o contenere il tuo nome utente, "password" o "websitename"

Ed ecco la mia espressione di convalida che è per otto caratteri, tra cui una lettera maiuscola, una lettera minuscola e un numero o carattere speciale.

(?=^.{8,}$)((?=.*\d)|(?=.*\W+))(?![.\n])(?=.*[A-Z])(?=.*[a-z]).*$"

Come posso scriverlo per una password deve contenere otto caratteri, tra cui una lettera maiuscola, un carattere speciale e caratteri alfanumerici ?

287

Almeno otto caratteri, almeno una lettera e un numero:

"^(?=.*[A-Za-z])(?=.*\d)[A-Za-z\d]{8,}$"

Almeno otto caratteri, almeno una lettera, un numero e un carattere speciale:

"^(?=.*[A-Za-z])(?=.*\d)(?=.*[@$!%*#?&])[A-Za-z\[email protected]$!%*#?&]{8,}$"

Almeno otto caratteri, almeno una lettera maiuscola, una lettera minuscola e un numero:

"^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)[a-zA-Z\d]{8,}$"

Almeno otto caratteri, almeno una lettera maiuscola, una lettera minuscola, un numero e un carattere speciale:

"^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\[email protected]$!%*?&]{8,}$"

Minimo otto e massimo 10 caratteri, almeno una lettera maiuscola, una lettera minuscola, un numero e un carattere speciale:

"^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\[email protected]$!%*?&]{8,10}$"
827
Srinivas

Puoi usare questa regex:

^(?=.*?[A-Z])(?=.*?[a-z])(?=.*?[0-9])(?=.*?[#[email protected]$%^&*-]).{8,}$

Questa regex applicherà queste regole:

  • Almeno una lettera maiuscola Lettera inglese , (?=.*?[A-Z])
  • Almeno una lettera inglese minuscola, (?=.*?[a-z])
  • Almeno una cifra, (?=.*?[0-9])
  • Almeno un carattere speciale, (?=.*?[#[email protected]$%^&*-])
  • Minimo otto di lunghezza .{8,} (con le ancore)
252
anubhava

Le espressioni regolari non hanno un operatore AND, quindi è piuttosto difficile scrivere una regex che corrisponda a password valide, quando la validità è definita da qualcosa E qualcos'altro E qualcos'altro ...

Ma le espressioni regolari hanno un operatore OR, quindi applica il teorema di DeMorgan e scrivi un'espressione regolare che corrisponde a password non valide:

Qualsiasi cosa con meno di otto caratteriOqualsiasi cosa senza numeriOqualsiasi cosa senza maiuscoloOo qualsiasi cosa senza maiuscoloOqualsiasi cosa senza personaggi speciali.

Così:

^(.{0,7}|[^0-9]*|[^A-Z]*|[^a-z]*|[a-zA-Z0-9]*)$

Se qualcosa corrisponde, allora è una password non valida.

48
Matt Timmermans

Un piccolo miglioramento per la risposta di @ anubhava: Poiché i caratteri speciali sono limitati a quelli della tastiera, utilizzali per qualsiasi carattere speciale:

^(?=.*?[A-Z])(?=(.*[a-z]){1,})(?=(.*[\d]){1,})(?=(.*[\W]){1,})(?!.*\s).{8,}$

Questa regex applicherà queste regole:

  • Almeno una lettera inglese maiuscola
  • Almeno una lettera inglese minuscola
  • Almeno una cifra
  • Almeno un personaggio speciale
  • Minimo otto di lunghezza
26
Edwin Beltran

Ho avuto qualche difficoltà a seguire la risposta più popolare per le mie circostanze. Ad esempio, la mia convalida falliva con caratteri come ; o [. Non ero interessato a elencare in bianco i miei caratteri speciali, quindi invece ho sfruttato [^\w\s] come test - semplicemente messo - combacia con caratteri non Word (compresi quelli numerici) e non spazi bianchi. Per riassumere, ecco cosa ha funzionato per me ...

  • almeno 8 caratteri
  • almeno 1 carattere numerico
  • almeno 1 lettera minuscola 
  • almeno 1 lettera maiuscola 
  • almeno 1 carattere speciale

/^(?=.*?[A-Z])(?=.*?[a-z])(?=.*?[0-9])(?=.*?[^\w\s]).{8,}$/

JSFiddle Link - semplice demo che copre vari casi

20
scniro

Una versione più "generica" ​​(?), Che consente lettere non inglesi come caratteri speciali .

^(?=\S*[a-z])(?=\S*[A-Z])(?=\S*\d)(?=\S*[^\w\s])\S{8,}$

var pwdList = [
    '@@V4-\3Z`zTzM{>k',
    '12qw!"QW12',
    '123qweASD!"#',
    '1qA!"#$%&',
    'Günther32',
    '123456789',
    'qweASD123',
    'qweqQWEQWEqw',
    '12qwAS!'
  ],
  re = /^(?=\S*[a-z])(?=\S*[A-Z])(?=\S*\d)(?=\S*[^\w\s])\S{8,}$/;
  
  pwdList.forEach(function (pw) {
    document.write('<span style="color:'+ (re.test(pw) ? 'green':'red') + '">' + pw + '</span><br/>');
  });

12
SamWhan

Importa il file JavaScript jquery.validate.min.js.

Puoi usare questo metodo:

$.validator.addMethod("pwcheck", function (value) {
    return /[\@\#\$\%\^\&\*\(\)\_\+\!]/.test(value) && /[a-z]/.test(value) && /[0-9]/.test(value) && /[A-Z]/.test(value)
});
  1. Almeno una lettera inglese maiuscola
  2. Almeno una lettera inglese minuscola
  3. Almeno una cifra
  4. Almeno un personaggio speciale
11
Vikram

Prova questo:

  1. Minimo sei caratteri
  2. Almeno un carattere maiuscolo
  3. Almeno un carattere minuscolo
  4. Almeno un personaggio speciale

Espressione:

"/^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[[email protected]$!%*?&.])[A-Za-z\[email protected]$!%*?&.]{6, 20}/"

Caratteri speciali opzionali:

  1. Almeno un personaggio speciale
  2. Almeno un numero
  3. I caratteri speciali sono opzionali
  4. Minimo sei caratteri e massimo 16 caratteri

Espressione:

"/^(?=.*\d)(?=.*[a-zA-Z]).{6,20}$/"

Se la condizione min e max non è richiesta, rimuovere .{6, 16}

  • 6 è il limite di caratteri minimi
  • 20 è il limite massimo di caratteri
  • ? = significa espressione di corrispondenza
9
ojus kulkarni
Use the following Regex to satisfy the below conditions:

Conditions: 1] Min 1 uppercase letter.
            2] Min 1 lowercase letter.
            3] Min 1 special character.
            4] Min 1 number.
            5] Min 8 characters.
            6] Max 30 characters.

Regex: /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[#[email protected]!%&*?])[A-Za-z\d#[email protected]!%&*?]{8,30}$/    
6
SHASHANK HONRAO

Risponderei a Peter Mortensen, ma non ho abbastanza reputazione.

Le sue espressioni sono perfette per ciascuno dei requisiti minimi specificati. Il problema con le sue espressioni che non richiedono caratteri speciali è che non consentono anche caratteri speciali, quindi applicano anche i requisiti massimi, che non credo l'OP richiesto. Normalmente vuoi consentire ai tuoi utenti di rendere la loro password forte come vogliono; perché limitare le password forti?

Quindi, la sua espressione "minimo otto caratteri, almeno una lettera e un numero":

^(?=.*[A-Za-z])(?=.*\d)[A-Za-z\d]{8,}$

raggiunge il requisito minimo, ma i caratteri rimanenti possono solo essere lettera e numeri. Per consentire (ma non richiedere) caratteri speciali, devi usare qualcosa come:

^(?=.*[A-Za-z])(?=.*\d).{8,}$ per consentire qualsiasi carattere

o

^(?=.*[A-Za-z])(?=.*\d)[A-Za-z\[email protected]$!%*#?&]{8,}$ per consentire caratteri speciali specifici

Allo stesso modo, "minimo otto caratteri, almeno una lettera maiuscola, una lettera minuscola e un numero:"

^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)[a-zA-Z\d]{8,}$

soddisfa questo requisito minimo, ma solo consente lettere e numeri. Uso:

^(?=.*[a-z])(?=.*[A-Z])(?=.*\d).{8,}$ per consentire qualsiasi carattere

o

^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)[A-Za-z\[email protected]$!%*?&]{8,} per consentire caratteri speciali specifici.

5
deathwombat

Non risponde direttamente alla domanda, ma deve essere davvero una regex?

Ho usato un sacco di Perl e mi sono abituato a risolvere i problemi con le espressioni regolari. Tuttavia, quando diventano più complicati con tutti i look-ahead e le altre stranezze, è necessario scrivere dozzine di test unitari per uccidere tutti quei piccoli bug.

Inoltre, un regex è in genere un paio di volte più lento di una soluzione imperativa o funzionale.

Ad esempio, la seguente funzione Scala (non molto FP) risolve la domanda originale circa tre volte più veloce della regex della risposta più popolare. Ciò che fa è anche così chiaro che non è necessario un test unitario:

def validatePassword(password: String): Boolean = {
  if (password.length < 8)
    return false

  var lower = false
  var upper = false
  var numbers = false
  var special = false

  password.foreach { c =>
    if (c.isDigit)       numbers = true
    else if (c.isLower)  lower = true
    else if (c.isUpper)  upper = true
    else                 special = true
  }

  lower && upper && numbers && special
}
4
Heikki Salokanto

Secondo il tuo bisogno questo schema dovrebbe funzionare bene. Prova questo,

^(?=(.*\d){1})(.*\S)(?=.*[a-zA-Z\S])[0-9a-zA-Z\S]{8,}

Basta creare una variabile stringa, assegnare il modello e creare un metodo booleano che restituisce true se il pattern è corretto, altrimenti false.

Campione:

String pattern = "^(?=(.*\d){1})(.*\S)(?=.*[a-zA-Z\S])[0-9a-zA-Z\S]{8,}";
String password_string = "Type the password here"

private boolean isValidPassword(String password_string) {
    return password_string.matches(Constants.passwordPattern);
}
3
Arun Sivanandan
(?=.*[0-9])(?=.*[a-z])(?=.*[A-Z])(?=.*[@#$%^&+-]).{6}
2
shiyani suresh

@ClasG ha già suggerito :

^(?=\S*[a-z])(?=\S*[A-Z])(?=\S*\d)(?=\S*[^\w\s])\S{8,}$

ma non accetta _ (carattere di sottolineatura) come carattere speciale (ad esempio Aa12345_).

Uno migliorato è:

^(?=\S*[a-z])(?=\S*[A-Z])(?=\S*\d)(?=\S*([^\w\s]|[_]))\S{8,}$
2
SONewbiee

Ho trovato molti problemi qui, quindi ho creato il mio.

Eccolo in tutta la sua gloria, con i test: 

^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*([^a-zA-Z\d\s])).{9,}$

https://regex101.com/r/DCRR65/4/tests

Cose da cercare:

  1. non usa \w perché include _, che sto testando per.
  2. Ho avuto molti problemi con i simboli, senza corrispondere alla fine della linea.
  3. Non specifica i simboli in modo specifico, questo anche perché le diverse impostazioni locali potrebbero avere simboli diversi sulle loro tastiere che potrebbero voler utilizzare.
1
Stefano

Utilizzare il seguente Regex per soddisfare le seguenti condizioni:

Conditions: 1] Min 1 special character.
            2] Min 1 number.
            3] Min 8 characters or More

Regex: ^(?=.*\d)(?=.*[#[email protected]!%&*?])[A-Za-z\d#[email protected]!%&*?]{8,}$

Può testare online: https://regex101.com

1
Samrat Saha

Solo noi possiamo farlo usando HTML5.

Usa sotto il codice nell'attributo pattern,

pattern="(?=^.{8,}$)((?=.*\d)(?=.*\W+))(?![.\n])(?=.*[A-Z])(?=.*[a-z]).*$"

Funzionerà perfettamente.

1
Vidya

È possibile utilizzare il seguente modello di espressioni regolari per verificare se la password corrisponde o meno alle proprie aspettative.

((?=.*\\d)(?=.*[a-z])(?=.*[A-Z])(?=.*[[email protected]#$%^&*()]).{8,20})
1

Prova questo:

^.*(?=.{8,})(?=.*[a-z])(?=.*[A-Z])(?=.*[@#$%^&+=])[[email protected]#$%^&+=]*$

Questa espressione regolare funziona perfettamente per me.

function myFunction() {
    var str = "[email protected]";
    var patt = new RegExp("^.*(?=.{8,})(?=.*[a-z])(?=.*[A-Z])(?=.*[@#$%^&+=])[[email protected]#$%^&+=]*$");
    var res = patt.test(str);
    console.log("Is regular matches:", res);
}
0
Kiwi Rupela

Pattern per abbinare almeno 1 carattere maiuscolo, 1 cifra e qualsiasi carattere speciale e la lunghezza tra 8 e 63.

"^ (? =. [a-z]) (? =. [A-Z]) (? =. *\d) [a-zA-Z\d\W] {8,63} $"

Questo modello è stato utilizzato per la programmazione Java.

0
Anup Seth

In Java/Android, per testare una password con almeno un numero, una lettera, un carattere speciale nel seguente schema:

"^(?=.*[A-Za-z])(?=.*\\d)(?=.*[[email protected]$!%*#?&])[A-Za-z\\[email protected]$!%*#?&]{8,}$"
0
Dadaji
(?=.*[a-z])(?=.*[A-Z])(?=.*\d)[a-zA-Z\d]{8,}$

Verifica collegamento online https://regex101.com/r/mqGurh/1

0
Tai Ho

Spero che il sotto funzioni. Ho provato questo nella politica personalizzata di Azure.

^ (? =. [az]) (? =. [AZ]) (? =.\d) (? =. [@ # $% ^ & * -_ + = [] {} | \:?.',/~&quot;();!])([A-Za-z\[email protected]#$%^&amp;*\-_+=[\]{}|\\:',?/ ~ "() ;!] | (?! @)) {} $ 6,16

0
Venkatesh