js中的正则表达式入门

时间 2019-11-29

原文原文链接

什么是正则表达式呢？

正则表达式(regular expression)描述了一种字符串匹配的模式，能够用来检查一个字符串是否含有某种子串、将匹配的子串作替换或者从某个字符串中取出符合某个条件的子串等。node

说白了正则表达式就是处理字符串的,咱们能够用它来处理一些复杂的字符串。git

为何要学习正则表达式

咱们直接用一个例子来讲明github

//找出这个字符串中的全部数字
var str = 'abc123de45fgh6789qqq111';
//方法1
     function findNum(str) {
        var tmp = '',
            arr = [];
        for (var i = 0; i < str.length; i++) {
            var cur = str[i];
            if (!isNaN(cur)) {
                tmp += cur;
            } else {
                if (tmp) {
                    arr.push(tmp);
                    tmp = '';
                }
            }
        }
        if (tmp) {
            arr.push(tmp)
        }
        return arr;
    }
    console.log(findNum(str))
    //["123", "45", "6789", "111"]
    
//方法2 使用正则表达式
    var reg = /\d+/g;
    console.log(str.match(reg))
   // ["123", "45", "6789", "111"]

经过比较2种方法咱们明显看出在对字符串进行处理时，使用正则表达式会简单许多，因此虽然正则表达式看起来像是火星文同样的一堆乱码的东西，但咱们仍是有必要去学习它的。正则表达式

正则表达式的建立方式

字面量建立方式
实例建立方式

var reg = /pattern/flags
    // 字面量建立方式
    var reg = new RegExp(pattern,flags);
    //实例建立方式
    
    pattern:正则表达式  
    flags:标识(修饰符)
    标识主要包括：
    1. i 忽略大小写匹配
    2. m 多行匹配，即在到达一行文本末尾时还会继续寻常下一行中是否与正则匹配的项
    3. g 全局匹配 模式应用于全部字符串，而非在找到第一个匹配项时中止

字面量建立方式和构造函数建立方式的区别express

字面量建立方式不能进行字符串拼接，实例建立方式能够

var regParam = 'cm';
var reg1 = new RegExp(regParam+'1');
var reg2 = /regParam/;
console.log(reg1);  //   /cm1/
console.log(reg2);  //  /regParam/

字面量建立方式特殊含义的字符不须要转义，实例建立方式须要转义

var reg1 = new RegExp('\d');  //    /d/ 
var reg2 = new RegExp('\\d')  //   /\d/
var reg3 = /\d/;              //  /\d/

元字符

表明特殊含义的元字符数组

\d : 0-9之间的任意一个数字  \d只占一个位置
\w : 数字，字母 ，下划线 0-9 a-z A-Z _
\s : 空格或者空白等
\D : 除了\d
\W : 除了\w
\S : 除了\s
 . : 除了\n以外的任意一个字符
 \ : 转义字符
 | : 或者
() : 分组
\n : 匹配换行符
\b : 匹配边界 字符串的开头和结尾 空格的两边都是边界 => 不占用字符串位数
 ^ : 限定开始位置 => 自己不占位置
 $ : 限定结束位置 => 自己不占位置
[a-z] : 任意字母 []中的表示任意一个均可以
[^a-z] : 非字母 []中^表明除了
[abc] : abc三个字母中的任何一个 [^abc]除了这三个字母中的任何一个字符

表明次数的量词元字符函数

* : 0到多个
+ : 1到多个
? : 0次或1次 无关紧要
{n} : 正好n次；
{n,} : n到屡次
{n,m} : n次到m次

量词出如今元字符后面如\d+，限定出如今前面的元字符的次数学习

var str = '1223334444';
var reg = /\d{2}/g;
var res = str.match(reg);
console.log(res)  //["12", "23", "33", "44", "44"]

var str ='  我是空格君  ';
var reg = /^\s+|\s+$/g; //匹配开头结尾空格
var res = str.replace(reg,'');
console.log('('+res+')')  //(我是空格君)

正则中的()和[]和重复子项 //拿出来单独说一下this

通常[]中的字符没有特殊含义如+就表示+
可是像\w这样的仍是有特殊含义的

