Regex สำหรับรหัสผ่านจะต้องมีอย่างน้อยแปดตัวอักษรอย่างน้อยหนึ่งหมายเลขและทั้งตัวอักษรตัวเล็กและตัวพิมพ์ใหญ่และตัวอักษรพิเศษ

ฉันต้องการแสดงออกปกติเพื่อตรวจสอบว่า:

รหัสผ่านที่มีอย่างน้อยแปดตัวอักษรรวมทั้งจำนวนอย่างน้อยหนึ่งและรวมทั้งตัวอักษรที่ต่ำกว่าและตัวพิมพ์ใหญ่และตัวอักษรพิเศษเช่น#, ,?!

ไม่สามารถเป็นรหัสผ่านเก่าของคุณหรือมีชื่อผู้ใช้"password"หรือ"websitename"

และนี่คือนิพจน์การตรวจสอบความถูกต้องของฉันซึ่งมีความยาวแปดตัวอักษรรวมถึงตัวอักษรตัวพิมพ์ใหญ่หนึ่งตัวอักษรตัวพิมพ์เล็กหนึ่งตัวและตัวเลขหนึ่งตัวหรืออักขระพิเศษ

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

ฉันจะเขียนให้รหัสผ่านต้องมีแปดตัวอักษรรวมถึงอักษรตัวพิมพ์ใหญ่หนึ่งหนึ่งอักขระพิเศษและตัวเลขและตัวอักษร ?

อย่างน้อยแปดตัวอักษรอย่างน้อยหนึ่งตัวอักษรและหมายเลขหนึ่ง:

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

อย่างน้อยแปดตัวอักษรอย่างน้อยหนึ่งตัวอักษรหนึ่งหมายเลขและหนึ่งตัวละครพิเศษ:

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

อย่างน้อยแปดตัวอักษรอย่างน้อยหนึ่งตัวอักษรตัวพิมพ์ใหญ่หนึ่งตัวอักษรตัวเล็กและหนึ่งหมายเลข:

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

อย่างน้อยแปดตัวอักษรอย่างน้อยหนึ่งตัวอักษรตัวพิมพ์ใหญ่หนึ่งตัวอักษรตัวพิมพ์เล็กหนึ่งหมายเลขและหนึ่งอักขระพิเศษ:

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

อย่างน้อยแปดและสูงสุด 10 ตัวอักษรอย่างน้อยหนึ่งตัวอักษรตัวพิมพ์ใหญ่หนึ่งตัวอักษรตัวพิมพ์เล็กหนึ่งตัวจำนวนหนึ่งและอักขระพิเศษหนึ่งตัว:

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

คุณสามารถใช้ regex นี้กับการยืนยันหลายlookahead (เงื่อนไข) :

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

regex นี้จะบังคับใช้กฎเหล่านี้:

