正则表达式学习使用笔记整理

「爱情、让人受尽委屈。」 2022-04-16 01:41 186阅读 0赞

正则表达式一般来说分为正向正则表达式和逆向正则表达式

正则表达式可以实现字符串匹配的功能，它采用一定的策略进行匹配，在有贪婪模式的情况下，正则会优先匹配能匹配的最大值，然后再以步退的模式向前迭代，直到整句正则表达式完全匹配为止，可以看出，在有贪婪模式的正则中，时间复杂度是比较高的，所以在匹配环境中最好避免大量使用贪婪模式。

正则表达式复杂度测试工具： R e g e x B u d d y 4 RegexBuddy 4 RegexBuddy4  
在线练习正则表达式：[https://regex101.com/][https_regex101.com]

1、匹配ip地址  
ip地址最大的特点就是具有重复性，所以只需要确定某一个的正则就行，ipv4最大值为255，所以我们每一项都需匹配小于255的情况，于是正则转换为 用正则实现小于等于255：

一位数和二位数 \d{1,2}
    三位数：((1\d{2})|(2[0-4]\d)|(25[0-5]))
    合起来就是 (^|\s)(((\d{1,2})|((1\d{2})|(2[0-4][0-9])|(25[0-5])))\.){3}((\d{1,2})|((1\d{2})|(2[0-4][0-9])|(25[0-5])))(\s|$)

2、任意值一般写法

[a-zA-Z0-9_-]+

3、匹配首尾的写法

(^|\s)(\s|$)

4、数字大小匹配

小于15：
    	不包含负数
    	(^|\s)(\d|(1[0-5]))(\s|$)
    	包含负数的版本
    	(^|\s)(\d|(1[0-5])|(-\d+))(\s|$)
    大于90
    	(^|\s)(9[1-9]|\d{3,})(\s|$)

数字匹配枚举所有可能的情况就行了

5、| 语句的每一种并列的情况都需要单独用括号括起来  
错误实例

匹配配置 ospf shutdown , http shutdown , ssh shutdown 都可以
    正则为：(^|\s)ospf|http|ssh\s+shutdown(\s|$)
    匹配的结果为： ospf ，http，ssh shutdown

这样的匹配结果跟 | 符号的优先级有关，| 符号的优先级比较低，+号比较高，所以ssh\\s+shutdown会被认为是一起的，应该将上面的正则修改为

匹配配置 ospf shutdown , http shutdown , ssh shutdown 都可以
    正则为：(^|\s)(ospf|http|ssh)\s+shutdown(\s|$)
    匹配的结果为：ospf shutdown , http shutdown , ssh shutdown

6、一些特殊字符需要进行转义

. => \.
    + => \+
    - 不需要转义 -
    $ => \$
    ^ => \^

7、常备(搬运工日常存储)

var validator = { 
    
            isCookie: function (str) { 
                //var reg = /(?is);?([\w\W]+?)=([\w\W]+?)(?=(;|,))/;
                //var reg = /(^| )id=([^;]*)(;|$)/;
                var reg=/([A-Za-z])=([A-Za-z0-9_]+)$/;
                if (reg.test(str)) { 
                    return true;
                } else { 
                    return false;
                }
            },
    
            isURL: function (str) { 
                //var reg = /^((ht|f)tps?):\/\/[\w\-]+(\.[\w\-]+)+([\w\-\.,@?^=%&:\/~\+#]*[\w\-\@?^=%&\/~\+#])?$/;
                var reg = /^((http|https)?):\/\/[\w\-]+(\.[\w\-]+)+([\w\-\.,@?^=%&:\/~\+#]*[\w\-\@?^=%&\/~\+#])?$/;
                if (reg.test(str)) { 
                    return true;
                } else { 
                    return false;
                }
            },
    
            isURL1: function (str) { 
                var reg = new RegExp(
                    "^" +
                    // protocol identifier
                    "(?:(?:https?|ftp)://)" +
                    // user:pass authentication
                    "(?:\\S+(?::\\S*)?@)?" + "(?:" +
                    // IP address dotted notation octets
                    // excludes loopback network 0.0.0.0
                    // excludes reserved space >= 224.0.0.0
                    // excludes network & broacast addresses
                    // (first & last IP address of each class)
                    "(?:[1-9]\\d?|1\\d\\d|2[01]\\d|22[0-3])" +
                    "(?:\\.(?:1?\\d{1,2}|2[0-4]\\d|25[0-5])){2}" +
                    "(?:\\.(?:[1-9]\\d?|1\\d\\d|2[0-4]\\d|25[0-4]))" +
                    "|" +
                    // host name
                    "(?:(?:[a-z\\u00a1-\\uffff0-9]-*)*[a-z\\u00a1-\\uffff0-9]+)" +
                    // domain name
                    "(?:\\.(?:[a-z\\u00a1-\\uffff0-9]-*)*[a-z\\u00a1-\\uffff0-9]+)" +
                    // TLD identifier
                    "(?:\\.(?:[a-z\\u00a1-\\uffff]{2,}))" +
    
                    ")" +
    
                    "(?:\\.(?:[a-z\\u00a1-\\uffff]{2,}))?" +
    
                    // port number
                    "(?::\\d{2,5})?" +
                    // resource path
                    "(?:/\\S*)?" + "$", "i" );
    
                if (reg.test(str)) { 
                    return true;
                } else { 
                    return false;
                }
            },
    
    
            isHTTP: function (str) { 
                //var reg = /^((ht|f)tps?):\/\/[\w\-]+(\.[\w\-]+)+([\w\-\.,@?^=%&:\/~\+#]*[\w\-\@?^=%&\/~\+#])?$/;
                var reg = /^((http)?):\/\/[\w\-]+(\.[\w\-]+)+([\w\-\.,@?^=%&:\/~\+#]*[\w\-\@?^=%&\/~\+#])?$/;
                if (reg.test(str)) { 
                    return true;
                } else { 
                    return false;
                }
            },
    
            isHTTPS: function (str) { 
                //var reg = /^((ht|f)tps?):\/\/[\w\-]+(\.[\w\-]+)+([\w\-\.,@?^=%&:\/~\+#]*[\w\-\@?^=%&\/~\+#])?$/;
                var reg = /^((https)?):\/\/[\w\-]+(\.[\w\-]+)+([\w\-\.,@?^=%&:\/~\+#]*[\w\-\@?^=%&\/~\+#])?$/;
                if (reg.test(str)) { 
                    return true;
                } else { 
                    return false;
                }
            },
    
    
    
            isDNAddress: function (str) { 
                var reg = /^(?=^.{3,255}$)[a-zA-Z0-9][-a-zA-Z0-9]{0,62}(\.[a-zA-Z0-9][-a-zA-Z0-9]{0,62})+$/;
                if (reg.test(str)) { 
                    return true;
                } else { 
                    return false;
                }
            },
    
    
            isIPAddress:function (str) { 
                var reg=/((25[0-5]|2[0-4]\d|((1\d{2})|([1-9]?\d)))\.){3}(25[0-5]|2[0-4]\d|((1\d{2})|([1-9]?\d)))/;
                if (reg.test(str)) { 
                    return true;
                } else { 
                    return false;
                }
            },
    
    
            isPassword:function (str) { 
                var reg= /^(?![0-9]+$)(?![a-zA-Z]+$)[0-9A-Za-z]{6,}$/;
                if (reg.test(str)) { 
                    return true;
                } else { 
                    return false;
                }
            },
    
            isPassword1:function (str) { 
                // var reg = /^(?=.*[a-zA-Z])(?=.*\d)(?=.*[~!@#$%^&*()_+`\-={}\[\]:";'<>?,.\/]).{8,20}$/;
                var reg=/^(?![a-zA-Z]+$)(?![A-Z0-9]+$)(?![A-Z\W_]+$)(?![a-z0-9]+$)(?![a-z\W_]+$)(?![0-9\W_]+$)[a-zA-Z0-9\W_]{8,20}$/;
                if (reg.test(str)) { 
                    return true;
                } else { 
                    return false;
                }
            },
    
    
    
            isMail: function (str) { 
                var re = /^([a-zA-Z0-9_-])+@([a-zA-Z0-9_-])+(.[a-zA-Z0-9_-])+/;
                if (re.test(str)) { 
                    return true;
                } else { 
                    return false;
                }
            },
    
            isMails: function (str) { 
                var strs=str.split(";"); //字符分割
                var flag=1;
    
                for (var i=0;i<strs.length ;i++ ){ 
                    var reg = /^([a-zA-Z0-9_-])+@([a-zA-Z0-9_-])+(.[a-zA-Z0-9_-])+/;
                    if (reg.test(strs[i])) { 
    
                    } else { 
                        return flag;
                    }
                }
            },
    
    
    
    
            checkUser: function (str) { 
                var reg = /^(?![0-9]+$)(?![a-zA-Z]+$)[0-9A-Za-z_-]{6,20}$/;
                if (reg.test(str)) { 
                    return true;
                }
                else { 
                    return false;
                }
            },
            isMoney: function (money) { 
                var reg = /^^([1-9]\d{0,9}|0)([.]?|(\.\d{1,2})?)$/;
                if (!reg.test(money)) { 
                    return false;
                }
                return true;
            },
            //非空验证
            isNull: function (str) { 
                if ($.trim(str) === '') { 
                    return false;
                }
                return true;
            },
            //字符串是否有空字符
            isStringNull: function (str) { 
                var n_reg = /\s+/;
                if (n_reg.test(str)) { 
                    return false;
                }
                return true;
            },
            //验证字符范围
            strLen: function (str, len, len2) { 
                if (str.length < len || str.length > len2) { 
                    return false;
                }
                return true;
            },
            //密码比较
            pwdCompare: function (str1, str2) { 
                if (str1 != str2) { 
                    return false;
                }
                return true;
            },
            //带区号的
            isTel: function (str) { 
                var reg = /^((0\d{2,3})-?)?(\d{7,8})(-(\d{3,}))?$/;
                if (!reg.test(str)) { 
                    return false;
                }
                return true;
            },
            //手机验证
            isPhone: function (phone) { 
                var reg = /^1[3456789]{1}[0-9]{9}$/;
                return reg.test(phone);
            },
    
            isPhones: function (str) { 
                var strs1=str.split(";"); //字符分割
                var flag=1;
                for (var j=0;j<strs1.length ;j++ ){ 
                    var reg = /^1[34578]{1}[0-9]{9}$/;
                    if (reg.test(strs1[j])) { 
    
                    } else { 
                        return flag;
                    }
                }
            },
    
    
    
    
    
            isChecked:function (str) { 
                var name = document.getElementsByName(str);
                var isSel = false;
                for (var i = 0; i < name.length; i++) { 
                    if (name[i].checked == true) { 
                        isSel = true;
                        break;
                    }
                }
                if (isSel == false) { 
                    return false;
                } else { 
                    return true;
                }
            },
            //密码强度
            checkStrong: function (sValue) { 
                /** 强度规则 + ------------------------------------------------------- + 1) 任何少于6个字符的组合，弱；任何字符数的同类字符组合，弱； 2) 任何字符数的两类字符组合，中； 3) 12位字符数以下的三类或四类字符组合，强； 4) 12位字符数以上的三类或四类字符组合，非常好。 + ------------------------------------------------------- + **/
                var modes = 0;
                if (sValue.length < 6)
                    return modes;
                if (/\d/.test(sValue))
                    modes++; //数字
                if (/[a-z]/.test(sValue))
                    modes++; //小写
                if (/[A-Z]/.test(sValue))
                    modes++; //大写
                if (/\W/.test(sValue))
                    modes++; //特殊字符
                switch (modes) { 
                    case 1:
                        return 1;
                        break;
                    case 2:
                        return 2;
                        break;
                    case 3:
                        if (sValue.length >= 12) { 
                            return 4;
                        }
                        return sValue.length > 10 ? 3 : 2;
                        break;
                    case 4:
                        return sValue.length > 12 ? 4 : 3;
                        break;
                }
            },
            //15位和18位身份证号码的正则表达式
            isIdCard: function (idCard) { 
                var regIdCard = /(^\d{15}$)|(^\d{18}$)|(^\d{17}(\d|X|x)$)/;
                return regIdCard.test(idCard);
            },
            //6位验证码
            isCode: function (str) { 
                if (!this.v_str_s(str))
                    return false;
                var reg1 = /^\d{6}$/;
                if (!reg1.test(str))
                    return false;
                return true;
            }
        };

[https_regex101.com]: https://regex101.com/

发表评论取消回复

表情：

评论列表（有 0 条评论，186人围观）

还没有评论，来说两句吧...

相关阅读

相关正则表达式学习笔记

该笔记内容通过《Learn regular expressions in about 55 minutes》整理得到。文章链接：https://qntm.org/files

亦凉/ 2023年06月11日 03:19/ 0 赞/ 44 阅读

相关正则表达式学习笔记（全）

确实想简单学习一下正则表达式的同学们，在此也不建议大家到处去网上找什么乱七八糟的文章看，毛毛躁躁的也没法记住正则表达式。快速学习正则推荐《正则表达式必知必会》Ben Forta

水深无声/ 2022年07月14日 12:51/ 0 赞/ 235 阅读

相关正则表达式整理

正则表达式，能够用一段非常简短的表达式语句，便能够快速实现一个非常复杂的业务逻辑。熟练地掌握正则表达式的话，能够使你的开发效率得到极大的提升。本文介绍正则表达式

深藏阁楼爱情的钟/ 2022年07月12日 15:49/ 0 赞/ 257 阅读

相关正则表达式学习笔记

还没时间看，先放上收藏的资料链接，有时间再看下：正则表达式30分钟入门教程： [https://deerchao.net/tutorials/regex/regex.h

Love The Way You Lie/ 2022年06月15日 06:17/ 0 赞/ 292 阅读

相关 shell 正则表达式学习笔记

shell 正则表达式学习笔记 -------------------- 基础正则表达式 1. 行首定位符 `^` ``str=`ls /etc |

系统管理员/ 2022年05月18日 01:28/ 0 赞/ 315 阅读

相关正则表达式学习使用笔记整理

正则表达式一般来说分为正向正则表达式和逆向正则表达式正则表达式可以实现字符串匹配的功能，它采用一定的策略进行匹配，在有贪婪模式的情况下，正则会优先匹配能匹配的最大值，然后再

「爱情、让人受尽委屈。」/ 2022年04月16日 01:41/ 0 赞/ 187 阅读

相关正则表达式整理（基本）

格式化数字千分位 format(num) { var reg = /\d{1,3}(?=(\d{3})+$)/g r

红太狼/ 2022年03月01日 06:00/ 0 赞/ 294 阅读

相关正则表达式学习笔记

正则表达式无论是在爬虫还是其它的应用中都是有一定作用的。 1、常见的匹配模式模式　　　　　　　　　　　　　　　　　　　　　　　　　　描述 \w 　　　　　　　　

柔光的暖阳◎/ 2021年11月02日 13:32/ 0 赞/ 459 阅读

相关正则表达式整理

1.符号及描述： 2.常用运算符与表达式：　　^ 开始　　\ 匹配0次或更多　（）域段　　\[\] 包含,默认是一个字符长度　　\[^\]

今天药忘吃喽~/ 2021年09月30日 13:42/ 0 赞/ 363 阅读

相关正则表达式学习笔记

元字符常用元字符 . : 匹配除换行符以外的任意字符 \\w : 匹配字母或数字或下划线或汉字 \\s :

小灰灰/ 2021年06月26日 16:06/ 0 赞/ 529 阅读