javascript正则表达式

• 正则表达式：就是按照某种规则去匹配符合条件的字符串
• javascrip通过内置对象RegExp支持正则表达式
• 有两种方法实例化RegExp对象
  • 使用字面量，以斜杠表示开始课结束   var   regex=/xyz/;       //在编译时新建正则表达式

    格式：/正则表达式/g
     
    var a="He is a boy 233";
     
    var s=a.replace( /\bis\b/g , 'IS' );
    console.log(s);                                     // He IS a boy 233
     
    var m=a.replace( /\bis\b/g , '');
    console.log(m);                                              // He    a  boy 233
     
    var n=a.replace( /[^0-9]/g , '' );
    console.log(n);                                               // "233"    [^0-9]这是反向类，下面有详细的说明

• • 构造函数  ： 使用RegExp构造函数   var   regex=new  RegExp("xyz");     //在运行时新建正则表达式

    var reg=new RegExp('正则表达式','标识符')

• 标识符：
  •  g :   global全文搜索，不添加时，搜索到第一个匹配停止

    var  a="He is a boy.This is a dog.";
     
    var  reg1=new RegExp('/\bis\b/');
    var s1=a.replace(reg1,'IS');
    console.log(s1);     // He IS a boy.This is a dog.
     
    var  reg2=new RegExp('/\bis\b/', 'g');
    var s2=a.replace(reg2,'IS');
    console.log(s2);    // He IS a boy.This IS a dog.

• •  i  :   ignore case 忽略大小写，默认大小写敏感

    var a='a1Ab2B';
     
    var s1=a.replace(/[a-e]/g,'Q');
    console.log(s1);  //  'Q1AQ2B'  默认大小写敏感
     
    var s2=a.replace(/[a-e]/ig,'Q');
    console.log(s2);     //'Q1QQ2Q' //忽略大小写

• • m :   multiline 表示多行匹配

---

元字符

• 正则表达式由两种基本基本字符类型组成
  • 原义文本字符
  • 元字符 ： 在正则表达式中有特殊含义的非字母字符
• 元字符

 

\t	水平制表符
\v	垂直制表符
\n	换行符
\r	回车符
\0	空字符
\f	换页符

• 字符类
  • 一般情况下正则表达式一个字符对应字符串一个字符
  • 可以使用元字符构建一个简单的类，所谓类是指符合某些特性的对象，一个泛指，而不是特指

    表达式[abc]把字符a或b或c归为一类，表达式可以匹配这类的字符
     
    'ab cd ef'.replace(/[acf]/g,'x');   // 'xb xd ex'

• • 字符类取反 ：使用元字符^创建反向类/负向类

    [^abc]表示不是字符a或者b或c的内容
     
    'ab 123c ef'.replace(/[^acf]/g,'x')   // 'axxxxxcxxf'  空格也被x替换

• 范围类
  • 正则表达式还提供了范围类

    [a-z] 表示从 a 到 z 的任意字符  // 这是一个闭区间，也就是包含 a 和 z 本身
     
    var a='a1b2c3d4e5f6';
    var s=a.replace(/[b-e]/g,'W');
    console.log(s)     //  'a1W2W3W4W5f6'

• • 在  [  ]  组成的类内部是可以连写的
    var a='a1Ab2Bc3Cd4De5E';

     

    var s1=a.replace(/[a-e]/g,'Q');

    console.log(s1);  //  'Q1AQ2BQ3CQ4DQ5E'

     

    var s2=a.replace(/[a-zA-Z]/g,'Q');

    console.log(s2);  //  'Q1QQ2QQ3QQ4QQ5Q'

• • 一个需要注意的点

    var a=2016-05-16;
     
    var s1=a.replace(/[0-9]/g,'A');
    console.log(s1);   // AAAA-AA-AA
     
    若需要将中间的 - 也匹配到则 [0-9-]
    var s2=a.replace(/[0-9-]/g,'A');
    console.log(s2);   // AAAAAAAAAAAA

• 预定义类

 

字符	等价类	含义
.	[^\r\n]	除了回车符和换行符之外的所有字符
\d	[0-9]	数字字符
\D	[^0-9]	非数字字符
\s	[\t\n\x0B\f\r]	空白符
\S	[^\t\n\x0B\f\r]	非空白符
\w	[a-zA-Z_0-9]	单词字符(字母、数字、下划线)
\W	[^a-zA-Z_0-9]	非单词字符

• • 一个例子

    var a='this is ab2hh';
    var s=a.replace(/ab\d./g,'Q');  
    console.log(s)  // this is Qh

• 边界匹配字符

 

