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 = /.*(?

 

欢迎补充!欢迎纠正!

你可能感兴趣的:(javascript)