Regex hasła musi zawierać co najmniej osiem znaków, co najmniej jedną cyfrę oraz zarówno małe, jak i wielkie litery oraz znaki specjalne

Chcę, aby wyrażenie regularne sprawdzało, czy:

Hasło zawiera co najmniej osiem znaków, w tym co najmniej jednego numeru i obejmuje zarówno dolne i wielkich liter oraz znaków specjalnych, na przykład #, ?, !.

Nie może to być twoje stare hasło ani nazwa użytkownika "password", lub"websitename"

A oto moje wyrażenie walidacyjne, które dotyczy ośmiu znaków, w tym jednej wielkiej litery, jednej małej litery oraz jednej cyfry lub znaku specjalnego.

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

Jak mogę napisać, aby hasło składało się z ośmiu znaków, w tym jednej wielkiej litery, jednego znaku specjalnego i znaków alfanumerycznych ?

Co najmniej osiem znaków, co najmniej jedna litera i jedna liczba:

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

Co najmniej osiem znaków, co najmniej jedna litera, jedna cyfra i jeden znak specjalny:

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

Co najmniej osiem znaków, co najmniej jedna wielka litera, jedna mała litera i jedna cyfra:

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

Co najmniej osiem znaków, co najmniej jedna wielka litera, jedna mała litera, jedna cyfra i jeden znak specjalny:

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

Co najmniej osiem i maksymalnie 10 znaków, co najmniej jedna wielka litera, jedna mała litera, jedna cyfra i jeden znak specjalny:

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

Możesz użyć tego wyrażenia regularnego z wieloma twierdzeniami dotyczącymi przyszłości (warunki) :

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

Ten regex wymusi następujące reguły:

