前端js开发常用的60种正则验证方法

已于 2023-04-11 16:35:35 修改
阅读量1.2k 收藏 6
点赞数 4
分类专栏： 前端 # JavaScript 文章标签： 前端 javascript
于 2023-04-11 16:29:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41462647/article/details/130086973
版权

目录

1.邮箱

2.手机号码

3.电话号码

4.是否url地址

5.是否字符串

6.是否数字

7.是否boolean

8.是否函数

9.是否为null

10.是否undefined

11.是否对象

12.是否数组

13.是否时间

14.是否正则

15.是否错误对象

16.是否Symbol函数

17.是否Promise对象

18.是否Set对象

19.是否是微信浏览器

20.是否是移动端

21.是否是QQ浏览器

22.是否是爬虫

23.是否ios

24.是否为PC端

25.去除html标签

26.获取url参数

27.动态引入js

28.根据url地址下载

29.el是否包含某个class

30.el添加某个class

31.el去除某个class

32.获取滚动的坐标

33.滚动到顶部

34.el是否在视口范围内

35.洗牌算法随机

36.劫持粘贴板

37.判断类型集合

38.严格的身份证校验

39.随机数范围

40.将阿拉伯数字翻译成中文的大写数字

41.将数字转换为大写金额

42.判断一个元素是否在数组中

43.数组排序，{type} 1：从小到大 2：从大到小 3：随机

44.去重

45.求两个集合的并集

46.求两个集合的交集

47.删除其中一个元素

48.将类数组转换为数组

49.最大值

50.最小值

51.求和

52.平均值

53.去除空格,type: 1-所有空格 2-前后空格 3-前空格 4-后空格

54.字符转换，type: 1:首字母大写 2：首字母小写 3：大小写转换 4：全部大写 5：全部小写

55.检测密码强度

56.函数节流器

57.在字符串中插入新字符串

58.判断两个对象是否键值相同

59.16进制颜色转RGBRGBA字符串

60.追加url参数

1.邮箱

export const isEmail = (s) => {

    return /^([a-zA-Z0-9_-])+@([a-zA-Z0-9_-])+((.[a-zA-Z0-9_-]{2,3}){1,2})$/.test(s)}

2.手机号码

export const isMobile = (s) => {

    return /^1[0-9]{10}$/.test(s)}

3.电话号码

export const isPhone = (s) => {

    return /^([0-9]{3,4}-)?[0-9]{7,8}$/.test(s)}

4.是否url地址

export const isURL = (s) => {

    return /^http[s]?:\/\/.*/.test(s)}

5.是否字符串

export const isString = (o) => {

    return Object.prototype.toString.call(o).slice(8, -1) === 'String'}

6.是否数字

export const isNumber = (o) => {

    return Object.prototype.toString.call(o).slice(8, -1) === 'Number'}

7.是否boolean

export const isBoolean = (o) => {

    return Object.prototype.toString.call(o).slice(8, -1) === 'Boolean'}

8.是否函数

export const isFunction = (o) => {

    return Object.prototype.toString.call(o).slice(8, -1) === 'Function'}

9.是否为null

export const isNull = (o) => {

    return Object.prototype.toString.call(o).slice(8, -1) === 'Null'}

10.是否undefined

export const isUndefined = (o) => {

    return Object.prototype.toString.call(o).slice(8, -1) === 'Undefined'}

11.是否对象

export const isObj = (o) => {

    return Object.prototype.toString.call(o).slice(8, -1) === 'Object'}

12.是否数组

export const isArray = (o) => {

    return Object.prototype.toString.call(o).slice(8, -1) === 'Array'}

13.是否时间

export const isDate = (o) => {

    return Object.prototype.toString.call(o).slice(8, -1) === 'Date'}

14.是否正则

export const isRegExp = (o) => {

    return Object.prototype.toString.call(o).slice(8, -1) === 'RegExp'}

15.是否错误对象

export const isError = (o) => {

    return Object.prototype.toString.call(o).slice(8, -1) === 'Error'}

16.是否Symbol函数

