国产xxxx99真实实拍_久久不雅视频_高清韩国a级特黄毛片_嗯老师别我我受不了了小说

資訊專欄INFORMATION COLUMN

javascript正則表達(dá)式總結(jié)

AlienZHOU / 3523人閱讀

摘要：匹配模式全局搜索，默認(rèn)搜索到第一個匹配立刻停止忽略大小寫，默認(rèn)大小寫敏感創(chuàng)建正則表達(dá)式兩種方式完全匹配匹配字符串中的一部分找不到匹配不使用匹配，默認(rèn)大小寫敏感使用匹配，忽略大小寫使用匹配不使用匹配使用全局模式匹配時，如果使用或方法匹配時

匹配模式
Flag Description
g Global search
i Case-insensitive search
m Multi-line search

g 全局搜索，默認(rèn)搜索到第一個匹配立刻停止

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

To include a flag with the regular expression, use this syntax:

var re = /pattern/flags;

or

var re = new RegExp("pattern", "flags");

javascript創(chuàng)建正則表達(dá)式兩種方式

javascriptvar re1 = new RegExp("abc", "g");

// equal to
var re2 = /abc/g;

console.log(re2 instanceof RegExp); //true

完全匹配：

javascriptvar re = /abc/;
var str = "abc";

var res = re.test(str);
var arr = re.exec(str);

console.log(res);   //true
console.log(arr);   //["abc"]

匹配字符串中的一部分：

javascriptvar re = /abc/;
var str = "123abcdefg";

var res = re.test(str);
var arr = re.exec(str);

console.log(res);   //true
console.log(arr);   //["abc"]

找不到匹配：

javascriptvar re = /abc/;
var str = "ab";

var res = re.test(str);
var arr = re.exec(str);

console.log(res);   //false
console.log(arr);   //null

不使用i匹配，默認(rèn)大小寫敏感：

javascriptvar re = /abc/;
var str = "ABC";

var res = re.test(str);
var arr = re.exec(str);

console.log(res);   //false
console.log(arr);   //null

使用i匹配，忽略大小寫：

javascriptvar re = /abc/i;
var str = "ABC";

var res = re.test(str);
var arr = re.exec(str);

console.log(res);   //true
console.log(arr);   //["ABC"]

使用g匹配：

javascriptvar re = /abc/g;
var str = "abc";

console.log(re.lastIndex);  //0

var res = re.test(str); //or re.exec(str)

console.log(re.lastIndex);  //3

不使用g匹配：

javascriptvar re = /abc/;
var str = "abc";

console.log(re.lastIndex);  //0

var res = re.test(str); //or re.exec(str)

console.log(re.lastIndex);  //0

使用全局模式g匹配時，如果使用.test()或.exec()方法匹配時，每次匹配到一個字符串后，lastIndex值會被更新，如果不使用g匹配，索引值lastIndex不會更新。

javascriptvar re = /abc/;
var str = "abc123abc456abc";

//未使用全局匹配時，只匹配到了第一個abc即終止
var arr = re.exec(str);

console.log(arr);   //["abc"]
console.log(re.lastIndex);  //0

javascriptvar re = /abc/g;
var str = "abc123abc456abc";

//使用全局匹配時，只匹配到了第一個abc即終止
var arr = re.exec(str);

console.log(arr);   //["abc"]
console.log(re.lastIndex);  //3，此時lastIndex指向字符串中的"1"

遍歷所有匹配：

javascriptvar re = /abc/g;
var str = "abc123abc456abc";
var arr, list = [];

while ( (arr = re.exec(str)) ) {
    console.log(arr);
    console.log(re.lastIndex);
    list.push(arr[0]);
}

console.log(list);

// output
// ["abc"]
// 3
// ["abc"]
// 9
// ["abc"]
// 15
// ["abc", "abc", "abc"]

使用String.prototype.match()

如果使用全局匹配g，String.prototype.match()會返回匹配的所有子串組成的數(shù)組

javascriptvar re = /abc/g;
var str = "abc123abc456abc";

var arr = str.match(re);

console.log(arr);   //["abc", "abc", "abc"]

javascriptvar re = /[bcf]at/gi;
var str = "a bat ,a Cat,a fAt bat ,a faT cat";

var arr = str.match(re);

console.log(arr);   //[ "bat", "Cat", "fAt", "bat", "faT", "cat" ]
預(yù)定義特殊字符
Character Meaning
Matches a tab
Matches a carriage return(回車)
Matches a line feed(換行)
. 匹配.
/ 匹配/
匹配

