澳门网络娱乐游戏平台-澳门电子游戏娱乐网址-官方直营

正则表达式学习笔记

JavaScript 正则表达式

正则表明式演练题点击这里

上学笔记

标签(空格分隔): 基本功 JavaScript


正则表达式是用来相配字符串中字符组合的形式。在javascript中,正则表明式也是指标。那个情势被用来RegExpexectest方法,以及Stringmatchreplacesearchsplit方法。

源码地址
原稿地址


创设二个正则表达式

利用叁个正则表明式字面量,其由满含在斜杠之间的方式组成,如下所示:

const regExp = /a+c/;  //匹配一个或多个a后面跟着'c'的字符串;
regExp.test('acbc'); //true
regExp.test('aacb'); //true

在加载脚本后,正则表明式字面值提供正则表达式的编写翻译。当正则表明式保持不变时,使用此办法可收获更加好的性质。

只怕调用RegExp对象的布局函数,如下所示:

const regExp = new RegExp('a+c');
console.log(regExp.test('aacbc')); //true

使用结构函数提供正则表明式的运转时编写翻译。使用结构函数,当您通晓正则说明式格局将会变动,也许您不了然格局,并从另叁个出自,如客商输入。

意气风发、创造叁个正则表明式

三种办法塑造正则表明式:

  1. 行使一个正则表明式字面来极度,其由富含在斜杠之间的格局组成。在加载脚本后,正则表明式字票面价值提供正则表明式的编写翻译。当正则表达式保持不改变时,使用此方法可获得更加好的属性。
const regex = /ab+c/;
const regex_2 = /^[a-zA-Z]+[0-9]*W?_$/gi;
  1. 调用RegExp目的的构造函数。使用布局函数提供正则表明式的运作时编写翻译。使用布局函数,当你精通正则表明式方式将会变动,恐怕您不明白方式,并从另贰个来源于,如顾客输入。
let regex_3 = new RegExp('ab+c');
let regex_4 = new RegExp(/^[a-zA-Z]+[0-9]*W?_$/, 'gi');
let regex_5 = new RegExp('^[a-zA-Z]+[0-9]*\W?_$', 'gi');

正则表明式中的特殊字符

二、编写八个正则表明式的方式

叁个正则表明式情势是由轻松的字符所构成的,例如/ab/,或许是简约和特殊字符的三结合,譬如/ab*c//Chapter (d+).d*/。或然应用了括号,它在正则表明式中能够被用做是贰个回想设备。那一部分的正则所匹配的字符将会被记住,在后头能够被应用。

字符

杰出将遵纪守法下列准绳:

在非特殊字符以前的反斜杠表示下四个字符是例外的,无法从字面上解释。比方,未有前边''的'b'平时相称小写'b',不论它们出今后哪个地方。假使加了'',那些字符变成了贰个非正规意义的字符,意思是相配叁个字符边界。

反斜杠也得以将其后的特殊字符,转义为字面量。比方,方式 /a*/ 代表会合营0 个也许四个 a。相反,情势 /a*/ 将 '*' 的特殊性移除,进而得以包容像 "a*" 那样的字符串。

const regExp1 = /a*/; // 匹配 0 个或者多个 a
const regExp2 = /a*/; // 匹配'a*' 字符串
console.log(regExp1.test('')); // true
console.log(regExp2.test(''));  // false
console.log(regExp2.test('a*'));  // true

1. 选拔简易的格局

大约的格局是由你找到的字符一向相配所构成的。比如/abc/其一模式就合作了字符串中但是字符'abc'同偶然间现身并据守那一个顺序。在'Hi, do u know ur abc's?'和'The latest artplane designs evolved from slabcraft.'都能相配成功。在上边三个实例中,相配的是子字符串'abc'。在字符串'Grab crab'少校不会被相称,因为它不含有别的的'abc'子字符串。

字符 ^

相当输入的发端。若是多行标记被安装为true,那么也合营换行符后紧跟之处。

比如说,/^A/ 并不会相称 "an A" 中的 'A',但是会相配 "An E" 中的 'A'。

当 '^' 作为第二个字符出未来二个字符会集情势时,它将会有两样的意思

const regExp = /^A/; // 匹配以'A'开头的字符串
console.log(regExp1.test('an A')); // false
console.log(regExp1.test('An E')); // true
const regExp2 = /[^abc]/;  // 匹配任何没有包含在方括号中的字符
console.log(regExp2.test('abc')); // false
console.log(regExp2.test('efg')); // true

2. 运用特殊字符