export const isSymbol = (o) => {

    return Object.prototype.toString.call(o).slice(8, -1) === 'Symbol'}

17.是否Promise对象

export const isPromise = (o) => {

    return Object.prototype.toString.call(o).slice(8, -1) === 'Promise'}

18.是否Set对象

export const isSet = (o) => {

    return Object.prototype.toString.call(o).slice(8, -1) === 'Set'}export const ua = navigator.userAgent.toLowerCase();

19.是否是微信浏览器

export const isWeiXin = () => {

    return ua.match(/microMessenger/i) == 'micromessenger'

}

20.是否是移动端

export const isDeviceMobile = () => {

    return /android|webos|iphone|ipod|balckberry/i.test(ua)}

21.是否是QQ浏览器

export const isQQBrowser = () => {

    return !!ua.match(/mqqbrowser|qzone|qqbrowser|qbwebviewtype/i)}

22.是否是爬虫

export const isSpider = () => {

    return /adsbot|googlebot|bingbot|msnbot|yandexbot|baidubot|robot|careerbot|seznambot|bot|baiduspider|jikespider|symantecspider|scannerlwebcrawler|crawler|360spider|sosospider|sogou web sprider|sogou orion spider/.test(ua)}

23.是否ios

export const isIos = () => {

    var u = navigator.userAgent;

    if (u.indexOf('Android') > -1 || u.indexOf('Linux') > -1) {  //安卓手机        return false

    } else if (u.indexOf('iPhone') > -1) {//苹果手机        return true

    } else if (u.indexOf('iPad') > -1) {//iPad        return false

    } else if (u.indexOf('Windows Phone') > -1) {//winphone手机        return false

    } else {

        return false

    }}

24.是否为PC端

export const isPC = () => {

    var userAgentInfo = navigator.userAgent;

    var Agents = ["Android", "iPhone",

        "SymbianOS", "Windows Phone",

        "iPad", "iPod"];

    var flag = true;

    for (var v = 0; v < Agents.length; v++) {

        if (userAgentInfo.indexOf(Agents[v]) > 0) {

            flag = false;

            break;

        }

    }

    return flag;}

25.去除html标签

export const removeHtmltag = (str) => {

    return str.replace(/<[^>]+>/g, '')}

26.获取url参数

export const getQueryString = (name) => {

    const reg = new RegExp('(^|&)' + name + '=([^&]*)(&|$)', 'i');

    const search = window.location.search.split('?')[1] || '';

    const r = search.match(reg) || [];

    return r[2];}

27.动态引入js

export const injectScript = (src) => {

    const s = document.createElement('script');

    s.type = 'text/javascript';

    s.async = true;

    s.src = src;

    const t = document.getElementsByTagName('script')[0];

    t.parentNode.insertBefore(s, t);}

28.根据url地址下载

export const download = (url) => {

    var isChrome = navigator.userAgent.toLowerCase().indexOf('chrome') > -1;

    var isSafari = navigator.userAgent.toLowerCase().indexOf('safari') > -1;

    if (isChrome || isSafari) {

        var link = document.createElement('a');

        link.href = url;

        if (link.download !== undefined) {

            var fileName = url.substring(url.lastIndexOf('/') + 1, url.length);

            link.download = fileName;

        }

        if (document.createEvent) {

            var e = document.createEvent('MouseEvents');

            e.initEvent('click', true, true);

            link.dispatchEvent(e);

            return true;

        }

    }

    if (url.indexOf('?') === -1) {

        url += '?download';

    }

    window.open(url, '_self');

    return true;}

29.el是否包含某个class

export const hasClass = (el, className) => {

    let reg = new RegExp('(^|\\s)' + className + '(\\s|$)')

    return reg.test(el.className)}

30.el添加某个class

export const addClass = (el, className) => {

    if (hasClass(el, className)) {

        return

    }

    let newClass = el.className.split(' ')

    newClass.push(className)

    el.className = newClass.join(' ')}

31.el去除某个class

export const removeClass = (el, className) => {

    if (!hasClass(el, className)) {

        return

    }

    let reg = new RegExp('(^|\\s)' + className + '(\\s|$)', 'g')

    el.className = el.className.replace(reg, ' ')}

