Js正则表达式

# 正则

* 正则表达式, 又名 "规则表达式"

* 由我们自己来书写 "规则", 专门用来检测 **字符串** 是否符合 "规则" 使用的

* 我们使用一些特殊的字符或者符号定义一个 "规则公式", 然后用我们定义好的 "规则公式" 去检测字符串是不是合格

```js

var reg = /\d+/

var str1 = '123'

var str2 = 'abc'

console.log(reg.test(str1)) // true

console.log(reg.test(str2)) // false

```

* 上面的变量 `reg` 就是定制好的规则

* 检测 str1 这个字符串的时候, 符合规则

* 检测 str2 这个字符串的时候, 不符合规则

## 创建一个正则表达式

* 想制定 "规则", 就必须要按照人家要求的方式来制定

* 把一些字母和符号写在 `//` 中间的东西, 叫做正则表达式, 比如 `\abcdefg\`

* 创建正则表达式有两个方式 **字面量** 和 **构造函数创建**

###### 字面量创建

```js

// 字面量创建一个正则表达式

var reg = /abcdefg/

```

###### 构造函数创建

```js

var reg = new RegExp('abcdefg')

```

## 正则表达式里面的符号

###### 元字符

* `.`: 匹配非换行的任意字符

* `\`: 转译符号, 把有意义的 **符号** 转换成没有意义的 **字符**, 把没有意义的 **字符** 转换成有意义的 **符号**

* `\s`: 匹配空白字符(空格/制表符/...)

* `\S`: 匹配非空白字符

* `\d`: 匹配数字

* `\D`: 匹配非数字

* `\w`: 匹配数字字母下划线

* `\W`: 匹配非数字字母下划线

> 利用元字符制定一些简单的规则

```js

var reg = /\s/

var str = 'a b'

var str2 = 'ab'

console.log(reg.test(str)) // true

console.log(reg.test(str2)) // false

```

```js

var reg = /\d/

var str = 'abc1'

var str2 = 'abc'

console.log(reg.test(str)) // true

console.log(reg.test(str2)) // false

```

```js

var reg = /\w/

var str = 'a1'

var str2 = '#$%'

console.log(reg.test(str)) // true

console.log(reg.test(str2)) // false

```

###### 限定符

* `*`: 前一个内容重复至少 0 次, 也就是可以出现 **0~正无穷** 次

* `+`: 前一个内容重复至少 1 次, 也就是可以出现 **1~正无穷** 次

* `?`: 前一个内容重复 0 或者 1 次, 也就是可以出现 **0~1** 次

* `{n}`: 前一个内容重复 n 次, 也就是必须出现 **n** 次

* `{n,}`: 前一个内容至少出现 n 次, 也就是出现 **n ~ 正无穷** 次

* `{n, m}`: 前一个内容至少出现 n 次至多出现 m 次, 也就是出现 **n~m** 次

> 限定符一般是配合元字符使用

```js

var reg = /\d*/ // 验证数字出现 0~正无穷次

var str = 'abc'

var str2 = 'abc1'

var str3 = 'abc123'

console.log(reg.test(str)) // true

console.log(reg.test(str2)) // true

console.log(reg.test(str3)) // true

```

```js

var reg = /\d+/ // 验证数字出现 1~正无穷次

var str = 'abc'

var str2 = 'abc1'

var str3 = 'abc123'

console.log(reg.test(str)) // false

console.log(reg.test(str2)) // true

console.log(reg.test(str3)) // true

```

```js

var reg = /\d?/ // 验证数字出现 0~1 次都可以

var str = 'abc'

var str2 = 'abc1'

var str3 = 'abc123'

console.log(reg.test(str)) // true

console.log(reg.test(str2)) // true

console.log(reg.test(str3)) // true

```

```js

var reg = /\d{3}/ // 验证数字出现 3 次

var str = 'abc'

var str2 = 'abc1'

