Parola için normal ifade en az sekiz karakter, en az bir sayı ve hem küçük hem de büyük harfler ve özel karakterler içermelidir

Bunu kontrol etmek için düzenli bir ifade istiyorum:

Bir şifre en az bir numarası dahil en az sekiz karakter içerir ve alt ve büyük harf ve özel karakter içerir, örneğin #, ?, !.

Eski şifreniz olamaz veya kullanıcı adınızı içeremez "password", veya"websitename"

Ve burada bir büyük harf, bir küçük harf ve bir sayı veya özel karakter içeren sekiz karakterlik doğrulama ifadem.

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

Parola için bir büyük harf, bir özel karakter ve alfasayısal karakterler de dahil olmak üzere sekiz karakter olması için nasıl yazabilirim ?

En az sekiz karakter, en az bir harf ve bir sayı:

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

En az sekiz karakter, en az bir harf, bir sayı ve bir özel karakter:

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

En az sekiz karakter, en az bir büyük harf, bir küçük harf ve bir sayı:

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

En az sekiz karakter, en az bir büyük harf, bir küçük harf, bir sayı ve bir özel karakter:

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

En az sekiz ve en fazla 10 karakter, en az bir büyük harf, bir küçük harf, bir sayı ve bir özel karakter:

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

Bu normal ifadeyi birden fazla ileriye dönük iddiasıyla (koşullar) kullanabilirsiniz :

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

Bu normal ifade aşağıdaki kuralları uygulayacaktır:

