# 目的

# 场景

在前端工作中，表单检验一直是一个比较繁琐的事，规范的表单肯定少不了正则的功劳，那么正则表达式就是我们需要掌握的重要知识点了。

# 学习途径

RegExLab
正则表达式-Runoob
RegEx101

# 实例

• 只能输入数字

var reg = /^\d*$/
var value = '';
reg.test(value);
value = '1'; // true
value = '01'; // true
value = '10'; // true
value = '123'; // true
value = '1a'; // false
value = '1 '; // false

• 姓名只能是2~20位的中文字符

var reg = /^[\u4E00-\u9FA5]{2,20}$/
var value = '';
reg.test(value);
value = '小李'; // true
value = '小李小李'; // true
value = '小'; // false
value = '小小小小小小小小小小小小小小小小小小小小小'; // false
value = '小李 '; // false
value = '小 李'; // false
value = '小李1'; // false
value = '小li'; // false

• 中国地区的手机号码

var reg = /^([1][3,4,5,6,7,8,9])\d{9}$/
var value = '';
reg.test(value);
value = '13000000000'; // true
value = '12000000000'; // false
value = '1'; // false
value = 'a'; // false

# 学习

# 字符

|限定符|描述|
|-|-|-|
||匹配前面的子表达式零次或多次。例如，zo 能匹配 “z” 以及 “zoo”。* 等价于{0,}。|
|+|匹配前面的子表达式一次或多次。例如，‘zo+’ 能匹配 “zo” 以及 “zoo”，但不能匹配 “z”。+ 等价于 {1,}。|
|?|匹配前面的子表达式零次或一次。例如，“do(es)?” 可以匹配 “do” 、 “does” 中的 “does” 、 “doxy” 中的 “do” 。? 等价于 {0,1}。|
|{n}|n 是一个非负整数。匹配确定的 n 次。例如，‘o{2}’ 不能匹配 “Bob” 中的 ‘o’，但是能匹配 “food” 中的两个 o。|
|{n,}|n 是一个非负整数。至少匹配n 次。例如，‘o{2,}’ 不能匹配 “Bob” 中的 ‘o’，但能匹配 “foooood” 中的所有 o。‘o{1,}’ 等价于 ‘o+’。‘o{0,}’ 则等价于 ‘o*’。|
|{n,m}|m 和 n 均为非负整数，其中n <= m。最少匹配 n 次且最多匹配 m 次。例如，“o{1,3}” 将匹配 “fooooood” 中的前三个 o。‘o{0,1}’ 等价于 ‘o?’。请注意在逗号和两个数之间不能有空格。|

# 正则的组合

最全的常用正则表达式大全——包括校验数字、字符、一些特殊的需求等等
完美版js金钱正则表达式校验

# “认”表达式

^(0|[1-9][0-9]*)$ // 0或者正整数

> ^开头$结尾，表示从开始到结束都要满足匹配 
> (0|[1-9][0-9]*) 这里是一个子表达式(存在一个选择符 “|” ，所以为了^和$在 0 和 [1-9][0-9]* 两个表达式起到作用)
> 0 表达式1，表示可匹配0
> | 选择符，表示左右两边任意匹配一个即可
> [1-9][0-9]* 表达式2，表示第一个为1-9的数字，后续为零次或多次的0-9数字

 ^([1][3,4,5,6,7,8,9])\d{9}$ // 手机号码

> ^开头$结尾，表示从开始到结束都要满足匹配 
> ([1][3,4,5,6,7,8,9]) 这里是一个子表达式(也可不写括号)
> [1][3,4,5,6,7,8,9] 这个表达式表示第一位须为1，第二位须为“3,4,5,6,7,8,9”其中一位(也可[3456789]这样书写)
> \d{9} 表示匹配9位的所有数字

(^[1-9]([0-9]+)?(\.[0-9]{1,2})?$)|(^(0){1}$)|(^[0-9]\.[0-9]([0-9])?$) // 钱

