正则表达式学习记录

匹配文字字符串

let testStr = "Hello, my name is Kevin.";
let testRegex = /Kevin/;
testRegex.test(testStr);
// Returns true

注：任何其他形式的"Kevin"都不会被匹配。例如，正则表达式/Kevin/不会匹配"kevin"或者"KEVIN"。

同时用多种模式匹配文字字符串

使用正则表达式/coding/，我们可以在其他字符串中查找"coding"。

这对于搜寻单个字符串非常有用，但仅限于一种匹配模式。我们可以使用|操作符来匹配多个规则。

这些匹配模式可以包含更多的|操作符来分隔它们，比如/yes|no|maybe/，用于匹配"yes"、“no"或者"maybe”。

匹配时忽略大小写

正则表达式中，标志有很多，其中忽略大小写的标志为i。我们可以通过将它附加到正则表达式之后来使用它。这里给出使用该标志的一个实例/ignorecase/i。这个字符串可以匹配字符串"ignorecase"、"igNoreCase"和"IgnoreCase"等。

提取匹配项

从前面来看，我们只是检查了一个匹配模式是否存在于字符串中。我们还可以使用.match()方法来提取我们找到的实际匹配项。

let extractStr = "Extract the word 'coding' from this string.";
let codingRegex = /coding/; // 
let result = extractStr.match(codingRegex); // result = "coding"

全局匹配

到目前为止，我们只能提取或搜寻一次匹配模式。

let testStr = "Repeat, Repeat, Repeat";
let ourRegex = /Repeat/;
testStr.match(ourRegex);
// Returns ["Repeat"]

若要多次搜寻或提取匹配模式，我们可以使用g标志。

let repeatRegex = /Repeat/g;
testStr.match(repeatRegex);
// Returns ["Repeat", "Repeat", "Repeat"]

若既要多次搜寻或提取匹配模式，又要忽略大小写，我们还可以使用多个标志。

let twinkleStar = "Twinkle, twinkle, little star";
let starRegex = /Twinkle/ig; 
let result = twinkleStar.match(starRegex); // result = [Twinkle, twinkle]

用通配符.匹配任何内容

有时我们不会（或不需要）知道匹配模式中的确切字符。如果要精确匹配到完整的单词，那出现一个拼写错误就会匹配不到。幸运的是，我们可以使用通配符.来处理这种情况。

通配符.将匹配任何一个字符。通配符也叫dot或period。我们可以像使用正则表达式中任何其他字符一样使用通配符。例如，如果我们想匹配"hug"、"huh"、"hut"和"hum"，那么我们可以使用正则表达式/hu./匹配以上四个单词。

let humStr = "I'll hum a song";
let hugStr = "Bear hug";
let huRegex = /hu./;
humStr.match(huRegex); // Returns ["hum"]
hugStr.match(huRegex); // Returns ["hug"]

将单个字符与多种可能性匹配

前面我们已经了解了如何匹配文字匹配模式（/literal/）和通配符（/./）。这是正则表达式的两种极端情况，一种是精确匹配，而另一种则是匹配所有。不过在这两种极端情况之间还有一个平衡选项。

我们可以使用字符集搜寻具有一定灵活性的文字匹配模式。字符集允许你通过把它们放在方括号（[和]）之间的方式来定义一组你需要匹配的字符串。

例如，你想要匹配"bag"、"big"和"bug"，但是不想匹配"bog"。你可以创建正则表达式/b[aiu]g/来执行此操作。[aiu]是只匹配字符"a"、"i"或者"u"的字符集。

let bigStr = "big";
let bagStr = "bag";
let bugStr = "bug";
let bogStr = "bog";
let bgRegex = /b[aiu]g/;
bigStr.match(bgRegex); // Returns ["big"]
bagStr.match(bgRegex); // Returns ["bag"]
bugStr.match(bgRegex); // Returns ["bug"]
bogStr.match(bgRegex); // Returns null

匹配字母表中的字母

在字符集中，我么还可以使用连字符（-）来定义要匹配的字符范围。

例如，要匹配小写字母a到e，你可以使用[a-e]。

