FCC JavaScript 算法和数据结构正则表达式

最新推荐文章于 2023-08-05 00:17:22 发布

Tobby Guo

最新推荐文章于 2023-08-05 00:17:22 发布

阅读量473

点赞数

分类专栏： JS

本文链接：https://blog.csdn.net/m0_59437193/article/details/118525567

版权

JS 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

Free Code Camp 学习笔记 js.正则表达式

Many thx for the FCC platform to open the JS door to me

#1 使用测试方法

在编程语言中，正则表达式用于匹配指定的字符串。通过正则表达式创建匹配模式（规则）可以帮你完成指定匹配。

.test() 方法会把编写的正则表达式和字符串（即括号内的内容）匹配，如果成功匹配到字符，则返回 true，反之，返回 false。

参考：

原题
let myString = "Hello, World!";
let myRegex = /Hello/;
let result = myRegex; // 修改这一行

解法
let myString = "Hello, World!";
let myRegex = /Hello/;
let result = myRegex.test(myString); // 修改这一行

#2匹配文字字符串

大小写敏感

原题：完成正则表达式 waldoRegex，在字符串 waldoIsHiding 中匹配到文本 "Waldo"。


let waldoIsHiding = "Somewhere Waldo is hiding in this text.";
let waldoRegex = /search/; // 修改这一行
let result = waldoRegex.test(waldoIsHiding);


参考
let waldoIsHiding = "Somewhere Waldo is hiding in this text.";
let waldoRegex = /Waldo/; // 修改这一行
let result = waldoRegex.test(waldoIsHiding);

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

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

这对于搜寻单个字符串非常有用，但仅限于一种匹配模式。你可以使用 alternation 或 OR 操作符搜索多个模式： |

此操作符匹配操作符前面或后面的字符。例如，如果你想匹配 yes 或 no，你需要的正则表达式是 /yes|no/。

你还可以匹配多个规则，这可以通过添加更多的匹配模式来实现。这些匹配模式将包含更多的 OR 操作符来分隔它们，比如/yes|no|maybe/。

原题
完成正则表达式 petRegex 以匹配 dog、cat、bird 或者 fish。
let petString = "James has a pet cat.";
let petRegex = /change/; // 修改这一行
let result = petRegex.test(petString);

参考
let petString = "James has a pet cat.";
let petRegex = /dog|cat|bird|fish/; // 修改这一行
let result = petRegex.test(petString);

#4匹配时忽略大小写

到目前为止，已经了解了如何用正则表达式来执行字符串的匹配。但有时候，并不关注匹配字母的大小写。

大小写即大写字母和小写字母。大写字母如 A、B 和 C。小写字母如 a、b 和 c。

可以使用标志（flag）来匹配这两种情况。标志有很多，不过这里我们只关注忽略大小写的标志——i。可以通过将它附加到正则表达式之后来使用它。这里给出使用该标志的一个实例 /ignorecase/i。这个字符串可以匹配字符串 ignorecase、igNoreCase 和 IgnoreCase。

原题
编写正则表达式 fccRegex 以匹配 freeCodeCamp，忽略大小写。 正则表达式不应与任何缩写或带有空格的变体匹配。

let myString = "freeCodeCamp";
let fccRegex = /change/; // 修改这一行
let result = fccRegex.test(myString);

参考
let myString = "freeCodeCamp";
let fccRegex = /freecodecamp/i; // 修改这一行
let result = fccRegex.test(myString);

#5提取匹配项

可以使用 .match() 方法来提取找到的实际匹配项。

可以使用字符串来调用 .match() 方法，并在括号内传入正则表达式。

例子
"Hello, World!".match(/Hello/);
let ourStr = "Regular expressions";
let ourRegex = /expressions/;
ourStr.match(ourRegex);

'string'.match(/regex/);
/regex/.test('string');

原题
利用 .match() 方法提取单词 coding。
let extractStr = "Extract the word 'coding' from this string.";
let codingRegex = /change/; // 修改这一行
let result = extractStr; // 修改这一行

参考
let extractStr = "Extract the word 'coding' from this string.";
let codingRegex = /coding/; // 修改这一行
let result = extractStr.match(codingRegex); // 修改这一行

