js正则表达式—笔记

正则表达式是一种表达字符串结构的方法，常常用来按照“给定模式”匹配文本。比如，正则表达式给出一个Email地址的模式，然后用它来确定一个字符串是否为Email地址。

 

新建正则表达式

  • 使用字面量方法，斜杠表示开始和结束
var regex = /xyz/;  //该方法效率高、便利、直观，推荐使用


等价于：
var regex = /xyz/i； //i为修饰符
  • 使用RegExp构造函数
var regex = new RegExp('xyz');


等价于：
var regex = new RegExp('xyz','i'); //i为修饰符

 

正则对象的实例属性

与修饰符有关的属性

  • RegExp.prototype.ignoreCase：返回一个布尔值，表示是否设置了 i 修饰符

　　　i 修饰符表示不区分大小写。

　　　例如，/abc/i，可以匹配abc、Aba、aBc

  • RegExp.prototype.global：返回一个布尔值，表示是否设置了 g 修饰符

　　　g 修饰符表示全局匹配。

　　　如果不带g，正则过程中字符串从左到右匹配，找到第一个符合条件的即匹配成功，返回。例如，'aaaaa'.match(/a/)，结果为 ["a"]

　　　如果带g，正则过程中字符串从左到右匹配，找到每个符合条件的都记录下来，直到字符串结束位置。例如，'aaaaaa'.match(/a/g)，结果为 ["a", "a", "a", "a", "a", "a"]

  • RegExp.prototype.multiline：返回一个布尔值，表示是否设置了 m 修饰符

　　　m 修饰符表示多行匹配。

　　　若字符串中存在换行 \n  并且正则表达式中有开始符号 ^ 和结束符号 $ 的情况下，和 g 一起使用实现全局匹配

　　　因为存在换行时，默认把换行字符作为一个字符任务匹配，即字符串默认为单行

　　　g只匹配第一行，添加m之后实现多行，每个换行符之后就是开始。例如

var str = "abcdeab\ndabcgab";

str.match(/^abc/gm) //["abc", "abc"] 以abc开始
str.match(/ab$/gm) //["ab", "ab"] 以ab结束
  • RegExp.prototype.flags：返回一个字符串，包含了已经设置的所有修饰符，按字母排序
var r = /abc/igm；


r.ignoreCase //true
r.global //true
r.multiline //true
r.flags //'gim'

 与修饰符无关的属性

  • RegExp.prototype.lastIndex：返回一个整数，表示下一次开始搜索的位置。该属性可读写
  • RegExp.prototype.source：返回正则表达式的字符串形式（不包括反斜杠），该属性只读

 

var r = /abc/igm;

r.lastIndex //0
r.source //"abc"

 

正则对象的实例方法

  • RegExp.prototype.test()，返回一个布尔值，表示当前模式是否能匹配参数字符串。函数参数为你要查询的字符串

/cats/.test('cats and dogs'); //true
//字符串中含有'cat'，所以结果返回true



//正则表达式带有 g 修饰符，表示全局搜索，会有多个结果。每一次test方法都从上一次结束位置开始向后匹配，即每一次开始搜索的位置都是上一次匹配的后一个位置，用 lastIndex 表示这个位置 


var r = /x/g;
var s = '_x_x';

r.lastIndex //0 第一次从 0 位置开始向后匹配
r.test(s) //true

r.lastIndex  //2  上一次结束位置为1，向后匹配即从 2 位置开始匹配
r.test(s) //true

r.lastIndex //4
r.test(s) //false 字符串的 4 位置为空，所以返回false。同时，lastIndex的属性重置为0

r.lastIndex //0
r.test(s) //true

  •  RegExp.prototype.exec()，用来返回匹配结果。如果匹配成功，就返回一个数组，数组元素是匹配成功的字符串，否则返回null。函数参数为你要查询的字符串

var s = '_x_x';
var r1 = /x/;
var r2 = /y/;

r1.exec(s) //["x"]   正则对象 r1 匹配成功
r2.exeec(s) //null   正则对象 r2 匹配失败



//如果正则表达式中含有括号（即含有"组匹配"）,则返回的数组会包括多个成员。
//第一个成员是整个正则表达式匹配的结果；第二个成员对应正则表达式的第一个括号；第三个成员对应正则表达式的第二个括号，以此类推

var s = '_x_x';
var r = /_(x)/;

r.exec(s) //["_x","x"] //我理解的是，括号可去可不去，所以有两种情况：去掉括号是一种情况；括号内部又是一种情况



  • execx方法返回的数组包含两个属性

