jQuery 密码强度检查器

Question

I'm quite new to jQuery, and I've written a simple function to check the strength of a password for each keypress.我对 jQuery 很陌生，我编写了一个简单的函数来检查每个按键的密码强度。

The idea is that every time a user enters a character, the contents is evaluated to test the strengh of the password they have entered... I'm sure everyone has seen these before.这个想法是每次用户输入一个字符时，都会评估内容以测试他们输入的密码的强度......我相信每个人之前都见过这些。

Anyhow, the logic I have used is that no password begins with a value of 1. When a lower-case character is used, the score increments to 2. When a digit is used the score increments by 1 again, same for when an uppercase character is used and when the password becomes 5 or more characters long.无论如何，我使用的逻辑是没有密码以值 1 开头。使用小写字符时，分数增加到 2。使用数字时，分数再次增加 1，与大写时相同当密码长度为 5 个或更多字符时使用字符。

What is returned is the strength of the password so far as a value from 1 to 5 every time a key is pressed.返回的是每次按下键时密码的强度，即从 1 到 5 的值。

So, about my question.那么，关于我的问题。 The way that I've done it doesn't seem very jQuery like... almost like I may as well have just done straight javascript.我完成它的方式似乎不像 jQuery 那样......几乎就像我刚刚完成了直接的 javascript 一样。 Also I was wondering about my logic.我也想知道我的逻辑。 Have I done anything done or overlooked something?我有没有做过什么或忽略了什么？ Any suggestions from smarter people than myself?比我更聪明的人有什么建议吗？

Any suggestions or advice would be appreciated.任何建议或意见将不胜感激。

$(document).ready(function(){

        $("#pass_strength").keyup(function() {

            var strength = 1;

            /*length 5 characters or more*/
            if(this.value.length >= 5) {
                strength++;
            }

            /*contains lowercase characters*/
            if(this.value.match(/[a-z]+/)) {
                strength++;
            }

            /*contains digits*/
            if(this.value.match(/[0-9]+/)) {
                strength++;
            }

            /*contains uppercase characters*/
            if(this.value.match(/[A-Z]+/)) {
                strength++;
            }

            alert(strength);
        });
     });

Answer 1

I'm quite new to jQuery, and I've written a simple function to check the strength of a password for each keypress.我对jQuery很陌生，并且编写了一个简单的函数来检查每个按键的密码强度。

The idea is that every time a user enters a character, the contents is evaluated to test the strengh of the password they have entered... I'm sure everyone has seen these before.这个想法是，每次用户输入一个字符时，都会对内容进行评估，以测试他们输入的密码的强度……我敢肯定，每个人以前都看过这些密码。

Anyhow, the logic I have used is that no password begins with a value of 1. When a lower-case character is used, the score increments to 2. When a digit is used the score increments by 1 again, same for when an uppercase character is used and when the password becomes 5 or more characters long.无论如何，我使用的逻辑是没有密码以1开头。使用小写字符时，分数增加到2。使用数字时，分数再次增加1，与大写相同使用字符，并且密码长度为5个或更多字符时。

What is returned is the strength of the password so far as a value from 1 to 5 every time a key is pressed.每次按键时返回的密码强度为1到5。

So, about my question.所以，关于我的问题。 The way that I've done it doesn't seem very jQuery like... almost like I may as well have just done straight javascript.我完成的方式似乎不像jQuery，...好像我也可以直接编写javascript。 Also I was wondering about my logic.我也想知道我的逻辑。 Have I done anything done or overlooked something?我做过什么事还是忽略了什么？ Any suggestions from smarter people than myself?比我聪明的人有什么建议吗？

Any suggestions or advice would be appreciated.任何建议或意见将不胜感激。

$(document).ready(function(){

        $("#pass_strength").keyup(function() {

            var strength = 1;

            /*length 5 characters or more*/
            if(this.value.length >= 5) {
                strength++;
            }

            /*contains lowercase characters*/
            if(this.value.match(/[a-z]+/)) {
                strength++;
            }

            /*contains digits*/
            if(this.value.match(/[0-9]+/)) {
                strength++;
            }

            /*contains uppercase characters*/
            if(this.value.match(/[A-Z]+/)) {
                strength++;
            }

            alert(strength);
        });
     });

Answer 2

I'm quite new to jQuery, and I've written a simple function to check the strength of a password for each keypress.我对jQuery很陌生，并且编写了一个简单的函数来检查每个按键的密码强度。

