正则表达式中的特殊字符

'^'号

• 匹配输入的开始。如果多行标志被设置为true，那么也匹配换行符后紧跟的位置。
• 例如，/^A/ 并不会匹配 "an A" 中的 'A'，但是会匹配 "An E" 中的 'A'。

/^A/.test("an A");   // true
/^A/.test("An E");   // false

'$'号

• 匹配输入的结束。如果多行标示被设置为true，那么也匹配换行符前的位置。
• 例如，/t$/ 并不会匹配 "eater" 中的 't'，但是会匹配 "eat" 中的 't'。

/t$/.test("eater");   // false
/t$/.test("eat");     // true

'*'号

• 匹配前一个表达式0次或多次。等价于 {0,}。
• 例如，/bo*/会匹配 "A ghost boooooed" 中的 'booooo' 和 "A bird warbled" 中的 'b'，但是在 "A goat grunted" 中将不会匹配任何东西。

"A ghost boooooed".replace(/bo*/,"c"); // "A ghost ced"

'+'号

• 匹配前面一个表达式1次或者多次。等价于 {1,}。
• 例如，/a+/匹配了在 "candy" 中的 'a'，和在 "caaaaaaandy" 中所有的 'a'。

'?'号

• 匹配前面一个表达式0次或者1次。等价于 {0,1}。
• 例如，/e?le?/ 匹配 "angel" 中的 'el'，和 "angle" 中的 'le' 以及"oslo' 中的'l'。
• 如果紧跟在任何量词 *、 +、? 或 {} 的后面，将会使量词变为非贪婪的（匹配尽量少的字符），和缺省使用的贪婪模式（匹配尽可能多的字符）正好相反。例如，对 "123abc" 应用 /\d+/ 将会返回 "123"，如果使用 /\d+?/,那么就只会匹配到 "1"。
• 还可以运用于向前断言，在x(?=y) 和 x(?!y) 中有描述。

/e?le?/.exec("angel");        // ['el']
/e?le?/.exec("angle");        // ['le']
/e?le?/.exec("oslo");         // ['l']

/\d+?/.exec("123abc")         // ['1'] 非贪婪模式 （匹配尽量少的字符） 

'.'小数点

• （小数点）匹配除了换行符（\n）之外的任何单个字符。
• 例如，/.n/将会匹配 "nay, an apple is on the tree" 中的 'an' 和 'on'，但是不会匹配 'nay'。

'(x)'圆括号 捕获括号

• 匹配 'x' 并且记住匹配项，就像下面的例子展示的那样。括号被称为 捕获括号。
• 模式 /(foo) (bar) \1 \2/ 中的 '(foo)' 和 '(bar)' 匹配并记住字符串 "foo bar foo bar" 中前两个单词。模式中的 \1 和 \2 匹配字符串的后两个单词。注意 \1、\2、\n 是用在正则表达式的匹配环节。在正则表达式的替换环节，则要使用像 $1、$2、$n 这样的语法，例如，'bar foo'.replace( /(...) (...)/, '$2 $1' )。

\n(n为正整数)表示第n个捕获括号中的内容

/(foo) (bar) \1 \2/.exec( "foo bar foo bar"); // ["foo bar foo bar", "foo", "bar"]

(?:x) 非捕获括号

• 匹配 'x' 但是不记住匹配项。这种叫作非捕获括号，使得你能够定义为与正则表达式运算符一起使用的子表达式。
• 来看示例表达式 /(?:foo){1,2}/。如果表达式是 /foo{1,2}/，{1,2}将只对 ‘foo’ 的最后一个字符 ’o‘ 生效。如果使用非捕获括号，则{1,2}会匹配整个 ‘foo’ 单词。

/foo{1,2}/.exec("fooofooo");          //["fooo"]
/(?:foo){1,2}/.exec("foofooo");       //["foofoo"]  

x(?=y) 正向肯定查找

• 匹配'x'仅仅当'x'后面跟着'y'.这种叫做正向肯定查找。
• 例如，/Jack(?=Sprat)/会匹配到'Jack'仅仅当它后面跟着'Sprat'。/Jack(?=Sprat|Frost)/匹配‘Jack’仅仅当它后面跟着'Sprat'或者是‘Frost’。但是‘Sprat’和‘Frost’都不是匹配结果的一部分。

/Jack(?=Sprat)/.exec("JackSprat");        // ["Jack"]
/Jack(?=Sprat|Frost)/.exec("JackFrost")   // ["Jack"]

x(?!y) 正向否定查找

• 匹配'x'仅仅当'x'后面不跟着'y',这个叫做正向否定查找。
• 例如，/\d+(?!\.)/匹配一个数字仅仅当这个数字后面没有跟小数点的时候。正则表达式/\d+(?!\.)/.exec("3.141")匹配‘141’但是不是‘3.141’

/\d+(?!\\.)/.exec("3.141")    // '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，也匹配“caaaaaaandy”中得前三个a。注意，当匹配”caaaaaaandy“时，匹配的值是“aaa”，即使原始的字符串中有更多的a。

[xyz]

• 一个字符集合。匹配方括号的中任意字符。你可以使用破折号（-）来指定一个字符范围。对于点（.）和星号（*）这样的特殊符号在一个字符集中没有特殊的意义。他们不必进行转意，不过转意也是起作用的。
• 例如，[abcd] 和[a-d]是一样的。他们都匹配"brisket"中得‘b’,也都匹配“city”中的‘c’。/[a-z.]+/ 和/[\w.]+/都匹配“test.i.ng”中得所有字符。

[^xyz]

• 一个反向字符集。匹配不包含在方括号内的任何字符
• 例如，[^abc] 和 [^a-c] 是一样的。他们匹配"brisket"中得‘r’，也匹配“chop”中的‘h’。

\b

• 匹配一个词的边界。

\B

• 匹配一个非单词边界。

\d

• 匹配一个数字，等价于[0-9]。

\D

• 匹配一个非数字，等价于[^0-9]。

\s

• 匹配一个空白符 包括空格、制表符、换页符和换行符。

\S

• 匹配一个非空白字符。

\w

• 匹配一个单字字符（字母、数字或者下划线）。等价于[A-Za-z0-9_]。

\W

• 匹配一个非单字字符。等价于[^A-Za-z0-9_]。

正则表达式方法

exec()

regexObj.exec(str)

• 参数
  • str
    • 要用正则表达式匹配的字符串。
• 返回值

  • 如果成功匹配，exec 方法返回一个数组，并且更新正则表达式对象的属性(lastIndex)。返回的数组包括匹配的字符串作为第一个元素，紧接着一个元素对应一个成功匹配被捕获的字符串的捕获括号

  • 如果匹配失败，exec 方法将返回 null。

var re = /quick\s(brown).+?(jumps)/ig;
var result = re.exec('The Quick Brown Fox Jumps Over The Lazy Dog');

result{
    0: "Quick Brown Fox Jumps",
    1: "Brown",
    2: "Jumps",
    index: 4,
    input: "The Quick Brown Fox Jumps Over The Lazy Dog",
    length: 3
}

re{
    global: true,
    ignoreCase: true,
    lastIndex: 25,
    multiline: false,
    source: "quick\s(brown).+?(jumps)"
}

test()

regexObj.test(str)

执行一个检索，用来查看正则表达式与指定的字符串是否匹配。返回 true 或 false。