共计 7953 个字符，预计需要花费 20 分钟才能阅读完成。
正则表达式 Regular Expression
在编程语言中，正则表达式用于匹配指定的字符串。
如果想要在字符串 The dog chased the cat 中匹配到 the 这个单词，能够应用如下正则表达式：/the/。留神，正则表达式中不须要引号。
应用测试方法 Test Method
JavaScript 中有多种应用正则表达式的办法。测试正则表达式的一种办法是应用 .test() 办法。.test() 办法会把编写的正则表达式和字符串（即括号内的内容）匹配，如果胜利匹配到字符，则返回 true，反之，返回 false。
let testStr = "freeCodeCamp";
let testRegex = /Code/;
testRegex.test(testStr) // true多种模式匹配 Match
应用 alternation 或 OR 操作符搜寻多个模式：|。此操作符匹配操作符后面或前面的字符。例如，如果想匹配 yes 或 no，你须要的正则表达式是 /yes|no/。
let petString = "James has a pet cat.";
let petRegex = /dog|cat|bird|fish/;
let result = petRegex.test(petString); // true疏忽大小写 Ignore Case
有时候，并不关注匹配字母的大小写。
能够应用标记（flag）来匹配这两种状况。疏忽大小写的标记——i。能够通过将它附加到正则表达式之后来应用它。
let myString = "freeCodeCamp";
let fccRegex = /freeCodeCamp/i;
let result = fccRegex.test(myString); // 匹配 freeCodeCamp 疏忽大小写提取匹配项 Extract
应用 .match() 办法来提取找到的理论匹配项。
能够应用字符串来调用 .match() 办法，并在括号内传入正则表达式。
"Hello, World!".match(/Hello/);
let ourStr = "Regular expressions";
let ourRegex = /expressions/;
ourStr.match(ourRegex);
// 这里第一个 match 将返回 ["Hello"] 第二个将返回 ["expressions"]。请留神，.match 语法是目前为止始终应用的 .test 办法中的“反向”：
'string'.match(/regex/);
/regex/.test('string');全局匹配 Global
若要屡次搜查或提取模式匹配，能够应用 g 标记。
let testStr = "Repeat, Repeat, Repeat";
let repeatRegex = /Repeat/g;
testStr.match(repeatRegex);
// match 返回值 `["Repeat", "Repeat", "Repeat"]`留神：
在正则表达式上能够有多个标记，比方 /search/gi
用通配符匹配任何内容 Wildcard Period
有时不（或不须要）晓得匹配模式中的确切字符。如果要准确匹配到残缺的单词，那呈现一个拼写错误就会匹配不到。侥幸的是，能够应用通配符 . 来解决这种状况。
通配符 . 将匹配任何一个字符。通配符也叫 dot 或 period。能够像应用正则表达式中任何其余字符一样应用通配符。例如，如果想匹配 hug、huh、hut 和 hum，能够应用正则表达式 /hu./ 匹配以上四个单词。
let humStr = "I'll hum a song";
let hugStr = "Bear hug";
let huRegex = /hu./;
huRegex.test(humStr); // true
huRegex.test(hugStr); // true多种可能匹配 Multiple Possbilities
文字匹配模式（/literal/）和通配符（/./）。这是正则表达式的两种极其状况，一种是准确匹配，而另一种则是匹配所有。在这两种极其状况之间有一个均衡选项。
能够应用字符集（character classes）更灵便的匹配字符。能够把字符集放在方括号（[ 和 ]）之间来定义一组须要匹配的字符串。
例如，如果想要匹配 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); // ["big"]
bagStr.match(bgRegex); // ["bag"]
bugStr.match(bgRegex); // ["bug"]
bogStr.match(bgRegex); // null匹配字母表 Alphabet
有时须要匹配大量字符（例如，字母表中的每个字母）。在字符集中，能够应用连字符（-）来定义要匹配的字符范畴。例如，要匹配小写字母 a 到 e，能够应用 [a-e]。
let catStr = "cat";
let batStr = "bat";
let matStr = "mat";
let bgRegex = /[a-e]at/;
catStr.match(bgRegex); // ["cat"]
batStr.match(bgRegex); // ["bat"]
matStr.match(bgRegex); // null匹配数字和字母 Letters and Numbers
应用连字符（-）匹配字符范畴并不仅限于字母。它还能够匹配一系列数字。在单个字符集中组合一系列字母和数字。
let jennyStr = "Jenny8675309";
let myRegex = /[a-z0-9]/ig;
jennyStr.match(myRegex);匹配单个未指定字符 Not Specified
创立一个不想匹配的字符汇合。这些类型的字符集称为否定字符集（negated character sets）。
要创立否定字符集，须要在开始括号前面和不想匹配的字符后面搁置脱字符（即^）。
例如，/[^aeiou]/gi 匹配所有非元音字符。留神，字符 .、!、[、@、/ 和空白字符等也会被匹配，该否定字符集仅排除元音字符。
let quoteSample = "3 blind mice.";
let myRegex = /[^0-9aeiou]/gi;
let result = quoteSample.match(myRegex);
// 匹配所有非数字和非元音字符匹配呈现一次或屡次的字符
有时，须要匹配呈现一次或者间断屡次的的字符（或字符组）。这意味着它至多呈现一次，并且可能反复呈现。
能够应用 + 符号来查看状况是否如此。记住，字符或匹配模式必须一个接一个地间断呈现。这就是说，字符必须一个接一个地反复。
例如，/a+/g 会在 abc 中匹配到一个匹配项，并且返回 ["a"]。因为 + 的存在，它也会在 aabc 中匹配到一个匹配项，而后返回 ["aa"]。
如果它是查看字符串 abab，它将匹配到两个匹配项并且返回 ["a", "a"]，因为a 字符不间断，在它们之间有一个 b 字符。最初，因为在字符串 bcd 中没有 a，因而找不到匹配项。
let difficultSpelling = "Mississippi";
let myRegex = /s+/g;
let result = difficultSpelling.match(myRegex);
// 匹配 Mississippi 中呈现的 s匹配呈现零次或屡次的字符
匹配呈现零次或屡次的字符。
执行该操作的字符叫做星号，即*。
let soccerWord = "gooooooooal!";
let gPhrase = "gut feeling";
let oPhrase = "over the moon";
let goRegex = /go*/;
soccerWord.match(goRegex); // ["goooooooo"]
gPhrase.match(goRegex); // ["g"]
oPhrase.match(goRegex); // null惰性匹配 Lazy Matching
在正则表达式中，贪婪（greedy）匹配会匹配到合乎正则表达式匹配模式的字符串的最长可能局部，并将其作为匹配项返回。另一种计划称为懈怠（lazy）匹配，它会匹配到满足正则表达式的字符串的最小可能局部。
能够将正则表达式 /t[a-z]*i/ 利用于字符串 "titanic"。这个正则表达式是一个以 t 开始，以 i 完结，并且两头有一些字母的匹配模式。
正则表达式默认是贪婪匹配，因而匹配返回为 ["titani"]。它会匹配到适宜该匹配模式的最大子字符串。
然而，应用 ? 字符来将其变成懈怠匹配。调整后的正则表达式 /t[a-z]*?i/ 匹配字符串 "titanic" 返回 ["ti"]。
留神：应该防止应用正则表达式解析 HTML，然而能够用正则表达式匹配 HTML 字符串。
let text = "<h1>Winter is coming</h1>";
let myRegex = /<.*?>/; // 批改这一行
let result = text.match(myRegex);
// 匹配 h1匹配字符串结尾 Beginning
应用字符集中前插入符号（^）来创立一个否定字符集，形如 [^thingsThatWillNotBeMatched]。除了在字符集中应用之外，脱字符还用于匹配字符串的开始地位。
let firstString = "Ricky is first and can be found.";
let firstRegex = /^Ricky/;
firstRegex.test(firstString); // true
let notFirst = "You can't find Ricky now.";
firstRegex.test(notFirst); // false匹配字符串开端 Ending
能够应用正则表达式的美元符号 $ 来搜查字符串的结尾。
let theEnding = "This is a never ending story";
let storyRegex = /story$/;
storyRegex.test(theEnding); // true
let noEnding = "Sometimes a story will have to end";
storyRegex.test(noEnding); // false匹配所有字母和数字 \w
JavaScript 中与字母表匹配的最靠近的元字符是\w。这个缩写等同于[A-Za-z0-9_]。此字符类匹配大写字母和小写字母以及数字。留神，这个字符类也蕴含下划线字符 (_)。
let longHand = /[A-Za-z0-9_]+/;
let shortHand = /\w+/;
let numbers = "42";
let varNames = "important_var";
longHand.test(numbers); // true
shortHand.test(numbers); // true
longHand.test(varNames); // true
shortHand.test(varNames); // true这些元字符缩写也被称为短语元字符 shorthand character classes。
匹配除了数字和字母之外所有的符号 \W
能够应用 \W 搜查和 \w 相同的匹配模式。留神，相同匹配模式应用大写字母。此缩写与 [^A-Za-z0-9_] 是一样的。
let shortHand = /\W/;
let numbers = "42%";
let sentence = "Coding!";
numbers.match(shortHand); // ["%"]
sentence.match(shortHand); // ["!"]匹配所有数字 \d
查找数字字符的缩写是 \d，留神是小写的 d。这等同于元字符 [0-9]，它查找 0 到 9 之间任意数字的单个字符。
let movieName = "2001: A Space Odyssey";
let numRegex = /\d/g;
let result = movieName.match(numRegex).length;匹配所有非数字 \D
也能够应用相似的缩写来搜查非数字，该缩写应用大写的 D。
查找非数字字符的缩写是 \D。这等同于字符串 [^0-9]，它查找不是 0 – 9 之间数字的单个字符。
let movieName = "2001: A Space Odyssey";
let noNumRegex = /\D/g;
let result = movieName.match(noNumRegex).length;匹配空白字符 \s
能够匹配字符之间的空格。
能够应用 \s 搜查空格，其中 s 是小写。此匹配模式将匹配空格、回车符、制表符、换页符和换行符。能够认为这相似于元字符 [\r\t\f\n\v]。
let whiteSpace = "Whitespace. Whitespace everywhere!"
let spaceRegex = /\s/g;
whiteSpace.match(spaceRegex); // [""," "]匹配非空白字符 \S
应用 \S 搜查非空白字符，其中 s 是大写。此匹配模式将不匹配空格、回车符、制表符、换页符和换行符。能够认为这相似于元字符 [^ \r\t\f\n\v]。
let whiteSpace = "Whitespace. Whitespace everywhere!"
let nonSpaceRegex = /\S/g;
whiteSpace.match(nonSpaceRegex).length // 32指定匹配的上上限 Upper and Lower
应用数量说明符（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); // true
multipleA.test(A2); // false只指定匹配的上限 Only Lower
有时候只想指定匹配模式的上限而不须要指定下限。为此，在第一个数字前面跟一个逗号即可。
例如，要匹配至多呈现 3 次字母 a 的字符串 hah，正则表达式应该是/ha{3,}h/。
let A4 = "haaaah";
let A2 = "haah";
let A100 = "h" + "a".repeat(100) + "h";
let multipleA = /ha{3,}h/;
multipleA.test(A4); // t
multipleA.test(A2); // false
multipleA.test(A100);
// true指定匹配的确切数量 Exact Number
要指定肯定数量的匹配模式，只需在大括号之间搁置一个数字。
例如，要只匹配字母 a 呈现 3 次的单词hah，正则表达式应为/ha{3}h/。
let A4 = "haaaah";
let A3 = "haaah";
let A100 = "h" + "a".repeat(100) + "h";
let multipleHA = /ha{3}h/;
multipleHA.test(A4); // false
multipleHA.test(A3); // true
multipleHA.test(A100); // false查看全副或无 ?
为此，能够应用问号 ? 指定可能存在的元素。这将查看 后面的零个或一个元素。能够将此符号视为后面的元素是可选的。
例如，美式英语和英式英语略有不同，能够应用问号来匹配两种拼写。
let american = "color";
let british = "colour";
let rainbowRegex= /colou?r/;
rainbowRegex.test(american); // true
rainbowRegex.test(british); // true正向后行断言和负向后行断言 Positive and Negative Loadahead
后行断言（Lookaheads）是通知 JavaScript 在字符串中向前查找的匹配模式。当想要在同一个字符串上搜查多个匹配模式时，这可能十分有用。
有两种后行断言：正向后行断言（positive lookahead）和负向后行断言（negative lookahead）。
正向后行断言会查看并确保搜寻匹配模式中的元素存在，但实际上并不匹配。正向后行断言的用法是 (?=...)，其中 ... 就是须要存在但不会被匹配的局部。
另一方面，负向后行断言会查看并确保搜寻匹配模式中的元素不存在。负向后行断言的用法是 (?!...)，其中 ... 是心愿不存在的匹配模式。如果负向后行断言局部不存在，将返回匹配模式的其余部分。
只管后行断言有点儿令人困惑，然而这些示例会有所帮忙。
let quit = "qu";
let noquit = "qt";
let quRegex= /q(?=u)/;
let qRegex = /q(?!u)/;
quit.match(quRegex); // true
noquit.match(qRegex); // true查看混合字符 Mixed
应用正则表达式里的括号 () 来查看字符组。
如果想在字符串找到 Penguin 或 Pumpkin，能够用这个正则表达式：/P(engu|umpk)in/g。
而后应用 test() 办法查看 test 字符串外面是否蕴含字符组。
let testStr = "Pumpkin";
let testRegex = /P(engu|umpk)in/;
testRegex.test(testStr); // true应用捕捉组重用模式 Capture Group
捕捉组能够用于找到反复的子字符串。捕捉组是通过把要捕捉的正则表达式放在括号中来构建的。在这个例子里，指标是捕捉一个蕴含字母数字字符的词，所以捕捉组是将 \w+ 放在括号中：/(\w+)/。
分组匹配的子字符串被保留到一个长期的“变量”，能够应用同一正则表达式和反斜线及捕捉组的编号来拜访它（例如：\1）。捕捉组按其结尾括号的地位主动编号（从左到右），从 1 开始。
上面的示例是匹配被空格隔开的两个雷同单词：
let repeatRegex = /(\w+) \1 \1/;
repeatRegex.test(repeatStr); // Returns true
repeatStr.match(repeatRegex); // Returns ["row row row", "row"]应用捕捉组搜寻和替换
能够在字符串上应用 .replace() 办法来搜寻并替换字符串中的文本。.replace() 的输出首先是想要搜寻的正则表达式匹配模式。第二个参数是用于替换匹配的字符串或用于执行某些操作的函数。
let wrongText = "The sky is silver.";
let silverRegex = /silver/;
wrongText.replace(silverRegex, "blue");
// The sky is blue还能够应用美元符号（$）拜访替换字符串中的捕捉组。
"Code Camp".replace(/(\w+)\s(\w+)/, '$2 $1');
// Camp Code删除结尾和结尾的空白 Remove whitespace
字符串的典型解决是删除字符串结尾和结尾处的空格。
String.prototype.trim() 办法在这里也能够实现同样的成果。
let hello = "Hello, World!";
let wsRegex = /^\s+|\s+$/g; //
let result = hello.replace(wsRegex, "");