The idea is that every time a user enters a character, the contents is evaluated to test the strengh of the password they have entered... I'm sure everyone has seen these before.这个想法是，每次用户输入一个字符时，都会对内容进行评估，以测试他们输入的密码的强度……我敢肯定，每个人以前都看过这些密码。

Anyhow, the logic I have used is that no password begins with a value of 1. When a lower-case character is used, the score increments to 2. When a digit is used the score increments by 1 again, same for when an uppercase character is used and when the password becomes 5 or more characters long.无论如何，我使用的逻辑是没有密码以1开头。使用小写字符时，分数增加到2。使用数字时，分数再次增加1，与大写相同使用字符，并且密码长度为5个或更多字符时。

What is returned is the strength of the password so far as a value from 1 to 5 every time a key is pressed.每次按键时返回的密码强度为1到5。

So, about my question.所以，关于我的问题。 The way that I've done it doesn't seem very jQuery like... almost like I may as well have just done straight javascript.我完成的方式似乎不像jQuery，...好像我也可以直接编写javascript。 Also I was wondering about my logic.我也想知道我的逻辑。 Have I done anything done or overlooked something?我做过什么事还是忽略了什么？ Any suggestions from smarter people than myself?比我聪明的人有什么建议吗？

Any suggestions or advice would be appreciated.任何建议或意见将不胜感激。

$(document).ready(function(){

        $("#pass_strength").keyup(function() {

            var strength = 1;

            /*length 5 characters or more*/
            if(this.value.length >= 5) {
                strength++;
            }

            /*contains lowercase characters*/
            if(this.value.match(/[a-z]+/)) {
                strength++;
            }

            /*contains digits*/
            if(this.value.match(/[0-9]+/)) {
                strength++;
            }

            /*contains uppercase characters*/
            if(this.value.match(/[A-Z]+/)) {
                strength++;
            }

            alert(strength);
        });
     });

Answer 3

I'm quite new to jQuery, and I've written a simple function to check the strength of a password for each keypress.我对jQuery很陌生，并且编写了一个简单的函数来检查每个按键的密码强度。

The idea is that every time a user enters a character, the contents is evaluated to test the strengh of the password they have entered... I'm sure everyone has seen these before.这个想法是，每次用户输入一个字符时，都会对内容进行评估，以测试他们输入的密码的强度……我敢肯定，每个人以前都看过这些密码。

Anyhow, the logic I have used is that no password begins with a value of 1. When a lower-case character is used, the score increments to 2. When a digit is used the score increments by 1 again, same for when an uppercase character is used and when the password becomes 5 or more characters long.无论如何，我使用的逻辑是没有密码以1开头。使用小写字符时，分数增加到2。使用数字时，分数再次增加1，与大写相同使用字符，并且密码长度为5个或更多字符时。

What is returned is the strength of the password so far as a value from 1 to 5 every time a key is pressed.每次按键时返回的密码强度为1到5。

So, about my question.所以，关于我的问题。 The way that I've done it doesn't seem very jQuery like... almost like I may as well have just done straight javascript.我完成的方式似乎不像jQuery，...好像我也可以直接编写javascript。 Also I was wondering about my logic.我也想知道我的逻辑。 Have I done anything done or overlooked something?我做过什么事还是忽略了什么？ Any suggestions from smarter people than myself?比我聪明的人有什么建议吗？

Any suggestions or advice would be appreciated.任何建议或意见将不胜感激。

$(document).ready(function(){

        $("#pass_strength").keyup(function() {

            var strength = 1;

            /*length 5 characters or more*/
            if(this.value.length >= 5) {
                strength++;
            }

            /*contains lowercase characters*/
            if(this.value.match(/[a-z]+/)) {
                strength++;
            }

            /*contains digits*/
            if(this.value.match(/[0-9]+/)) {
                strength++;
            }

            /*contains uppercase characters*/
            if(this.value.match(/[A-Z]+/)) {
                strength++;
            }

            alert(strength);
        });
     });

Answer 4

I'm quite new to jQuery, and I've written a simple function to check the strength of a password for each keypress.我对jQuery很陌生，并且编写了一个简单的函数来检查每个按键的密码强度。

