RegExp使用技巧
正則表達式
//用法
1. /\d/g
2. new RegExp('/\d/','g')
//修飾符
g,i,m
//元字符
1.元字符是在正則表達式中有特殊含義的非字母字符
. * + ? $ ^ | \ () {} []
\t,\v,\n,\r,\0,\f,\cX
//字符類
1.元字符[]來構建一個簡單的類
2.元字符^建立反向類
[abc] , [^abc]
//範圍類
1.[a-z],[1-9]
//預約義類
. [^\r\n]
\d [0-9]
\D [^0-9]
\s [\t\n\xOB\f\r]
\S [^\t\n\xOB\f\r]
\w [a-zA-Z_0-9]
\W [^a-zA-Z_0-9]
//邊界
^ $ \b \B
"
@23
@45
@6
".replace(/^@\d/gm,'X')
//量詞
? 零次或一次
+ 一次或屢次
* 零次或屢次
{n} 出現n次
{n,m} 出現m到n次
{n,} 至少出現n次
//貪婪模式
'12345678'.replace(/\d{3,6}/g,'X')
//匹配最大次
//非貪婪模式
在量詞後面加?
'12345678'。replace(/\d{3,6}?/g,'X')
//匹配最少次
//分組
()能夠達到分組的功能，使量詞做用於分組
'a1b2c3d4'.replace(/([a-z]\d){3}/g,'X')
//反向引用
'2015-12-25'.replace(/(\d{4})-(\d{2})-(\d{2})/g,'$1$2$3')
//前瞻
正向前瞻exp(?=assert)
負向前瞻exp(?!assert)
'a2*3'.replace(/\w(?=\d)/g,'x')
//對象屬性
//.test()
var reg2 = /\w/g
reg2.test('ab')
reg2.lastIndex 從上一次的記錄開始匹配
//.exec()
// 沒有加g的調用每次從第一次開始搜素，不然從上一次，返回一個結果數組[匹配項，匹配子項]
var reg3 = /\d(\w)\d/;
var ts = '1a2b3c4d5e'
var ret = reg3.exec(ts)
console.log(reg3.lastIndex +
'\t' + ret.index + '\t' + ret.toStirng())
//string
'a1b2'.search(/1/g,'a')
var reg3 = /\d(\w)\d/;
var ts = '1a2b3c4d5e'
var ret = ts.match(reg3)
console.log(reg3.lastIndex +
'\t' + ret.index + '\t' + ret.toStirng())
'a,b,c,d'.split(',')
'a1b1c1'.replace(//,(匹配字符串，分組，匹配項索引，原字符串)=>{
})
g模式
var str = 'hello world hello life' reg1 = /hello/ reg2 = /hello/g //match非全局模式下返回一個數組 /* ["hello", index: 0, input: "hello world, hello life", groups: undefined] 0: "hello" //匹配的字符 groups: undefined index: 0 //匹配字符的起始位置 input: "hello world, hello life" //引用的文本 length: 1 */ str.match(reg1) //全局模式下返回匹配結果的數組 /* (2) ["hello", "hello"] 0: "hello" 1: "hello" length: 2 */ str.match(reg2)
m模式
m模式
// multiline
var mStr = 'hello world\n hello life',
mReg1 = /world$/,
mReg2 = /world$/m;
// 結果爲null，由於沒有啓用多行，world並不算mStr的結尾
mStr.match(mReg1); // null
// 匹配成功，啓用多行以後，world變成第一行的結尾
mStr.match(mReg2); // [ 'world', index: 6, input: 'hello world\n he
i模式
var cStr = 'Hello world',
cReg1 = /hello/,
cReg2 = /hello/i;
cReg1.exec(cStr); // null
cReg2.exec(cStr); // [ 'Hello', index: 0, input: 'Hello world' ]
RegExp實例方法
exec方法
exec主要用來提取捕獲組，接收一個字符做爲參數，若是匹配成功，返回一個匹配項信息的數組，在沒有匹配到的時候返回null
數組中包含2個屬性，index和input，index表示匹配字符串在文本的起始位置，input表示匹配的字符串
在非全局模式下，若是字符串中含有與模式匹配的多個子字符串，那麼只會返回第一個匹配項的結果，返回的數組中下標爲0的位置表示匹配到的字符串，其他位置表示匹配到的捕獲組信息，exec方法，依次返回的是每個匹配項信息的數組
// 在全局模式匹配下，找到第一個匹配項信息以後，若是繼續執行，會在字符串中繼續查找下一個匹配項
var str = `<div class="hello"><b>hello</b><i>regexp</i></div>`
var reg = /<(\/?)(\w+)([^>]*?)>/
var matches = reg.exec(str)
console.log(
matches[0],
matches[1],
matches[2],
matches[3],//分組的匹配結果
matches.index,//從第幾個字符開始匹配
reg.lastIndex//reg記錄最後一次匹配的位置
)
//與上一次匹配結果一致
var matches = reg.exec(str)
console.log(
matches[0],
matches[1],
matches[2],
matches[3],
matches.index,
reg.lastIndex
)
//加上全局模式後再次執行exec會從上次記錄的位置開始匹配
var reg = /<(\/?)(\w+)([^>]*?)>/g
var matches = reg.exec(str)
console.log(
matches[0],
matches[1],
matches[2],
matches[3],
matches.index,
reg.lastIndex
)
var matches = reg.exec(str)
console.log(
matches[0],
matches[1],
matches[2],
matches[3],
matches.index,
reg.lastIndex
)
test方法
//檢測字符串中是否有與模式匹配的字符
var pattern = /\d{2}-\d{3}/,
str = '29-234',
str1 = '290-3345',
str2 = '1-33245';
pattern.test(str); // true
pattern.test(str1); // true
pattern.test(str2); // false
RegExp構造函數屬性
構造函數靜態屬性，分別有一個長屬性名和一個短屬性名(Opera是例外，不支持短屬性名)。
長屬性名 短屬性名 說明
input $_ 最近一次要匹配的字符串
lastMatch $& 最近一次的匹配項
lastParen $+ 最近一次匹配的捕獲組
leftContext $` input字符串中lastMatch以前的文本
multiline $* 布爾值，表示是否全部表達式都使用多行模式
rightContext $' input字符串中lastMatch以後的文本
var pattern = /(.)or/,
str = 'this is a normal string or meaningful';
if (pattern.test(str)) {
console.log(RegExp.input); // this is a normal string or meaningful
console.log(RegExp.lastMatch); // nor
console.log(RegExp.lastParen); // n
console.log(RegExp.leftContext); // this is a
console.log(RegExp.multiline); // false
console.log(RegExp.rightContext); // mal string or meaningful
console.log(RegExp['$_']); // this is a normal string or meaningful
console.log(RegExp['$&']); // nor
console.log(RegExp['$+']); // n
console.log(RegExp['$`']); // this is a
console.log(RegExp['$*']); // false
console.log(RegExp['$\'']); // mal string or meaningful
}
用於模式匹配的string方法
str.search
//傳入一個正則表達式，若是不是會轉成正則表達式，返回匹配的位置，不支持全局g模式
var str = 'JavaScript is not java',
pattern = /Java/i,
pattern2 = /Java/ig;
console.log(str.search(pattern))
console.log(str.search(pattern2))
str.replace
//參數是一個正則表達式，若是參數不是正則表達式不會進行轉換，而是進行字符串匹配
var str = 'JavaScript is not java',
pattern = /Java/i;
console.log(str.replace(pattern, 'live')); // liveScript is not java
console.log(str.replace('Java', 'live')); // liveScript is n
//第二個參數是函數會拿到匹配結果
// function
var str2 = '123-456-789',
pattern2 = /(\d+)/g;
str2.replace(pattern2, function(v) {
// 會執行三次
// 第一次打印123
// 第二次打印456
// 第三次打印789
console.log(v);
});
/**
* 第一個參數表示匹配的字符串
* 第二個參數表示匹配的元組(若是沒有元組,則實際上回調函數只有三個值,即此時的d值會爲undefined)
* 第三個參數表示字符串匹配的開始索引
* 第四個參數表示匹配的字符串
*/
str2.replace(pattern2, function(a, b, c, d) {
// 會執行三次
// 第一次打印123, 123, 0, 123-456-789
// 第二次打印456, 456, 4, 123-456-789
// 第三次打印789, 789, 8, 123-456-789
console.log(a, b, c, d);
});
// 此時沒有進行元組匹配
str2.replace(/\d+/g, function(a, b, c, d) {
// 會執行三次
// 第一次打印123, 0, 123-456-789, undefined
// 第二次打印456, 4, 123-456-789, undefined
// 第三次打印789, 8, 123-456-789, undefined
console.log(a, b, c, d);
});
str.match
//全局模式下返回匹配數組，反之第一個是匹配結果，後面的是捕獲結果
var str3 = 'yuzhongzi_91@sina.com',
pattern3 = /^([a-zA-Z][\w\d]+)@([a-zA-Z0-9]+)(\.([a-zA-Z]+))+$/,
matches;
matches = str3.match(pattern3);
console.log(matches[0]); // yuzhongzi_91@sina.com
console.log(matches[1]); // yuzhongzi_91
console.log(matches[2]); // sina
console.log(matches[3]); // .com
console.log(matches[4]); // com
console.log(matches.index); // 0
console.log(matches.input); // yuzhongzi_91@sina.com
str.split
//第一個參數是分割模版，第二個參數是長度
var str4 = 'Hope left life become a cat.',
pat1 = /\s/,
pat2 = ' ';
console.log(str4.split(pat1)); // [ 'Hope', 'left', 'life', 'become', 'a', 'cat.' ]
console.log(str4.split(pat2),2); // [ 'Hope', 'left' ]
匹配
精準匹配
字符 匹配內容 [...] 方括號內的任意字符 [^...] 不在方括號內的任意字符 · 除換行符和其餘Unicode行終止符以外的任意字符 \w 任意ASCII字符組成的單詞，等價於[a-zA-Z0-9_] \W 任意不是ASCII字符組成的單詞，等價於[^a-zA-Z0-9_] \s 任何Unicode空白符 \S 任何非Unicode空白符的字符，注意w和S不一樣 \d 任何ASCII數字，等價於[0-9] \D 除了ASCII數字以外的任何字符，等價於[^0-9] \b 單詞邊界 \B 非單詞邊界 \t 水平製表符 \v 垂直製表符 \f 換頁符 \r 回車 \n 換行符 \cA:\cZ 控制符，例如：\cM匹配一個Control-M \u0000:\uFFFF 十六進制Unicode碼 \x00:\xFF 十六進制ASCII碼
// [abc] 表示匹配abc其中的一個
var str = 'abc',
pattern = /[abc]/;
console.log(str.match(pattern)); // [ 'a', index: 0, input: 'abc' ]
var str = 'abcd',
pattern = /[^abc]/;
console.log(str.match(pattern)); // [ 'd', index: 3, input: 'abcd' ]
// · 匹配除換行之外的字符
var str = '<p>I am a cat.</p>\n<b>what about you?</b>',
pattern = /.*/;
console.log(str.match(pattern)); // [ '<p>I am a cat.</p>', index: 0, input: '<p>I am a cat.</p>\n<b>what about you?</b>' ]
// \w 匹配包括下劃線的任意單詞字符
var str = 'Your are _ so cute #*& so | beatiful ',
pattern = /\w+/g;
console.log(str.match(pattern)); // [ 'Your', 'are', '_', 'so', 'cute', 'so', 'beatiful' ]
// \W 匹配任意非單詞字符
var str = 'Your are _ so cute #*& so | beatiful ',
pattern = /\W+/g;
console.log(str.match(pattern)); // [ ' ', ' ', ' ', ' ', ' #*& ', ' | ', ' ' ]
// \s 匹配空白字符
var str = 'Your \r\n\f ful',
pattern = /\s/g;
console.log(str.match(pattern)); // [ ' ', '\r', '\n', '\f', ' ' ]
console.log(str.match(pattern)); // [ 'Y', 'o', 'u', 'r', 'f', 'u', 'l' ]
// \d 匹配任意數字
var str = '123helloworld34javascript',
pattern = /\d+/g;
console.log(str.match(pattern)); // [ '123', '34' ]
// \D 匹配任意非數字
var str = '123helloworld34javascript',
pattern = /\D+/g;
console.log(str.match(pattern)); // [ 'helloworld', 'javascript' ]
// \b 匹配單詞邊界
var str = 'I never come back',
pattern = /e\b/g;
if (pattern.test(str)) {
console.log(RegExp['$&']); // e
console.log(RegExp['$`']); // I never com
}
// \B 匹配非單詞邊界
var str = 'I never come back',
pattern = /e\B/g;
if (pattern.test(str)) {
console.log(RegExp['$&']); // e
console.log(RegExp['$`']); // I n
}
// \n 匹配換行符
var str = 'hello \n world',
pattern = /\n/;
console.log(str.match(pattern)); // [ '\n', index: 6, input: 'hello \n world' ]
// \u0000:\uFFFF 匹配十六進制Unicode字符
var str = 'Visit W3School. Hello World!',
pattern = /\u0057/g;
console.log(str.match(pattern)); // [ 'W', 'W' ]
// \x00:\xFF 匹配十六進制ASCII字符
var str = 'Visit W3School. Hello World!',
pattern = /\x57/g;
console.log(str.match(pattern)); // [ 'W', 'W' ]
轉義
與其餘語言中的正則表達式相似，模式中使用的全部元字符都必須轉義。正則表達式中的元字符包括：
( [ { \ ^ $ | ? * + . } ] )
因爲RegExp構造函數的模式參數是字符串，因此在某些狀況下須要雙重轉義。例如：
字面量模式 等價的字符串
/\[abc\]/ "\\[abc\\]"
/\w{2, 3}/ "\\w{2, 3}"
var reg1 = /\[abc\]/,
reg2 = new RegExp("\\[abc\\]"),
str = '[abc]';
console.log(str.match(reg1)); // [ '[abc]', index: 0, input: '[abc]' ]
console.log(str.match(reg2)); // [ '[abc]', index: 0, input: '[abc]' ]
console.log(reg1.source); // \[abc\]
console.log(reg2.source); // \[abc\]
匹配開始和結尾
匹配一個字符串的開始使用符號(^)，例如: /^java/表示匹配已"java"開頭的字符串
匹配一個字符串的結尾使用符號($)，例如: /script$/表示匹配已"script"結尾的字符串
若是一個正則表達式中即出現了(^)又出現了($)，表示必須匹配整個候選字符串，例如：/^javaScript$/表示匹配整個"javaScript"字符串
var str = 'javaScript is fun',
str2 = 'JavaScript',
reg1 = /^java/,
reg2 = /fun$/i,
reg3 = /^javascript$/i;
console.log(reg1.test(str)); // true
console.log(reg2.test(str)); // true
console.log(reg3.test(str)); // false
console.log(reg3.test(str2)); // true
重複
貪婪重複
要連續匹配四個'a'，咱們可使用/aaaa/來進行匹配，但若是匹配的不止是四個，而是十幾個呢？想必是不方便的，在重複匹配的選項上，正則表達式提供了不少方式。
貪婪匹配 貪婪匹配表示儘量多的匹配，例如/a+/表示至少匹配一個"a"字符，即表示有多少個"a"就會匹配多少個，例如：
var str = 'aaaaa',
str1 = 'aaaaaaaaaa',
reg = /a+/;
console.log(reg.exec(str)); // [ 'aaaaa', index: 0, input: 'aaaaa' ]
console.log(reg.exec(str1)); // [ 'aaaaaaaaaa', index: 0, input: 'aaaaaaaaaa' ]
在貪婪重複上，正則表達式主要有如下方式：
字符 含義
{x,y} 匹配至少x次，最多y次
{x,} 匹配至少x次
{x} 匹配x次
? 匹配0次或者1次, { 0, 1 }
+ 匹配至少1次, { 1, }
* 匹配0次或者屢次, { 0, }
// {2,3} 匹配至少2次，最多3次
var str = '.abc.def.xyz.com',
reg = /(.\w+){2,3}/;
console.log(str.match(reg)); // [ '.abc.def.xyz', '.xyz', index: 0, input: '.abc.def.xyz.com' ]
// {2,} 匹配至少2次
var str = '.abc.def.xyz.com',
reg = /(.\w+){2,}/;
console.log(str.match(reg)); // [ '.abc.def.xyz.com', '.com', index: 0, input: '.abc.def.xyz.com'
// {2} 匹配2次
var str = '.abc.def.xyz.com',
reg = /(.\w+){2}/;
console.log(str.match(reg)); // [ '.abc.def', '.def', index: 0, input: '.abc.def.xyz.com' ]
// ? 匹配0次或者1次
var str = '.abc//.def.xyz.com',
reg = /(.\w+\/?)?/;
console.log(str.match(reg)); // [ '.abc/', '.abc/', index: 0, input: '.abc//.def.xyz.com' ]
// * 匹配0次或者屢次
var str = '.abc//.def.xyz.com',
reg = /(.\w+\/*)*/;
console.log(str.match(reg)); // [ '.abc//.def.xyz.com', '.com', index: 0, input: '.abc//.def.xyz.com' ]
非貪婪重複
非貪婪模式就是在貪婪模式後面加上一個"?"，表示儘儘量少的匹配，例如：
{x,y}?, {x,}?, {x}?, ??, +? *?
var str = 'aaaa',
str1 = '<p>Hello</p><p>Javascript</p>',
reg = /a+?/,
reg2 = /(<p>[^<]*<\/p>)+/,
reg3 = /(<p>[^<]*<\/p>)+?/;
console.log(reg.exec(str)); // [ 'a', index: 0, input: 'aaaa' ]
console.log(str1.match(reg2)); // [ '<p>Hello</p><p>Javascript</p>', '<p>Javascript</p>', index: 0, input: '<p>Hello</p><p>Javascript</p>' ]
console.log(str1.match(reg3)); // [ '<p>Hello</p>', '<p>Hello</p>', index: 0, input: '<p>Hello</p><p>Javascript</p>' ]
分組
使用()表示分組，表示匹配一類字符串，例如：/(\w\s)+/表示匹配一個或者多個以字母和空格組合出現的字符串
var str = 'a b c',
reg = /(\w\s)+/;
console.log(str.match(reg)); // [ 'a b ', 'b ', index: 0, input: 'a b c' ]
捕獲組
當用於模式匹配以後，匹配到的元組就被成爲捕獲組。捕獲組對應着括號的數量，分別使用$1,$2...$99...$x表示匹配到的捕獲組，另外可使用\1,\2...\99...\x表示引用捕獲組。
var str = '20170809',
str2 = '20170808',
reg = /(\d{4})(\d{2})(\d{2})/,
reg2 = /(\d{4})(\d{2})\2/;
console.log(str.replace(reg, '$1-$2-$3')); // 2017-08-09
console.log(str.replace(/a/, '$1/$2')); // 20170809
console.log(str.replace(reg2, '$1/$2')); // 20170809
console.log(str2.replace(reg2, '$1/$2')); // 2017/08
能夠看到第三個打印與第四個打印之間的差別，緣由是由於第三個沒有正則匹配項。
\x表示引用，引用的是具體的匹配字符串，也就是說上面例子中的\2引用的是第二個捕獲組中的內容，其實應該對應的是"08"字符串，所以"20170808"固然與"20170809"字符串不匹配；反證能夠看第四個匹配，驗證了上面的結果
非捕獲組
若但願以()分組的元組在匹配的時候不被捕獲，可使用以下形式：
(?:str|pattern)
var str2 = '20170808',
reg2 = /(?:\d{4})(\d{2})\1/;
console.log(str2.replace(reg2, '$1')); // 08
或操做符(|)
用(|)表示或者的關係。例如：/a|b/表示匹配字符"a"或者"b"，/(ab)+|(def)+/表示匹配一次或者屢次出現的"ab"或者"def"
斷言
正則表達式中的斷言大致分爲兩類，先行斷言與後發斷言；在每一種斷言中又分爲正環顧和負環顧，所以一共有四種斷言形式。 先行斷言 通俗的理解，先行斷言就是表示在匹配的字符串後必須出現(正)或者不出現(負)什麼字符串 (?=patten) 零寬正向先行斷言 (?!patten) 零寬負向先行斷言
// (?=patten)零寬正向先行斷言
var str = 'yuzhongzi91',
str2 = '123abc',
// 表示匹配以字母或者數字組成的，而且第一個字符必須爲小寫字母開頭的字符串
reg = /^(?=[a-z])([a-z0-9])+$/;
console.log(str.match(reg)); // [ 'yuzhongzi91', '1', index: 0, input: 'yuzhongzi91' ]
console.log(str2.match(reg)); // null
// (?!pattern)零寬負向先行斷言
var str = 'bb<div>I am a div</div><p>hello</p><i>world</i><p>javascript</p>',
// 表示匹配除了<p>標籤以外的標籤
// 分析：
// ?! 表示否認，這個能夠先不用看
// \/?p\b 表示匹配"/p"或者"p"
// [^>]+ 表示匹配不是">"字符
// 若是沒有"?!"就表示匹配"<p>"標籤
// 而加上了"?!"，就表示否認，所以就是匹配除了<p>標籤以外的標籤
reg = /<(?!\/?p\b)[^>]+>/g;
console.log(str.match(reg)); // [ '<div>', '</div>', '<i>', '</i>' ]
後發斷言(兼容性，測試目前仍不支持)
通俗的理解，後發斷言就是表示在匹配的字符串前必須出現(正)或者不出現(負)什麼字符串
(?<=patten) 零寬正向後發斷言
(?<!patten) 零寬負向後發斷言
var str = '<p>hello</p>',
reg = /(?<=<p>).*(?=<\/p>)/;
console.log(str.match(reg)); // 兼容狀況下會匹配到"hello"字符串
經常使用正則表達式
// 去除首尾字符串空格(trim)
var str = ' I am a cat. ',
reg = /^\s+|\s+$/;
console.log(str.replace(reg, '')); // I am a cat.
// 匹配電話號碼
var str = '0715-85624582-234',
str2 = '027-51486325',
// \d{3,4} 3-4位區號
// \d{8} 8位電話號碼
// (-(\d{3,4}))? 可能存在3-4位分機號
reg = /^(\d{3,4})-(\d{8})(?:-(\d{3,4}))?$/;
console.log(str.match(reg)); // [ '0715-85624582-234', '0715', '85624582', '234', index: 0, input: '0715-85624582-234' ]
console.log(str2.match(reg)); // [ '027-51486325', '027', '51486325', undefined, index: 0, input: '027-51486325' ]
// 匹配手機號碼
var str = '17985642351',
reg = /^1[3|4|5|7|8]\d{9}$/;
console.log(str.match(reg)); // [ '17985642351', index: 0, input: '17985642351' ]
// 匹配郵箱
var str3 = 'yuzhongzi_91.xiao@sina.com',
pattern3 = /^(?=[a-zA-Z])([\w\d-]+)(?:\.([\w\d-]+))*?@([a-zA-Z0-9]+)(?:\.([a-zA-Z]+))+$/;
// [ 'reg.xiao91@gmail.com', 'reg', 'xiao91', 'gmail', 'com', index: 0, input: 'reg.xiao91@gmail.com' ]
console.log(str3.match(pattern3));
// 限制文本框只能輸入數字和小數點(二位小數點)
var reg = /^\d*\.?\d{0,2}$/;
console.log(reg.test('.4')); // true
console.log(reg.test('3')); // true
console.log(reg.test('3.3333')); // false
// 匹配中文
var str = '223我是abc一隻貓234',
reg = /[\u4E00-\u9FA5\uf900-\ufa2d]/g;
console.log(str.match(reg)); // [ '我', '是', '一', '只', '貓' ]
// 匹配標籤中的內容
var str = '<div>java<p>hello</p>script</div>',
// 或者爲 /<div>(.*)<\/div>/ 但不能匹配'\n'
// /<div>((?:.|\s)*)<\/div>/
reg = /<div>[\s\S]*<\/div>/;
if (reg.test(str)) {
console.log(RegExp.$1); // java<p>hello</p>script
}
// 匹配帶有屬性的標籤
var str = '<div class="test" id="test" data-id="2345-766-sd24">hello</div>',
reg = /<([a-zA-Z]+)(\s*[a-zA-Z-]*?\s*=\s*".+?")*\s*>([\s\S]*?)<\/\1>/;
if (reg.test(str)) {
console.log(RegExp.$3); // hello
}
// 將數字轉化爲中文大寫字符
var arrs = ["零","壹","貳","叄","肆","伍","陸","柒","捌","玖"],
reg = /\d/g,
str = '135268492580',
res;
res = str.replace(reg, function(v) {
return arrs[v];
});
console.log(res); // 壹叄伍貳陸捌肆玖貳伍捌零
// 查找連接
var str = '<a href="http://www.rynxiao.com">rynxiao.com</a>',
reg = /http:\/\/(?:.?\w+)+/;
console.log(str.match(reg)[0]); // http://www.rynxiao.com
//ES6新增
構造函數能夠添加第二個規則參數
// es5添加第二個參數時會報錯
var regex = new RegExp(/test/, 'i');
// es6
var regex = new RegExp(/test/, 'ig');
regex.flags; // ig
添加了u修飾符，含義爲"Unicode"模式，用來正確處理大於\uFFFF的Unicode字符。
// \uD83D\uDC2A會被es5認爲是兩個字符，加了u以後就會被認定爲一個字符
/^\uD83D/u.test('\uD83D\uDC2A'); // false
/^\uD83D/.test('\uD83D\uDC2A'); // true
u字符對正則表達式行爲形成的影響，具體參考阮一峯的《ECMAScript 6入門》
添加了y修飾符(粘連修飾符)，全局匹配，但必須從剩餘字符串的第一個位置進行匹配。
var str = 'aaa_aa_a',
reg1 = /a+/g,
reg2 = /a+/y;
reg1.exec(str); // aaa
reg2.exec(str); // aaa
reg1.exec(str); // aa
// 第二次執爲null，是由於剩餘字符串爲_aa_a，必須從頭部開始匹配，所以沒有匹配到規則`a+`
// 若將reg1和reg2修改成`/a+_/g`和/a+_/y，結果將相同
reg2.exec(str); // null
增長了RegExp實例屬性sticky，表示是否設置了y標誌
var r = /test/y;
r.sticky; // true
增長了RegExp實例屬性flags，表示正則表達式的修飾符
var r = /test/ig;
r.flags; // gi
構造函數增長方法RegExp.escape()，表示對字符串轉義，用於正則模式
RegExp.escape('The Quick Brown Fox');
// "The Quick Brown Fox"
RegExp.escape('Buy it. use it. break it. fix it.');
// "Buy it\. use it\. break it\. fix it\."
RegExp.escape('(*.*)');
// "\(\*\.\*\)"
增長修飾符s，可使得.能夠匹配任意單個字符，包括行終止符(\n,\r,U+2018,U+2029)
const re = /foo.bar/s;
// 另外一種寫法
// const re = new RegExp('foo.bar', 's');
re.test('foo\nbar') // true
re.dotAll // true
re.flags // 's'
支持後行斷言，具體參看斷言所講
Unicode屬性類
目前，有一個提案，引入了一種新的類的寫法\p{...}和\P{...}，容許正則表達式匹配符合Unicode某種屬性的全部字符。
// 匹配全部數字
const regex = /^\p{Number}+$/u;
regex.test('²³¹¼½¾') // true
regex.test('㉛㉜㉝') // true
regex.test('ⅠⅡⅢⅣⅤⅥⅦⅧⅨⅩⅪⅫ') // true
相關文章
- 1. SystemTap使用技巧
- 2. NPM使用技巧
- 3. git 使用技巧
- 4. Idea使用技巧
- 5. JQ使用技巧
- 6. Chrome使用技巧
- 7. MacOS使用技巧
- 8. WORD 使用技巧
- 9. CComboBox使用技巧
- 10. Object.defineProperty使用技巧
- 更多相關文章...
- • Markdown 高級技巧 - Markdown 教程
- • TortoiseSVN 使用教程 - SVN 教程
- • Composer 安裝與使用
- • 使用Rxjava計算圓周率
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
最新文章
歡迎關注本站公眾號,獲取更多信息
相關文章
- 1. SystemTap使用技巧
- 2. NPM使用技巧
- 3. git 使用技巧
- 4. Idea使用技巧
- 5. JQ使用技巧
- 6. Chrome使用技巧
- 7. MacOS使用技巧
- 8. WORD 使用技巧
- 9. CComboBox使用技巧
- 10. Object.defineProperty使用技巧