密码的正则表达式必须包含至少八个字符、至少一个数字以及小写和大写字母以及特殊字符

您可以将此正则表达式与多个前瞻断言（条件）一起使用：

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

此正则表达式将强制执行以下规则：

• 至少一个大写英文字母，(?=.*?[A-Z])
• 至少一个小写英文字母，(?=.*?[a-z])
• 至少一位数字，(?=.*?[0-9])
• 至少一个特殊字符，(?=.*?[#?!@$%^&*-])
• 最短长度为八（带锚）.{8,}

只是对 @anubhava 的回答进行了一个小的改进：由于特殊字符仅限于键盘中的字符，因此请将其用于任何特殊字符：

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

此正则表达式将强制执行以下规则：

• 至少一个大写英文字母
• 至少一个小写英文字母
• 至少一位数字
• 至少一个特殊字符
• 最少长度为 8 个

至少 8 个字符，至少一个字母和一个数字：

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

最少 8 个字符、至少 1 个字母、1 个数字和 1 个特殊字符：

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

至少 8 个字符、至少 1 个大写字母、1 个小写字母和 1 个数字：

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

最少 8 个字符、至少 1 个大写字母、1 个小写字母、1 个数字和 1 个特殊字符：

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

最少 8 个字符，最多 10 个字符，至少一个大写字母、一个小写字母、一个数字和一个特殊字符：

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

导入 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. 至少一个特殊字符

我很难按照我的情况找到最受欢迎的答案。例如，我的验证失败，并带有 或 等字符。我对将我的特殊字符列入白名单不感兴趣，所以我转而利用作为测试 - 简单地说 - 匹配非单词字符（包括数字）和非空格字符。总而言之，这是对我有用的东西......;[[^\w\s]

• 至少字符数8
• 至少为数字字符1
• 至少小写字母1
• 至少大写字母1
• 至少特殊字符1

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

JSFiddle Link - 涵盖各种案例的简单演示

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

正则表达式没有 AND 运算符，因此当有效性由 AND else 和 something else 定义时，很难编写与有效密码匹配的正则表达式......

但是，正则表达式确实有一个 OR 运算符，因此只需应用 DeMorgan 定理，并编写一个与无效密码匹配的正则表达式：

少于 8 个字符的任何内容，或没有数字的任何内容，没有大写字母 OR 的任何内容，没有小写字母的任何内容，或者没有特殊字符的任何内容。

所以：

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

如果有任何匹配项，则该密码无效。

根据您的需要，此模式应该可以正常工作。试试这个，

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

只需创建一个字符串变量，分配模式，然后创建一个布尔方法，如果模式正确，则返回 true，否则返回 false。

样本：

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

在 Java/Android 中，要测试至少一个数字、一个字母、一个特殊字符的密码，请采用以下模式：

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

试试这个：

1. 最少 6 个字符
2. 至少一个大写字符
3. 至少一个小写字符
4. 至少一个特殊字符

表达：

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

可选特殊字符：

1. 至少一个特殊字符
2. 至少一个数字
3. 特殊字符是可选的
4. 最少 6 个字符，最多 16 个字符

表达：

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

如果不需要最小值和最大值条件，则删除.{6, 16}

• 6 是最小字符限制
• 20 是最大字符限制
• ？= 表示匹配表达式

试试这个：

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

我在之前的答案之一中找到的解决方案是：

*最少 8 个字符，至少 1 个大写字母、1 个小写字母、1 个数字和 1 个特殊字符：

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

...对我不起作用，但以下是简化版本并且效果很好（添加您喜欢的任何特殊字符，我在这里添加了#），并添加数字规则，就像您对字母所做的那样：

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

使用以下正则表达式来满足以下条件：

条件：

1. 最少 1 个大写字母。
2. 最少 1 个小写字母。
3. 最少 1 个特殊字符。
4. 最少 1 个数字。
5. 最少 8 个字符。
6. 最多 30 个字符。

正则表达式：

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

没有直接回答这个问题，但它真的必须是一个正则表达式吗？

我曾经做过很多Perl，并且习惯于用正则表达式解决问题。然而，当它们因所有展望和其他怪癖而变得更加复杂时，你需要编写几十个单元测试来杀死所有这些小错误。

此外，正则表达式通常比命令式解决方案或功能解决方案慢几倍。

例如，以下（不是很FP）Scala 函数求解原始问题的速度比最流行的答案的正则表达式快三倍左右。它的作用也非常清楚，你根本不需要单元测试：

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
}

一个更“通用”的版本（？），不允许英文字母作为特殊字符。

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

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

匹配至少 1 个大写字符、1 个数字和任何特殊字符以及长度介于 8 到 63 之间的模式。

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

此模式用于 JAVA 编程。

使用以下正则表达式来满足以下条件：

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

正则表达式：^(?=.*\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})

希望以下内容有效。我在 Azure 自定义策略中尝试过这个。

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

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

在线链接检查 https://regex101.com/r/mqGurh/1

我在这里发现了很多问题，所以我自己做了。

在这里，它尽显荣耀，并进行了测试：

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

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

需要注意的事项：

1. 不使用，因为这包括我正在测试的 。\w_
2. 我在匹配符号时遇到了很多麻烦，而没有匹配行尾。
3. 没有专门指定符号，这也是因为不同的区域设置在其键盘上可能具有不同的符号，他们可能想要使用这些符号。

实际上，我只是在这里复制了第一个答案，并将其变成了一个更方便用户体验的正则表达式，它需要一个上、一个下和至少 8 个字符，但接受“介于两者之间”的所有内容。

这是一个示例正则表达式，它需要

1. 长度至少为 8 个字符
2. 至少一个小写字母
3. 至少一个大写字母

重要提示：此正则表达式还将排除所有其他字符，例如数字、特殊字符（如 $、#、！ 等） - 只要规则 1.至 3.匹配输入字符串

^(?=.*[a-z])(?=.*[A-Z]).{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">

用这个，

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

它将验证至少一个小写字母、一个大写字母、一个数字和 （！，@，#，$，%,?,=，*，&） 的特殊字符。

最小长度为 8，最大长度为 20

考虑以下正则表达式解决方案怎么样：

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

这验证了以下内容：

1. 至少一个小写字母
2. 至少一个大写字母
3. 至少一位数字
4. 至少一个特殊字符
5. 至少它应该有 8 个字符长。

在以下链接中查看它 https://regex101.com/r/qPmC06/4/

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

这对我有用：

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

• 长度至少为 8 个字符;
• 一个小写字母、一个大写字母、一个数字和一个特殊字符;
• 没有空格。

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

/^(?=.*[A-Z])(?=.*[a-z])(?=.*[0-9]).*$/

这是使用它的简单方法，同时验证至少 1 个大写字母、1 个小写字母和 1 个数字

这是我在快速验证中使用的示例

check('password')
    .notEmpty()
    .withMessage('Password cannot be null')
    .bail()
    .isLength({ min: 6 })
    .withMessage('Password must be at least 6 characters')
    .bail()
    .matches(/^(?=.*[A-Z])(?=.*[a-z])(?=.*[0-9]).*$/)
    .withMessage(
      'Must have atleast 1 uppercase, 1 lowercase letter and 1 number'
    ),

var strongRegex = new RegExp("^(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])(?=.*[!@#\$%\^&\*])(?=.{8,})");
var mediumRegex = new RegExp("^(((?=.*[a-z])(?=.*[A-Z]))|((?=.*[a-z])(?=.*[0-9]))|((?=.*[A-Z])(?=.*[0-9])))(?=.{6,})");

最适合 javascript

     var value=$("#password").val();
     $.validator.addMethod("strongePassword",function(value) 
     {
         return /^[A-Za-z0-9!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~]*$/.test(value) && /[a-z]/.test(value) && /\d/.test(value) && /[A-Z]/.test(value)&& /[A-Z]/.test(value);`enter code here`
     },'Password must have minimum 9 characters and contain at least 1 UPPERCASE, 1 lower case, 1 number, 1 special character.');

对于标准密码要求，我发现这很有用：

• 至少 1 个字母

• 至少 1 位数字

• 不包含空格

• 可选特殊字符，例如 @$！%*#？&^_-

• 最短长度为 8 个字符

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

您还可以设置上限，例如 {8,32}，长度不超过 32 个字符。

如果您不喜欢使用正则表达式。所以这个模块有很大帮助：https://www.npmjs.com/package/password-validator

var passwordValidator = require('password-validator');
 
// Create a schema
var schema = new passwordValidator();
 
// Add properties to it
schema
.is().min(8)                                    // Minimum length 8
.is().max(100)                                  // Maximum length 100
.has().uppercase()                              // Must have uppercase letters
.has().lowercase()                              // Must have lowercase letters
.has().digits(2)                                // Must have at least 2 digits
.has().not().spaces()                           // Should not have spaces
.is().not().oneOf(['Passw0rd', 'Password123']); // Blacklist these values
 
// Validate against a password string
console.log(schema.validate('validPASS123'));
// => true
console.log(schema.validate('invalidPASS'));
// => false

对于需要满足以下条件的更严格的验证：

1. 至少一个大写字符
2. 至少一个小写字符
3. 至少一位数字
4. 至少一个符号/特殊字符 @$！%*#？&^_-
5. 最少 8 个字符/数字

正则表达式：

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

我希望它能帮助那些更严格的人。

保持简单愚蠢：

这应该总是对你有用。

正则表达式：^(.{0,7}|[^a-z]{1,}|[^A-Z]{1,}|[^\d]{1,}|[^\W]{1,})$|[\s]

如果您的密码与上述正则表达式匹配，则该密码无效。

如果没有匹配项，则您的密码有效，并且包含至少 8 个字符、一个大写字母、一个小写字母和一个符号或特殊字符。而且它也不包含空格、制表符或换行符。

正则表达式的细分

1. .{0,7}- 如果密码包含 0 到 7 个字符，则匹配。
2. [^a-z]{1,}- 如果未找到小写字母，则匹配
3. [^A-Z]{1,}- 如果未找到大写字母，则匹配
4. [^\d]{1,}- 如果未找到数字（介于 [0-9]） 之间，则匹配
5. [\s]- 如果找到空格、制表符或换行符，则匹配。

使用这种方法，在允许的符号方面没有限制或限制。如果要限制为允许的符号很少，只需将 更改为 .[^\W][^YourSymbols]

另一种选择是使用否定字符类在前瞻断言中使用对比度，可以选择匹配任何字符，但在匹配应匹配的字符之前列出的字符除外。

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

观看正则表达式演示

在某种程度上，模式匹配：

• ^字符串的开头
• (?=[^A-Z\n]*[A-Z])积极展望，断言 0+ 倍除 A-Z 或换行符以外的任何字符。然后匹配字符 A-Z
• (?=[^a-z\n]*[a-z])char a-z 的相同方法
• (?=[^0-9\n]*[0-9])数字 0-9 采用相同的方法
• (?=[^#?!@$%^&*\n-]*[#?!@$%^&*-])对于您认为特殊的字符，采用相同的方法
• .{8,}匹配除换行符以外的任何字符 8 次或更多次
• $字符串末尾

笔记

• 点也可以与空格匹配。如果不想允许匹配空格，则可以更改为匹配 8 个或更多非空格字符.{8,}\S{8,}
• 使用 either 或 可以匹配比 lookahead 断言中指定的字符更多的字符。如果只想匹配断言中使用的字符，则可以使用字符类更改为仅匹配允许的字符.\S.{8,}[#?!@$%^&*A-Za-z0-9-]{8,}

const regex = /^(?=[^A-Z\n]*[A-Z])(?=[^a-z\n]*[a-z])(?=[^0-9\n]*[0-9])(?=[^#?!@$%^&*\n-]*[#?!@$%^&*-]).{8,}$/;
[
  "abcA1#!A",
  "#!asdfSFD1;",
  "# a f F1 ;",
  "1111111111",
  "aaaaaaaa",
  "11111111",
  "AAAAAAAA",
  "########",
  "aA1#"
].forEach(s =>
  console.log(regex.test(s) ? `Match --> ${s}` : `No match --> ${s}`)
);

使用此正则表达式，满足所有条件：

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

此正则表达式将强制执行以下规则：

• 至少一个大写字母，(?=.*?[A-Z])
• 至少一个小写字母，(?=.*?[a-z])
• 至少一位数字，(?=.*?[0-9])
• 至少一个特殊字符，即前 3 个条件中未包含的任何字符，(?=.*?[^A-Za-z0-9])
• 最少长度为 8 个.{8,}

"^(?=.*[0-9])(?=.*[a-z])(?=.*[A-Z])(?=.*[\\\\`~!@#$%^&/*()_+=[{}]\\[\\]|\\:;'\"<>.,?/-]).{8,}$";

✅ 以下 4 种正则表达式模式可以帮助您编写几乎任何密码验证

模式 1：

密码必须包含1-9个数字，一个小写字母，一个大写字母，一个特殊字符，不能有空格，长度必须为8-16个字符。

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

解释：

• (?=.*[0-9])表示密码必须包含 1 到 9 之间的一位数字。

• (?=.*[a-z])表示密码必须包含一个小写字母。

• (?=.*[A-Z])表示密码必须包含一个大写字母。

• (?=.*\W)表示密码必须包含一个特殊字符。

• .{8,16}表示密码长度必须为 8-16 个字符。我们必须在正则表达式的末尾，就在符号之前使用它。$

什么是 ^ 和 $：

^指示字符串的开头。 指示字符串的末尾。$

如果我们不使用这些 & ，正则表达式将无法确定密码的最大长度。在上面的示例中，我们有一个条件，即密码不能超过 16 个字符，为了使该条件起作用，我们使用了这些^$^ & $

删除最大长度限制：

• 而不是 ，如果我们使用 ，则意味着密码必须至少为 8 个字符长。因此，检查密码的最大长度没有任何条件。.{8,16}.{8,}

不接受任何数字（数字）：

• 而不是 ，如果我们使用 ，则意味着密码不得包含 1-9 之间的任何数字（与 的区别在于使用 而不是(?=.*[0-9])(?!.*[0-9])(?=.*[0-9])!=)

不接受任何特殊字符：

• 而不是 ，如果我们使用 ，则意味着密码不得包含任何特殊字符（与 的区别在于使用 而不是(?=.*\W)(?!.*\W)(?=.*\W)!=)

number（digit） 的替代语法：

• 代替 ，我们可以使用 . 还意味着密码必须包含 1 到 9 之间的一位数字。(?=.*[0-9])(?=.*\d)(?=.*\d)

模式 2：

密码必须包含 1 到 9 之间的一位数字、一个小写字母、一个大写字母、一个下划线但不能包含其他特殊字符、空格，长度必须为 8-16 个字符。

/^(?=.*[0-9])(?=.*[a-z])(?=.*[A-Z])(?=.*_)(?!.*\W)(?!.* ).{8,16}$/

与模式 1 的区别

• 在这里，我们使用了 .(?=.*_)Pattern 1

• (?=.*_)(?!.*\W)表示密码必须包含下划线，但不能包含任何其他特殊字符。

模式 3：

密码必须包含 1 到 9 之间的一位数字、一个小写字母、一个大写字母、一个下划线、无空格，长度必须为 8-16 个字符。除下划线外的任何其他特殊字符的使用是可选的。

/^(?=.*[0-9])(?=.*[a-z])(?=.*[A-Z])(?=.*_)(?!.* ).{8,16}$/

与模式 2 的区别

• 在这里，我们没有使用 .(?!.*\W)Pattern 2

• 但它仍然具有(?=.*_)

• 通过删除 ，特殊字符已成为可选字符。现在，一个下划线是必需的，但可以使用或不使用任何其他特殊字符，因为它是可选的。(?!.*\W)

模式 4：

密码必须包含1-9之间的一位数字，一个小写字母，一个大写字母和一个下划线，长度必须为8-16个字符。任何其他特殊字符的使用和空格的使用都是可选的。

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

与模式 3 的区别

• 在这里，我们没有使用&，这是在.(?=.*_)(?!.* )Pattern 3

• 通过删除 ，不再强制传递一个下划线。现在，传递特殊字符是可选的。(?=.*_)

• 通过删除 ，空间的使用也变得可选。(?!.* )

我会使用：

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

大多数答案都假设您使用他们预定义的特殊字符之一，但我会说，如果可以使用任何特殊字符，如果它不是 a-zA-Z0-9，那就更好了，所以你可以写成： ，但使用“Not Word”会更短： 这相当于： - 但当然，您希望下划线被视为特殊字符， 如此简单地添加它，然后你以：[^a-zA-Z0-9]\W[^a-zA-Z0-9_]_[\W_]

regex101 是一个非常好且有用的工具，用于构建您的个人正则表达式、修改或测试现有正则表达式： https://regex101.com

这对我有用：

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