The idea is that every time a user enters a character, the contents is evaluated to test the strengh of the password they have entered... I'm sure everyone has seen these before.这个想法是，每次用户输入一个字符时，都会对内容进行评估，以测试他们输入的密码的强度……我敢肯定，每个人以前都看过这些密码。

Anyhow, the logic I have used is that no password begins with a value of 1. When a lower-case character is used, the score increments to 2. When a digit is used the score increments by 1 again, same for when an uppercase character is used and when the password becomes 5 or more characters long.无论如何，我使用的逻辑是没有密码以1开头。使用小写字符时，分数增加到2。使用数字时，分数再次增加1，与大写相同使用字符，并且密码长度为5个或更多字符时。

What is returned is the strength of the password so far as a value from 1 to 5 every time a key is pressed.每次按键时返回的密码强度为1到5。

So, about my question.所以，关于我的问题。 The way that I've done it doesn't seem very jQuery like... almost like I may as well have just done straight javascript.我完成的方式似乎不像jQuery，...好像我也可以直接编写javascript。 Also I was wondering about my logic.我也想知道我的逻辑。 Have I done anything done or overlooked something?我做过什么事还是忽略了什么？ Any suggestions from smarter people than myself?比我聪明的人有什么建议吗？

Any suggestions or advice would be appreciated.任何建议或意见将不胜感激。

$(document).ready(function(){

        $("#pass_strength").keyup(function() {

            var strength = 1;

            /*length 5 characters or more*/
            if(this.value.length >= 5) {
                strength++;
            }

            /*contains lowercase characters*/
            if(this.value.match(/[a-z]+/)) {
                strength++;
            }

            /*contains digits*/
            if(this.value.match(/[0-9]+/)) {
                strength++;
            }

            /*contains uppercase characters*/
            if(this.value.match(/[A-Z]+/)) {
                strength++;
            }

            alert(strength);
        });
     });

Answer 5

I'm quite new to jQuery, and I've written a simple function to check the strength of a password for each keypress.我对jQuery很陌生，并且编写了一个简单的函数来检查每个按键的密码强度。

The idea is that every time a user enters a character, the contents is evaluated to test the strengh of the password they have entered... I'm sure everyone has seen these before.这个想法是，每次用户输入一个字符时，都会对内容进行评估，以测试他们输入的密码的强度……我敢肯定，每个人以前都看过这些密码。

Anyhow, the logic I have used is that no password begins with a value of 1. When a lower-case character is used, the score increments to 2. When a digit is used the score increments by 1 again, same for when an uppercase character is used and when the password becomes 5 or more characters long.无论如何，我使用的逻辑是没有密码以1开头。使用小写字符时，分数增加到2。使用数字时，分数再次增加1，与大写相同使用字符，并且密码长度为5个或更多字符时。

What is returned is the strength of the password so far as a value from 1 to 5 every time a key is pressed.每次按键时返回的密码强度为1到5。

So, about my question.所以，关于我的问题。 The way that I've done it doesn't seem very jQuery like... almost like I may as well have just done straight javascript.我完成的方式似乎不像jQuery，...好像我也可以直接编写javascript。 Also I was wondering about my logic.我也想知道我的逻辑。 Have I done anything done or overlooked something?我做过什么事还是忽略了什么？ Any suggestions from smarter people than myself?比我聪明的人有什么建议吗？

Any suggestions or advice would be appreciated.任何建议或意见将不胜感激。

$(document).ready(function(){

        $("#pass_strength").keyup(function() {

            var strength = 1;

            /*length 5 characters or more*/
            if(this.value.length >= 5) {
                strength++;
            }

            /*contains lowercase characters*/
            if(this.value.match(/[a-z]+/)) {
                strength++;
            }

            /*contains digits*/
            if(this.value.match(/[0-9]+/)) {
                strength++;
            }

            /*contains uppercase characters*/
            if(this.value.match(/[A-Z]+/)) {
                strength++;
            }

            alert(strength);
        });
     });

Answer 6

I'm quite new to jQuery, and I've written a simple function to check the strength of a password for each keypress.我对jQuery很陌生，并且编写了一个简单的函数来检查每个按键的密码强度。

The idea is that every time a user enters a character, the contents is evaluated to test the strengh of the password they have entered... I'm sure everyone has seen these before.这个想法是，每次用户输入一个字符时，都会对内容进行评估，以测试他们输入的密码的强度……我敢肯定，每个人以前都看过这些密码。

