正则表达式检查密码是否为“”；8个字符，包括1个大写字母、1个特殊字符、字母数字字符“；

您所追求的正则表达式很可能是巨大的，维护起来是一场噩梦，尤其是对于不太熟悉正则表达式的人来说。

我认为分解正则表达式并一次只做一点会更容易。这可能需要做更多的工作，但我确信维护和调试它会更容易。这也将允许您向用户（而不仅仅是Invalid Password）提供更多定向错误消息，这将改善用户体验。

据我所见，您的正则表达式非常流利，所以我认为给您提供正则表达式来做您需要的事情是徒劳的。

看到你的评论，我会这样做：

• 长度必须为八个字符：您不需要正则表达式。使用.Length属性就足够了。

• 包含一个大写字母：可以使用[A-Z]+正则表达式。如果字符串至少包含一个大写字母，则此正则表达式将生成true。

• 一个特殊字符：您可以使用'W来匹配任何不是字母或数字的字符，也可以使用类似的[!@#]来指定特殊字符的自定义列表。请注意，$、^、(和)等字符在正则表达式语言中是特殊字符，因此需要像这样转义：'$。简而言之，您可以使用'W。

• 字母数字字符：使用'w+应匹配任何字母、数字和下划线。

有关更多信息，请参阅本教程。