> ^开头$结尾，表示从开始到结束都要满足匹配 
> 拆分成三对表达式 (^[1-9]([0-9]+)?(\.[0-9]{1,2})?$)、(^(0){1}$) 和 (^[0-9]\.[0-9]([0-9])?$)
> 第一对：(^[1-9]([0-9]+)?(\.[0-9]{1,2})?$) 
> 第一对：^开头$结尾，表示从开始到结束都要满足匹配 
> 第一对：[1-9]([0-9]+)? 第一位1-9的数字，[0-9]+为一次或多次的0-9数字，?表示([0-9]+)可以零次或一次
> 第一对：(\.[0-9]{1,2})? \. 需要匹配“.”，[0-9]{1,2}匹配1-2位0-9的数字，?表示(\.[0-9]{1,2})可以零次或一次
> 第一对：结果就是满足1-9开头(不限位数)可带1-2位小数的数

> 第二对：(^(0){1}$)
> 第二对：^开头$结尾，表示从开始到结束都要满足匹配
> 第二对：(0){1} 只能匹配一位数字0

> 第三对：(^[0-9]\.[0-9]([0-9])?$)
> 第三对：^开头$结尾，表示从开始到结束都要满足匹配
> 第三对：[0-9] 一位0-9的数字
> 第三对：\. 需要匹配“.”
> 第三对：[0-9] 一位0-9的数字
> 第三对：([0-9])? 一位0-9的数字，?表示([0-9])可以零次或一次
> 第三对：结果就是满足0-9开头(1位数)可带1-2位小数的数

> 组合起来就是匹配 0和1-9开头(不限位数)可带1-2位小数的数和0开头可带1-2位小数的数

# 使用正则表达式

# RegExp对象方法

test() 返回字符串是否与Reg匹配(多用于表单强校验,返回布尔类型)

// 0和1-9开头(不限位数)可带1-2位小数的数和0开头可带1-2位小数的数
let reg = /(^[1-9]([0-9]+)?(\.[0-9]{1,2})?$)|(^(0){1}$)|(^[0-9]\.[0-9]([0-9])?$)/
reg.test('1.1'); // true
reg.test('1.12'); // true
reg.test('0.1'); // true
reg.test('1'); // true
reg.test('0'); // true
reg.test('1.999'); // false

exec() 返回字符串中与reg首次匹配的值(用于包含判断，存在返回数组，不存在返回null)

let reg = /\d/
reg.exec('923ABC'); // ["9", index: 0, input: "923ABC", groups: undefined] 
reg.exec('adss'); // null

compile() 用于改变RegExp(改变表达式)

let reg = /\d/
reg.compile('^\d$'); // reg = /^\d$/

# 字符串操支持正则表达式的方法

replace() 替换reg匹配字符串

let val = 'aabcd';
let reg = /a/;
val.replace(reg, '1'); // val = '1abcd'
let regg = /a/g; // g 全文查找
val.replace(regg, '1'); // val = '11bcd'
let regi = /A/i; // i 忽略大小写
val.replace(regi, '1'); // val = '1abcd'
let regm = /a/m; // i 多行查找(多行查找一般用于有换(\r\n)行的字符中)
val = 'cc\r\naabcd';
val.replace(regm, '1'); 
// val = 
// 'cc
// 1abcd'

g/i/m可以组合使用

split() 按reg匹配的值拆分成数组

let val = 'aabcd';
let reg = /a/;
val.split(reg); // ["", "", "bcd"]

match() 返回reg匹配的第个字符串(多用于表单强校验,匹配成功返回数组，不存在返回null)

// 0和1-9开头(不限位数)可带1-2位小数的数和0开头可带1-2位小数的数
let reg = /(^[1-9]([0-9]+)?(\.[0-9]{1,2})?$)|(^(0){1}$)|(^[0-9]\.[0-9]([0-9])?$)/
'1.1'.match(reg); // [...] 匹配成功
'1.12'.match(reg); // [...] 匹配成功
'0.1'.match(reg); // [...] 匹配成功
'1'.match(reg); // [...] 匹配成功
'0'.match(reg); // [...] 匹配成功
'1.999'.match(reg); // null 匹配不成功

search() 返回reg匹配的第一个字符串的位置，没有则返回-1

let val = 'aabcd';
let reg = /a/;
val.search(reg); // 0
let val = '1abcd';
let reg = /a/;
val.search(reg); // 1
let val = '12bcd';
let reg = /a/;
val.search(reg); // -1