var str3 = 'abc123'

console.log(reg.test(str)) // false

console.log(reg.test(str2)) // false

console.log(reg.test(str3)) // true

```

```js

var reg = /\d{3,}/ // 验证数字出现 3~正无穷次

var str = 'abc'

var str2 = 'abc1'

var str3 = 'abc123'

var str4 = 'abc1234567890'

console.log(reg.test(str)) // false

console.log(reg.test(str2)) // false

console.log(reg.test(str3)) // true

console.log(reg.test(str4)) // true

```

```js

var reg = /\d{3,5}/ // 验证数字出现 3~5 次

var str = 'abc'

var str2 = 'abc1'

var str3 = 'abc123'

var str4 = 'abc1234567890'

console.log(reg.test(str)) // false

console.log(reg.test(str2)) // false

console.log(reg.test(str3)) // true

console.log(reg.test(str4)) // true

```

###### 边界符

* `^`: 表示开头

* `$`: 表示结尾

> 边界符是限定字符串的开始和结束的

```js

var reg = /^\d{3,5}$/

var str = 'abc'

var str2 = 'abc123'

var str3 = '1'

var str4 = '1234567'

var str5 = '123'

var str6 = '12345'

console.log(reg.test(str)) // false

console.log(reg.test(str2)) // false

console.log(reg.test(str3)) // false

console.log(reg.test(str4)) // false

console.log(reg.test(str5)) // true

console.log(reg.test(str6)) // true

```

###### 特殊符号

* `()`: 限定一组元素

* `[]`: 字符集合, 表示写在 `[]` 里面的任意一个都行

* `[^]`: 反字符集合, 表示写在 `[^]` 里面之外的任意一个都行

* `-`: 范围, 比如 `a-z` 表示从字母 a 到字母 z 都可以

* `|`: 或, 正则里卖弄的或 `a|b` 表示字母 a 或者 b 都可以

```js

/**

* 书写一个简单的邮箱验证

*

* 验证规则:

* 非 _$开头, 任意字符出现至少6次, 一个@符号, (163|126|qq|sina)中的任意一个, 一个点, (com|cn|net) 中的任意一个

*/

var reg = /^[^_$].{5,}@(163|126|qq)\.(com|cn|net)$/

```

###### 标识符

* `i`: 表示忽略大小写

* 这个 i 是写在正则的最后面的, 例如: `/\w/i`

* 这就是在匹配的时候匹配数字字母下划线, 并且不区分大小写

* `g`: 表示全局匹配

* 这个 g 是写在正则的最后面的, 例如: `/\w/g`

* 就是全局匹配数字字母下划线

###### 重复元字符

* `\数字`: 表示重复第 n 个小括号的内容, 要求和第 n 个小括号的内容一摸一样

```js

/**

* 表示 \1 位置需要出现一个 和 第1个 小括号 一模一样的额呢绒

* 小括号位置出现的是 abc, \1 位置也带是 abc

* 小括号位置出现的是 def, \1 位置也带是 def

*/

var reg = /^(abc|def)\1$/

console.log(reg.test('abcabc')) // true

console.log(reg.test('defdef')) // true

console.log(reg.test('defabc')) // false

```

## 正则的两大特性 (懒惰与贪婪)

* 懒惰

* 每次捕获都会从字符串 `[0]` 的位置开始检索

* 解决:

* 给正则添加全局标识符

* 贪婪

* 每次捕获内容的时候会尽可能地多的去捕获内容

* 解决:

* 使用非贪婪限定符(在原有限定符后面多加一个 ?)

* 贪婪限定符

* `*`; `+`; `?`; `{n,}`; `{n,m}`

* 非贪婪限定符

* `*?`; `+?`; `??`; `{n,}?`; `{n,m}?`

```js

var str = `<div class="box" id="box"><span></span></div>`

// 贪婪捕获

var reg = /<div.*>/

