Javascript 正則表達(dá)式

woshicixide 發(fā)布于2019-08-23 10:40 / 420人閱讀

摘要：正則表達(dá)式對(duì)象通過內(nèi)置對(duì)象支持正則表達(dá)式。做法很簡(jiǎn)單，就是在量詞后添加一個(gè)即可分組分組或分組取值前瞻正則表達(dá)式是從文本頭部向尾部解析。

正則表達(dá)式 REGEXP對(duì)象

javascript通過內(nèi)置對(duì)象Regexp支持正則表達(dá)式。

兩種方法來創(chuàng)建Regexp對(duì)象。

1、字面量

var reg = /d{4}/g;
// g 表示進(jìn)行全局替換

2、構(gòu)造函數(shù)

var reg = new RegExp("d{4}","g");

// 這里因?yàn)槭亲址?，需要?duì)特殊字符進(jìn)行轉(zhuǎn)義

// 利用正則進(jìn)行文本替換
var reg = new RegExp("is","g");
"what is this?".replace(reg, "IS");

// "what IS this?"

修飾符

g : global 全文搜索，如果不添加的話，搜索到第一個(gè)就匹配停止

i : ignore case 忽略大小寫，默認(rèn)大小寫敏感

m : multiple lines 多行搜索

"He is a boy. Is he?".replace(/is/g, "0");
// "He 0 a boy. Is he?"

"He is a boy. Is he?".replace(/is/gi, "0");
// "He 0 a boy. 0 he?"

元字符

正則表達(dá)式中有著兩種基本字符，原義文本字符 和 元字符；

原義文本字符: a b f r ...

元字符: 指有特殊含義的非字母字符 b t ...

正則表達(dá)式中的特殊字符： * + ? $ ^ . | [] {} ()

字符類

我們可以使用元字符 [] 來構(gòu)造一個(gè)簡(jiǎn)單的類

所謂類，就是符合某一個(gè)特征的對(duì)象，是泛指。

[abc]把a b c 歸為一類，表達(dá)式可以匹配這類字符

使用 ^可以取反，創(chuàng)建反向類,表示匹配不符合的字符

"a1b3c342bb".replace(/[abc]/g, "X");
// "X1X3X342XX"

"a1b3c342bb".replace(/[^abc]/g, "X");
// "aXbXcXXXbb"

范圍類

使用 [a-z]來鏈接兩個(gè)字符表示從 a到 z的任意字符；

[a-zA-Z0-9]

預(yù)定義類和邊界

預(yù)定義類

* .  [^
]  除了回車換行之外的任意字符

* d [0-9]    數(shù)字

* D [^0-9]   非數(shù)字

* s [	
f
x0B]  空白符

* S [^	
f
x0B] 非空白符

* w [0-9a-zA-Z_]  字母數(shù)字下劃線

* W [^0-9a-zA-Z_] 非字母數(shù)字下劃線

邊界

^ 開頭

$ 結(jié)尾

b 單詞邊界

B 非單詞邊界

"@abc@ab@".replace(/@./g, "Q");
// "QbcQb@"

"@abc@ab@".replace(/^@./g, "Q");
// "Qbc@ab@"

"@abc@ab@".replace(/.@$/g, "Q");
// "@abc@aQ"

// 驗(yàn)證 m 表示多行搜索
var mulSrt="@123
@456
%890";

mulSrt.replace(/@d/gm, "X");

"X23
X56
%890"

量詞

* ?  出現(xiàn)0次或者一次   0/1

* +  至少出現(xiàn)1次      >= 1

* *  出現(xiàn)零次或者一次  >= 0 

* {n} 出現(xiàn)n次

* {n, m} 出現(xiàn) n 到 m 次

* {n, }  至少出現(xiàn)n 次

貪婪模式和非貪婪模式

/d{3,6}/

匹配 12345678 得到 123456

// 這就是貪婪模式

非貪婪模式

讓正則表達(dá)式盡可能的少匹配，也就是說一旦匹配成功就不在繼續(xù)嘗試。[做法很簡(jiǎn)單，就是在量詞后添加一個(gè)?即可]