var str1 = 'abc';
var str2 = 'dbc';
var str3 = '.bc';
var reg = /[ab.]bc/; //此时的.就表示.
reg.test(str1)  //true
reg.test(str2)  //false
reg.test(str3)  //true

[]中，不会出现两位数

[12]表示1或者2 不过[0-9]这样的表示0到9 [a-z]表示a到z
例如:匹配从18到65年龄段全部的人
var reg = /[18-65]/; // 这样写对么
reg.test('50')
 //Uncaught SyntaxError: Invalid regular expression: /[18-65]/: Range out of order in character class
//聪明的你想多是8-6这里不对，因而改为[16-85]彷佛能够匹配16到85的年龄段的，但实际上发现这也是不靠谱的

实际上咱们匹配这个18-65年龄段的正则咱们要拆开来匹配
咱们拆成3部分来匹配 18-19  20-59 60-65 
reg = /(18|19)|([2-5]\d)|(6[0-5])/;

()的提升优先级功能:凡有|出现的时候，咱们必定要注意是否有必要加上()来提升优先级；url
()的分组重复子项 (两个放到一块儿说)

分组：
只要正则中出现了小括号那么就会造成一份分组
只要有分组，exec(match)和replace中的结果就会发生改变(后边的正则方法中再说)

分组的引用(重复子项) :
只要在正则中出现了括号就会造成一个分组，咱们能够经过\n (n是数字表明的是第几个分组)来引用这个分组，第一个小分组咱们能够用\1来表示

例如：求出这个字符串'abAAbcBCCccdaACBDDabcccddddaab'中出现最多的字母,并求出出现多少次(忽略大小写)。
var str = 'abbbbAAbcBCCccdaACBDDabcccddddaab';
    str = str.toLowerCase().split('').sort(function(a,b){return a.localeCompare(b)}).join('');

    var reg = /(\w)\1+/ig;
    var maxStr = '';
    var maxLen = 0;
    str.replace(reg,function($0,$1){
        var regLen = $0.length;
        if(regLen>maxLen){
            maxLen = regLen;
            maxStr = $1;
        }else if(maxLen == regLen){
            maxStr += $1;
        }
    })
    console.log(`出现最多的字母是${maxStr},共出现了${maxLen}次`)

当咱们加()只是为了提升优先级而不想捕获小分组时，能够在()中加?:来取消分组的捕获

var str = 'aaabbb';
var reg = /(a+)(?:b+)/;
var res =reg.exec(str);
console.log(res)
//["aaabbb", "aaa", index: 0, input: "aaabbb"]
//只捕获第一个小分组的内容

正则运算符的优先级

正则表达式从左到右进行计算，并遵循优先级顺序，这与算术表达式很是相似。
相同优先级的会从左到右进行运算，不一样优先级的运算先高后低。

下面是常见的运算符的优先级排列
依次从最高到最低说明各类正则表达式运算符的优先级顺序：

\ : 转义符
(), (?:), (?=), []  => 圆括号和方括号
*, +, ?, {n}, {n,}, {n,m}   => 量词限定符
^, $, \任何元字符、任何字符 
|       => 替换，"或"操做

字符具备高于替换运算符的优先级，通常用 | 的时候，为了提升 | 的优先级，咱们经常使用()来提升优先级
如： 匹配 food或者foot的时候 reg = /foo(t|d)/ 这样来匹配

正则的特性

贪婪性

所谓的贪婪性就是正则在捕获时，每一次会尽量多的去捕获符合条件的内容。
若是咱们想尽量的少的去捕获符合条件的字符串的话，能够在量词元字符后加?
懒惰性

懒惰性则是正则在成功捕获一次后无论后边的字符串有没有符合条件的都再也不捕获。
若是想捕获目标中全部符合条件的字符串的话，咱们能够用标识符g来标明是全局捕获

var str = '123aaa456';
var reg = /\d+/;  //只捕获一次,一次尽量多的捕获
var res = str.match(reg)
console.log(res)
// ["123", index: 0, input: "123aaa456"]
reg = /\d+?/g; //解决贪婪性、懒惰性
res = str.match(reg)
console.log(res)
// ["1", "2", "3", "4", "5", "6"]

和正则相关的一些方法

这里咱们只介绍test、exec、match和replace这四个方法