匹配水平制表符

javascriptvar re = /	/;
var str = "abc	def";

var res = re.test(str);
var arr = re.exec(str);

console.log(res);   //true
console.log(arr);   //["       "]

匹配回車

javascriptvar re = /
/;
var str = "abc
def";

var res = re.test(str); //true

匹配換行

javascriptvar re = /
/;
var str = "abc
def";

var res = re.test(str); //true

使用.匹配.例如：

javascript/[a-z].[0-9]/.test("a.9");     //true

使用/匹配/例如：

javascript///.test("/");     //true
//+/.test("http://");   //true

使用匹配例如：

javascript//.test("");        //true 匹配一個""
/^{2}$/.test("");   //true 匹配兩個""
集合
Character Meaning
[xyz] Character set.
[^xyz] A negated or complemented character set.

[xyz] 包含x,y,z任意一個字符的集合

[a-d] 等價于[abcd]，或[a-zA-Z0-9]匹配a-z,A-Z,0-9

[^xyz] 不包含x,y,z任意一個字符

[a-z.] 如果方括號中包含.，僅僅匹配一個.而不是量詞的.

[u4e00-u9fa5] 匹配單個漢字

javascriptvar re = /[xyz]/;
var str = "ax";
var arr = re.exec(str);
console.log(arr);   //["x"]

javascriptvar re = /[^xyz]/;
var str = "ax";
var arr = re.exec(str);
console.log(arr);   //["a"]

匹配集合中的.

javascriptvar re = /[a-z.]+/;     //或 var re = /[w.]+/
var str = "test.i.ng";
var arr = re.exec(str);
console.log(arr);   //["test.i.ng"]

javascript/[d-z]/.test("g");      //true
/[d-z]/.test("gg");     //true 匹配到第一個"g"立即停止匹配
/[^abc]/.test("g");     //true
/[^abc]/.test("gg");    //true 匹配到第一個"g"立即停止匹配
/[^abc]/.test("ga");    //true 匹配到第一個"g"立即停止匹配
量詞
Character Meaning
? Matches the preceding character 0 or 1 time. Equivalent to {0,1}.
+ Matches the preceding character 1 or more times. Equivalent to {1,}.
* Matches the preceding character 0 or more times. Equivalent to {0,}.
{n} Matches exactly n occurrences of the preceding character. N must be a positive integer.
{n,m} Matches at least n and at most m occurrences of the preceding character.When m is omitted, it"s treated as ∞.

{n}匹配n次

{n,m}匹配n到m次

{n,}最少匹配n次

{,m}最多匹配m次

關(guān)于{n}的例子：

javascriptvar re = /a{2}/;
var str = "a";

//由于"a"只出現(xiàn)1次，所以無法匹配exec返回null
var arr = re.exec(str);

console.log(arr);   // null

javascriptvar re = /a{2}/;
var str = "aa";

//"a"連續(xù)出現(xiàn)兩次，匹配"aa"
var arr = re.exec(str);

console.log(arr);   // ["aa"]

javascriptvar re = /a{2}/;
var str = "aaa";

//"a"連續(xù)出現(xiàn)3次，也只能匹配兩個"a"
var arr = re.exec(str);

console.log(arr);   // ["aa"]

關(guān)于{n,m}的例子

javascriptvar re = /a{2,5}/;
var str1 = "a";
var str2 = "aa";
var str3 = "aaaaa";
var str4 = "aaaaaa";

var arr1 = re.exec(str1);   //匹配不到
var arr2 = re.exec(str2);   //可以匹配到"aa"
var arr3 = re.exec(str3);   //可以匹配到"aaaaa"
var arr4 = re.exec(str4);   //最多只能匹配到5個a

console.log(arr1);  //null
console.log(arr2);  //["aa"]
console.log(arr3);  //["aaaaa"]
console.log(arr4);  //["aaaaa"]

匹配0或1個a

javascriptvar re = /a?/;
var str = "a";

// 匹配到了1個"a"
var res = re.test(str);
var arr = re.exec(str);

console.log(res);   // true
console.log(arr);   // ["a"]

javascriptvar re = /a?/;
var str = "";

// 匹配到了0個"a"
var res = re.test(str);
var arr = re.exec(str);

console.log(res);   // true
console.log(arr);   // [""]

javascriptvar re = /a+/;
var str = "aaabc";