32.获取滚动的坐标

export const getScrollPosition = (el = window) => ({

    x: el.pageXOffset !== undefined ? el.pageXOffset : el.scrollLeft,

    y: el.pageYOffset !== undefined ? el.pageYOffset : el.scrollTop});

33.滚动到顶部

export const scrollToTop = () => {

    const c = document.documentElement.scrollTop || document.body.scrollTop;

    if (c > 0) {

        window.requestAnimationFrame(scrollToTop);

        window.scrollTo(0, c - c / 8);

    }}

34.el是否在视口范围内

export const elementIsVisibleInViewport = (el, partiallyVisible = false) => {

    const { top, left, bottom, right } = el.getBoundingClientRect();

    const { innerHeight, innerWidth } = window;

    return partiallyVisible

        ? ((top > 0 && top < innerHeight) || (bottom > 0 && bottom < innerHeight)) &&

        ((left > 0 && left < innerWidth) || (right > 0 && right < innerWidth))

        : top >= 0 && left >= 0 && bottom <= innerHeight && right <= innerWidth;}

35.洗牌算法随机

export const shuffle = (arr) => {

    var result = [],

        random;

    while (arr.length > 0) {

        random = Math.floor(Math.random() * arr.length);

        result.push(arr[random])

        arr.splice(random, 1)

    }

    return result;}

36.劫持粘贴板

export const copyTextToClipboard = (value) => {

    var textArea = document.createElement("textarea");

    textArea.style.background = 'transparent';

    textArea.value = value;

    document.body.appendChild(textArea);

    textArea.select();

    try {

        var successful = document.execCommand('copy');

    } catch (err) {

        console.log('Oops, unable to copy');

    }

    document.body.removeChild(textArea);}

37.判断类型集合

export const checkStr = (str, type) => {

    switch (type) {

        case 'phone':   //手机号码            return /^1[3|4|5|6|7|8|9][0-9]{9}$/.test(str);

        case 'tel':     //座机            return /^(0\d{2,3}-\d{7,8})(-\d{1,4})?$/.test(str);

        case 'card':    //身份证            return /(^\d{15}$)|(^\d{18}$)|(^\d{17}(\d|X|x)$)/.test(str);

        case 'pwd':     //密码以字母开头，长度在6~18之间，只能包含字母、数字和下划线            return /^[a-zA-Z]\w{5,17}$/.test(str)

        case 'postal':  //邮政编码            return /[1-9]\d{5}(?!\d)/.test(str);

        case 'QQ':      //QQ号            return /^[1-9][0-9]{4,9}$/.test(str);

        case 'email':   //邮箱            return /^[\w-]+(\.[\w-]+)*@[\w-]+(\.[\w-]+)+$/.test(str);

        case 'money':   //金额(小数点2位)            return /^\d*(?:\.\d{0,2})?$/.test(str);

        case 'URL':     //网址            return /(http|ftp|https):\/\/[\w\-_]+(\.[\w\-_]+)+([\w\-\.,@?^=%&:/~\+#]*[\w\-\@?^=%&/~\+#])?/.test(str)

        case 'IP':      //IP            return /((?:(?:25[0-5]|2[0-4]\\d|[01]?\\d?\\d)\\.){3}(?:25[0-5]|2[0-4]\\d|[01]?\\d?\\d))/.test(str);

        case 'date':    //日期时间            return /^(\d{4})\-(\d{2})\-(\d{2}) (\d{2})(?:\:\d{2}|:(\d{2}):(\d{2}))$/.test(str) || /^(\d{4})\-(\d{2})\-(\d{2})$/.test(str)

        case 'number':  //数字            return /^[0-9]$/.test(str);

        case 'english': //英文            return /^[a-zA-Z]+$/.test(str);

        case 'chinese': //中文            return /^[\\u4E00-\\u9FA5]+$/.test(str);

        case 'lower':   //小写            return /^[a-z]+$/.test(str);

        case 'upper':   //大写            return /^[A-Z]+$/.test(str);

        case 'HTML':    //HTML标记            return /<("[^"]*"|'[^']*'|[^'">])*>/.test(str);

        default:

            return true;

    }}