• อย่างน้อยหนึ่งตัวอักษรภาษาอังกฤษตัวพิมพ์ใหญ่(?=.*?[A-Z])
• ตัวอักษรภาษาอังกฤษตัวพิมพ์เล็กอย่างน้อยหนึ่งตัว (?=.*?[a-z])
• อย่างน้อยหนึ่งหลัก (?=.*?[0-9])
• อักขระพิเศษอย่างน้อยหนึ่งตัว (?=.*?[#?!@$%^&*-])
• ความยาวอย่างน้อยแปด.{8,}(พร้อมจุดยึด)

นิพจน์ทั่วไปไม่มีตัวดำเนินการ AND ดังนั้นจึงค่อนข้างยากที่จะเขียน regex ที่ตรงกับรหัสผ่านที่ถูกต้องเมื่อมีการกำหนดความถูกต้องโดยบางสิ่งและอย่างอื่นและอย่างอื่น ...

แต่นิพจน์ทั่วไปมีตัวดำเนินการ OR ดังนั้นเพียงใช้ทฤษฎีบทของ DeMorgan และเขียน regex ที่ตรงกับรหัสผ่านที่ไม่ถูกต้อง:

สิ่งใดที่มีน้อยกว่าแปดตัวอักษรหรืออะไรกับไม่มีตัวเลขหรืออะไรที่ไม่มีตัวพิมพ์ใหญ่หรือหรือสิ่งที่ไม่มีตัวพิมพ์เล็กหรืออะไรที่ไม่มีอักขระพิเศษ

ดังนั้น:

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

หากมีสิ่งใดตรงกับนั้นแสดงว่าเป็นรหัสผ่านที่ไม่ถูกต้อง

การปรับปรุงเพียงเล็กน้อยสำหรับคำตอบของ @ anubhava: เนื่องจากอักขระพิเศษถูก จำกัด เฉพาะอักขระในแป้นพิมพ์ใช้สำหรับอักขระพิเศษใด ๆ :

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

regex นี้จะบังคับใช้กฎเหล่านี้:

• อย่างน้อยหนึ่งตัวอักษรภาษาอังกฤษตัวพิมพ์ใหญ่
• ตัวอักษรภาษาอังกฤษตัวพิมพ์เล็กอย่างน้อยหนึ่งตัว
• อย่างน้อยหนึ่งหลัก
• อักขระพิเศษอย่างน้อยหนึ่งตัว
• ความยาวอย่างน้อยแปดขั้น

ฉันมีปัญหาในการปฏิบัติตามคำตอบที่ได้รับความนิยมสูงสุดสำหรับสถานการณ์ของฉัน ยกตัวอย่างเช่นการตรวจสอบของฉันถูกล้มเหลวกับตัวละครเช่นหรือ; [ฉันไม่ได้สนใจรายชื่อตัวละครพิเศษของฉันดังนั้นฉันจึงใช้ประโยชน์จาก[^\w\s]การทดสอบ - ใส่ - จับคู่อักขระที่ไม่ใช่คำ (รวมถึงตัวเลข) และอักขระเว้นวรรคสีขาว เพื่อสรุปนี่คือสิ่งที่ได้ผลสำหรับฉัน ...

• อย่างน้อย8ตัวอักษร
• อย่างน้อย1อักขระที่เป็นตัวเลข
• อย่างน้อย1ตัวอักษรพิมพ์เล็ก
• อย่างน้อย 1ตัวอักษรตัวพิมพ์ใหญ่
• อย่างน้อย 1อักขระพิเศษ

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

ลิงก์ JSFiddle - ตัวอย่างง่ายๆครอบคลุมกรณีต่างๆ

มากกว่า "ทั่วไป" รุ่น (?) ที่ช่วยให้ตัวอักษรภาษาอังกฤษไม่มีใครเป็นตัวอักษรพิเศษ

^(?=\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 jquery.validate.min.jsนำเข้าไฟล์

คุณสามารถใช้วิธีนี้:

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

1. อย่างน้อยหนึ่งตัวอักษรภาษาอังกฤษตัวพิมพ์ใหญ่
2. ตัวอักษรภาษาอังกฤษตัวพิมพ์เล็กอย่างน้อยหนึ่งตัว
3. อย่างน้อยหนึ่งหลัก
4. อักขระพิเศษอย่างน้อยหนึ่งตัว

ลองอันนี้:

1. อย่างน้อยหกตัวอักษร
2. อย่างน้อยหนึ่งตัวอักษรตัวพิมพ์ใหญ่
3. อักขระตัวพิมพ์เล็กอย่างน้อยหนึ่งตัว
4. อักขระพิเศษอย่างน้อยหนึ่งตัว

นิพจน์:

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

อักขระพิเศษเพิ่มเติม:

1. อักขระพิเศษอย่างน้อยหนึ่งตัว
2. อย่างน้อยหนึ่งหมายเลข
3. อักขระพิเศษเป็นทางเลือก
4. อย่างน้อยหกตัวอักษรและสูงสุด 16 ตัวอักษร

นิพจน์:

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

หากไม่ต้องการเงื่อนไขขั้นต่ำและสูงสุดให้ลบออก .{6, 16}

• 6คือจำนวนอักขระขั้นต่ำ
• 20จำกัด จำนวนอักขระสูงสุด
• ? =หมายถึงการจับคู่การแสดงออก

ไม่ตอบคำถามโดยตรง แต่ต้องเป็น regex หรือไม่

ฉันเคยทำ Perl จำนวนมากและคุ้นเคยกับการแก้ปัญหาด้วย regexes อย่างไรก็ตามเมื่อพวกเขามีความซับซ้อนมากขึ้นด้วยลุคที่ดูดีและนิสัยใจคออื่น ๆ คุณต้องเขียนบททดสอบหลายหน่วยเพื่อฆ่าแมลงตัวเล็ก ๆ เหล่านั้นทั้งหมด

นอกจากนี้ regex มักจะช้ากว่าโซลูชั่นที่จำเป็นหรือฟังก์ชั่น

ตัวอย่างเช่นฟังก์ชั่น Scala (ไม่มาก FP) ต่อไปนี้จะแก้คำถามเดิมได้เร็วกว่า regex ของคำตอบที่ได้รับความนิยมสูงสุดสามเท่า สิ่งที่ชัดเจนคือคุณไม่จำเป็นต้องทำการทดสอบหน่วยเลย:

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 แต่ฉันไม่มีชื่อเสียงเพียงพอ

การแสดงออกของเขาสมบูรณ์แบบสำหรับข้อกำหนดขั้นต่ำที่ระบุแต่ละข้อ ปัญหาเกี่ยวกับการแสดงออกของเขาที่ไม่ต้องใช้อักขระพิเศษคือพวกเขาไม่อนุญาตให้ใช้อักขระพิเศษดังนั้นพวกเขาจึงบังคับใช้ข้อกำหนดสูงสุดซึ่งฉันไม่เชื่อว่า OP ร้องขอ โดยปกติคุณต้องการอนุญาตให้ผู้ใช้ของคุณทำรหัสผ่านของพวกเขาที่แข็งแกร่งตามที่พวกเขาต้องการ; เหตุใดจึงต้อง จำกัด รหัสผ่านที่รัดกุม

ดังนั้นการแสดงออกของเขา "ขั้นต่ำแปดตัวอักษรอย่างน้อยหนึ่งตัวและหนึ่งหมายเลข":

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

ประสบความสำเร็จในความต้องการขั้นต่ำ แต่ตัวอักษรที่เหลือสามารถเพียงเป็นตัวอักษรและตัวเลข หากต้องการอนุญาตให้ใช้อักขระพิเศษ (แต่ไม่จำเป็น) คุณควรใช้สิ่งต่อไปนี้:

^(?=.*[A-Za-z])(?=.*\d).{8,}$ เพื่ออนุญาตให้ใช้อักขระใด ๆ

หรือ

^(?=.*[A-Za-z])(?=.*\d)[A-Za-z\d$@$!%*#?&]{8,}$ เพื่ออนุญาตให้ใช้อักขระพิเศษเฉพาะ

ในทำนองเดียวกัน "อย่างน้อยแปดตัวอักษรอย่างน้อยหนึ่งตัวอักษรตัวพิมพ์ใหญ่ตัวอักษรตัวพิมพ์เล็กหนึ่งตัวและหมายเลขหนึ่ง:"

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

ตรงตามข้อกำหนดขั้นต่ำ แต่อนุญาตเฉพาะตัวอักษรและตัวเลข ใช้:

^(?=.*[a-z])(?=.*[A-Z])(?=.*\d).{8,}$ เพื่ออนุญาตให้ใช้อักขระใด ๆ

หรือ

^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)[A-Za-z\d$@$!%*?&]{8,} เพื่ออนุญาตให้ใช้อักขระพิเศษเฉพาะ

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

สิ่งที่เกี่ยวกับการพิจารณาโซลูชัน regex ต่อไปนี้:

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

ซึ่งตรวจสอบสิ่งต่อไปนี้:

1. อย่างน้อยหนึ่งตัวพิมพ์เล็ก
2. อย่างน้อยหนึ่งตัวพิมพ์ใหญ่
3. อย่างน้อยหนึ่งหลัก
4. อักขระพิเศษอย่างน้อยหนึ่งตัว
5. อย่างน้อยควรมีความยาว 8 ตัวอักษร

ลองใช้งานได้ที่ลิงค์ต่อไปนี้https://regex101.com/r/qPmC06/4/

ตามความต้องการของคุณรูปแบบนี้ควรใช้งานได้ดี ลองนี้

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

เพียงสร้างตัวแปรสตริงกำหนดรูปแบบและสร้างเมธอดบูลีนที่คืนค่าจริงหากรูปแบบนั้นถูกต้องมิฉะนั้นจะเป็นเท็จ

ตัวอย่าง:

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

ฉันพบปัญหามากมายที่นี่ดังนั้นฉันจึงสร้างของตัวเอง

ที่นี่มันอยู่ในทุกสิ่งมันรุ่งโรจน์ด้วยการทดสอบ:

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

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

สิ่งที่ต้องระวัง:

1. ไม่ได้ใช้\wเพราะรวมถึง_สิ่งที่ฉันกำลังทดสอบ
2. ฉันมีปัญหามากมายในการจับคู่สัญลักษณ์โดยไม่จับคู่จุดสิ้นสุดของบรรทัด
3. ไม่ได้ระบุสัญลักษณ์โดยเฉพาะนี่เป็นเพราะสถานที่ต่างกันอาจมีสัญลักษณ์ที่แตกต่างกันบนคีย์บอร์ดที่อาจต้องการใช้

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

@ClasG ได้แนะนำแล้ว:

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

แต่ไม่ยอมรับ _ (ขีดล่าง) เป็นอักขระพิเศษ (เช่น Aa12345_)

การปรับปรุงคือ:

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

การสาธิต:

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

ทดสอบอันนี้ในปี 2020:

^(?=.*[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}`);
    });
}

ใช้ Regex ต่อไปนี้เพื่อปฏิบัติตามเงื่อนไขด้านล่าง:

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

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

สามารถทดสอบออนไลน์: https://regex101.com

เพียงแค่เราสามารถทำได้โดยใช้ HTML5

ใช้รหัสด้านล่างในแอตทริบิวต์รูปแบบ

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

ตรวจสอบลิงค์ออนไลน์https://regex101.com/r/mqGurh/1

ใช้สิ่งนี้

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

มันจะตรวจสอบอย่างน้อยหนึ่งตัวพิมพ์เล็กตัวพิมพ์ใหญ่หนึ่งตัวหมายเลขหนึ่งและตัวตรวจสอบพิเศษของ (!, @, #, $,%,?, =, *, &)

ความยาวต่ำสุดคือ 8 และความยาวสูงสุดคือ 20

ใน Java / Android เพื่อทดสอบรหัสผ่านด้วยตัวเลขอย่างน้อยหนึ่งตัวอักษรหนึ่งตัวอักขระพิเศษหนึ่งตัวในรูปแบบต่อไปนี้:

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

ลองสิ่งนี้:

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

การแสดงออกปกตินี้เหมาะกับฉันอย่างสมบูรณ์

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

รูปแบบเพื่อให้ตรงกับอักขระตัวพิมพ์ใหญ่อย่างน้อย 1 ตัวตัวเลข 1 ตัวและอักขระพิเศษใด ๆ และความยาวระหว่าง 8 ถึง 63

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

รูปแบบนี้ใช้สำหรับการเขียนโปรแกรม JAVA

หวังว่างานด้านล่าง ฉันลองสิ่งนี้ในนโยบายที่กำหนดเองของ Azure

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

ฉันเพิ่งคัดลอกคำตอบแรกที่นี่และเปลี่ยนเป็นregex สะดวกยิ่งขึ้นซึ่งต้องการหนึ่งบนล่างหนึ่งและอย่างน้อย 8 ตัวอักษร แต่ยอมรับทุกอย่าง "ในระหว่าง"

อันนี้คือ example-regex ที่ต้องการ

1. ความยาวอย่างน้อย 8 ตัวอักษร
2. อย่างน้อยหนึ่งตัวอักษรพิมพ์เล็ก
3. อย่างน้อยหนึ่งตัวอักษรตัวพิมพ์ใหญ่

สำคัญ : regex นี้จะยกเว้นตัวละครอื่น ๆ เช่นตัวเลขตัวอักษรพิเศษเช่น $, #,! ฯลฯ - ตราบใดที่กฎ 1 ถึง 3 ตรงกับสตริงอินพุต

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

ระวัง "." มากที่สุดในตอนท้ายของ regex สิ่งนี้จะจับคู่กับอักขระเกือบทุกตัว (และ afaik ที่อ่านได้)

หากคุณต้องการใช้นิพจน์ทั่วไปเพื่อตรวจสอบอักขระอย่างน้อยแปดตัวอักษรอย่างน้อยหนึ่งตัวอักษรตัวพิมพ์ใหญ่อย่างน้อยหนึ่งตัวอักษรตัวเล็กอย่างน้อยหนึ่งตัวจาก 0 ถึง 9 และอย่างน้อยหนึ่งตัวอักษรพิเศษจาก:! @ # $% ^ & * _? และให้ข้อมูลเพิ่มเติมแก่ผู้ใช้อีกเล็กน้อยเกี่ยวกับสิ่งที่พวกเขาหายไปในรหัสผ่านคุณสามารถใช้รหัสต่อไปนี้:

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
}

วิธีการแก้ปัญหาที่ฉันพบในหนึ่งในคำตอบก่อนหน้านี้เป็น:

* อย่างน้อย 8 ตัวอักษรอย่างน้อย 1 ตัวอักษรตัวพิมพ์ใหญ่ 1 ตัวอักษรตัวพิมพ์เล็ก 1 หมายเลขและ 1 อักขระพิเศษ:

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

... ไม่ได้ผลสำหรับฉัน แต่ต่อไปนี้เป็นเวอร์ชันที่เรียบง่ายและใช้งานได้ดี (เพิ่มอักขระพิเศษที่คุณชอบฉันเพิ่ม # ที่นี่) และเพิ่มกฎตัวเลขตามที่คุณทำด้วยตัวอักษรดังนี้

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