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

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

密码必须为八个字符，包括一个大写字母、一个特殊字符和字母数字字符

这是我的验证表达式，用于八个字符，包括一个大写字母、一个小写字母和一个数字或特殊字符

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

---

如何为一个必须包含八个字符（包括一个大写字母、一个特殊字符和字母数字字符）的密码编写它？

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

我认为把你的正则表达式分解，一次做一点会更容易。这可能需要更多的时间来完成，但我确信维护和调试它会更容易。这还允许您向用户提供更多定向错误消息（而不仅仅是

无效密码

），这将改善用户体验

据我所见，你对正则表达式非常熟练，所以我认为给你正则表达式来做你需要的事情是徒劳的

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

• 长度必须为八个字符：不需要正则表达式。使用

  .Length

  属性应该足够了

• 包括一个大写字母：您可以使用

  [A-Z]+

  正则表达式。如果字符串至少包含一个大写字母，则此正则表达式将生成

  true

• 一个特殊字符：您可以使用将匹配任何非字母或数字字符的

  \W

  ，或者，您可以使用类似so

  [！@#]

  的内容来指定特殊字符的自定义列表。请注意，尽管诸如

  $

  、

  ^

  、

  （

  和

  ）

  等字符是正则表达式语言中的特殊字符，但它们需要像这样转义：

  \$

  。因此，简而言之，您可以使用

  \W

• 字母数字字符：使用

  \w+

  应匹配任何字母、数字和下划线

---

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

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

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

一行：

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

编辑2019-05-28： 您需要匹配整个输入字符串。因此，您可以将正则表达式括在

^

和

$

之间，以防止意外地将部分匹配假定为匹配整个输入：

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

资料来源：

---

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

对于较长的正则表达式，应始终使用

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

---

答案是不要使用正则表达式。这是布景和计数

正则表达式是关于顺序的

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

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

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

如果s.length<8：
返回错误
nUpper=nLower=nAlphanum=nSpecial=0
对于s中的c：
如果为上限（c）：
努珀++
如果是岛国（c）：
低++
如果是对数（c）：
纳尔芬努姆++
如属特殊情况（c）：
特别的++
返回值（0

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

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

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

返回（0

（将帽子改为以安全为中心，这是一条非常烦人/没有用的规则。）

---

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

这个问题开始流行起来，出现了许多有趣的建议

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

这些链接可能很有趣：

我使用这个模板

（？=（？：.*（{type}））{（{count}}）

基于我在SO中看到的所有正则表达式。下一步是替换所需的模式（

数字

，

特殊字符

…）并添加长度配置

我上了一堂写正则表达式的小课 例如：

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 ( ) + ")";
    }
}

string result=new PasswordRegexGenerator（）
.大写字母（3，-1）/。。。{3,}
.编号（2，4）/。。。{2,4}
.特殊字符（2）/。。。{2}
.总计（8，-1）
.Compose（）；
/// 
///正则表达式生成器，验证密码要求。
/// 
公共类PasswordRegexGenerator
{
私有字符串_elementTemplate=“（？=（？：.*（{type}））{（{count}}）”；
私有字典_元素=新字典{
{“大写”，“[A-Z]”，
{“小写”，“[a-z]}，
{“编号”@“\d}，
{“特殊”@“\W”}，
{“字母数字”@
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)

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

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 ( ) + ")";
    }
}

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

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

  }
}

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