当您须求寻觅三个比直接相称供给越多规格的配适时,比方寻觅多少个或八个'b'前面跟了零个大概多少个'b'(*的情趣正是前方风华正茂项出现了零个要么八个),而且前面随着'c'的其它字符串'cbbabbbbcdebc'中,这几个形式相配了子字符串'abbbbc'。

正则表明式中的特殊字符

字符 含义
转义

匹配将依照下列规则:

在非特殊字符之前的反斜杠表示下一个字符是特殊的,不能从字面上解释。例如,没有''的'b'匹配小写'b',而加了表示匹配一个字符边界。

反斜杠也可以将其后的特殊字符,转义为字面量。例如,模式/a*/表示会匹配0个或者多个a;而模式/a*/表示匹配'a*'这样的字符串。

使用new RegExp('pattern')时需要将进行转义,因为在字符串里也是一个转义字符。
^ 匹配输入的开始。

如果多行标志被设置为true,那么也匹配换行符后紧跟的位置。

例如,/^A/并不会匹配'an A'中的A,但是会匹配'An E'中的A。

当'^'作为第一个字符出现在一个字符集合模式时,它将会有不同的含义。
$ 匹配输入的结束。匹配行或字符串的结尾。

如果多行标志被设置为true,那么也匹配换行符前的位置。

例如,/t$/不会匹配'eater'中的't',会匹配'eat'中的't'。
* 匹配前一个表达式0次或多次。等价于{0,}。

例如,/bo*/会匹配'A ghost boooooed'中的'booooo'和'A bird warbled'中的'b',但是在'A goat grunted'中将不会匹配。
+ 匹配前面一个表达式1次或者多次。等价于{1,}。

例如,在/a+/匹配了'candy'中的'a',和在'caaaaandy'中的所有'a'。
? 匹配前面一个表达式0次或1次。等价于{0,1}。

例如,/e?le?/匹配'angel'中的'el','angle'中的'le','oslo'中的'l'。

如果紧跟在任何量词、+?或{}的后面,将会使量词变为非贪婪的(匹配尽量少的字符),和缺省使用的贪婪模式正好相反。

例如,'123abc'应用/d+/将会返回'123',如果使用/d+?/,就只会匹配到'1'。

还可以运用于先行断言,比如本表的x(?=y)x(?!y)条目中所述。
. (小数点)匹配除换行符之外的任何单个字符。

例如,/.n/匹配'nay, an apple is on the tree'中的'an'和'on',不会匹配'nay'。
(x) 匹配'x'并且记住匹配项,就像下面的例子展示的那样,括号被称为捕获括号

模式/(foo) (bar) 1 2/中的'(foo)'和'(bar)'匹配并记住字符串'foo bar foo bar'中的前两个单词。模式中的12匹配字符串的后两个单词。注意使用12n是用在正则表达式的匹配环节。在正则表达式的替换环节,则要使用像$1$2$n的语法,例如,'bar foo'.replace(/(...) (...)/, '$2 $1')

(?:x) 匹配'x'但是不记住匹配项。这种叫做非捕获括号,使得你能够定义为与正则表达式运算符一起使用的子表达式。

来看示例表达式/(?:foo){1,2}/。如果表达式是/foo{1,2}/,{1,2}将只对'foo'的最后一个字符'o'生效。如果使用非捕获括号,则{1,2}会匹配整个'foo'单词。
x(?=y) 匹配'x'仅仅当'x'后面跟着'y'。这种叫做正向肯定查找

例如,/Jack(?=Sprat)/会匹配到'Jack'仅仅当它后面跟着'Sprat'。/Jack(?=Sprat|Frost)/匹配'Jack'仅当它后面跟着'Sprat'或者是'Frost'。但是'Sprat'和'Frost'都不是匹配结果的一部分。

x(?!y) 匹配'x'仅当'x'后面不跟着'y',这叫做正向否定查找

例如,/d+(?!.)/匹配一个数字仅仅当这个数字后面没有跟小数点的时候。正则表达式/d+(?!.)/.exec('3.141')匹配'141'而不是'3.141'。
x|y 匹配x或者y。

例如,/green|red/匹配'green apple'中的'green'和'red apple'中的'red'。
{n} n是一个正整数,匹配了前面一个字符刚好发生了n次。

比如,/a{2}/不会匹配'candy'中的'a',但是会匹配'caandy'中所有的a,以及'caaandy'中的前两个'a'。

{n,m} n和m都是整数。匹配前面的字符至少n次,最多m次。如果n或者m的值是0,这个值被忽略。

