javaScript正则表达式

---

一、作用

RegExp：匹配特殊字符或有特殊搭配原则的字符的最佳选择

二、两种创建方式

1. 直接量

cosnt reg= / 正则表达式 / 修饰符

<script>
  var reg = /abc/;  //正则表达式规则 要有abc且是挨着的
  var str = "abcd";
  console.log(reg.test(str))  //true
</script>

最后一个/后面可以填i ， g ，m属性

2. new对象

 const req = new RegExp（'正则表达式','修饰符'）

个人推荐直接量

三、修饰符

修饰符	描述
g	执行全局匹配（查找所有匹配而不是在第一个匹配后停止）。
i	执行不区分大小写的匹配。
m	执行多行匹配。

对m的解释

const str = 'abcdef\na'  //\n表示换行 
const reg1 = /a/g  //搜索字符串中所有的a
console.log(str.match(reg1)) // ["a", "a"]
//现在要求搜索字符串中第一个a
const reg2 = /^a/g
console.log(str.match(reg2)) // [ 'a' ]
//这时候只有一个a被匹配到 但是\n后面确实是第一个a 怎么办？
const reg3 = /^a/gm
console.log(str.match(reg3)) // [ 'a', 'a' ]
//  /m就是可以匹配多行的意思

四、表达式

形式：[ ]

一个表达式代表一个字符

表达式	描述
[abc]	查找字符a或者b或者c 一个符合即可。
[^abc]	查找任何不在方括号之间的字符。
[0-9]	查找任何从 0 至 9 的数字。
[A-z]	查找从大写A到小写z的字符。
[A-Z]	查找从大写A到大写Z的字符。.
(x|y)	查找x或者y

五、元字符

元字符	描述
.	查找单个字符，除了换行符或行终止符。 [^\r\n]
\w	查找单词字符。 [0-9A-z_]
\W	查找非单词字符。[^\w]
\d	查找数字。[0-9]
\D	查找非数字字符。[^\d]
\s	查找空白字符。 [\t\n\r\v\f ] 制表符、换行符、回车符、垂直制表符、换页符、回车
\S	查找非空白字符。 [^\s]
\b	在单词的开头/结尾查找匹配项，开头如下：\bHI，结尾如下：HI\b。
\B	查找匹配项，但不在单词的开头/结尾处。
\0	查找 NULL 字符。
\n	查找换行符。
\f	查找换页符。
\r	查找回车符。
\t	查找制表符。
\v	查找垂直制表符。
\xxx	查找以八进制数 xxx 规定的字符。
\xdd	查找以十六进制数 dd 规定的字符。
\uxxxx	查找以十六进制数 xxxx 规定的 Unicode 字符。

六、量词

量词	描述
n+	匹配任何包含至少一个 n 的字符串。 {1，infinite}或者{1，}
n*	匹配任何包含零个或多个 n 的字符串。{0，infinite}或者{0，}
n?	匹配任何包含零个或一个 n 的字符串。{0,1}
n{X}	匹配包含 X 个 n 的序列的字符串。 {x}
n{X,Y}	匹配包含 X 至 Y 个 n 的序列的字符串。{x,y}
n{X,}	匹配包含至少 X 个 n 的序列的字符串。{x, } 或者{x,infinite}
n$	匹配任何以 n 结尾的字符串。
^n	匹配任何以 n 开头的字符串。
?=n	匹配任何其后紧接指定字符串 n 的字符串。
?!n	匹配任何其后没有紧接指定字符串 n 的字符串。

七、对象属性

用法：reg.属性

属性	描述
constructor	返回创建 RegExp 对象原型的函数。
global	检查是否设置了 “g” 修饰符。
ignoreCase	检查是否设置了 “i” 修饰符。
lastIndex	规定开始下一个匹配的索引。
multiline	检查是否设置了 “m” 修饰符。
source	返回 RegExp 模式的文本。

八、对象方法

用法：reg.方法()

方法	描述
compile()	在 1.5 版中已弃用。编译正则表达式。
exec()	测试字符串中的匹配项。返回第一个匹配项。
test()	测试字符串中的匹配项。返回 true 或 false。
toString()	返回正则表达式的字符串值。

lastInde 与exec 与g