#6全局匹配

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

let repeatRegex = /Repeat/g;
testStr.match(repeatRegex);

这里 match 返回值 ["Repeat", "Repeat", "Repeat"]

要求
使用正则表达式 starRegex，从字符串 twinkleStar 中匹配所有的 Twinkle 单词并提取出来。

注意：
在正则表达式上可以有多个标志，比如 /search/gi
let twinkleStar = "Twinkle, twinkle, little star";
let starRegex = /change/; // 修改这一行
let result = twinkleStar; // 修改这一行

参考
let twinkleStar = "Twinkle, twinkle, little star";
let starRegex = /Twinkle/gi; // 修改这一行
let result = twinkleStar.match(starRegex); // 修改这一行

#7用通配符匹配任何内容

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

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

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

要求
完成正则表达式 unRegex 以匹配字符串 run、sun、fun、pun、nun 和 bun。 正则表达式中应该使用通配符。
let exampleStr = "Let's have fun with regular expressions!";
let unRegex = /change/; // 修改这一行
let result = unRegex.test(exampleStr);

参考
let exampleStr = "Let's have fun with regular expressions!";
let unRegex = /un./; // 修改这一行
let result = unRegex.test(exampleStr);

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

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

可以使用字符集（character classes）更灵活的匹配字符。可以把字符集放在方括号（[ 和 ]）之间来定义一组需要匹配的字符串。

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

要求
使用元音字符集（a、e、i、o、u）在正则表达式 vowelRegex 中匹配到字符串 quoteSample 中的所有元音。

**注意:**一定要同时匹配大小写元音。

let quoteSample = "Beware of bugs in the above code; I have only proved it correct, not tried it.";
let vowelRegex = /change/; // 修改这一行
let result = vowelRegex; // 修改这一行

参考
let quoteSample = "Beware of bugs in the above code; I have only proved it correct, not tried it.";
let vowelRegex = /[aeiou]/ig; // 修改这一行
let result = quoteSample.match(vowelRegex); // 修改这一行

#9匹配字母表中的字母

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

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

要求
匹配字符串 quoteSample 中的所有字母。

注意：一定要同时匹配大小写字母。
let quoteSample = "The quick brown fox jumps over the lazy dog.";
let alphabetRegex = /change/; // 修改这一行
let result = alphabetRegex; // 修改这一行

参考
let quoteSample = "The quick brown fox jumps over the lazy dog.";
let alphabetRegex = /[a-z]/ig; // 修改这一行
let result = quoteSample.match(alphabetRegex); // 修改这一行

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

使用连字符（-）匹配字符范围并不仅限于字母。它还可以匹配一系列数字。

例如，/[0-5]/ 匹配 0 和 5 之间的任意数字，包含 0 和 5。

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

要求
创建一个正则表达式，使其可以匹配 h 和 s 之间的一系列字母，以及 2 和 6 之间的一系列数字。 请记得在正则表达式中包含恰当的标志。

let quoteSample = "Blueberry 3.141592653s are delicious.";
let myRegex = /change/; // 修改这一行
let result = myRegex; // 修改这一行

参考
let quoteSample = "Blueberry 3.141592653s are delicious.";
let myRegex = /[h-s2-6]/ig; // 修改这一行
let result = quoteSample.match(myRegex); // 修改这一行

#11匹配单个未指定的字符

创建一个不想匹配的字符集合。这些类型的字符集称为否定字符集（ negated character sets）。

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