(                   # Start of group
    (?=.*'d)        #   must contain at least one digit
    (?=.*[A-Z])     #   must contain at least one uppercase character
    (?=.*'W)        #   must contain at least one special symbol
       .            #     match anything with previous condition checking
         {8,8}      #        length is exactly 8 characters
)                   # End of group

一行：

((?=.*'d)(?=.*[A-Z])(?=.*'W).{8,8})

编辑2019-05-28：

您需要匹配整个输入字符串。因此，您可以将正则表达式包含在^和$之间，以防止意外地将部分匹配假定为匹配的整个输入：

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

来源：

• 密码匹配表达式

• 使用正则表达式进行密码强度验证

答案太多了。。。。一切都糟透了！

正则表达式没有AND运算符，所以当有效性由AND和其他东西定义时，很难编写与有效密码匹配的正则表达式。。。

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

少于8个字符的任何东西或没有数字的任何东西或没有大写字母的任何东西或[/strong>没有特殊字符的任何东西

因此：

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

如果有任何匹配项，那么它就是一个无效的密码。

答案是不使用正则表达式。这是设置和计数。

正则表达式是关于顺序的。

在你作为程序员的生活中，你会被要求做很多没有意义的事情。学会更深入地挖掘。当问题出错时学习。

这个问题（如果它提到正则表达式）是错的。

伪代码（最近在太多语言之间切换）：

if s.length < 8:
    return False
nUpper = nLower = nAlphanum = nSpecial = 0
for c in s:
    if isUpper(c):
        nUpper++
    if isLower(c):
        nLower++
    if isAlphanumeric(c):
        nAlphanum++
    if isSpecial(c):
        nSpecial++
return (0 < nUpper) and (0 < nAlphanum) and (0 < nSpecial)

我打赌你几乎立刻就阅读并理解了上面的代码。我打赌您使用正则表达式的时间要长得多，而且不太确定它是否正确。扩展正则表达式是有风险的。扩展了上面的内容，更不用说了。

请注意，这个问题措辞不准确。字符集是ASCII还是Unicode，还是？？我从阅读这个问题中猜测，至少假设了一个小写字符。所以我认为假设的最后一条规则应该是：

return (0 < nUpper) and (0 < nLower) and (0 < nAlphanum) and (0 < nSpecial)

（将帽子改为以安全为中心，这是一条非常讨厌/无用的规则。）

学会知道问题什么时候错了比聪明的答案重要得多。对错误问题的巧妙回答几乎总是错误的。

作为一个示例，如何使用可读/可维护的正则表达式来实现这一点。

对于较长的正则表达式，您应该始终使用RegexOptions.IgnorePatternWhitespace来允许表达式中有空格和注释，以提高可读性。

String[] passwords = { "foobar", "Foobar", "Foobar1", "Fooobar12" };
foreach (String s in passwords) {
    Match password = Regex.Match(s, @"
                                      ^              # Match the start of the string
                                       (?=.*'p{Lu})  # Positive lookahead assertion, is true when there is an uppercase letter
                                       (?=.*'P{L})   # Positive lookahead assertion, is true when there is a non-letter
                                       'S{8,}        # At least 8 non whitespace characters
                                      $              # Match the end of the string
                                     ", RegexOptions.IgnorePatternWhitespace);
    if (password.Success) {
        Console.WriteLine(s + ": valid");
    }
    else {
        Console.WriteLine(s + ": invalid");
    }
}
Console.ReadLine();

如果您只需要一个大写和特殊字符，那么这应该有效：

@"^(?=.{8,}$)(?=[^A-Z]*[A-Z][^A-Z]*$)'w*'W'w*$"

您要查找的正则表达式是：/^(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])(?=.*[!@#'$%'^&'*'[']"'';:_'-<>'., ='+'/'']).{8,}$/u。

示例和测试：http://regexr.com/3fhr4

这个问题开始在网上疯传，出现了很多有趣的建议。

是的，手写很难。因此，一个更简单的解决方案是使用模板。尽管生成的正则表达式可能不是最佳的，但它将更容易维护和/或更改，并且用户将更好地控制结果。我可能遗漏了什么，所以任何建设性的批评都会有所帮助。

这个链接可能很有趣：在字符串中以任何顺序匹配至少2个数字2个字母，正则表达式语言，捕获组

我使用这个模板(?=(?:.*?({type})){({count})})是基于我在SO中看到的所有正则表达式。下一步是替换所需的模式（number、special character…）并添加长度配置。

我为编写regex PasswordRegexGenerator.cs制作了一个小类一个例子：

string result = new PasswordRegexGenerator ( )
        .UpperCase ( 3, -1 )    // ... {3,}
        .Number ( 2, 4 )        // ... {2,4}
        .SpecialCharacter ( 2 ) // ... {2}
        .Total ( 8,-1 )
        .Compose ( );
/// <summary>
/// Generator for regular expression, validating password requirements.
/// </summary>
public class PasswordRegexGenerator
{
    private string _elementTemplate = "(?=(?:.*?({type})){({count})})";
    private Dictionary<string, string> _elements = new Dictionary<string, string> {
        { "uppercase", "[A-Z]" },
        { "lowercase", "[a-z]" },
        { "number", @"'d" },
        { "special", @"'W" },
        { "alphanumeric", @"'w" }
    };
    private StringBuilder _sb = new StringBuilder ( );
    private string Construct ( string what, int min, int max )
    {
        StringBuilder sb = new StringBuilder ( _elementTemplate );
        string count = min.ToString ( );
        if ( max == -1 )
        {
            count += ",";
        }
        else if ( max > 0 )
        {
            count += "," + max.ToString();
        }
        return sb
            .Replace ( "({type})", what )
            .Replace ( "({count})", count )
            .ToString ( );
    }
    /// <summary>
    /// Change the template for the generation of the regex parts
    /// </summary>
    /// <param name="newTemplate">the new template</param>
    /// <returns></returns>
    public PasswordRegexGenerator ChangeRegexTemplate ( string newTemplate )
    {
        _elementTemplate = newTemplate;
        return this;
       }
    /// <summary>
    /// Change or update the regex for a certain type ( number, uppercase ... )
    /// </summary>
    /// <param name="name">type of the regex</param>
    /// <param name="regex">new value for the regex</param>
    /// <returns></returns>
    public PasswordRegexGenerator ChangeRegexElements ( string name, string regex )
    {
        if ( _elements.ContainsKey ( name ) )
        {
            _elements[ name ] = regex;
        }
        else
        {
            _elements.Add ( name, regex );
        }
        return this;
    }
    #region construction methods 
    /// <summary>
    /// Adding number requirement
    /// </summary>
    /// <param name="min"></param>
    /// <param name="max"></param>
    /// <returns></returns>
    public PasswordRegexGenerator Number ( int min = 1, int max = 0 )
    {
        _sb.Append ( Construct ( _elements[ "number" ], min, max ) );
        return this;
    }
    public PasswordRegexGenerator UpperCase ( int min = 1, int max = 0 )
    {
        _sb.Append ( Construct ( _elements[ "uppercase" ], min, max ) );
        return this;
    }
    public PasswordRegexGenerator LowerCase ( int min = 1, int max = 0 )
    {
        _sb.Append ( Construct ( _elements[ "lowercase" ], min, max ) );
        return this;
    }
    public PasswordRegexGenerator SpecialCharacter ( int min = 1, int max = 0 )
    {
        _sb.Append ( Construct ( _elements[ "special" ], min, max ) );
        return this;
    }
    public PasswordRegexGenerator Total ( int min, int max = 0 )
    {
        string count = min.ToString ( ) + ( ( max == 0 ) ? "" : "," + max.ToString ( ) );
        _sb.Append ( ".{" + count + "}" );
        return this;
    }
    #endregion
    public string Compose ()
    {
        return "(" + _sb.ToString ( ) + ")";
    }
}

您可以使用以下类进行验证：

public class PasswordValidator{
  private Pattern pattern;
  private Matcher matcher;
  private static final String PASSWORD_PATTERN =
          "((?=.*''d)(?=.*[a-z])(?=.*[A-Z])(?=.*[@#$%]).{6,20})";
  public PasswordValidator(){
      pattern = Pattern.compile(PASSWORD_PATTERN);
  }
  /**
   * Validate password with regular expression
   * @param password password for validation
   * @return true valid password, false invalid password
   */
  public boolean validate(final String password){
      matcher = pattern.matcher(password);
      return matcher.matches();
  }
}

其中6和20是密码的最小和最大长度。

• 如果密码至少有8个字符，请首先使用非回溯表达式来匹配整个密码（这样，长但无效的密码就不会出现组合爆炸）：(?>{8,})
• 使用后备断言来检查是否存在所有必需的字符（AND条件）。(?<=...)
• 至少有一个大写字符：(?<='p{Lu}.*)
• 至少有一个特殊字符（有点模糊，但我们不要用词）：(?<='W.*)
• 至少一个字母数字字符（：(?<='w.*)

总结：

(?>.{8,})(?<='p{Lu}.*)(?<='W.*)(?<='w.*)

Best并没有对所有内容都使用正则表达式。这些要求很轻。在CPU上，用于检查条件/验证的字符串操作比regex便宜得多，速度也快得多！

我找到的至少有8个字符的，至少由1个小写、1个大写、1个数字和1个符号组成。

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

var regex =/^(?=.*'d)(?=.*[!@#$%^&*])(?=.*[a-z])(?=.*[A-Z]).{8,64}$/;
 
function test() {
 if(regex.test(document.getElementById("txtPassword").value)===false)
 {
 alert("Min 6,Max 64,At Least One Uppercase Character,One Lowercase Character,One Numeric Value And One Special Character(!@#$%^&*) Required ");
 }
 else
 {
 alert("Success");
 }
}

<input type="text" id="txtPassword" />
<button id="testBtn" onclick=test()>CheckPassword</button>

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