JS详解对象篇-RegExp

创建

有两种方法，字面量和构造函数模式

字面量

  var reg=/\d+/g;
  console.log(reg.test("789456"));//true

构造函数

  var reg2=new RegExp("\\d+","g");
  console.log(reg2.test("1234444456"));//true
  console.log(reg2.test("asdsa"));//false

修饰符

可以记img，这样方便记住；

i 忽略大小写模式
m 多行匹配
g 全局模式

属性

实例属性
- global 布尔值，检测是走设置g标记
- ignoreCase 布尔值，检测是否设置i标记
- nultiline 布尔值，检测是否设置了m标记
- lastIndex 整数，表示开始搜索下一个匹配项的字符位置，从 0 算起。
- source 返回正则表达式的字符串表示,按照字面量形式而非传入构造函数中的字符串模式返回。

通过这些属性可以获知一个正则表达式的各方面信息，但却没有多大用处，因为这些信息全都包含在模式声明中

var pattern1 = /\[bc\]at/i;
console.log(pattern1.global); //false
console.log(pattern1.ignoreCase); //true
console.log(pattern1.multiline); //false
console.log(pattern1.lastIndex); //0
console.log(pattern1.source); //"\[bc\]at"
var pattern2 = new RegExp("\\[bc\\]at", "i");
console.log(pattern2.global); //false
console.log(pattern2.ignoreCase); //true
console.log(pattern2.multiline); //false
console.log(pattern2.lastIndex); //0
console.log(pattern2.source); //"\[bc\]at"

尽管第一个模式使用的是字面量，第二个模式使用了 RegExp 构造函数，但它们的source 属性是相同的。可见， source 属性保存的是规范形式的字符串，即字面量形式所用的字符串。