// 最多匹配1個"a"
var arr = re.exec(str);

console.log(arr);   // ["a"]

匹配1或多個a

javascriptvar re = /a+/;
var str = "abc";

// 匹配到了1個"a"
var arr = re.exec(str);

console.log(arr);   // ["a"]

javascriptvar re = /a+/;
var str = "aaabc";

// 匹配到了多個"a"
var arr = re.exec(str);

console.log(arr);   // ["aaa"]

集合+量詞

javascriptvar re = /[a-z]?/;
var str = "aaabc";

// 匹配到了一個"a"
var arr = re.exec(str);

console.log(arr);   // ["a"]

javascriptvar re = /[a-z]+/;
var str = "aaabc";

// 匹配整個字符串
var arr = re.exec(str);

console.log(arr);   // ["aaabc"]

javascriptvar re = /[a-z]?/;
var str = "ABCdef";

// 匹配0或1次集合中字符，由于第一個字符不在集合中，所以匹配到了空字符（0個）
var arr = re.exec(str);

console.log(arr);   // [""]

javascriptvar re = /[a-z]?/;
var str = "abcABCdef";

// 匹配0或1次集合中字符，由于第一個字符在集合中，所以最多匹配了一個字符"a"
var arr = re.exec(str);

console.log(arr);   // ["a"]

javascriptvar re = /[a-z]+/;
var str = "ABCdefGHijk";

// 匹配1或多次集合中字符，在字符串中找到了最先出現(xiàn)的匹配"def"
// 優(yōu)先匹配多個字符"def"，而不是1個字符"d"
var arr = re.exec(str);

console.log(arr);   // ["def"]

javascriptvar re = /[a-z]+/;
var str = "aABCdefGHijk";

// 匹配1或多次集合中字符，在字符串中找到了最先出現(xiàn)的匹配"a"
// 由于接下來的是"A"所以停止匹配
var arr = re.exec(str);

console.log(arr);   // ["a"]

javascriptvar re = /[a-z]*/;
var str = "ABCdefGHijk";

// 匹配0或多次集合中字符，由于第一個字符不在集合中，所以匹配到了空字符（0個）
var arr = re.exec(str);

console.log(arr);   // [""]

javascriptvar re = /[a-z]*/;
var str = "abcABCdefGHijk";

// 匹配0或多次集合中字符，由于前面的3個字符"abc"在集合中，所以匹配到了"abc"
var arr = re.exec(str);

console.log(arr);   // ["abc"]
預(yù)定義類
Character Meaning
. matches any single character except the newline character.
d Matches a digit character. Equivalent to [0-9].
D Matches any non-digit character. Equivalent to [^0-9].
s Matches a single white space character, including space, tab, form feed, line feed（空白符）
S Matches a single character other than white space（非空白符）
w Matches any alphanumeric character including the underscore. Equivalent to [A-Za-z0-9_].
W Matches any non-word character. Equivalent to [^A-Za-z0-9_].

.匹配除了回車和換行之外的所有字符，等價于[^ ]

返回用空白符分隔的字符串組成的數(shù)組：

javascriptvar re = /S+/g;
var str = "abc def ghi";
var arr = str.match(re);
console.log(arr);   //["abc", "def", "ghi"]
邊界
Character Meaning
^ Matches beginning of input.
$ Matches end of input.
 Matches a word boundary
B Matches a non-word boundary 
javascript/abc/.test("123abc");    //true 匹配到abc
/^abc/.test("123abc");   //false 在字符串起始位置未匹配到
/abc/.test("abc123");    //true 匹配到abc

/abc/.test("abc123");   //true  
/abc$/.test("abc123");  //false
/abc$/.test("123abc");  //true

匹配單詞邊界，指[A-Za-z0-9_]之外的字符

B匹配非單詞邊界

javascript// 不使用邊界匹配
var arr1 = "-12w-eefd&efrew".match(/[w-]+/g);

// 由于[w-]包含"-"，所以匹配出的第一個字符串為"-12w-eefd"
console.log(arr1);   //["-12w-eefd", "efrew"]

// 使用邊界匹配
var arr2 = "-12w-eefd&efrew".match(/[w-]+/g);

// 從第一個[A-Za-z0-9_]之外的字符開始匹配，即從"-"作為起始點匹配，所以第一個匹配出的字符串不包含"-"，為"12w-eefd"
console.log(arr2);   //["12w-eefd", "efrew"]
貪婪模式和惰性模式

