RegExp复习 - 代码天地

感觉好动东西长时间不用就会忘掉,记录一下把…

regular expression

正则基础

转义符号->\
转义字符->+被转义的字符
引号问题

var str = "我是一名"牛逼"的程序员";// 语法错误 ，牛逼是一个变量，变量和字符串直接应该有加号
var str = "我是一名"+牛逼+"的程序员"//引用错误，牛逼这个变量没有被定义

var str = "我是一名\"牛逼\"的程序员";
// '我是一名"牛逼"的程序员'

var str = "我是一名\\牛逼\\的程序员";
// '我是一名\牛逼\的程序员'

n、r、t

\n 换行

var str = "我是一名\n牛逼\n的程序员";
console.log(str) //1. 浏览器控制台换行

document.write(str) //2. document没有换行
// 我是一名 牛逼 的程序员  显示为空格

编辑系统，如编辑器，控制台等的换行都是\n
html是纯文本显示，它的换行是\n\r，只有\n无法识别所以显示为一个空格

window->回车换行+\r\n
mac->回车换行+\r
linux->回车换行+\n

\t 制表符，四个空格

字符串的换行

var str = "我是一名
            牛逼
            的程序员"

// 转义，把回车换行转义成空格，这是系统默认加的
var str = "我是一名\
            牛逼\
            的程序员"

字面量、构造函数、标志参数（i、g、m）

var reg = new RegExp('Test','i'); 
var str = 'this is Test'
reg.test(str) //true

var reg = new RegExp('test','i'); //ignore case 忽略大小写
var str = 'this is Test,i am test2'
str.match(reg) //['Test', index: 8, input: 'this is Test,i am test2', groups: undefined]
// 只匹配了第一个Test

//全匹配 
var reg = new RegExp('test','ig'); //g 全局匹配 global
var str = 'this is Test,i am test2'
str.match(reg) //['Test', 'test']

var reg = new RegExp('^test','igm'); //m 多行匹配 multi-line
var str = 'this is Test,\ntest is now'
str.match(reg) //['test']


// 字面量 不用写引号
var reg = /test/ 
var str = 'this is test'
reg.test(str) //true
// 忽略大小写
var reg = /test/i 
var str = 'this is Test'
reg.test(str) //true

正则用字面量还是对象new ？
推荐使用正则字面量、如果正则表达式还有变量，就只能用实例化对象声明
对比

 var reg = /test/;
 var newReg = new RegExp('test');
//  reg 和  newReg 是不同的两个对象

var reg = /test/;
reg.a = 1;
var newReg = RegExp('test');
console.log(newReg.a)
// 也是不同的两个对象

var reg = /test/;
var newReg = RegExp(reg); //这个它两是相同的引用

var reg = /test/;
var newReg = new RegExp(reg);
// 不同的两个对象

表达式[]

[xyz]

一个字符集合。匹配方括号中的任意字符

例如，[abcd] 和[a-d]是一样的。他们都匹配"brisket"中的‘b’,也都匹配“city”中的‘c’。

var str = "0154eer878we232";
var reg = /[12345678][12345678][12345678]/g;
str.match(reg) //(3) ['154', '878', '232']

var str = "015284eer878we232";
var reg = /[12345678][12345678][12345678]/g;
str.match(reg) //(3)  ['152', '878', '232']
// 匹配过的不再匹配

[0-9]
[A-Z]、[A-z]（不能是小写到大写： Invalid regular expression: /[0-9a-Z]/: Range out of order in character class）
[a-z]
[0-9A-Z]

[^xyz]

一个反向字符集。也就是说，它匹配任何没有包含在方括号中的字符。你可以使用破折号（-）来指定一个字符范围。任何普通字符在这里都是起作用的。

例如，[^abc] 和 [^a-c] 是一样的。他们匹配"brisket"中的‘r’，也匹配“chop”中的‘h’。

x|y

匹配‘x’或者‘y’。

例如，/green|red/匹配“green apple”中的‘green’和“red apple”中的‘red’

var reg = /green|red/g
var str = 'green apple'
console.log(str.match(reg))//['green']

元字符

一个元字符匹配一位

\w、\W

w -> [0-9A-z]
W -> [^\w]

var reg = /\wab/g
var str = '2345abc-avc'
str.match(reg) //['5ab']

var reg = /\Wab/g
var str = '2345abc-ab'
str.match(reg) //['-ab']

var reg = /[\W][\w][\w]/g
var str = '2345abc-ab'
str.match(reg) //['-ab']

\d、\D

d -> [0-9]
D -> [^\d]

\s、\S

s匹配一个空白字符，包括空格、制表符、换页符和换行符
s -> [\r\n\t\v\f]
S -> 匹配一个非空白字符