构造函数属性
- $_ input 返回最近一次匹配的字符串
- $& lastMatch 返回最近一次的匹配项
- $+ lastParen 返回最近一次匹配的捕获组
- $` leftContext 返回被查找的字符串中从字符串开始位置到最后匹配之前的位置之间的字符
- $' rightContext 返回被搜索的字符串中从最后一个匹配位置开始到字符串结尾之间的字符
- $* multiline 检测表达式是否采用多行匹配m

方法

实例方法
- test 在字符串中检测模式匹配，返回true或false
- exec 该方法是专门为捕获组而设计的
  - 功能：正则捕获的数据，一个数组；
  - 参数：要应用模式匹配的字符串
  - 特性：
    - 使用全局标记g；持续查找所有匹配项并返回
    - 不使用全局标记g；始终返回第一个匹配项信息
  - 执行的过程
    - 检测字符串参数，获取正则表达式匹配文本
    - 找到匹配文本则返回一个数组
      - 第0个元素：与整个模式匹配的字符串
      - 其他元素：与捕获组匹配的字符串
    - 否则返回null
  - 派生属性
    - index 匹配项在字符串中的位置
    - input 应用正则表达式的字符串
    - length 返回数组元素的个数

/a/i.test('AAaaA');
true
/a/i.exec('AAaaA');
["A", index: 0, input: "AAaaA", groups: undefined]

字符串方法
- match 找到一个或者多个正则表达式的匹配
- replace 替换与正则表达式匹配的子串
- search 检索与正则表达式匹配的值
- split 把字符串分割为字符串数组

'AAaaaA'.match('/a/i');
null
'AAaaaA'.match(/a/i);
["A", index: 0, input: "AAaaaA", groups: undefined]
'AAaaaA'.match(/a/ig);
(6) ["A", "A", "a", "a", "a", "A"]
'AAaaaA'.search(/a/ig);
0
'AAaaaA'.search(/a/ig);
0
'AAaaaA'.split(/a/ig);
(7) ["", "", "", "", "", "", ""]
'AAaaaA'.replace(/a/ig,'ok');
"okokokokokok"

元字符--重点

ps:以下是python语法，学正则模块做的笔记，但是重点学元字符的使用，换成JS语法一样的~~~

# -*- coding: UTF-8 -*- 
# RE 正则模块
import re

# 完全匹配
strs = 'sdnasldaslkda'
res = re.findall('as',strs)
print(res) # ['as', 'as']

# 模糊匹配

# 元字符
st1 = "abbsdadasacccacds"

# 以 a开头s结尾 中间两个任意字符的 字符（几个点就是几个字符）
print(re.findall('a..s',st1))  # ['abbs', 'adas']

# ^  表示只能从字符串的开头开始找 必须开头是a...
print(re.findall('^a..s',st1))  # ['abbs']


# $  表示只能从字符串的结尾结束 必须结尾是 ...s
print(re.findall('a..s$',st1))  # ['acds']

# \  表示 转义

# | 管道符   或





# 当大量重复的时候
# * 表示 0-无穷大   ==>  {0,}
# + 表示 1-无穷大   ==>  {1,}
# ? 表示 0-1       ==>  {o,1}
#
#  {}  区间 ---
#      {6,}  表示 6 到无穷
#  {6} 表示 重复 6次

st2 = "ddddddsdsadsalddddddddddasiiiowoqqdddddd"
print(re.findall('d*',st2)) # ['', 'd', '', '', 'd', '', '', '', 'dddddddddd', '', '', '', '', '', '', '', '', '', '', '']
print(re.findall('^d*',st2)) # ['dddddd']
print(re.findall('d*$',st2)) # ['dddddd', '']
print(re.findall('^d*$',st2)) # []

# 也叫贪婪匹配
print(re.findall('d+$',st2)) # ['dddddd']

st3 = 'asdasdsadaalexxxxx'
print(re.findall('alex+',st3))  # ['alexxxxx']

# 惰性匹配 加个 ？
print(re.findall('alex?',st3)) # ['alex']

print(re.findall('10{8}','1000000000')) # ['100000000']  结果是8位  字符串是9位  表名是匹配了 8个0


#  ****************重点********************

# []  字符集 存放后边可能匹配到的字符        在字符集里的特殊符号例如 * 就是普通字符了
# [] 里的功能字符
# -   例如 a-z  表示26个英文  0-9 表示数字  A-Z表示大写
# ^   例如： [^a-z] 表示匹配 a-z之外的字符
# \

st4 = 'xyzsdalksdkladaxym'
print(re.findall('xy[zam]',st4))  # ['xyz', 'xym']

st5 = '789a9asxzcaas'
print(re.findall('[a-z]',st5)) # ['a', 'a', 's', 'x', 'z', 'c', 'a', 'a', 's']
print(re.findall('[a-z]*',st5)) # ['', '', '', 'a', '', 'asxzcaas', '']
print(re.findall('[a-z]*?',st5)) # ['', '', '', '', 'a', '', '', 'a', '', 's', '', 'x', '', 'z', '', 'c', '', 'a', '', 'a', '', 's', '']

print(re.findall('[A-Z]',st5)) # []

print(re.findall('[0-9]a*',st5)) # ['7', '8', '9a', '9a']

print(re.findall('9[^a-z]',st5)) # []

# 匹配括号 (2-1)
cal = "12+3+(2+3+4*(2-1))"
print(re.findall('\([^()]*\)',cal))  # ['(2-1)']


# \ 关于反斜杠
# \d  ===>  0-9
# \D =====>  [^0-9]  表示非数字部分
# \s  ------  匹配任何空白字符   相当于  [\t\n\r\f\v]
# \S  -------  匹配任何非空白字符     [^\t\n\r\f\v]
# \w ------  匹配任何 字母 数字 字符   [a-zA-Z0-9]
# \W ------- 匹配任何非 数字 字母    [^a-zA-Z0-9]
# \b  ------  匹配特殊字符边界  如:  空格 & #

print(re.findall('[\d]','01')) # ['0', '1']  匹配0或1

# 对于空格
print(re.findall(r'n\b','hello n hanha'))  # ['n'] 加上r 表示普通字符
print(re.findall('n\\b','hello n hanha'))  # ['n'] 加上 \



#  |  ---- 或
print(re.findall('aa|b','aabbcc'))  # ['aa', 'b', 'b']


# 分组 （） 会先把分组的找出来  去掉优先级 ---- (?:
print(re.findall('(abc)+','abcabcbacbacbacbabcbacbac')) # ['abc', 'abc']

# 语法 --- '(?P<name>写自己想要匹配的字符)'  name的作用就是方便最后拿到分组的结果
print(re.findall('(?P<name>\d+)','ab99cc00ccc')) # ['99', '00']

# search 匹配成功返回对象   不成功也不会报错  而且只会返回一个结果
print(re.search('(?P<name>\w+)','abccccc'))
print(re.search('(?P<name>\d+)','abc9009hh55cccc').group())  # 拿到结果 9009

# 拿到分组name的值
print(re.search('(?P<name>[a-z]+)\d','abc9009hh55cccc').group('name'))  # 拿到结果 abc

# 补充:
print(re.findall('www\.(baidu|163)\.com','www.baidu.com')) # ['baidu']
# 去掉优先级
print(re.findall('www\.(?:baidu|163)\.com','www.baidu.com')) # ['www.baidu.com']



#  正则模块的方法
# findall()  略
# search()  略

# match 判断是否匹配成功 成功 .group方法返回 1  失败没有group方法 返回 None
print(re.match('\d','aa'))  #

# split 分割
print(re.split('\d','a1c2s'))  # ['a', 'c', 's']

# sub 替换
print(re.sub('\d+','A','qwsadad11111sdasda')) # qwsadadAsdasda 贪婪匹配11111替换成A
print(re.sub('\d','A','dasda99999sdad')) # dasdaAAAAAsdad  会匹配每个数字换成A
print(re.sub('\d','A','dasda99999sdad',2)) # dasdaAA999sdad  只会匹2个数字换成A

# sub 替换 并返回次数
print(re.subn('\d+','A','qwsadad11111sdasda'))  # ('qwsadadAsdasda', 1)  匹配了一个


# compile 匹配规则  然后可以调用正则的方法  好处在于可以多次利用
com = re.compile('\d')
print(com.findall('sdad333dada33')) # ['3', '3', '3', '3', '3']

# finditer 返回迭代器对象
print(re.finditer('\d','sdsada999sdad9ad9ad9a')) # <callable_iterator object at 0x105ea3898>

#拿到结果
its = re.finditer('\d','sdsada999sdad9ad9ad9a')
print(next(its).group()) #9
print(next(its).group())  #9
print(next(its).group())  #9
print(next(its).group()) #9

补充：

分组

(?:x) 匹配x但不记录匹配结果（匹配不捕获）
x(?=y) 当x后面接y时匹配x
x(?!y) 当x后不是y时匹配x

'AAaaaxAAAsikaA'.match(/x(?=AA)/g);
["x"]
'AAaaaxAAAsikaA'.match(/.(?=AA)/g);
(2) ["x", "A"]
'AAaaaxAAAsikaA'.match(/.(?:AA)/g);
["xAA"]
'AAaaaxAAAsikaA'.match(/.(?!AA)/g);
(12) ["A", "A", "a", "a", "a", "A", "A", "s", "i", "k", "a", "A"]

正则还是要多写多练的，看是比较模糊的~~

posted on 2019-01-28 11:33 Alpha_qiu 阅读(1994) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

导航

JS详解对象篇-RegExp

创建

修饰符

属性

方法

元字符--重点