1 正则表达式的两个方法
/*
1.匹配： 验证字符串是不是符合正则规则
语法： 正则.test(要检验的字符串)
返回值：true/false
2.捕获：从字符串里面获取符合正则规则的那一部分片段
语法: 正则.exec(要检验的字符串)
返回值：
1. 字符串里没有符合规则的片段
-> null
2.字符串里没有符合规则的片段
2-1.基础捕获
->返回值是一个数组
->[0]是捕获出来的片段
->不管有多少个片段，都只是捕获第一个片段
->不管捕获多少次，都是第一个片段
2-2.
*/
2 正则表达式的元字符
2-1 基础元字符
/*
正则表达式的元字符 – 基础元字符 + 元字符: 组成正则的基本符号
=>以符号的形式来代替文本内容
=>把所有的文木内容归结成些符导来代节
1. \s 表示一个 空格
2. \S 表示一个 非空格
3. \t 表示一个 制表符
=> 一个制表符是一个制表符 不是多个空格
4. \d 表示一个 数字 0~9
5. \D 表示一个 非数字
6. \w 表示一个 数字 || 字母 || 下划线 都可以 （三种类型必须有一个）
7. \W 表示一个 数字 || 字母 || 下划线 以外任意一个字符
8. 点(.) 表示非换行的任意字符
9. 斜线(\) 表示 转义符
=> 把没有意义的内容转换成有意文的内容
=> 把有意义的内容转换成没有意义的内容
*/
// 1. \s
const reg = /\s/ //等价于 / /
// 表示字符串里需要有一个空格字符
console.log(reg.test( 'abedefg')) // false
console.log(reg.test( 'abedefg ')) // true
console.log(reg.test( ' abedefg ')) // true
console.log(reg.test( 'a be de fg ')) // true
// 2. \S
const reg = /\S/
// 表示字符串里需要有一个 非空格 字符
console.log(reg.test( ' ')) // false
console.log(reg.test( 'a ')) // true
console.log(reg.test( ' g ')) // true
console.log(reg.test( 'a be de fg ')) // true
// 3. \t
const reg = /\t/
// 表示字符串里需要有一个 制表符
console.log(reg.test( ' ')) // 两个空格=> false
console.log(reg.test( ' ')) // 一个制表符=> true
// 4. \d
const reg = /\d/
// 表示字符串里需要有一个 数字
console.log(reg.test( '1adasd')) // => true
console.log(reg.test( ' asd a3')) // => true
// 5. \D
const reg = /\D/
// 表示字符串里需要有一个 非数字 字符
console.log(reg.test( '0123456789')) // => false
console.log(reg.test( ' asd a3')) // => true
// 6. \w
const reg = /\w/
// 表示字符串里需要有一个 数字 || 字母 || 下划线 都OK
console.log(reg.test( '@#￥@#￥@#￥@￥@#%￥#%')) // => false
console.log(reg.test( '@#￥a')) // => true
console.log(reg.test( '@#￥_1111')) // => true
// 7. \W
const reg = /\W/
// 表示字符串里需要有一个 数字 || 字母 || 下划线 以外的字符
console.log(reg.test( 'aasda___111')) // => false
console.log(reg.test( '@aadasd_')) // => true
console.log(reg.test( '65756%^1')) // => true
// 8. 点(.)
const reg = /./
// 表示字符串里需要有一个 非换行 内容
console.log(reg.test( '\n')) // => false
console.log(reg.test( 'a\nb')) // => true
console.log(reg.test( ' \n')) // => true
// 9. 斜线(\)
const reg = /s/
// 表示字符串里需要有一个 字母s
console.log(reg.test( 'abcd')) // => false
console.log(reg.test( 'a\ns')) // => true
const reg2 = /\s/
// 表示字符串里需要有一个 空格
console.log(reg2.test('asdasdasdsa')) // => false
const reg3 = /./
// 表示字符串里需要有一个 非换行 任意字符
const reg4 = /\./
// 表示字符串里需要有一个 点(.) 文本
2-2 边界元字符
/*
正则表达式的元字符 – 边界元字符
1. ^ 表示字符串开始
2. $ 表示字符串结束
*/
// 1. ^
const reg = /^\d/
// 表示字符串需要以一个数字开头
console.log(reg.test('asda12312sda')) // => false
console.log(reg.test('2asda12312sda')) // => true
// 2. $
const reg = /\d$/
// 表示字符串需要以一个数字结尾
console.log(reg.test('asda12312sda')) // => false
console.log(reg.test('2asda12312sda1')) // => true
const reg2 = /^\d$/
// 表示字符串从开头到结尾只能有一个数字
console.log(reg2.test('1w4')) // => false
console.log(reg2.test('1')) // => true
const reg3 = /^\d\d$/
// 表示字符串从开头到结尾只能有两个数字
2-3 限定元字符
/*
正则友达式的元字符 – 限定元字符
+ 写在普通元字符或者字母符号的后面
+ 修饰前面 **一个符号** 的出现次数
1. * 表示 0 ~ 多次
2. + 表示 1 ~ 多次
3. ? 表示 0 ~ 1 次
4. {n} 表示 n 次 只能修饰前边的一个符号或者字母
5. {n,} 表示 n ~ 多 次
=> {0,} 等价于 *
=> {1,} 等价于 +
6. {n,m} 表示 n ~ m 次
*/
// 1. *
const reg = /\d*/
// 表示字符串中需要有 0 ~ 多个 数字
console.log(reg.test('asdas12ds')) // => true
const reg = /^\d*$/
// 表示字符串中需要有数字开头结尾的 0 ~ 多个 数字
console.log(reg.test('asdas12ds')) // => false
console.log(reg.test('213asdas12ds')) // => false
console.log(reg.test('213423')) // => true
console.log(reg.test('')) // => true
// 2. +
const reg = /^\d+$/
// 表示字符串中需要有数字开头结尾的 1 ~ 多个 数字
console.log(reg.test('')) // => false
// 3. ?
const reg = /^\d?$/
// 表示字符串中需要有数字开头结尾的 0 ~ 1个 数字
console.log(reg.test('')) // => true
console.log(reg.test('12weq')) // => false
console.log(reg.test('1')) // => true
// 4. {n}
const reg = /^\d{3}$/
// 表示字符串必须由 3 个数字组成
console.log(reg.test('')) // => false
console.log(reg.test('5345')) // => false
console.log(reg.test('341')) // => true
// 5. {n,}
const reg = /^\d{3,}$/
// 表示字符串只能由 3 ~ 多个 数字组成
console.log(reg.test('')) // => false
console.log(reg.test('5345')) // => true
console.log(reg.test('341')) // => true
// 6. {n,m}
const reg = /^\d{3,6}$/
// 表示字符串只能由 3 ~ 6个 数字组成
console.log(reg.test('')) // => false
console.log(reg.test('5345')) // => true
console.log(reg.test('341123123')) // => false
2-4 正则的贪婪和非贪婪
/*
正则的贪婪和非贪婪
贪婪：
当你给一个符号使用限定符的时候
+ 在你插的时候,他会尽可能多的大捕内容
+ 我们管这个特性叫做正则的贪楼性
非贪婪：
+ 正则在捕获的时候尽可能的按照最小值来捕获
+ 写限定符的时候,在后面多加一个?
*/
// 贪婪
// 在捕获的时候会捕获能捕获到的最大长度， 就是 123456789
const reg = /\d+/
console.log(reg.exec('as123456789tyh'))
// 非贪婪
const reg2 =/d+?/
// +? 是一个限定符 非贪婪+
// 在捕获的时候会按照最少的数量来捕获
console.log(reg2.exec( 'abc123456789abce )
特殊字符
/*
正则友达式的元字符 – 特殊字符
1. ()
1-1. 一个整体
1-2. 单独捕获
=> 在捕获字符串的时候
=> 从左边开始每一个小括号依次是数组里面的 [1] 开始的内容
2. (?:)
=> 整体匹配但不捕获
=> 只是标志一个整体，但是捕获的时候不会单独捕获出来
3. |
=> 占位或
=> 表示左边或者右边的都行
=> 大部分时候和 () 连用，表示一个整体或者另一个整体
4. []
=> 注意： **一个 [] 占一个字符位置**
=> 表示里面的任意一个都行
5. [^]
=> 注意： **一个 [^] 占一个字符位置**
=> 表示非里面的任意一个都行
6. -
=> 表示 至 或者 到
=> 是使用在 [] 里面的一个符号
=> 表示从 哪一个字符 到 哪一个字符
=> 前提是他们在 ASCII 码中是连着的
组合形式
1. [0-9a-zA-Z_] 等价于 \w
2. [^0-9a-zA-Z_] 等价于 \W
3. [0-9] \d
4. [^0-9] \D
5. [ ] \s
6. [^ ] \S
特殊说明
=>当 点(.) 出现在 [] 或者 [^] 里时
=> 表示一个 点 文本
*/
// 1. ()
// 1-1. 一个整体
const reg = /abcd{2}/
// 表示 d出现两次
console.log(reg.test('abcdabcd'))
const reg2 = /(abcd){2}/
// 表示 abcd出现两次
console.log(reg2.test('abcdd'))
// 1-2. 单独捕获
const reg = /\d+\s+\d+/
console.log(reg.exec('123 123'))
// 返回值 [0]: '123 123'
const reg2 = /\d+(\s+)\d+/
console.log(reg2.test('123 123'))
//返回值 [0]: '123 123',[1]: ' '
const reg3 = /(\d+(\s+))\d+/
console.log(reg3.test('123 123'))
//返回值 [0]: '123 123',[1]: '123 ',[2]: ' '
// 2. (?:)
const reg = /\d+(?:\s+\d+){2}/
console.log(reg.exec('123 123 123'))
// 3. |
const reg = /(abc|def)/
console.log(reg.test('abc')) // true
console.log(reg.test('def')) // true
console.log(reg.test('qqq')) // false
// 4. []
const reg = /[abcd]/
// 表示字符串里有 a 或 b 或 c 或 d 任意一个就行
console.log(reg.test('srtjsgf')) // false
console.log(reg.test('srtjsgfa')) // true
console.log(reg.test('srtjsgfd')) // true
const reg2 = /^[abcd]$/
// 整个字符串只能由一个字符组成，可以是a b c d 中的任意一个
console.log(reg2.test('asda') // false
console.log(reg2.test('a') // true
console.log(reg2.test('d') // true
// 5. [^]
const reg = /^[^abcd]$/
// 表示一个字符串只能由一个字符组成，只要不是a b c d 其中一个就可以
console.log(reg2.test('asda')) // false
console.log(reg2.test('a')) // false
console.log(reg2.test('d')) // false
console.log(reg2.test('e')) // true
// 6. -
const reg = /^[0-9]$/
// 表示字符是由0到9的任意数字
console.log(reg.test('1')) // true
console.log(reg.test('2')) // true
console.log(reg.test('9')) // true
console.log(reg.test('a')) // false
// 小练习： 验证一个字符串，只能由数字字母下划线组成，6-12位，不能以_开头
const reg = /^[a-zA-Z0-9]\w{5,11}$/
// [a-zA-Z0-9] 开头已经占了一位 所以 \w 后是{5,11}
console.log(reg.test('1')) // false
console.log(reg.test('_arqwerdadad')) // false
console.log(reg.test('9as23wa23')) // true
console.log(reg.test('a1423erq')) // true
正则的预查
/*
正则表达式的预查
+ 正向预查
=> 正向肯定预查
->当我在捕获一个内容的时候，后面必须跟着是我选择的某一个才可以
-> (?=)
=> 正向否定预查
-> 当我捕获一个内容的时候，后面跟着的不是我选择的某一个
-> (?!)
+ 负向预查
=> 负向肯定预查
-> 当我在捕获一个内容的时候，前面是我选择的某一项
-> (?<=)
=> 负向否定预查
-> 当我在捕获一个内容的时候，前面不是我选择的某一项
-> (?<!)
*/
// 例子：
// 'ES2015 ES2016 ES2017 都是 Javascript 的语法标准'
// 正向肯定预查： 我要捕获 后面必须写着 2015 或者 2016 的ES
// 1. 正向肯定预查
const reg = /ES(?=2015|2016)/
// 预查的内容 (?=2015|2016) 是不占字符位置的
// 字符串是2015或者2016 是可以捕获的
// 但是我只捕获ES 不需要2015或2016
console.log(reg.test('ES2015')) // true
console.log(reg.test('ES2016')) // true
console.log(reg.test('ES2017')) // false
console.log(reg.exec('ES2017')) // null
// 2. 正向否定预查
const reg = /ES(?!2015|2016)/
console.log(reg.test('ES2015')) // false
console.log(reg.test('ES2016')) // false
console.log(reg.test('ES2017')) // true
// 3. 负向肯定预查
const reg = /(?<=2015|2016)ES/
console.log(reg.exec('2015ES')) // 0: 'ES
console.log(reg.exec('2016ES')) // 0: 'ES
console.log(reg.exec('2017ES')) // null
// 4. 负向否定预查
const reg = /(?<!2015|2016)ES/
console.log(reg.exec('2015ES')) // null
console.log(reg.exec('2016ES')) // 0: 'ES
console.log(reg.exec('2017ES')) // 0: 'ES
重复出现
/*
重复出现
1. /num
=> num 是一个正整数
=> num 是一个数字，表示的是正则第 num 个可被捕获的()
-> 这个可被捕获的
*/
待更新。。
扫一扫
1103
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