reg.test(str) 用来验证字符串是否符合正则符合返回true 不然返回false

var str = 'abc';
var reg = /\w+/;
console.log(reg.test(str));  //true

reg.exec() 用来捕获符合规则的字符串

var str = 'abc123cba456aaa789';
var reg = /\d+/;
console.log(reg.exec(str))
//  ["123", index: 3, input: "abc123cba456aaa789"];
console.log(reg.lastIndex)
// lastIndex : 0 

reg.exec捕获的数组中 
// [0:"123",index:3,input:"abc123cba456aaa789"]
0:"123" 表示咱们捕获到的字符串
index:3 表示捕获开始位置的索引
input 表示原有的字符串

当咱们用exec进行捕获时，若是正则没有加'g'标识符，则exec捕获的每次都是同一个，当正则中有'g'标识符时捕获的结果就不同了,咱们仍是来看刚刚的例子

var str = 'abc123cba456aaa789';
var reg = /\d+/g;  //此时加了标识符g
console.log(reg.lastIndex)
// lastIndex : 0 

console.log(reg.exec(str))
//  ["123", index: 3, input: "abc123cba456aaa789"]
console.log(reg.lastIndex)
// lastIndex : 6

console.log(reg.exec(str))
// ["456", index: 9, input: "abc123cba456aaa789"]
console.log(reg.lastIndex)
// lastIndex : 12

console.log(reg.exec(str))
// ["789", index: 15, input: "abc123cba456aaa789"]
console.log(reg.lastIndex)
// lastIndex : 18

console.log(reg.exec(str))
// null
console.log(reg.lastIndex)
// lastIndex : 0

每次调用exec方法时,捕获到的字符串都不相同
lastIndex ：这个属性记录的就是下一次捕获从哪一个索引开始。
当未开始捕获时，这个值为0。          
若是当前次捕获结果为null。那么lastIndex的值会被修改成0.下次从头开始捕获。
并且这个lastIndex属性还支持人为赋值。

exec的捕获还受分组()的影响

var str = '2017-01-05';
var reg = /-(\d+)/g
// ["-01", "01", index: 4, input: "2017-01-05"]
"-01" : 正则捕获到的内容
"01"  : 捕获到的字符串中的小分组中的内容

str.match(reg) 若是匹配成功，就返回匹配成功的数组，若是匹配不成功，就返回null

//match和exec的用法差很少
var str = 'abc123cba456aaa789';
var reg = /\d+/;
console.log(reg.exec(str));
//["123", index: 3, input: "abc123cba456aaa789"]
console.log(str.match(reg));
//["123", index: 3, input: "abc123cba456aaa789"]

上边两个方法console的结果有什么不一样呢？二个字符串是同样滴。
当咱们进行全局匹配时，两者的不一样就会显现出来了.

var str = 'abc123cba456aaa789';
var reg = /\d+/g;
console.log(reg.exec(str));
// ["123", index: 3, input: "abc123cba456aaa789"]
console.log(str.match(reg));
// ["123", "456", "789"]

当全局匹配时，match方法会一次性把符合匹配条件的字符串所有捕获到数组中,
若是想用exec来达到一样的效果须要执行屡次exec方法。

咱们能够尝试着用exec来简单模拟下match方法的实现。

String.prototype.myMatch = function (reg) {
    var arr = [];
    var res = reg.exec(this);
    if (reg.global) {
        while (res) {
            arr.push(res[0]);
            res = reg.exec(this)
        }
    }else{
        arr.push(res[0]);
    }
    return arr;
}

var str = 'abc123cba456aaa789';
var reg = /\d+/;
console.log(str.myMatch(reg))
// ["123"]

var str = 'abc123cba456aaa789';
var reg = /\d+/g;
console.log(str.myMatch(reg))
// ["123", "456", "789"]

此外，match和exec均可以受到分组()的影响，不过match只在没有标识符g的状况下才显示小分组的内容，若是有全局g，则match会一次性所有捕获放到数组中

var str = 'abc';
var reg = /(a)(b)(c)/;

console.log( str.match(reg) );
// ["abc", "a", "b", "c", index: 0, input: "abc"]
console.log( reg.exec(str) );
// ["abc", "a", "b", "c", index: 0, input: "abc"]


