正则表达式及其使用例子

/**
 * 直接量字符(这个没有举例子)
 * 
 * 字母和数字字符 匹配自身
 * o NUL字符(u0000),	制表符(u0009),
换行符(u000A)
 * v垂直制表符(u000B),f换页符(u000C),
回车符(u000D)
 * xnn由十六进制数nn指定的拉丁字符,如：x0A等价于

 * uxxxx由十六进制数xxxx指定的Unicode字符,如：009等价于	
 * cX控制字符^X,如：cJ等价于换行符

 */


/**
 * 字符类: 将直接量字符放进方括号内“[]”，就组成了字符类，一个字符类匹配它所包含的任意字符
 * 
 * [...] 方括号内任意字符 , [^...] 不在方括号内任意字符
 * . 除换行符和其他Unicode行终止符之外的任意字符
 * w 任何ASCII字符组成的单词 等价于[a-zA-Z0-9]，W 与 w 相反 等价于 [^a-zA-Z0-9]
 * s 任何Unicode空白符，S 与 s 相反
 * d 任何ASCII数字，D 与 d 相反
 * [] 退格直接量
 */
console.log("e2ba53w".match(/S/g));//输出 [ 'e', '2', 'b', 'a', '5', '3', 'w' ]
//可通过"^"符号来定义否定字符类，它匹配所有不包含在方括号内的字符。注意，在定义否定字符类时，
//需要将"^"符号作为左方括号内的第一个字符
console.log("ebaw".match(/[^abc]/g));//输出 [ 'e', 'w' ]


 /**
  * 重复字符(原则：尽可能多地匹配 “贪婪”匹配)
  * 
  * {n,m} 匹配前一项至少n次但不超过m次，
    * {n,}  匹配前一项n次或更多次
  * {n}   匹配前一项n次， 
    * ? 匹配前一项0次或1次,即{0,1}
  * + 匹配前一项1次或多次,即{1,} , 
    * * 匹配前一项0次或多次,即{0,}
  */
 //“非贪婪”匹配，在待匹配的字符后跟一个"?"号即可 "??","+?","*?","{1,9}?"
 // 正则表示式: "aaab".match(/a+b/) 匹配结果 "aaab",而不是 "ab"
 // 因为正则表达式的模式匹配总是会寻找字符串中第一个可能的匹配位置

 /**
  * 选择、分组、引用 
  */
 // "|" 用于分隔供选择的字符，匹配顺序从到右直到发现匹配项，若左边的选择项匹配，则忽略右边的选择项匹配
 console.log("a3b45fd".match(/d{2}|[a-z]{3}/));//输出："45" ，匹配2个数字或3个字母 

 //圆括号
 //作用一：把单独的项组合成子表达式，以便可以像处理一个独立的单元那样进行处理
 //如：/(java)+(script)?/
 
 //作用二：在完整的模式中定义子模式，当一个正则成功地和目标字符串匹配时，可以从目标串中抽出圆括号中的子模式想匹配的部分
 //如下面执行结果为：输出：[ '123abc666', '123', 'abc', '666', index: 0, input: '123abc666' ]
 console.log("123abc666".match(/([0-9]*)([a-z]+)(666)/));

 //作用三：允许正则表达式的后部引用前面的子表达式，通过字符""后加一位或多位数字实现
 //如：对 /([jJ]ava([Ss]cript)?)siss(funw*)s2/ 来说，"2" 指代 ([Ss]cript)所匹配的文本的引用
 console.log("javascript is fun script".match(/([jJ]ava([Ss]cript)?)siss(funw*)s2/));
 //输出：[ 'javascript is fun script','javascript','script','fun',index: 0,input: 'javascript is fun script' ]
 //解析：([Ss]cript) 在正则中匹配的是 'script' ，因此 2 也匹配 'script'

 //注：对正则表达式中前一个表达式的引用，并不是对子表达式模式的引用，而是指与那个模式相匹配的文本的引用,不能再字符类中使用
 //如：/['"][^'"]*['"]/ 不要求左侧引号和右侧引号匹配,字符串 'fd3" 可以正确匹配
 console.log(" 'fd3" ".match(/['"][^'"]*['"]/));//输出：'fd3"
 //如：/['"][^'"]*1/ 由于 1 “是指与那个模式相匹配的文本的引用” ,如果前面匹配的文本为单(双)引号 '(") ，那么后面也要匹配单(双)引号 '(") ,
 console.log(" 'fd3" ".match(/(['"])[^'"]*1/));//输出：null
 console.log(" 'fd3' ".match(/(['"])[^'"]*1/));//输出：'fd3'
 //如：/['"][^1]*1/ 非法，不能再字符类中使用

 //不想创建带有数字编码的引用，也可以对子表达式进行分组
 //如：对 /([jJ]ava(?:[Ss]cript)?)siss(funw*)/ 来说, "2" 指代 (funw*)


 /**
  * 指定匹配位置 正则表达式中的锚字符(匹配的是正则表达式之间的位置，不匹配实际的字符)
  * ^ 匹配字符串的开头，多行检索中匹配一行的开头
  * $ 匹配字符串的结尾，多行检索中匹配一行的结尾
  *  匹配一个单词的边界(即 w和W之间的位置,或位于字符w和字符串的开头或结尾的位置,匹配的是退格符)
  * B 与相反，匹配非单词边界的位置
  * (?=p) 零宽正向先行断言,要求接下来的字符都与p匹配，但不能包括匹配p的哪些字符
  * (?!p) 零宽负向先行断言,要求接下来的字符不与p匹配
  */
 //如匹配单词"javascript"
 console.log("javascript".match(/^javascript$/));//输出："javascript"
 //如 /[jJ]ava/ 匹配 "java"、" java"、"java ",不匹配"abcjava"或"javaabc"
 console.log(" java".match(/java/));//输出："java"
 //如 /B[Jj]ava/ 匹配 "abcjava",不匹配"java"或"javaabc"或" java"
 console.log("abcjava".match(/Bjava/));//输出："java"

 //正向先行断言
 //如： /[Jj]ava([Ss]cript)?(?=:)/ 要求 j(J)avas(S)cript 接下来的字符必须是冒号 : ,但匹配的结果不包括冒号
 console.log("JavaScript: The Definitive Guide".match(/[Jj]ava(?:[Ss]cript)?(?=:)/));//输出：JavaScript
 console.log("Java The Definitive Guide".match(/[Jj]ava([Ss]cript)?(?=:)/));//输出：null

 //负向先行断言
 //如：/Java(?!Script)([A-Z]w*)/ 要求 j(J)avas(S)cript 接下来的字符必须不能是字符串 Script 
 console.log("JavaScriptAbc".match(/Java(?!Script)([A-Z]w*)/));//输出：null
 console.log("JavaBeans".match(/Java(?!Script)([A-Z]w*)/));//输出：JavaBeans


 /**
  * 修饰符
  * 修饰符放在 “//”符号之外，在第二条斜线之后
  * i 执行不区分大小写的匹配
  * g 执行一个全局匹配，即找出被检索字符串的所有匹配项
  * m 多行匹配模式，即如果检索字符串包含多行，^和$处理匹配整个字符串的开始和结尾
  *   还能匹配每一行的开始和结尾
  */
  //如：/java$/im , i忽略大小写，m匹配多行
  console.log("Java
 is fun");
  /**
   * 输出：
   * Java
   *  is fun
   */


  /**
  * 用于模式匹配的String方法：
  * search()最简单，不支持全局
  * replace()很强大，默认不全局搜索
  * match()最常用，默认不全局搜索
  * split()
  * 这些方法是 String.prototype 的方法，只不过它们支持正则表达式而已
  */


  //search()，返回正则表达式在字符串中首次匹配项的索引。否则，返回 -1。参数是正则表达式，若参数不是正则则先转换成正则
  console.log("javascript".search(/script/i));//输出：4
  console.log("javascript".search("script"));//输出：4

    //replace()，替换操作
    //参数一:正则或字符串 参数二:替换字符串(还可以是函数),($$:插入一个:"$"),($&:插入匹配的子串),($`[反引号]:插入当前匹配的子串左边的内容),
    //($':插入当前匹配的子串右边的内容),($n:若参数一是 RegExp对象且 0<n<100 那么就插入正则表达式中第 n 个括号最近一次匹配结果中的内容)
    
    //参数一：字符串
    var str="hello world,how are you?"
    console.log(str.replace("world","guang"));//hello guang,how are you?

    //参数一：正则表达式
    var str='"cat", "bat", "sat", "fat"';
    console.log(str.replace(/"([^"]*)"/g,"Hello “$1”"));
    // 输出： Hello “cat”, Hello “bat”, Hello “sat”, Hello “fat”  可以看到 ""(英文符号) 变成了 “”(中文符号)
    // 解析: 对于上述字符串来说：
    // 正则表达式  /"([^"]*)"/g  的匹配结果为: ("cat"  "bat"  "sat"   "fat")
    // 那 /"([^"]*)"/g 括号中的的匹配结果就为：( cat    bat    sat    fat )
    // $1 ：表示要插入正则表达式中第 1 个括号最近一次匹配结果中的内容(分别为: cat    bat    sat    fat )
    // Hello “$1” :就可以看出表示的是 (Hello “cat”   Hello “bat”   Hello “sat”   Hello “fat”)
    // 因此就将 ("cat"  "bat"  "sat"   "fat") 替换成了 (Hello “cat”   Hello “bat”   Hello “sat”   Hello “fat”)
    /**
     * 对应的还有其他结果：
     * console.log(str.replace(/"([^"]*)"/g,"Hello “$$”"));
     * 输出：Hello “$”, Hello “$”, Hello “$”, Hello “$”
     * 
     * console.log(str.replace(/"([^"]*)"/g,"Hello “$&”"));
     * Hello “"cat"”, Hello “"bat"”, Hello “"sat"”, Hello “"fat"”
     * 
     * console.log(str.replace(/"([^"]*)"/g,"Hello “$`”"));
     * 输出：Hello “”, Hello “"cat", ”, Hello “"cat", "bat", ”, Hello “"cat", "bat", "sat", ”
     * 
     * console.log(str.replace(/"([^"]*)"/g,"Hello “$'”"));
     * 输出：Hello “, "bat", "sat", "fat"”, Hello “, "sat", "fat"”, Hello “, "fat"”, Hello “”
     */

  //第二个参数是函数的情况:　　　 

 　　 //参数一：match，匹配的子串（对应于上述的$&）

  　　 //参数二：p1,p2, ... 假如replace()方法的第一个参数是一个RegExp 对象，则代表第n个括号匹配的字符串。（对应于上述的$1，$2等）

  　　 //参数三：offset 匹配到的子字符串在原字符串中的偏移量。（比如，如果原字符串是“abcd”，匹配到的子字符串是“bc”，那么这个参数将是1）

  　　 //参数四：string  被匹配的原字符串。

  function replacer(match, p1, p2, p3, offset, string) {
    console.log(match);// 匹配到字符串 abc12345#$*%
    console.log(offset);// 匹配到的子字符串在原字符串中的偏移量 3
    console.log(string);// 原字符串 123abc12345#$*%A
    console.log(p1,p2,p3);// p1、p2、p3 的值 abc 12345 #$*%
    return [p1, p2, p3].join(' - ');// 返回值 abc - 12345 - #$*%
  }
  var newString = '123abc12345#$*%A'.replace(/([^d]{1,})(d*)([^w]*)/, replacer);
  console.log(newString);  // 123abc - 12345 - #$*%A
  //解析：replacer 返回一个新的替换后的字符串，该方法并不改变调用它的字符串本身
  //即将 123abc12345#$*%A 想要替换的部分(abc12345#$*%) 替换成 abc - 12345 - #$*% 
  //即 (括号内容将要被替换)(123abc12345#$*%)A ---> (括号内容已经被替换)(123abc - 12345 - #$*%)A 


    //match()，唯一的参数是正则，如果字符串匹配到了表达式，会返回一个数组，数组的第一项是进行匹配的那个字符串，
    //之后的项是用圆括号捕获的结果。如果没有匹配到，返回null。
  //Array[1]存放与第一个用圆括号括起来的表达式相匹配的子串,以此类推
  //为了与replace()保持一致，Array[n]存放的是$n的内容
  str="Visit my blog at http://www.example.com/~guang";
  var result=str.match(/(w+)://([w.]+)/(S*)/);
  console.log(result[0],result[1],result[2],result[3]);//http://www.example.com/~guang , http  , www.example.com , ~guang


    //split()，使用指定的分隔符字符串将一个String对象分割成字符串数组并返回
    //参数一(可选)：分隔符(字符串或正则表达式)  参数二(可选)：一个整数，限定返回的分割片段数量
    //描述：找到分隔符后，将其从字符串中删除，并将子字符串的数组返回。
    
    //如果分隔符为空字符串，则将str转换为字符数组
    var str="ni hao";
    console.log(str.split(""));//[ 'n', 'i', ' ', 'h', 'a', 'o' ]

    //如果分隔符出现在字符串的开始或结尾，则分别以空字符串开头，结尾。
    //因此，如果字符串仅由一个分隔符实例组成，则该数组由两个空字符串组成。
    var str="#a***b#c*d###e*";
    console.log(str.split("#"));//[ '', 'a***b', 'c*d', '', '', 'e*' ]
    console.log(str.split("*"));//[ '#a', '', '', 'b#c', 'd###e', '' ]
    console.log("@".split("@"));//[ '', '' ]

    //如果没有找到或者省略了分隔符，则该数组包含一个由整个字符串组成的元素。
    var str="hello world";    
    console.log(str.split("a"));//[ 'hello world' ]
    console.log(str.split());//[ 'hello world' ]

    //当字符串为空时，split()返回一个包含一个空字符串的数组，而不是一个空数组
    console.log("".split("separator"));//[ '' ]
    console.log("".split());//[ '' ]    
    //console.log("".split());也可理解为,如果没有找到或者省略了分隔符，则该数组包含一个由整个字符串组成的元素。

    //如果字符串和分隔符都是空字符串，则返回一个空数组
    console.log("".split(""));//[]

    //其他例子,去除空白字符
    var str="1,2   ,3,   4   ,   5";    
    console.log(str.split(/s*,s*/));//输出：[ '1', '2', '3', '4', '5' ]
    //解析：console.log(str.match(/s*,s*/g));//[ ',', '   ,', ',   ', '   ,   ' ]


/**
 * RegExp()构造函数 有5个属性
 * 只读属性：
 * source 包含正则表达式的文本
 * global(ignoreCase)(multiline) 用以说明正则是否带修饰符g(i)(m)
 * 可读写属性：
 * lastIndex(这个属性会被exec()和test()方法用到)
 * 方法: exec()、test()
 */

//利用RegExp()构造函数创建正则表达式,使用""作为专业字符的前缀,因此使用""必须替换成"\"
//参数一：正则主体(即//中间的文本)，参数二：可选修饰符(i/g/m)
//构造函数可用于动态创建正则表达式，如用户输入
var re=new RegExp("\d{5}","g");
console.log("123456gww 4321 fjf87654".match(re));//输出：["12345", "87654"]
console.log(re.source,re.global,re.ignoreCase,re.multiline,re.lastIndex);// 输出：d{5} true false false 0


//exec()参数是一个字符串,找到则返回一个数组,否则返回null
//与match()不同之处在于，exec()不管有无修饰符g"总是返回一个匹配结果"
//当它具有修饰符g时，它的lastIndex属性就为紧挨着匹配子串的字符位置,
//当"同一个"正则表达式第二次调用exec()时,则从lastIndex处开始检索,
//找出所有匹配之后lastIndex会自动重置为0
//当它不使用全局修饰符g时,每次开始检索时lastIndex都设置为0

str="Who think JavaScript is more fun than Java!";
pattern_no_g=/Java/;
pattern_carry_g=/Java/g;

//不使用全局修饰符
/*
while((result=pattern_no_g.exec(str)) !=null){
  console.log("Matched '"+result[0]+"'"+
  " at position "+result.index+"; next search " +
      "begins at "+pattern_no_g.lastIndex);
}
*/
//While循环第一遍返回一个结果：Matched 'Java' at position 10; next search begins at 0
//While循环第二遍返回一个结果：Matched 'Java' at position 10; next search begins at 0
//...... 死循环
//While循环第N遍返回一个结果：Matched 'Java' at position 10; next search begins at 0

//使用全局修饰符
while((result=pattern_carry_g.exec(str)) !=null){
    console.log("Matched '"+result[0]+"'"+
    " at position "+result.index+"; next search " +
        "begins at "+pattern_carry_g.lastIndex);
}
//While循环第一遍返回一个结果：Matched 'Java' at position 10; next search begins at 14
//While循环第二遍返回一个结果：Matched 'Java' at position 38; next search begins at 42
console.log(pattern_carry_g.lastIndex);//输出：0，带有全局修饰符g，找出所有匹配之后,lastIndex自动重置为0

//只匹配一次(不找出所有匹配)
if((result=pattern_carry_g.exec(str)) !=null){
    console.log("Matched '"+result[0]+"'"+
        " at position "+result.index+"; next search " +
        "begins at "+pattern_carry_g.lastIndex);
}
//if条件语句内输出：Matched 'Java' at position 10; next search begins at 14
console.log(pattern_carry_g.lastIndex);//输出：14，没有找出所有匹配,因此lastIndex不会自动重置为0
var otherStr="JavaScript is fun";//此时 pattern_carry_g.lastIndex 值为 14
if((result=pattern_carry_g.exec(otherStr)) !=null){
  console.log("Matched '"+result[0]+"'"+
      " at position "+result.index+"; next search " +
      "begins at "+pattern_carry_g.lastIndex);
}
//输出：没有输出
//解析：pattern_carry_g.lastIndex 值为 14，此时检索将从字符串othertext的othertext[14]开始
//因此匹配值为空 result=pattern_carry_g.exec(otherStr) 语句执行后 result 等于 null
//因此没有进入if语句内执行，因此记得必要时应该手动将lastIndex置0

pattern_carry_g.lastIndex=0;//手动重置为0
if((result=pattern_carry_g.exec(otherStr)) !=null){
  console.log("Matched '"+result[0]+"'"+
      " at position "+result.index+"; next search " +
      "begins at "+pattern_carry_g.lastIndex);
}
//输出：Matched 'Java' at position 0; next search begins at 4
//解析：正则表达式将字符串从头开始匹配，匹配成功


//test()参数是一个字符串,返回true/false,其lastIndex属性与exec()类似
console.log((/hello/g).test("hello world!"));// true
console.log((/hello/g).test("world! world!"));// false

使用例子,待更......