const reg = /ab/g
const str = 'abababab'
//lastInde : 游标位置
console.log(reg.lastIndex)//0 
console.log(reg.exec(str))//[ 'ab', index: 0, input: 'abababab', groups: undefined ]
console.log(reg.lastIndex)//2
console.log(reg.exec(str))//[ 'ab', index: 2, input: 'abababab', groups: undefined ]
console.log(reg.lastIndex)//4
console.log(reg.exec(str))//[ 'ab', index: 4, input: 'abababab', groups: undefined ]
console.log(reg.lastIndex)//6
console.log(reg.exec(str))//[ 'ab', index: 6, input: 'abababab', groups: undefined ]
console.log(reg.lastIndex)//8
console.log(reg.exec(str))//null
console.log(reg.lastIndex)//0  又回来了

lastIndex 与 exec

const reg = /ab/
const str = 'abababab'
//lastInde : 游标位置
console.log(reg.lastIndex)//0 
console.log(reg.exec(str))//[ 'ab', index: 0, input: 'abababab', groups: undefined ]
console.log(reg.lastIndex)//0
console.log(reg.exec(str))//[ 'ab', index: 0, input: 'abababab', groups: undefined ]
//不加g每次调用exec都会从第0位开始 此时lastIndex修改无效

九、例子

1.表达式（[ ]）题目

1. 连续三个都要求是数字

const str = "1234jsadioasj14213j4io125ij"
// 现在想要一个规则 连续三个都要求是数字
const reg = /[1234567890][1234567890][1234567890]/g 
//一个【】 代表一位 
console.log(str.match(reg))//[ '123', '142', '125' ]

2. 题目

const reg =/[ab][cd][d]/g  //解读：第一位可以是a|b 第二位可以是c|d 第三位可以是d 且连续三位符合
const str = 'abcd'
console.log(str.match(reg))//["acd"]

3. 题目

const reg =/[0-9A-z][cd][d]/g  //解读：第一位可以是0-9 | A-z第二位可以是c|d 第三位可以是d 且连续三位符合
const str = 'ab1cd'
console.log(str.match(reg))//[ '1cd' ]

4. 题目

const reg =/[^a][^b]/g  //解读：第一位不是a 第二位不是b
const str = 'ab1cd'
console.log(str.match(reg))//[ 'b1', 'cd' ]

5. 题目

const reg =/(abc|bcd)/
const str = 'abc'
console.log(reg.test(str))//true
const str2= 'bcd'
console.log(reg.test(str2))//true

2.元字符题目

1. 题目 w与W

//   \w===[0-9A-z_] 表示匹配一个字母或数字或下划线或汉字
//   \W=== [^\w] 除了字母、数字、下划线、汉字以外的字符
const reg =/\wcd2/g
const str = 'bcd2' 
console.log(str.match(reg)) //bcd2
const reg2 = /\Wcd2/g
const str2 = 'b*cd2'
console.log(str.match(reg2)) //null
console.log(str2.match(reg2))//*cd2

2. 题目 d 与 D

//  \d ===[0-9]
//  \D ===[^0-9]

var reg=/\d\d\d/g //匹配三个数字
const str='123'
console.log(str.match(reg)) //123

3. 题目s与S

// \b ===单词边界
// \B ===非单词边界

const  reg = /\bcde\b/g  //匹配 单词边界cde单词边界
const str = 'abc  cde fgh'  //三个单词
console.log(str.match(reg)) //cde
const str2='abc cdefgh'
console.log(str2.match(reg)) //null

4. 题目\t

const reg=/\tc/g
const str='abc  cef'
console.log(str.match(reg))//null
const str2='abc\tcef'
console.log(str2.match(reg))//[ '\tc']

5. 题目匹配一切

//匹配一切
const reg =/[\d\D]/ //匹配一切 有很多种组合 sS wW

6.题目 .

const reg =/./g //匹配任意字符除了\r\n
const str =`hello world`
console.log(str.match(reg))
// [
//   'h', 'e', 'l', 'l',
//   'o', ' ', 'w', 'o',
//   'r', 'l', 'd'
// ]

3.量词题目

1. 题目n+与n*

const reg = /\w+/g //解读：\w可以出现一次或者无数次
const str = 'abc'
console.log(str.match(reg)) // ['abc']
const reg2=/\w*/g   
console.log(str.match(reg2)) // ['abc', '']
//当匹配到c的时候光标再往后移动一位，发现没有了，所以就匹配到了空字符串
const reg3=/\d*/g
console.log(str.match(reg3)) //[ '', '', '', '' ]
//a前面的空格 a后面的空格 b后面的空格 c后面的空格  即有多少个光标定位点就有多少个