/d{3,5}?/g

分組

()分組

"a1b2c3d4".replace(/[a-z]d{3}/g, "X");
// a1b2c3d4

"a1b2c3d4".replace(/([a-z]d){3}/g, "X");
// Xd4

或 |

"meiaals".replace(/[a-z]+(aa|bb)[a-z]+/g, "0");
// 0

"meibbls".replace(/[a-z]+(aa|bb)[a-z]+/g, "0");
// 0

分組取值

"2016-04-23".replace(/(d{4})-(d{2})-(d{2})/, "$3-$2-$1");

// "23-04-2016"

前瞻

“正則表達(dá)式是從文本頭部向尾部解析”。這就像在走路，沒走過的路在你的前面，需要你往前看（前瞻）；走過的路需要你回頭看（后顧）

[js不支持后顧]

正向前瞻exp(?=assert)

負(fù)向前瞻exp(?!assert)

"a2*3".replace(/w(?=d)/g, "X");
// "X2*3"

對(duì)象屬性

global：是否全文搜索，默認(rèn)false

ignore case：是否大小寫敏感，默認(rèn)是false

multiline：多行搜索，默認(rèn)值是false

lastIndex：當(dāng)前表達(dá)式匹配內(nèi)容的最后一個(gè)字符的下一個(gè)位置

source：正則表達(dá)式的文本字符串

let regex = /(d{4}1)-(d{2})-(d{2})/g;

regex.source
// "(d{4}1)-(d{2})-(d{2})"

RegExp對(duì)象本身的方法

RegExp.prototype.test(str)

用戶測(cè)試某一個(gè)字符串是否存在匹配正則表達(dá)式模式的字符串，如果存在就返回true 、否則返回 false。

var reg2=/w/g;

進(jìn)行reg2.test("ab")時(shí)，第三次會(huì)變成false

原因：
while(reg2.test("ab")){
   console.log(reg2.lastIndex);
}

RegExp.prototype.exec(str)

如果沒有匹配返回null，如果匹配成功，返回一個(gè)數(shù)組。(index: 匹配文本的第一個(gè)字符的位置，input：存放被檢索的字符串的string)；

var reg = /d(w)(w)d/g;

var str = "$1ab343sdd5ef6";
var ret;
while(ret = reg.exec(str)) {
    console.log(ret[0] +"-"+ret[1] +"-"+ret[2]); 
    console.log(ret.index); 
}
// ["1ab3", "a", "b", index: 1, input: "$1ab343sdd5ef6", groups: undefined]

// ["5ef6", "e", "f", index: 10, input: "$1ab343sdd5ef6", groups: undefined]

// 第一個(gè)為匹配的字符串， 第二項(xiàng)之后都是分組內(nèi)容

String對(duì)象本身的方法

String.prototype.search(reg)

用于檢索字符串中指定的子字符串、或者檢索于正則匹配的子字符串。返回一個(gè)index，如果沒有找到返回-1. [忽略g，并且每次都是從開頭匹配]；

"wwasdasf7".search(/d/);
// 8

String.prototype.match(reg)

match方法將檢索字符串，以找到一個(gè)或者多個(gè)與regexp匹配的文本。
（是否有g(shù)影響很大）

如果找到了就返回一個(gè)數(shù)組，如果沒有找到，返回null

var reg = /d(w)(w)d/g;

var str = "$1ab343sdd5ef6";
var ret = str.match(reg);
console.log(ret);
// ["1ab3", "5ef6"]

String.prototype.split(str/reg)

"a,d,f,g,h".split(",");
// ["a", "d", "f", "g", "h"]

"a1b1c2d3f5".split(/d/g);
// ["a", "b", "c", "d", "f", ""]

String.prototype.replace(str, replacestr)

"asd231".replace("2", "S");

String.prototype.replace(reg, replacestr)

"asd231".replace(/d+/g, "S");

String.prototype.replace(reg, function)

// a1b2c3d4 => z2b3c4d5

"a1b2c3d4".replace(/d/g, function(match, index, origin){
    console.log(index);
    return parseInt(match) + 1;
})
// "a2b3c4d5"