例如, /\s\w*/ 匹配"foo bar."中的’ bar’。
例如，/\S\w*/ 匹配"foo bar."中的’foo’。

var reg = /\sab/g
var str = '23\nab'
console.log(str.match(reg))

\b、\B

b-> 匹配一个词的边界

var reg = /\bthis\b/g
var str = 'this is a test'
console.log(str.match(reg))//['this']

var reg = /\Bhis\b/g
var str = 'this is a test'
console.log(str.match(reg))//['his']

.

（小数点）默认匹配除换行符之外的任何单个字符。

var reg = /.n/g
var str = 'nay, an apple is on the tree'
console.log(str.match(reg))//(2) ['an', 'on']

正则量词

不回头
贪婪模式

+

匹配前面一个表达式 1 次或者多次。等价于 {1,}。

var reg = /\w+/g
var str = '1@candy#23'
str.match(reg)// ['1', 'candy', '23']

*

匹配前一个表达式 0 次或多次。等价于 {0,}

var reg = /\w*/g
var str = '1@candy#23'
str.match(reg)// (6) ['1', '', 'candy', '', '23', '']

var reg = /\d*/g
var str = 'abcde'
str.match(reg)//(6) ['', '', '', '', '', '']
// 字符串从左到右依次匹配多，如果一旦匹配上就不回头
// 贪婪匹配原则：能匹配多个绝不匹配少个
// 1a2b3c4d5e6
// 每个光标处都会匹配到 6 

var reg = /\w*/g
var str = 'abcde'
str.match(reg) //(2) ['abcde', '']

var reg = /\d*/g
var str = 'sdf12'
str.match(reg) //(5) ['', '', '', '12', '']
// \d* 是匹配连续的0个或多个数字。并且是贪婪匹配，能匹配2个时就不会只匹配1个。
// 结果是 ['', '', '', '12', '']
// 因为\d* 可以匹配0个数字，也就等同匹配空字符串''
// 第1次的''是匹配s前面的空字符串
// 第2次的''是匹配d前面的空字符串
// 第3次的''是匹配f前面的空字符串
// 第4次'12'是能匹配2个时就不会只匹配1个。
// 第5次的''是匹配字符串结尾前的空字符串

是零次和多次，比+多出一个空字符串

先是贪婪匹配，然后再匹配空字符串

?

匹配前面一个表达式 0 次或者 1 次。等价于 {0,1}。

var reg = /\d?/g
var str = 'abcde'
str.match(reg) //(6) ['', '', '', '', '', '']

var reg = /\w?/g
var str = 'abcde'
str.match(reg) //(6) ['a', 'b', 'c', 'd', 'e', '']

如果紧跟在任何量词 *、 +、? 或 {} 的后面，将会使量词变为非贪婪（匹配尽量少的字符），
和缺省使用的贪婪模式（匹配尽可能多的字符）正好相反。
例如，对 “123abc” 使用 /\d+/ 将会匹配 “123”，而使用 /\d+?/ 则只会匹配到 “1”。

var reg = /\d+/g
var str = '123abc'
str.match(reg) //['123']

var reg = /\d+?/g
var str = '123abc'
str.match(reg) // ['1', '2', '3']

var reg = /\d?/g
var str = '123abc'
str.match(reg) //['1', '2', '3', '', '', '', '']

{n,m}

n 和 m 都是整数。匹配前面的字符至少n次，最多m次。如果 n 或者 m 的值是0，这个值被忽略。

var reg = /\w{1,2}/g
var str = 'abcdefg'
str.match(reg)//(4) ['ab', 'cd', 'ef', 'g']

注意：正则表达式里面空格就是真的空格

{n,}

n是一个正整数，匹配前一个字符至少出现了n次。

{n}

n 是一个正整数，匹配了前面一个字符刚好出现了 n 次。

^

匹配输入的开始。如果多行标志被设置为 true，那么也匹配换行符后紧跟的位置。

例如，/^A/ 并不会匹配 “an A” 中的 ‘A’，但是会匹配 “An E” 中的 ‘A’。

$

匹配输入的结束。如果多行标志被设置为 true，那么也匹配换行符前的位置。

例如，/t$/ 并不会匹配 “eater” 中的 ‘t’，但是会匹配 “eat” 中的 ‘t’。

// 匹配abc开头，abc结尾的字符
var reg = /^abc\w*abc$/g
var str = 'abcdefgabc'
str.match(reg)//['abcdefgabc']

var reg = /^abc[\w]*abc$/g
var str = 'abcdefgabc'
str.match(reg)//['abcdefgabc']

var reg = /[^abc][abc$]/g
var str = 'abcdefgabc'
str.match(reg)//['abcdefgabc']