• Co najmniej jedna wielka litera angielska ,(?=.*?[A-Z])
• Co najmniej jedna mała angielska litera, (?=.*?[a-z])
• Co najmniej jedna cyfra, (?=.*?[0-9])
• Co najmniej jedna postać specjalna, (?=.*?[#?!@$%^&*-])
• Minimalna długość ośmiu .{8,}(z kotwami)

Wyrażenia regularne nie mają operatora AND, więc bardzo trudno jest napisać wyrażenie pasujące do poprawnych haseł, gdy ważność jest zdefiniowana przez coś ORAZ coś innego ORAZ coś innego ...

Ale wyrażenia regularne mają operator OR, więc po prostu zastosuj twierdzenie DeMorgan i napisz wyrażenie pasujące do niepoprawnych haseł:

Wszystko z mniej niż ośmioma znakami LUB cokolwiek bez cyfr LUB cokolwiek bez wielkich liter LUB cokolwiek bez małych liter LUB cokolwiek bez znaków specjalnych.

Więc:

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

Jeśli coś pasuje, to jest to nieprawidłowe hasło.

Tylko małe ulepszenie odpowiedzi @ anubhava: Ponieważ znaki specjalne są ograniczone do znaków na klawiaturze, użyj tego dla każdego znaku specjalnego:

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

Ten regex wymusi następujące reguły:

• Co najmniej jedna wielka litera angielska
• Co najmniej jedna mała angielska litera
• Co najmniej jedna cyfra
• Co najmniej jedna postać specjalna
• Minimalna długość ośmiu

Z trudem podążałem za najbardziej popularną odpowiedzią na moje okoliczności. Na przykład moja walidacja zakończyła się niepowodzeniem ze znakami takimi jak ;lub [. Nie byłem zainteresowany umieszczaniem na liście moich znaków specjalnych na białej liście, więc zamiast tego wykorzystałem [^\w\s]jako test - po prostu - dopasowuję znaki nie zawierające słów (w tym numeryczne) i znaki spacji. Podsumowując, oto, co zadziałało dla mnie ...

• przynajmniej 8postacie
• co najmniej 1znak numeryczny
• przynajmniej 1 mała litera
• przynajmniej 1 wielka litera
• przynajmniej 1znak specjalny

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

JSFiddle Link - proste demo obejmujące różne przypadki

Bardziej „ogólna” wersja (?), Która nie dopuszcza żadnych liter angielskich jako znaków specjalnych .

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

Zaimportuj plik JavaScript jquery.validate.min.js.

Możesz użyć tej metody:

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

1. Co najmniej jedna wielka litera angielska
2. Co najmniej jedna mała angielska litera
3. Co najmniej jedna cyfra
4. Co najmniej jedna postać specjalna

Spróbuj tego:

1. Minimum sześć znaków
2. Co najmniej jedna wielka litera
3. Co najmniej jedna mała litera
4. Co najmniej jedna postać specjalna

Wyrażenie:

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

Opcjonalne znaki specjalne:

1. Co najmniej jedna postać specjalna
2. Przynajmniej jeden numer
3. Znaki specjalne są opcjonalne
4. Minimum sześć znaków i maksymalnie 16 znaków

Wyrażenie:

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

Jeśli warunek minimalny i maksymalny nie jest wymagany, usuń go .{6, 16}

• 6 to minimalny limit znaków
• 20 to maksymalny limit znaków
• ? = oznacza dopasowanie wyrażenia

Nie odpowiada bezpośrednio na pytanie, ale czy naprawdę musi to być wyrażenie regularne?

Robiłem dużo Perla i przyzwyczaiłem się do rozwiązywania problemów z wyrażeniami regularnymi. Jednak gdy stają się bardziej skomplikowane ze względu na wszystkie przewidywania i inne dziwactwa, musisz napisać dziesiątki testów jednostkowych, aby zabić wszystkie te małe błędy.

Co więcej, wyrażenie regularne jest zazwyczaj kilka razy wolniejsze niż rozwiązanie imperatywne lub funkcjonalne.

Na przykład następująca (niezbyt FP) funkcja Scala rozwiązuje oryginalne pytanie około trzy razy szybciej niż regex najpopularniejszej odpowiedzi. To, co robi, jest tak jasne, że wcale nie potrzebujesz testu jednostkowego:

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
}

Chciałbym odpowiedzieć Peterowi Mortensenowi, ale nie mam wystarczającej reputacji.

Jego wyrażenia są idealne dla każdego z określonych wymagań minimalnych. Problem z jego wyrażeniami, które nie wymagają znaków specjalnych, polega na tym, że NIE ZEZWALAJĄ także na znaki specjalne, dlatego też egzekwują maksymalne wymagania, których, jak sądzę, nie wymagał OP. Zwykle chcesz pozwolić swoim użytkownikom ustawić hasło tak silne, jak chcą; po co ograniczać silne hasła?

Zatem jego wyrażenie „co najmniej osiem znaków, co najmniej jedna litera i jedna cyfra”:

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

spełnia minimalne wymagania, ale pozostałe znaki mogą być tylko literą i cyframi. Aby zezwolić (ale nie wymagać) znaków specjalnych, należy użyć czegoś takiego:

^(?=.*[A-Za-z])(?=.*\d).{8,}$ aby umożliwić dowolne postacie

lub

^(?=.*[A-Za-z])(?=.*\d)[A-Za-z\d$@$!%*#?&]{8,}$ aby umożliwić określone znaki specjalne

Podobnie „co najmniej osiem znaków, co najmniej jedna wielka litera, jedna mała litera i jedna cyfra:”

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

spełnia to minimalne wymaganie, ale dopuszcza tylko litery i cyfry. Posługiwać się:

^(?=.*[a-z])(?=.*[A-Z])(?=.*\d).{8,}$ aby umożliwić dowolne postacie

lub

^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)[A-Za-z\d$@$!%*?&]{8,} aby umożliwić określone znaki specjalne.

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

Co powiesz na rozważenie następującego rozwiązania wyrażenia regularnego:

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

Który potwierdza następujące:

1. Co najmniej jedna mała litera
2. Co najmniej jedna wielka litera
3. Co najmniej jedna cyfra
4. Co najmniej jedna postać specjalna
5. Powinien mieć przynajmniej 8 znaków.

Sprawdź to, pracując pod następującym linkiem https://regex101.com/r/qPmC06/4/

W zależności od potrzeb wzór ten powinien działać dobrze. Spróbuj tego,

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

Po prostu utwórz zmienną łańcuchową, przypisz wzór i utwórz metodę logiczną, która zwraca true, jeśli wzór jest poprawny, w przeciwnym razie false.

Próba:

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

Znalazłem tutaj wiele problemów, więc zrobiłem własny.

Oto wszystko w pełnej krasie dzięki testom:

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

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

Na co zwrócić uwagę:

1. nie używa, \wponieważ to obejmuje _, dla których testuję.
2. Miałem wiele problemów z dopasowaniem symboli, bez dopasowania końca linii.
3. Nie określa konkretnie symboli, dzieje się tak również dlatego, że różne ustawienia narodowe mogą mieć różne symbole na klawiaturze, z których mogą chcieć korzystać.

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

@ClasG zasugerował już :

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

ale nie akceptuje _ (podkreślenia) jako znaku specjalnego (np. Aa12345_).

Ulepszony to:

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

Próbny:

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

Testowanie tego w 2020 roku:

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

Sprawdź siebie

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

Użyj następującego Regex, aby spełnić poniższe warunki:

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

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

Można testować online: https://regex101.com

Po prostu możemy to zrobić za pomocą HTML5.

Użyj poniższego kodu w atrybucie wzorca,

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

Będzie działać idealnie.

Możesz użyć poniższego wzorca wyrażeń regularnych, aby sprawdzić, czy hasło odpowiada Twoim oczekiwaniom.

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

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

Link sprawdzić online https://regex101.com/r/mqGurh/1

Użyj tego,

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

Sprawdza poprawność co najmniej jednej małej litery, jednej dużej litery, jednej liczby i specjalnych znaków (!, @, #, $,%,?, =, *, &).

Minimalna długość to 8, a maksymalna to 20

W Javie / Androidzie, aby przetestować hasło z co najmniej jedną cyfrą, jedną literą i jednym znakiem specjalnym według następującego wzoru:

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

Spróbuj tego:

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

To wyrażenie regularne działa dla mnie idealnie.

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

Wzór do dopasowania co najmniej 1 wielkiej litery, 1 cyfry i dowolnych znaków specjalnych oraz długości od 8 do 63.

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

Ten wzorzec wykorzystano do programowania JAVA.

Mam nadzieję, że poniżej działa. Próbowałem tego w niestandardowych zasadach platformy Azure.

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

Właśnie skopiowałem pierwszą odpowiedź tutaj i przekształciłem ją w bardziej wygodny dla użytkownika regex, który wymaga jednej górnej, jednej dolnej i co najmniej 8 znaków, ale akceptuje wszystko „pomiędzy”.

Ten jest przykładem wyrażenia regularnego wymagającego

1. co najmniej 8 znaków
2. co najmniej jedna mała litera
3. przynajmniej jedna duża litera

WAŻNE : Wyrażenie regularne będzie również oprócz wszystkich innych znaków, np. Liczb, znaków specjalnych, takich jak $, # ,! itd. - o ile reguły 1. do 3. odpowiadają ciągowi wejściowemu

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

Pamiętaj o „.” alomst na końcu wyrażenia regularnego. Będzie pasować do prawie każdego (i afaik dowolnego czytelnego) znaku

Jeśli chcesz użyć wyrażeń regularnych do sprawdzenia co najmniej ośmiu znaków, co najmniej jednej dużej litery, co najmniej jednej małej litery, co najmniej jednej cyfry od 0 do 9 i co najmniej jednego znaku specjalnego z:! @ # $% ^ I * _? ORAZ daj użytkownikowi nieco więcej informacji o tym, czego brakuje w haśle, możesz użyć następującego kodu:

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
}

Rozwiązanie znalazłem w jednej z poprzednich odpowiedzi jako:

* Minimum 8 znaków co najmniej 1 wielki alfabet, 1 mały alfabet, 1 liczba i 1 znak specjalny:

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

... nie działało dla mnie, ale poniższa wersja jest uproszczona i działa świetnie (dodaj dowolny znak specjalny, który ci się podoba, dodałem tutaj #) i dodaj regułę liczbową, tak jak robisz to z literami:

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