精华内容
下载资源
问答
  • 密码强度校验
    2021-04-26 17:56:42
    package net.wangxiaolong.shopmanager.util;
    
    /**
     * @auther:Wangxl
     * @Emile:18335844494@163.com
     * @Time:2021/4/22 9:32
     */
    public class CheckStrength {
        public enum LEVEL {
            EASY("简单"), MIDIUM("中等"), STRONG("强"), VERY_STRONG("非常强"), EXTREMELY_STRONG("极强");
    
            public String getMessage() {
                return message;
            }
    
            public void setMessage(String message) {
                this.message = message;
            }
    
            private String message;
    
    
            LEVEL(String message) {
                this.message = message;
            }
        }
    
        /**
         * NUM 数字
         * SMALL_LETTER 小写字母
         * CAPITAL_LETTER 大写字母
         * OTHER_CHAR  特殊字符
         */
        private static final int NUM = 1;
        private static final int SMALL_LETTER = 2;
        private static final int CAPITAL_LETTER = 3;
        private static final int OTHER_CHAR = 4;
    
        /**
         * 简单的密码字典
         */
        private final static String[] DICTIONARY = {"password", "abc123", "iloveyou", "adobe123", "123123", "1234567890",
                "1314520", "a1b2c3", "123qwe", "aaa111", "qweasd", "admin", "passwd"};
    
        /**
         *检查字符类型,包括num、大写字母、小写字母和其他字符。
         *
         * @param c
         * @return
         */
        private static int checkCharacterType(char c) {
            if (c >= 48 && c <= 57) {
                return NUM;
            }
            if (c >= 65 && c <= 90) {
                return CAPITAL_LETTER;
            }
            if (c >= 97 && c <= 122) {
                return SMALL_LETTER;
            }
            return OTHER_CHAR;
        }
    
        /**
         * 按不同类型计算密码的数量
         *
         * @param passwd
         * @param type
         * @return
         */
        private static int countLetter(String passwd, int type) {
            int count = 0;
            if (null != passwd && passwd.length() > 0) {
                for (char c : passwd.toCharArray()) {
                    if (checkCharacterType(c) == type) {
                        count++;
                    }
                }
            }
            return count;
        }
    
        /**
         * 检查密码的强度
         *
         * @param passwd
         * @return strength level
         */
        public static int checkPasswordStrength(String passwd) {
            if (StringUtils.equalsNull(passwd)) {
                throw new IllegalArgumentException("password is empty");
            }
            int len = passwd.length();
            int level = 0;
    
            // 增加点
            //判断密码是否含有数字有level++
            if (countLetter(passwd, NUM) > 0) {
                level++;
            }
            //判断密码是否含有小写字母有level++
            if (countLetter(passwd, SMALL_LETTER) > 0) {
                level++;
            }
            //判断密码是否还有大写字母有level++
            if (len > 4 && countLetter(passwd, CAPITAL_LETTER) > 0) {
                level++;
            }
            //判断密码是否还有特殊字符有level++
            if (len > 6 && countLetter(passwd, OTHER_CHAR) > 0) {
                level++;
            }
            //密码长度大于4并且2种类型组合......(不一一概述)
            if (len > 4 && countLetter(passwd, NUM) > 0 && countLetter(passwd, SMALL_LETTER) > 0
                    || countLetter(passwd, NUM) > 0 && countLetter(passwd, CAPITAL_LETTER) > 0
                    || countLetter(passwd, NUM) > 0 && countLetter(passwd, OTHER_CHAR) > 0
                    || countLetter(passwd, SMALL_LETTER) > 0 && countLetter(passwd, CAPITAL_LETTER) > 0
                    || countLetter(passwd, SMALL_LETTER) > 0 && countLetter(passwd, OTHER_CHAR) > 0
                    || countLetter(passwd, CAPITAL_LETTER) > 0 && countLetter(passwd, OTHER_CHAR) > 0) {
                level++;
            }
            //密码长度大于6并且3中类型组合......(不一一概述)
            if (len > 6 && countLetter(passwd, NUM) > 0 && countLetter(passwd, SMALL_LETTER) > 0
                    && countLetter(passwd, CAPITAL_LETTER) > 0 || countLetter(passwd, NUM) > 0
                    && countLetter(passwd, SMALL_LETTER) > 0 && countLetter(passwd, OTHER_CHAR) > 0
                    || countLetter(passwd, NUM) > 0 && countLetter(passwd, CAPITAL_LETTER) > 0
                    && countLetter(passwd, OTHER_CHAR) > 0 || countLetter(passwd, SMALL_LETTER) > 0
                    && countLetter(passwd, CAPITAL_LETTER) > 0 && countLetter(passwd, OTHER_CHAR) > 0) {
                level++;
            }
            //密码长度大于8并且4种类型组合......(不一一概述)
            if (len > 8 && countLetter(passwd, NUM) > 0 && countLetter(passwd, SMALL_LETTER) > 0
                    && countLetter(passwd, CAPITAL_LETTER) > 0 && countLetter(passwd, OTHER_CHAR) > 0) {
                level++;
            }
            //密码长度大于6并且2种类型组合每种类型长度大于等于3或者2......(不一一概述)
            if (len > 6 && countLetter(passwd, NUM) >= 3 && countLetter(passwd, SMALL_LETTER) >= 3
                    || countLetter(passwd, NUM) >= 3 && countLetter(passwd, CAPITAL_LETTER) >= 3
                    || countLetter(passwd, NUM) >= 3 && countLetter(passwd, OTHER_CHAR) >= 2
                    || countLetter(passwd, SMALL_LETTER) >= 3 && countLetter(passwd, CAPITAL_LETTER) >= 3
                    || countLetter(passwd, SMALL_LETTER) >= 3 && countLetter(passwd, OTHER_CHAR) >= 2
                    || countLetter(passwd, CAPITAL_LETTER) >= 3 && countLetter(passwd, OTHER_CHAR) >= 2) {
                level++;
            }
            //密码长度大于8并且3种类型组合每种类型长度大于等于3或者2......(不一一概述)
            if (len > 8 && countLetter(passwd, NUM) >= 2 && countLetter(passwd, SMALL_LETTER) >= 2
                    && countLetter(passwd, CAPITAL_LETTER) >= 2 || countLetter(passwd, NUM) >= 2
                    && countLetter(passwd, SMALL_LETTER) >= 2 && countLetter(passwd, OTHER_CHAR) >= 2
                    || countLetter(passwd, NUM) >= 2 && countLetter(passwd, CAPITAL_LETTER) >= 2
                    && countLetter(passwd, OTHER_CHAR) >= 2 || countLetter(passwd, SMALL_LETTER) >= 2
                    && countLetter(passwd, CAPITAL_LETTER) >= 2 && countLetter(passwd, OTHER_CHAR) >= 2) {
                level++;
            }
            //密码长度大于10并且4种类型组合每种类型长度大于等于2......(不一一概述)
            if (len > 10 && countLetter(passwd, NUM) >= 2 && countLetter(passwd, SMALL_LETTER) >= 2
                    && countLetter(passwd, CAPITAL_LETTER) >= 2 && countLetter(passwd, OTHER_CHAR) >= 2) {
                level++;
            }
            //特殊字符>=3 level++;
            if (countLetter(passwd, OTHER_CHAR) >= 3) {
                level++;
            }
            //特殊字符>=6 level++;
            if (countLetter(passwd, OTHER_CHAR) >= 6) {
                level++;
            }
            //长度>12 >16 level++
            if (len > 12) {
                level++;
                if (len >= 16) {
                    level++;
                }
            }
    
            // 减少点
            if ("abcdefghijklmnopqrstuvwxyz".indexOf(passwd) > 0 || "ABCDEFGHIJKLMNOPQRSTUVWXYZ".indexOf(passwd) > 0) {
                level--;
            }
            if ("qwertyuiop".indexOf(passwd) > 0 || "asdfghjkl".indexOf(passwd) > 0 || "zxcvbnm".indexOf(passwd) > 0) {
                level--;
            }
            if (StringUtils.isNumeric(passwd) && ("01234567890".indexOf(passwd) > 0 || "09876543210".indexOf(passwd) > 0)) {
                level--;
            }
    
            if (countLetter(passwd, NUM) == len || countLetter(passwd, SMALL_LETTER) == len
                    || countLetter(passwd, CAPITAL_LETTER) == len) {
                level--;
            }
    
            if (len % 2 == 0) { // aaabbb
                String part1 = passwd.substring(0, len / 2);
                String part2 = passwd.substring(len / 2);
                if (part1.equals(part2)) {
                    level--;
                }
                if (StringUtils.isCharEqual(part1) && StringUtils.isCharEqual(part2)) {
                    level--;
                }
            }
            if (len % 3 == 0) { // ababab
                String part1 = passwd.substring(0, len / 3);
                String part2 = passwd.substring(len / 3, len / 3 * 2);
                String part3 = passwd.substring(len / 3 * 2);
                if (part1.equals(part2) && part2.equals(part3)) {
                    level--;
                }
            }
    
            if (StringUtils.isNumeric(passwd) && len >= 6) { // 19881010 or 881010
                int year = 0;
                if (len == 8 || len == 6) {
                    year = Integer.parseInt(passwd.substring(0, len - 4));
                }
                int size = StringUtils.sizeOfInt(year);
                int month = Integer.parseInt(passwd.substring(size, size + 2));
                int day = Integer.parseInt(passwd.substring(size + 2, len));
                if (year >= 1950 && year < 2050 && month >= 1 && month <= 12 && day >= 1 && day <= 31) {
                    level--;
                }
            }
    
            if (null != DICTIONARY && DICTIONARY.length > 0) {// dictionary
                for (int i = 0; i < DICTIONARY.length; i++) {
                    if (passwd.equals(DICTIONARY[i]) || DICTIONARY[i].indexOf(passwd) >= 0) {
                        level--;
                        break;
                    }
                }
            }
    
            if (len <= 6) {
                level--;
                if (len <= 4) {
                    level--;
                    if (len <= 3) {
                        level = 0;
                    }
                }
            }
    
            if (StringUtils.isCharEqual(passwd)) {
                level = 0;
            }
    
            if (level < 0) {
                level = 0;
            }
    
            return level;
        }
    
        /**
         *获得密码强度等级,包括简单、复杂、强、强、强
         *
         * @param passwd
         * @return
         */
        public static LEVEL getPasswordLevel(String passwd) {
            int level = checkPasswordStrength(passwd);
            switch (level) {
                case 0:
                case 1:
                case 2:
                case 3:
                    return LEVEL.EASY;
                case 4:
                case 5:
                case 6:
                    return LEVEL.MIDIUM;
                case 7:
                case 8:
                case 9:
                    return LEVEL.STRONG;
                case 10:
                case 11:
                case 12:
                    return LEVEL.VERY_STRONG;
                default:
                    return LEVEL.EXTREMELY_STRONG;
            }
        }
    }
    

    StringUtils工具类

    package net.wangxiaolong.shopmanager.util;
    
    /**
     * @auther:Wangxl
     * @Emile:18335844494@163.com
     * @Time:2021/4/22 9:33
     */
    public class StringUtils {
    
    
        private final static int[] SIZE_TABLE = {9, 99, 999, 9999, 99999, 999999, 9999999, 99999999, 999999999,
                Integer.MAX_VALUE};
    
        /**
         * 计算一个整数的大小
         *
         * @param x
         * @return
         */
        public static int sizeOfInt(int x) {
            for (int i = 0; ; i++)
                if (x <= SIZE_TABLE[i]) {
                    return i + 1;
                }
        }
    
        /**
         * 判断字符串的每个字符是否相等
         *
         * @param str
         * @return
         */
        public static boolean isCharEqual(String str) {
            return str.replace(str.charAt(0), ' ').trim().length() == 0;
        }
    
        /**
         * 确定字符串是否为数字
         *
         * @param str
         * @return
         */
        public static boolean isNumeric(String str) {
            for (int i = str.length(); --i >= 0; ) {
                if (!Character.isDigit(str.charAt(i))) {
                    return false;
                }
            }
            return true;
        }
    
        /**
         * 判断字符串是否为空格、空(“)”或null。
         *
         * @param str
         * @return
         */
        public static boolean equalsNull(String str) {
            int strLen;
            if (str == null || (strLen = str.length()) == 0 || str.equalsIgnoreCase("null")) {
                return true;
            }
            for (int i = 0; i < strLen; i++) {
                if ((Character.isWhitespace(str.charAt(i)) == false)) {
                    return false;
                }
            }
            return true;
        }
    
    }
    
    

    测试

    package net.wangxiaolong.shopmanager.controller;
    
    import net.wangxiaolong.shopmanager.util.CheckStrength;
    
    /**
     * @auther:Wangxl
     * @Emile:18335844494@163.com
     * @Time:2021/4/22 9:33
     */
    public class TestPass {
    
        public static void main(String[] args) {
            String passwd = "Wangxl4494!@#";
            String message = CheckStrength.getPasswordLevel(passwd).getMessage();
            System.out.println(message);
        }
    
    }
    
    更多相关内容
  • jquery密码强度校验

    2020-10-23 05:45:46
    主要介绍了jquery密码强度校验,这是一个非常常见的功能,在输入密码的时候提示密码的强度,本文使用jQuery来实现,有需要的小伙伴可以参考下。
  • js密码强度校验

    2021-01-21 11:24:52
    现在很多论坛和博客都在用户注册时添加了验证密码强度的功能,在以前的文章中,我们曾经给出过一段检验密码强度的例子,今天再看一个与《js密码强度校验》的代码。 效果: <html> <head> [removed] //...
  • 前台jquery实现密码强度校验,防止密码强度太弱,java防止jquery验证被跳过,实现同原理的密码重复校验
  • 密码强度校验

    2022-02-09 13:23:31
    密码强度校验改造 背景 ​ 由于对项目中用户的密码级别有一定要求,所以需要对用户的密码强度基于一定的校验,方便在重置密码时可以引导用户使用强度偏大的密码,以此为背景展开改造工作。 ​ 由于是对页面的改造,...

    密码强度校验改造

    背景

    ​ 由于对项目中用户的密码级别有一定要求,所以需要对用户的密码强度基于一定的校验,方便在重置密码时可以引导用户使用强度偏大的密码,以此为背景展开改造工作。

    ​ 由于是对页面的改造,且涉及到多个项目,需要尽可能的改动少量文件,以下为实施过程。

    Demo搭建

    <!DOCTYPE html>
    <html>
    <head>
        <meta charset="utf-8">
        <title>密码强度检测算法分析及实现-zxcvbn示例</title>
    </head>
    <style>
        .container > * {
            width: 200px;
        }
        .bar {
            margin: 5px 0 3px;
            border: 2px solid #ccc;
            overflow: hidden;
        }
        .bar > span {
            display: block;
            height: 20px;
            width: 1%;
            background-color: green;
        }
    </style>
    <body>
    <div class="container">
      <h1>请输入密码:</h1>
        <input id ="pwd" type="text" maxlength="32"  />
        <div class="bar">
            <span id="rate"></span>
        </div>
        <span id="score">0</span>
    </div>
    <script src="https://cdn.bootcss.com/zxcvbn/4.4.2/zxcvbn.js"></script>
    <script>
        document.addEventListener('DOMContentLoaded', function () {
            var pwd = document.getElementById("pwd");
            pwd.addEventListener("keyup",function () {
                var result = zxcvbn(pwd.value);
                document.getElementById("score").innerHTML = "评分:"+result['score']*100.0 / 4;
                document.getElementById("rate").style.width = (result['score']*100.0 / 4)+"%";
            });
        });
    </script>
    </body>
    </html>
    

    上述代码可保存为HTML文件,直接运行;下面我们按照demo,将其集成到项目中去,由于项目框架使用的是若依,其他项目框架可参考调整,主要逻辑没变。

    步骤

    若依项目中,存在两处可以修改代码,分别为右上角头像hover中的个人中心和修改密码,操作方式相同,可参考一下步骤。

    第一步:添加响应的HTML,用于显示强度信息

    <input name="strength" id="strength" type="hidden"/>
    <div class="form-group">
        <label class="col-sm-3 control-label">密码强度:</label>
        <div class="col-sm-8">
            <div style="border: 2px solid #ccc;overflow: hidden;">
                <span id="rate"
                      style="display: block;height: 20px;width: 0%;background-color: green;"></span>
            </div>
            <span id="score"></span>
        </div>
    </div>
    

    若依项目可以直接复制该代码块,放置到新密码所在的DIV之后即可;除此之外,还需声明一个隐藏字段,放置强度等级,用于最终的表单校验。

    第二步:添加核心的校验逻辑

        <script src="https://cdn.bootcss.com/zxcvbn/4.4.2/zxcvbn.js"></script>
        <script>
            $(document).ready(function () {
                jQuery.validator.addMethod("strengthLev", function (value, element, param) {
                    return $("#strength").val() > param;
                });
                var pwd = $("#newPassword");
                var colorList = ["red", "orange", "yellow", "blue", "green"];
                var strengthList = ["非常弱", "弱", "一般", "强", "非常强"];
                pwd.keyup(function () {
                    var result = zxcvbn(pwd.val());
                    var level = result['score'];
                    $("#score").html(strengthList[level]);
                    $("#rate").css({
                        "width": (level * 100.0 / 4) + "%",
                        "background-color": colorList[level]
                    });
                    $("#strength").val(level);
                });
            });
        </script>
    

    上述代码和demo相比,使用了JQ的方式并且优化了等级和颜色的显示;初次之外,还增加了自定的校验器用于表单校验,下一步做说明

    第三步:添加表单校验逻辑

    有了强度的提示,还需要满足对应的强度才能修改密码。

    对应的校验rules中添加对应的strengthLev等级

    newPassword: {
        required: true,
            minlength: 5,
                maxlength: 20,
                    strengthLev: 2
    },
    

    并在对应的message中添加提示信息

    newPassword: {
        required: "请输入新密码",
            minlength: "密码不能小于6个字符",
                maxlength: "密码不能大于20个字符",
                    strengthLev: "密码强度不足,请重新输入!"
    }
    

    备注

    • 附效果图
      在这里插入图片描述
    展开全文
  • 本文实例为大家分享了python实现密码强度校验的具体代码,供大家参考,具体内容如下 一 校验规则 规则1 密码长度8位以上 规则2 密码需包含数字 规则3 密码需包含大小写字母 规则4 密码需包含特殊字符[‘+’, ‘-‘, ...
  • 为了保证网站个人信息的安全,很多网站在注册页面都设置密码强度这项,用javascript如何实现密码强度校验代码呢?下面小编给大家整理了两种方法使用javascript密码强度校验代码,有需要的朋友可以参考下
  • 密码强度有4个状态,分别如下图。 无密码状态 密码低级状态 密码中级状态 密码高级状态 实现的代码主要如下: HTML代码 <input name=password type=PassWord onKeyUp=CheckIntensity(this.value)> ...
  • 最近在做一个通行证的项目,在项目中有这样的需求,注册模块中输入密码需要显示密码强度,今天小编给大家分享JS 密码强度校验的正则表达式,简单好用,需要的朋友参考下
  • 主要介绍了Python如何设计密码强度校验程序,文中讲解非常细致,代码帮助大家更好的理解和学习,感兴趣的朋友可以了解下
  • 密码强度校验例子

    热门讨论 2012-11-29 11:45:39
    密码强度校验 模仿很多网站上的密码强度校验,基于jquery插件写的密码强度校验,将密码等级分为三级,纯字符或数字或特殊字符 达到一定位数 具体可以看下例子
  • vue实现密码强度校验

    千次阅读 2022-06-09 17:35:40
    vue实现密码强度校验

    一、前言

    在使用el-form的过程中会遇到密码修改的时候,此时需要对密码强度进行校验,本篇文章主要使用正则来对密码强度进行校验

    二、需求

    设置密码要求:8~16位,数字、字母和符号,三种选一种为弱模式,选两种为中模式,选三种为强模式

    三、具体代码

    html部分

    <el-form ref="psdform" :model="form" :rules="rules" label-width="120px">
          <el-form-item label="新密码:" prop="newPassword">
            <el-input
              :type="newPsdtype"
              v-model="form.newPassword"
              placeholder="8-16位密码,区分大小写"
            >
              <span slot="suffix" class="show_pwd" @click="showPwd">
                <svg-icon
                  :icon-class="newPsdtype == 'password' ? 'eye' : 'eye-open'"
                />
              </span>
            </el-input>
    
            <div class="intensity">
              <span class="psdText">密码强度</span>
              <span
                class="line"
                :class="[level.includes('low') ? 'low' : '']"
              ></span>
              <span
                class="line"
                :class="[level.includes('middle') ? 'middle' : '']"
              ></span>
              <span
                class="line"
                :class="[level.includes('high') ? 'high' : '']"
              ></span>
              <div class="warningtext">
                密码应由8-16位数字、字母、符号组成。请不要使用容易被猜到的密码
              </div>
            </div>
          </el-form-item>
          <el-form-item label="确认密码:" prop="confirmPassword">
            <el-input
              :type="confirmPsdtype"
              v-model="form.confirmPassword"
              placeholder="确认密码"
            >
              <span slot="suffix" class="show_pwd" @click="showconfirmPwd">
                <svg-icon
                  :icon-class="confirmPsdtype == 'password' ? 'eye' : 'eye-open'"
                /> </span
            ></el-input>
          </el-form-item>
    <el-form>
    

    js部分

    data() {
        return {
          form: {
            newPassword: '',
            confirmPassword: ''
          },
          rules: {
            newPassword: [
              { required: true, validator: this.checkPassword, trigger: 'change' }
            ],
            confirmPassword: [
              {
                required: true,
                validator: this.checkConfirmPassword,
                trigger: 'blur'
              }
            ],
          },
          level: []
        }
      },
      methods: {
        //点击小眼睛
        showPwd() {
          if (this.newPsdtype === 'password') {
            this.newPsdtype = ''
          } else {
            this.newPsdtype = 'password'
          }
        },
        //点击小眼睛
        showconfirmPwd() {
          if (this.confirmPsdtype === 'password') {
            this.confirmPsdtype = ''
          } else {
            this.confirmPsdtype = 'password'
          }
        },
        // 校验密码
        checkPassword(rule, value, callback) {
          this.level = []
          if (!value) {
            return callback('密码不能为空')
          }
          if (value.length < 8) {
            return callback('密码不少于8位')
          }
          if (value.length > 16) {
            return callback('密码不大于16位')
          }
          // 校验是数字
          const regex1 = /^\d+$/
          // 校验字母
          const regex2 = /^[A-Za-z]+$/
          // 校验符号
          const regex3 =
            /^[`~!@#$%^&*()_\-+=<>?:"{}|,.\/;'\\[\]·~!@#¥%……&*()——\-+={}|《》?:“”【】、;‘',。、]+$/
          if (regex1.test(value)) {
            this.level.push('low')
          } else if (regex2.test(value)) {
            this.level.push('low')
          } else if (regex3.test(value)) {
            this.level.push('low')
          } else if (/^[A-Za-z\d]+$/.test(value)) {
            this.level.push('low')
            this.level.push('middle')
          } else if (
            /^[`~!@#$%^&*()_\-+=<>?:"{}|,.\/;'\\[\]·~!@#¥%……&*()——\-+={}|《》?:“”【】、;‘',。、\d]+$/.test(
              value
            )
          ) {
            this.level.push('low')
            this.level.push('middle')
          } else if (
            /^[`~!@#$%^&*()_\-+=<>?:"{}|,.\/;'\\[\]·~!@#¥%……&*()——\-+={}|《》?:“”【】、;‘',。、A-Za-z]+$/.test(
              value
            )
          ) {
            this.level.push('low')
            this.level.push('middle')
          } else if (
            /^[`~!@#$%^&*()_\-+=<>?:"{}|,.\/;'\\[\]·~!@#¥%……&*()——\-+={}|《》?:“”【】、;‘',。、A-Za-z\d]+$/.test(
              value
            )
          ) {
            this.level.push('low')
            this.level.push('middle')
            this.level.push('high')
          }
          return callback()
        },
        // 确认密码
        checkConfirmPassword(rule, value, callback) {
          if (!value) {
            return callback('请输入确认密码')
          }
          if (value != this.form.newPassword) {
            return callback('两次密码输入不一致,请重新输入')
          }
        },
    

    css部分

    .show_pwd {
      cursor: pointer;
      user-select: none;
      padding-right: 5px;
    }
    .intensity {
      .psdText {
        font-size: 14px;
        margin-right: 10px;
      }
      .line {
        display: inline-block;
        width: 48px;
        height: 4px;
        background: #d8d8d8;
        border-radius: 3px;
        margin-right: 8px;
        &.low {
          background: #f4664a;
        }
        &.middle {
          background: #ffb700;
        }
        &.high {
          background: #2cbb79;
        }
      }
      .level {
        margin: 0 16px 0 8px;
      }
      .warningtext {
        color: #5a5a5a;
        font-size: 12px;
        margin-top: 5px;
      }
    }
    

    四、实现效果

    以上代码是使用三种颜色来判断密码强度,具体效果如下
    在这里插入图片描述

    五、尾声

    上面图片分别演示了不同情况下的密码强度判断,并未演示长度校验,但功能已经实现,可自行验证

    展开全文
  • 主要为大家详细介绍了javascrpt密码强度校验函数,文中示例代码介绍的非常详细,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 【go-zero】regexp2 如何保证前后端密码强度校验一致 go密码强度校验规则 go正则表达式 正则表达式校验密码强度 go-zero框架common公共库(服务)

    一、场景

    1、前后端统一的强度校验

    当我们需要对密码进行强度校验时,不能单独的在前端或后端控制,为了统一前后端的校验规则,最佳方案是使用同一套的正则表达式去校验输入的内容

    密码强度必须为字⺟⼤⼩写+数字+符号 正则表达式如下:

    ^(?=.*?[A-Z])(?=(.*[a-z]){1,})(?=(.*[\d]){1,})(?=(.*[\W]){1,})(?!.*\s).{6,16}$
    

    我则必须保证前后端一致,才能让需要校验的数据可以通过,最后保存到数据库中

    二、common公共库

    这里我们使用的go-zero微服务架构
    当然你也可以直接将此方法写到代码中

    1、创建公共方法 passwordValidate

    • 创建文件夹:passwordValidate
    • 创建验证文件:passwordValidate.go

    在这里插入图片描述

    2、正则校验方法库

    推荐使用的类库:https://github.com/dlclark/regexp2

    这里我们的需求是校验 密码强度必须为字⺟⼤⼩写+数字+符号,6位以上
    对应的代码如下:

    package passwordvalidate
    
    import (
    	"github.com/dlclark/regexp2"
    )
    
    // CheckPasswordLever 密码强度必须为字⺟⼤⼩写+数字+符号,6位以上
    func CheckPasswordLever(ps string) bool {
    	if len(ps) < 6 {
    		//return fmt.Errorf("password len is < 7")
    		return false
    	}
    
    	// 配置规则 (最后参数给0)
    	re := regexp2.MustCompile(`^(?=.*?[A-Z])(?=(.*[a-z]){1,})(?=(.*[\d]){1,})(?=(.*[\W]){1,})(?!.*\s).{6,16}$`, 0)
    	if flag, err := re.MatchString(ps); !flag || err != nil {
    		return false
    	}
    
    	return true
    }
    
    
    展开全文
  • 1.密码要求有 数字、大写字母、小写字母 特殊字符 任选3种 的组合, 密码最小长度最少要求有8位,最大20位 2. 新密码中不能够包含帐户。 3.密码中不能包含有连续四位及以上顺序(或逆序)数字(如:密码中不能包含1234或...
  • <... 密码强度检测 </title> <meta http-equiv="Content-Type" content="text/html; charset=utf-8"> <style type="text/css"> input { float: left; font-size: 14px; .
  • 网上有很多关于JS常用正则表达式的文章很全但今天为大家分享一些最新,且非常有用的正则表达式其中有密码强度校验,金额校验,IE版本,IPv4,IPv6校验等
  • vue密码强度校验

    千次阅读 多人点赞 2019-08-19 13:21:52
    vue密码强度校验 可直接复制使用,根据自己所需再更改! <template> <div class="container"> <label style="margin-left:40px;">密码:</label> <input v-model="pwdee" id="inputValue...
  • jQuery密码强度校验

    2021-06-01 19:42:38
    jQuery密码强度校验

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 10,289
精华内容 4,115
关键字:

密码强度校验