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

Regex for password must contain at least eight characters, at least one number and both lower and uppercase letters and special characters

本文关键字：特殊字符数字一个大写字母八个正则表达式包含字符密码更新时间：2023-09-26

我想要一个正则表达式来检查：

密码至少包含八个字符，包括至少一个数字，并且包括小写和大写字母以及特殊字符，例如 # 、 ? 、 ! 。

它不能是您的旧密码或包含您的用户名、"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,}$"

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

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

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

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

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

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

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

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

任何少于八个字符的东西或任何没有数字的东西，或任何没有大写字母或没有小写的东西或任何没有特殊字符的东西。

所以：

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

如果有任何匹配，则它是无效密码。

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

条件：

最少 1 个大写字母。
最少 1 个小写字母。
最少 1 个特殊字符。
最少 1 个数字。
最少 8 个字符。
最多 30 个字符。

正则表达式：

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

只是

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

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

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

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

我很难

遵循最适合我情况的答案。例如，我的验证失败了，例如 ; 或 [ 。我对将特殊字符列入白名单不感兴趣，所以我利用[^'w's]作为测试 - 简单地说 - 匹配非单词字符（包括数字）和非空格字符。总而言之，这是对我有用的东西...

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

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

JSFiddle Link - 涵盖各种情况的简单演示

✅ 以下 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,16} ，如果我们使用 .{8,} ，这意味着密码长度必须至少为 8 个字符。因此，检查密码的最大长度没有任何条件。

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

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

不要接受任何特殊字符：

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

数字

（数字）的替代语法：

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

模式 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上的(?=.*_)和(?!.* )。

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

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

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

^(?='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 个字母
至少 1 位数字
不包含空格
可选特殊字符，例如 @$！%*#？&^_-
长度至少为 8 个字符

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

您还可以将上限设置为 {8,32}，最多 32 个字符。

试试这个：

最少六个字符
至少一个大写字符
至少一个小写字符
至少一个特殊字符

表达：

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

可选特殊字符：

至少一个特殊字符
至少一个数字
特殊字符是可选的
最少 6 个字符，最多 16 个字符

表达：

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

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

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

这对

我有用：

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

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

不直接回答问题，但它真的必须是正则表达式吗？

我曾经做过很多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
}

<</div> div class="answers">

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

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

这将验证以下内容：

至少一个小写字母
至少一个大写字母
至少一位数字
至少一个特殊字符
至少它应该有 8 个字符长。

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

对于需要以下内容的更严格的验证：

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

正则表达式：

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

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

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

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

^(?=[^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]) 字符 a-z 的相同方法
(?=[^0-9'n]*[0-9]) 数字 0-9 的方法相同
(?=[^#?!@$%^&*'n-]*[#?!@$%^&*-]) 对于您认为特殊的字符的相同方法
.{8,} 匹配除换行符以外的任何字符 8 次或更多次
$ 字符串结尾

笔记

点也可以匹配空格。如果不想允许匹配空格，则可以将.{8,}更改为'S{8,}以匹配 8 个或更多非空格字符
使用 . 或 '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]).*$/

这是使用它的简单方法，同时验证至少 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'
    ),

在 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,7}|[^a-z]{1,}|[^A-Z]{1,}|[^'d]{1,}|[^'W]{1,})$|['s]

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

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

正则表达式的细分

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

使用这种方法，在允许的符号方面没有限制或限制。如果要限制为允许的几个符号，只需使用 [^YourSymbols] 更改[^'W]即可。

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

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

这是它的所有荣耀，带有测试：

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

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

需要注意的事项：

不使用'w，因为其中包括我正在测试的_。
我在匹配符号时遇到了很多麻烦，而不匹配行尾。
没有具体指定符号，这也是因为不同的区域设置的键盘上可能有不同的符号，他们可能想要使用。

演示：

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

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

我会使用：

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

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

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

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

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

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

如果你不喜欢使用正则表达式。所以这个模块很有帮助：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

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

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

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

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

这是对我有用的：

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