javascript正则表达式总结

AlienZHOU 发布于2019-08-21 10:34 / 3518人阅读

摘要：匹配模式全局搜索，默认搜索到第一个匹配立刻停止忽略大小写，默认大小写敏感创建正则表达式两种方式完全匹配匹配字符串中的一部分找不到匹配不使用匹配，默认大小写敏感使用匹配，忽略大小写使用匹配不使用匹配使用全局模式匹配时，如果使用或方法匹配时

匹配模式

Flag	Description
g	Global search
i	Case-insensitive search
m	Multi-line search

g 全局搜索，默认搜索到第一个匹配立刻停止

i 忽略大小写，默认大小写敏感

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

var re = /pattern/flags;

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

javascript创建正则表达式两种方式

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匹配，默认大小写敏感：

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()会返回匹配的所有子串组成的数组

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" ]

Character	Meaning
	Matches a tab
	Matches a carriage return(回车)
	Matches a line feed(换行)
.	匹配.
/	匹配/
	匹配

预定义特殊字符

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("//");   //true

使用匹配例如：

javascript//.test("");        //true 匹配一个""
/^{2}$/.test("");   //true 匹配两个""

Character	Meaning
[xyz]	Character set.
[^xyz]	A negated or complemented character set.

集合

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 ∞.

量词

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次

关于{n}的例子：

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

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

console.log(arr);   // null

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

//"a"连续出现两次，匹配"aa"
var arr = re.exec(str);

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

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

//"a"连续出现3次，也只能匹配两个"a"
var arr = re.exec(str);

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

关于{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或多次集合中字符，在字符串中找到了最先出现的匹配"def"
// 优先匹配多个字符"def"，而不是1个字符"d"
var arr = re.exec(str);

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

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

// 匹配1或多次集合中字符，在字符串中找到了最先出现的匹配"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"]

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_].

预定义类

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_].

.匹配除了回车和换行之外的所有字符，等价于[^ ]

返回用空白符分隔的字符串组成的数组：

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

边界

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// 默认情况下为贪婪匹配，{3,5}优先从最大值5匹配
"123456789".match(/d{3,5}/g);  //["12345", "6789"]

// 在量词后面添加?为惰性匹配，{3,5}优先从最小值3匹配，如果匹配到则终止匹配
"123456789".match(/d{3,5}?/g); //["123", "456", "789"]

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

// 惰性匹配，当匹配到第一个"bbb"即停止匹配
"abbbcbbb".match(/.*?bbb/g); //["abbb", "cbbb"]

Character	Meaning
x\|y	Matches either "x" or "y".

或

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

分组匹配

Character Meaning

(x) Matches "x" and remembers the match

使用()进行分组匹配

javascript/(foo){3}/.test("foofoofoo");   //true 连续匹配"foo"3次

使用exec()，返回的数组的第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匹配，返回的数组的第0个元素存储匹配的字符串，从第1个元素开始依次存储分组字符串，同exec()的返回结果

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

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

使用g匹配，match返回的数组只存储匹配的字符串

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

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

虽然使用g匹配，match的结果没有保存分组信息，但实际上还是捕获到了分组信息，如：

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"和""

// 第二个参数为最后一次匹配的分组"dad"
"baddad".match(/([bd]ad?)*/);   //["baddad", "dad"]
"baddad".match(/([bd]ad?)*/g);  //["baddad", ""]

// 匹配到了ab，第1个元素为最外层分组"ab"，第2个元素为内层分组"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"

在正则表达式中使用

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

Character	Meaning
(?:x)	Matches "x" but does not remember the match.

非捕获性分组
不记录分组信息，不能创建反向引用的匹配，格式为(?: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.

前瞻捕获

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之间，结果匹配到了"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之间的位置(字符串开始和结束的两个"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]+匹配的结果
"abaa1".match(/[a-b]+(?!1)/);  //["aba"]

// "abc"共有4个间隔位置，分别是字符串开始和a之间，a和b之间，b和c之间，c和字符串结束之间
// 这里匹配每个位置如果后面的是b则不匹配，不为b则匹配，所以总共匹配了3个位置
"abc".match(/(?!b)/g);  //["", "", ""]

以上是我整理的正则学习笔记，参考了api文档和网上的一些资料，会有不全和不对的地方，希望大家提出，我好及时补充和更正。

GPU云服务器云服务器正则正则表达式正则匹配正则表达式 -正则表达式正则表达式?

文章版权归作者所有，未经允许请勿转载,若此文章存在违规行为，您可以联系管理员删除。

转载请注明本文地址：https://www.ucloud.cn/yun/85767.html

上一篇：自定义前端构建工具生成器 generator-pg-cloud

下一篇：ES6 Features系列：Template Strings & Tagged Templ

相关文章

正则表达式

摘要：本文内容共正则表达式火拼系列正则表达式回溯法原理学习正则表达式，是需要懂点儿匹配原理的。正则表达式迷你书问世了让帮你生成和解析参数字符串最全正则表达式总结验证号手机号中文邮编身份证地址等是正则表达式的缩写，作用是对字符串执行模式匹配。 JS 的正则表达式正则表达式一种几乎可以在所有的程序设计语言里和所有的计算机平台上使用的文字处理工具。它可以用来查找特定的信息（搜索），也可以用来查...

