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

Voglio un'espressione regolare per verificare che:

Una password contiene almeno otto caratteri, di cui almeno un numero e comprende sia lettere maiuscole e 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 validazione che è per otto caratteri tra cui una lettera maiuscola, una lettera minuscola e un numero o un carattere speciale.

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

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

Minimo otto caratteri, almeno una lettera e un numero:

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

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

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

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

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

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

"^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{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\d@$!%*?&]{8,10}$"

Puoi usare questa regex con più asserzioni (condizioni) di lookahead :

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

Questa regex imporrà queste regole:

• Almeno una lettera inglese maiuscola ,(?=.*?[A-Z])
• Almeno una lettera inglese minuscola, (?=.*?[a-z])
• Almeno una cifra, (?=.*?[0-9])
• Almeno un personaggio speciale, (?=.*?[#?!@$%^&*-])
• Lunghezza minima otto .{8,}(con le ancore)

Le espressioni regolari non hanno un operatore AND, quindi è abbastanza 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 basta applicare il teorema di DeMorgan e scrivere una regex che corrisponda a password non valide:

Tutto ciò con meno di otto caratteri O niente senza i numeri O nulla senza maiuscolo O o qualsiasi cosa senza minuscola OR nulla senza caratteri speciali.

Così:

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

Se qualcosa corrisponde, allora è una password non valida.

Solo un piccolo miglioramento per la risposta di @ anubhava: poiché i caratteri speciali sono limitati a quelli della tastiera, usalo per qualsiasi carattere speciale:

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

Questa regex imporrà queste regole:

• Almeno una lettera inglese maiuscola
• Almeno una lettera inglese minuscola
• Almeno una cifra
• Almeno un personaggio speciale
• Lunghezza minima otto

Ho avuto qualche difficoltà a seguire la risposta più popolare per le mie circostanze. Ad esempio, la mia convalida non è riuscita con caratteri come ;o [. Non ero interessato a elencare in bianco i miei caratteri speciali, quindi ho sfruttato [^\w\s]come test - in poche parole - abbinare caratteri non di parole (incluso un numero) e caratteri di spazi non bianchi. Per riassumere, ecco cosa ha funzionato per me ...

• almeno 8personaggi
• almeno 1carattere numerico
• almeno una 1lettera minuscola
• almeno una 1lettera maiuscola
• almeno 1carattere speciale

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

JSFiddle Link - semplice demo che copre vari casi

Una versione più "generica" ​​(?), Che non consente lettere 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/>');
  });

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

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)(?=.*[$@$!%*?&.])[A-Za-z\d$@$!%*?&.]{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 non sono richieste le condizioni min e max, rimuoverle .{6, 16}

• 6 è il limite minimo di caratteri
• 20 è il limite massimo di caratteri
• ? = significa espressione di corrispondenza

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

Facevo molto Perl e mi sono abituato a risolvere i problemi con le regex. Tuttavia, quando diventano più complicati con tutte le anticipazioni e altre stranezze, è necessario scrivere dozzine di test unitari per uccidere tutti quei piccoli bug.

Inoltre, una regex è in genere alcune volte più lenta di una soluzione imperativa o funzionale.

Ad esempio, la seguente funzione Scala (non molto FP) risolve la domanda originale circa tre volte più velocemente del 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
}

Vorrei rispondere 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 caratteri speciali, quindi applicano anche i requisiti massimi, cosa che non credo sia stata richiesta dall'OP. Normalmente vuoi consentire ai tuoi utenti di rendere la loro password forte come vogliono; perché limitare le password complesse?

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 solo i personaggi rimanenti possono farlo essere lettere e numeri. Per consentire (ma non richiedere) caratteri speciali, dovresti usare qualcosa come:

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

o

^(?=.*[A-Za-z])(?=.*\d)[A-Za-z\d$@$!%*#?&]{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 tale requisito minimo, ma solo consente lettere e numeri. Uso:

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

o

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

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)(?=.*[#$@!%&*?])[A-Za-z\d#$@!%&*?]{8,30}$/    

Che ne dici di considerare la seguente soluzione regex:

^(?=.*[\w])(?=.*[\W])[\w\W]{8,}$

Che convalida quanto segue:

1. Almeno una minuscola
2. Almeno una maiuscola
3. Almeno una cifra
4. Almeno un personaggio speciale
5. Almeno dovrebbe contenere 8 caratteri.

Dai un'occhiata funzionando al seguente link https://regex101.com/r/qPmC06/4/

In base alle tue necessità, questo schema dovrebbe funzionare perfettamente. 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 ritorni vero se il modello è corretto, altrimenti falso.

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);
}

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

