Regex for password muss mindestens acht Zeichen, mindestens eine Zahl sowie Groß- und Kleinbuchstaben sowie Sonderzeichen enthalten

Mindestens acht Zeichen, mindestens ein Buchstabe und eine Zahl:

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

Mindestens acht Zeichen, mindestens ein Buchstabe, eine Zahl und ein Sonderzeichen:

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

Mindestens acht Zeichen, mindestens ein Großbuchstabe, ein Kleinbuchstabe und eine Zahl:

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

Mindestens acht Zeichen, mindestens ein Großbuchstabe, ein Kleinbuchstabe, eine Zahl und ein Sonderzeichen:

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

Mindestens acht und höchstens zehn Zeichen, mindestens ein Großbuchstabe, ein Kleinbuchstabe, eine Zahl und ein Sonderzeichen:

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

Sie können diese Regex verwenden:

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

Diese Regex wird die folgenden Regeln durchsetzen:

• Mindestens ein Großbuchstabe englischer Buchstabe , (?=.*?[A-Z])
• Mindestens ein englischer Kleinbuchstabe, (?=.*?[a-z])
• Mindestens eine Ziffer, (?=.*?[0-9])
• Mindestens ein Sonderzeichen, (?=.*?[#[email protected]$%^&*-])
• Mindestens acht Länge .{8,} (mit den Ankern)

Reguläre Ausdrücke haben keinen AND-Operator. Daher ist es ziemlich schwierig, einen Regex zu schreiben, der mit gültigen Passwörtern übereinstimmt, wenn Gültigkeit durch etwas AND AND AND AND AND Anderes definiert wird.

Allerdings haben reguläre Ausdrücke einen OR - Operator, wenden Sie also einfach den Satz von DeMorgan an und schreiben Sie eine Regex, die mit ungültigen Passwörtern übereinstimmt:

Alles mit weniger als acht ZeichenODERAlles ohne NummernODERAlles ohne GroßbuchstabenODERoder alles ohne KleinbuchstabenODERirgendetwas mit Nein spezielle Charaktere.

So:

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

Wenn irgendetwas dazu passt, ist es ein ungültiges Passwort.

Nur eine kleine Verbesserung für @ anubhavas Antwort: Da Sonderzeichen auf die auf der Tastatur angegebenen Zeichen beschränkt sind, können Sie diese für jedes Sonderzeichen verwenden:

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

Dieser reguläre Ausdruck erzwingt die folgenden Regeln:

• Mindestens ein englischer Großbuchstabe
• Mindestens ein englischer Kleinbuchstabe
• Mindestens eine Ziffer
• Mindestens ein Sonderzeichen
• Mindestens acht in der Länge

Ich hatte einige Schwierigkeiten, der beliebtesten Antwort für meine Umstände zu folgen. Beispielsweise ist meine Überprüfung mit Zeichen wie ; oder [ fehlgeschlagen. Ich war nicht an der weißen Auflistung meiner Sonderzeichen interessiert, also habe ich stattdessen [^\w\s] als Test verwendet. Zusammenfassend, hier ist was für mich gearbeitet hat ...

• mindestens 8 Zeichen
• mindestens 1 numerisches Zeichen
• mindestens 1 Kleinbuchstaben 
• mindestens 1 Großbuchstaben 
• mindestens 1 Sonderzeichen

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

JSFiddle Link - einfache Demo für verschiedene Fälle

Eine generischere Version (?), Die keine englischen Buchstaben als Sonderzeichen zulässt.

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

Importieren Sie die JavaScript-Datei jquery.validate.min.js.

Sie können diese Methode verwenden:

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

1. Mindestens ein englischer Großbuchstabe
2. Mindestens ein englischer Kleinbuchstabe
3. Mindestens eine Ziffer
4. Mindestens ein Sonderzeichen

Probier diese:

1. Mindestens sechs Zeichen
2. Mindestens ein Großbuchstabe
3. Mindestens ein Kleinbuchstabe
4. Mindestens ein Sonderzeichen

Ausdruck:

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

Optionale Sonderzeichen:

1. Mindestens ein Sonderzeichen
2. Mindestens eine Zahl
3. Sonderzeichen sind optional
4. Mindestens sechs und maximal 16 Zeichen

Ausdruck:

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

Wenn die Min- und Max-Bedingung nicht erforderlich ist, entfernen Sie .{6, 16}.

• 6 ist das minimale Zeichenlimit
• 20 ist maximale Zeichenbegrenzung
• ? = bedeutet übereinstimmender Ausdruck

Ich würde Peter Mortensen antworten, aber ich habe nicht genug Ruf.

Seine Ausdrücke sind für jede der angegebenen Mindestanforderungen perfekt. Das Problem mit seinen Ausdrücken, die keine Sonderzeichen erfordern, ist, dass sie auch keine Sonderzeichen zulassen, so dass sie auch maximale Anforderungen durchsetzen, die meines Erachtens vom OP nicht verlangt wurden. Normalerweise möchten Sie Ihren Benutzern erlauben, ihr Passwort so sicher zu machen, wie sie wollen. Warum starke Passwörter einschränken?

Also sein Ausdruck "mindestens acht Zeichen, mindestens ein Buchstabe und eine Ziffer":

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

erreicht die Mindestanforderung, aber die verbleibenden Zeichen können nur Buchstaben und Zahlen sein. Um Sonderzeichen zuzulassen (aber nicht zu erfordern), sollten Sie Folgendes verwenden:

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

oder

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

Ebenso "mindestens acht Zeichen, mindestens ein Großbuchstabe, ein Kleinbuchstabe und eine Ziffer:"

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

erfüllt diese Mindestanforderung, aber nur erlaubt Buchstaben und Zahlen. Verwenden:

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

oder

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

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

Die Frage nicht direkt beantworten, aber muss es wirklich eine Regex sein?

Ich habe viel Perl gemacht und habe mich daran gewöhnt, Probleme mit Regex zu lösen. Wenn sie jedoch mit den Look-Aheads und anderen Macken komplizierter werden, müssen Sie Dutzende von Unit-Tests schreiben, um all die kleinen Fehler zu beseitigen.

Darüber hinaus ist ein Regex normalerweise einige Male langsamer als eine zwingende oder funktionale Lösung.

Beispielsweise löst die folgende Scala-Funktion (nicht sehr FP) die ursprüngliche Frage etwa dreimal schneller als der Regex der am häufigsten verwendeten Antwort. Was es macht, ist auch so klar, dass Sie überhaupt keinen Komponententest benötigen:

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 nach Bedarf sollte dieses Muster gut funktionieren. Versuche dies,

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

Erstellen Sie einfach eine Zeichenfolgenvariable, weisen Sie das Muster zu und erstellen Sie eine boolesche Methode, die true zurückgibt, wenn das Muster korrekt ist.

Probe:

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

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

@ClasG hat bereits vorgeschlagen :

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

_ (Unterstrich) als Sonderzeichen (z. B. Aa12345_) wird jedoch nicht akzeptiert.

Eine verbesserte ist:

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

Ich habe hier viele Probleme gefunden, also habe ich meine eigenen gemacht.

Hier ist es in all seiner Pracht, mit Tests: 

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

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

Dinge, auf die Sie achten sollten:

1. verwendet \w nicht, da dies _ enthält, für das ich teste.
2. Ich hatte viele Probleme mit Symbolen, ohne das Ende der Zeile zu finden.
3. Gibt keine speziellen Symbole an. Dies liegt auch daran, dass verschiedene Gebietsschemas unterschiedliche Symbole auf der Tastatur haben, die sie verwenden möchten.

Verwenden Sie das folgende Regex, um die folgenden Bedingungen zu erfüllen:

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

Kann online testen: https://regex101.com

Wir können dies nur mit HTML5 tun.

Verwenden Sie den folgenden Code im Musterattribut.

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

Es wird perfekt funktionieren.

Sie können das folgende Muster für reguläre Ausdrücke verwenden, um das Kennwort zu überprüfen, ob es Ihren Erwartungen entspricht oder nicht.

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

Versuche dies:

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

Dieser reguläre Ausdruck funktioniert perfekt für mich.

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

Muster für mindestens 1 Großbuchstaben, 1 Ziffer und Sonderzeichen sowie eine Länge zwischen 8 und 63.

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

Dieses Muster wurde für die Java-Programmierung verwendet.

Ich habe gerade die erste Antwort hier kopiert und in eine mehr x-bequeme Regex verwandelt, die eine obere, eine untere und mindestens 8 Zeichen benötigt, aber alles "dazwischen" akzeptiert.

Dies ist eine Beispiel-Regex, die erfordert

1. mindestens 8 Zeichen lang
2. mindestens ein Kleinbuchstabe
3. mindestens ein Großbuchstabe

IMPORTANT: Diese Regex wird auch alle anderen Zeichen wie zB Zahlen, Sonderzeichen wie $, # ,! etc. ausnehmen - solange die Regeln 1. bis 3. Passen Sie die Eingabezeichenfolge an

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

Pass auf "." am Ende des regulären Ausdrucks. Dies entspricht fast jedem (und auch jedem lesbaren) Zeichen

Um in Java/Android ein Kennwort mit mindestens einer Nummer, einem Buchstaben und einem Sonderzeichen im folgenden Muster zu testen:

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

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

Linkprüfung online https://regex101.com/r/mqGurh/1

Hoffe das unten funktioniert. Ich habe dies in der benutzerdefinierten Azure-Richtlinie versucht.

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