Anyhow, the logic I have used is that no password begins with a value of 1. When a lower-case character is used, the score increments to 2. When a digit is used the score increments by 1 again, same for when an uppercase character is used and when the password becomes 5 or more characters long.无论如何，我使用的逻辑是没有密码以1开头。使用小写字符时，分数增加到2。使用数字时，分数再次增加1，与大写相同使用字符，并且密码长度为5个或更多字符时。

What is returned is the strength of the password so far as a value from 1 to 5 every time a key is pressed.每次按键时返回的密码强度为1到5。

So, about my question.所以，关于我的问题。 The way that I've done it doesn't seem very jQuery like... almost like I may as well have just done straight javascript.我完成的方式似乎不像jQuery，...好像我也可以直接编写javascript。 Also I was wondering about my logic.我也想知道我的逻辑。 Have I done anything done or overlooked something?我做过什么事还是忽略了什么？ Any suggestions from smarter people than myself?比我聪明的人有什么建议吗？

Any suggestions or advice would be appreciated.任何建议或意见将不胜感激。

$(document).ready(function(){

        $("#pass_strength").keyup(function() {

            var strength = 1;

            /*length 5 characters or more*/
            if(this.value.length >= 5) {
                strength++;
            }

            /*contains lowercase characters*/
            if(this.value.match(/[a-z]+/)) {
                strength++;
            }

            /*contains digits*/
            if(this.value.match(/[0-9]+/)) {
                strength++;
            }

            /*contains uppercase characters*/
            if(this.value.match(/[A-Z]+/)) {
                strength++;
            }

            alert(strength);
        });
     });

Answer 7

I'm quite new to jQuery, and I've written a simple function to check the strength of a password for each keypress.我对jQuery很陌生，并且编写了一个简单的函数来检查每个按键的密码强度。

The idea is that every time a user enters a character, the contents is evaluated to test the strengh of the password they have entered... I'm sure everyone has seen these before.这个想法是，每次用户输入一个字符时，都会对内容进行评估，以测试他们输入的密码的强度……我敢肯定，每个人以前都看过这些密码。

Anyhow, the logic I have used is that no password begins with a value of 1. When a lower-case character is used, the score increments to 2. When a digit is used the score increments by 1 again, same for when an uppercase character is used and when the password becomes 5 or more characters long.无论如何，我使用的逻辑是没有密码以1开头。使用小写字符时，分数增加到2。使用数字时，分数再次增加1，与大写相同使用字符，并且密码长度为5个或更多字符时。

What is returned is the strength of the password so far as a value from 1 to 5 every time a key is pressed.每次按键时返回的密码强度为1到5。

So, about my question.所以，关于我的问题。 The way that I've done it doesn't seem very jQuery like... almost like I may as well have just done straight javascript.我完成的方式似乎不像jQuery，...好像我也可以直接编写javascript。 Also I was wondering about my logic.我也想知道我的逻辑。 Have I done anything done or overlooked something?我做过什么事还是忽略了什么？ Any suggestions from smarter people than myself?比我聪明的人有什么建议吗？

Any suggestions or advice would be appreciated.任何建议或意见将不胜感激。

$(document).ready(function(){

        $("#pass_strength").keyup(function() {

            var strength = 1;

            /*length 5 characters or more*/
            if(this.value.length >= 5) {
                strength++;
            }

            /*contains lowercase characters*/
            if(this.value.match(/[a-z]+/)) {
                strength++;
            }

            /*contains digits*/
            if(this.value.match(/[0-9]+/)) {
                strength++;
            }

            /*contains uppercase characters*/
            if(this.value.match(/[A-Z]+/)) {
                strength++;
            }

            alert(strength);
        });
     });

Answer 8

I'm quite new to jQuery, and I've written a simple function to check the strength of a password for each keypress.我对jQuery很陌生，并且编写了一个简单的函数来检查每个按键的密码强度。

The idea is that every time a user enters a character, the contents is evaluated to test the strengh of the password they have entered... I'm sure everyone has seen these before.这个想法是，每次用户输入一个字符时，都会对内容进行评估，以测试他们输入的密码的强度……我敢肯定，每个人以前都看过这些密码。

Anyhow, the logic I have used is that no password begins with a value of 1. When a lower-case character is used, the score increments to 2. When a digit is used the score increments by 1 again, same for when an uppercase character is used and when the password becomes 5 or more characters long.无论如何，我使用的逻辑是没有密码以1开头。使用小写字符时，分数增加到2。使用数字时，分数再次增加1，与大写相同使用字符，并且密码长度为5个或更多字符时。