38.严格的身份证校验

export const isCardID = (sId) => {

    if (!/(^\d{15}$)|(^\d{17}(\d|X|x)$)/.test(sId)) {

        console.log('你输入的身份证长度或格式错误')

        return false

    }

    //身份证城市    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: "国外" };

    if (!aCity[parseInt(sId.substr(0, 2))]) {

        console.log('你的身份证地区非法')

        return false

    }

    // 出生日期验证    var sBirthday = (sId.substr(6, 4) + "-" + Number(sId.substr(10, 2)) + "-" + Number(sId.substr(12, 2))).replace(/-/g, "/"),

        d = new Date(sBirthday)

    if (sBirthday != (d.getFullYear() + "/" + (d.getMonth() + 1) + "/" + d.getDate())) {

        console.log('身份证上的出生日期非法')

        return false

    }

    // 身份证号码校验    var sum = 0,

        weights = [7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2],

        codes = "10X98765432"

    for (var i = 0; i < sId.length - 1; i++) {

        sum += sId[i] * weights[i];

    }

    var last = codes[sum % 11]; //计算出来的最后一位身份证号码    if (sId[sId.length - 1] != last) {

        console.log('你输入的身份证号非法')

        return false

    }

    return true}

39.随机数范围

export const random = (min, max) => {

    if (arguments.length === 2) {

        return Math.floor(min + Math.random() * ((max + 1) - min))

    } else {

        return null;

    }}

40.将阿拉伯数字翻译成中文的大写数字

export const numberToChinese = (num) => {

    var AA = new Array("零", "一", "二", "三", "四", "五", "六", "七", "八", "九", "十");

    var BB = new Array("", "十", "百", "仟", "萬", "億", "点", "");

    var a = ("" + num).replace(/(^0*)/g, "").split("."),

        k = 0,

        re = "";

    for (var i = a[0].length - 1; i >= 0; i--) {

        switch (k) {

            case 0:

                re = BB[7] + re;

                break;

            case 4:

                if (!new RegExp("0{4}//d{" + (a[0].length - i - 1) + "}$")

                    .test(a[0]))

                    re = BB[4] + re;

                break;

            case 8:

                re = BB[5] + re;

                BB[7] = BB[5];

                k = 0;

                break;

        }

        if (k % 4 == 2 && a[0].charAt(i + 2) != 0 && a[0].charAt(i + 1) == 0)

            re = AA[0] + re;

        if (a[0].charAt(i) != 0)

            re = AA[a[0].charAt(i)] + BB[k % 4] + re;

        k++;

    }

    if (a.length > 1) // 加上小数部分(如果有小数部分)    {

        re += BB[6];

        for (var i = 0; i < a[1].length; i++)

            re += AA[a[1].charAt(i)];

    }

    if (re == '一十')

        re = "十";

    if (re.match(/^一/) && re.length == 3)

        re = re.replace("一", "");

    return re;}

41.将数字转换为大写金额