Eccolo in tutto il suo splendore, 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 lo usa \wperché include _, per cui sto testando.
2. Ho avuto molti problemi con i simboli corrispondenti, senza corrispondere alla fine della linea.
3. Non specifica simboli in modo specifico, anche perché localizzazioni diverse potrebbero avere simboli diversi sulla tastiera che potrebbero voler usare.

(?=.*[0-9])(?=.*[a-z])(?=.*[A-Z])(?=.*[@#$%^&+-]).{6}

@ClasG ha già suggerito :

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

ma non accetta _ (trattino basso) come carattere speciale (es. Aa12345_).

Uno migliorato è:

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

demo:

function password_check() {
  pass = document.getElementById("password").value;
  console.log(pass);
  regex = /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$/;
  if (regex.exec(pass) == null) {
    alert('invalid password!')
  }
  else {
    console.log("valid");
  }
}

<input type="text" id="password" value="Sample@1">
<input type="button" id="submit" onclick="password_check()" value="submit">

Test questo nel 2020:

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

Verifica te stesso

const regex = /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$/;
const str = `some12*Nuts`;
let m;

if ((m = regex.exec(str)) !== null) {
    // The result can be accessed through the `m`-variable.
    m.forEach((match, groupIndex) => {
        console.log(`Found match, group ${groupIndex}: ${match}`);
    });
}

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)(?=.*[#$@!%&*?])[A-Za-z\d#$@!%&*?]{8,}$

Può eseguire il test online: https://regex101.com

Solo possiamo farlo usando HTML5.

Usa sotto il codice nell'attributo modello,

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

Funzionerà perfettamente.

È possibile utilizzare il modello di espressioni regolari di seguito per verificare la password che corrisponda o meno alle proprie aspettative.

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

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

Controllo link online https://regex101.com/r/mqGurh/1

Usa questo,

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

Convalida per almeno una lettera minuscola, una maiuscola, un numero e i caratteri speciali di (!, @, #, $,%,?, =, *, &).

La lunghezza minima è 8 e la lunghezza massima è 20

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

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

Prova questo:

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

Questa espressione regolare funziona perfettamente per me.

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

Pattern per abbinare almeno 1 carattere maiuscolo, 1 cifra e tutti i caratteri speciali e la lunghezza tra 8 e 63.

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

Questo modello è stato utilizzato per la programmazione JAVA.

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

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

In realtà ho appena copiato la prima risposta qui e l'ho trasformata in una regex più comoda che ha bisogno di un carattere superiore, uno inferiore e almeno 8 caratteri, ma accetta tutto "in mezzo".

Questo è un esempio di regex che richiede

1. lunghezza di almeno 8 caratteri
2. almeno una lettera minuscola
3. almeno una lettera maiuscola

IMPORTANTE : questa regex esclude anche tutti gli altri caratteri, ad esempio numeri, caratteri speciali come $, # ,! ecc ., purché le regole da 1. a 3. corrispondano alla stringa di input

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

Badate al "." dalla fine della regex. Questo corrisponderà a quasi tutti i personaggi (e tutti i caratteri leggibili)

Se si desidera utilizzare le espressioni regolari per verificare la presenza di almeno otto caratteri, almeno una lettera maiuscola, almeno una lettera minuscola, almeno un numero compreso tra 0 e 9 e almeno un carattere speciale tra:! @ # $% ^ & * _? E anche dare all'utente un po 'più di informazioni su ciò che manca nella password, è possibile utilizzare il seguente codice:

let password = "@Aa3a4d$";

//  Check every single condition separately
let lowercase = password.match((/[a-z]+/g));
let uppercase = password.match((/[A-Z]+/g));
let digits = password.match((/[\d]+/g));
let special = password.match((/[!@#$%^&*_]+/g));
let lenght = password.match((/[A-Za-z\d!@#$%^&*_]{8,}/g));

//  Array to store information about any mismatches in the string
let errors = [];

if (password === '' ) {
    errors.push('Password is required');
}
if (lowercase === null) {
    errors.push('Password must include at least one lowercase letter');
}
if (uppercase === null) {
    errors.push('Password must include at least one uppercase letter');
}
if (digits === null) {
    errors.push('Password must include at least one digit from 0 to 9');
}
if (special  === null) {
    errors.push('Password must include at least one special character');
}
if (lenght === null) {
    errors.push('Password must include at least 8 characters');
}
if (errors.length > 0) {
    console.log(errors);
    return;
} else {
    // Process your password
}

Una soluzione che ho trovato in una delle risposte precedenti come:

* Minimo 8 caratteri almeno 1 alfabeto maiuscolo, 1 alfabeto minuscolo, 1 numero e 1 carattere speciale:

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

... non ha funzionato per me, ma la seguente è una versione semplificata e funziona benissimo (aggiungi qualsiasi carattere speciale che ti piace, ho aggiunto # qui) e aggiungi la regola numerica come fai con le lettere come:

"^(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])(?=.*[$@$!%*?&]){8,}"