What is returned is the strength of the password so far as a value from 1 to 5 every time a key is pressed.每次按键时返回的密码强度为1到5。

So, about my question.所以，关于我的问题。 The way that I've done it doesn't seem very jQuery like... almost like I may as well have just done straight javascript.我完成的方式似乎不像jQuery，...好像我也可以直接编写javascript。 Also I was wondering about my logic.我也想知道我的逻辑。 Have I done anything done or overlooked something?我做过什么事还是忽略了什么？ Any suggestions from smarter people than myself?比我聪明的人有什么建议吗？

Any suggestions or advice would be appreciated.任何建议或意见将不胜感激。

$(document).ready(function(){

        $("#pass_strength").keyup(function() {

            var strength = 1;

            /*length 5 characters or more*/
            if(this.value.length >= 5) {
                strength++;
            }

            /*contains lowercase characters*/
            if(this.value.match(/[a-z]+/)) {
                strength++;
            }

            /*contains digits*/
            if(this.value.match(/[0-9]+/)) {
                strength++;
            }

            /*contains uppercase characters*/
            if(this.value.match(/[A-Z]+/)) {
                strength++;
            }

            alert(strength);
        });
     });

Answer 9

I'm quite new to jQuery, and I've written a simple function to check the strength of a password for each keypress.我对jQuery很陌生，并且编写了一个简单的函数来检查每个按键的密码强度。

The idea is that every time a user enters a character, the contents is evaluated to test the strengh of the password they have entered... I'm sure everyone has seen these before.这个想法是，每次用户输入一个字符时，都会对内容进行评估，以测试他们输入的密码的强度……我敢肯定，每个人以前都看过这些密码。

Anyhow, the logic I have used is that no password begins with a value of 1. When a lower-case character is used, the score increments to 2. When a digit is used the score increments by 1 again, same for when an uppercase character is used and when the password becomes 5 or more characters long.无论如何，我使用的逻辑是没有密码以1开头。使用小写字符时，分数增加到2。使用数字时，分数再次增加1，与大写相同使用字符，并且密码长度为5个或更多字符时。

What is returned is the strength of the password so far as a value from 1 to 5 every time a key is pressed.每次按键时返回的密码强度为1到5。

So, about my question.所以，关于我的问题。 The way that I've done it doesn't seem very jQuery like... almost like I may as well have just done straight javascript.我完成的方式似乎不像jQuery，...好像我也可以直接编写javascript。 Also I was wondering about my logic.我也想知道我的逻辑。 Have I done anything done or overlooked something?我做过什么事还是忽略了什么？ Any suggestions from smarter people than myself?比我聪明的人有什么建议吗？

Any suggestions or advice would be appreciated.任何建议或意见将不胜感激。

$(document).ready(function(){

        $("#pass_strength").keyup(function() {

            var strength = 1;

            /*length 5 characters or more*/
            if(this.value.length >= 5) {
                strength++;
            }

            /*contains lowercase characters*/
            if(this.value.match(/[a-z]+/)) {
                strength++;
            }

            /*contains digits*/
            if(this.value.match(/[0-9]+/)) {
                strength++;
            }

            /*contains uppercase characters*/
            if(this.value.match(/[A-Z]+/)) {
                strength++;
            }

            alert(strength);
        });
     });

Answer 10

I'm quite new to jQuery, and I've written a simple function to check the strength of a password for each keypress.我对jQuery很陌生，并且编写了一个简单的函数来检查每个按键的密码强度。

The idea is that every time a user enters a character, the contents is evaluated to test the strengh of the password they have entered... I'm sure everyone has seen these before.这个想法是，每次用户输入一个字符时，都会对内容进行评估，以测试他们输入的密码的强度……我敢肯定，每个人以前都看过这些密码。

Anyhow, the logic I have used is that no password begins with a value of 1. When a lower-case character is used, the score increments to 2. When a digit is used the score increments by 1 again, same for when an uppercase character is used and when the password becomes 5 or more characters long.无论如何，我使用的逻辑是没有密码以1开头。使用小写字符时，分数增加到2。使用数字时，分数再次增加1，与大写相同使用字符，并且密码长度为5个或更多字符时。