惰性模式匹配是在量詞后面加? 

javascript// 默認(rèn)情況下為貪婪匹配，{3,5}優(yōu)先從最大值5匹配
"123456789".match(/d{3,5}/g);  //["12345", "6789"]

// 在量詞后面添加?為惰性匹配，{3,5}優(yōu)先從最小值3匹配，如果匹配到則終止匹配
"123456789".match(/d{3,5}?/g); //["123", "456", "789"]

javascript// 貪婪匹配，匹配到整個字符串
"abbbcbbb".match(/.*bbb/g); //["abbbcbbb"]

// 惰性匹配，當(dāng)匹配到第一個"bbb"即停止匹配
"abbbcbbb".match(/.*?bbb/g); //["abbb", "cbbb"]
或
Character Meaning
x|y Matches either "x" or "y". 
javascript/a|b/.test("a");    //true 只匹配a或b任一個字符
/a|b/.test("c");    //false

javascript/[a|b]/.test("|");  //true 在集合中"|"不代表或，只代表字符"|"

javascript/(a|b|c)+/.test("a");   //true 可以在分組中使用"|"
分組匹配
Character Meaning
(x) Matches "x" and remembers the match

使用()進(jìn)行分組匹配

javascript/(foo){3}/.test("foofoofoo");   //true 連續(xù)匹配"foo"3次

使用exec()，返回的數(shù)組的第0個元素存儲匹配的字符串，從第1個元素開始依次存儲分組字符串

javascript// 第0個元素為匹配后的字符串"foofoofoo"，第1個元素存儲分組字符串"foo"
/(foo){3}/.exec("foofoofoo");   //["foofoofoo", "foo"]

// 第1，2個元素分別存儲"foo","bar"
/(foo){1}(bar){2}/.exec("foobarbar");   //["foobarbar", "foo", "bar"]

使用String.prototype.match()

不使用g匹配，返回的數(shù)組的第0個元素存儲匹配的字符串，從第1個元素開始依次存儲分組字符串，同exec()的返回結(jié)果

javascript"foobarbar".match(/(foo){1}(bar){2}/);  //["foobarbar", "foo", "bar"]

"abc123abcabc456abc".match(/(abc)+/);   //["abc", "abc"]

使用g匹配，match返回的數(shù)組只存儲匹配的字符串

javascript"foobarbar".match(/(foo){1}(bar){2}/g);  //["foobarbar"]

"abc123abcabc456abc".match(/(abc)+/g);   //["abc", "abcabc", "abc"]

雖然使用g匹配，match的結(jié)果沒有保存分組信息，但實際上還是捕獲到了分組信息，如：

javascript"foobarbar".match(/(foo){1}(bar){2}/g);     //["foobarbar"]

// 通過反向引用查看捕獲的分組信息
console.log(RegExp.$1);     //"foo"
console.log(RegExp.$2);     //"bar"

分組匹配的一些例子：

javascript"a".match(/(a)?/);  //["a", "a"]，匹配到了"a"
"a".match(/(a)?/g); //["a", ""]，匹配到了"a"和""
"aa".match(/(a)?/); //["a", "a"]，匹配到了第一個"a"
"aa".match(/(a)?/g);//["a", "a", ""]，匹配到了第一個"a"，第二個"a"，和""

"a".match(/(a)+/);  //["a", "a"]，匹配到了"a"
"a".match(/(a)+/g); //["a"]，只匹配到了"a"
"aa".match(/(a)+/); //["aa", "a"]，匹配了"aa"
"aa".match(/(a)+/g);//["aa"]，只匹配到了"aa"

"a".match(/(a)*/);  //["a", "a"]，匹配到了"a"
"a".match(/(a)*/g); //["a", ""]，匹配到了"a"和""
"aa".match(/(a)*/); //["aa", "a"]，匹配了"aa"
"aa".match(/(a)*/g);//["aa", ""]，匹配到了"aa"和""

// 第二個參數(shù)為最后一次匹配的分組"dad"
"baddad".match(/([bd]ad?)*/);   //["baddad", "dad"]
"baddad".match(/([bd]ad?)*/g);  //["baddad", ""]

// 匹配到了ab，第1個元素為最外層分組"ab"，第2個元素為內(nèi)層分組"b"
"ab".match(/(a(b)?)/);  //["ab", "ab", "b"]
反向引用

使用RegExp.$n 

javascript/(foo){3}/.exec("foofoofoo");   //["foofoofoo", "foo"]
console.log(RegExp.$1);     //"foo"

