正则的api的整理

1.普通正则

var eg = /hello/ig;

   正则可以传入两个参数：  
   这里是引用

  1、正则主体部分，一般情况下就是字符串    
  2、修饰符(没有先后顺序)
       i  忽略大小写
       g  全局匹配          
       m  换行匹配

2.new RegExp() 对象

var num = new RegExp(“hello”, “ig”);

3.省略new创建正则

var num = RegExp(“hello”, “ig”);

4.正则表达式的常用方法

1.RegExp 对象方法

1-1 exec

  var reg=/\d/g;
   var str="1c2v3r"
   var r=""
   //因为exec每次捕获一次 （加g的时候是捕获全部的内容，不加g的时候只捕获第一个）所以加while循环
   while(r=reg.exec(str)){
   console.log(r)  
   }
  ["1", index: 0, input: "1c2v3r", groups: undefined]
  
  ["2", index: 2, input: "1c2v3r", groups: undefined]
   
  ["3", index: 4, input: "1c2v3r", groups: undefined]
   注释：只能执行一次，返回的数组就是当前的匹配内容的信息
0,表示需要匹配的内容,index表示匹配的位置，input匹配的内容 
   }
 //受小分组的影响 但不受g的影响
    var str5 = 'abc';
    var reg5 = /(a)(b)(c)/;
   console.log( reg5.exec(str5));
    ["abc", "a", "b", "c", index: 0, input: "abc"]
   其中 "a" "b" "c" 都是第一次匹配到的"abc" 拆分的小分组

1-2.test

   var str="aass1d"
    var reg=/\d/g
    var r=reg.test(str)
    console.log(r) //true
   //返回值为true或者false

2.String对象方法

2-1. match()

      var  reg = /\d+/g;
      var str = 'abc123de45fgh6789qqq111';
      str.match(reg)
      // ["123", "45", "6789", "111"]
     //受小分组的影响 且也受g的影响
      1.无g的情况
      var str = 'abc-abc';
      var reg= /(a)(b)(c)/;
      console.log( str.match(reg)); 
     //["abc", "a", "b", "c", index: 0, input: "abc-abc", groups: undefined]
      2.有g的情况
      var str = 'abc-abc';
      var reg = /(a)(b)(c)/g;
     console.log( str.match(reg));//["abc", "abc"] 

2-2.Search()

search() 方法不执行全局匹配，它将忽略标志 g。它同时忽略 regexp 的 lastIndex 属性，并且总是从字符串的开始进行检索，这意味着它总是返回 stringObject 的第一个匹配的位置；它对i是支持的,它的返回值是检索的位置，若没有返回-1

    var str="aass1zd"
    var reg=/\d/g
    var r= str.search(reg);
    console.log(r) // 4

2-3match

返回数组，该方法类似 indexOf() 和 lastIndexOf()，但是它返回指定的值，而不是字符串的位置,而是检索出来的内容数组形式展现（多个结果的返回，要加g,否知只返回第一个内容，若没有匹配结果则返回null）

   var str="aass1zd"
    var reg=/\d/g
    var r= str.match(reg);
    console.log(r) // ["1"]

    var str2="a1ass11zd"
    var reg2=/\d+/g
    var r= str2.match(reg2);
    console.log(r) // ["1","11"]

    //不加g的情况
     var str="aass1z2d"
     var reg=/\d/
     var r= str.match(reg);
     console.log(r) // ["1", index: 4, input: "aass1z2d",     groups: undefined]

2-3replace()

一些字符替换另一些字符，或替换一个与正则表达式匹配的子串

• 如果 regexp 具有全局标志 g，那么 replace() 方法将替换所有匹配的子串。否则，它只替换第一个匹配子串
• 如果replace方法的第一个参数传入的是带分组的正则表达式，我们在第二个参数中可以使

用以下来获取相应的分组内容

  
  var str3="a1ass11zd"
    var reg=/\d+/g
    var r3= str3.replace(reg,"1111")
    console.log(r3,"replace") //a1111ass1111zd 

    var str3="a1ass11zd"
    var reg=/\d+/
    var r3= str3.replace(reg,"1111")
    console.log(r3,"replace") //a1111ass11zd 