What is returned is the strength of the password so far as a value from 1 to 5 every time a key is pressed.每次按键时返回的密码强度为1到5。

So, about my question.所以，关于我的问题。 The way that I've done it doesn't seem very jQuery like... almost like I may as well have just done straight javascript.我完成的方式似乎不像jQuery，...好像我也可以直接编写javascript。 Also I was wondering about my logic.我也想知道我的逻辑。 Have I done anything done or overlooked something?我做过什么事还是忽略了什么？ Any suggestions from smarter people than myself?比我聪明的人有什么建议吗？

Any suggestions or advice would be appreciated.任何建议或意见将不胜感激。

$(document).ready(function(){

        $("#pass_strength").keyup(function() {

            var strength = 1;

            /*length 5 characters or more*/
            if(this.value.length >= 5) {
                strength++;
            }

            /*contains lowercase characters*/
            if(this.value.match(/[a-z]+/)) {
                strength++;
            }

            /*contains digits*/
            if(this.value.match(/[0-9]+/)) {
                strength++;
            }

            /*contains uppercase characters*/
            if(this.value.match(/[A-Z]+/)) {
                strength++;
            }

            alert(strength);
        });
     });

Answer 11

I'm quite new to jQuery, and I've written a simple function to check the strength of a password for each keypress.我对jQuery很陌生，并且编写了一个简单的函数来检查每个按键的密码强度。

The idea is that every time a user enters a character, the contents is evaluated to test the strengh of the password they have entered... I'm sure everyone has seen these before.这个想法是，每次用户输入一个字符时，都会对内容进行评估，以测试他们输入的密码的强度……我敢肯定，每个人以前都看过这些密码。

Anyhow, the logic I have used is that no password begins with a value of 1. When a lower-case character is used, the score increments to 2. When a digit is used the score increments by 1 again, same for when an uppercase character is used and when the password becomes 5 or more characters long.无论如何，我使用的逻辑是没有密码以1开头。使用小写字符时，分数增加到2。使用数字时，分数再次增加1，与大写相同使用字符，并且密码长度为5个或更多字符时。

What is returned is the strength of the password so far as a value from 1 to 5 every time a key is pressed.每次按键时返回的密码强度为1到5。

So, about my question.所以，关于我的问题。 The way that I've done it doesn't seem very jQuery like... almost like I may as well have just done straight javascript.我完成的方式似乎不像jQuery，...好像我也可以直接编写javascript。 Also I was wondering about my logic.我也想知道我的逻辑。 Have I done anything done or overlooked something?我做过什么事还是忽略了什么？ Any suggestions from smarter people than myself?比我聪明的人有什么建议吗？

Any suggestions or advice would be appreciated.任何建议或意见将不胜感激。

$(document).ready(function(){

        $("#pass_strength").keyup(function() {

            var strength = 1;

            /*length 5 characters or more*/
            if(this.value.length >= 5) {
                strength++;
            }

            /*contains lowercase characters*/
            if(this.value.match(/[a-z]+/)) {
                strength++;
            }

            /*contains digits*/
            if(this.value.match(/[0-9]+/)) {
                strength++;
            }

            /*contains uppercase characters*/
            if(this.value.match(/[A-Z]+/)) {
                strength++;
            }

            alert(strength);
        });
     });

Answer 12

I'm quite new to jQuery, and I've written a simple function to check the strength of a password for each keypress.我对jQuery很陌生，并且编写了一个简单的函数来检查每个按键的密码强度。

The idea is that every time a user enters a character, the contents is evaluated to test the strengh of the password they have entered... I'm sure everyone has seen these before.这个想法是，每次用户输入一个字符时，都会对内容进行评估，以测试他们输入的密码的强度……我敢肯定，每个人以前都看过这些密码。

Anyhow, the logic I have used is that no password begins with a value of 1. When a lower-case character is used, the score increments to 2. When a digit is used the score increments by 1 again, same for when an uppercase character is used and when the password becomes 5 or more characters long.无论如何，我使用的逻辑是没有密码以1开头。使用小写字符时，分数增加到2。使用数字时，分数再次增加1，与大写相同使用字符，并且密码长度为5个或更多字符时。

What is returned is the strength of the password so far as a value from 1 to 5 every time a key is pressed.每次按键时返回的密码强度为1到5。