• En az bir büyük harf İngilizce harf ,(?=.*?[A-Z])
• En az bir küçük İngilizce harf, (?=.*?[a-z])
• En az bir rakam, (?=.*?[0-9])
• En az bir özel karakter, (?=.*?[#?!@$%^&*-])
• Minimum sekiz uzunluk .{8,}(ankrajlarla)

Normal ifadelerde AND operatörü yoktur, bu nedenle geçerlilik bir şey VE başka bir şey VE başka bir şey tarafından tanımlandığında, geçerli parolalarla eşleşen bir normal ifade yazmak oldukça zordur ...

Ancak, normal ifadelerde OR operatörü vardır, bu nedenle DeMorgan teoremini uygulayın ve geçersiz parolalarla eşleşen bir normal ifade yazın:

Sekizden az karakterlerle şey VEYA numarası olmayan bir şey VEYA hiçbir büyük harf ile bir şey VEYA hiçbir küçük harf ile ya da bir şey VEYA hiçbir özel karakterler ile bir şey.

Yani:

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

Eşleşen bir şey varsa, bu geçersiz bir paroladır.

@ Anubhava'nın cevabı için küçük bir gelişme: Özel karakter klavyedeki karakterlerle sınırlı olduğundan, bunu herhangi bir özel karakter için kullanın:

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

Bu normal ifade aşağıdaki kuralları uygulayacaktır:

• En az bir büyük harf İngilizce harf
• En az bir küçük İngilizce harf
• En az bir basamak
• En az bir özel karakter
• Minimum sekiz uzunluk

Koşullarım için en popüler yanıtı takip etmekte zorlandım. Örneğin, doğrulamam ;veya gibi karakterlerle başarısız oluyordu [. Özel karakterlerimi beyaz listelemeye ilgi duymadım, bu yüzden [^\w\s]test yerine basitçe - kelime olmayan karakterleri (sayısal dahil) ve boşluk olmayan karakterleri eşleştirin. Özetlemek gerekirse, işte benim için işe yarayan ...

• en az 8karakter
• en azından 1sayısal karakter
• en azından 1küçük harf
• en azından 1büyük harf
• en azından 1özel karakter

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

JSFiddle Link - çeşitli vakaları kapsayan basit demo

Özel karakter olarak İngilizce harflerin kullanılmasına izin vermeyen daha "genel" bir sürüm (?) .

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

JavaScript dosyasını içe aktarın jquery.validate.min.js.

Bu yöntemi kullanabilirsiniz:

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

1. En az bir büyük harf İngilizce harf
2. En az bir küçük İngilizce harf
3. En az bir basamak
4. En az bir özel karakter

Bunu dene:

1. Minimum altı karakter
2. En az bir büyük harf karakter
3. En az bir küçük harf
4. En az bir özel karakter

İfade:

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

İsteğe Bağlı Özel Karakterler:

1. En az bir özel karakter
2. En az bir sayı
3. Özel karakterler isteğe bağlıdır
4. Minimum altı karakter ve maksimum 16 karakter

İfade:

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

Minimum ve maksimum koşulu gerekli değilse kaldırın .{6, 16}

• 6 minimum karakter sınırıdır
• 20 maksimum karakter sınırıdır
• ? = eşleşme ifadesi anlamına gelir

Soruyu doğrudan cevaplamak değil, ama gerçekten bir regex olmalı mı?

Eskiden çok fazla Perl yapıyordum ve regexes ile problemleri çözmeye alıştım. Ancak, tüm görünümlerle ve diğer tuhaflıklarla daha karmaşık hale geldiklerinde, tüm bu küçük böcekleri öldürmek için düzinelerce birim testi yazmanız gerekir.

Dahası, bir normal ifade tipik olarak bir zorunluluk veya işlevsel bir çözümden birkaç kat daha yavaştır.

Örneğin, aşağıdaki (çok FP değil) Scala fonksiyonu, orijinal soruyu en popüler cevabın regex'inden üç kat daha hızlı çözer. Yaptığı şey o kadar açık ki, bir birim testine hiç ihtiyacınız yok:

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
}

Peter Mortensen'e cevap verirdim, ama yeterince itibarım yok.

İfadeleri, belirtilen minimum gereksinimlerin her biri için mükemmeldir. Özel karakter gerektirmeyen ifadeleriyle ilgili sorun, özel karakterleri İZİN VERMEMEKTEDİR, bu nedenle OP'nin talep ettiğine inanmadığım maksimum gereksinimleri de zorlarlar. Normalde kullanıcılarınızın şifrelerini istedikleri kadar güçlü yapmalarına izin vermek istersiniz; neden güçlü parolalar kısıtlanmalı?

Yani, "en az sekiz karakter, en az bir harf ve bir sayı" ifadesi:

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

minimum gereksinimi karşılar, ancak kalan karakterler yalnızca harf ve rakam olabilir. Özel karakterlere izin vermek (ancak zorunlu değil) için aşağıdakine benzer bir şey kullanmalısınız:

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

veya

^(?=.*[A-Za-z])(?=.*\d)[A-Za-z\d$@$!%*#?&]{8,}$ belirli özel karakterlere izin vermek için

Benzer şekilde, "en az sekiz karakter, en az bir büyük harf, bir küçük harf ve bir sayı:"

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

bu minimum gereksinimi karşılar, ancak yalnızca harf ve sayılara izin verir. kullanın:

^(?=.*[a-z])(?=.*[A-Z])(?=.*\d).{8,}$ herhangi bir karaktere izin vermek

veya

^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)[A-Za-z\d$@$!%*?&]{8,} belirli özel karakterlere izin vermek için.

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

Aşağıdaki regex çözümünü düşünmeye ne dersiniz:

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

Bu aşağıdakileri doğrular:

1. En az bir küçük harf
2. En az bir büyük harf
3. En az bir basamak
4. En az bir özel karakter
5. En az 8 karakter uzunluğunda olmalı.

Aşağıdaki bağlantıda çalışıp çalışmadığına bakın https://regex101.com/r/qPmC06/4/

İhtiyacınıza göre bu desen gayet iyi çalışmalıdır. Bunu dene,

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

Sadece bir dize değişkeni oluşturun, deseni atayın ve desen doğruysa true döndüren, aksi takdirde false olan bir boolean yöntemi oluşturun.

Örneklem:

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

Burada birçok sorun buldum, bu yüzden kendiminkini yaptım.

İşte testlerle tüm ihtişamıyla:

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

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

Dikkat edilmesi gerekenler:

1. kullanmıyor \wçünkü_ test ediyorum.
2. Çizginin sonuna uymadan sembollerle eşleşen birçok sorun yaşadım.
3. Sembolleri özel olarak belirtmez, bunun nedeni farklı yerel ayarların klavyelerinde kullanmak isteyebilecekleri farklı simgeler olabilmesidir.

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

@ClasG zaten önerdi :

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

ancak _ (alt çizgi) özel bir karakter (örn. Aa12345_) olarak kabul edilmez.

Geliştirilmiş olan:

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

Bunu 2020'de test etmek:

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

Kendinizi doğrulayın

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

Aşağıdaki koşulları yerine getirmek için aşağıdaki Regex'i kullanın:

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

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

Çevrimiçi Test Edebilir: https://regex101.com

HTML5 kullanarak bunu yapabiliriz.

Desen özelliğinde aşağıdaki kodu kullanın,

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

Mükemmel çalışır.

Parolanızın beklentilerinize uygun olup olmadığını kontrol etmek için aşağıdaki normal ifade modelini kullanabilirsiniz.

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

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

Bağlantı kontrolü çevrimiçi https://regex101.com/r/mqGurh/1

Bunu kullan,

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

En az bir küçük harf, bir büyük harf, bir sayı ve (!, @, #, $,%,?, =, *, &) Özel karakterlerini doğrular.

Minimum uzunluk 8 ve maksimum uzunluk 20

Java / Android'de, en az bir sayı, bir harf ve bir özel karakter içeren bir parolayı aşağıdaki düzende test etmek için:

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

Bunu dene:

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

Bu düzenli ifade benim için mükemmel çalışıyor.

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

En az 1 büyük harf, 1 hane ve herhangi bir özel karakter ile 8 ila 63 arasındaki uzunluklara uyacak şekilde desen.

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

Bu model JAVA programlama için kullanıldı.

Umarım aşağıdaki işler. Bunu Azure özel politikasında denedim.

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

Aslında burada ilk cevabı kopyaladım ve daha ux-uygun bir regex'e çevirdim bir üst, bir alt ve en az 8 karakter gerektiren ama aradaki her şeyi kabul .

Bu bir örnek regex gerektiren

1. en az 8 karakter uzunluğunda
2. En az bir küçük harf
3. en az bir büyük harf

ÖNEMLİ : Bu normal ifade ayrıca sayılar, $, # ,! vb. - 1. ila 3. kurallar girdi dizesiyle eşleştiği sürece

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

"." regex sonunda alomst. Bu hemen hemen her (ve okunabilir herhangi bir karakter) ile eşleşecektir

En az sekiz karakter, en az bir büyük harf, en az bir küçük harf, 0 ile 9 arasında en az bir sayı ve aşağıdakilerden en az bir özel karakter olup olmadığını kontrol etmek için normal ifadeler kullanmak isterseniz:! @ # $% ^ & * _? VE ayrıca kullanıcıya parolada eksik oldukları hakkında biraz daha bilgi verir, aşağıdaki kodu kullanabilirsiniz:

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
}

Önceki cevaplardan birinde şu şekilde bulduğum bir çözüm:

* En az 8 karakter en az 1 Büyük Harf, 1 Küçük Harf, 1 Sayı ve 1 Özel Karakter:

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

... benim için çalışmadı, ancak aşağıdaki basitleştirilmiş bir sürüm ve harika çalışıyor (istediğiniz herhangi bir özel karakteri ekleyin, buraya # ekledim) ve sayı kuralını harflerle yaptığınız gibi ekleyin:

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