子表达式(x)和反向引用

它会匹配 ‘x’ 并且记住匹配项。其中括号被称为捕获括号。

模式 /(foo) (bar) \1 \2/ 中的 ‘(foo)’ 和 ‘(bar)’ 匹配并记住字符串 “foo bar foo bar” 中前两个单词。

var str = 'foo bar foo bar'
var reg =  /(foo) (bar) \1 \2/
str.match(reg)
//(3) ['foo bar foo bar', 'foo', 'bar', index: 0, input: 'foo bar foo bar', groups: undefined]
//=====================
var str = 'abcabc'
var reg = /bc/
str.match(reg) //['bc', index: 1, input: 'abcabc', groups: undefined]
// 加括号捕获子表达式
var str = 'abcabc'
var reg = /(b)(c)/
str.match(reg) //(3) ['bc', 'b', 'c', index: 1, input: 'abc', groups: undefined]
// 不捕获子表达式b
var str = 'abcabc'
var reg = /(?:b)(c)/
str.match(reg)// (2) ['bc', 'c', index: 1, input: 'abcabc', groups: undefined]

模式中的 \1 和 \2 表示第一个和第二个被捕获括号匹配的子字符串，即 foo 和 bar，匹配了原字符串中的后两个单词。这是反向引用
注意 \1、\2、…、\n 是用在正则表达式的匹配环节
而在正则表达式的替换环节，则要使用像 $1、 $2 、 . . . 、$ n 这样的语法，例如，‘bar foo’.replace(/(…) (…)/, '$2 $1^{'}) 。$ & 表示整个用于匹配的原字符串。

var reg = /(foo) (bar) \1 \2/g
var str = 'foo bar foo bar'
str.match(reg)//['foo bar foo bar']

正向预查

x(?=y)先行断言

匹配’x’仅仅当’x’后面跟着’y’.这种叫做先行断言。

先行断言用来检查接下来的出现的是不是某个特定的字符集。

x(?!y)正向否定查找

仅仅当’x’后面不跟着’y’时匹配’x’，这被称为正向否定查找。

正向否定查找则是检查接下来的不应该出现的特定字符串集。

(?:x)非捕获括号

匹配 ‘x’ 但是不记住匹配项。这种括号叫作非捕获括号

RegExp属性

RegExp.prototype.global
针对字符串中所有可能的匹配项测试正则表达式，还是仅针对第一个匹配项。
RegExp.prototype.ignoreCase
匹配文本的时候是否忽略大小写。
RegExp.prototype.multiline
是否进行多行搜索。
RegExp.prototype.source
正则表达式的文本。
RegExp.lastIndex 静态属性
该索引表示从哪里开始下一个匹配

RegExp方法

test()

test() 方法执行一个检索，用来查看正则表达式与指定的字符串是否匹配。返回 true 或 false。

let str = 'hello world!';
let result = /^hello/.test(str);
console.log(result);
// true

exec()

正则匹配迭代器

exec() 方法在一个指定字符串中执行一个搜索匹配。返回一个结果数组或 null。

var myRe = /ab*/g; //如果没有g 永远匹配第一项，永远不会有null，下面的判断会死循环
var str = 'abbcdefabh';
var myArray;
while ((myArray = myRe.exec(str)) !== null) {
    
    
    // 循环判断exec返回null之后又会从从头开始匹配
  var msg = 'Found ' + myArray[0] + '. ';
  msg += 'Next match starts at ' + myRe.lastIndex;//lastIndex是可以修改的
  console.log(msg);
}
// Found abb. Next match starts at 3 。 ['abb', index: 0, input: 'abbcdefabh', groups: undefined]
// Found ab. Next match starts at 9 。  ['ab', index: 7, input: 'abbcdefabh', groups: undefined]

match exec

贪婪模式和非贪婪模式

var str = "abc{
    
    {def}}abc{
    
    {xyz}}";
var reg = /{
     
     {.*}}/g
str.match(reg)  //['{
    
    {def}}abc{
    
    {xyz}}']
//本意是想匹配{
    
    {def}}和{
    
    {xyz}}
//任何语言的正则都是贪婪模式

var reg = /{
     
     {.*?}}/g //?将贪婪模式变为非贪婪模式
str.match(reg)   // ['{
    
    {def}}', '{
    
    {xyz}}']

var str = 'aaaaaa';
var reg = /\w?/g //贪婪模式  问号匹配零次或一次，贪婪模式优先匹配一次
str.match(reg) //(7) ['a', 'a', 'a', 'a', 'a', 'a', '']

var reg = /\w??/g  //+? 非贪婪
str.match(reg) //(7) ['', '', '', '', '', '', '']

RegExp复习

文章目录