/(foo){1}(bar){2}/.exec("foobarbar");   //["foobarbar", "foo", "bar"]
console.log(RegExp.$1);     //"foo"
console.log(RegExp.$2);     //"bar"

在正則表達(dá)式中使用 

javascript/(foo)/.exec("foofoo");    //["foo", "foo"]

// 因為"1"="foo"，所以"/(foo)1/"等價于"/(foo)foo/"
/(foo)1/.exec("foofoo");      //["foofoo", "foo"]，匹配到了"foofoo"

在String.prototype.replace()中使用反向引用

javascriptvar re = /(w+)s(w+)/;
var str = "John Smith";
str.match(re);  //["John Smith", "John", "Smith"]
var newstr = str.replace(re, "$2, $1");
console.log(newstr);    //Smith, John
非捕獲性分組

不記錄分組信息，不能創(chuàng)建反向引用的匹配，格式為(?:x)

Character Meaning
(?:x) Matches "x" but does not remember the match. 
javascript// 正常情況下為捕獲性分組，匹配字符串"abc"，捕獲分組字符串"c"
"abc".match(/(w){3}/);     //["abc", "c"]

// 使用非捕獲性分組，匹配字符串"abc"，未捕獲到分組字符串
"abc".match(/(?:w){3}/);   //["abc"]

javascript// 正常情況下兩個分組信息都捕獲
"12345.123".match(/^(d)+.(d){3}$/g);

console.log(RegExp.$1); //5
console.log(RegExp.$2); //3

// 第一個分組使用非捕獲
"12345.123".match(/^(?:d)+.(d){3}$/g);

console.log(RegExp.$1); //3
console.log(RegExp.$2); //不存在
前瞻捕獲
Character Meaning
x(?=y) Matches "x" only if "x" is followed by "y". This is called a lookahead.
x(?!y) Matches "x" only if "x" is not followed by "y". This is called a negated lookahead.

正向前瞻匹配x(?=y)，找到x后面緊跟著y的位置，如果找到則匹配這個位置，返回x

逆向前瞻匹配x(?!y)，找到x后面不是y的位置，如果找到則匹配這個位置，返回x

括號()只代表匹配的一個位置，不代表匹配的字符

javascript// 匹配到了位置，在a和1之間，結(jié)果匹配到了"a"
"a1".match(/a(?=1)/);   //["a"]

// 匹配到了位置，在a和1之間，"d"匹配了后面的1
"a1".match(/a(?=1)d/);   //["a1"]

// 匹配了第一個a和1之間的位置
"a1bcdefa1".match(/a(?=1)/);    //["a"]

// 匹配到了所有的a和1之間的位置(字符串開始和結(jié)束的兩個"a1")
"a1bcdefa1".match(/a(?=1)/g);   //["a", "a"]

// 在a后面沒有找到1，所以沒有匹配到a和1之間的位置
"a2".match(/a(?=1)/);   //null

javascript// a后面為2不是1，所以找到了匹配的位置，在a和2之間
"a2".match(/a(?!1)/);   //["a"]

// 同上，用"d"匹配了2
"a2".match(/a(?!1)d/); //["a2"]

// 這里匹配的位置是"aba"和"a"之間的位置，返回的是[a-b]+匹配的結(jié)果
"abaa1".match(/[a-b]+(?!1)/);  //["aba"]

// "abc"共有4個間隔位置，分別是字符串開始和a之間，a和b之間，b和c之間，c和字符串結(jié)束之間
// 這里匹配每個位置如果后面的是b則不匹配，不為b則匹配，所以總共匹配了3個位置
"abc".match(/(?!b)/g);  //["", "", ""]

以上是我整理的正則學(xué)習(xí)筆記，參考了api文檔和網(wǎng)上的一些資料，會有不全和不對的地方，希望大家提出，我好及時補充和更正。

文章版權(quán)歸作者所有，未經(jīng)允許請勿轉(zhuǎn)載,若此文章存在違規(guī)行為，您可以聯(lián)系管理員刪除。

轉(zhuǎn)載請注明本文地址：http://specialneedsforspecialkids.com/yun/85767.html

