Regex 使用正则表达式验证密码_Regex_Validation

Regex 使用正则表达式验证密码

regex validation

Regex 使用正则表达式验证密码,regex,validation,Regex,Validation,下面是验证我的密码的正则表达式： (((?=.*\\d{2,20})(?=.*[a-z]{2,20})(?=.*[A-Z]{3,20})(?=.*[@#$%!@@%&*?_~,-]{2,20})).{9,20}[^<>'\"]) （（（？=.*\\d{2,20}）（？=.[a-z]{2,20}）（？=.[a-z]{3,20}）（？=.[-%！@%&*？{2,20}]）。{9,20}[^'\] 基本上我想要的是，它在密码中包含所有上述给定字符它验证23aaaaaa！，但不

下面是验证我的密码的正则表达式：

(((?=.*\\d{2,20})(?=.*[a-z]{2,20})(?=.*[A-Z]{3,20})(?=.*[@#$%!@@%&*?_~,-]{2,20})).{9,20}[^<>'\"])

（（（？=.*\\d{2,20}）（？=.[a-z]{2,20}）（？=.[a-z]{3,20}）（？=.[-%！@%&*？{2,20}]）。{9,20}[^'\]

基本上我想要的是，它在密码中包含所有上述给定字符

它验证

23aaaaaa！

，但不验证

a2@！AAAa

只需添加嵌套的捕获组，以保持字符验证不严格按顺序进行。正则表达式也可以简化为以下内容（无需额外的组）：

（？=（？：.[0-9]）{2,20}）
（？=（？：.[a-z]）{2,20}）
（？=（？：.[A-Z]）{3,20}）
(?=(?:.*[@#$%!&*?_~,-]){2,20})
.{9,20}
[^'\“]\35;这也与换行符匹配，我想你不是真的想要这个。。。

在java中，按如下方式使用它来匹配：

String regex = "(?=(?:.*[0-9]){2,20})(?=(?:.*[a-z]){2,20})(?=(?:.*[A-Z]){3,20})(?=(?:.*[@#$%!&*?_~,-]){2,20}).{9,20}[^<>'\"]";
String password = "23aaA@AA!@X"; // This have to be 10 chars long at least, no newline

if (password.matches(regex))
    System.out.println("Success");
else
    System.out.println("Failure");

String regex=“（？=（？：.[0-9]）{2,20}”（？=（？：.[a-z]）{2,20}）（？=（？：.[a-z]）{3,20}）（？=（？：.[@$%！&*？!，-]）{2,20}.{9,20}[^'\\”；
字符串密码=”23aaA@AA!@X“；//这必须至少有10个字符长，没有换行符
if（password.matches（regex））
System.out.println（“成功”）；
其他的
系统输出打印项次（“失败”）；

正则表达式需要一个密码（并非严格按顺序）：

```
（？=（？：.[0-9]）{2,20}
```
：2个数字
```
（？=（？：.[a-z]）{2,20}）
```
：3个小写字母
```
（？=（？：.[A-Z]）{3,20}
```
：3个大写字母

（？=（？：.[@#$%！&*？#~，-]）{2,20}

：字符组中的2个符号

```
{9,20}
```
：最小长度为9，最大长度为20

[^'\“]

：一个字符不在（

，

，，“
）（注意：这也与换行符匹配）


因此min
/max
实际上是10
/21
，但最后一个语句也与换行符匹配，因此在在线regex演示中，可见字符将介于9
和20
之间
Regex在线演示
我不会尝试构建一个单一的regexp，因为再也没有人能够阅读或更改这个表达式了。这很难理解
“a2@！AAAa“将永远不会验证，因为它需要2位数字
如果您想要一个密码，它包含一个组中的最小和最大字符数。只需对它们进行计数
public class Constraint {

    private Pattern pattern;
    public String regexp = "";
    public int mincount=2;
    public int maxcount=6;

    public Constraint(String regexp, int mincount, int maxcount) {
        this.mincount=mincount;
        this.maxcount=maxcount;
        pattern = Pattern.compile(regexp);
    }

    public boolean fit(String str)
    {
        int count = str.length() - pattern.matcher(str).replaceAll("").length();
        return count >= mincount && count <= maxcount;
    }

    @Override
    public String toString() {
        return pattern.toString();
    }
}


public class Test {

    static Constraint[] constraints = new Constraint[] {
            new Constraint("[a-z]",2,20),
            new Constraint("[A-Z]",2,20),
            new Constraint("\\d",2,20),
            new Constraint("["+Pattern.quote("@#$%!@@%&*?_~,-")+"]",2,20),
            new Constraint("[<>'\\\"]",0,0)
    };

    public static boolean checkit(String pwd)
    {
        boolean ok=true;
        for (Constraint constraint:constraints)
        {
            if (constraint.fit(pwd)==false)
            {
                System.out.println("match failed for constraint "+constraint);
                ok=false;
            }
        }
        return ok;
    }

    public static void main(String[] args) {
        checkit("23aaAAA@!");
        checkit("a2@!AAAa");
    }
}

公共类约束{
私有模式；
公共字符串regexp=“”；
公共int mincount=2；
公共整数最大计数=6；
公共约束（字符串regexp、int-mincount、int-maxcount）{
this.mincount=mincount；
this.maxcount=maxcount；
pattern=pattern.compile（regexp）；
}
公共布尔拟合（字符串str）
{
int count=str.length（）-pattern.matcher（str.replaceAll）（“”.length（）；
return count>=mincount&&count我也有同样的问题。这看起来像是XY问题。您是否需要为此使用正则表达式，而不是以另一种方式验证密码？密码是基于此正则表达式生成的。因此我们需要基于该正则表达式进行验证。是否可以针对多个正则表达式进行验证？例如 密码.密码.匹配（（[A-Z[A-Z[A-Z[A-Z[A-Z[A-Z[A-Z[A-A-Z-Z-d[A-A-A-Z-Z-d[A-A-Z-Z-d[A-Z-Z[A-Z[A-Z[A-Z[A-Z[A-Z[A-Z-Z-Z-d[A-Z-d]”）的）匹配（
/code>/code>/code>/code>.巴沙拉塔：你们没有给出任何反馈，你们没有任何反馈，你们有你们没有，你们有你们没有给任何反馈，你们有你们有你们有你们有你们有你们有你们没有尝试简单地插入任何反馈，有你们有你们有你们有你们有你们有你们有你们有你们有你们有你们有你们有你们有你们有你们有你们有你们有你们有你们有你们有你们有你们有你们有你们有你们尝试简单地插入了作为作为作为作为作为“]
.Php是基于PCRE的，因此它将按预期工作，我不能确定Asp.net（它在C#中工作）。自由间距（？x）修饰符允许间距（在java中不可用），但将组内联放置到修复程序中。如果不起作用，请让我尝试，然后返回stack@BasharatAli：抱歉，我想你必须用java来完成这个任务，我真的需要睡觉：）
public class Constraint {

    private Pattern pattern;
    public String regexp = "";
    public int mincount=2;
    public int maxcount=6;

    public Constraint(String regexp, int mincount, int maxcount) {
        this.mincount=mincount;
        this.maxcount=maxcount;
        pattern = Pattern.compile(regexp);
    }

    public boolean fit(String str)
    {
        int count = str.length() - pattern.matcher(str).replaceAll("").length();
        return count >= mincount && count <= maxcount;
    }

    @Override
    public String toString() {
        return pattern.toString();
    }
}


public class Test {

    static Constraint[] constraints = new Constraint[] {
            new Constraint("[a-z]",2,20),
            new Constraint("[A-Z]",2,20),
            new Constraint("\\d",2,20),
            new Constraint("["+Pattern.quote("@#$%!@@%&*?_~,-")+"]",2,20),
            new Constraint("[<>'\\\"]",0,0)
    };

    public static boolean checkit(String pwd)
    {
        boolean ok=true;
        for (Constraint constraint:constraints)
        {
            if (constraint.fit(pwd)==false)
            {
                System.out.println("match failed for constraint "+constraint);
                ok=false;
            }
        }
        return ok;
    }

    public static void main(String[] args) {
        checkit("23aaAAA@!");
        checkit("a2@!AAAa");
    }
}