例如,/a{1,3}/并不匹配'cndy'中的任意字符,匹配'candy'中的a,匹配'caandy'中的前两个a,匹配'caaaaaandy'中的前3个a。

[xyz] 一个字符集合。匹配方括号中的任意字符,包括转义序列。

你可以用短横线(-)来指定一个字符范围。对于点(.)和星号(*)这样的特殊符号在一个字符集中没有特殊的意义。他们不必进行转义,不过转义也是起作用的。

例如,[abcd][a-d]是一样的,他们都匹配'brisket'中的'b',也都匹配'city'中的'c'。/[a-z.]+//[w.]+/都匹配'test.i.ng'中的所有字符。

[^xyz] 一个反向字符集。也就是说,它匹配任何没有包含在方括号中的字符。你可以使用短横线(-)来指定一个字符范围。任何普通字符在这里都起作用。

例如,[^abc][^a-c]是一样的。他们匹配'brisket'中的'r',也匹配'chop'中的'h'。

[b] 匹配一个退格(U+0008)(不要和b混淆)。
b 匹配一个词的边界。一个词的边界就是一个词不被另外一个词跟随的位置或者不是另一个词汇字符前边的位置。注意一个匹配的词的边界并不包含在匹配内容中。换句话说,一个匹配的词的边界的内容长度是0。

例如,/bm/匹配'moon'中的'm'。

/oob/不匹配'moon'中的'oo',因为'oo'被一个词汇字符'n'紧跟着。

/oonb/匹配'moon'中的'oon',因为'oon'是这个字符串的结束部分。这样它没有被一个词汇字符紧跟着。

/wbw/将不能匹配任何字符串,因为一个单词中的字符永远也不可能被一个非词汇字符和一个词汇字符同时紧跟着。

注意:javascript的正则表达式引擎将»特定的字符集定义为“字”字符。不在该集合中的任何字符都被认为是一个断词。这组字符相当有限:它只包括大写和小写的罗马字母小数位数下划线字符。不幸的是,重要的字符,例如'é'和'ü'被视为断词。
B 匹配一个非单词边界。它匹配一个前后字符都是相同类型的位置:都是字符或者都不是单词。一个字符串的开始和结尾都被认为是非单词。

例如,/B../匹配'noonday'中的'oo',而/yB/匹配'possibly yesterday'中的'y'。

cX 当X是处于A到Z之间的字符的时候,匹配字符串中的一个控制符。

例如,/cM/匹配字符串中的control-M(U+000D)。
d 匹配一个数字。

等价于[0-9]

例如,/d/或者/[0-9]/匹配'B2 is the suite number.'中的'2'。

D 匹配一个非数字子字符。

等价于[^0-9]

例如,/D/或者/[^0-9]/匹配'B2 is the suite number.'中的'B'。
f 匹配一个换页符(U+000C)。
n 匹配一个换页符(U+000A)。
r 匹配一个换页符(U+000D)。
s 匹配一个空白字符,包括空格、制表符、换页符和换行符。

等价于[fnrtvu00a0u1680u180eu2000-u200au2028u2029u202fu205fu3000ufeff]

例如,/sw*/匹配'foo bar'中的' bar'。
S 匹配一个非空白字符。

等价于[^fnrtvu00a0u1680u180eu2000-u200au2028u2029u202fu205fu3000ufeff]

例如,/Sw*/匹配'foo bar'中的'foo'。

t 匹配一个水平制表符(U+0009)。
v 匹配一个垂直制表符(U+000B)。
w 匹配一个单字字符(字母、数字、下划线)。

等价于[A-Za-z0-9_]

例如,/w/匹配'apple'中的'a','$5.28'中的'5','3D.'中的'3'。

W 匹配一个非单字字符。

等价于[^A-Za-z0-9_]

例如,/W/匹配'50%'中的'%'。
n 当n是一个正整数,一个返回引用到最后一个与有n插入的正值表达式(counting left parentheses)匹配的副字符串。

比如,/apple(,)sorange1/匹配'apple, orange, cherry, peach'中的'apple,orange,'。按照我的理解,n就是在此之前需要的捕获括号的下标(从1开始)。

匹配NULL(U+0000)字符,不要在这后面跟其它小数,因为<digits>是一个八进制转义序列。
xhh 与代码hh匹配字符(两个十六进制数字)。
uhhhh 与代码hhhh匹配字符(四个十六进制数字)。
u{hhhh} (仅当设置了u标志时)使用Unicode值hhhh匹配字符(十六进制数字)。

