1 /**
  2  * 直接量字符(这个没有举例子)
  3  * 
  4  * 字母和数字字符 匹配自身
  5  * \o NUL字符(\u0000),\t制表符(\u0009),\n换行符(\u000A)
  6  * \v垂直制表符(\u000B),\f换页符(\u000C),\r回车符(\u000D)
  7  * \xnn由十六进制数nn指定的拉丁字符,如：\x0A等价于\n
  8  * \uxxxx由十六进制数xxxx指定的Unicode字符,如：\0009等价于\t
  9  * \cX控制字符^X,如：\cJ等价于换行符\n
 10  */
 11 
 12 
 13 /**
 14  * 字符类: 将直接量字符放进方括号内“[]”，就组成了字符类，一个字符类匹配它所包含的任意字符
 15  * 
 16  * [...] 方括号内任意字符 , [^...] 不在方括号内任意字符
 17  * . 除换行符合其他Unicode行终止符之外的任意字符
 18  * \w 任何ASCII字符组成的单词 等价于[a-zA-Z0-9]，\W 与 \w 相反 等价于 [^a-zA-Z0-9]
 19  * \s 任何Unicode空白符，\S 与 \s 相反
 20  * \d 任何ASCII数字，\D 与 \d 相反
 21  * [\b] 退格直接量
 22  */
 23 console.log("e2ba53w".match(/\S/g));//输出 [ 'e', '2', 'b', 'a', '5', '3', 'w' ]
 24 //可通过"^"符号来定义否定字符类，它匹配所有不包含在方括号内的字符。注意，在定义否定字符类时，
 25 //需要将"^"符号作为左方括号内的第一个字符
 26 console.log("ebaw".match(/[^abc]/g));//输出 [ 'e', 'w' ]
 27 
 28 
 29  /**
 30   * 重复字符(原则：尽可能多地匹配 “贪婪”匹配)
 31   * 
 32   * {n,m} 匹配前一项至少n次但不超过m次，{n,}  匹配前一项n次或更多次
 33   * {n}   匹配前一项n次， ? 匹配前一项0次或1次,即{0,1}
 34   * +     匹配前一项1次或多次,即{1,} , * 匹配前一项0次或多次,即{0,}
 35   */
 36  //“非贪婪”匹配，在待匹配的字符后跟一个"?"号即可 "??","+?","*?","{1,9}?"
 37  // 正则表示式: "aaab".match(/a+b/) 匹配结果 "aaab",而不是 "ab"
 38  // 因为正则表达式的模式匹配总是会寻找字符串中第一个可能的匹配位置
 39 
 40  /**
 41   * 选择、分组、引用 
 42   */
 43  // "|" 用于分隔供选择的字符，匹配顺序从到右直到发现匹配项，若左边的选择项匹配，则忽略右边的选择项匹配
 44  console.log("a3b45fd".match(/\d{2}|[a-z]{3}/));//输出："45" ，匹配2个数字或3个字母 
 45 
 46  //圆括号
 47  //作用一：把单独的项组合成子表达式，以便可以像处理一个独立的单元那样进行处理
 48  //如：/(java)+(script)?/
 49  
 50  //作用二：在完整的模式中定义子模式，当一个正则成功地和目标字符串匹配时，可以从目标串中抽出圆括号中的子模式想匹配的部分
 51  //如下面执行结果为：输出：[ '123abc666', '123', 'abc', '666', index: 0, input: '123abc666' ]
 52  console.log("123abc666".match(/([0-9]*)([a-z]+)(666)/));
 53 
 54  //作用三：允许正则表达式的后部引用前面的子表达式，通过字符"\"后加一位或多位数字实现
 55  //如：对 /([jJ]ava([Ss]cript)?)\sis\s(fun\w*)\s\2/ 来说，"\2" 指代 ([Ss]cript)所匹配的文本的引用
 56  console.log("javascript is fun script".match(/([jJ]ava([Ss]cript)?)\sis\s(fun\w*)\s\2/));
 57  //输出：[ 'javascript is fun script','javascript','script','fun',index: 0,input: 'javascript is fun script' ]
 58  //解析：([Ss]cript) 在正则中匹配的是 'script' ，因此 \2 也匹配 'script'
 59 
 60  //注：对正则表达式中前一个表达式的引用，并不是对子表达式模式的引用，而是指与那个模式相匹配的文本的引用,不能再字符类中使用
 61  //如：/['"][^'"]*['"]/ 不要求左侧引号和右侧引号匹配,字符串 'fd3" 可以正确匹配
 62  console.log(" 'fd3\" ".match(/['"][^'"]*['"]/));//输出：'fd3"
 63  //如：/['"][^'"]*\1/ 由于 \1 “是指与那个模式相匹配的文本的引用” ,如果前面匹配的文本为单(双)引号 '(") ，那么后面也要匹配单(双)引号 '(") ,
 64  console.log(" 'fd3\" ".match(/(['"])[^'"]*\1/));//输出：null
 65  console.log(" 'fd3' ".match(/(['"])[^'"]*\1/));//输出：'fd3'
 66  //如：/['"][^\1]*\1/ 非法，不能再字符类中使用
 67 
 68  //不想创建带有数字编码的引用，也可以对子表达式进行分组
 69  //如：对 /([jJ]ava(?:[Ss]cript)?)\sis\s(fun\w*)/ 来说, "\2" 指代 (fun\w*)
 70 
 71 
 72  /**
 73   * 指定匹配位置 正则表达式中的锚字符(匹配的是正则表达式之间的位置，不匹配实际的字符)
 74   * ^ 匹配字符串的开头，多行检索中匹配一行的开头
 75   * $ 匹配字符串的结尾，多行检索中匹配一行的结尾
 76   * \b 匹配一个单词的边界(即 \w和\W之间的位置,或位于字符\w和字符串的开头或结尾的位置,匹配的是退格符)
 77   * \B 与\b相反，匹配非单词边界的位置
 78   * (?=p) 零宽正向先行断言,要求接下来的字符都与p匹配，但不能包括匹配p的哪些字符
 79   * (?!p) 零宽负向先行断言,要求接下来的字符不与p匹配
 80   */
 81  //如匹配单词"javascript"
 82  console.log("javascript".match(/^javascript$/));//输出："javascript"
 83  //如 /\b[jJ]ava\b/ 匹配 "java"、" java"、"java ",不匹配"abcjava"或"javaabc"
 84  console.log(" java".match(/\bjava\b/));//输出："java"
 85  //如 /\B[Jj]ava/ 匹配 "abcjava",不匹配"java"或"javaabc"或" java"
 86  console.log("abcjava".match(/\Bjava/));//输出："java"
 87 
 88  //正向先行断言
 89  //如： /[Jj]ava([Ss]cript)?(?=\:)/ 要求 j(J)avas(S)cript 接下来的字符必须是冒号 : ,但匹配的结果不包括冒号
 90  console.log("JavaScript: The Definitive Guide".match(/[Jj]ava(?:[Ss]cript)?(?=\:)/));//输出：JavaScript
 91  console.log("Java The Definitive Guide".match(/[Jj]ava([Ss]cript)?(?=\:)/));//输出：null
 92 
 93  //负向先行断言
 94  //如：/Java(?!Script)([A-Z]\w*)/ 要求 j(J)avas(S)cript 接下来的字符必须不能是字符串 Script 
 95  console.log("JavaScriptAbc".match(/Java(?!Script)([A-Z]\w*)/));//输出：null
 96  console.log("JavaBeans".match(/Java(?!Script)([A-Z]\w*)/));//输出：JavaBeans
 97 
 98 
 99  /**
100   * 修饰符
101   * 修饰符放在 “//”符号之外，在第二条斜线之后
102   * i 执行不区分大小写的匹配
103   * g 执行一个全局匹配，即找出被检索字符串的所有匹配项
104   * m 多行匹配模式，即如果检索字符串包含多行，^和$处理匹配整个字符串的开始和结尾
105   *   还能匹配每一行的开始和结尾
106   */
107   //如：/java$/im , i忽略大小写，m匹配多行
108   console.log("Java\n is fun");
109   /**
110    * 输出：
111    * Java
112    *  is fun
113    */
114 
115 
116   /**
117   * 用于模式匹配的String方法：
118   * search()最简单，不支持全局
119   * replace()很强大，默认不全局搜索
120   * match()最常用，默认不全局搜索
121   * split()
122   * 这些方法是 String.prototype 的方法，只不过它们支持正则表达式而已
123   */
124 
125 
126   //search()参数是正则表达式，若参数不是正则则先转换成正则
127   //返回第一个与之匹配的子串的起始位置，若找不到子串则返回-1,
128   console.log("javascript".search(/script/i));//输出：4
129 
130 
131   //replace()替换操作,参数一:正则，参数二:替换字符串(还可以是函数)
132   //若参数一不是正则，则直接搜索该字符
133   var str='"Javascript":javascript:JavaScript:javaScript';
134   console.log(str.replace(/javascript/gi,"jAvAsCrIpT"));
135   //输出："jAvAsCrIpT":jAvAsCrIpT:jAvAsCrIpT:jAvAsCrIpT
136 
137   //若在replace()替换字符串中出现 $加数字 ,那么replace将
138   //用 “指定的子表达式相匹配的文本”来替换这两个字符
139   //如：用中文半角引号替换英文半角引号，同时保持引号中内容不变(存储在$1中)
140   str='\'Javascript\':javascript:JavaScript:javaScript';
141   console.log(str.match(/'([^"]*)'/g));
142   console.log(str.replace(/"([^"]*)"/g,'“$1”'));
143   //解析：/"([^"']*)"/g 匹配字符串 "Javascript" ,“指定的子表达式相匹配的文本”(此处指第一个括号匹配的文本)匹配字符串 Javascript
144   //将该字符串(JavaScript)替换 $1 这两个字符，得到 “$1” ---> “JavaScript”
145 
146   //第二个参数时函数的情况：
147   function replacer(match, p1, p2, p3, offset, string) {
148     console.log(match);// 匹配到字符串 abc12345#$*%
149     console.log(offset);// 匹配到的子字符串在原字符串中的偏移量 3
150     console.log(string);// 原字符串 123abc12345#$*%A
151     console.log(p1,p2,p3);// p1、p2、p3 的值 abc 12345 #$*%
152     return [p1, p2, p3].join(' - ');// 返回值 abc - 12345 - #$*%
153   }
154   var newString = '123abc12345#$*%A'.replace(/([^\d]{1,})(\d*)([^\w]*)/, replacer);
155   console.log(newString);  // 123abc - 12345 - #$*%A
156   //解析：replacer 返回一个新的替换后的字符串，该方法并不改变调用它的字符串本身
157   //即将 123abc12345#$*%A 想要替换的部分(abc12345#$*%) 替换成 abc - 12345 - #$*% 
158   //即 (括号内容将要被替换)(123abc12345#$*%)A ---> (括号内容已经被替换)(123abc - 12345 - #$*%)A 
159 
160 
161   //match()唯一的参数是正则，返回一个数组Array,Array[0]存放完整的匹配
162   //Array[1]存放与第一个用圆括号括起来的表达式相匹配的子串,以此类推
163   //为了与replace()保持一致，Array[n]存放的是$n的内容
164   str="Visit my blog at http://www.example.com/~guang";
165   var result=str.match(/(\w+):\/\/([\w.]+)\/(\S*)/);
166   console.log(result[0],result[1],result[2],result[3]);//http://www.example.com/~guang http www.example.com ~guang
167 
168 
169   //split()指定分隔符
170   str="1,2 ,3, 4 , 5";
171   console.log(str.split(/\s*,\s*/));//输出：[ '1', '2', '3', '4', '5' ]
172 
173 
174 /**
175  * RegExp()构造函数 有5个属性
176  * 只读属性：
177  * source 包含正则表达式的文本
178  * global(ignoreCase)(multiline) 用以说明正则是否带修饰符g(i)(m)
179  * 可读写属性：
180  * lastIndex(这个属性会被exec()和test()方法用到)
181  * 方法: exec()、test()
182  */
183 
184 //利用RegExp()构造函数创建正则表达式,使用"\"作为专业字符的前缀,因此使用"\"必须替换成"\\"
185 //参数一：正则主体(即//中间的文本)，参数二：可选修饰符(i/g/m)
186 //构造函数可用于动态创建正则表达式，如用户输入
187 var re=new RegExp("\\d{5}","g");
188 console.log("123456gww 4321 fjf87654".match(re));//输出：["12345", "87654"]
189 console.log(re.source,re.global,re.ignoreCase,re.multiline,re.lastIndex);// 输出：\d{5} true false false 0
190 
191 
192 //exec()参数是一个字符串,找到则返回一个数组,否则返回null
193 //与match()不同之处在于，exec()不管有无修饰符g"总是返回一个匹配结果"
194 //当它具有修饰符g时，它的lastIndex属性就为紧挨着匹配子串的字符位置,
195 //当"同一个"正则表达式第二次调用exec()时,则从lastIndex处开始检索,
196 //找出所有匹配之后lastIndex会自动重置为0
197 //当它不使用全局修饰符g时,每次开始检索时lastIndex都设置为0
198 
199 str="Who think JavaScript is more fun than Java!";
200 pattern_no_g=/Java/;
201 pattern_carry_g=/Java/g;
202 
203 //不使用全局修饰符
204 /*
205 while((result=pattern_no_g.exec(str)) !=null){
206   console.log("Matched '"+result[0]+"'"+
207   " at position "+result.index+"; next search " +
208       "begins at "+pattern_no_g.lastIndex);
209 }
210 */
211 //While循环第一遍返回一个结果：Matched 'Java' at position 10; next search begins at 0
212 //While循环第二遍返回一个结果：Matched 'Java' at position 10; next search begins at 0
213 //...... 死循环
214 //While循环第N遍返回一个结果：Matched 'Java' at position 10; next search begins at 0
215 
216 //使用全局修饰符
217 while((result=pattern_carry_g.exec(str)) !=null){
218     console.log("Matched '"+result[0]+"'"+
219     " at position "+result.index+"; next search " +
220         "begins at "+pattern_carry_g.lastIndex);
221 }
222 //While循环第一遍返回一个结果：Matched 'Java' at position 10; next search begins at 14
223 //While循环第二遍返回一个结果：Matched 'Java' at position 38; next search begins at 42
224 console.log(pattern_carry_g.lastIndex);//输出：0，带有全局修饰符g，找出所有匹配之后,lastIndex自动重置为0
225 
226 //只匹配一次(不找出所有匹配)
227 if((result=pattern_carry_g.exec(str)) !=null){
228     console.log("Matched '"+result[0]+"'"+
229         " at position "+result.index+"; next search " +
230         "begins at "+pattern_carry_g.lastIndex);
231 }
232 //if条件语句内输出：Matched 'Java' at position 10; next search begins at 14
233 console.log(pattern_carry_g.lastIndex);//输出：14，没有找出所有匹配,因此lastIndex不会自动重置为0
234 var otherStr="JavaScript is fun";//此时 pattern_carry_g.lastIndex 值为 14
235 if((result=pattern_carry_g.exec(otherStr)) !=null){
236   console.log("Matched '"+result[0]+"'"+
237       " at position "+result.index+"; next search " +
238       "begins at "+pattern_carry_g.lastIndex);
239 }
240 //输出：没有输出
241 //解析：pattern_carry_g.lastIndex 值为 14，此时检索将从字符串othertext的othertext[14]开始
242 //因此匹配值为空 result=pattern_carry_g.exec(otherStr) 语句执行后 result 等于 null
243 //因此没有进入if语句内执行，因此记得必要时应该手动将lastIndex置0
244 
245 pattern_carry_g.lastIndex=0;//手动重置为0
246 if((result=pattern_carry_g.exec(otherStr)) !=null){
247   console.log("Matched '"+result[0]+"'"+
248       " at position "+result.index+"; next search " +
249       "begins at "+pattern_carry_g.lastIndex);
250 }
251 //输出：Matched 'Java' at position 0; next search begins at 4
252 //解析：正则表达式将字符串从头开始匹配，匹配成功
253 
254 
255 //test()参数是一个字符串,返回true/false,其lastIndex属性与exec()类似
256 console.log((/hello/g).test("hello world!"));// true
257 console.log((/hello/g).test("world! world!"));// false
258 
259 
260 /**
261  * 常用例子
262  */
263 待更新...