当有全局g的状况下
var str = 'abc';
var reg = /(a)(b)(c)/g;
console.log( str.match(reg) );
// ["abc"]
console.log( reg.exec(str) );
// ["abc", "a", "b", "c", index: 0, input: "abc"]

str.replace() 这个方法你们确定不陌生，如今咱们要说的就是和这个方法和正则相关的东西了。

正则去匹配字符串，匹配成功的字符去替换成新的字符串
写法：str.replace(reg,newStr);

var str = 'a111bc222de';
var res = str.replace(/\d/g,'Q')
console.log(res)
// "aQQQbcQQQde"

replace的第二个参数也能够是一个函数
str.replace(reg,fn);

var str = '2017-01-06';
str = str.replace(/-\d+/g,function(){
    console.log(arguments)
})

控制台打印结果：
["-01", 4, "2017-01-06"]
["-06", 7, "2017-01-06"]
"2017undefinedundefined"
从打印结果咱们发现每一次输出的值彷佛跟exec捕获时很类似，既然与exec彷佛很类似，那么彷佛也能够打印出小分组中的内容喽 

var str = '2017-01-06';
str = str.replace(/-(\d+)/g,function(){
    console.log(arguments)
})
["-01", "01", 4, "2017-01-06"]
["-06", "06", 7, "2017-01-06"]
"2017undefinedundefined"
从结果看来咱们的猜想没问题。

此外，咱们须要注意的是，若是咱们须要替换replace中正则找到的字符串，函数中须要一个返回值去替换正则捕获的内容。

经过replace方法获取url中的参数的方法

(function(pro){
    function queryString(){
        var obj = {},
            reg = /([^?&#+]+)=([^?&#+]+)/g;
        this.replace(reg,function($0,$1,$2){
            obj[$1] = $2;
        })
        return obj;
    }
    pro.queryString = queryString;
}(String.prototype));

// 例如 url为 https://www.baidu.com?a=1&b=2
// window.location.href.queryString();
// {a:1,b:2}

零宽断言

用于查找在某些内容(但并不包括这些内容)以前或以后的东西，如\b,^,$那样用于指定一个位置，这个位置应该知足必定的条件(即断言)，所以它们也被称为零宽断言。

在使用正则表达式时，捕获的内容先后必须是特定的内容，而咱们又不想捕获这些特定内容的时候，零宽断言就能够派上用场了。

零宽度正预测先行断言 (?=exp)
零宽度负预测先行断言 (?!exp)
零宽度正回顾后发断言 (?<=exp)
零宽度负回顾后发断言 (?<!exp)

这四胞胎看着名字好长，给人一种好复杂好难的感受，咱们仍是挨个来看看它们到底是干什么的吧。

(?=exp) 这个简单理解就是说字符出现的位置的右边必须匹配到exp这个表达式。

var str = "i'm singing and dancing";
var reg = /\b(\w+(?=ing\b))/g
var res = str.match(reg);
console.log(res)
// ["sing", "danc"]


注意一点，这里说到的是位置，不是字符。
var str = 'abc';
var reg = /a(?=b)c/;
console.log(res.test(str));  // false

// 这个看起来彷佛是正确的，实际上结果是false
reg中a(?=b)匹配字符串'abc' 字符串a的右边是b这个匹配没问题,接下来reg中a(?=b)后边的c匹配字符串时是从字符串'abc'中a的后边b的前边的这个位置开始匹配的，
这个至关于/ac/匹配'abc',显然结果是false了

(?!exp) 这个就是说字符出现的位置的右边不能是exp这个表达式。

var str = 'nodejs';
var reg = /node(?!js)/;
console.log(reg.test(str)) // false

(?<=exp) 这个就是说字符出现的位置的前边是exp这个表达式。

var str = '￥998$888';
var reg = /(?<=\$)\d+/;
console.log(reg.exec(str)) //888

(?<!exp) 这个就是说字符出现的位置的前边不能是exp这个表达式。

var str = '￥998$888';
var reg = /(?<!\$)\d+/;
console.log(reg.exec(str)) //998

最后，来一张思惟导图

图片若是放大也看不清的话下载地址若有错误欢迎指正！