将客户输入转义为正则表明式中的三个字面字符串,可以经过简单的交替来落到实处:

function escapeRegExp(string) {
    return string.replace(/([.*+?^=!:${}()|[]/\])/g, '\$&'/);
    // $&表示整个被匹配的字符串
}

字符 $

合作输入的收尾。倘使多行标示被设置为true,那么也相称换行符前的职分。

举例,/t$/ 并不会相称 "eater" 中的 't',不过会相配 "eat" 中的 't'。

//匹配以'abc'结尾的字符串;
const regExp1 = /abc$/; 
//匹配以'abc'开头又以'abc'结尾的字符串,即匹配'abc'。
const regExp2 = /^abc$/; 
console.log(regExp1.test('aaabc')); // true
console.log(regExp2.test('aaabc')); // false
console.log(regExp2.test('abc'));  // true

3. 施用插入语

任何正则表明式的插入语都会使那某个同盟的副字符串被回想。生机勃勃旦被记念,那么些副字符串就足以被调用于别的用场,就如使用括号的子字符串相称中所述。

比如,/Chapter (d+).d*/解释了附加转义的和异样的字符,并证实了那生龙活虎部分pattern应该被记念。它纯粹地协作后边随着一个上述数字字符的字符'Chapter'(d意为任何数字字符,+意为1次以上),跟着一个小数点(在这里个字符中本身也是四个特殊字符,小数点前的意味着那一个pattern必得寻觅字面字符'.'),跟着别的数字字符0次以上。(d表示数字字符,*代表0次之上)。别的,插入语也用来回忆第八个非常的数字字符。

此情势能够相称字符串'Open Chapter 4.3, paragraph 6',而且'4'将会被铭记。此格局并无法相配'Chapter 3 and 4',因为在此个字符串中'3'前边未有一点'.'。

let str_17 = 'Open Chapter 4.3, paragraph 6';
console.log(/Chapter (d+).d*/.exec(str_17)); // ["Chapter 4.3", "4", index: 5, input: "Open Chapter 4.3, paragraph 6"]

括号中的'?:',这种格局相称的子字符串将不会被记住。比方,(?:d+)协作一次或频仍数字字符,可是不可能记住相称的字符。

字符 *

相配前三个表述式0次或频仍。等价于 {0,}。
例如,/bo*/会相配 "A ghost boooooed" 中的 'booooo' 和 "A bird warbled" 中的 'b',可是在 "A goat grunted" 中校不会协作任郭亚莎西。

示例:

// 匹配'a'后面跟着任意数量的‘b'的字符串。
const regExp = /ab*/;
console.log(regExp.test('a')); // true
console.log(regExp.test('ab')); // true
console.log(regExp.test('bbbc')); // false

三、使用正则表明式

正则表明式能够被用来RegExpexectest方法,以及Stringmatchreplacesearchsplit方法。

动用正则表明式的法子

方法 描述
exec 一个在字符串中执行查找匹配的RegExp方法,它返回一个数组(为匹配到则返回null)。
test 一个在字符串中测试是否匹配的RegExp方法,它返回true或false。
match 一个在字符串中执行查找匹配的String方法,它返回一个数组或者在未匹配到时返回null。
search 一个在字符串中测试匹配的String方法,它返回匹配到的位置索引,或者在失败时返回-1。
replace 一个在字符串中执行查找匹配的String方法,并且使用替换字符串替换掉匹配到的子字符串。
split 一个使用正则表达式或者一个固定字符串分隔一个字符串,并将分隔后的子字符串存储到数组中的String方法。

当您想要知道在多少个字符串中的叁个匹配是还是不是被找到,你可以利用test或search方法;想获取越来越多的新闻(不过相当慢)则足以使用exec或match方法。即便你使用exec或match方法何况杰出成功了,那么这个主意将回来一个数组何况更新相关的正则表明式对象的习性和预约义的正则表明式对象(详见下)。假设相称失利,那么exec方法重返null。

举例使用exec方法在四个字符串中查找一个协作。

const myRe = /d(b+)d/g;
let str_18 = 'cdbbdbsbz';
let myArray = myRe.exec(str_18);
console.log(myArray); // ["dbbd", "bb", index: 1, input: "cdbbdbsbz"]

借使无需拜谒正则表达式的属性,这么些剧本通过另一个主意来创设:

let myArray_2 = /d(b+)d/g.exec(str_18);
console.log(myArray); // ["dbbd", "bb", index: 1, input: "cdbbdbsbz"]

