RegExp() 在es5中,RegExp的構造函數參數有兩種情況 1、字元串 2、正則表達式 // 第一種情況 let regex = new RegExp('abc', 'i') // 第二種情況 let regex2 = /abc/i 這兩種情況是等價的 let s = 'abc' regex ...
RegExp()
在es5
中,RegExp
的構造函數參數有兩種情況
1、字元串
2、正則表達式
// 第一種情況
let regex = new RegExp('abc', 'i')
// 第二種情況
let regex2 = /abc/i
這兩種情況是等價的
let s = 'abc'
regex.test(s) == regex2.test(s); // true
在es5中這兩種方式不能混用,如果第一個參數是一個正則,第二個是修飾會報錯
let regex3 = new RegExp(/abc/,'i')
// 報錯
es6
改變了這種行為,如果第一個是正則,第二個參數可以使用修飾符,並且返回的正則表達式會忽略原有的正則表達式修飾符,只使用新指定的修飾符。
let regex4 = new RegExp(/abc/ig, 'i')
在這裡,第二個參數i
會把原有的正則修飾符ig
覆蓋,最後的結果為/abc/i
u 修飾符
es6
對正則表達式添加了u
修飾符,表示為Unicode模式,用來處理大於\uFFFF
的Unicode
字元
/^\uD83D/u.test('\uD83D\uDC2A'); // false
這裡加上了u.
所以變成了es6
支持,將\uD83D\uDC2A
轉譯為一個字元,與\uD83D
不匹配,所以返回false
/^\uD83D/.test('\uD83D\uDC2A'); // true
這裡沒有加u.
為es5
支持,無法識別4個位元組的UTF-16
編碼。會將\uD83D\uDC2A
識別為兩個字元
,比對的時候其中的字元匹配,所以返回true
點字元 .
點字元在正則表達式中,表示除了換行符以外的任意單個字元,但對於碼點大於0xFFFF
的字元,點字元串無法識別,必須前面加上u
修飾符
let z = '正'
/^.$/.test(z); // true
/^.$/u.test(z); // true
Unicode 字元表示法
es6
新增了大括弧
表示unicode
字元,這種字元在正則中必須使用 u
修飾符才能識別,否則會被解讀為量詞,量詞是無法識別大於0xFFFF
的unicode
字元的。
/\u{61}/.test('a'); // false
/\u{61}/u.test('a'); // true
i 修飾符
i
修飾符為不區分大小寫,對於大於0xFFFF
的unicode
的修飾符,後面需要加上 u
/[a-z]/i.test('\u212A'); // false
/[a-z]/iu.test('\u212A'); // true
y 修飾符
y
修飾符,意為粘連(sticky)修飾符
在正則匹配中,g
為全局匹配且沒有位置限制
。
y
在正則匹配中,有位置限制,必須在上一次匹配完後的下一個字元串的第一位開始匹配。
let a = 'aaa-aa-a'
let r = /a+/y
let r2 = /a+/g
// 第一次匹配
r.exec(a); // aaa
r2.exec(a); // aaa
// 第二次匹配
r.exec(a); // null
r2.exec(a); // aa
y
為粘連,上一次匹配完後的下一個字元串第一位,第一位是:-
無法匹配上,解決的方法:其實只需要修改一下正則保證每次匹配上就行了 /a+-/y
g
為全局匹配沒有位置限制
RegExp.prototype.sticky
來檢查是否設置了 y 修飾符
let a1 = /heelo\d/y
console.log(a1.sticky); // true
檢測正則表達式修飾符以及正文
- source 返回正則匹配規則
- flags 返回正則的修飾符
let rul = /abc/ig
console.log(rul.source); // abc
console.log(rul.flags); // ig
s 修飾符 : dotAll模式
正則表達式中,點(.)
是一個特殊的字元,代表任意字元,但是有兩種例外
第一種:四個位元組的UTF-16
字元,這個使用 u
修飾符解決
第二種:行終止符,使用 s
修飾符解決
行終止符,就是該字元表示一行的終結,下麵四個字元屬於“行終止符”
- U+000A 換行符(
\n
) - U+000D 回車符(
\r
) - U+2028 行分隔符(line separator)
- U+2029 段分隔符(paragraph separator)
let f = /foo.bar/.test('foo\nbar')
console.log(f); // false // 因為.不匹配 \n ,所以正則表達式返回false
// 解決方法 : s 修飾符
/* 使用s修飾符,可以使 . 匹配任意單個字元 */
let f2 = /foo.bar/s.test('foo\nbar')
console.log(f2); // true
這種s修飾符的模式被稱為dotAll
模式,dot
就是代表一切字元。
所以,正則表達式還引入了dotAll
模式,檢查該表達式是否開啟了dotAll
模式。
let f3 = /foo.bar/s
console.log(f3.dotAll); // true // 開始了dotAll模式
先行斷言和後行斷言
先行斷言
先行斷言指的是,x在y的前面才匹配
語法:/x(?=y)/
x在y符號前才匹配
let look = '100% 東方不敗'
/\d+(?=%)/.exec(look); // 100 // 數字在百分號前面才匹配
let look2 = '100! 東方不敗'
console.log(/\d+(?=%)/.exec(look2)); // null 沒有匹配到%前的數字
後行斷言
與先行斷言相反,x在y的後面時才匹配
語法:/(?<=y)x/
說明: ? 後面跟 <= 條件y
let look3 = '東方不敗 $100 西方求敗'
/(?<=\$)\d+/.exec(look3); // 100 表示在\$後的字元才會被匹配
註意 : 先行斷言和後行斷言的條件是不計入返回結果的
具名組匹配
正則表達式使用圓括弧進行組的匹配,每組圓括弧代表著一個匹配,匹配結果可以從組中提取出來
let rul = /(\d{4})-(\d{2})-(\d{2})/
let r = rul.exec('2022-12-13')
console.log(r[1]); // 2022
console.log(r[2]); // 12
console.log(r[3]); // 13
雖然結果可以從組中提取出來,但它是通過下標提取的,如果組的順序發生改變,那麼下標也需要做對應更改,其實是不太方便的,對此es2018
引入了"具名組匹配",可以給組取別名,通過別名提取結果
語法:(?<別名>正則)
let rul2 = /(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/
let r2 = rul2.exec('2022-12-13')
console.log(r2.groups.year); // 2022
console.log(r2.groups.month); // 12
console.log(r2.groups.day); // 13
console.log(r2.groups.minute); // undefined 如果沒有匹配,那麼對象屬性為undefined
解構賦值和替換
通過上面的具名組匹配,給組取別名後,在正則的groups
中,匹配的屬性實際上是一個對象,通過解構賦值可以直接從匹配結果上為變數賦值。
. 可以匹配任意字元,查找單個字元,除了換行和行結束符。
n* 匹配任何包含零個或多個 n 的字元串。
解構:
let {groups : {hours,minute}} = /^(?<hours>.*):(?<minute>.*)/.exec('12:49')
console.log(hours,minute); // 12 49 // 通過解構賦值提取
替換
字元串替換時,使用$<組名>
進行替換
- 將匹配的字元串位置替換
- 不影響原正則表達式
let rul4 = /(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/u
console.log('2022-12-13'.replace(rul4,'$<day>/$<month>/$<year>')); // 13-12-2022
console.log(rul4); // /(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/u
replace()
的第二個參數可以是一個函數
let data = '2022-12-13'.replace(rul4,(matched,params1,param2,params3,position,sources,groups)=>{
let {day,month,year} = groups;
return `${day}/${month}/${year}`
})
console.log(data); // 13-12-2022
說明:
- matched // '2022-12-13' 匹配結果
- params1 // 第一個組匹配2022
- param2 // 第一個組匹配12
- params3 // 第一個組匹配13
- position // 匹配開始的位置 0
- sources // 原字元串 2022-12-13
- groups // 具名組構成的一個對象
引用
如果要在正則表達式內部引用某個“具名組匹配”,可以使用 \k<組名>
的寫法
let str = /^(?<word>[a-z]+)!\k<word>$/
str.test('abc!abc'); // true 引用了具名匹配,前後都是abc,前後字元一致
str.test('abc!ab'); // false 引用了具名匹配,前後字元不匹配,但是第二個少一個c
其實可以這麼理解,引用就是將前面定義好的組,拿過來複用。
數字引用
首先需要明確分組的概念,即正則中的()
中的內容是一個分組,裡面的內容作為一個整體引用。如果在分組後面接上 \數字
,表示匹配第幾個分組
let str2 = /^(\d{2})([a-z]+)\1$/
console.log(str2.test('11abcd')); // false
console.log(str2.test('11aa11')); // true
第一個輸出:問題出在結尾是英文,這裡結尾使用了\數字
,1
表示匹配第一個分組,第一個分組是必須是2
個數字,這裡的結尾用的英文所以返回false
第二個輸出:true
,其實這時的正則為/^(\d{2})([a-z]+)(\d{2})$/
,\1
引用了第一個組
具名匹配的引用和數字引用可以同時使用
let str3 = /^(?<word>[a-z]+)-(\d{2})-\k<word>-\2$/
str3.test('a-11-a-11'); // true
str3.test('a-11-a-aa'); // false
第一個輸出:這裡使用了引用以及數字引用
第二個輸出:false
, 結尾通過數字引用後,應該為數字\d{2}
d 修飾符:正則匹配索引
es2022
新增d
修飾符,可以在exec()
、match()
的返回結果添加indices
屬性,在該屬性上可以拿到匹配的開始位置和結束位置,下標從0
開始
let text = 'abcdefg'
let te = /bc/d
let result = te.exec(text)
result.index; // 1 拿到bc匹配的起始位置,下標為1
result.indices; // [1,3] 拿到bc匹配的開始和結束位置的下一個字元的位置
非常重要!!!這裡需要註意的是,匹配的字元串開始位置是字元串的第一個值,匹配的結束位置,並不在返回結果中,正確來說,匹配的結束位置是匹配字元串的末尾的下一個位置,如果這一句不理解,下麵的內容將會很難理解
如果正則中包含組匹配,那麼indices
屬性對應的數組就會包含多個成員,並且提供每個組的開始位置和結束位置
let text2 = 'abccdef'
let te2 = /bc+(de)/d
let result2 = te2.exec(text2)
console.log(result2.indices); // [1,6][4,6]
- 這裡的匹配並不是單個的匹配,而是整體,最外層的
bc
其實不參與單獨的匹配,而是放到bcde
整體中,所以第一個數組列印的是1,6
,b的下標為
1,
e的下一個字元的下標為
6` - 組會單獨進行匹配,
d
的下標為4
,e
的下一個字元的下標為6
多個組匹配以及下標
let text3 = 'abccdefgh'
let te3 = /bc+(de(fg))/d
let result3 = te3.exec(text3)
result3.indices; // [1,8][4,8][6,8]
匹配的順序:bcdefg
、defg
、fg
,對應的列印結果[1,8][4,8][6,8]
如果正則表達式包含具名匹配,那麼indices.groups
的屬性會是一個對象,可以從該對象獲取具名組匹配的開始位置和結束位置
let text4 = 'abcdefgh'
let te4 = /bc+(?<word>de)/d // 具名組<word>
let result4 = te4.exec(text4)
result4.indices; // [1,5][3,5]
result4.indices.groups; // {word : [3,5]}
如果未匹配上則列印undefined
String.prototype.matchAll()
matchAll()
可以一次性取出所有匹配,返回的是遍歷器(Iterator)而不是數組
let strings = 'test1test2test3';
let regex = /t(e)(st(\d?))/g;
for(let match of strings.matchAll(regex)){
console.log(match); // 返回所有匹配
}
轉為數組的方法一
[...strings.matchAll(regex)]; // 返回所有匹配,結果為數組
轉為數組的方法二
Array.from(strings.matchAll(regex)); // 返回所有匹配,結果為數組
案例源碼:https://gitee.com/wang_fan_w/es6-science-institute
如果覺得這篇文章對你有幫助,歡迎點亮一下star喲