Regex für Passwort muss mindestens acht Zeichen, mindestens eine Zahl sowie Klein- und Großbuchstaben und Sonderzeichen enthalten

Ich möchte, dass ein regulärer Ausdruck dies überprüft:

Ein Passwort enthält mindestens acht Zeichen, darunter mindestens eine Zahl und umfasst sowohl niedrigere als auch Großbuchstaben und Sonderzeichen, zum Beispiel #, ?, !.

Es kann nicht Ihr altes Passwort sein oder Ihren Benutzernamen enthalten "password", oder"websitename"

Und hier ist mein Validierungsausdruck für acht Zeichen, einschließlich eines Großbuchstaben, eines Kleinbuchstaben und einer Zahl oder eines Sonderzeichens.

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

Wie kann ich es schreiben, denn ein Passwort muss aus acht Zeichen bestehen, darunter ein Großbuchstabe, ein Sonderzeichen und alphanumerische Zeichen ?

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\d@$!%*#?&]{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\d@$!%*?&]{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\d@$!%*?&]{8,10}$"

Sie können diesen regulären Ausdruck mit mehreren Lookahead-Zusicherungen (Bedingungen) verwenden :

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

Dieser reguläre Ausdruck erzwingt die folgenden Regeln:

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

Reguläre Ausdrücke haben keinen UND-Operator, daher ist es ziemlich schwierig, einen regulären Ausdruck zu schreiben, der gültigen Passwörtern entspricht, wenn die Gültigkeit durch etwas UND etwas anderes UND etwas anderes definiert wird ...

Reguläre Ausdrücke haben jedoch einen ODER-Operator. Wenden Sie also einfach den Satz von DeMorgan an und schreiben Sie einen regulären Ausdruck, der mit ungültigen Kennwörtern übereinstimmt:

Alles mit weniger als acht Zeichen ODER alles ohne Zahlen ODER alles ohne Großbuchstaben ODER oder alles ohne Kleinbuchstaben ODER alles ohne Sonderzeichen.

Damit:

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

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

Nur eine kleine Verbesserung für die Antwort von @ anubhava: Da Sonderzeichen auf die Zeichen auf der Tastatur beschränkt sind, verwenden Sie diese für jedes Sonderzeichen:

^(?=.*?[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. Zum Beispiel schlug meine Validierung mit Zeichen wie ;oder fehl [. Ich war nicht daran interessiert, meine Sonderzeichen in eine weiße Liste aufzunehmen, daher habe ich stattdessen [^\w\s]als Test - einfach ausgedrückt - die Übereinstimmung von Nicht-Wort-Zeichen (einschließlich numerischer Zeichen) und Nicht-Leerzeichen verwendet. Zusammenfassend ist hier, was für mich funktioniert hat ...

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

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

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

Eine "allgemeinere" 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)(?=.*[$@$!%*?&.])[A-Za-z\d$@$!%*?&.]{6, 20}/"

Optionale Sonderzeichen:

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

Ausdruck:

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

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

• 6 ist die minimale Zeichenbegrenzung
• 20 ist die maximale Zeichenbegrenzung
• ? = bedeutet Übereinstimmungsausdruck

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

Ich habe viel Perl gemacht und mich daran gewöhnt, Probleme mit Regexen zu lösen. Wenn sie jedoch mit all den Voraussichten und anderen Macken komplizierter werden, müssen Sie Dutzende von Komponententests schreiben, um all diese kleinen Fehler zu beseitigen.

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

Zum Beispiel löst die folgende (nicht sehr FP) Scala-Funktion die ursprüngliche Frage etwa dreimal schneller als der reguläre Ausdruck der beliebtesten Antwort. Was es tut, 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
}

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

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

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

^(?=.*[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,}$ Zeichen zulassen

oder

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

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

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

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

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

oder

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

Was ist mit der Betrachtung der folgenden Regex-Lösung:

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

Was Folgendes bestätigt:

1. Mindestens ein Kleinbuchstabe
2. Mindestens ein Großbuchstabe
3. Mindestens eine Ziffer
4. Mindestens ein Sonderzeichen
5. Es sollte mindestens 8 Zeichen lang sein.

Überprüfen Sie es unter dem folgenden Link: https://regex101.com/r/qPmC06/4/

Je nach Bedarf sollte dieses Muster einwandfrei 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, andernfalls false.

Stichprobe:

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

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

Hier ist es in seiner ganzen 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. wird nicht verwendet, \wweil das beinhaltet _, worauf ich teste.
2. Ich hatte viele Probleme, Symbole zu finden, ohne das Zeilenende zu finden.
3. Gibt keine spezifischen Symbole an. Dies liegt auch daran, dass unterschiedliche Gebietsschemas möglicherweise unterschiedliche Symbole auf ihren Tastaturen haben, die sie möglicherweise verwenden möchten.

(?=.*[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) wird jedoch nicht als Sonderzeichen akzeptiert (z. B. Aa12345_).

Eine verbesserte ist:

^(?=\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">

Testen Sie dieses im Jahr 2020:

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

Überprüfen Sie sich

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

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

Kann online testen: https://regex101.com

Nur können wir dies 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])(?=.*[~!@#$%^&*()]).{8,20})

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

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

Benutze das,

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

Es wird für mindestens einen Kleinbuchstaben, einen Großbuchstaben, eine Zahl und die Sonderzeichen von (!, @, #, $,%,?, =, *, &) Validiert.

Die minimale Länge beträgt 8 und die maximale Länge beträgt 20

Testen Sie in Java / Android ein Kennwort mit mindestens einer Zahl, einem Buchstaben und einem Sonderzeichen in folgendem Muster:

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

Versuche dies:

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

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

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

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

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

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

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

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

Ich habe gerade die erste Antwort hier kopiert und sie in einen bequemeren regulären Ausdruck umgewandelt, der einen oberen, einen unteren und mindestens 8 Zeichen benötigt, aber alles "dazwischen" akzeptiert.

Dies ist ein Beispiel-Regex, der erfordert

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

WICHTIG : Dieser reguläre Ausdruck schließt auch alle anderen Zeichen aus, z. B. Zahlen, Sonderzeichen wie $, #,! usw. - solange die Regeln 1. bis 3. mit der Eingabezeichenfolge übereinstimmen

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

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

Wenn Sie reguläre Ausdrücke verwenden möchten, um nach mindestens acht Zeichen zu suchen, mindestens einem Großbuchstaben, mindestens einem Kleinbuchstaben, mindestens einer Zahl von 0 bis 9 und mindestens einem Sonderzeichen von :! @ # $% ^ & * _? UND geben Sie dem Benutzer auch ein bisschen mehr Informationen darüber, was im Passwort fehlt. Sie können den folgenden Code verwenden:

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
}

Eine Lösung, die ich in einer der vorherigen Antworten gefunden habe:

* Mindestens 8 Zeichen, mindestens 1 Großbuchstaben, 1 Kleinbuchstaben, 1 Zahl und 1 Sonderzeichen:

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

... hat bei mir nicht funktioniert, aber das Folgende ist eine vereinfachte Version und funktioniert hervorragend (fügen Sie ein beliebiges Sonderzeichen hinzu, ich habe hier # hinzugefügt) und fügen Sie die Zahlenregel hinzu, wie Sie es mit den Buchstaben tun:

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