借使想透过七个字符串创设正则表明式,那么这么些本子还有其它大器晚成种办法:

const myRe_2 = new RegExp('d(b+)d', 'g');
let myArray_3 = myRe_2.exec(str_18);
console.log(myArray_3);
// ["dbbd", "bb", index: 1, input: "cdbbdbsbz"]
//     0: "dbbd"
//     1: "bb"
//     index: 1
//     input: "cdbbdbsbz"
//     length: 2
//     __proto__: Array(0)

透过那几个本子,相称成功后将回到七个数组并且更元日则表明式的性质。

正则表明式施行回来消息

对象

品质或索引

描述

在例子中对应的值

myArray

相配到的字符串和具备被记住的子字符串。

["dbbd", "bb"]

index

在输入的字符串中特别到的以0起头的索引值。

1

input

起首字符串。

"cdbbdbsbz"

[0]

匹配到的具有字符串(而不是合作后记住的字符串)。匹配到的最后四个字符索引。

"dbbd"

myRe

lastIndex

下一个卓越的索引值(这么些天性只有在接纳g参数时可用)。

5

source

格局文本。在正则表明式创建时更加细,不执行。

d(b+)d

在这里个事例中如第二种样式所示,你可以采纳三个正则表明式创造一个还未分配给变量的对象起先化容器。若是你这么做,每二回接受时都好比在使用贰个新的正则表明式。所以生龙活虎旦利用那一个未分配给变量的正则,将在随之不能够访谈那么些正则表明式的性质:

let myArray_4 = /d(b+)d/g.exec(str_18);
console.log('The value of lastIndex is ' + /d(b+)d/g.lastIndex); // The value of lastIndex is 0

字符 +

相配前者表明式1次照旧频仍。等价于 {1,}。
比如,/a+/相配了在 "candy" 中的 'a',和在 "caaaaaaandy" 中全体的 'a'。

// 匹配至少一个'a'
const regExp = /a+/; 
console.log(regExp.test('a')); // true
console.log(regExp.test('aab')); // true
console.log(regExp.test('b')); // false

1. 用到括号的子字符串相配

三个正则表明式使用括号,将产生响应的子匹配被记住。举个例子,/a(b)c/能够相称字符串'abc',并且记得'b'。回调那几个括号中非常的子串,使用数组成分[1],......[n]。

行使括号相配的子字符串的多寡数最棒的。重回的数组中保存全数被察觉的子相配。下边包车型客车例子表明了何等使用括号的子字符串相称。

上边包车型大巴脚本使用replace()方法来转变字符串中的单词,在协作到的替换文本中,脚本使用取代的$1,$2表示第叁个和第3个括号的子字符串相配。

const re_11 = /(w+)s(w+)/;
let str_19 = 'Jehorn Gu';
let str_19_r = str_19.replace(re_11, '$2, $1');
console.log(str_19_r); // Gu, Jehorn

字符 ?

相称前者表达式0次依然1次。等价于 {0,1}。

//匹配 'l','el','ele','le'四种字符串
const regExp = /e?le?/;
console.log(regExp.test('ele')); // true
console.log(regExp.test('angel')); // true
console.log(regExp.test('angle')); // true
console.log(regExp.test('oslo')); // true

就算紧跟在任何量词 *、 +、? 或 {} 的背后,将会使量词变为非贪婪的(相配尽量少的字符),和缺省运用的贪心情势(相配尽恐怕多的字符)正巧相反。

例如,对 "123abc" 应用 /d+/ 将会回到 "123",倘若使用 /d+?/,那么就只会协作到 "1"。

示例:

// 匹配0个数字
const regExp1 = /d*?/;
// 匹配1个数字
const regExp2 = /d+?/;
// 匹配1个'a'
const regExp3 = /a{1,3}?/;
let str = '123a';
console.log(str.replace(regExp1, 'abc')); //abc123a
console.log(str.replace(regExp2, 'abc')); // abc23a
console.log(str.replace(regExp3, 'abc')); // 123abc

2. 经过注解实行尖端搜索

正则表明式有几个可选参数进行全局和一些大小写找寻。那么些参数不只能够独立使用也能够大器晚成并利用在别的顺序和带有正则表明式的某些中。

标志 描述
g 全局搜索。
i 不区分大小写搜索。
m 多行搜索。
y 执行“粘性”搜索,匹配从目标字符串的当前位置开始,可以使用y标志。

蕴含三个标记的正则表达式,使用这几个表明式:

var re = /pattern/flags;

或者

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