2. 题目n?

const reg = /\w?/g
const str = 'aaaaaa'
console.log(str.match(reg))
// [
//   'a', 'a', 'a',
//   'a', 'a', 'a',
//   ''
// ]

3. 题目 n{x}

const reg = /\w{3}/g//解读：匹配3个连续的字母或数字或下划线
const str = 'aaaaaa'
console.log(str.match(reg))//[ 'aaa', 'aaa' ]

4. 题目n{x,y}

const reg = /\w{3,5}/g//解读：匹配3到5个字符的单词
const str = 'aaaaaaaaaaaaaa'
console.log(str.match(reg))//[ 'aaaaa', 'aaaaa', 'aaaa' ]
//正则匹配规则：贪狼 能多就不少

4.检验一个字符串首尾是否含有数字

解读：首和尾有一个就可以

const  reg = /^\d|\d$/gm

//如果想检验一个字符串首尾是否都含有数字呢？
const reg2 = /^\d[\d\D]*\d$/

5.匹配XXXX格式的

const str = 'aaaabbbb'
const reg = /(\w)\1{3}/g  // \1反向引用第一个子表达式里面匹配的内容
console.log(str.match(reg)) // aaaa bbbb

6.aabb转化为bbaa

let str ='aabb'
const reg = /(\w)\1(\w)\2/g
str=str.replace(reg,"$2$2$1$1")
//或者
str = str.replace(reg,function($,$1,$2){
  //$代表str
  //$1代表第一个括号匹配的内容
  //$2代表第二个括号匹配的内容
  return $2+$2+$1+$1
})
console.log(str) //bbaa

7.the-first-name–>theFirstName

const str = 'the-first-name'
const reg = /-(\w)/g
console.log(str.replace(reg,function($,$1){
  return $1.toUpperCase()
}))

8.正向预查 正向断言

const str='abaaaaa'
//现在要匹配一个a后面跟着一个b但是b不参与匹配
const reg =/a(?=b)/g//解读：a后面跟着一个b但是b不参与匹配
console.log(str.match(reg))//["a"]
const reg2=/a(!=b)/g//解读：a后面跟着一个非b但是b不参与匹配
console.log(str.match(reg2))//["a", "a", "a", "a", "a", "a"]

9.打破贪婪匹配

const str ='aaaaaa'
const reg=/\w{1,3}/g
console.log(str.match(reg))//[ 'aaa', 'aaa' ]  贪婪匹配 
//能多就不少

const reg2=/\w{1,3}?/g 
console.log(str.match(reg2))//[ 'a', 'a', 'a', 'a', 'a', 'a' ]  非贪婪匹配
//能少就不多

10.字符串去重

const str ='aaaaaaaabbbbbbbbccccccccddddddd' //现在要变为abcd
const reg=/(\w)\1*/g
// console.log(str.match(reg))//[ 'aaaaaaaa', 'bbbbbbbb', 'cccccccc', 'ddddddd' ]
str=str.replace(reg,'$1')

11.100000000从后往前数每隔三个打逗号

let str ='1000000000000'
// const reg = /((\d{3})+$)/g //从后往前查找3的倍数的数字
// console.log(str.match(reg)) //[ '000000000000' ]
// const reg = /(?=((\d{3})+$))/g //空后面跟着3的倍数的数字 正向预查
// console.log(str.match(reg))//[ '', '', '', '' ]
// str=str.replace(reg,'.')
// console.log(str)//1.000.000.000.000
//但是此时还没结束 如果我多加两个0
 str='100000000000000'
// str=str.replace(reg,'.')
// console.log(str)//.100.000.000.000.000
const reg= /(?=(\B)((\d{3})+$))/g //空后面跟的必须得是非单词边界
str=str.replace(reg,'.')
console.log(str)//.100.000.000.000.000

//用js实现
const str = '1000000000000000'
function change(str){
  let arr = str.split('').reverse()//转化为数组
  let newArr=[]
  while(arr.length){
    newArr.push(arr.splice(0,3))
  }
  for(var i =0;i<newArr.length;i++){
    newArr[i]=newArr[i].join('')
  }
  newArr=newArr.join(',')
  newArr=newArr.split('').reverse().join('')
  return newArr
}

console.log(change(str))