字符	含义
^	以xxx开始
$	以xxx结束
\b	单词边界
\B	非单词边界

• • 一些实例

    var a='This is a cat';
    var s=a.replace(/\bis\b/g,'IS');
    console.log(s);      // This IS a cat 
     
    var b='@abc@def@';
    var s1=b.replace(/@./g,'Q');
    console.log(s1);    //  'QabcQdef@'
    var s2=b.replace(/^@./g,'Q');
    console.log(s2);   //   'Qabc@def@'
    var s3=b.replace(/.@$/g,'Q');
    console.log(s3);   //   '@abc@defQ'

• 量词

 

字符	含义
?	出现零次或一次(最多出现一次)
+	出现一次或多次(至少出现一次)
*	出现零次或多次(任意次)
{n}	出现n次
{n,m}	出现n到m次
{n , }	至少出现n次

• • 一些实例

    var a='a123456bc';
    var s1=a.replace(/\d+/g,'h');
    console.log(s1);  //ahbc
    var s2=a.replace(/\d{2}/g,'h');
    console.log(s2);  //ahhhbc

• 贪婪模式与非贪婪模式
  • 贪婪模式  ： 让正则表达式尽可能多的匹配 (默认贪婪模式)

    '1234567'.replace(/\d{3,6}/g,'h');    // h7   尽可能多的匹配 比如{3 , 6} 则匹配出现6次的

• • 非贪婪模式 ： 让正则表达式尽可能少的匹配，也就是说一旦成功匹配不再继续尝试，这就是非贪婪模式。在量词后面加上 ? 就表示非贪婪模式

    '1234567'.replace(/\d{3,6}?/g,'h');  // hh7

•  分组
  • 使用 ( )  可以达到分组的功能，使量词作用于分组

    'a1b2c3d4'.replace(/([a-z]\d){3}/g,'h');   // hd4

• • 使用 |  可以达到或的效果

    'ByJaon'.replace(/By|Jaon/g,'h');   //  hh

• • 反向引用

    '2016-12-11'.replace(/(\d{4})-(\d{2})-(\d{2})/g,'$2/$3/$1');     //  12/11/2016

• • 忽略分组  ： 在分组内加上 ?:
• 前瞻
  • 正则表达式从文本头部向尾部开始解析，文本尾部方向，称之为 “前”
  • 前瞻：在正则表达式匹配到规则的时候，向前检查是否符合断言。
  • 符合和不符合特定断言称为肯定/正向 匹配和否定/负向匹配
  • 断言 ：  指明某个字符串前边或后边，将会出现满足某种规律的字符串

 

正向前瞻	exp(?=assert)
负向前瞻	exp( ?!assert )

• • 一些实例

    var a='a2*34v8';
    var s=a.replace(/\w(?=\d)/g,'h');   // /\w(?=\d)/g ,中 \w 是匹配部分 , (?=\d) 是断言
    conole.log(s);   // h2*h4h8

---

RegExp对象的属性和方法

• RegExp的属性
  • 修饰符相关的属性，返回一个布尔值，表示对应的修饰符是否设置
    1. ignoreCase ：返回一个布尔值，表示是否设置了i修饰符，该属性只读
    2.  global : 返回一个布尔值，表示是否设置了g修饰符，该属性只读
    3. multiline :  返回一个布尔值，表示知否设置了m修饰符，该属性只读

       var r=/abc/igm; 
       r.ignoreCase;    //true
       r.global;        //true
       r.multiline;     //true

• • 与修饰符无关的属性
    1. lastIndex  :  返回下一次开始搜索的位置。该属性可读写，但只在设置 g修饰符时有意义
    2. source  :  返回正则表达式的字符串形式 ( 不包括反斜杠) ，该属性只读
• RegExp对象的方法
  • test() 用于测试字符串参数中是否存在匹配正则表达式模式的字符串  如果存在则返回true , 否则返回false

    /cat/.test('cat and dogs')   //true   在参数字符串中匹配cat
    如果正则表达式带有g修饰符，则每一次test方法都从上一次结束的位置开始向后匹配
    带有g修饰符时，可以通过正则对象的lastIndex属性指定开始搜索的位置
    var r=/x/g;
    var s='_x_x';
    r.test(s);    //true
    r.lastIndex; //2
    r.test(s);   //true
    r.lastIndex; //4
    r.test(s); // false

• • exec( ) : 可以返回匹配结果。如果发现匹配，就返回一个数组，成员是每一个匹配的成功的子字符串，否则返回null
    •  结果数组：
      • index --- 声明匹配文本的第一个字符的位置
      • input --- 存放被检索的字符串string

 

转载于:https://www.cnblogs.com/chtt/p/5808047.html