Javascript Regex密码验证问题

Question

I'm currently doing a Javascript password control, which of I have to put alerts out for every single mismatch the password has towards the password requirements, which tells you exactly what's wrong with your input.

I've been trying and trying, but never found a solution.

So here's the code:

function checkForm(form)
  {

     var re = /^\w{6,10}$/;

    if(!re.test(form.pwd1.value)) {
      alert("Password in-between 6-10 characters");
      form.inputfield.focus();
      return false;
    }

    var re = /^[\w ]+$/;

    if(!re.test(form.pwd1.value)) {
      alert("You need to write something");
      form.inputfield.focus();
      return false;
    }

    var re = /^(?=.*[A-Z])\w{2,}$/;

    if(!re.test(form.pwd1.value)) {
      alert("At least two Upper case");
      form.inputfield.focus();
      return false;
    }


    var re = /^(?=.*[a-z])\w{2,}$/;

    if(!re.test(form.pwd1.value)) {
      alert(" At least two Lower Case letters");
      form.inputfield.focus();
      return false;
    }

    var re = /^(?=.*\d)\w{2,}$/;

    if(!re.test(form.pwd1.value)) {
      alert("At least two numbers");
      form.inputfield.focus();
      return false;
    }

    // validation was successful
    else(alert("Welcome!"));
    return true;
  }

My issue is that the controller settles by one character of each, instead of two, however it need you to input at least two of one of the values eg. either 2x uppercase, 2x lowercase or 2x numbers. Which is impossible to not-do when it requires 6 characters. And that's the weirdest thing, that expression actually works!

I'd really appreciate if anyone has any input on this. Thanks!

Answer 1

first of all, it is annoying getting alert box every time but if it is what you want then change your upper lower and number checking pattern;

^.*[A-Z]{2,}.*$
^.*[0-9]{2,}.*$
^.*[a-z]{2,}.*$

Answer 2

Your 2-Upper-case, 2-Lower-case and 2-Number patterns are wrong. You should use something like:

var re = /^.*([A-Z].*){2,}$/;
var re = /^.*([a-z].*){2,}$/;
var re = /^.*([0-9].*){2,}$/;

See this short demo .

EDIT :
Please, note that:

• By using \\w you limit the valid password characters to letters, digits, and underscores (more info here ).
• According to the specs you gave, you need either 2 upper OR 2 lower OR 2 digits. This means you cannot alert the user if he fails one of those check, because he might succeed the next. You have to make all three checks and the alert the user if ALL three fail.
• If the user enters a 6-10 letter password containing non- \\w characters (eg "abCD56-"), he will be alerted that "the password should be between 6 and 10 characters", while his password IS 6-10 characters (just not the characters you want), so the message would be kind of misleading in this case.

I hope that helps.

Answer 3

There is a pattern you use in your code that does something different from what you likely intend:

    var re = /^(?=.*\d)\w{2,}$/;

The lookahead, (?=.*\\d) , does not consume any characters in the string. It looks ahead at the point of the anchor to match the pattern .*\\d . The lookahead will return a successful match if there is one digit in the string (ie, any number of characters followed by a digit).

Conceptually, once the lookahead returns true, the parser will attempt to match \\w{2,}$ , which matches any number of word characters (letters, numbers, and _ ) followed by the end of the string.

The result is that the pattern will match any string comprised of 2 or more word characters that contains at least one digit, rather than the intended two.

As a correction, you have several options. Since your first pattern ensures that the password is a proper length, you can replace this expression with:

var re = /\d.*\d/;

This will find a digit followed by any sequence of characters, followed by another digit (note the removal of the ^ and $ anchors, since the first digit can occur anywhere in the string).

The same concept can be applied to the other patterns that require two symbols:

var re = /^(?=.*[A-Z])\w{2,}$/; becomes var re = /[A-Z].*[A-Z]/;
var re = /^(?=.*[a-z])\w{2,}$/; becomes var re = /[a-z].*[a-z]/;