值得注意的是,标记时一个正则表达式的意气风发有的,它们在接下去的时刻将不能够增添或删除。

例如,re = /w+s/g将成立贰个搜寻贰个或四个字符后有贰个空格的正则表明式,只怕组合起来像此要求的字符串。

const re_12 = /w+s/g;
let str_20 = 'fee fi fo fum';
let myArray_5 = str_20.match(re_12);
console.log(myArray_5); //  ["fee ", "fi ", "fo "]

m标识用于钦定多行输入字符串应该被视为两个行。倘诺使用m标记,^和$相称的开首或终止输入字符串中的每大器晚成行,实际不是整个字符串的开始或终止。

字符 .

(小数点)相配除换行符之外的其余单个字符。
比如,/.n/将会相称 "nay, an apple is on the tree" 中的 'an' 和 'on',不过不会相称 'nay'。

示例:

const regExp = /.n/;
console.log(regExp.test('n')); // false
console.log(regExp.test('.n'));  // true
console.log(regExp.test('an')); //true

四、例子

(x)

万分 'x' 何况记住相称项,就如上边包车型地铁例子展现的这样。括号被称为破获括号
模式 /(foo) (bar) 1 2/ 中的 '(foo卡塔尔' 和 '(bar卡塔尔(قطر‎' 相称并切记字符串 "foo bar foo bar" 中前多个单词。格局中的 1 和 2 相配字符串的后多个单词。注意 1、2、n 是用在正则表明式的拾贰分环节。在正则表明式的替换环节,则要使用像 $1、$2、$n 那样的语法,举个例子,'bar foo'.replace( /(...卡塔尔(英语:State of Qatar) (...卡塔尔(قطر‎/, '$2 $1' 卡塔尔(英语:State of Qatar)。

示例:

const regExp1 = /(foo) (bar) 2 1/;
const regExp2 = /(foo) (bar) 1 2/;
let str1 = 'foo bar bar foo bar';
let str2 = 'foo bar foo bar';
console.log(str1.replace(regExp1, '666')); // 666 bar
console.log(str2.replace(regExp2, '666')); // 666
console.log(str1.replace(regExp2, '666')); // foo bar bar foo bar

1. 转移输入字符串的逐条

以下例子解释了正则表明式的三结合和string.split(卡塔尔(英语:State of Qatar)以致string.replace(卡塔尔(英语:State of Qatar)的用场。它会照应二个独有大致格式的含有全名(名字首先现身)的输入字符串,那么些字符串被空格、换行符和二个分店分隔。最后,它会太阿倒持名字顺序(姓氏首先现身)和list的体系。

// 姓名字符串包含多个空格和制表符
// 而且可能在姓氏和名字之间有多个空格
let names = 'Harry Trump ;Fred Barney; Helen Rigby ; Bill Abel ; Chris Hand ';

let output = ['---------- Original Stringn', names + 'n'];

// 准备两个正则表达式和数组模型
// 将字符串分隔到数组元素中

// 正则: 可能空格 分号 空格
let pattern = /s*;s*/;

// 将字符串拆分成上面模式分隔的部分
// 将这些片段存储在名为nameList的数组中
let nameList = names.split(pattern);

// 新的正则: 一个或多个字符 空格 字符
// 使用圆括号来"记住"匹配的部分
// 记住的部分将在后面使用
pattern = /(w+)s+(w)/;

// 用于存放被处理后名字的数组
let bySurnameList = [];

// 显示名称数组并将用逗号分隔的名字填充到新的数组
// 替换方法删除了所有匹配到的,并且替换为记住的字符串的第一部分
// 随后是逗号,最后是记住字符串的第二部分
output.push('---------- After Split by Regular Expression');

let i, len;
for (i = 0, len = nameList.length; i < len; i++) {
    output.push(nameList[i]);
    bySurnameList[i] = nameList[i].replace(pattern, '$2, $1');
}

// 显示新数组
output.push('---------- Names Reversed');
for (i = 0, len = bySurnameList.length; i < len; i++) {
    output.push(bySurnameList[i]);
}

// 根据姓氏排序 然后显示排好序的数组
bySurnameList.sort();
output.push('---------- Sorted');
for (i = 0, len = bySurnameList.length; i < len; i++) {
    output.push(bySurnameList[i]);
}

output.push('---------- End');

console.log(output.join('n'));
// join() 方法用于把数组中的所有元素放入一个字符串。
// 元素是通过指定的分隔符进行分隔的。
// arrayObject.join(separator);

调控台打字与印刷效果为:

澳门平台注册送 1

(?:x)

相配 'x' 不过不记住相称项。这种称为非捕获括号,使得你能够定义为与正则表明式运算符一同使用的子表达式。来看示例表明式 /(?:foo卡塔尔(قطر‎{1,2}/。如若表明式是 /foo{1,2}/,{1,2}将只对 ‘foo’ 的末段多个字符 ’o‘ 生效。假若运用非捕获括号,则{1,2}会合作整个 ‘foo’ 单词

示例:

const regExp1 = /(?:foo)1/;
console.log('foofoobar'.replace(regExp1, 'abc')); // foofoobar
console.log('foofoo1bar'.replace(regExp1, 'abc'));// fooabcbar
const regExp2 = /(foo)1/;
console.log('foofoobar'.replace(regExp2, 'abc')); // abcbar

2. 用特殊字符核实输入

在偏下例子中,大家期待客商输入二个电话号码。当客商点击'Submit'开关,大家的脚本起头检查那几个数字是还是不是合法。如果数字合法(相配正则表明式所鲜明的字符体系),脚本呈现一条感激顾客的音讯并认同该数字。假诺那串数字非法,脚本提醒顾客电话号码不合规。

包括非捕获括号(?:本条正则表明式寻找多少个数字字符d{3}或者|叁个左半括号(随之四人数字d{3},跟着三个密闭括号),(截止非捕获括号)),后随着大器晚成格短横线或许左斜杠或小数点,随后随着八个数字字符,当回想字符([-/.])破获并切记,前边随着几人数字d{3},再前面跟着记住的左斜杠、右斜杠或小数点1,最终跟着四个人数字。

当顾客按下Enter设置RegExp.input,那个生成也能被激活。

<p>
    Enter your phone number (with area code) and then click 'SUBMIT'. <br>
    The expected format is like ###-###-####.
</p>
<form action="javascript: void(0);">
    <input type="text" id="phone">
    <button type="submit" onclick="testInfo(document.getElementById('phone'));">SUBMIT</button>
</form>

<script type="text/javascript">
    const re_phone = /(?:d{3}|(d{3}))([-/.])d{3}1d{4}/;
    function testInfo(phoneInput) {
        let OK = re_phone.exec(phoneInput.value),
            OK_str;

        console.log(OK);
        OK_str = phoneInput.value + ' isn't a phone number with area code!';
        if (OK) OK_str = 'Thanks, ur phone number is ' + OK[0];

        window.alert(OK_str);
    }
</script>

澳门平台注册送 2

The end...    Last updated by: Jehorn, Jan 01, 2018, 4:16 PM

附录 常用计算
澳门平台注册送 3

x(?=y)

相配'x'仅仅当'x'前面随着'y'.这种称为正向鲜明查找

譬喻说,/Jack(?=Sprat卡塔尔国/会相称到'Jack'仅仅当它背后随着'Sprat'。/杰克(?=Sprat|Frost卡塔尔(قطر‎/相配‘Jack’仅仅当它背后跟着'Sprat'也许是‘Frost’。不过‘Sprat’和‘Frost’都不是相称结果的黄金年代有个别。

示例:

const regExp = /Jack(?=Sprat|Frost)/;
console.log('JackSprat'.replace(regExp, 'ABC'));//  ABCSprat
console.log('JackFrost'.replace(regExp, 'ABC')); // ABCFrost
console.log('Jack'.replace(regExp, 'ABC'));// Jack

澳门平台注册送,x(?!y)

匹配'x'仅仅当'x'前面不随着'y',这么些名称叫正向否定查找
例如,/d+(?!.卡塔尔/相配一个数字只是当以此数字背后未有跟小数点的时候。正则表明式/d+(?!.卡塔尔(قطر‎/.exec("3.141"卡塔尔相配‘141’不过或不是'3.141'。

示例:

const regExp = /d+(?!.)/;
console.log('Pi3.1415926'.replace(regExp, '666'));// Pi3.666

x | y

匹配‘x’或者‘y’。

例如,/green|red/匹配“green apple”中的‘green’和“red apple”中的‘red’

示例:

const regExp1 = /green|red/;
const regExp2 = /green|red/g;
let str = 'greenredgreen';
console.log(str.replace(regExp1, 'blue'));//blueredgreen
console.log(str.replace(regExp2, 'blue'));//blueblueblue

{n}

n是贰个正整数,相配了后边四个字符恰巧发生了n次。
比方,/a{2}/不会同盟“candy”中的'a',不过会同盟“caandy”中全体的a,以致“caaandy”中的前四个'a'。

示例:

const regExp1 = /a{2}/g;
console.log('aaaaa'.replace(regExp1, 'AA')); //AAAAa

{n,m}

n 和 m 都以正整数。相称后边的字符起码n次,最多m次。如若 n 也许 m 的值是0, 那么些值被忽略。

例如说,/a{1, 3}/ 并不相配“cndy”中得放肆字符,相配“candy”中得a,相称“caandy”中得前八个a,也十分“caaaaaaandy”中得前多少个a。注意,当相配”caaaaaaandy“时,相称的值是“aaa”,纵然原本的字符串中有越来越多的a。

示例:

const regExp1 = /a{1,3}/;
console.log('aaaaa'.replace(regExp1, 'AAA')); // AAAaa

[xyz]

一个字符集结。相称方括号的中任性字符,包罗转义系列。你可以选拔破折号(-)来钦定叁个字符范围。对于点(.)和星号(*)那样的特殊符号在二个字符聚焦未有万分的含义。他们不要进行转义,可是转义也是起效果的。

例如,[abcd] 和[a-d]是近似的。他们都合作"brisket"中得‘b’,也都分外“city”中的‘c’。/[a-z.]+/ 和/[w.]+/都格外“test.i.ng”中得全数字符。

let regExp1 = /[abc]/;
let regExp2 = /[abc]/g;
console.log('aAbBcC'.replace(regExp1, 'H'));// HAbBcC
console.log('aAbBcC'.replace(regExp2, 'H'));// HAHBHC

[^xyz]

叁个反向字符集。也等于说, 它优越任何未有富含在方括号中的字符。你能够选拔破折号(-)来钦赐三个字符范围。任何平日字符在这里间都以起功能的。

例如,[^abc] 和 [^a-c] 是风流倜傥致的。他们卓殊"brisket"中得‘r’,也合作“chop”中的‘h’。

let regExp1 = /[^abc]/;
let regExp2 = /[^abc]/g;
console.log('aAbBcC'.replace(regExp1, 'H'));//aHbBcC
console.log('aAbBcC'.replace(regExp2, 'H'));//aHbHcH

[b]

相称二个退格(U+0008)。(不要和b混淆了。)

b

相配二个词的边际。一个词的边际正是三个词不被其它二个词跟随的职位依旧不是另二个词汇字符前面包车型地铁岗位。注意,二个神工鬼斧的词的境界并不满含在合作的开始和结果中。换句话说,八个十分的词的界线的剧情的尺寸是0。(不要和[b]混淆了)
例子:
/bm/匹配“moon”中得‘m’;
/oob/并不包容"moon"中得'oo',因为'oo'被三个词汇字符'n'紧跟着。
/oonb/相称"moon"中得'oon',因为'oon'是那几个字符串的甘休部分。那样他从没被叁个词汇字符紧跟着。
/wbw/将不可能匹配任何字符串,因为一个单词中的字符长久也不恐怕被三个非词汇字符和二个词汇字符相同的时间跟随。

示例:

let regExp = /bm/;
console.log('moon'.replace(regExp, 'M')); //Moon

B

合作叁个非单词边界。他协作贰个光景字符都以千篇风流罗曼蒂克律档期的顺序的岗位:都以单词只怕都不是单词。三个字符串的发端和结尾都被以为是非单词。

例如,/B../匹配"noonday"中得'oo', 而/yB./匹配"possibly yesterday"中得’ye‘

let regExp1 = /B./;
let regExp2 = /Bo/;
console.log('You have to consider'.replace(regExp1, 'M'));
//YMu have to consider.
console.log('You have to consider'.replace(regExp2, 'O'));
//YOu have to consider.

cX

当X是高居A到Z之间的字符的时候,相称字符串中的四个调整符。

例如,/cM/ 相称字符串中的 control-M (U+000D卡塔尔(قطر‎。

d

非常一个数字。等价于[0-9]。
例如, /d/ 或者 /[0-9]/ 匹配"B2 is the suite number."中的'2'。

示例:

let regExp = /d/;
console.log('123abc'.replace(regExp, '&'));//&23abc

D

相配一个非数字字符。等价于[^0-9]。
例如, /D/ 或者 /[^0-9]/ 匹配"B2 is the suite number."中的'B' 。

示例:

let regExp = /D/g;
console.log('123abc'.replace(regExp, '&'));//123&&&

本文由澳门网络娱乐游戏平台发布于Web前端,转载请注明出处:正则表达式学习笔记

相关阅读