L'expression régulière du mot de passe doit contenir au moins huit caractères, au moins un chiffre et des lettres minuscules et majuscules et des caractères spéciaux

Je veux une expression régulière pour vérifier que:

Un mot de passe contient au moins huit caractères, dont au moins un chiffre et comprend les lettres majuscules et minuscules et des caractères spéciaux, par exemple #, ?, !.

Il ne peut pas s'agir de votre ancien mot de passe ou contenir votre nom d'utilisateur "password", ou"websitename"

Et voici mon expression de validation qui est pour huit caractères dont une lettre majuscule, une lettre minuscule et un chiffre ou caractère spécial.

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

Comment puis-je l'écrire pour un mot de passe doit être composé de huit caractères dont une lettre majuscule, un caractère spécial et des caractères alphanumériques ?

Huit caractères au minimum, au moins une lettre et un chiffre:

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

Huit caractères au moins, au moins une lettre, un chiffre et un caractère spécial:

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

Huit caractères au minimum, au moins une lettre majuscule, une lettre minuscule et un chiffre:

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

Huit caractères au moins, au moins une lettre majuscule, une lettre minuscule, un chiffre et un caractère spécial:

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

Huit et dix caractères au minimum, au moins une lettre majuscule, une lettre minuscule, un chiffre et un caractère spécial:

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

Vous pouvez utiliser cette expression régulière avec plusieurs assertions d'anticipation (conditions) :

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

Cette expression régulière appliquera ces règles:

• Au moins une lettre majuscule en anglais ,(?=.*?[A-Z])
• Au moins une lettre minuscule en anglais, (?=.*?[a-z])
• Au moins un chiffre, (?=.*?[0-9])
• Au moins un caractère spécial, (?=.*?[#?!@$%^&*-])
• Longueur minimale de huit .{8,}(avec les ancres)

Les expressions régulières n'ont pas d'opérateur ET, il est donc assez difficile d'écrire une expression régulière qui correspond à des mots de passe valides, lorsque la validité est définie par quelque chose ET quelque chose d'autre ET quelque chose d'autre ...

Mais, les expressions régulières ont un opérateur OU, alors appliquez simplement le théorème de DeMorgan et écrivez une expression régulière qui correspond aux mots de passe invalides:

Tout ce qui contient moins de huit caractères OU tout ce qui n'a pas de chiffres OU tout ce qui n'est pas en majuscule OU ou quoi que ce soit sans minuscule OU quoi que ce soit sans caractère spécial.

Donc:

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

Si quelque chose correspond à cela, alors c'est un mot de passe invalide.

Juste une petite amélioration pour la réponse de @ anubhava: Étant donné que les caractères spéciaux sont limités à ceux du clavier, utilisez-le pour tout caractère spécial:

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

Cette expression régulière appliquera ces règles:

• Au moins une lettre anglaise majuscule
• Au moins une lettre minuscule en anglais
• Au moins un chiffre
• Au moins un caractère spécial
• Longueur minimale de huit

J'ai eu quelques difficultés à suivre la réponse la plus populaire pour ma situation. Par exemple, ma validation échouait avec des caractères tels que ;ou [. Je n'étais pas intéressé par la mise en liste blanche de mes caractères spéciaux, alors j'ai plutôt utilisé [^\w\s]comme test - simplement - des caractères non verbaux (y compris numériques) et des espaces non blancs. Pour résumer, voici ce qui a fonctionné pour moi ...

• au moins des 8personnages
• au moins 1un caractère numérique
• au moins une 1lettre minuscule
• au moins une 1lettre majuscule
• au moins 1caractère spécial

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

JSFiddle Link - démo simple couvrant divers cas

Une version plus "générique" (?), N'autorisant aucune lettre anglaise comme caractère spécial .

^(?=\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/>');
  });

Importez le fichier JavaScript jquery.validate.min.js.

Vous pouvez utiliser cette méthode:

$.validator.addMethod("pwcheck", function (value) {
    return /[\@\#\$\%\^\&\*\(\)\_\+\!]/.test(value) && /[a-z]/.test(value) && /[0-9]/.test(value) && /[A-Z]/.test(value)
});

1. Au moins une lettre anglaise majuscule
2. Au moins une lettre minuscule en anglais
3. Au moins un chiffre
4. Au moins un caractère spécial

Essaye celui-là:

1. Minimum six caractères
2. Au moins un caractère majuscule
3. Au moins un caractère minuscule
4. Au moins un caractère spécial

Expression:

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

Caractères spéciaux facultatifs:

1. Au moins un caractère spécial
2. Au moins un numéro
3. Les caractères spéciaux sont facultatifs
4. Minimum six caractères et maximum 16 caractères

Expression:

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

Si la condition min et max n'est pas requise, supprimez .{6, 16}

• 6 est la limite de caractères minimum
• 20 est la limite maximale de caractères
• ? = signifie expression de correspondance

Ne répondant pas directement à la question, mais faut-il vraiment que ce soit une expression régulière?

J'avais l'habitude de faire beaucoup de Perl et de m'habituer à résoudre des problèmes avec des expressions rationnelles. Cependant, quand ils deviennent plus compliqués avec toutes les perspectives et autres bizarreries, vous devez écrire des dizaines de tests unitaires pour tuer tous ces petits bugs.

De plus, une expression régulière est généralement quelques fois plus lente qu'une solution impérative ou fonctionnelle.

Par exemple, la fonction Scala suivante (pas très FP) résout la question d'origine environ trois fois plus rapidement que l'expression régulière de la réponse la plus populaire. Ce qu'il fait est également si clair que vous n'avez pas du tout besoin d'un test unitaire:

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
}

Je répondrais à Peter Mortensen, mais je n'ai pas assez de réputation.

Ses expressions sont parfaites pour chacune des exigences minimales spécifiées. Le problème avec ses expressions qui ne nécessitent pas de caractères spéciaux est qu'elles n'autorisent pas non plus les caractères spéciaux, elles imposent donc également des exigences maximales, ce que je ne crois pas que l'OP ait demandé. Normalement, vous voulez permettre à vos utilisateurs de rendre leur mot de passe aussi fort qu'ils le souhaitent; pourquoi restreindre les mots de passe forts?

Ainsi, son expression "au moins huit caractères, au moins une lettre et un chiffre":

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

atteint l'exigence minimale, mais les caractères restants ne peuvent être que des lettres et des chiffres. Pour autoriser (mais pas exiger) des caractères spéciaux, vous devez utiliser quelque chose comme:

^(?=.*[A-Za-z])(?=.*\d).{8,}$ pour autoriser tous les caractères

ou

^(?=.*[A-Za-z])(?=.*\d)[A-Za-z\d$@$!%*#?&]{8,}$ pour autoriser des caractères spéciaux spécifiques

De même, "au moins huit caractères, au moins une lettre majuscule, une lettre minuscule et un chiffre:"

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

répond à cette exigence minimale, mais autorise uniquement les lettres et les chiffres. Utilisation:

^(?=.*[a-z])(?=.*[A-Z])(?=.*\d).{8,}$ pour autoriser tous les caractères

ou

^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)[A-Za-z\d$@$!%*?&]{8,} pour autoriser des caractères spéciaux spécifiques.

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}$/    

Qu'en est-il de la solution regex suivante:

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

Ce qui valide les éléments suivants:

1. Au moins un minuscule
2. Au moins un majuscule
3. Au moins un chiffre
4. Au moins un caractère spécial
5. Au moins, il doit contenir 8 caractères.

Découvrez-le en travaillant sur le lien suivant https://regex101.com/r/qPmC06/4/

Selon votre besoin, ce modèle devrait très bien fonctionner. Essaye ça,

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