console.log(reg.exec(str))

// 非贪婪捕获

var reg1 = /<div.*?>/

console.logIreg1.exec(str)

```

## 正则表达式的方法

###### test 用来检测字符串是否符合我们正则的标准

* 语法: `正则.test(字符串)`

* 返回值: boolean

```js

console.log(/\d+/.test('123'))

```

###### exec 把字符串中符合条件的内容捕获出来

* 语法: `正则.exec(字符串)`

* 返回值:

1. 当原始字符串内没有符合正则规范的片段的时候, 返回值为 null

2. 当原始字符串内有符合正则规范的判断的时候

* 返回值一定是一个数组: 数组内的 `[0]` 是捕获出来的字符串片段

* 没有 () 没有标识符g

* 只能获取第一组匹配到的字符串片段

* 不管匹配多少回, 都是从字符串 `[0]` 的位置开始检索

* 有 ()

会在返回值数组的 `[1]` 开始依次是每一个 `()` 内的单独内容

* 有 g

* g 叫做全局标识符

* 第二次捕获会从第一次捕获的结束位置开始进行检索

* 直到找不到内容, 返回 null

* 在下一次捕获的时候, 会从字符串 `[0]` 开始检索

* 扩展: 匹配但不捕获

* 当我们需要使用 `()` 的一个整体这个作用的时候, 但是又不想单独捕获出来

* 可以这样书写: `(?:)`

```js

var reg = /\d{3}/

var str = 'hello123word456你好789'

var res = reg.exec(str)

console.log(res)

/*

['123', index: 5, input: 'hello123word456你好789', groups: undefined]

0: "123"

groups: undefined

index: 5

input: "hello123word456你好789"

length: 1

*/

```

* 数组第 0 项就是匹配到的字符串内容

* index 属性表示从字符串的索引几 开始是匹配到的字符串

## 字符串的方法

> 字符串中有一些方法是可以和正则一起使用

###### search: 查找字符串中是否有满足条件的内容

* 语法: `字符串.search(正则)`

* 返回值: 有的话返回开始索引, 没有返回 -1

```js

var reg = /\d{3}/

var str1 = 'hello123'

var str2 = 'hello'

console.log(str1.search(reg)) // 5

console.log(str2.search(reg)) // -1

```

###### match: 找到字符串中符合正则条件的内容返回

* 语法: `字符串.match(正则)`

* 返回值:

* 没有标识符 g 的时候, 是和 exec 方法一样

* 有标识符 g 的时候, 是返回一个数组, 里面是匹配到的每一项, 没有匹配到内容是返回的是 null

```js

var reg = /\d{3}/

var str1 = 'hello123world456'

var str2 = 'hello world'

console.log(str1.match(reg))

/*

['123', index: 5, input: 'hello123world456', groups: undefined]

0: "123"

groups: undefined

index: 5

input: "hello123world456"

length: 1

*/

console.log(str2.match(reg)) // -1

```

```js

var reg = /\d{3}/g

var str1 = 'hello123world456'

var str2 = 'hello world'

console.log(str1.match(reg)) // ['123', '456']

console.log(str2.match(reg)) // null

```

###### replace: 是将字符串中满足正则条件的字符串替换掉

* 语法: `字符串.replace(正则, 要替换的字符串)`

* 返回值: 替换后的字符串

```js

var reg = /\d{3}/

var str1 = 'hello123world456'

var str2 = 'hello world'

console.log(str1.replace(reg, '哈哈哈哈')) // hello哈哈哈哈world456

console.log(str2.replace(reg, '哈哈哈哈')) // hello world

```

```js

var reg = /\d{3}/g

var str1 = 'hello123world456'

var str2 = 'hello world'

console.log(str1.replace(reg, '哈哈哈哈')) // hello哈哈哈哈world哈哈哈哈

console.log(str2.replace(reg, '哈哈哈哈')) // hello world

```