检查和验证的js方法封装（手机，身份证，IPv4，IPv6、邮箱、URL等）

最新推荐文章于 2021-09-08 14:24:50 发布
最新推荐文章于 2021-09-08 14:24:50 发布
阅读量4k 收藏 5
点赞数
文章标签： 手机 url string function whitespace date

/**
*
* 项目名称     :JiaZheng_SNS
* 子系统名称   :检查和验证
* 对象名称     :CheckAndValidator
* 功能概要     :数据、对象、内容合法性检查和验证的方法封装
*
* 创建者       :放下    2008/11/01    Ver 1.0
* 修改历史     :修改者    yyyy/mm/dd    Ver x.x    修改的内容
*
* Copyright(c) 2009 jiazheng Corporation., All rights reserved
*/

JIAZHENG.SNS.CheckAndValidator = function() {
    ///    <summary>
    ///        检查和验证类的构造器
    ///    </summary>
    ///    <returns type="Object">检查和验证类引用</returns>
};

JIAZHENG.SNS.CheckAndValidator.prototype = {
    f_check_integer: function(value) {
        ///    <summary>
        ///    判断是否为整数，是则返回true，否则返回false
        ///    </summary>
        ///    <param name="value" type="String">
        ///    需要判断的值 字符串类型
        ///    </param>
        ///    <returns type="bool">true 是整数，false 不是整数</returns>
        if (/^(/+|-)?/d+$/.test(value)) {
            return true;
        }
        else {
            return false;
        }
    },

    f_check_float: function(value) {
        ///    <summary>
        ///    判断是否为实数，是则返回true，否则返回false
        ///    </summary>
        ///    <param name="value" type="String">
        ///    需要判断的值 字符串类型
        ///    </param>
        ///    <returns type="bool"></returns>
        if (/^(/+|-)?/d+($|/./d+$)/.test(value)) {
            return true;
        }
        else {
            return false;
        }
    },

    f_check_zh: function(value) {
        ///    <summary>
        ///    检查输入字符串是否只由汉字组成，如果通过验证返回true,否则返回false
        ///    </summary>
        ///    <param name="value" type="String">
        ///    需要判断的值 字符串类型
        ///    </param>
        ///    <returns type="bool"></returns>
        if (/^[/u4e00-/u9fa5]+$/.test(value)) {
            return true;
        }
        return false;
    },

    f_check_lowercase: function(value) {
        ///    <summary>
        ///    判断是否为小写英文字母，是则返回true，否则返回false
        ///    </summary>
        ///    <param name="value" type="String">
        ///    需要判断的值 字符串类型
        ///    </param>
        ///    <returns type="bool"></returns>
        if (/^[a-z]+$/.test(value)) {
            return true;
        }
        return false;
    },

    f_check_uppercase: function(value) {
        ///    <summary>
        ///    判断是否为大写英文字母，是则返回true，否则返回false
        ///    </summary>
        ///    <param name="value" type="String">
        ///    需要判断的值 字符串类型
        ///    </param>
        ///    <returns type="bool"></returns>
        if (/^[A-Z]+$/.test(value)) {
            return true;
        }
        return false;
    },

    f_check_letter: function(value) {
        ///    <summary>
        ///    判断是否为英文字母，是则返回true，否则返回false
        ///    </summary>
        ///    <param name="value" type="String">
        ///    需要判断的值 字符串类型
        ///    </param>
        ///    <returns type="bool"></returns>
        if (/^[A-Za-z]+$/.test(value)) {
            return true;
        }
        return false;
    },

    f_check_ZhOrNumOrLett: function(value) {
        ///    <summary>
        ///    检查输入字符串是否只由汉字、字母、数字组成，是则返回true，否则返回false
        ///    </summary>
        ///    <param name="value" type="String">
        ///    需要判断的值 字符串类型
        ///    </param>
        ///    <returns type="bool"></returns>
        var strRegex = "^[0-9a-zA-Z/u4e00-/u9fa5]+$";
        var re = new RegExp(strRegex);
        if (re.test(value)) {
            return true;
        }
        return false;
    },

    f_check_IPv4: function(value) {
        ///    <summary>
        ///    校验ip地址的格式是否正确，是则返回true，否则返回false
        ///    </summary>
        ///    <param name="value" type="String">
        ///    需要判断的IPv4地址 字符串类型
        ///    </param>
        ///    <returns type="bool"></returns>
        var re = /^(/d+)/.(/d+)/.(/d+)/.(/d+)$/; //匹配IP地址的正则表达式
        if (re.test(value)) {
            if (RegExp.$1 < 256 && RegExp.$2 < 256 && RegExp.$3 < 256 && RegExp.$4 < 256) return true;
        }
        return false;
    },

    f_check_IPv6: function(value) {
        ///    <summary>
        ///    校验ip地址是否为IPv6格式，是则返回true，否则返回false
        ///    </summary>
        ///    <param name="value" type="String">
        ///    需要判断的IPv6地址 字符串类型
        ///    </param>
        ///    <returns type="bool"></returns>
        var result = false;
        var regHex = "(//p{XDigit}{1,4})";
        var regIPv6Full = "^(" + regHex + ":){7}" + regHex + "$";
        var regIPv6AbWithColon = "^(" + regHex + "(:|::)){0,6}" + regHex + "$";
        var regIPv6AbStartWithDoubleColon = "^(" + "::(" + regHex + ":){0,5}" + regHex + ")$";
        var regIPv6 = "^(" + regIPv6Full + ")|(" + regIPv6AbStartWithDoubleColon + ")|(" + regIPv6AbWithColon + ")$";
        if (value.indexOf( ":") != -1) {
            if (value.length() <= 39) {
                var addressTemp = value;
                var doubleColon = 0;
                while (addressTemp.indexOf( "::") != -1) {
                    addressTemp = addressTemp.substring(addressTemp.indexOf( "::") + 2, addressTemp.length());
                    doubleColon++;
                }
                if (doubleColon <= 1) {
                    var re = new RegExp(regIPv6);
                    result = re.test(address);
                }
            }
        }
        return result;
    },

    f_check_port: function(value) {
        ///    <summary>
        ///    检查输入的值是否符合合法的计算机IP地址端口号格式，是则返回true，否则返回false
        ///    </summary>
        ///    <param name="value" type="String">
        ///    需要判断的端口号 字符串类型
        ///    </param>
        ///    <returns type="bool"></returns>
        if (! this.f_check_number(value))
            return false;
        if (value < 65536)
            return true;
        return false;
    },

    f_check_URL: function(value) {
        ///    <summary>
        ///    检查输入的值是否符合合法的计算机网址格式，是则返回true，否则返回false
        ///    </summary>
        ///    <param name="value" type="String">
        ///    需要判断的地址 字符串类型
        ///    </param>
        ///    <returns type="bool"></returns>
        var strRegex = "^((https|http|ftp|rtsp|mms)?://)"
        + "?(([0-9a-z_!~*'().&=+$%-]+: )?[0-9a-z_!~*'().&=+$%-]+@)?"    //ftp的user@
        + "(([0-9]{1,3}.){3}[0-9]{1,3}"                                 // IP形式的URL- 199.194.52.184
        + "|"                                                           // 允许IP和DOMAIN（域名）
        + "([0-9a-z_!~*'()-]+.)*"                                       // 域名- www.
        + "([0-9a-z][0-9a-z-]{0,61})?[0-9a-z]."                         // 二级域名
        + "[a-z]{2,6})"                                                 // first level domain- .com or .museum
        + "(:[0-9]{1,4})?"                                              // 端口- :80
        + "((/?)|"                                                      // a slash isn't required if there is no file name
        + "(/[0-9a-z_!~*'().;?:@&=+$,%#-]+)+/?)$";
        var myReg = new RegExp(strRegex);
        if (myReg.test(value)) return true;
        return false;
    },

    f_check_email: function(value) {
        ///    <summary>
        ///    检查输入的值是否符合E-Mail格式，是则返回true，否则返回false
        ///    </summary>
        ///    <param name="value" type="String">
        ///    需要判断的E-Mail值 字符串类型
        ///    </param>
        ///    <returns type="bool"></returns>
        var myReg = /^([a-zA-Z0-9]+[_|/_|/.]?)*[a-zA-Z0-9]+@([a-zA-Z0-9]+[_|/_|/.]?)*[a-zA-Z0-9]+/.[a-zA-Z]{2,3}$/;
        if (myReg.test(value)) return true;
        return false;
    },

    f_check_zipcode: function(value) {
        ///    <summary>
        ///    检查输入的值是否符合邮政编码格式，是则返回true，否则返回false
        ///    </summary>
        ///    <param name="value" type="String">
        ///    需要判断的邮政编码 字符串类型
        ///    </param>
        ///    <returns type="bool"></returns>
        if (!f_check_number(value))
            return false;
        if (value.length != 6) {
            return false;
        }
        return true;
    },

    f_check_mobile: function(value) {
        ///    <summary>
        ///    检查输入手机号码是否正确，是则返回true，否则返回false
        ///    一、移动电话号码为11或12位，如果为12位,那么第一位为0
        ///    </summary>
        ///    <param name="value" type="String">
        ///    需要判断的手机号 字符串类型
        ///    </param>
        ///    <returns type="bool"></returns>
        var strRegex = /(^[1][0-9][0-9]{9}$)|(^0[1][0-9][0-9]{9}$)/;
        var re = new RegExp(strRegex);
        if (re.test(value)) {
            return true;
        }
        return false;
    },

    f_check_phone: function(value) {
        ///    <summary>
        ///    检查输入的电话号码格式是否正确，是则返回true，否则返回false
        ///    一、电话号码由数字、"("、")"和"-"构成
        ///    二、电话号码为3到8位
        ///    三、如果电话号码中包含有区号，那么区号为三位或四位
        ///    四、区号用"("、")"或"-"和其他部分隔开
        ///    </summary>
        ///    <param name="value" type="String">
        ///    需要判断的电话号码 字符串类型
        ///    </param>
        ///    <returns type="bool"></returns>
        var strRegex = /(^([0][1-9]{2,3}[-])?/d{3,8}(-/d{1,6})?$)|(^/([0][1-9]{2,3}/)/d{3,8}(/(/d{1,6}/))?$)|(^/d{3,8}$)/;
        var re = new RegExp(strRegex);
        if (re.test(value)) {
            return true;
        }
        return false;
    },

    /*
    用户ID，可以为数字、字母、下划线的组合，
    第一个字符不能为数字,且总长度不能超过20。
    */
    f_check_userID: function(value, len) {
        ///    <summary>
        ///    检查用户ID是否正确，是则返回true，否则返回false
        ///    一、长度不能超过len的数值，不赋值时用户ID总长度默认为20
        ///    二、第一个字符不能为数字
        ///    三、只能为数字、字母、下划线的组合
        ///    </summary>
        ///    <param name="value" type="String">
        ///    需要判断的用户ID 字符串类型
        ///    </param>
        ///    <param name="len" type="Number">
        ///    用户ID允许的长度 数值类型
        ///    </param>
        ///    <returns type="bool"></returns>

        var length = 20; //用户ID总长度默认设置为20
        if (len != null && this.f_check_integer(len)) {
            length = len;
        }
        var userID = value;
        if (userID.length > length) { //ID长度不能大于length
            return false;
        }
        if (!isNaN(userID.charAt(0))) { //ID第一个字符不能为数字
            return false;
        }
        var strRegex = "^([0-9]|[a-zA-Z]|_)*$";
        var re = new RegExp(strRegex);
        if (!re.test(userID)) { //ID只能由数字、字母、下划线组合而成
            return false;
        }
        return true;
    },

    f_check_IDno: function(value) {
        ///    <summary>
        ///    验证身份证号码是否有效
        ///    一、支持15位和18位身份证格式
        ///    二、验证通过则返回字符串“Right”，如果返回值不为“Right”则返回具体错误信息。
        ///    例子：var result = JIAZHENG.SNS.CheckAndValidator.f_check_IDno("452427198705050058");if(result != "Right")alert("错误身份证："+result);
        ///    </summary>
        ///    <param name="value" type="String">
        ///    需要判断的身份证号 字符串类型
        ///    </param>
        ///    <returns type="String"></returns>
        var aCity = { 11: "北京", 12: "天津", 13: "河北", 14: "山西", 15: "内蒙古", 21: "辽宁", 22: "吉林", 23: "黑龙江", 31: "上海", 32: "江苏", 33: "浙江", 34: "安徽", 35: "福建", 36: "江西", 37: "山东", 41: "河南", 42: "湖北", 43: "湖南", 44: "广东", 45: "广西", 46: "海南", 50: "重庆", 51: "四川", 52: "贵州", 53: "云南", 54: "西藏", 61: "陕西", 62: "甘肃", 63: "青海", 64: "宁夏", 65: "新疆", 71: "台湾", 81: "香港", 82: "澳门", 91: "国外" };
        var iSum = 0;
        var info = "";
        var strIDno = value;
        var idCardLength = strIDno.length;
        var result = "Right";

        if (!/^/d{17}(/d|x)$/i.test(strIDno) && !/^/d{15}$/i.test(strIDno)) {
            return result = "非法身份证号";
        }

        //在后面的运算中x相当于数字10,所以转换成a  
        strIDno = strIDno.replace(/x$/i, "a");

        if (aCity[parseInt(strIDno.substr(0, 2))] == null) {
            return result = "非法地区";
        }

        if (idCardLength == 18) {
            sBirthday = strIDno.substr(6, 4) + "-" + Number(strIDno.substr(10, 2)) + "-" + Number(strIDno.substr(12, 2));
            var d = new Date(sBirthday.replace(/-/g, "/"))
            if (sBirthday != (d.getFullYear() + "-" + (d.getMonth() + 1) + "-" + d.getDate())) {
                return result = "非法生日";
            }

            for ( var i = 17; i >= 0; i--)
                iSum += (Math.pow(2, i) % 11) * parseInt(strIDno.charAt(17 - i), 11);

            if (iSum % 11 != 1) {
                return result = "非法身份证号";
            }
        }
        else if (idCardLength == 15) {
            sBirthday = "19" + strIDno.substr(6, 2) + "-" + Number(strIDno.substr(8, 2)) + "-" + Number(strIDno.substr(10, 2));
            var d = new Date(sBirthday.replace(/-/g, "/"))
            var dd = d.getFullYear().toString() + "-" + (d.getMonth() + 1) + "-" + d.getDate();
            if (sBirthday != dd) {
                return result = "非法生日";
            }
        }
        return result;
    },

    f_check_str_match_reg: function(value, regu) {
        ///    <summary>
        ///    判断字符串是否符合指定的正则表达式，是则返回true，否则返回false
        ///    </summary>
        ///    <param name="value" type="String">
        ///    需要判断的字符串 字符串类型
        ///    </param>
        ///    <param name="regu" type="String">
        ///    正则规则字符串 字符串类型
        ///    </param>
        ///    <returns type="bool"></returns>
        var re = new RegExp(regu);
        if (re.test(value))
            return true;
        return false;
    },

    f_ltrim: function(value) {
        ///    <summary>
        ///    去除左边的空格，返回去除左边空格后的字符串
        ///    </summary>
        ///    <param name="value" type="String">
        ///    需要去除左边空格的字符串 字符串类型
        ///    </param>
        ///    <returns type="String"></returns>
        var whitespace = new String( " /t/n/r");
        var s = new String(value);

        if (whitespace.indexOf(s.charAt(0)) != -1) {
            var j = 0, i = s.length;
            while (j < i && whitespace.indexOf(s.charAt(j)) != -1) {
                j++;
            }
            s = s.substring(j, i);
        }
        return s;
    },

    f_rtrim: function(value) {
        ///    <summary>
        ///    去除右边的空格，返回去除右边空格后的字符串
        ///    </summary>
        ///    <param name="value" type="String">
        ///    需要去除右边空格的字符串 字符串类型
        ///    </param>
        ///    <returns type="String"></returns>
        var whitespace = new String( " /t/n/r");
        var s = new String(value);

        if (whitespace.indexOf(s.charAt(s.length - 1)) != -1) {
            var i = s.length - 1;
            while (i >= 0 && whitespace.indexOf(s.charAt(i)) != -1) {
                i--;
            }
            s = s.substring(0, i + 1);
        }
        return s;
    },

    f_trim: function(str) {
        ///    <summary>
        ///    去除字符串两边的空格，返回去除两边空格后的字符串
        ///    </summary>
        ///    <param name="value" type="String">
        ///    需要去除两边空格的字符串 字符串类型
        ///    </param>
        ///    <returns type="String"></returns>
        return RTrim(LTrim(str));
    },

    f_check_date: function(obj, format) {
        ///    <summary>
        ///    判断日期是否与指定格式匹配
        ///    一、format的格式为：yyyy年MM月dd日, yyyy-MM-dd, yyyy/MM/dd, yyyyMMdd
        ///    二、验证通过则返回字符串“Right”，如果返回值不为“Right”则返回具体错误信息。
        ///    例子：var result = JIAZHENG.SNS.CheckAndValidator.f_check_date("2008-01-01");if(result != "Right")alert("错误信息："+result);
        ///    </summary>
        ///    <param name="value" type="String">
        ///    需要判断的日期 字符串类型
        ///    </param>
        ///    <param name="value" type="String">
        ///    匹配的日期格式（yyyy年MM月dd日, yyyy-MM-dd, yyyy/MM/dd, yyyyMMdd） 字符串类型
        ///    </param>
        ///    <returns type="String"></returns>
        var date = this.f_trim(value);
        var year, month, day, datePat, matchArray;
        var result = "Right";

        if (/^(y{4})(-|//)(M{1,2})/2(d{1,2})$/.test(format))
            datePat = /^(/d{4})(-|//)(/d{1,2})/2(/d{1,2})$/;
        else if (/^(y{4})(年)(M{1,2})(月)(d{1,2})(日)$/.test(format))
            datePat = /^(/d{4})年(/d{1,2})月(/d{1,2})日$/;
        else if (format == "yyyyMMdd")
            datePat = /^(/d{4})(/d{2})(/d{2})$/;
        else {
            return result = "日期格式不对";
        }
        matchArray = date.match(datePat);
        if (matchArray == null) {
            return result = "日期长度不对或日期中有非数字符号";
        }
        if (/^(y{4})(-|//)(M{1,2})/2(d{1,2})$/.test(format)) {
            year = matchArray[1];
            month = matchArray[3];
            day = matchArray[4];
        } else {
            year = matchArray[1];
            month = matchArray[2];
            day = matchArray[3];
        }
        if (month < 1 || month > 12) {
            return result = "月份应该为1到12的整数";
        }
        if (day < 1 || day > 31) {
            return result = "每个月的天数应该为1到31的整数";
        }
        if ((month == 4 || month == 6 || month == 9 || month == 11) && day == 31) {
            return result = "该月不存在31号";
        }
        if (month == 2) {
            var isleap = (year % 4 == 0 && (year % 100 != 0 || year % 400 == 0));
            if (day > 29) {
                return result = "2月最多有29天";
            }
            if ((day == 29) && (!isleap)) {
                return result = "闰年2月才有29天";
            }
        }
        return result;
    },

    f_check_time: function(value, format) {
        ///    <summary>
        ///    判断时间是否与指定格式匹配
        ///    一、format的格式为：yyyy年MM月dd日HH时mm分ss秒, yyyy-MM-dd HH:mm:ss, yyyy/MM/dd HH:mm:ss, yyyyMMddHHmmss
        ///    二、验证通过则返回字符串“Right”，如果返回值不为“Right”则返回具体错误信息。
        ///    例子：var result = JIAZHENG.SNS.CheckAndValidator.f_check_time("2008-01-01 12:30:21");if(result != "Right")alert("错误信息："+result);
        ///    </summary>
        ///    <param name="value" type="String">
        ///    需要判断的时间 字符串类型
        ///    </param>
        ///    <param name="value" type="String">
        ///    匹配的时间格式（yyyy年MM月dd日HH时mm分ss秒, yyyy-MM-dd HH:mm:ss, yyyy/MM/dd HH:mm:ss, yyyyMMddHHmmss ） 字符串类型
        ///    </param>
        ///    <returns type="String"></returns>
        var time = this.f_trim(value);
        var datePat, matchArray, year, month, day, hour, minute, second;
        var result = "Right";

        if (/^(y{4})(-|//)(M{1,2})/2(d{1,2}) (HH:mm:ss)$/.test(format))
            datePat = /^(/d{4})(-|//)(/d{1,2})/2(/d{1,2}) (/d{1,2}):(/d{1,2}):(/d{1,2})$/;
        else if (/^(y{4})(年)(M{1,2})(月)(d{1,2})(日)(HH时mm分ss秒)$/.test(format))
            datePat = /^(/d{4})年(/d{1,2})月(/d{1,2})日(/d{1,2})时(/d{1,2})分(/d{1,2})秒$/;
        else if (format == "yyyyMMddHHmmss")
            datePat = /^(/d{4})(/d{2})(/d{2})(/d{2})(/d{2})(/d{2})$/;
        else {
            return result = "日期格式不对";
        }
        matchArray = time.match(datePat);
        if (matchArray == null) {
            return result = "日期长度不对或日期中有非数字符号";
        }
        if (/^(y{4})(-|//)(M{1,2})/2(d{1,2}) (HH:mm:ss)$/.test(format)) {
            year = matchArray[1];
            month = matchArray[3];
            day = matchArray[4];
            hour = matchArray[5];
            minute = matchArray[6];
            second = matchArray[7];
        } else {
            year = matchArray[1];
            month = matchArray[2];
            day = matchArray[3];
            hour = matchArray[4];
            minute = matchArray[5];
            second = matchArray[6];
        }
        if (month < 1 || month > 12) {
            return result = "月份应该为1到12的整数";
        }
        if (day < 1 || day > 31) {
            return result = "每个月的天数应该为1到31的整数";
        }
        if ((month == 4 || month == 6 || month == 9 || month == 11) && day == 31) {
            return result = "该月不存在31号";
        }
        if (month == 2) {
            var isleap = (year % 4 == 0 && (year % 100 != 0 || year % 400 == 0));
            if (day > 29) {
                return result = "2月最多有29天";
            }
            if ((day == 29) && (!isleap)) {
                return result = "闰年2月才有29天";
            }
        }
        if (hour < 0 || hour > 23) {
            return result = "小时应该是0到23的整数";
        }
        if (minute < 0 || minute > 59) {
            return result = "分应该是0到59的整数";
        }
        if (second < 0 || second > 59) {
            return result = "秒应该是0到59的整数";
        }
        return true;
    },

    f_is_visible: function(obj) {
        ///    <summary>
        ///    判断当前DOM对象是否可见，可见则返回true，否则返回false
        ///    </summary>
        ///    <param name="obj" type="DOM Object">
        ///    需要处理的DOM元素 DOM对象
        ///    </param>
        ///    <returns type="bool"></returns>
        var visAtt, disAtt;
        try {
            disAtt = obj.style.display;
            visAtt = obj.style.visibility;
        } catch (e) { }
        if (disAtt == "none" || visAtt == "hidden")
            return false;
        return true;
    },

    f_check_pr_visible: function(obj) {
        ///    <summary>
        ///    判断当前对象及其父对象是否可见，可见则返回true，否则返回false
        ///    </summary>
        ///    <param name="obj" type="DOM Object">
        ///    需要处理的DOM元素 DOM对象
        ///    </param>
        ///    <returns type="bool"></returns>
        var pr = obj.parentNode;
        do {
            if (pr == undefined || pr == "undefined") return true;
            else {
                if (! this.f_is_visible(pr)) return false;
            }
        } while (pr = pr.parentNode);
        return true;
    },

    /**
    * 检测字符串是否为空
    */
    f_is_null: function(str) {
        var i;
        if (str.length == 0)
            return true;
        for (i = 0; i < str.length; i++) {
            if (str.charAt(i) != ' ')
                return false;
        }
        return true;
    },

    f_get_date_by_format: function(str, format) {
        ///    <summary>
        ///    根据日期格式，将字符串转换成Date对象 不正确则返回null，否则返回日期Date对象
        /// 格式：yyyy-MM-dd HH:mm:ss，yyyy-MM-dd
        ///    </summary>
        ///    <param name="str" type="String">
        ///    需要处理的日期字符串 字符串类型
        ///    </param>
        ///    <param name="format" type="String">
        ///    日期格式 默认为：yyyy-MM-dd HH:mm:ss
        ///    </param>
        ///    <returns type="Date?"></returns>
        var dateReg, format;
        var y, M, d, H, m, s, yi, Mi, di, Hi, mi, si;
        if ((arguments[1] + "") == "undefined") format = "yyyy-MM-dd HH:mm:ss";
        else format = arguments[1];
        yi = format.indexOf( "yyyy");
        Mi = format.indexOf( "MM");
        di = format.indexOf( "dd");
        Hi = format.indexOf( "HH");
        mi = format.indexOf( "mm");
        si = format.indexOf( "ss");
        if (yi == -1 || Mi == -1 || di == -1) return null;
        else {
            y = parseInt(str.substring(yi, yi + 4));
            M = parseInt(str.substring(Mi, Mi + 2));
            d = parseInt(str.substring(di, di + 2));
        }
        if (isNaN(y) || isNaN(M) || isNaN(d)) return null;
        if (Hi == -1 || mi == -1 || si == -1) return new Date(y, M - 1, d);
        else {
            H = str.substring(Hi, Hi + 4);
            m = str.substring(mi, mi + 2);
            s = str.substring(si, si + 2);
        }
        if (isNaN(parseInt(y)) || isNaN(parseInt(M)) || isNaN(parseInt(d))) return new Date(y, M - 1, d);
        else return new Date(y, M - 1, d, H, m, s);
    }
};

JIAZHENG.SNS.CheckAndValidator = new JIAZHENG.SNS.CheckAndValidator();
showrock
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
IPv6详解IPv6详解
12-12
IPv6详解IPv6详解IPv6详解IPv6详解IPv6详解IPv6详解IPv6详解IPv6详解IPv6详解IPv6详解IPv6详解IPv6详解
js数据验证集合、js email验证、js url验证、js长度验证、js数字验证等简单封装
12-12
前段时间写了一个 js数据验证、js email验证、js url验证、js长度验证、js数字验证等 弹出对话框形式的但是,现在不太流行那种很不友好的方式,于是重写了一个,封装得更加好的,更友好的层形式共享给大家,如果大家使用...
Js验证身份证是否正确
胖太乙
09-08 1万+
前言 一般情况下，提交数据时， 会对要提交的数据进行各种验证，其他的验证我这里就不讲了， 现在网上有很多， 我要讲的是对身份证的验证， 我看大部分对身份证的验证都是对身份证的位数进行验证（例如15位或者18位）， 这个其实是不太准确地，在一些系统中， 以身份证为唯一标识的话， 身份证错误会造成很大的错误， 所以我们要增加身份证的验证。接下来我们先普及一下我们国家对身份证的产生规则做一下了解。 身份证规则 中华人民共和国居民身份证验证规则如下: 1.号码的结构: 公民身份号码是特征组合码，由十七位数字本体码和
JS正则匹配IPV4 IPV6
夢工場
03-16 5039
bootstrapvalidator 里面的 var ipv4Regex = /^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/, ipv6Regex = /^\s*((([0-9A-Fa-f]{1,4}:){7}([0-9A-Fa-f]{1,4}|
正则(JS)re=new RegExp("^\\d*$");与re=/^\d*$/;之间区别?
10-30
正则(JS)re=new RegExp("^d*$");与re=/^d*$/;之间区别?
阿里云类API.zip 封装类：包括短信验证，oss操作，身份证操作等
09-13
阿里云类Api封装： 1、发送阿里云短信验证码 2、文件上传到阿里云oss上 3、阿里云身份证实名认证 等 附带：苹果内购验证票据api 等
原生js实现文件上传、下载、封装等实例方法
01-21
一 、下载 1、代码 const fileDownloadClick = (obj) => { // 解决兼容 if( document.all ){ obj.click(); } else { let event = document.createEvent(MouseEvents); event.initEvent('click', true, true);...
支持IPv4_IPv6的芯片.docx
11-27
W6100支持TCP、UDP、IPv6、IPv4、ICMPv6、ICMPv4、IGMP、ARP以及PPPoE等协议，同时内部集成了10/100M以太网数据链路层（MAC）以及物理层（PHY），使用户能够更快速地实现嵌入式设备联网功能。 W6100有8个独立硬件...
初步验证身份证是否正确，验证是否为手机号php
廖圣平
07-24 443
function idcard_checksum18($idcard) { if (strlen($idcard) == 15) { $idcard = idcard_15to18($idcard); } if (strlen($idcard) != 18) { return false; } $aCity = array(1
javascript判断IPV6格式
weixin_34405557的博客
07-18 471
随着ipv6的普及，在web上添加ip6地址的要求逐渐增多，下面这个函数是我按照ipv6的定义写的判断，可以用来判断正常的,缩写的ipv6格式，同时可以判断ipv6和ipv4混合的格式：   //统计 10F: 或者:10B的个数   function cLength(str){      var reg = /([0-9a-f]{1,4}:)|(:[0-9a-f]{1,4})/gi;    ...
IPV6正则表达式
rongweiqiao的专栏
09-10 153
^([\da-fA-F]{1,4}:){6}((25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(25[0-5]|2[0-4]\d|[01]?\d\d?)$|^::([\da-fA-F]{1,4}:){0,4}((25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(25[0-5]|2[0-4]\d|[01]?\d\d?)$|^([\da-fA-F]{1,4}:...
js 判断ipv4 ipv6
jiegeng2233的博客
03-02 2851
ipv4地址中间是用点(.)隔开，比如192.168.0.1ipv6地址中间使用冒号(:)隔开，比如80:0:0:0:0:0:0:1用脚本判断就很简单了，有多种方法，var ip;if(ip.indexOf(".")>0){ //ipv4地址}else{ //ipv6地址}
验证IPV4正则表达式
热门推荐
痴人说梦
08-26 2万+
IPV4地址由4个组数字组成，每组数字之间以.分隔，每组数字的取值范围是0-255。 IPV4必须满足以下四条规则： 1、任何一个1位或2位数字，即0-99； 2、任何一个以1开头的3位数字，即100-199； 3、任何一个以2开头、第2位数字是0-4之间的3位数字，即200-249； 4、任何一个以25开头，第3位数字在0-5之间的3位数字，即250-255。   这样把规则全部罗
JS及java验证 IPV6,IPV4地址的 正则表达式
szl的专栏
08-02 8616
JS 验证: ipv4地址验证： function queryDev(ip){var exp=/^(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])\.(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])\.(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])\.(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])$/;var flag =
js IPV 4 IPV6 校验 正则表达式
大白的博客
11-08 4921
百度了很多正则表达式，很多都不准确，或者不全面，下边是实验很多个正则之后，选用的一个非常准确的正则 IPV4 地址校验的正则表达式： /^(([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])\.){3}([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])$/ IPV6 地址校验的正则表达式： /^\...
ipv4 ipv6
最新发布
08-21
IPv4和IPv6是用来标识连接到Internet的设备的地址。它们在原理上相同，都用于唯一地标识网络设备。然而，它们在工作方式上有一些区别。首先，IPv4使用32位地址，而IPv6使用128位地址，因此IPv6具有更大的地址空间。这意味着IPv6可以为更多的设备提供唯一的地址，并且可以支持更多的互联网连接。其次，IPv6引入了新的特性和协议，例如IPsec（用于网络安全）和Anycast（用于负载均衡和冗余性），这些特性在IPv4中是不可用的。另外，IPv6还支持更高的性能，例如更快的路由和更少的延迟。 在实际应用中，IPv6和IPv4通常是分开使用的，但现在可以利用隧道技术将IPv6与IPv4进行互通。通过隧道技术，路由器可以将IPv6数据封装在IPv4中，并在离开IPv4网络时将其解封并转发给目的节点。但是需要注意的是，隧道两端的节点都必须同时支持IPv4和IPv6协议。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* *3* [IPv6/IPv4是什么？IPv4和IPv6有什么区别？](https://blog.csdn.net/FS_China/article/details/118100320)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 50%"] - *2* [IPv6与Volp](https://blog.csdn.net/qq_58606689/article/details/122214824)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 50%"] [ .reference_list ]

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值