Regex cho mật khẩu phải chứa ít nhất tám ký tự, ít nhất một số và cả chữ thường, chữ hoa và các ký tự đặc biệt

Tôi muốn một biểu thức chính quy để kiểm tra rằng:

Một mật khẩu có chứa ít nhất tám ký tự, trong đó có ít nhất một số và bao gồm cả chữ thường và chữ hoa và ký tự đặc biệt, ví dụ #, ?, !.

Nó không thể là mật khẩu cũ của bạn hoặc chứa tên người dùng của bạn "password", hoặc"websitename"

Và đây là biểu thức xác thực của tôi dành cho tám ký tự bao gồm một ký tự hoa, một ký tự viết thường và một số hoặc ký tự đặc biệt.

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

Làm thế nào tôi có thể viết nó cho mật khẩu phải có tám ký tự bao gồm một ký tự hoa, một ký tự đặc biệt và các ký tự chữ và số ?

Tối thiểu tám ký tự, ít nhất một chữ cái và một số:

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

Tối thiểu tám ký tự, ít nhất một chữ cái, một số và một ký tự đặc biệt:

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

Tối thiểu tám ký tự, ít nhất một ký tự viết hoa, một ký tự viết thường và một số:

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

Tối thiểu tám ký tự, ít nhất một ký tự hoa, một ký tự thường, một số và một ký tự đặc biệt:

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

Tối thiểu tám và tối đa 10 ký tự, ít nhất một ký tự hoa, một ký tự thường, một số và một ký tự đặc biệt:

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

Bạn có thể sử dụng regex này với nhiều xác nhận (điều kiện) trên trang đầu :

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

Regex này sẽ thực thi các quy tắc sau:

• Ít nhất một chữ cái viết hoa bằng tiếng Anh ,(?=.*?[A-Z])
• Ít nhất một chữ cái tiếng Anh viết thường, (?=.*?[a-z])
• Ít nhất một chữ số, (?=.*?[0-9])
• Ít nhất một ký tự đặc biệt, (?=.*?[#[email protected]$%^&*-])
• Chiều dài tối thiểu tám .{8,}(với các neo)

Biểu thức chính quy không có toán tử AND, do đó, khá khó để viết một regex khớp với mật khẩu hợp lệ, khi tính hợp lệ được xác định bởi thứ gì đó VÀ thứ khác VÀ thứ gì đó khác ...

Tuy nhiên, biểu thức chính quy có một toán tử OR, vì vậy chỉ cần áp dụng định lý DeMorgan và viết một regex khớp với mật khẩu không hợp lệ:

Bất kỳ thứ gì có ít hơn tám ký tự HOẶC bất kỳ thứ gì không có số HOẶC bất kỳ thứ gì không có chữ hoa HOẶC bất kỳ thứ gì không có chữ thường HOẶC bất kỳ thứ gì không có ký tự đặc biệt.

Vì thế:

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

Nếu bất kỳ điều gì khớp với điều đó, thì đó là mật khẩu không hợp lệ.

Chỉ là một cải tiến nhỏ cho câu trả lời của @ anubhava: Vì ký tự đặc biệt được giới hạn cho các ký tự trong bàn phím, hãy sử dụng ký tự này cho bất kỳ ký tự đặc biệt nào:

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

Regex này sẽ thực thi các quy tắc sau:

• Ít nhất một chữ cái viết hoa tiếng Anh
• Ít nhất một chữ cái tiếng Anh viết thường
• Ít nhất một chữ số
• Ít nhất một ký tự đặc biệt
• Chiều dài tối thiểu tám

Tôi gặp một số khó khăn khi theo dõi câu trả lời phổ biến nhất cho hoàn cảnh của mình. Ví dụ: xác thực của tôi không thành công với các ký tự như ;hoặc [. Tôi không quan tâm đến việc liệt kê trắng các ký tự đặc biệt của mình, vì vậy thay vào đó tôi tận dụng [^\w\s]như một phép thử - chỉ cần đặt - khớp các ký tự không phải từ (bao gồm cả số) và các ký tự không phải khoảng trắng. Tóm lại, đây là những gì đã làm việc cho tôi ...

• ít nhất 8ký tự
• ít nhất 1ký tự số
• ít nhất là 1chữ thường
• ít nhất là 1chữ hoa
• ít nhất là 1ký tự đặc biệt

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

JSFiddle Link - bản demo đơn giản bao gồm các trường hợp khác nhau

Một phiên bản "chung chung" hơn (?), Không cho phép ký tự tiếng Anh nào là ký tự đặc biệt .

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

Sử dụng Regex sau để thỏa mãn các điều kiện dưới đây:

Điều kiện:

1. Tối thiểu 1 chữ hoa.
2. Tối thiểu 1 chữ thường.
3. Tối thiểu 1 ký tự đặc biệt.
4. Tối thiểu 1 số.
5. Tối thiểu 8 ký tự.
6. Tối đa 30 ký tự.

Regex:

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

Nhập tệp JavaScript jquery.validate.min.js.

Bạn có thể sử dụng phương pháp này:

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

1. Ít nhất một chữ cái viết hoa tiếng Anh
2. Ít nhất một chữ cái tiếng Anh viết thường
3. Ít nhất một chữ số
4. Ít nhất một ký tự đặc biệt

Hãy thử cái này:

1. Tối thiểu sáu ký tự
2. Ít nhất một ký tự viết hoa
3. Ít nhất một ký tự viết thường
4. Ít nhất một ký tự đặc biệt

Biểu hiện:

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

Các ký tự đặc biệt tùy chọn:

1. Ít nhất một ký tự đặc biệt
2. Ít nhất một số
3. Các ký tự đặc biệt là tùy chọn
4. Tối thiểu sáu ký tự và tối đa 16 ký tự

Biểu hiện:

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

Nếu điều kiện tối thiểu và tối đa không được yêu cầu thì loại bỏ .{6, 16}

• 6 là giới hạn ký tự tối thiểu
• 20 là giới hạn ký tự tối đa
• ? = nghĩa là đối sánh biểu thức

Tôi sẽ trả lời Peter Mortensen, nhưng tôi không có đủ danh tiếng.

Biểu cảm của anh ấy là hoàn hảo cho từng yêu cầu tối thiểu được chỉ định. Vấn đề với các biểu thức không yêu cầu ký tự đặc biệt của anh ấy là chúng cũng KHÔNG CHO PHÉP các ký tự đặc biệt, vì vậy chúng cũng thực thi các yêu cầu tối đa, điều mà tôi không tin OP đã yêu cầu. Thông thường, bạn muốn cho phép người dùng của mình đặt mật khẩu mạnh như họ muốn; tại sao hạn chế mật khẩu mạnh?

Vì vậy, biểu thức "tối thiểu tám ký tự, ít nhất một chữ cái và một số":

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

đạt được yêu cầu tối thiểu, nhưng các ký tự còn lại chỉ có thể là chữ cái và số. Để cho phép (nhưng không yêu cầu) các ký tự đặc biệt, bạn nên sử dụng một số thứ như:

^(?=.*[A-Za-z])(?=.*\d).{8,}$ cho phép bất kỳ ký tự nào

hoặc là

^(?=.*[A-Za-z])(?=.*\d)[A-Za-z\d[email protected]$!%*#?&]{8,}$ để cho phép các ký tự đặc biệt cụ thể

Tương tự như vậy, "tối thiểu tám ký tự, ít nhất một ký tự hoa, một ký tự thường và một số:"

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

đáp ứng yêu cầu tối thiểu đó, nhưng chỉ cho phép các chữ cái và số. Sử dụng:

^(?=.*[a-z])(?=.*[A-Z])(?=.*\d).{8,}$ cho phép bất kỳ ký tự nào

hoặc là

^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)[A-Za-z\[email protected]$!%*?&]{8,} để cho phép các ký tự đặc biệt cụ thể.

Còn về việc xem xét giải pháp regex sau:

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

Điều nào xác thực những điều sau:

1. Ít nhất một chữ thường
2. Ít nhất một chữ hoa
3. Ít nhất một chữ số
4. Ít nhất một ký tự đặc biệt
5. Ít nhất nó phải có 8 ký tự.

Kiểm tra nó hoạt động tại liên kết sau https://regex101.com/r/qPmC06/4/

Không trực tiếp trả lời câu hỏi, nhưng nó có thực sự phải là một regex không?

Tôi đã từng làm rất nhiều Perl, và quen với việc giải quyết các vấn đề với regexes. Tuy nhiên, khi chúng trở nên phức tạp hơn với tất cả những cái nhìn về phía trước và những điều kỳ quặc khác, bạn cần phải viết hàng tá bài kiểm tra đơn vị để tiêu diệt tất cả những lỗi nhỏ đó.

Hơn nữa, regex thường chậm hơn một vài lần so với giải pháp bắt buộc hoặc chức năng.

Ví dụ, hàm Scala (không phải FP) sau đây giải câu hỏi ban đầu nhanh hơn khoảng ba lần so với regex của câu trả lời phổ biến nhất. Những gì nó làm cũng rõ ràng đến mức bạn không cần phải kiểm tra đơn vị nào cả:

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
}

Điều này đã làm việc cho tôi:

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

• Có ít nhất 8 kí tự;
• Một chữ thường, một chữ hoa, một số và một ký tự đặc biệt;
• Không có khoảng trắng.

^(?=.*[A-Z])(?=.*[a-z])(?=.*[0-9])(?=.*[[email protected]#$%^&*()_+,.\\\/;':"-]).{8,}$
    

Theo nhu cầu của bạn, mô hình này sẽ hoạt động tốt. Thử đi,

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

Chỉ cần tạo một biến chuỗi, gán mẫu và tạo một phương thức boolean, phương thức này sẽ trả về true nếu mẫu là đúng, còn lại là false.

Mẫu vật:

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

Tôi đã tìm thấy nhiều vấn đề ở đây, vì vậy tôi đã giải quyết vấn đề của riêng mình.

Đây là vinh quang, với các thử nghiệm:

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

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

Những điều cần chú ý:

1. không sử dụng \wvì điều đó bao gồm _, mà tôi đang thử nghiệm.
2. Tôi đã gặp rất nhiều khó khăn khi khớp các ký hiệu mà không khớp với cuối dòng.
3. Không chỉ định cụ thể các ký hiệu, điều này cũng là do các ngôn ngữ khác nhau có thể có các ký hiệu khác nhau trên bàn phím mà họ có thể muốn sử dụng.

Bản giới thiệu:

function password_check() {
  pass = document.getElementById("password").value;
  console.log(pass);
  regex = /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\[email protected]$!%*?&]{8,}$/;
  if (regex.exec(pass) == null) {
    alert('invalid password!')
  }
  else {
    console.log("valid");
  }
}

<input type="text" id="password" value="[email protected]">
<input type="button" id="submit" onclick="password_check()" value="submit">

Thử nghiệm cái này vào năm 2020:

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

Xác minh bản thân

const regex = /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\[email protected]$!%*?&]{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}`);
    });
}

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

@ClasG đã đề xuất :

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

nhưng nó không chấp nhận _ (gạch dưới) là một ký tự đặc biệt (ví dụ: Aa12345_).

Một cải tiến là:

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

Sử dụng Regex sau để thỏa mãn các điều kiện dưới đây:

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

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

Có thể kiểm tra trực tuyến: https://regex101.com

Chỉ cần chúng ta có thể làm điều này bằng cách sử dụng HTML5.

Sử dụng mã bên dưới trong thuộc tính mẫu,

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

Nó sẽ hoạt động hoàn hảo.

Bạn có thể sử dụng mẫu biểu thức chính quy dưới đây để kiểm tra xem mật khẩu có khớp với mong đợi của bạn hay không.

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

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

Liên kết kiểm tra trực tuyến https://regex101.com/r/mqGurh/1

Dùng cái này,

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

Nó sẽ xác thực cho ít nhất một chữ thường, một chữ hoa, một số và các ký tự đặc biệt của (!, @, #, $,%,?, =, *, &).

Chiều dài tối thiểu là 8 và chiều dài tối đa là 20

• Phải chứa ít nhất 1 số, 1 chữ hoa, 1 chữ thường và ít nhất 8 ký tự trở lên: https://www.w3schools.com/howto/howto_js_password_validation.asp

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

Trong Java / Android, để kiểm tra mật khẩu có ít nhất một số, một chữ cái, một ký tự đặc biệt theo mẫu sau:

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

Thử đi:

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

Biểu thức chính quy này phù hợp với tôi một cách hoàn hảo.

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

Tôi thực sự vừa sao chép câu trả lời đầu tiên ở đây và biến nó thành một regex tiện lợi hơn , cần một ký tự trên, một ký tự dưới và ít nhất 8 ký tự nhưng chấp nhận mọi thứ "ở giữa".

Đây là một ví dụ-regex yêu cầu

1. độ dài ít nhất 8 ký tự
2. ít nhất một chữ thường
3. ít nhất một chữ cái viết hoa

QUAN TRỌNG : Biểu thức này cũng sẽ ngoại trừ tất cả các ký tự khác, ví dụ như số, ký tự đặc biệt như $, # ,! vv - miễn là các quy tắc từ 1. đến 3. khớp với chuỗi đầu vào

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

Tâm trí "." alomst vào cuối thời kỳ regex. Điều này sẽ khớp với hầu hết mọi ký tự (và bất kỳ ký tự nào có thể đọc được)

Mẫu để khớp với ít nhất 1 ký tự hoa, 1 chữ số và bất kỳ ký tự đặc biệt nào và độ dài từ 8 đến 63.

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

Mẫu này được sử dụng cho lập trình JAVA.