export const changeToChinese = (Num) => {

    //判断如果传递进来的不是字符的话转换为字符    if (typeof Num == "number") {

        Num = new String(Num);

    };

    Num = Num.replace(/,/g, "") //替换tomoney()中的“,”    Num = Num.replace(/ /g, "") //替换tomoney()中的空格    Num = Num.replace(/￥/g, "") //替换掉可能出现的￥字符    if (isNaN(Num)) { //验证输入的字符是否为数字        //alert("请检查小写金额是否正确");        return "";

    };

    //字符处理完毕后开始转换，采用前后两部分分别转换    var part = String(Num).split(".");

    var newchar = "";

    //小数点前进行转化    for (var i = part[0].length - 1; i >= 0; i--) {

        if (part[0].length > 10) {

            return "";

            //若数量超过拾亿单位，提示        }

        var tmpnewchar = ""

        var perchar = part[0].charAt(i);

        switch (perchar) {

            case "0":

                tmpnewchar = "零" + tmpnewchar;

                break;

            case "1":

                tmpnewchar = "壹" + tmpnewchar;

                break;

            case "2":

                tmpnewchar = "贰" + tmpnewchar;

                break;

            case "3":

                tmpnewchar = "叁" + tmpnewchar;

                break;

            case "4":

                tmpnewchar = "肆" + tmpnewchar;

                break;

            case "5":

                tmpnewchar = "伍" + tmpnewchar;

                break;

            case "6":

                tmpnewchar = "陆" + tmpnewchar;

                break;

            case "7":

                tmpnewchar = "柒" + tmpnewchar;

                break;

            case "8":

                tmpnewchar = "捌" + tmpnewchar;

                break;

            case "9":

                tmpnewchar = "玖" + tmpnewchar;

                break;

        }

        switch (part[0].length - i - 1) {

            case 0:

                tmpnewchar = tmpnewchar + "元";

                break;

            case 1:

                if (perchar != 0) tmpnewchar = tmpnewchar + "拾";

                break;

            case 2:

                if (perchar != 0) tmpnewchar = tmpnewchar + "佰";

                break;

            case 3:

                if (perchar != 0) tmpnewchar = tmpnewchar + "仟";

                break;

            case 4:

                tmpnewchar = tmpnewchar + "万";

                break;

            case 5:

                if (perchar != 0) tmpnewchar = tmpnewchar + "拾";

                break;

            case 6:

                if (perchar != 0) tmpnewchar = tmpnewchar + "佰";

                break;

            case 7:

                if (perchar != 0) tmpnewchar = tmpnewchar + "仟";

                break;

            case 8:

                tmpnewchar = tmpnewchar + "亿";

                break;

            case 9:

                tmpnewchar = tmpnewchar + "拾";

                break;

        }

        var newchar = tmpnewchar + newchar;

    }

    //小数点之后进行转化    if (Num.indexOf(".") != -1) {

        if (part[1].length > 2) {

            // alert("小数点之后只能保留两位,系统将自动截断");            part[1] = part[1].substr(0, 2)

        }

        for (i = 0; i < part[1].length; i++) {

            tmpnewchar = ""

            perchar = part[1].charAt(i)

            switch (perchar) {

                case "0":

                    tmpnewchar = "零" + tmpnewchar;

                    break;

                case "1":

                    tmpnewchar = "壹" + tmpnewchar;

                    break;

                case "2":

                    tmpnewchar = "贰" + tmpnewchar;

                    break;

                case "3":

                    tmpnewchar = "叁" + tmpnewchar;

                    break;

                case "4":

                    tmpnewchar = "肆" + tmpnewchar;

                    break;

                case "5":

                    tmpnewchar = "伍" + tmpnewchar;

                    break;

                case "6":

                    tmpnewchar = "陆" + tmpnewchar;

                    break;

                case "7":

                    tmpnewchar = "柒" + tmpnewchar;

                    break;

                case "8":

                    tmpnewchar = "捌" + tmpnewchar;

                    break;

                case "9":

                    tmpnewchar = "玖" + tmpnewchar;

                    break;

            }

            if (i == 0) tmpnewchar = tmpnewchar + "角";

            if (i == 1) tmpnewchar = tmpnewchar + "分";

            newchar = newchar + tmpnewchar;

        }

    }

    //替换所有无用汉字    while (newchar.search("零零") != -1)

        newchar = newchar.replace("零零", "零");

    newchar = newchar.replace("零亿", "亿");

    newchar = newchar.replace("亿万", "亿");

    newchar = newchar.replace("零万", "万");

    newchar = newchar.replace("零元", "元");

    newchar = newchar.replace("零角", "");

    newchar = newchar.replace("零分", "");

    if (newchar.charAt(newchar.length - 1) == "元") {

        newchar = newchar + "整"

    }

    return newchar;}

42.判断一个元素是否在数组中

export const contains = (arr, val) => {

    return arr.indexOf(val) != -1 ? true : false;}

43.数组排序，{type} 1：从小到大 2：从大到小 3：随机

