JavaScript - 正则表达式

b @[TOC]

.test() 测试字符是否存在于字符串中 /coding/

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

测试字符串内是否有对应字符
let testStr = "Hello, my name is Kevin.";
let testRegex = /Kevin/;
testRegex.test(testStr);
任何其他形式的 Kevin 都不会被匹配。 例如，正则表达式 /Kevin/ 不会匹配 kevin 或者KEVIN

匹配多个文字字符串

/yes|no/
使用|分隔

匹配时忽略大小写 i

使用 i 标志忽略大小写

 /ignorecase/i 
 这个字符串可以匹配字符串 ignorecase、igNoreCase 和 IgnoreCase。

.match() 提取匹配项

"Hello, World!".match(/Hello/);

let ourStr = "Regular expressions";
let ourRegex = /expressions/;
ourStr.match(ourRegex);
第一个 match 将返回 ["Hello"] 第二个将返回 ["expressions"]

全局匹配（搜索多次） g

可使用 g 标志，多次搜寻或提取模式匹配
在正则表达式上可以有多个标志，比如 /search/gi

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

用通配符匹配任何内容（模糊匹配） 通配符（.）

例如，如果想匹配 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);

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

如果想要匹配 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);
bagStr.match(bgRegex);
bugStr.match(bgRegex);
bogStr.match(bgRegex);
四次 match 调用将返回值 ["big"]、["bag"]、["bug"] 和 null

匹配字母表中的数字和字母 连字符（-）

let catStr = "cat";
let batStr = "bat";
let matStr = "mat";
let bgRegex = /[a-e]at/;  #匹配小写字母 a 到 e
catStr.match(bgRegex);
batStr.match(bgRegex);
matStr.match(bgRegex);

/[0-5]/ 匹配 0 和 5 之间的任意数字，包含 0 和 5
let jennyStr = "Jenny8675309";
let myRegex = /[a-z0-9]/ig;
jennyStr.match(myRegex);

/\w+/这个缩写等同于[A-Za-z0-9_]
此字符类匹配上面字母和小写字母以及数字。 
注意，这个字符类也包含下划线字符 (_)

匹配排除后的字符 否定字符集 脱字符（^）

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

匹配出现一次或多次的字符 （+）

例如，/a+/g 会在 abc 中匹配到一个匹配项，并且返回 [“a”]。 因为 + 的存在，它也会在 aabc 中匹配到一个匹配项，然后返回 [“aa”]。
如果它是检查字符串 abab，它将匹配到两个匹配项并且返回[“a”, “a”]，因为a字符不连续，在它们之间有一个b字符。 最后，因为在字符串 bcd 中没有 a，因此找不到匹配项。

匹配出现零次或多次的字符 （*）

let soccerWord = "gooooooooal!";
let gPhrase = "gut feeling";
let oPhrase = "over the moon";
let goRegex = /go*/;  #匹配g及其之后出现的零个或多个o
soccerWord.match(goRegex);
gPhrase.match(goRegex);
oPhrase.match(goRegex);
三次 match 调用将返回值 ["goooooooo"]，["g"] 和 null

惰性匹配来查找字符 （匹配最小可能部分)

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

字符串：["titani"]
贪婪匹配：
/t[a-z]*i/  匹配返回为 ["titani"]
懒惰匹配：
/t[a-z]*?i/匹配返回为["ti"]

匹配字符串的开头 脱字符（^）

let firstString = "Ricky is first and can be found.";
let firstRegex = /^Ricky/;
firstRegex.test(firstString);
let notFirst = "You can't find Ricky now.";
firstRegex.test(notFirst);
第一次 test 调用将返回 true，而第二次调用将返回 false。

匹配字符串的末尾 美元符号（$）

let theEnding = "This is a never ending story";
let storyRegex = /story$/;
storyRegex.test(theEnding);
let noEnding = "Sometimes a story will have to end";
storyRegex.test(noEnding);
第一次 test 调用将返回 true, 而第二次调用将返回 false。

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

let shortHand = /\W/;
let numbers = "42%";
let sentence = "Coding!";
numbers.match(shortHand);
sentence.match(shortHand);
第一次 match 调用将返回值 ["%"] 而第二次调用将返回 ["!"]。

匹配所有数字（\d）

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

匹配所有非数字 （\D）

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

限制可能的用户名

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

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

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

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

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

首先每个分支的前面要加上 ^，表示从头开始匹配。不加的话 BadUs3rnam3 中的 rnam3 会被匹配。
其次 * 要从 [] 中移出来。[a-z*] 表示匹配一个 a-z 的字母，或者一个符号 *；[a-z]* 表示匹配任意个 a-z 的字母。
然后每个分支结尾都要加 $。
最后结尾的 g 修饰符要删去。它会导致某些边界情况出错

匹配空白字符（\s）

\s。 此匹配模式将匹配空格、回车符、制表符、换页符和换行符。
类似于元字符 [ \r\t\f\n\v]

匹配非空白字符

\S。此匹配模式将不匹配空格、回车符、制表符、换页符和换行符。
类似于元字符 [^ \r\t\f\n\v]

指定匹配的上限和下限 花括号{ }

要匹配出现 3 到 5 次字母 a 的在字符串 ah
let A4 = "aaaah";
let A2 = "aah";
let multipleA = /a{3,5}h/;
multipleA.test(A4);
multipleA.test(A2);
第一次 test 调用将返回 true，而第二次调用将返回 false

只指定匹配的下限

匹配至少出现 3 次字母 a 的字符串 hah
/ha{3,}h/

指定匹配的确切数量

只匹配字母 a 出现 3 次的单词hah
/ha{3}h/

检查全部或无

问号 ? 将检查前面的零个或一个元素

/colou?r/

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

正向先行断言的用法是 (?=…)，其中 … 就是需要存在但不会被匹配的部分。
负向先行断言的用法是 (?!..)，其中 … 是希望不存在的匹配模式。 如果负向先行断言部分不存在，将返回匹配模式的其余部分。

let quit = "qu";
let noquit = "qt";
let quRegex= /q(?=u)/;
let qRegex = /q(?!u)/;
quit.match(quRegex);
noquit.match(qRegex);
这两次 match 调用都将返回 ["q"]。

匹配大于 5 个字符且有两个连续数字的密码

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

检查混合字符组 括号 ()

想在字符串找到 Penguin 或 Pumpkin
let testStr = "Pumpkin";
let testRegex = /P(engu|umpk)in/;
testRegex.test(testStr);