//index 属性，整个模式匹配的开始位置
//input 属性，整个原字符串

var r = /a(b+)a/; //b+ 代表有1个或多个b。默认为贪婪模式，会一直匹配到字符 b 不出现为止
var arr = r.exev('_abbba_aba');

arr //["abbba","bbb"]

arr.index //1 ，即从原字符串的第二个位置开始匹配成功
arr.input //"_abbba_aba"



//利用g修饰符允许多次匹配的特点，可以用一个循环完成全部匹配
var reg = /a/g;
var str = 'abc_abc_abc';

while(true){
　　var arr= reg.esec(str);
　　if(!match) break;  //只要 exec 方法不返回 null，就会一直循环下去
　　console.log('#' + match.index + ':' + match[0]); //每次输出匹配的位置和匹配的文本
}

// #0:a
// #4:a
// #8:a



 

字符串的实例方法

  • String.prototype.match()：返回一个数组，成员时所有匹配的字符串。函数的参数是正则对象

　　字符串的match方法与正则对象的exec方法非常类似。匹配成功返回一个数组，匹配失败返回 null


var str = '_x_';
var r1 = /x/;
var r2 = /y/;

str.match(r1) //["x"]
str.match(r2) //null

　如果正则表达式带有 g 修饰符，则该方法与正则对象的 exec 方法返回值不同，会一次性返回所有匹配成功的结果。


var str = 'abba';
var r = /a/g;

str.match(r) //["a","a"]
r.exec(str) //["a"]

　 上面提到过正则表达式的 lastIndex 可读可写，但是这一属性对 match 无效，因为 match 方法的匹配总是从第一个字符串开始。


var r = /a|b/g;
r.lastIndex = 5;

'cacb'.match(r) //["a","b"]
r.lastIndex = 0;


//可以看出，lastIndex 在 match 方法中无效

  • String.prototype.search()：按照给定的正则表达式进行搜索，返回一个整数，表示匹配开始的位置

　　search 方法返回第一个满足条件的匹配结果在整个字符串中的位置。如果没有任何匹配，则返回 -1

'_x_x'.search(/x/) //1 ,即第一个匹配结果出现在字符串的第一个位置
  • String.prototype.replace()：按照给定的正则表达式进行替换，返回替换后的字符串

　　replace方法可以替换匹配的值。接受两个参数，第一个是正则表达式，表示搜索模式，第二个是替换的内容

　　正则表达式如果不加 g 修饰符，就替换第一个匹配成功的值，否则替换所有匹配的值


'aaa'.replace('a','b') //baa
'aaa'.replace(/a/,'b') //baa
'aaa'.replace(/a/g,'b') //bbb

　　replace方法的一个应用，消除字符串首尾两端得空格


var str = ' hello world！ '；

str.replace(/^\s+|\s+$/,'') // 'hello world!'

//^\s+表示以空格开始， \s+$表示以空格结束

　　replace方法的2第二个参数可以使用美元符号 $ ，用来指定所代替的内容

　　　　$&：匹配的字符串

　　　　$`：匹配结果前面的为本

　　　　$'：匹配结果后面的文本

　　　　$n：匹配成功的第 n 组内容，n 是从1开始的自然数

　　　　$$：指代美元符号 $


'hello world'.replace(/(\w+)\s(\w+)/,'$2 $1') //"world hello" ,互换位置

'abc'.replace(/b/,[$`-$&-$\']) //"a[a-b-c]c" ，改写匹配值

　　replace方法的第二个参数还可以是一个函数，将每一个匹配内容替换为函数返回值


'2 and 7'.rep;ace(/[0-9]+/g,function(match){
　　return match * 2;  //match是根据正则表达式获取到的内容，此次获取到 2、7
})
// "4 and 14"


var str = 'The quick brown fox jumped over the lazy dog.';
var r = /quick|brown|lazy/ig;

str.replace(r,function(match){
　　return match.toUpperCase(); //当前match指的是quick、brown、lazy
})

//"The QUICK BROWN fox jumped over the LAZY dog."

　　 replace 方法的第二个参数的替换函数，可以接收多个参数。其中，第一个参数是捕捉到的内容，第二个参数是捕捉到的组匹配（有多少个组匹配，就有多少个对应的参数）。


var p = {
　　'p1': '$1.99';
　　'p2': '$19.99';
　　'p3': '$99.9';
}

