Regex voor wachtwoord moet minimaal acht tekens, minimaal één cijfer en zowel kleine als hoofdletters en speciale tekens bevatten

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

Antwoord 8

Ik zou Peter Mortensen willen antwoorden, maar ik heb niet genoeg reputatie.

Zijn uitdrukkingen zijn perfect voor elk van de gespecificeerde minimumvereisten. Het probleem met zijn uitdrukkingen die geen speciale tekens vereisen, is dat ze ook geen speciale tekens TOESTAAN, dus ze dwingen ook maximale vereisten af, wat volgens mij niet door het OP is gevraagd. Normaal gesproken wil je dat je gebruikers hun wachtwoord zo sterk kunnen maken als ze willen; waarom sterke wachtwoorden beperken?

Dus zijn uitdrukking “minimaal acht tekens, ten minste één letter en één cijfer”:

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

voldoet aan de minimumvereiste, maar de overige tekens mogen alleenletters en cijfers zijn. Om speciale tekens toe te staan (maar niet te vereisen), moet je zoiets gebruiken als:

^(?=.*[A-Za-z])(?=.*\d).{8,}$om alle tekens toe te staan

of

^(?=.*[A-Za-z])(?=.*\d)[A-Za-z\d$@$!%*#?&]{8,}$om specifieke speciale tekens toe te staan

Evenzo, “minimaal acht tekens, ten minste één hoofdletter, één kleine letter en één cijfer:”

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

voldoet aan die minimumvereiste, maar alleenstaat letters en cijfers toe. Gebruik:

^(?=.*[a-z])(?=.*[A-Z])(?=.*\d).{8,}$om alle tekens toe te staan

of

^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)[A-Za-z\d$@$!%*?&]{8,}om specifieke speciale tekens toe te staan.

Antwoord 9

Importeer het JavaScript-bestand jquery.validate.min.js.

U kunt deze methode gebruiken:

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

1. Ten minste één hoofdletters Engelse letter
2. Ten minste één kleine letter
3. ten minste één cijfer
4. ten minste één speciaal teken

Antwoord 10

Probeer deze:

1. minimaal zes tekens
2. ten minste één hoofdletters
3. ten minste één kleine letters
4. ten minste één speciaal teken

expressie:

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

Optionele speciale tekens:

1. ten minste één speciaal teken
2. ten minste één cijfer
3. Speciale tekens zijn optioneel
4. minimaal zes tekens en maximaal 16 tekens

expressie:

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

Als de MIN- en MAX-voorwaarde niet vereist is, verwijdert u vervolgens .{6, 16}

• 6 is een minimale tekenlimiet
• 20 is maximale tekenlimiet
• ? = middelen match expressie

Antwoord 11

Hoe zit het met het overwegen van de volgende regexoplossing:

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

die het volgende valideert:

1. ten minste één kleine letters
2. ten minste één hoofdletter
3. ten minste één cijfer
4. ten minste één speciaal teken
5. het zou tenminste 8 tekens lang moeten hebben.

Bekijk het werken op de volgende link https://regex101.com/r/qpmc06/4 /

Antwoord 12

Dit werkte voor mij:

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

• ten minste 8 tekens lang;
• één kleine letters, één hoofdletters, één nummer en één speciaal teken;
• geen witvakken.

Antwoord 13

^(?=.*[A-Z])(?=.*[a-z])(?=.*[0-9])(?=.*[!@#$%^&*()_+,.\\\/;':"-]).{8,}$

Antwoord 14

de vraag niet rechtstreeks beantwoorden, maar moet het echt een regex zijn?

Ik droeg veel perl en werd gewend aan het oplossen van problemen met regoxes. Wanneer ze echter gecompliceerder worden met alle kijkbeurten en andere eigenaardigheden, moet u tientallen eenheidstests schrijven om al die kleine bugs te doden.

Bovendien is een regex typisch een paar keer langzamer dan een imperatief of een functionele oplossing.

Bijvoorbeeld, de volgende (niet erg FP) Scala-functie lost de oorspronkelijke vraag ongeveer drie keer sneller op dan de regex van het populairste antwoord. Wat het wel doet is ook zo duidelijk dat u helemaal geen eenheidstest nodig hebt:

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
}

Antwoord 15

/^(?=.*[A-Z])(?=.*[a-z])(?=.*[0-9]).*$/

Dit is de eenvoudige manier om het te gebruiken terwijl je tenminste 1 hoofdletters 1 kleine letters en 1 cijfer

En dit is het voorbeeld terwijl ik gebruik in Express-validatie

check('password')
    .notEmpty()
    .withMessage('Password cannot be null')
    .bail()
    .isLength({ min: 6 })
    .withMessage('Password must be at least 6 characters')
    .bail()
    .matches(/^(?=.*[A-Z])(?=.*[a-z])(?=.*[0-9]).*$/)
    .withMessage(
      'Must have atleast 1 uppercase, 1 lowercase letter and 1 number'
    ),

Antwoord 16

Volgens uw behoefte moet dit patroon prima werken. Probeer dit,

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

Maak gewoon een tekenreeksvariabele, wijs het patroon toe en maak een Booleaanse methode die TRUE reteert als het patroon correct is, anders onwaar.

Sample:

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

Antwoord 17

Ik heb hier veel problemen gevonden, dus ik heb het mijne gemaakt.

Hier is het in al het is glorie, met tests:

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

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

Dingen om op te letten:

1. Gebruikt niet \womdat dat _bevat, waar ik op test.
2. Ik heb veel problemen bij elkaar passende symbolen gehad, zonder het einde van de regel te matchen.
3. Geeft geen specifiek symbolen op, dit komt ook omdat verschillende localen verschillende symbolen hebben op hun toetsenborden die ze misschien willen gebruiken.

Antwoord 18

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">

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

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

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

var strongRegex = new RegExp("^(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])(?=.*[!@#\$%\^&\*])(?=.{8,})");
var mediumRegex = new RegExp("^(((?=.*[a-z])(?=.*[A-Z]))|((?=.*[a-z])(?=.*[0-9]))|((?=.*[A-Z])(?=.*[0-9])))(?=.{6,})");

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

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

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

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

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

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

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

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

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