So, about my question.所以，关于我的问题。 The way that I've done it doesn't seem very jQuery like... almost like I may as well have just done straight javascript.我完成的方式似乎不像jQuery，...好像我也可以直接编写javascript。 Also I was wondering about my logic.我也想知道我的逻辑。 Have I done anything done or overlooked something?我做过什么事还是忽略了什么？ Any suggestions from smarter people than myself?比我聪明的人有什么建议吗？

Any suggestions or advice would be appreciated.任何建议或意见将不胜感激。

$(document).ready(function(){

        $("#pass_strength").keyup(function() {

            var strength = 1;

            /*length 5 characters or more*/
            if(this.value.length >= 5) {
                strength++;
            }

            /*contains lowercase characters*/
            if(this.value.match(/[a-z]+/)) {
                strength++;
            }

            /*contains digits*/
            if(this.value.match(/[0-9]+/)) {
                strength++;
            }

            /*contains uppercase characters*/
            if(this.value.match(/[A-Z]+/)) {
                strength++;
            }

            alert(strength);
        });
     });

Answer 13

I'm quite new to jQuery, and I've written a simple function to check the strength of a password for each keypress.我对jQuery很陌生，并且编写了一个简单的函数来检查每个按键的密码强度。

The idea is that every time a user enters a character, the contents is evaluated to test the strengh of the password they have entered... I'm sure everyone has seen these before.这个想法是，每次用户输入一个字符时，都会对内容进行评估，以测试他们输入的密码的强度……我敢肯定，每个人以前都看过这些密码。

Anyhow, the logic I have used is that no password begins with a value of 1. When a lower-case character is used, the score increments to 2. When a digit is used the score increments by 1 again, same for when an uppercase character is used and when the password becomes 5 or more characters long.无论如何，我使用的逻辑是没有密码以1开头。使用小写字符时，分数增加到2。使用数字时，分数再次增加1，与大写相同使用字符，并且密码长度为5个或更多字符时。

What is returned is the strength of the password so far as a value from 1 to 5 every time a key is pressed.每次按键时返回的密码强度为1到5。

So, about my question.所以，关于我的问题。 The way that I've done it doesn't seem very jQuery like... almost like I may as well have just done straight javascript.我完成的方式似乎不像jQuery，...好像我也可以直接编写javascript。 Also I was wondering about my logic.我也想知道我的逻辑。 Have I done anything done or overlooked something?我做过什么事还是忽略了什么？ Any suggestions from smarter people than myself?比我聪明的人有什么建议吗？

Any suggestions or advice would be appreciated.任何建议或意见将不胜感激。

$(document).ready(function(){

        $("#pass_strength").keyup(function() {

            var strength = 1;

            /*length 5 characters or more*/
            if(this.value.length >= 5) {
                strength++;
            }

            /*contains lowercase characters*/
            if(this.value.match(/[a-z]+/)) {
                strength++;
            }

            /*contains digits*/
            if(this.value.match(/[0-9]+/)) {
                strength++;
            }

            /*contains uppercase characters*/
            if(this.value.match(/[A-Z]+/)) {
                strength++;
            }

            alert(strength);
        });
     });

Answer 14

I'm quite new to jQuery, and I've written a simple function to check the strength of a password for each keypress.我对jQuery很陌生，并且编写了一个简单的函数来检查每个按键的密码强度。

The idea is that every time a user enters a character, the contents is evaluated to test the strengh of the password they have entered... I'm sure everyone has seen these before.这个想法是，每次用户输入一个字符时，都会对内容进行评估，以测试他们输入的密码的强度……我敢肯定，每个人以前都看过这些密码。

Anyhow, the logic I have used is that no password begins with a value of 1. When a lower-case character is used, the score increments to 2. When a digit is used the score increments by 1 again, same for when an uppercase character is used and when the password becomes 5 or more characters long.无论如何，我使用的逻辑是没有密码以1开头。使用小写字符时，分数增加到2。使用数字时，分数再次增加1，与大写相同使用字符，并且密码长度为5个或更多字符时。

What is returned is the strength of the password so far as a value from 1 to 5 every time a key is pressed.每次按键时返回的密码强度为1到5。

So, about my question.所以，关于我的问题。 The way that I've done it doesn't seem very jQuery like... almost like I may as well have just done straight javascript.我完成的方式似乎不像jQuery，...好像我也可以直接编写javascript。 Also I was wondering about my logic.我也想知道我的逻辑。 Have I done anything done or overlooked something?我做过什么事还是忽略了什么？ Any suggestions from smarter people than myself?比我聪明的人有什么建议吗？