例如，/[^aeiou]/gi 匹配所有非元音字符。注意，字符 .、!、[、@、/ 和空白字符等也会被匹配，该否定字符集仅排除元音字符。

要求
创建一个匹配所有非数字或元音字符的正则表达式。 请记得在正则表达式中包含恰当的标志。
let quoteSample = "3 blind mice.";
let myRegex = /change/; // 修改这一行
let result = myRegex; // 修改这一行

参考
let quoteSample = "3 blind mice.";
let myRegex = /[^aeiou0-9]/gi; // 修改这一行
let result = quoteSample.match(myRegex); // 修改这一行

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

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

可以使用 + 符号来检查情况是否如此。记住，字符或匹配模式必须一个接一个地连续出现。这就是说，字符必须一个接一个地重复。

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

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

要求
想要在字符串 Mississippi 中匹配到出现一次或多次的字母 s 的匹配项。 编写一个使用 + 符号的正则表达式。
let difficultSpelling = "Mississippi";
let myRegex = /change/; // 修改这一行
let result = difficultSpelling.match(myRegex);

参考
let difficultSpelling = "Mississippi";
let myRegex = /s+/g; // 修改这一行
let result = difficultSpelling.match(myRegex);

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

一个选项可以匹配出现零次或多次的字符。

执行该操作的字符叫做星号，即*。

要求
在这个挑战里，chewieQuote 已经被初始化为 Aaaaaaaaaaaaaaaarrrgh!。 创建一个变量为 chewieRegex 的正则表达式，使用 * 在 chewieQuote 中匹配 A 及其之后出现的零个或多个a。 你的正则表达式不需要使用修饰符，也不需要匹配引号。

// 只修改这一行下面的代码
let chewieRegex = /change/; // 修改这一行
// 只修改这一行上面的代码

let result = chewieQuote.match(chewieRegex);

参考
// 只修改这一行下面的代码
let chewieRegex = /Aa*/; // 修改这一行,这里不ig，不需要修饰符或匹配引号
// 只修改这一行上面的代码
let result = chewieQuote.match(chewieRegex);

#14用惰性匹配来查找字符

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

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

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

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

**注意：**应该避免使用正则表达式解析 HTML，但是可以用正则表达式匹配 HTML 字符串。

要求
// 修复正则表达式 /<.*>/，让它返回 HTML 标签 <h1>，而不是文本 "<h1>Winter is coming</h1>"。 请记得在正则表达式中使用通配符 . 来匹配任意字符;

let text = "<h1>Winter is coming</h1>";
let myRegex = /<.*>/; // 修改这一行
let result = text.match(myRegex);

参考
let text = "<h1>Winter is coming</h1>";
let myRegex = /<.*?>/; // 修改这一行
let result = text.match(myRegex);

#15在狩猎中找到一个或多个罪犯

一群罪犯越狱逃跑了，但你不知道有多少人。然而，你知道他们不在一起时会保持紧密联系。你有责任立刻找到所有的罪犯。

这里有一个示例来提示如何做到这一点：

当字母z在一行中出现一次或连续多次时，正则表达式/z+/会匹配到它。它会在以下所有字符串中找到匹配项：

"z"
"zzzzzz"
"ABCzzzz"
"zzzzABC"
"abczzzzzzzzzzzzzzzzzzzzzabc"

但是它不会在以下字符串中找到匹配项，因为它们中没有字母z：

""
"ABC"
"abcabc"

要求
编写一个贪婪正则表达式，在一组其他人中匹配到一个或多个罪犯。 罪犯由大写字母C表示。
let reCriminals = /./; // 修改这一行

参考
let reCriminals = /C+/; // 修改这一行

//这题因为没给原代码有点懵，测试结果放在这好理解些

您的正则表达式应该匹配字符串 C 中的一个罪犯(C)

您的正则表达式应该匹配字符串 CC 中的两个罪犯(CC)
您的正则表达式应该在字符串 P1P5P4CCCcP2P6P3 中匹配三个罪犯(CCC)。
您的正则表达式应该在字符串 P6P2P7P4P5CCCCCP3P1中匹配五个罪犯(CCCCC)
你的正则表达式在""中不应该匹配到任何罪犯
你的正则表达式在P1P2P3中不应该匹配到任何罪犯
你的正则表达式应该在P2P1P5P4CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCP3中匹配五十个 罪犯（'CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC'）

#16匹配字符串的开头

正则表达式可以用于查找多项匹配。还可以查询字符串中符合指定匹配模式的字符。

在之前的挑战中，使用字符集中前插入符号（^）来创建一个否定字符集。除了在字符集中使用之外，脱字符还用于匹配字符串的开始位置。

第一次 test 调用将返回 true，而第二次调用将返回 false。

要求
在正则表达式中使用脱字符来找到 Cal 在字符串 rickyAndCal 中的开始位置。
let rickyAndCal = "Cal and Ricky both like racing.";
let calRegex = /change/; // 修改这一行
let result = calRegex.test(rickyAndCal);

参考
let rickyAndCal = "Cal and Ricky both like racing.";
let calRegex = /^Cal/; // 修改这一行
let result = calRegex.test(rickyAndCal);

#17匹配字符串的末尾

还有一种方法可以搜寻字符串末尾的匹配模式。

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

要求
使用锚点字符 $ 来匹配字符串 caboose 在字符串末尾 caboose。
let caboose = "The last car on a train is the caboose";
let lastRegex = /change/; // 修改这一行
let result = lastRegex.test(caboose);

参考
let caboose = "The last car on a train is the caboose";
let lastRegex = /caboose$/; // 修改这一行
let result = lastRegex.test(caboose);

#18匹配所有的字母和数字

使用元字符，可以使用 [a-z] 搜寻字母表中的所有字母。这种元字符是很常见的，它有一个缩写，但这个缩写也包含额外的字符。

JavaScript 中与字母表匹配的最接近的元字符是\w。这个缩写等同于[A-Za-z0-9_]。此字符类匹配上面字母和小写字母以及数字。注意，这个字符类也包含下划线字符 (_)。

要求
使用元字符 \w 来计算所有引号中字母和数字字符的数量。
let quoteSample = "The five boxing wizards jump quickly.";
let alphabetRegexV2 = /change/; // 修改这一行
let result = quoteSample.match(alphabetRegexV2).length;

参考
let quoteSample = "The five boxing wizards jump quickly.";
let alphabetRegexV2 = /\w/g; // 修改这一行
let result = quoteSample.match(alphabetRegexV2).length;

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

已经了解到可以使用缩写 \w 来匹配字母和数字 [A-Za-z0-9_]。不过，有可能想要搜寻的匹配模式是非字母数字字符。

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

要求
使用缩写 \W 来计算引号中所有非字符字母和数字字符的数量。
let quoteSample = "The five boxing wizards jump quickly.";
let nonAlphabetRegex = /change/; // 修改这一行
let result = quoteSample.match(nonAlphabetRegex).length;

参考
let quoteSample = "The five boxing wizards jump quickly.";
let nonAlphabetRegex = /\W/g; // 修改这一行
let result = quoteSample.match(nonAlphabetRegex).length;

#20匹配所有数字

已经了解了常见字符串匹配模式的元字符，如字母数字。另一个常见的匹配模式是只寻找数字。

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

要求
使用缩写 \d 来计算电影标题中有多少个数字。 书面数字（"six" 而不是 6）不计算在内。
let movieName = "2001: A Space Odyssey";
let numRegex = /change/; // 修改这一行
let result = movieName.match(numRegex).length;

参考
let movieName = "2001: A Space Odyssey";
let numRegex = /\d/g; // 修改这一行
let result = movieName.match(numRegex).length;

#21匹配所有非数字

上一项挑战中展示了如何使用带有小写 d 的缩写 \d 来搜寻数字。也可以使用类似的缩写来搜寻非数字，该缩写使用大写的 D。

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

要求
使用非数字缩写 \D 来计算电影标题中有多少非数字。
let movieName = "2001: A Space Odyssey";
let noNumRegex = /change/; // 修改这一行
let result = movieName.match(noNumRegex).length;

参考
let movieName = "2001: A Space Odyssey";
let noNumRegex = /\D/g; // 修改这一行
let result = movieName.match(noNumRegex).length;

#22限制可能的用户名

用户名在互联网上随处可见。它们是用户在自己喜欢的网站上的唯一身份。

需要检索数据库中的所有用户名。以下是用户在创建用户名时必须遵守的一些简单规则。

用户名只能是数字字母字符。
用户名中的数字必须在最后。数字可以有零个或多个。用户名不能以数字开头。
用户名字母可以是小写字母和大写字母。
用户名长度必须至少为两个字符。两位用户名只能使用字母。

要求
修改正则表达式 userCheck 以满足上面列出的约束。
let username = "JackOfAllTrades";
let userCheck = /change/; // 修改这一行
let result = userCheck.test(username);

参考
let username = "JackOfAllTrades";
let userCheck = /^[a-z]([0-9]{2,}|[a-z]+\d*)$/i; // 修改这一行
let result = userCheck.test(username);

//常用正则用户名一
用户名中的数字必须在最后，且数字可以有零个或多个。

[a-zA-Z]：大写字母或者小写字母；
{2，}：至少2位；
\d*:数字有零个或多个；
$:字符串末尾

let userCheck = /[a-zA-Z]{2,}\d*$/; 

//常用正则用户名二
用户名字母可以是小写字母和大写字母。

 ^：字符串开头；
 [a-z]：小写字母；
 [0-9][0-9]+：至少2位数字；
 |：或；
 [a-z]+：至少一位小写字母；
 \d*：零个或多个数字；
 $：字符串结尾；
 i：不区分大小写

let userCheck2 = /^[a-z]([0-9][0-9]+|[a-z]+\d*)$/i;

//常用正则用户名三
用户名长度必须至少为两个字符。两位用户名只能使用字母。

^：字符串开头；
 [a-z]：小写字母；
 [0-9]{2,}：至少2位数字；
 |：或；
 [a-z]+：至少一位小写字母；
 \d*：零个或多个数字；
 $：字符串结尾；
 i：不区分大小写
 
let userCheck3 = /^[a-z]([0-9]{2,}|[a-z]+\d*)$/i;

感谢SummerStar分享
作者：SummerStar
链接：https://juejin.cn/post/6850418110030151694

常用正则表达传送门
https://www.jb51.net/article/115170.htm

#23匹配空白字符

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

要求
修改正则表达式 countWhiteSpace 查找字符串中的多个空白字符。
let sample = "Whitespace is important in separating words";
let countWhiteSpace = /change/; // 修改这一行
let result = sample.match(countWhiteSpace);

参考
let sample = "Whitespace is important in separating words";
let countWhiteSpace = /\s/g; // 修改这一行
let result = sample.match(countWhiteSpace);

#24匹配非空白字符

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

要求
修改正则表达式 countNonWhiteSpace 以查找字符串中的多个非空字符。
let sample = "Whitespace is important in separating words";
let countNonWhiteSpace = /change/; // 修改这一行
let result = sample.match(countNonWhiteSpace);

参考
let sample = "Whitespace is important in separating words";
let countNonWhiteSpace = /\S/g; // 修改这一行
let result = sample.match(countNonWhiteSpace);

#25指定匹配的上限和下限

回想一下，使用加号 + 查找一个或多个字符，使用星号 * 查找零个或多个字符。这些都很方便，但有时需要匹配一定范围的匹配模式。

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

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

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

第一次 test 调用将返回 true，而第二次调用将返回 false。

要求
修改正则表达式 ohRegex 以匹配出现 3 到 6 次字母 h 的字符串 Oh no。
let ohStr = "Ohhh no";
let ohRegex = /change/; // 修改这一行
let result = ohRegex.test(ohStr);

参考
let ohStr = "Ohhh no";
let ohRegex =/Oh{3,6}\sno/; // 修改这一行
let result = ohRegex.test(ohStr);

#26只指定匹配的下限

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

为此，在第一个数字后面跟一个逗号即可。

要求
修改正则表达式 haRegex，匹配包含四个或更多字母 z 的单词 Hazzah。
let haStr = "Hazzzzah";
let haRegex = /change/; // 修改这一行
let result = haRegex.test(haStr);

参考
let haStr = "Hazzzzah";
let haRegex = /Haz{4,}ah/; // 修改这一行
let result = haRegex.test(haStr);

#27指定匹配的确切数量

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

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

要求
修改正则表达式timRegex，以匹配仅有四个字母 m 的单词 Timber。
let timStr = "Timmmmber";
let timRegex = /change/; // 修改这一行
let result = timRegex.test(timStr);

参考
let timStr = "Timmmmber";
let timRegex = /tim{4}ber/i; // 修改这一行
let result = timRegex.test(timStr);

#28检查全部或无

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

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

要求
修改正则表达式 favRegex 以匹配美式英语（favorite）和英式英语（favourite）的单词版本。
let favWord = "favorite";
let favRegex = /change/; // 修改这一行
let result = favRegex.test(favWord);

参考
let favWord = "favorite";
let favRegex = /favou?rite/; // 修改这一行
let result = favRegex.test(favWord);

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

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

有两种先行断言：正向先行断言（positive lookahead）和负向先行断言（negative lookahead）。

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

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

尽管先行断言有点儿令人困惑，但是这些示例会有所帮助。

let quit = "qu";
let noquit = "qt";
let quRegex= /q(?=u)/;
let qRegex = /q(?!u)/;
quit.match(quRegex);
noquit.match(qRegex);

这两次 match 调用都将返回 ["q"]。

先行断言的更实际用途是检查一个字符串中的两个或更多匹配模式。这里有一个简单的密码检查器，密码规则是 3 到 6 个字符且至少包含一个数字：

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

要求
在正则表达式 pwRegex 中使用先行断言以匹配大于 5 个字符且有两个连续数字的密码。
let sampleWord = "astronaut";
let pwRegex = /change/; // 修改这一行
let result = pwRegex.test(sampleWord);

参考
这里推荐写. 以免\w 会局限于数字、字母和_。

let sampleWord = "astronaut";
let pwRegex = /(?=.{6,})(?=\D*\d{2})/; // 修改这一行
let result = pwRegex.test(sampleWord);

//大于五个字符 不会写， 所以写的6， 有大神希望可以留言分享
开始写的
let sampleWord = "astronaut";
let pwRegex = /^(?=.{5})(?=.*\d{2,})/; // 修改这一行
let result = pwRegex.test(sampleWord);

这样的话 
sampleWord = "12345";
是不题目符合要求的，但是运行会被正则选中 所以应该是大于5

#30检查混合字符组

有时候我们想使用正则表达式里的括号 () 来检查字符组。

如果想在字符串找到 Penguin 或 Pumpkin，可以用这个正则表达式：/P(engu|umpk)in/g。

然后使用 test() 方法检查 test 字符串里面是否包含字符组。

let testStr = "Pumpkin";
let testRegex = /P(engu|umpk)in/;
testRegex.test(testStr);

test 方法会返回 true。

要求
完善正则表达式，使其以区分大小写的方式检查 Franklin Roosevelt 或 Eleanor Roosevelt 的名字，并且应该忽略 middle names。

然后完善代码，使创建的正则检查 myString，根据正则是否匹配返回 true 或 false。
let myString = "Eleanor Roosevelt";
let myRegex = /False/; // 修改这一行
let result = false; // 修改这一行
// 使用 myString 通过挑战后，了解分组如何运行

参考
let myString = "Eleanor Roosevelt";
let myRegex = /(Franklin|Eleanor).*Roosevelt/; // 修改这一行
let result = myRegex.test(myString); // 修改这一行

//感觉这样很慢，有没有分享下更快的

#31使用捕获组重用模式

一些你所搜寻的匹配模式会在字符串中出现多次。手动重复该正则表达式显得不够简洁。当字符串中出现多个重复子字符串时，有一种更好的方式来编写模式。

可以使用捕获组（capture groups）搜寻重复的子字符串。括号 ( 和 ) 可以用来匹配重复的子字符串。把需要重复匹配的模式放在括号中即可。

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

要求
在 reRegex 中使用捕获组来匹配一个只由相同的数字重复三次组成的由空格分隔字符串。
let repeatNum = "42 42 42";
let reRegex = /change/; // 修改这一行
let result = reRegex.test(repeatNum);

参考
let repeatNum = "42 42 42";
let reRegex = /^(\d+)\s\1\s\1$/; // 修改这一行
let result = reRegex.test(repeatNum);

//或者
let reRegex = /^(\d+)(\s)\1\2\1$/;

#32使用捕获组搜索和替换

搜索功能是很有用的。但是，当搜索同时也执行更改（或替换）匹配文本的操作时，搜索功能就会显得更加强大。

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

要求
使用三个捕获组编写一个正则表达式 fixRegex，这三个捕获组将搜索字符串 one two three 中的每个单词。 然后更新 replaceText 变量，以字符串 three two one 替换 one two three，并将结果分配给 result 变量。 确保使用美元符号（$）语法在替换字符串中使用捕获组。

let str = "one two three";
let fixRegex = /change/; // 修改这一行
let replaceText = ""; // 修改这一行
let result = str.replace(fixRegex, replaceText);

参考
let str = "one two three";
let fixRegex = /(\w+)\s(\w+)\s(\w+)/g; // 修改这一行
let replaceText = "$3 $2 $1"; // 修改这一行
let result = str.replace(fixRegex, replaceText);

#33删除开头和结尾的空白

有时字符串周围存在的空白字符并不是必需的。字符串的典型处理是删除字符串开头和结尾处的空格

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

注意： String.prototype.trim() 方法在这里也可以实现同样的效果，但是你需要使用正则表达式来完成此项挑战。
let hello = "   Hello, World!  ";
let wsRegex = /change/; // 修改这一行
let result = hello; // 修改这一行

参考一 揪出来替换为空
let hello = "   Hello, World!  ";
let wsRegex = /^\s+|\s+$/g; 
let result = hello.replace(wsRegex, ""); 

参考二 抓三段，一三为空然后重新赋予新变量第二段
let hello = "   Hello, World!  ";
let wsRegex = /^(\s+)(.+[^\s])(\s+)$/;
let result = hello.replace(wsRegex, '$2');

速记表

字符	描述
\	正则表达式中那些有特殊含义的元字符，如果要匹配它们本身，就需要在它们前面要加上反斜杠。比如要匹配+，就要写成+。正则表达式中，需要反斜杠转义的，一共有12个字符：^、.、[、$、(、)、\|、*、+、?、{和\。
^	匹配输入字符串的开始位置
$	匹配输入字符串的结束位置
\b	匹配一个单词边界（boundary），也就是指单词和空格间的位置,包括开头和结尾
\B	匹配非单词边界
(?=p)	匹配后面是p的位置
(?!p)	匹配后面不是p的位置
？	匹配前面的子表达式零次或一次
*	匹配前面的子表达式零次或多次
+	匹配前面的子表达式一次或多次
{n}	n 是一个非负整数。匹配确定的 n 次。
{n,}	n 是一个非负整数。至少匹配n 次。
{n,m}	m 和 n 均为非负整数，其中n <= m。最少匹配 n 次且最多匹配 m 次。
x\|y	匹配 x 或 y
[xyz]	字符集合。匹配所包含的任意一个字符
[^xyz]	负值字符集合。匹配未包含的任意字符。
[a-z]	字符范围。匹配指定范围内的任意字符。
[^a-z]	负值字符范围。匹配任何不在指定范围内的任意字符。
\d	匹配一个数字字符。等价于 [0-9]
\D	匹配一个非数字字符。等价于 [^0-9]
\s	匹配任何空白字符，包括空格、制表符、换页符等等。等价于 [ \f\n\r\t\v]
\S	匹配任何非空白字符。等价于 [^ \f\n\r\t\v]。
\w	匹配字母、数字、下划线。等价于'[A-Za-z0-9_]'。
\W	匹配非字母、数字、下划线。等价于 '[^A-Za-z0-9_]'。
.	匹配除换行符 \n 之外的任何单字符

7/7/2021 12.43 AM to-do list checked.

Tobby Guo

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
FCC JavaScript 算法和数据结构正则表达式

Free Code Camp 学习笔记 js.正则表达式Many thxfor the FCC platform to open the JS door to me#1使用测试方法在编程语言中，正则表达式用于匹配指定的字符串。通过正则表达式创建匹配模式（规则）可以帮你完成指定匹配。.test()方法会把编写的正则表达式和字符串（即括号内的内容）匹配，如果成功匹配到字符，则返回true，反之，返回false。参考：原题let myString = "Hello, Wo...
复制链接

扫一扫