JavaScript 正则表达式 零宽断言

介绍：

零宽断言的意思是（匹配宽度为零，满足一定的条件/断言）

零宽断言用于查找在某些内容(但并不包括这些内容)之前或之后的东西，也就是说它们像\b,^,$那样用于指定一个位置，这个位置应该满足一定的条件(即断言)。

 

分类：

零宽断言分为两类：

1. 正向零宽断言

2. 负向零宽断言

零宽断言分为四种：

1. 正向零宽先行断言：x(?=y)，表示：x 被 y 跟随时匹配 x

 

2. 正向零宽后发断言：(?<=y)x，表示：x 跟随 y 的情况下匹配 x

 

3. 负向零宽先行断言：x(?!y)，表示：x 没有被 y 紧随时匹配 x

 

4. 负向零宽后发断言：(?

 

关于名字：（不用太纠结）

正向零宽先行断言的英文是Lookahead assertion，翻译可能不统一，有的会省略“正向零宽”，直接叫先行断言、向前断言

正向零宽后发断言的英文是Lookbehind assertion，翻译可能不统一，有的会省略“正向零宽”，直接叫后发断言、向后断言、后行断言

负向零宽先行断言的英文是Negative lookahead assertion，翻译可能不统一，有的叫向前否定断言

负向零宽后发断言的英文是Negative lookbehind assertion，翻译可能不统一，有的叫向后否定断言

 

详细讲解：（具体解析过程看文章的解析过程部分）

1. 正向零宽断言：

1.1 先行断言（正向零宽先行断言）

写法：x(?=y)

x 被 y 跟随时匹配 x

 

例子：（具体解析过程看文章的解析过程部分）

var str1 = 'cooking'
var str2 = 'cooking dance'

var reg1 = new RegExp(/[a-z]*(?=ing)/)
console.log(reg1.exec(str1)) // ["cook", index: 0, input: "cooking", groups: undefined]
console.log(reg1.exec(str2)) // ["cook", index: 0, input: "cooking dance", groups: undefined]

 

注意：

先行断言的执行步骤大概是这样的：（具体解析过程看文章的解析过程部分）

①. 先从0开始匹配（字符串中的最左端）

②. 找到满足[a-z]*的字符，然后再匹配(?=ing)，若无法匹配。则更新索引位置（先缩减右侧索引，当右侧索引不能再缩减时，增加左侧索引）继续重复②步骤

 

关于先行断言是从最左端开始匹配还是从最右端开始匹配的问题：

 

var str1 = 'cooking singing going'

var reg1 = new RegExp(/[a-z]*(?=ing)/)
console.log(str1.match(reg1)) // ["cook", index: 0, input: "cooking singing going", groups: undefined]

var reg2 = new RegExp(/[a-z]*(?=ing)/g)
console.log(str1.match(reg2)) // ["cook", "", "sing", "", "go", ""]

我在查相关资料的时候，发现很多博客都说先行断言是从最右端开始匹配，但是从例子中可以看出来，先行断言是从最左端开始匹配的。

 

1.2 后发断言（正向零宽后发断言）

写法：(?<=y)x

 

x 跟随 y 的情况下匹配 x

 

例子：（具体解析过程看文章的解析过程部分）

var str1 = 'abcdefg'
var str2 = 'abcdefgabc'

var reg1 = new RegExp(/(?<=abc).*/)
console.log(reg1.exec(str1)) // ["defg", index: 3, input: "abcdefg", groups: undefined]
console.log(reg1.exec(str2)) // ["defgabc", index: 3, input: "abcdefgabc", groups: undefined]

var reg2 = new RegExp(/.*(?<=abc)/)
console.log(reg2.exec(str1)) // ["abc", index: 0, input: "abcdefg", groups: undefined]
console.log(reg2.exec(str2)) // ["abcdefgabc", index: 0, input: "abcdefgabc", groups: undefined]

 

注意：

后发断言跟先行断言恰恰相反，它的执行步骤是这样的：（具体解析过程看文章的解析过程部分）

①. 先从0开始匹配（字符串中的最左端）

②. 然后向左匹配(?<=abc)，若无法匹配，则更新索引位置（索引加一）。当满足(?<=abc)匹配时，匹配满足第二个条件.*的字符。以此类推重复步骤②，找到完全满足的字符

 

关于后发断言是从最左端开始匹配还是从最右端开始匹配的问题：

var str1 = 'abcdefgabc'

var reg1 = new RegExp(/(?<=abc).*/)
console.log(str1.match(reg1)) // ["defgabc", index: 3, input: "abcdefgabc", groups: undefined]

var reg2 = new RegExp(/(?<=abc).*/g)
console.log(str1.match(reg2)) // ["defgabc", ""]

从例子中可以看出来，后发断言是从最左端开始匹配的

 

2. 负向零宽断言

负向零宽断言也是匹配一个零宽度的位置，不过这个位置的“断言”取表达式的反值

负向零宽断言要注意的跟正向的一样

 

2.1 先行断言（负向零宽先行断言）

写法：x(?!y)

 

x 没有被 y 紧随时匹配 x

 

例子：（具体解析过程看文章的解析过程部分）

var str1 = 'abcdefg'
var str2 = 'abcdefgabg'

var reg1 = /ab(?!cd)/
console.log(reg1.exec(str1)) // null
console.log(reg1.exec(str2)) // ["ab", index: 7, input: "abcdefgabg", groups: undefined]

 

2.2 后发断言（负向零宽后发断言）

写法：(?

 

x 不跟随 y 时匹配 x

 

例子：（具体解析过程看文章的解析过程部分）

var str = '666-333'

var reg1 = /(? 
  
 
 
  
解析过程：
 
  
使用工具调试后，发现：正则的位置匹配（方向）是从最左端开始（向右）匹配的，零宽断言的匹配（方向）跟先行断言和后发断言有关，先行断言向后匹配，后发断言向左匹配
 
  
例子1. 使用：[a-z]*(?=ing)匹配“cooking”（看完以后自己联想“cooking dance”）
 
  
 
 
  
从0开始匹配，满足[a-z]*条件的是一直到7的位置（cooking），不满足(?=ing)。（因为是零宽，所以是不包含ing的）
 
  
　　继续匹配到6的位置（cookin），满足[a-z]*，不满足(?=ing)。
 
  
 
 
  
　　继续匹配到5的位置（cooki），满足[a-z]*，不满足(?=ing)。
 
  
　　继续匹配到4的位置（cook），满足[a-z]*，往右匹配i、n、g（一位一位检查），满足(?=ing)，得到结果：ook。
 
  
继续匹配。（因为已经匹配到4，所以从4开始）
 
  
从4开始匹配，满足[a-z]*条件的是一直到7的位置（ing），不满足(?=ing)。
 
  
　　继续匹配到6的位置（in），满足[a-z]*，不满足(?=ing)。
 
  
　　继续匹配到5的位置（i），满足[a-z]*，不满足(?=ing)。
 
  
　　继续匹配到4的位置（），满足[a-z]*，往右匹配i、n、g（一位一位检查），满足(?=ing)，得到结果：（空串）。
 
  
继续匹配。
 
  
从5开始匹配，满足[a-z]*条件的是一直到7的位置（ng），不满足(?=ing)。
 
  
　　继续匹配到6的位置（n），满足[a-z]*，不满足(?=ing)。
 
  
　　继续匹配到5的位置（），满足[a-z]*，不满足(?=ing)。
 
  
继续匹配。
 
  
从6开始匹配，满足[a-z]*条件的是一直到7的位置（g），不满足(?=ing)。
 
  
　　继续匹配到6的位置（），满足[a-z]*，不满足(?=ing)。
 
  
 
 
  
例子2. 使用：(?<=abc).*匹配“abcdefg”（看完以后自己联想“abcdefgabc”）
 
  
 
 
  
从0开始匹配，不满足(?<=abc)。
 
  
继续匹配。
 
  
从1开始匹配，不满足(?<=abc)。
 
  
继续匹配。
 
  
从2开始匹配，不满足(?<=abc)。
 
  
继续匹配。
 
  
从3开始匹配，往左匹配是否满足c、b、a（一位一位检查），满足(?<=abc)
 
  
　　从3到7位置（defg），满足.*，得到结果：defg。
 
  
 
 
  
例子2-2. 使用：.*(?<=abc)匹配“abcdefg”（看完以后自己联想“abcdefgabc”）
 
  
从0开始匹配，到位置7（abcdefg），满足.*，不满足(?<=abc)
 
  
　　继续匹配到6位置（abcdef），满足.*，不满足(?<=abc)
 
  
　　继续匹配到5位置（abcde），满足.*，不满足(?<=abc)
 
  
　　继续匹配到4位置（abcd），满足.*，不满足(?<=abc)
 
  
　　继续匹配到3位置（abc），满足.*，向左匹配是否满足c、b、a（一位一位检查），满足(?<=abc)，得到结果：abc
 
  
继续匹配。（因为已经匹配到3，所以从3开始）
 
  
从3开始匹配，到位置7（defg），满足.*，不满足(?<=abc)
 
  
　　继续匹配到6位置（def），满足.*，不满足(?<=abc)
 
  
　　继续匹配到5位置（de），满足.*，不满足(?<=abc)
 
  
　　继续匹配到4位置（d），满足.*，不满足(?<=abc)
 
  
　　继续匹配到3位置（），满足.*，向左匹配是否满足c、b、a（一位一位检查），满足(?<=abc)，得到结果：（空串）
 
  
继续匹配。
 
  
从4开始匹配，到位置7（efg），满足.*，不满足(?<=abc)
 
  
　　继续匹配到6位置（ef），满足.*，不满足(?<=abc)
 
  
　　继续匹配到5位置（e），满足.*，不满足(?<=abc)
 
  
　　继续匹配到4位置（），满足.*，不满足(?<=abc)
 
  
继续匹配。
 
  
从5开始匹配，到位置7（fg），满足.*，不满足(?<=abc)
 
  
　　继续匹配到6位置（f），满足.*，不满足(?<=abc)
 
  
　　继续匹配到5位置（），满足.*，不满足(?<=abc)
 
  
继续匹配。
 
  
从6开始匹配，到位置7（g），满足.*，不满足(?<=abc)
 
  
　　继续匹配到6位置（），满足.*，不满足(?<=abc)
 
  
 
 
  
例子3. 使用：ab(?!cd)匹配“abcdefg”（看完以后自己联想“abcdefgabg”）
 
  
 
 
  
从0开始匹配，
 
  
　　到1位置（a），满足ab。
 
  
　　到2位置（ab），满足ab。
 
  
　　到3位置（abc），满足(?!cd)。
 
  
　　到4位置（abcd），不满足(?!cd)。
 
  
继续匹配。
 
  
从1开始匹配（b），不满足ab。
 
  
继续匹配。
 
  
从2开始匹配（c），不满足ab。
 
  
继续匹配。
 
  
从3开始匹配（d），不满足ab。
 
  
继续匹配。
 
  
从4开始匹配（e），不满足ab。
 
  
继续匹配。
 
  
从5开始匹配（f），不满足ab。
 
  
继续匹配。
 
  
从6开始匹配（g），不满足ab。
 
  
 
 
  
例子4. 使用：(? 
  
 
 
  
从0开始匹配，到位置3（666），左侧没有字符，满足(? 
  
继续匹配。（因为已经匹配到3，所以从3开始）
 
  
从3开始匹配（-），左侧是6，满足(? 
  
继续匹配。
 
  
从4开始匹配（3），左侧是-，不满足(? 
  
继续匹配。
 
  
从5开始匹配（33），满足(? 
  
 
 
  
例子4-2. 使用：\d+(? 
  
从0开始匹配，到位置3（666），满足\d+，满足(? 
  
继续匹配。（因为已经匹配到3，所以从3开始）
 
  
从3开始匹配（-），不满足\d+
 
  
继续匹配。
 
  
从4开始匹配（333），满足\d+，满足(? 
  
 
 
  
小测一下：
 
  
var str1 = 'i am cooking meat.'
var str2 = 'cooking singing going'

var reg1 = new RegExp(/[a-z]*(?=ing)/)
console.log(reg1.exec(str1)) // ["cook", index: 5, input: "i am cooking meat.", groups: undefined]
console.log(reg1.exec(str2)) // ["cook", index: 0, input: "cooking singing going", groups: undefined]
 
  
var str1 = 'abZW863ab88'
var reg1 = /ab(?![A-Z])/g
console.log(reg1.exec(str1)) // ["ab", index: 7, input: "abZW863ab88", groups: undefined]
 
  
var str = '3'
var reg = /(? 
  
var str5 = 'abZW863'
var reg5 = /ab(?=[A-Z])/
console.log(reg5.exec(str5)) // ["ab", index: 0, input: "abZW863", groups: undefined]

var str6 = '
antzone'
var reg6 = /^(?=<)<[^>]+>\w+/
console.log(reg6.exec(str6)) // ["
antzone", index: 0, input: "
antzone", groups: undefined]

var str7 = '1234567890'
var reg7 = /((?=\d)\d{3})+\b/
console.log(reg7.exec(str7)) // ["234567890", "890", index: 1, input: "1234567890", groups: undefined]

var reg8 = new RegExp(/\b(?=re)\w+\b/)
var str8 = 'reading a book'
console.log(reg8.exec(str8)) // ["reading", index: 0, input: "reading a book", groups: undefined]

var reg9 = new RegExp(/\w+(?=ing)/)
var str9 = 'muing'
console.log(reg9.exec(str9)) // ["mu", index: 0, input: "muing", groups: undefined]

var str10 = "I'm singing while you're dancing."
var reg10 = /\b\w+(?=ing\b)/
console.log(reg10.exec(str10)) // ["sing", index: 4, input: "I'm singing while you're dancing.", groups: undefined]

console.log('-------------')

var str3 = 'I am reading'
var reg3 = new RegExp(/\b\w+(?<=ing\b)/)
console.log(reg3.exec(str3)) // ["reading", index: 5, input: "I am reading", groups: undefined]

var str4 = 'reading a book'
var reg4 = /(?<=\bre)\w+\b/
console.log(reg4.exec(str4)) // ["ading", index: 2, input: "reading a book", groups: undefined]

console.log('--------------')

var str = 'welcome! hello world! hi!'
var reg1 = /.*(?=hello)/
var reg2 = /.*(?<=hello)/
var reg3 = /.*(?!hello)/
var reg4 = /.*(? 
  
 
 
  
欢迎补充！欢迎纠正！