相關(guān)文章

  • 正則表達(dá)式

    摘要：本文內(nèi)容共正則表達(dá)式火拼系列正則表達(dá)式回溯法原理學(xué)習(xí)正則表達(dá)式，是需要懂點兒匹配原理的。正則表達(dá)式迷你書問世了讓幫你生成和解析參數(shù)字符串最全正則表達(dá)式總結(jié)驗證號手機(jī)號中文郵編身份證地址等是正則表達(dá)式的縮寫，作用是對字符串執(zhí)行模式匹配。 JS 的正則表達(dá)式 正則表達(dá)式 一種幾乎可以在所有的程序設(shè)計語言里和所有的計算機(jī)平臺上使用的文字處理工具。它可以用來查找特定的信息（搜索），也可以用來查...

    bang590 評論0 收藏0

  • JavaScript正則表達(dá)式總結(jié)

    摘要：正則表達(dá)式一直是里比較難以掌握的點。在中創(chuàng)建正則的兩種方式使用字面量這就是正則表達(dá)式的字面量語法，表示正則表達(dá)式的模式，為正則表達(dá)式的標(biāo)志。字面量形式的正則表達(dá)式一般使用較多，也推薦大家盡可能使用這種形式，簡潔易讀，符合正常的使用習(xí)慣。 正則表達(dá)式一直是js里比較難以掌握的點。 看不懂，學(xué)不會，記不住。 每次需要用到正則的時候，都需要再去查找資料。 今天花時間把正則的知識點總結(jié)下，希望...

    big_cat 評論0 收藏0

  • javascript正則表達(dá)式總結(jié)

    摘要：如果你知道正則表達(dá)式模式將會改變，或者你事先不知道什么模式，而是從另一個來源獲取，如用戶輸入，這些情況都可以使用構(gòu)造函數(shù)。 為什么要使用正則表達(dá)式 正則表達(dá)式通過由普通字符和特殊字符組成的文字模板完成對字符串的校驗，搜索，替換。在javascript中類似這樣 /^1d{10}$/ 上面的這個簡單的正則用來匹配手機(jī)號至于說正則表達(dá)式到底有什么意義，借由《精通正則表達(dá)式》里面的一句話來概...

    impig33 評論0 收藏0

  • 密碼強度的正則表達(dá)式（JavaScript）總結(jié)

    摘要：簡言本文給出了兩個密碼強度的正則表達(dá)式方案，一個簡單，一個更復(fù)雜和安全。要寫出正確的正則表達(dá)式，先要定義表達(dá)式規(guī)則。重復(fù)在正則表達(dá)式中用來表示元素重復(fù)出現(xiàn)的次數(shù)。你可以根據(jù)項目需要，自己調(diào)整上述正則表達(dá)式。 簡言 本文給出了兩個密碼強度的正則表達(dá)式方案，一個簡單，一個更復(fù)雜和安全。并分別給出了兩個方案的解析和測試程序。一般大家可以根據(jù)自己的項目的實際需要，自行定義自己的密碼正則約定。 ...

    Carl 評論0 收藏0

  • JavaScript學(xué)習(xí)總結(jié)（八）正則表達(dá)式

    摘要：首先推薦幾個正則表達(dá)式編輯器正則表達(dá)式是一種查找以及字符串替換操作。此表所列的常用正則表達(dá)式，除個別外均未在前后加上任何限定，請根據(jù)需要，自行處理。例如對而言，則采用一對引號來確定正則表達(dá)式的邊界。 這篇文章本來很早就要寫的，拖了挺久的，現(xiàn)在整理下，供大家學(xué)習(xí)交流哈！ 基本概念 正則表達(dá)式是一種文本模式，包括普通字符（例如，a 到 z 之間的字母）和特殊字符（稱為元字符）。模式描述在搜...

    trilever 評論0 收藏0

  • 正則表達(dá)式

    摘要：最全正則表達(dá)式總結(jié)驗證號手機(jī)號中文郵編身份證地址等是正則表達(dá)式的縮寫，作用是對字符串執(zhí)行模式匹配。學(xué)習(xí)目標(biāo)了解正則表達(dá)式語法在中使用正則表達(dá)式在中使 JS高級技巧 本篇是看的《JS高級程序設(shè)計》第23章《高級技巧》做的讀書分享。本篇按照書里的思路根據(jù)自己的理解和經(jīng)驗，進(jìn)行擴(kuò)展延伸，同時指出書里的一些問題。將會討論安全的類型檢測、惰性載入函數(shù)、凍結(jié)對象、定時器等話題。1. 安全的類型檢測...

    yibinnn 評論0 收藏0

發(fā)表評論

0條評論

閱讀需要支付1元查看
<