var r = /(<span id=")(.*?)(">)(<\/span>)/; //一个括号代表一个组匹配
var str = '<span id="p1"></span>' + '<span id="p1"></span>' + '<span id="p1"></span>';


str.replace(r,function(match,$1,$2,$3,$4){  //$1,$2,$3,$4 代表组匹配

　　return $1 + $2 + $3 + p[$3] + $4;
})

// "<span id="p1">$1.99</span><span id="p2">$9.99</span><span id="p3">$99.9</span>"




    

  • String.prototype.split()：按照给定规则进行字符串分割，返回一个数组，包含分割后的各个成员
    • 



　　split方法按照正则规则分割字符串，返回一个由分割后的各个部分组成的数组


　　接受两个参数，第一个参数是正则表达式，表示分割规则，第二个参数是 返回数组的最大成员数




　　'a,b, c, d'.split(/, */) //*代表前面的0个或多个字符（逗号和空格用 逗号代替）
　　//['a','b','c','d']

　　'a,b, c, d'.split(/, */,2)
　　//['a','b']


　　'aaa*a*'.split(/a*/) //正则默认是贪婪匹配，第一个分隔符是 aaa ，第二个分隔符是 a
　　//['','*','','a']

　　
　　'aa**a*'.split(/a*/) //第一个分隔符是 aaa，第二个分隔符是 0个a（*），第三个分隔符是 a
　　//['','*','*','','*']




 


匹配规则


    

  • 字面量字符
    • 



　　字面量字符，顾名思义，字面的意思




　　/cat/.test('cat and dog')
　　//true




 


    

  • 元字符
    • 



　　点字符，两个字符间包含任意一个字符




　　
　　/c.t/.test('cat')  //true
　　/c.t/.test('c4t')  //true
　　/c.t/.test('c-t')  //true

　　/c.t/.test(''caat) //false  因为中间有两个字符





　　位置字符，有两个。^  表示字符串的开始位置；$ 表示字符串的结束位置




　
　　/^cat/.test('cat123')  //true
　　/cat$/.test('789cat')  //true
　　
　　/^cat/.test('123cat') //false
　　/cat$/.test('cat789') //false

　　//只有cat
　　/^cat$/.test('cat and cat') //false
　　/^cat$/.test('cat') //true





　　选择符，表示 或 关系




　　/cat|dog/.test('cat')  //true




    

  • 转义字符
    • 



　　　对于特殊含义的元字符，如果要匹配它们本身，就需要在它们前面加上反斜杠。例如，




　　/1+1/.test('1+1')  //false
　　
　　/1\+1/.test('1+1')  //true


　　//正则表达式中，需要反斜杠转移的字符有12个：~，.，[，$，（，），|，*，+，？，{，\




    

  • 特殊字符
    • 



　　正则中表达式中对于一些不能打印的特殊字符，提供了表达方法。


　　　\cX 表示 Ctrl - [X] ，其中 X 是A-Z之中任意一个英文字母，用来匹配控制字符。


　　　[\b] 匹配退格键（U+0008），与 \b 不同


　　　\n 匹配换行键


　　　\r 匹配回车键


　　　\t 匹配制表符tab


　　　\v 匹配垂直制表符


　　　\f 匹配换页符


　　　\0 匹配 null 字符


　　　\xhh 匹配一个以两位十六进制数表示的字符


　　　\uhhhh 匹配四位十六进制数表示的字符


    

  • 字符类
    • 














　　字符类表示有一系列字符可供选择，只要匹配其中一个就可以了。所有可供选择的字符都放在 [] 内，比如 [xyz] 表示x、y、z之中任选一个匹配。





　　/[abc]/.test('apple') //true

　　/[abc]/.test('helllo worlad!') //false





　　脱字符，如果方括号内的第一个字符为 [^]，则表示除了字符类的字符，其他字符都可以匹配。比如，[^xyz] 表示除了 x、y、z之外的都可以匹配




　
　/[^abc]/.test('bbc news')  //true
　/[^abc]/.test('bbc')  /false

　//第一个例子中除了a、b、c之外还有其他字符，所以返回true
　//第二个例子中除了a、b、c之外没有其他字符，所以返回false





 


    

  • 预定义模式重复类
    • 

  • 量词符
    • 

  • 贪婪模式
    • 

  • 修饰符
    • 

  • 组匹配
    • 



 


 


 


参考链接：https://wangdoc.com/javascript/stdlib/regexp.html






            

            
posted @ 
2019-07-13 13:03 
足迹# 
阅读(396) 
评论(1) 
编辑 
收藏 
举报