5.正则表达式的属性

1.global：

如果设置了new RegExp(‘s’,’g’),g(全局)被设置，所以global为true

2.ignoreCase：

同上，ignoreCase,对应的是i(大小写是否敏感)

3lastIndex：

整数 表示开始搜索下一个匹配项的字符位置 从0开始

var reg=/\d/g;

var r=reg.exec('a1b2c3');

 console.log(reg.lastIndex); //2

 r=reg.exec('a1b2c3');

 console.log(reg.lastIndex); //4

4.multiline：

同上上:multiline对应m(多行匹配)

5 Source：

正则表达式的字符串的表示 按照字面量形式 而非传入构造函数中的字符串摸式返回

 var str = "Visit W3School.com.cn";

var patt1 = new RegExp("W3S","g");
console.log(patt1.source,"---") // W3S

6.元字符

\ :
将下一个字符标记为一个特殊字符、或一个原义字符、或一个 向后引用、或一个八进制转义符。例如，‘n’ 匹配字符 “n”。’\n’ 匹配一个换行符。序列 ‘\’ 匹配 “” 而 “(” 则匹配 “(”。

^:
匹配输入字符串的开始位置。如果设置了 RegExp 对象的 Multiline 属性，^ 也匹配 ‘\n’ 或 ‘\r’ 之后的位置

== : $ :==
匹配输入字符串的结束位置。如果设置了RegExp 对象的 Multiline 属性，$ 也匹配 ‘\n’ 或 ‘\r’ 之前的位置

*:
匹配前面的子表达式零次或多次。例如，zo* 能匹配 “z” 以及 “zoo”。* 等价于{0,}

+:
匹配前面的子表达式一次或多次。例如，‘zo+’ 能匹配 “zo” 以及 “zoo”，但不能匹配 “z”。+ 等价于 {1,}

?:
匹配前面的子表达式零次或一次。例如，“do(es)?” 可以匹配 “do” 或 “does” 。? 等价于 {0,1}

{n}:
n 是一个非负整数。匹配确定的 n 次。例如，‘o{2}’ 不能匹配 “Bob” 中的 ‘o’，但是能匹配 “food” 中的两个 o

{n,}:
n 是一个非负整数。至少匹配n 次。例如，‘o{2,}’ 不能匹配 “Bob” 中的 ‘o’，但能匹配 “foooood” 中的所有 o。‘o{1,}’ 等价于 ‘o+’。‘o{0,}’ 则等价于 ‘o*’。

{n,m}
m 和 n 均为非负整数，其中n <= m。最少匹配 n 次且最多匹配 m 次。例如，“o{1,3}” 将匹配 “fooooood” 中的前三个 o。‘o{0,1}’ 等价于 ‘o?’。请注意在逗号和两个数之间不能有空格

?:
当该字符紧跟在任何一个其他限制符 (*, +, ?, {n}, {n,}, {n,m}) 后面时，匹配模式是非贪婪的。非贪婪模式尽可能少的匹配所搜索的字符串，而默认的贪婪模式则尽可能多的匹配所搜索的字符串。例如，对于字符串 “oooo”，‘o+?’ 将匹配单个 “o”，而 ‘o+’ 将匹配所有 ‘o’。

.：
匹配除换行符（\n、\r）之外的任何单个字符。要匹配包括 ‘\n’ 在内的任何字符，请使用像"(.|\n)"的模式

(pattern)
匹配 pattern 并获取这一匹配。所获取的匹配可以从产生的 Matches 集合得到，在VBScript 中使用 SubMatches 集合，在JScript 中则使用 $0…$9 属性。要匹配圆括号字符，请使用 ‘(’ 或 ‘)’

   //简单说就是可以设置小分组 并且可以通过$1,$n获取到
   //更换等号两边的位置
   var str="5=a,6=b,7=c";
   str=str.replace(/(\d+)=(\w)/g,"$2=$1");
   console.log(str)  

(?:pattern)

匹配 pattern 但不获取匹配结果，也就是说这是一个非获取匹配，不进行存储供以后使用。这在使用 “或” 字符 (|) 来组合一个模式的各个部分是很有用。例如， 'industr(?:y|ies) 就是一个比 ‘industry|industries’ 更简略的表达式

  var str7="'industryindustries"
  var reg7=/industr(?:y|ies)/g
  var r7=str7.match(reg7)
  console.log(r7,"7777")// ["industry", "industries"]

(?=pattern)：

正向肯定预查（look ahead positive assert），在任何匹配pattern的字符串开始处匹配查找字符串。这是一个非获取匹配，也就是说，该匹配不需要获取供以后使用。例如，“Windows(?=95|98|NT|2000)“能匹配"Windows2000"中的"Windows”，但不能匹配"Windows3.1"中的"Windows”。预查不消耗字符，也就是说，在一个匹配发生后，在最后一次匹配之后立即开始下一次匹配的搜索，而不是从包含预查的字符之后开始

  var str8="Windows2000"
  var reg8=/Windows(?=95|98|NT|2000)/
  var r8=str8.match(reg8)
  console.log(r8,"88888") //Windows

 var str8="Windows3.1"
  var reg8=/Windows(?=95|98|NT|2000)/
  var r8=str8.match(reg8)
  console.log(r8,"88888") //null

(?!pattern)

正向否定预查(negative assert)，在任何不匹配pattern的字符串开始处匹配查找字符串。这是一个非获取匹配，也就是说，该匹配不需要获取供以后使用。例如"Windows(?!95|98|NT|2000)“能匹配"Windows3.1"中的"Windows”，但不能匹配"Windows2000"中的"Windows"。预查不消耗字符，也就是说，在一个匹配发生后，在最后一次匹配之后立即开始下一次匹配的搜索，而不是从包含预查的字符之后开始

    var str8="Windows3.1"
    var reg8=/Windows(?!95|98|NT|2000)/
    var r8=str8.match(reg8)
    console.log(r8,"88888") //Windows
  
    var str8="Windows2000"
    var reg8=/Windows(?!95|98|NT|2000)/
    var r8=str8.match(reg8)
    console.log(r8,"88888") //null

(?<=pattern)：
反向(look behind)肯定预查，与正向肯定预查类似，只是方向相反。例如，"(?<=95|98|NT|2000)Windows"能匹配"2000Windows"中的"Windows"，但不能匹配"3.1Windows"中的"Windows"

(?<!pattern)
反向否定预查，与正向否定预查类似，只是方向相反。例如"(?<!95|98|NT|2000)Windows"能匹配"3.1Windows"中的"Windows"，但不能匹配"2000Windows"中的"Windows"

x|y
匹配 x 或 y。例如，‘z|food’ 能匹配 “z” 或 “food”。’(z|f)ood’ 则匹配 “zood” 或 “food”。

[xyz]
字符集合。匹配所包含的任意一个字符。例如， ‘[abc]’ 可以匹配 “plain” 中的 ‘a’

    var  str9="abcdef"
    var  reg9=/[abc]/g
    var r9=str9.match(reg9)
    console.log(r9,"999") //["a", "b", "c"]

[^xyz]
负值字符集合。匹配未包含的任意字符。例如， ‘[^abc]’ 可以匹配 “plain” 中的’p’、‘l’、‘i’、'n

    var str10="plain"
    var reg10=/[^abc]/g
    var r10=str10.match(reg10)
    console.log(r10,"1010") //["p", "l", "i", "n"]

[a-z]
字符范围。匹配指定范围内的任意字符。例如，’[a-z]’ 可以匹配 ‘a’ 到 ‘z’ 范围内的任意小写字母字符

    var str10="plain"
    var reg10=/[a-z]/g
    var r10=str10.match(reg10)
    console.log(r10,"1010") //["p", "l", "a", "i", "n"]

[^a-z]
负值字符范围。匹配任何不在指定范围内的任意字符。例如，’[^a-z]’ 可以匹配任何不在 ‘a’ 到 ‘z’ 范围内的任意字符。

\b:
匹配一个单词边界，也就是指单词和空格间的位置。例如， ‘er\b’ 可以匹配"never" 中的 ‘er’，但不能匹配 “verb” 中的 ‘er’

    var str11="never"
    var reg11=/er\b/g
    var r11=str11.match(reg11)
    console.log(r11,"111") //er
   
    var str12="verb"
    var reg12=/er\b/g
    var r12=str12.match(reg12)
    console.log(r12,"1212") //null

\B
匹配非单词边界。‘er\B’ 能匹配 “verb” 中的 ‘er’，但不能匹配 “never” 中的 ‘er’

\cx
匹配由 x 指明的控制字符。例如， \cM 匹配一个 Control-M 或回车符。x 的值必须为 A-Z 或 a-z 之一。否则，将 c 视为一个原义的 ‘c’ 字符

\d
匹配一个数字字符。等价于 [0-9]

\D
配一个非数字字符。等价于 [^0-9]

\f
匹配一个换页符。等价于 \x0c 和 \cL。

\n
匹配一个换行符。等价于 \x0a 和 \cJ

\r
匹配一个回车符。等价于 \x0d 和 \cM

\s:
匹配任何空白字符，包括空格、制表符、换页符等等。等价于 [ \f\n\r\t\v]。

\S： 匹配任何非空白字符。等价于 [^ \f\n\r\t\v]

\t 匹配一个制表符。等价于 \x09 和 \cI。

\v 匹配一个垂直制表符。等价于 \x0b 和 \cK

\w 数字，字母，下划线 0-9 a-z A-Z_

\W 匹配非字母、数字、下划线。等价于 ‘[^A-Za-z0-9_]’

\xn 匹配 n，其中 n 为十六进制转义值。十六进制转义值必须为确定的两个数字长。例如，’\x41’ 匹配 “A”。’\x041’ 则等价于 ‘\x04’ & “1”。正则表达式中可以使用 ASCII 编码

\num 匹配 num，其中 num 是一个正整数。对所获取的匹配的引用。例如，’(.)\1’ 匹配两个连续的相同字符

\n
标识一个八进制转义值或一个向后引用。如果 \n 之前至少 n 个获取的子表达式，则 n 为向后引用。否则，如果 n 为八进制数字 (0-7)，则 n 为一个八进制转义值。

\nm
标识一个八进制转义值或一个向后引用。如果 \nm 之前至少有 nm 个获得子表达式，则 nm 为向后引用。如果 \nm 之前至少有 n 个获取，则 n 为一个后跟文字 m 的向后引用。如果前面的条件都不满足，若 n 和 m 均为八进制数字 (0-7)，则 \nm 将匹配八进制转义值 nm。

\nml
如果 n 为八进制数字 (0-3)，且 m 和 l 均为八进制数字 (0-7)，则匹配八进制转义值 nml

\un
匹配 n，其中 n 是一个用四个十六进制数字表示的 Unicode 字符。例如， \u00A9 匹配版权符号 (?)

正则的贪婪模式与惰性模式

1.贪婪模式标识符
+，？，*，{n},{n,},{n,m}

2惰性模式标识符
+？，？？，*？？，{n}?，{n,}?,{n,m}?;

一些特殊的实例

匹配两个字符中间的东西

  第一种
  var pattern=/8([a-zA-Z0-9]*)7/;//贪婪模式
  var string="abc8defghij7klngon8qrstwxy7qqq";
  var r6=string.match(pattern) //defghij7klngon8qrstwxy
  console.log(r6,"贪婪")
  第二种
  var str6="copy_begin_12345_copy_end"
  var reg6=/copy_begin(.*)copy_end/
  var r6=str6.match(reg6)[1]
  console.log(r6,"6666") //_12345_
  第三种
  var str = "aaabbbcccdddeeefff"; 
  str = str.match(/aaa(\S*)fff/)[1]; 
  console.log(str);//结果bbbcccdddeee