Il suffit de créer une variable chaîne, d'assigner le modèle et de créer une méthode booléenne qui renvoie vrai si le modèle est correct, sinon faux.

Échantillon:

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

J'ai trouvé beaucoup de problèmes ici, alors j'ai fait le mien.

La voici dans toute sa splendeur, avec des tests:

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

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

À surveiller:

1. n'utilise pas \wparce que cela inclut _, que je teste.
2. J'ai eu beaucoup de problèmes pour faire correspondre les symboles, sans faire correspondre la fin de la ligne.
3. Ne spécifie pas spécifiquement les symboles, cela est également dû au fait que différents paramètres régionaux peuvent avoir différents symboles sur leurs claviers qu'ils peuvent vouloir utiliser.

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

@ClasG a déjà suggéré :

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

mais il n'accepte pas _ (trait de soulignement) comme caractère spécial (par exemple, Aa12345_).

Une amélioration est:

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

Démo:

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 de celui-ci en 2020:

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

Vérifiez-vous

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

Utilisez le Regex suivant pour satisfaire les conditions ci-dessous:

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

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

Peut tester en ligne: https://regex101.com

Nous pouvons simplement le faire en utilisant HTML5.

Utilisez le code ci-dessous dans l'attribut de modèle,

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

Cela fonctionnera parfaitement.

Vous pouvez utiliser le modèle d'expression régulière ci-dessous pour vérifier le mot de passe s'il correspond à vos attentes ou non.

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

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

Vérification des liens en ligne https://regex101.com/r/mqGurh/1

Utilisez ceci,

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

Il validera au moins un minuscule, un majuscule, un nombre et les caractères spéciaux de (!, @, #, $,%,?, =, *, &).

La longueur minimale est de 8 et la longueur maximale est de 20

En Java / Android, pour tester un mot de passe avec au moins un chiffre, une lettre, un caractère spécial dans le schéma suivant:

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

Essaye ça:

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

Cette expression régulière fonctionne parfaitement pour moi.

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

Motif pour correspondre à au moins 1 caractère majuscule, 1 chiffre et tout caractère spécial et la longueur entre 8 à 63.

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

Ce modèle a été utilisé pour la programmation JAVA.

J'espère que les travaux ci-dessous. J'ai essayé cela dans la stratégie personnalisée Azure.

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

En fait, je viens de copier la première réponse ici et de la transformer en une expression rationnelle plus pratique qui nécessite un caractère supérieur, un caractère inférieur et au moins 8 caractères, mais accepte tout "entre les deux".

Celui-ci est un exemple-regex qui nécessite

1. longueur d'au moins 8 caractères
2. au moins une lettre minuscule
3. au moins une lettre majuscule

IMPORTANT : Cette expression régulière exclura également tous les autres caractères, par exemple les chiffres, les caractères spéciaux tels que $, #,! etc. - tant que les règles 1. à 3. correspondent à la chaîne d'entrée

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

Attention au "." alomst à la fin de l'expression régulière. Cela correspondra à presque tous les caractères (et afaik tout lisible)

Si vous souhaitez utiliser des expressions régulières pour vérifier au moins huit caractères, au moins une lettre majuscule, au moins une lettre minuscule, au moins un chiffre de 0 à 9 et au moins un caractère spécial de:! @ # $% ^ & * _? ET donnez également à l'utilisateur un peu plus d'informations sur ce qu'il manque dans le mot de passe, vous pouvez utiliser le code suivant:

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
}

Une solution que j'ai trouvée dans l'une des réponses précédentes:

* Minimum 8 caractères au moins 1 alphabet majuscule, 1 alphabet minuscule, 1 chiffre et 1 caractère spécial:

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

... n'a pas fonctionné pour moi, mais ce qui suit est une version simplifiée et fonctionne très bien (ajoutez n'importe quel caractère spécial que vous aimez, j'ai ajouté # ici), et ajoutez la règle numérique comme vous le faites avec les lettres comme:

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