let catStr = "cat";
let batStr = "bat";
let matStr = "mat";
let bgRegex = /[a-e]at/;
catStr.match(bgRegex); // Returns ["cat"]
batStr.match(bgRegex); // Returns ["bat"]
matStr.match(bgRegex); // Returns null

匹配字母表中的数字和字母

此外，还可以在单个字符集中组合一系列字母和数字。

let jennyStr = "Jenny8675309";
let myRegex = /[a-z0-9]/ig; //a-z0-9不需要隔开
// matches all letters and numbers in jennyStr
jennyStr.match(myRegex);

匹配单个未指定的字符

到目前为止，我们已创建了一个想要匹配的字符集合，但我们也可以创建一个不想匹配的字符集合。这些类型的字符集称为否定字符集。

要创建否定字符集，你需要在开始括号后面和不想匹配的字符前面放置插入字符（即^）。

//	/[^aeiou]/gi 这个正则表达式匹配所有非元音字符

//又例如下面：
//匹配所有非数字或元音字符的正则表达式。
let quoteSample = "3 blind mice.";
let myRegex = /[^0-9aeiou]/ig;
let result = quoteSample.match(myRegex);

匹配出现一次或多次的字符

有时，我们需要匹配出现一次或者连续多次的的字符（或字符组）。这意味着它至少出现一次，并且可能重复出现。此时可以使用+符号。

例如，/a+/g会在"abc"中匹配到一个匹配项，并且返回["a"]。因为+的存在，它也会在"aabc"中匹配到一个匹配项，然后返回["aa"]。

如果它是检查字符串"abab"，它将匹配到两个匹配项并且返回["a", "a"]，因为a字符不连续，在它们之间有一个b字符。最后，因为在字符串"bcd"中没有"a"，因此找不到匹配项。

//用+符号在字符串"Mississippi"中匹配出现一次或多次的字母s的匹配项。
let difficultSpelling = "Mississippi";
let myRegex = /s+/g;
let result = difficultSpelling.match(myRegex);// Returns ["ss", "ss"]
//如果没有+标识，myRegex = /s/g，输出为 ['s','s','s','s']

//以上例子中+标志仅作用于单个字符
//如果要匹配出现一次或者连续多次的的字符组，则可以这样myRegex = /(ab)+/g，用()使得+标志作用与字符串

匹配出现零次或多次的字符

上面我们使用了加号+来查找出现一次或多次的字符。此外，还有一个选项可以匹配出现零次或多次的字符。

执行该操作的字符叫做asterisk或star，即*。

let soccerWord = "gooooooooal!";
let gPhrase = "gut feeling";
let oPhrase = "over the moon";
let goRegex = /go*/; //*标志仅作用与'o'字符
//测试了一下，*标志好像只能作用与单个字符
soccerWord.match(goRegex); // Returns ["goooooooo"]
gPhrase.match(goRegex); // Returns ["g"]
oPhrase.match(goRegex); // Returns null

用惰性匹配来查找字符

在正则表达式中，贪婪匹配会匹配到符合正则表达式匹配模式的字符串的最长可能部分，并将其作为匹配项返回。另一种方案称为懒惰匹配，它会匹配到满足正则表达式的字符串的最小可能部分。

我们可以将正则表达式/t[a-z]*i/应用于字符串"titanic"。这个正则表达式是一个以t开始，以i结束，并且中间有一些字母的匹配模式。

正则表达式默认是贪婪匹配，因此匹配返回为["titani"]。它会匹配到适合该匹配模式的最大子字符串。

但是，我们可以使用?字符来将其变成懒惰匹配。调整后的正则表达式/t[a-z]*?i/匹配字符串"titanic"返回["ti"]。

简单来说，贪婪匹配就是匹配满足条件的最长字符串，懒惰匹配就是匹配满足条件的最短字符串。

let text = "<h1>Winter is coming</h1>";
let myRegex = /<[a-z0-9]*?>/; 
let result = text.match(myRegex); // Returns ['<h1>']

匹配字符串的开头

在字符集中的插入符号（^），形如[^thingsThatWillNotBeMatched]，是用来创建一个否定字符集。但是当在字符集之外时，插入符号用于字符串的开头搜寻匹配模式。