export const sort = (arr, type = 1) => {

    return arr.sort((a, b) => {

        switch (type) {

            case 1:

                return a - b;

            case 2:

                return b - a;

            case 3:

                return Math.random() - 0.5;

            default:

                return arr;

        }

    })}

44.去重

export const unique = (arr) => {

    if (Array.hasOwnProperty('from')) {

        return Array.from(new Set(arr));

    } else {

        var n = {}, r = [];

        for (var i = 0; i < arr.length; i++) {

            if (!n[arr[i]]) {

                n[arr[i]] = true;

                r.push(arr[i]);

            }

        }

        return r;

    }}

45.求两个集合的并集

export const union = (a, b) => {

    var newArr = a.concat(b);

    return this.unique(newArr);}

46.求两个集合的交集

export const intersect = (a, b) => {

    var _this = this;

    a = this.unique(a);

    return this.map(a, function (o) {

        return _this.contains(b, o) ? o : null;

    });}

47.删除其中一个元素

export const remove = (arr, ele) => {

    var index = arr.indexOf(ele);

    if (index > -1) {

        arr.splice(index, 1);

    }

    return arr;}

48.将类数组转换为数组

export const formArray = (ary) => {

    var arr = [];

    if (Array.isArray(ary)) {

        arr = ary;

    } else {

        arr = Array.prototype.slice.call(ary);

    };

    return arr;}

49.最大值

export const max = (arr) => {

    return Math.max.apply(null, arr);}

50.最小值

export const min = (arr) => {

    return Math.min.apply(null, arr);}

51.求和

export const sum = (arr) => {

    return arr.reduce((pre, cur) => {

        return pre + cur

    })}

52.平均值

export const average = (arr) => {

    return this.sum(arr) / arr.length}

53.去除空格,type: 1-所有空格 2-前后空格 3-前空格 4-后空格

export const trim = (str, type) => {

    type = type || 1

    switch (type) {

        case 1:

            return str.replace(/\s+/g, "");

        case 2:

            return str.replace(/(^\s*)|(\s*$)/g, "");

        case 3:

            return str.replace(/(^\s*)/g, "");

        case 4:

            return str.replace(/(\s*$)/g, "");

        default:

            return str;

    }}

54.字符转换，type: 1:首字母大写 2：首字母小写 3：大小写转换 4：全部大写 5：全部小写

export const changeCase = (str, type) => {

    type = type || 4

    switch (type) {

        case 1:

            return str.replace(/\b\w+\b/g, function (word) {

                return word.substring(0, 1).toUpperCase() + word.substring(1).toLowerCase();

            });

        case 2:

            return str.replace(/\b\w+\b/g, function (word) {

                return word.substring(0, 1).toLowerCase() + word.substring(1).toUpperCase();

            });

        case 3:

            return str.split('').map(function (word) {

                if (/[a-z]/.test(word)) {

                    return word.toUpperCase();

                } else {

                    return word.toLowerCase()

                }

            }).join('')

        case 4:

            return str.toUpperCase();

        case 5:

            return str.toLowerCase();

        default:

            return str;

    }}

55.检测密码强度

export const checkPwd = (str) => {

    var Lv = 0;

    if (str.length < 6) {

        return Lv

    }

    if (/[0-9]/.test(str)) {

        Lv++

    }

    if (/[a-z]/.test(str)) {

        Lv++

    }

    if (/[A-Z]/.test(str)) {

        Lv++

    }

    if (/[\.|-|_]/.test(str)) {

        Lv++

    }

    return Lv;}

56.函数节流器

export const debouncer = (fn, time, interval = 200) => {

    if (time - (window.debounceTimestamp || 0) > interval) {

        fn && fn();

        window.debounceTimestamp = time;

    }}

57.在字符串中插入新字符串

export const insertStr = (soure, index, newStr) => {

    var str = soure.slice(0, index) + newStr + soure.slice(index);

    return str;}

58.判断两个对象是否键值相同

export const isObjectEqual = (a, b) => {

    var aProps = Object.getOwnPropertyNames(a);

    var bProps = Object.getOwnPropertyNames(b);

    if (aProps.length !== bProps.length) {

        return false;

    }

    for (var i = 0; i < aProps.length; i++) {

        var propName = aProps[i];

        if (a[propName] !== b[propName]) {

            return false;

        }

    }

    return true;}