Any suggestions or advice would be appreciated.任何建议或意见将不胜感激。

$(document).ready(function(){

        $("#pass_strength").keyup(function() {

            var strength = 1;

            /*length 5 characters or more*/
            if(this.value.length >= 5) {
                strength++;
            }

            /*contains lowercase characters*/
            if(this.value.match(/[a-z]+/)) {
                strength++;
            }

            /*contains digits*/
            if(this.value.match(/[0-9]+/)) {
                strength++;
            }

            /*contains uppercase characters*/
            if(this.value.match(/[A-Z]+/)) {
                strength++;
            }

            alert(strength);
        });
     });

Answer 15

implementation for scoring based on variation, mess and length:基于变化、混乱和长度进行评分的实现：

function scorePass(pass) {  
    let score = 0;
    
    // variation range
    score += new Set(pass.split("")).size * 1;
    const charCodes = [...new Set(pass.split(''))].map(x=>x.toLowerCase().charCodeAt(0));

    // shuffle score - bonus for messing things up
    for (let i=1; i < charCodes.length;i++)
    {
        const dist = Math.abs(charCodes[i-1]-charCodes[i]);
        if (dist>60)
            score += 15;
        else if (dist>8)
            score += 10;
        else if (dist>1)
            score += 2;
    }
    
    // bonus for length
    score += (pass.length - 6) * 3;

    return parseInt(score);
}

abcעfדg94a > jefPYM583^ > abcABC!@#$ abcעfדg94a > jefPYM583^ > abcABC!@#$

https://codepen.io/oriadam/pen/ExmaoYy https://codepen.io/oriadam/pen/ExmaoYy

jQuery 密码强度检查器

问题描述

15 个解决方案

解决方案1
32 已采纳 2009-09-07 10:47:51

解决方案2
7 2009-09-07 10:32:19

解决方案3
2 2009-09-07 10:39:46

解决方案4
2 2009-09-07 13:41:30

解决方案5
2 2016-09-18 10:24:48

解决方案6
1 2009-09-07 10:26:47

解决方案7
1 2009-09-07 13:38:21

解决方案8
1 2017-12-29 07:34:56

解决方案9
1 2018-06-27 09:27:05

解决方案10
0 2014-06-05 20:06:20

解决方案11
0 2017-02-18 09:36:51

解决方案12
0 2011-01-03 09:55:04

解决方案13
0 2019-05-03 02:44:20

解决方案14
0 2020-12-11 11:11:41

解决方案15
0 2021-06-30 12:25:09

jQuery 密码强度检查器

问题描述

15 个解决方案

解决方案1 32 已采纳 2009-09-07 10:47:51

解决方案2 7 2009-09-07 10:32:19

解决方案3 2 2009-09-07 10:39:46

解决方案4 2 2009-09-07 13:41:30

解决方案5 2 2016-09-18 10:24:48

解决方案6 1 2009-09-07 10:26:47

解决方案7 1 2009-09-07 13:38:21

解决方案8 1 2017-12-29 07:34:56

解决方案9 1 2018-06-27 09:27:05

解决方案10 0 2014-06-05 20:06:20

解决方案11 0 2017-02-18 09:36:51

解决方案12 0 2011-01-03 09:55:04

解决方案13 0 2019-05-03 02:44:20

解决方案14 0 2020-12-11 11:11:41

解决方案15 0 2021-06-30 12:25:09

解决方案1
32 已采纳 2009-09-07 10:47:51

解决方案2
7 2009-09-07 10:32:19

解决方案3
2 2009-09-07 10:39:46

解决方案4
2 2009-09-07 13:41:30

解决方案5
2 2016-09-18 10:24:48

解决方案6
1 2009-09-07 10:26:47

解决方案7
1 2009-09-07 13:38:21

解决方案8
1 2017-12-29 07:34:56

解决方案9
1 2018-06-27 09:27:05

解决方案10
0 2014-06-05 20:06:20

解决方案11
0 2017-02-18 09:36:51

解决方案12
0 2011-01-03 09:55:04

解决方案13
0 2019-05-03 02:44:20

解决方案14
0 2020-12-11 11:11:41

解决方案15
0 2021-06-30 12:25:09