let firstString = "Ricky is first and can be found.";
let firstRegex = /^Ricky/;
firstRegex.test(firstString); //匹配到开头有Ricky
// Returns true
let notFirst = "You can't find Ricky now.";
firstRegex.test(notFirst); //匹配不成功
// Returns false

匹配字符串的末尾

我们可以使用正则表达式的美元符号$来搜寻字符串的结尾。

let theEnding = "This is a never ending story";
let storyRegex = /story$/;
storyRegex.test(theEnding);
// Returns true
let noEnding = "Sometimes a story will have to end";
storyRegex.test(noEnding);
// Returns false

匹配所有的字母和数字

JavaScript 中与字母表匹配的最接近的字符类是\w，这个缩写等同于[A-Za-z0-9_]。它不仅可以匹配大小写字母和数字，注意，它还会匹配下划线字符（_）。

let quoteSample = "The five boxing wizards jump quickly.";
let alphabetRegexV2 = /\w/g; 
let result = quoteSample.match(alphabetRegexV2).length;//计算字符串长度

匹配除了字母和数字的所有符号

你可以使用\W搜寻和\w相反的匹配模式。注意，相反匹配模式使用大写字母。此缩写与[^A-Za-z0-9_]是一样的。

let shortHand = /\W/;
let numbers = "42%";
let sentence = "Coding!";
numbers.match(shortHand); // Returns ["%"]
sentence.match(shortHand); // Returns ["!"]

匹配所有数字

查找数字字符的缩写是\d，注意是小写的d。这等同于字符类[0-9]，它查找 0 到 9 之间任意数字的单个字符。

let numString = "Your sandwich will be $5.00";
let numRegex = /\d/g;
let result = numString.match(numRegex).length; //Returns ['5','0','0']

匹配所有非数字

查找非数字字符的缩写是\D。这等同于字符串[^0-9]，它查找不是 0 - 9 之间数字的单个字符。

let numString = "Your sandwich will be $5.00";
let noNumRegex = /\D/g;
let result = numString.match(noNumRegex).length;//返回非数字的字符数组

练习：限制可能的用户名

以下是用户在创建用户名时必须遵守的一些简单规则。

1. 用户名中的数字必须在最后，且数字可以有零个或多个。

2. 用户名字母可以是小写字母和大写字母。

3. 用户名长度必须至少为两个字符。两位用户名只能使用字母。

要求：修改正则表达式userCheck以适合上面列出的约束。

let username = "JackOfAllTrades";
let userCheck = /^[a-z][a-z]+\d*$|^[a-z]\d\d+$/i; // 修改这一行
let result = userCheck.test(username);

匹配空白字符

我们可以使用\s搜寻空格，其中s是小写。此匹配模式不仅匹配空格，还匹配回车符、制表符、换页符和换行符，你可以将其视为与[\r\t\f\n\v]类似。

let whiteSpace = "Whitespace. Whitespace everywhere!"
let spaceRegex = /\s/g;
whiteSpace.match(spaceRegex);
// Returns [" ", " "]

匹配非空白字符

使用\S搜寻非空白字符，其中S是大写。此匹配模式将不匹配空格、回车符、制表符、换页符和换行符。你可以认为这类似于字符类[^\r\t\f\n\v]。

let whiteSpace = "Whitespace. Whitespace everywhere!"
let nonSpaceRegex = /\S/g;
whiteSpace.match(nonSpaceRegex).length; // Returns 32

指定匹配的上限和下限

我们可以使用数量说明符指定匹配模式的上下限。数量说明符与花括号（{和}）一起使用。你可以在花括号之间放两个数字，这两个数字代表匹配模式的上限和下限。

例如，要在字符串"ah"中匹配仅出现3到5次的字母a，你的正则表达式应为/a{3,5}h/。

let ohStr1 = 'Ohhhh no'
let ohStr2 = 'Ohhhhhh no'
let ohStr3 = 'Ohhhhhhh no'
let ohRegex = /Oh{3,6}\sno/ // 修改这一行
let result1 = ohRegex.test(ohStr1)
let result2 = ohRegex.test(ohStr2)
let result3 = ohRegex.test(ohStr3)
console.log(result1, result2, result3); //true true false

指定匹配的下限

我们可以使用数量说明符指定匹配模式的上下限。数量说明符与花括号（{和}）一起使用。你可以在花括号之间放两个数字，这两个数字代表匹配模式的上限和下限。