59.16进制颜色转RGBRGBA字符串

export const colorToRGB = (val, opa) => {

    var pattern = /^(#?)[a-fA-F0-9]{6}$/; //16进制颜色值校验规则    var isOpa = typeof opa == 'number'; //判断是否有设置不透明度

    if (!pattern.test(val)) { //如果值不符合规则返回空字符        return '';

    }

    var v = val.replace(/#/, ''); //如果有#号先去除#号    var rgbArr = [];

    var rgbStr = '';

    for (var i = 0; i < 3; i++) {

        var item = v.substring(i * 2, i * 2 + 2);

        var num = parseInt(item, 16);

        rgbArr.push(num);

    }

    rgbStr = rgbArr.join();

    rgbStr = 'rgb' + (isOpa ? 'a' : '') + '(' + rgbStr + (isOpa ? ',' + opa : '') + ')';

    return rgbStr;}

60.追加url参数

export const appendQuery = (url, key, value) => {

    var options = key;

    if (typeof options == 'string') {

        options = {};

        options[key] = value;

    }

    options = $.param(options);

    if (url.includes('?')) {

        url += '&' + options

    } else {

        url += '?' + options

    }

    return url;

kuang*
关注
  • 4
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JS常用正则表达式及验证时间的正则表达式
10-21
在这篇文章里，我已经编写了12个超有用的正则表达式，本文给大家介绍的非常详细，感兴趣的朋友参考下吧
js 前端好用的验证方式
05-06
纯前端的验证码插件，超全的验证方式（验证码，滑动，计算等验证方式），简单易用
收集的一些前端正则表达式校验方法合集
一个超爱喝可乐的web前端攻城狮
10-19 721
收集的一些前端正则表达式校验方法合集 1、手机号码的校验 const phone = /^1[3456789]\d{9}$/ //一般 const phoneX = /^(13[0-9]|14[579]|15[0-3,5-9]|16[6]|17[0135678]|18[0-9]|19[89])\d{8}$/ //严格 const phone1 = '13891335566' console.log(phone.test(phone1)) // true const phone2 = '1234564
前端使用正则表达式进行校验
weixin_43962020的博客
03-22 875
设计思想是用一种描述性的语言定义一个规则，凡是符合规则的字符串，我们就认为它“匹配”了，否则，该字符串就是不合法的。在。
前端 - 开发中常用的正则校验
小草莓的博客
11-27 2180
￥?|‘；：”“'。，、？+=:]+/g/^[a-zA-Z]{5,17}$/ 且 /^[a-zA-Z0-9]{5,17}$//((^(?![0-9]+$)(?!
前端常用的正则校验
fern_ok的博客
07-06 4313
前端常用的正则校验
前端常见的15个正则验证
liukai6的博客
03-22 1304
将前端input添加属性pattern=”“ 用户名正则 //用户名正则，4到16位（字母，数字，下划线，减号） Pattern = /^[a-zA-Z0-9_-]{4,16}$/; 密码强度正则 //密码强度正则，最少6位，包括至少1个大写字母，1个小写字母，1个数字，1个特殊字符 Pattern = /^.*(?=.{6,})(?=.*\d)(?=.*[A-Z])(?=.*...
JavaScript正则验证
weixin_45857749的博客
06-22 4279
正则表达式的基础以及js中的应用
前端常用正则校验
chanzhiliao的博客
09-19 2096
一、校验数字的表达式 数字：1$ n位的数字：^\d{n}$ 至少n位的数字：^\d{n,}$ m-n位的数字：^\d{m,n}$ 零和非零开头的数字：^(0|[1-9][0-9])$ 非零开头的最多带两位小数的数字：^([1-9][0-9])+(.[0-9]{1,2})?$ 带1-2位小数的正数或负数：^(-)?\d+(.\d{1,2})?$ 正数、负数、和小数：^(-|+)?\d+(.\d+)?$ 有两位小数的正实数：2+(.[0-9]{2})?$ 有1~3位小数的正实数：3+(.[0-9]{1,3})
最常用的15个前端表单验证JS正则表达式
10-19
在表单验证中，使用正则表达式来验证正确与否是一个很频繁的操作，本文收集整理了15个常用的JavaScript正则表达式，非常不错，具有参考借鉴价值，需要的朋友参考下吧
js与jquery正则验证电子邮箱、手机号、邮政编码的方法
10-22
主要介绍了js与jquery正则验证电子邮箱、手机号、邮政编码的方法,涉及javascript与jQuery鼠标事件的响应与正则验证操作字符串的相关技巧,需要的朋友可以参考下
正则表达式–QQ微信、优酷前端 邮箱正则表达式验证 Bug
12-13
拿邮箱验证来说，网上绝大部分人写的邮箱验证正则表达式代码都不能验证这邮箱： [email protected]，也不能验证 [email protected] 。 上次我发现youku.com（优酷网）用户注册就有这个问题，见图：   ...
js正则表达式验证密码强度【推荐】
10-20
本文主要介绍了js利用正则表达式验证密码强度的实例，具有很好的参考价值。下面跟着小编一起来看下吧
【解决NodeJS项目无法在IDEA中调试的问题】使用JetBrains IDEA 2023 调试nodejs项目
宅斗士的博客
04-23 412
项目采用Ant Design Pro + React，使用前后端分离开发方式，后端可以很容易的打断点调试，但是前端用到了React脚手架，在IDEA中加了调试断点，但是没有什么用处。
SpringBoot项目打包分离高阶操作
Record Little
04-23 730
虽然传输jar包 比较大，但是安全性、稳定性比较高，不需要关注pom.xml 添加了新的依赖、更新了版本号等等影响版本功能的操作。关注maven的特性， profiles即可满足， 根据不同的activation 状态，激活不同的build操作。每次修改一小部分代码或仅仅更新某个依赖jar包时，都需要重新进行整个项目的构建、打包、上传和部署。但是当你的项目趋于稳定，只有业务上的逻辑变更时，如果使用分离版本，可以加快迭代、更新的速度。弊端： 需要配置IDE命令，修改依赖时需要同时修改2处。
判断前端入参是否空否则提示前端写法
最新发布
qq_39306234的博客
04-28 164
前端先声明一个变量，用于alert判断。在templeat中定义一个提示语句。然后在点击事件时判断一下是否展示。
vue实现录音并转文字功能，包括PC端web，手机端web
byebukesi的博客
04-26 477
不止vue，不限技术栈，vue2、vue3、react、.net以及原生js均可实现。
前端做身份证验证的正则表达式
01-05
身份证号码是一种特殊的格式，可以使用正则＊＊＊身份证号码： ```javascript ^(\\d{6})(19|20)?(\\d{2})(0[1-9]|1[0-2])(0[1-9]|[12]\\d|3[01])(\\d{3})(\\d|[Xx])$ ``` 这个正则表达式的含义是： - `^` 表示匹配字符串的开始 - `(\\d{6})` 表示匹配6位数字，用于匹配身份证号码的前6位地区代码 - `(19|20)?` 表示匹配19或20，可选项，用于匹配身份证号码的年份的前两位 - `(\\d{2})` 表示匹配2位数字，用于匹配身份证号码的年份的后两位 - `(0[1-9]|1[0-2])` 表示匹配01-12之间的数字，用于匹配身份证号码的月份 - `(0[1-9]|[12]\\d|3[01])` 表示匹配01-31之间的数字，用于匹配身份证号码的日期 - `(\\d{3})` 表示匹配3位数字，用于匹配身份证号码的顺序码 - `(\\d|[Xx])` 表示匹配一个数字或者字母X（大小写均可），用于匹配身份证号码的校验码 - `$` 表示匹配字符串的结束 请注意，这只是一个示例的正则表达式，实际上身份证号码的验证可能会更复杂，因为还需要考虑闰年、地区代码等因素。在实际使用中，建议使用成熟的身份证验证库或者根据具体需求进行适当的修改。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值