bang590 2019-08-22 13:59 评论0 收藏0

JavaScript正则表达式总结

摘要：正则表达式一直是里比较难以掌握的点。在中创建正则的两种方式使用字面量这就是正则表达式的字面量语法，表示正则表达式的模式，为正则表达式的标志。字面量形式的正则表达式一般使用较多，也推荐大家尽可能使用这种形式，简洁易读，符合正常的使用习惯。正则表达式一直是js里比较难以掌握的点。看不懂，学不会，记不住。每次需要用到正则的时候，都需要再去查找资料。今天花时间把正则的知识点总结下，希望...

big_cat 2019-08-22 18:32 评论0 收藏0

javascript正则表达式总结

摘要：如果你知道正则表达式模式将会改变，或者你事先不知道什么模式，而是从另一个来源获取，如用户输入，这些情况都可以使用构造函数。为什么要使用正则表达式正则表达式通过由普通字符和特殊字符组成的文字模板完成对字符串的校验，搜索，替换。在javascript中类似这样 /^1d{10}$/ 上面的这个简单的正则用来匹配手机号至于说正则表达式到底有什么意义，借由《精通正则表达式》里面的一句话来概...

impig33 2019-08-20 15:24 评论0 收藏0

密码强度的正则表达式（JavaScript）总结

摘要：简言本文给出了两个密码强度的正则表达式方案，一个简单，一个更复杂和安全。要写出正确的正则表达式，先要定义表达式规则。重复在正则表达式中用来表示元素重复出现的次数。你可以根据项目需要，自己调整上述正则表达式。简言本文给出了两个密码强度的正则表达式方案，一个简单，一个更复杂和安全。并分别给出了两个方案的解析和测试程序。一般大家可以根据自己的项目的实际需要，自行定义自己的密码正则约定。 ...

Carl 2019-08-22 15:14 评论0 收藏0

JavaScript学习总结（八）正则表达式

摘要：首先推荐几个正则表达式编辑器正则表达式是一种查找以及字符串替换操作。此表所列的常用正则表达式，除个别外均未在前后加上任何限定，请根据需要，自行处理。例如对而言，则采用一对引号来确定正则表达式的边界。这篇文章本来很早就要写的，拖了挺久的，现在整理下，供大家学习交流哈！基本概念正则表达式是一种文本模式，包括普通字符（例如，a 到 z 之间的字母）和特殊字符（称为元字符）。模式描述在搜...

trilever 2019-08-21 10:19 评论0 收藏0

正则表达式

摘要：最全正则表达式总结验证号手机号中文邮编身份证地址等是正则表达式的缩写，作用是对字符串执行模式匹配。学习目标了解正则表达式语法在中使用正则表达式在中使 JS高级技巧本篇是看的《JS高级程序设计》第23章《高级技巧》做的读书分享。本篇按照书里的思路根据自己的理解和经验，进行扩展延伸，同时指出书里的一些问题。将会讨论安全的类型检测、惰性载入函数、冻结对象、定时器等话题。1. 安全的类型检测...

yibinnn 2019-08-21 17:57 评论0 收藏0

发表评论

登陆后可评论

0条评论

AlienZHOU

男|高级讲师

我要关注我要私信

TA的文章
阅读更多

#黑五#virtono：全场最低3折优惠，标准vps首月€2.68起，大内存vps首月€18起，大硬

阅读 2079·2021-11-24 10:34

新晋独角兽房企估值10亿美元！品牌域名Place.com价值七位数！

阅读 3054·2021-11-22 11:58

二十五岁零基础转行做软件测试怎么样？一个过来人的心路历程送给迷茫的你

阅读 3711·2021-09-28 09:35

CSS居中完全指南——构建CSS居中决策树

阅读 1723·2019-08-30 15:53

轻松自定义一个响应式的timeline时间线组件（横向和纵向）

阅读 2769·2019-08-30 14:11

如何实现中间大两头小的轮播效果

阅读 1550·2019-08-29 17:31

30分钟用Node.js构建一个API服务器

阅读 541·2019-08-26 13:53

js中深拷贝与浅拷贝（堆内存、栈内存的关系）

阅读 2140·2019-08-26 13:45

最新活动

资讯专栏INFORMATION COLUMN

上云采购季！| 2核2G4M爆款云服务器低至59元/年，更有多台、长期优惠，快来选购！

javascript正则表达式总结

相关文章

正则表达式

JavaScript正则表达式总结

javascript正则表达式总结

**密码强度的正则表达式（JavaScript）总结**

***JavaScript学习总结（八）正则表达式***

正则表达式

发表评论

0条评论

AlienZHOU

男|高级讲师

TA的文章

#黑五#virtono：全场最低3折优惠，标准vps首月€2.68起，大内存vps首月€18起，大硬

新晋独角兽房企估值10亿美元！品牌域名Place.com价值七位数！

二十五岁零基础转行做软件测试怎么样？一个过来人的心路历程送给迷茫的你

CSS居中完全指南——构建CSS居中决策树

轻松自定义一个响应式的timeline时间线组件（横向和纵向）

如何实现中间大两头小的轮播效果

30分钟用Node.js构建一个API服务器

js中深拷贝与浅拷贝（堆内存、栈内存的关系）

最新活动