例如，要在字符串"ah"中匹配仅出现3个及3个以上的字母a，你的正则表达式应为/a{3,}h/。

let A4 = "aaaah";
let A2 = "aah";
let multipleA = /a{3,}h/;
multipleA.test(A4); // Returns true
multipleA.test(A2); // Returns false

指定匹配的确切数量

我们可以使用带有花括号的数量说明符来指定匹配模式的上下限。但有时我们只需要特定数量的匹配。

要指定一定数量的匹配模式，只需在大括号之间放置一个数字。

例如，要只匹配字母a出现3次的单词"hah"，我们的正则表达式应为/ha{3}h/。

let A4 = "haaaah";
let A3 = "haaah";
let A100 = "h" + "a".repeat(100) + "h";
let multipleHA = /a{3}h/;
multipleHA.test(A4); // Returns false
multipleHA.test(A3); // Returns true
multipleHA.test(A100); // Returns false

检查全部或无

有时，我们想要搜寻的匹配模式可能有不确定是否存在的部分。尽管如此，我们可能还是想检查它们。

为此，我们可以使用问号?指定可能存在的元素。这将检查前面的零个或一个元素。我们可以将此符号视为前面的元素是可选的。

例如，美式英语和英式英语略有不同，我们可以使用问号来匹配两种拼写。

let american = "color";
let british = "colour";
let rainbowRegex= /colou?r/;
rainbowRegex.test(american); // Returns true
rainbowRegex.test(british); // Returns true

正向先行断言和负向先行断言

先行断言是告诉 JavaScript 在字符串中向前查找的匹配模式。当你想要在同一个字符串上搜寻多个匹配模式时，这可能非常有用。

有两种先行断言：正向先行断言和负向先行断言。

正向先行断言会查看并确保搜索匹配模式中的元素存在，但实际上并不匹配。正向先行断言的用法是(?=...)，其中...就是需要存在但不会被匹配的部分。

另一方面，负向先行断言会查看并确保搜索匹配模式中的元素不存在。负向先行断言的用法是(?!...)，其中...是你希望不存在的匹配模式。如果负向先行断言部分不存在，将返回匹配模式的其余部分。

let password = "abc123";
let checkPass = /(?=\w{3,6})(?=\D*\d)/;
checkPass.test(password); // Returns true

使用先行断言的好处是，先行断言只是查看元素并不会匹配，也就是说先行断言并不会影响后续的匹配模式。

使用捕获组重用模式

我们可以使用捕获组搜寻重复的子字符串。括号(和)可以用来匹配重复的子字符串。我们只需要把重复匹配模式的正则表达式放在括号中即可。

要指定重复字符串将出现的位置，可以使用反斜杠（\）后接一个数字。这个数字从 1 开始，可以使用不同数字区别不同的捕获组。这里有一个示例，\1可以匹配第一个组。

let repeatNum = "42 42 42";
let reRegex = /^(\d+)\s\1\s\1$/; //这里的\1起到占位作用，指定重复字符串出现的位置
let result = reRegex.test(repeatNum); //true

使用捕获组搜索和替换

可以使用字符串上.replace()方法来搜索并替换字符串中的文本。.replace()的输入首先是你想要搜索的正则表达式匹配模式，第二个参数是用于替换匹配的字符串或用于执行某些操作的函数。

let wrongText = "The sky is silver.";
let silverRegex = /silver/;
wrongText.replace(silverRegex, "blue");
// Returns "The sky is blue."

我们还可以使用美元符号（$）访问替换字符串中的捕获组。

"Code Camp".replace(/(\w+)\s(\w+)/, '$2 $1');
// Returns "Camp Code"

练习：删除开头和结尾的空白

编写一个正则表达式并使用适当的字符串方法删除字符串开头和结尾的空格。

let hello = "   Hello, World!  ";
let wsRegex = /^\s+|\s+$/g; 
//注意不可以少了g标志，因为|多种匹配模式如果没有g标志只意味着匹配多种模式中的一种。
let result = hello.replace(wsRegex,'');

终于完结了，哈哈。

以后的学习我会继续补充更多有关正则表达式的知识的！