grep vivek /etc/passwd

vivek:x:1000:1000:Vivek Gite,,,:/home/vivek:/bin/bash
vivekgite:x:1001:1001::/home/vivekgite:/bin/sh
gitevivek:x:1002:1002::/home/gitevivek:/bin/sh

grep -i -w vivek /etc/passwd

grep -E -i -w 'vivek|raj' /etc/passwd

grep ^vivek /etc/passwd

vivek:x:1000:1000:Vivek Gite,,,:/home/vivek:/bin/bash
vivekgite:x:1001:1001::/home/vivekgite:/bin/sh

grep -w ^vivek /etc/passwd

grep 'foo

你还可以用下面这样的方式搜索空白行：

grep '^

(1) 正则表达式

【是什么】：特殊的序列。检测字符串是否与序列匹配。

【有什么作用】：实现快速检索文本，或实现替换文本的操作。

实战：查看字符串是否包含python

• findal查找全部
• re.findall(需要匹配的内容, 查找的字符串)

a = "C|Java|C#|python|PHP|JS"
# 方法一
print(a.index("python"))
# 方法二
import re
r = re.findall("python", a)
if len(r) != 0:
    print("字符串中包含python")

输出：
10
字符串中包含python

(2) 元字符与普通字符

实战：在字符串中把所有的数字提取出来

• ‘python’ 是普通字符
• ‘\d’ 是元字符，表示数字：0-9 ,代表一定的意义
• '\D' 表示‘\d’的相反，不是0-9

a = "C123Java321C#455python1321PHP1243JS"

import re
r = re.findall("\d", a)
print(r)

r = re.findall("\D", a)
print(r)

输出：
['1', '2', '3', '3', '2', '1', '4', '5', '5', '1', '3', '2', '1', '1', '2', '4', '3']
['C', 'J', 'a', 'v', 'a', 'C', '#', 'p', 'y', 't', 'h', 'o', 'n', 'P', 'H', 'P', 'J', 'S']

(3) 字符集

实战：查找中间单词是 c,或者 f 的字符集

• [] 可以抽象字符集，可以抽象c或者f，借助普通字符a和c来进行定界
• ^ 表示否的意思
• – 表示顺序,匹配 a 到 f 的字符

import re
a = "abc,acc,afc,adc,arc"
r1 = re.findall("a[cf]c", a)
r2 = re.findall("a[^cf]c", a)
r3 = re.findall("a[c-f]c", a)
print(r1)
print(r2)
print(r3)

输出：
['acc', 'afc']
['abc', 'adc', 'arc']
['acc', 'afc', 'adc']

(4) 元字符还有什么

\w ： 表示字母 a-z、A-Z 和数字0-9 和 _

import re
a = "a [email protected]!arc_"
r1 = re.findall("\w", a)
r2 = re.findall("\W", a)
print(r1)
print(r2)

输出：
['a', 'b', 'c', 'a', 'c', 'c', 'a', 'f', 'c', 'a', 'd', 'c', 'a', 'r', 'c', '_']
[' ', '!', '#39;, '@', '!']

\s ： 表示空白字符

import re
a = "a [email protected]!arc_"
r1 = re.findall("\s", a)
r2 = re.findall("\S", a)
print(r1)
print(r2)

输出：
[' ']
['a', 'b', 'c', '!', 'a', 'c', 'c', '#39;, 'a', 'f', 'c', '@', 'a', 'd', 'c', '!', 'a', 'r', 'c', '_']

. ：表示除换行符之外的所有字符

(5) 数量词

实战：把python匹配出来

• 表示重复的字符集，可以用数字表示
• {} 里面写的数字，表示重复几次

import re
a = "c123java321C#455python1321php1243JS"
r1 = re.findall("[a-z][a-z][a-z][a-z][a-z][a-z]", a)
r2 = re.findall("[a-z]{6}", a)
print(r1)
print(r2)

输出：
['python']
['python']

实战：把 python，java，php 匹配出来

• {} 里面写的数字，可以写有多少到多少的数字

import re
a = "c123java321C#455python1321php1243JS"
r1 = re.findall("[a-z]{3,6}", a)
print(r1)

输出：
['java', 'python', 'php']

(6) 贪婪与非贪婪

默认情况，python是贪婪模式，匹配最多的合适的数量。

？ ：在数字范围后表示非贪婪

实战： 获取3个字母

import re
a = "c123java321C#455python1321php1243JS"
r1 = re.findall("[a-z]{3,6}?", a)
r2 = re.findall("[a-z]{3}", a)
print(r1)
print(r2)

输出：
['jav', 'pyt', 'hon', 'php']
['jav', 'pyt', 'hon', 'php']

(7) 匹配0次1次或者无限多次

*表示匹配前面的字符0次或者多次

+表示匹配前面的字符1次或者多次

？表示匹配前面的字符0次或者1次，可以做去除的操作

import re
a = "pytho0python1pythonn2pythonnn333"
r1 = re.findall("python*", a)
r2 = re.findall("python+", a)
r3 = re.findall("python?", a)
r4 = re.findall("python{1,3}?", a) # 表示非贪婪模式
print(r1)
print(r2)
print(r3)
print(r4)
输出：
['pytho', 'python', 'pythonn', 'pythonnn']
['python', 'pythonn', 'pythonnn']
['pytho', 'python', 'python', 'python']
['python', 'python', 'python']

(8) 边界匹配符

实战： 验证位数是否符合

• ^ 表示从字符串前面开始匹配
• $ 表示从字符串后面开始匹配

import re
a = "100086"
r1 = re.findall("\d{3,5}", a)
r2 = re.findall("^\d{3,5}#34;, a)
print(r1)
print(r2)

输出：
['10008']
[]

import re
a = "100086"
r1 = re.findall("086#34;, a)
r2 = re.findall("^1000", a)
r3 = re.findall("000#34;, a)
r4 = re.findall("^000", a)
print(r1)
print(r2)
print(r3)
print(r4)

输出：
['086']
['1000']
[]
[]

(9) 组

判断字符串中是否包含 2个python

• python{3} : 表示单个n重复3次
• () :表示组，可以有多个组
• (python){3}表示一组的单词，重复3次
• [] 是或者的关系，（）是且的关系

import re
a = "pythonpython2pythonpython2nvvpythonpythonn"
r1 = re.findall("(python){2}", a)
r2 =  re.findall("(python){2}(2)", a)
print(r1)
print(r2)

输出：
['python', 'python', 'python']
[('python', '2'), ('python', '2')]

(10) 匹配模式参数

flags=re.I ： 表示不区分大小写

| ： 连接多个模式，且

import re
a = "pc#ythonpython2pythonpython2nvvpythonpythonn"
r1 = re.findall("C#", a,flags=re.I) 
print(r1)

输出：
['c#']

re.S ： 表示 .匹配所有字符，包括换行符

import re
a = "pc#\nythonpython2pythonpython2nvvpythonpythonn"
r1 = re.findall("C#.{1}", a, flags=re.I | re.S)
print(r1)

输出：
['c#\n']

(11) re.sub正则替换

re.sub("正则匹配规则"，“需要换成的字符串”，“查找的字符串”，count=0，flag)

实战 ： c# 换成 python

import re
a = "c#phpc#javac#"
r1 = re.sub("c#", "python", a)

输出:
pythonphppythonjavapython

count=0 ：默认是0，所能被替换的最大选项

import re
a = "c#phpc#javac#"
r1 = re.sub("c#", "python", a,count=1)

输出:
pythonphpc#javac#

内置函数 replace 同样可以实现替换

a = "c#phpc#javac#"
print(a.replace("c#", "python"))
输出:
pythonphppythonjavapython

(12) 把函数作为参数传递

sub第二个参数，可以接收函数。

根据不同的匹配结果做不同的操作。

import re
def conver(value):
    print(value)
    matched = value.group()
    print(matched)
    return "111" + matched + "111"
a = "c#phpc#javac#"
r1 = re.sub("c#", conver, a)
print(r1)

输出:
<re.Match object; span=(0, 2), match='c#'>
c#
<re.Match object; span=(5, 7), match='c#'>
c#
<re.Match object; span=(11, 13), match='c#'>
c#
111c#111php111c#111java111c#111

实战：匹配字符串，数字大于60变成9，否则变成0

import re
def conver(value):
    matched = value.group()
    if int(matched) >= 60:
        return "9"
    else:
        return "0"
a = "ABC123987456DE"
r1 = re.sub("\d{2}", conver, a)
print(r1)

输出:
ABC00906DE

(13) search与match函数

• 搜索到了一个，就停止搜索
• 返回结果都是组
• match 从字符串首字母开始匹配
• search 搜索字符串，直到找到满足条件的字符串

a = "1490ABC123987456DE"
r1 = re.match("\d", a)  #从字符串首字母开始匹配 
print(r1.group())
r2 = re.search("\d", a)  #搜索字符串，直到找到满足条件的字符串
print(r2.group())
print(r2.span())  # 返回位置

输出:
1
1
(0, 1)

(14) group分组

实战：获取 A 和 E 中间的字符

0 是默认取值 ，获取完整匹配结果。

a = "A 14956 63E234234E"
r1 = re.match("A(.*)E", a)
print(r1.group(1))   1 是第一个组

r1 = re.match("A(.*)E(.*)E", a)  # 可以有很多个组
print(r1.group(0, 1, 2))

print(r1.groups())  # 把匹配到的内容输出

print(re.findall("A(.*)E(.*)E", a))

输出:
 14956 63E234234
('A 14956 63E234234E', ' 14956 63', '234234')
(' 14956 63', '234234')
[(' 14956 63', '234234')]

(15) JSON

【Json】 是一种轻量级的数据交换格式。

【JSON字符串】：符合json格式的字符串

• 字符串是json的一种表现形式。

【优势】：易于阅读，解析，网络传输效率高。跨语言交换数据。

(16)序列化与反序列化

【反序列化】json.loads()

json字符串需要用双引号。

实战：json字符串转换python的字典

import json
j_str = '{"name":"CiCi","age":18}'
print(type(json.loads(j_str)))

输出：
<class 'dict'>

json字符串的 true 和 false是小写开头的。

json字符串的 null 是 None。

import json

j_str = '[{"name":"CiCi","flag":true},{"name":"CiCi","flag":false}]' 
print(json.loads(j_str))

输出：[{'name': 'CiCi', 'flag': True}, {'name': 'CiCi', 'flag': False}]

【序列化】json.dumps()

import json
dict_p = {"name": "CiCi", "flag": True}
print(json.dumps(dict_p))

输出：{"name": "CiCi", "flag": true}

作为一名程序员，不会写正则表达式总感觉少了点什么，不要求你能把正则玩出花来，但最起码要对常用的正则表达式手到擒来，刚毕业的我对于正则也是一头雾水，不过学会它也就一篇教程的事情[1]

本文我不会再浪费带宽把正则的规则再次重复一遍，而是从实际入手，直接告诉你为什么这么写

16进制颜色

按照规则来

1. 以 # 开头
2. 后面紧跟着6个字符或者3个字符作为结尾，这些字符可以是 a-f 的小写字母、A-F的大写字母、数字

第一句，可以写成 /^#/；第二句，[a-fA-F0-9] 表示任意的 a-f、A-F、0-9，6或 3的个数可以用 {6}、{3}进行表示，那么3个字符就是 [a-fA-F0-9]{3}，6个字符就是 [a-fA-F0-9]{6}，这两个都有可能，用一个或(|)符号来连接：([a-fA-F0-9]{6}|[a-fA-F0-9]{3})，最后结尾可以用个 $

所有合到一起就是 /^#([a-fA-F0-9]{6}|[a-fA-F0-9]{3})$/

链接

目标是匹配出协议、域名、端口号port、path、search

1. 协议

合法的协议有 http、https，还有一个是自适应协议，即不明确加协议，跟当前页面的协议保持一致，所以以下都是合法的：http://toutiao.com、https://toutiao.com、//toutiao.com。这三个协议组成的链接共同点是肯定有 // 字符串，在 //的前面可能是 https: 也可能是 http: 也可以没有任何字符串 先按照 https:// 这种写规则：^https:\/\/，其中的 s 字符可能有也可能没有，所以使用 ? 修饰：^https?:\/\/，又因为 https?:可能没有，所以这个字符串也用 ?修饰：^(https?:)?\/\/

2. 域名

域名的前面可能是 //，从 //往后面匹配，只要没有代表 :的 port、代表 search 的 ?、代表 path的 /，那么就都属于域名：[^?:/]+

3. 端口号 port

端口号肯定以 : 开头，后面跟着的只要是数字就都属于 port：:\d+，由于不一定有端口号，所以用 ? 修饰：(:\d+)?

4. path

肯定以 / 开头，只要不遇到代表 search 的 ?，那么就都属于 path：\/[^?]*，由于可能没有 path，所以用 ? 修饰：(\/[^?]*)? 5. search 肯定以 ? 开头，后面所有的字符都属于 search（不考虑 hash 路由）：\?(.*)，由于可能没有 search，所以用 ? 修饰：(\?.*)?

最后把上面所有规则合起来就是提取链接的完整正则了，考虑到需要精确提取所需要的部分，所以会对所需要提取的部分加上小括号，结果为：/^((https?):)?\/\/([^?:/]+)(:(\d+))?(\/[^?]*)?(\?(.*))?/

邮箱

以前在知乎上看到过一段邮箱正则，号称是最符合标准的正则表达式，那条正则的体积好像有几十KB吧，总之很长，现在找不到了，这里只关注常用的邮箱格式，规则：名称允许汉字、字母、数字，下划线，中划线，域名可以有数字、字母、下划线、中划线组成

汉字的范围是 [\u4e00-\u9fa5]，字母的范围是 [a-zA-Z]，数字的范围是 [0-9]，合起来组成邮箱的名称 ^[A-Za-z0-9-_\u4e00-\u9fa5]+

域名是 [a-zA-Z0-9_-]+，域名后缀可以是多级域名 (\.[a-zA-Z0-9_-]+)+

上面组合起来就是 ^[A-Za-z0-9-_\u4e00-\u9fa5][email protected][a-zA-Z0-9_-]+(\.[a-zA-Z0-9_-]+)+$

手机号

手机号的号段可能是会增加的，所以在实际场景中不建议限制得太死了

本正则按照以下规则编写：

1. 11位数字，以数字 1 开头，即 ^1
2. 接下来的数字如果是 3，那么 3后面可以跟一个任意数字，即 3\d；如果是 4，那么 4后面可以跟一个5-9之间的数字，即 4[5-9]；如果是 5，那么 5后面可以跟一个0-3或5-9之间的数字，即 5[0-35-9]；如果是 6，那么 6后面可以跟 2、5、6、7 其中一个数字，即 6[2567]；如果是 7，那么 7后面可以跟一个0-8之间的数字，即 7[0-8]；如果是 8，那么 8后面可以跟一个任意数字，即 8\d；如果是 9，那么 9后面可以跟一个0-3或5-9之间的数字，即 9[0-35-9]
3. 最后 8位可以是任意数字

上述三步合起来就是 /^1(3\d|4[5-9]|5[0-35-9]|6[2567]|7[0-8]|8\d|9[0-35-9])\d{8}$/

数字/货币金额

1. 支持负数

负号用 –负号，且必须在第一位，即 ^-，再加个 ? 用于表示这个负号可以有也可以没有，即 ^-? 2. 支持千分位分隔（没有也没关系） 如果有千分位，则千分位的后面必然跟着三位数字（否则这个千分号就不应该加了），千分位前面最少一位、最多三位数字，那么可以写成 \d{1,3},\d{3}，再精简下，千分位前面的数字其实可以不用限制，因为只要超过三位肯定就有千分位，就会被 \d{3}捕获，所以 \d{1,3}换成 \d+就行了，因为符合千分位的可以有多个也可能没有，所以写成 \d+(,\d{3})* 3. 如果有小数，则小数点后最多两位 小数点就是 \.，后面跟着最多两位数字 \d{1,2}，可能有小数也可能没有，所以整体需要再加个 ? 符号，即 (\.\d{1,2})?

最终规则 /^-?\d+(,\d{3})*(\.\d{1,2})?$/

身份证号

这里只看 2代身份证，18位数字 最后一位是校验位,可能为数字或字符X

1. 第一位数字在 [1-9] 闭区间内，后面紧跟着5位任意数字，写成 ^[1-9]\d{5}
2. 再紧跟着的四位数字代表年份（YYYY），因为目前有身份证的人最早是19世纪最晚21世纪，所以这四个数字中的前两位只看是 18、19、20，即 (18|19|20)，后两位则可以是任意数字，即 \d{2}
3. 再紧跟着两位数字是月(MM)，月份只可能是 [1-12]闭区间，所以可以写成 (01|02|03|04|05|06|07|08|09|10|11|12)，前九位的开头都是 0，第二位是 [1-9] 内的数字，所以简化成 (0[1-9]|10|11|12)
4. 再紧跟着两位数字是日(DD)，范围是 [01-31]，可以将这31个数字罗列出来，当然也可以精简下，看成是 [00-09]、[10-29]、[30-31]的组合，即 (0[1-9]|[1-2]\d|30|31)
5. 再紧跟着三位数字是顺序码，即 \d{3}
6. 最后一位是校验码，可以是数字也可以是 X，即 [\dX]

最终规则 /^[1-9]\d{5}(18|19|20)\d{2}(0[1-9]|10|11|12)(0[1-9]|[1-2]\d|30|31)\d{3}[\dX]$/

密码校验

最少6位，包括至少1个大写字母，1个小写字母，1个数字，1个特殊字符

对于 至少1个大写字母 这条规则，这个大写字母的位置是不固定的，只要有就行，如果只有这一条规则的话，正则可以写成 ^\S*[A-Z]+\S*$，\S 匹配任意非空白字符，这个规则即代表大写字母的前面、后面可以跟着任意个（包括0个）非空白字符

但除此之外还需要满足最少1个小写字母，1个数字，1个特殊字符，最少6位，你可以将这几条规则都单独写出正则，然后目标字符串跟这5条正则一一匹配，只要全部能匹配上就是对的，写成 js 代码就是：

function match(s: string) {
  return /^\S*[A-Z]+\S*$/.test(s)
    && /^\S*[a-z]+\S*$/.test(s)
    && /^\S*[0-9]+\S*$/.test(s)
    && /^\S*[[email protected]#$%^&*?]+\S*$/.test(s)
    && /^\S*\S{6,}\S*$/.test(s)
}
复制代码

如果就想在一条正则里实现这些校验呢，也是可以的，需要借助 零宽度正预测先行断言 （(?=exp)），代表 匹配exp前面的位置

有了这个东西，就可以把上面5条规则写到一起去了：/^\S*(?=\S{6,})(?=\S*\d)(?=\S*[A-Z])(?=\S*[a-z])(?=\S*[[email protected]#$%^&*?])\S*$/

这条正则前面后面的 \S* 还是之前的意思不变，中间是提取了5条规则的个性部分，然后通过 ?= 放在一起了，把规则里所有的 ?=去掉行不行？不行，因为如果去掉的话，首先就有顺序上的冲突了，例如上面的规则，如果把所有的 ?=去掉，就代表着 数字必须在大写字母前面，大写字母必须在小写字母前面，特殊字母必须在小写字母前面（除此之外整个正则也是有问题的）

你可以认为 ?= 在匹配的时候会忽略掉其他的 ?=，只关心自己的前面能不能匹配成功，有多个 ?=，则这多个 ?= 都是只关心自己，忽略其他，但整条正则最后的结果是所有 ?= 匹配结果的并集，计算逻辑和上面的 js 是差不多的

提取 HTML 标签数据

要提取的标签字符串类似于 <div class="header-box" name="header">

只是正则话无法完成，需要借助 js

首先，把标签的属性提取出来

这段标签包含标签开始符号、tag、属性字符串、标签结束符号

开始符号是 <，标签名紧跟着开始符号，且只要没遇到空白符就都是标签名，所以连起来就是 <\w+\s*

在开始符号+标签名，和 结束符号的中间，都是属性，结束符号是 >，所以只要没遇到结束符号 >，就认为是属性字符串，用到了反向选择 [^>]*\s*>，合起来就是 /<\w+\s*[^>]*\s*>/，为了能捕获属性字符串，加个小括号，即 /<\w+\s*([^>]*)\s*>/

const str = `<div class="header-box" name="header">`
const mt = str.match(/<\w+\s*([^>]*)\s*>/)
// properties 即 属性字符串，即 class="header-box" name="header"
const properties = mt[1]
复制代码

取到了 class="header-box" name="header" 之后，再对其进行处理，观察规律，每个属性的键值对之间肯定存在空白符，不过却不能通过空白符来直接分割，因为属性值是可以存在空白符的，例如 class="a b"

由于可能是自闭合标签，自闭合标签的最后有没有 / 都是合法的，例如 <hr> 和 hr />都是合法的，所以需要兼容下：/<\w+\s*([^>]*)\s*\/?>/

但属性名是可以确定的，它可能是 = 左边不包括空白符的内容，再次用到反向选择，从左往右匹配，反向选择既不是=也不是不是空白符的内容，即 [^\s=]+

虽然不确定属性值是否包含空白符，但有个是确定的，即属性值必然被引号包围，所以直接取 = 右侧所有引号的内容即可，=".*?"

不过还有个问题，引号不仅可以是单引号还可以是双引号，即 =".*?" 和 ='.*?' 都行，如果第一个引号是双引号开头那么对应的第二个引号也必然是双引号，反义单引号亦然，这里需要用到捕获的规则了 =(["']).*?\1，\1的意思是这块匹配的内容跟第一捕获组一样，第一捕获组也就是 ["']，如果第一捕获组匹配的是双引号，那么 \1 就代表双引号，否则就代表单引号

至此整个正则为 [^\s=]+=(["']).*?\1

不过还有个问题，属性是可以没有属性值的，例如 <input type="checkbox" checked />，这里 checked 就是可以不写属性值的，所以再兼容下：/[^\s=]+(=(["']).*?\2)?/，又因为希望捕捉属性和属性值，所以给属性和属性值加个小括号：/([^\s=]+)(=(["'])(.*?)\3)?/

上面的代表就可以继续写了

const str = `<div class="header-box" name="header">`
const mt = str.match(/<\w+\s*([^>]*)\s*>/)
// properties 即 属性字符串，即 class="header-box" name="header"
const properties = mt[1]
const mt1 = properties.match(/([^\s=]+)(=(["'])(.*?)\3)?/g)
const obj = {}
if (mt1) {
  mt1.forEach(p => {
    const kv = p.trim().split('=')
    obj[kv[0].trim()] = kv[1].trim().slice(1, -1)
  })
}
// obj => { class: 'header-box', name: 'header' }
复制代码

小结

学会正则的最接途径就是勤加练习，平时遇到可以用正则解决的问题，就尝试着正则解决，或许你一开始写不出来，但可以去网上看看别人是怎么写的，再自己独立写一遍，写得多了自然就会了，没什么诀窍，无非就是对正则规则的熟练掌握罢了

关于本文

来自：清夜

https://juejin.cn/post/7073360739410378760

• 1. 正则表达式分类
• 2. 基本正则表达式
• 3. 扩展正则表达式

1. 正则表达式分类

正则表达式：REGEXP，REGular EXPression。
正则表达式分为两类：

• Basic REGEXP（基本正则表达式）
• Extended REGEXP（扩展正则表达式）

2. 基本正则表达式

//元字符

. //任意单个字符

[] //匹配指定范围内的任意单个字符

[^] //匹配指定范围外的任意单个字符//匹配次数（贪婪模式）

* //匹配其前面的任意单个字符任意次

.* //任意长度的任意字符

\? //匹配其前面的任意单个字符1次或0次

\+ //匹配其前面的任意单个字符至少1次

\{m,n\} //匹配其前面的任意单个字符至少m次，至多n次//位置锚定

^ //锚定行首，此字符后面的任意单个字符必须出现在行首

$ //锚定行尾，此字符前面的任意单个字符必须出现在行尾

^$ //空白行

\<或\b //锚定词首，其后面的任意单个字符必须作为单词首部出现

\>或\b //锚定词尾，其前面的任意单个字符必须作为单词尾部出现

/分组

\(\)

例：\(ab\)*

//后向引用

\1 //引用第一个左括号以及与之对应的右括号所包括的所有内容

\2 //引用第二个左括号以及与之对应的右括号所包括的所有内容

3. 扩展正则表达式

//字符匹配

. //匹配任意单个字符

[] //匹配指定范围内的任意单个字符

[^] //匹配指定范围外的任意单个字符//次数匹配

* //匹配其前面的任意单个字符任意次

? //匹配其前面的任意单个字符1次或0次

+ //匹配其前面的任意单个字符至少1次

{m,n} //匹配其前面的任意单个字符至少m次，至多n次

//位置锚定

^ //锚定行首，此字符后面的任意单个字符必须出现在行首

$ //锚定行尾，此字符前面的任意单个字符必须出现在行尾

^$ //空白行

\<或\b //锚定词首，其后面的任意单个字符必须作为单词首部出现

\>或\b //锚定词尾，其前面的任意单个字符必须作为单词尾部出现//分组

() //分组

\1，\2，\3，….

例：(ab)*

//后向引用

\1 //引用第一个左括号以及与之对应的右括号所包括的所有内容

\2 //引用第二个左括号以及与之对应的右括号所包括的所有内容//或者

| //or 默认匹配｜的整个左侧或者整个右侧的内容

//例：C|cat表示C或者cat，要想表示Cat或者cat则需要使用分组，如(C|c)at

概述

?正则表达式是强大、便捷、高效的文本处理工具。

?正则表达式能够添加、删除、分离、叠加、插入和修改各种类型的文本和数据。

?使用正则表达式节省下来的时间或许并不能让人很激动，但总比把时间消耗在文本编辑器中要好

?正则表达式由元字符和文字组成，元字符指的是*、+、^等字符，文字指的是字母、数字等字符；元符通常用来描述文本。

元字符-匹配单个字符的元字符

注：在字符组内部（并且不在第一个位置和最后一个位置），

‘-’连字符作为元字符表示一个范围，如[a-z]；如果不在字符组内部，

连字符代表普通字符。

元字符-提供计数功能的元字符

元字符-匹配位置的元字符

元字符-其它元字符

各种量词

?匹配优先量词

*、+、？、{min,max}

用ab*c去匹配abcde，肯定会匹配abc

?忽略优先量词

*?、+?、??、{min,max}?

用ab*?c去匹配acde肯定会匹配ac,不会返回什么都没匹配

?占有优先量词

*+、++、?+、{min,max}+

用(.*+)([0-9]+)去匹配aaaaa1，什么也匹配不到，一旦占有不再交还，目前只有java和php有

捕获分组和反向引用

?捕获分组：将某些规律看成是一组，然后进行组级别的重复，可以得到意想不到的效果，正则表达式中分组用()表示，不参与捕获分组又要使用括号用(?:)表示。

?反向引用：反向应用实际上应用的是正则表达式所匹配的文本值，而不是正则表达式字面值。

捕获分组和反向引用-示例1

文本样本（从中抽取出ip信息）：
:10.153.135.53:8611:4::
:10.153.110.123:8611:1::
:10.15.242.66:8611:4::
:10.15.242.65:8611:4::
:10.153.110.120:8611:1::
:10.153.110.122:8611:1::
:10.153.110.121:8611:1::
正则表达式：:([0-9.]+):([0-9]+):(.+)

捕获分组和反向引用-示例2

文本样本（为图片相对路径增加绝对路径）：
<html>
<body>
	<div>12321321</div>
	<img src="/tv/pic/1.jpg"></img>
	<img src="/tv/pic/2.jpg"></img>
	<div>lasjdfljsadfpofdsahdsaf</div>
	<img src="/tv/pic/3.jpg"></img>
	<img src="/tv/pic/4.jpg"></img>
	<div>pwqipqpwepqweo;sdkf</div>
	<img src="/tv/pic/5.jpg"></img>
</body>
</html>
正则表达式：<img\s+src="([0-9a-z/.]+)">
替换为：<img src="http://www.pic0.baidu.com\1">

捕获分组和反向引用-示例3

正则表达式：([a-z]+)\s+\1
替换为：\1

If – then -else

正则表达式中的if-else结构用(?(condition)(reg1)|(reg2))
举例（匹配img标签）：
<div>
<img src="123">
</div>

正则表达式：(<div>\s*)?(<img\s+[^>]+>)(?(1)\s*</div>)

环视

环视不匹配任何字符，只匹配文本中的特定位置。

环视-肯定顺序示例

提取特征数据
样本示例:
1234.txt
456.java
abc.cpp
9876.java
正则表达式  .+(?=\.java) 

环视-格式化数字

样本示例（每三位逗号分隔数字）:
1234567890
12345
6789056
456823

正则表达式：(?<=\d)(?=(\d{3})+$)

固化分组

固化分组使用(?>…)实现，固化分组匹配与正常的匹配并无差别，但是如果匹配进行到此结构之后（也就是，进行到闭括号之后），那么此结构体中的所有备用状态都会被放弃（不能被回溯）。
处理数字小数点，保留三位小数，第三位不能为零。
样本：
123123.456000000
12345.670000
1234789.78
134.500000

正则表达式：(\.\d\d(?>[1-9]?))\d+     替换:\1

REGEXP： Regular Expressions，由一类特殊字符及文本字符所编写的模式，其中有些字符（元字符） 不表示字符字面意义，而表示控制或通配的功能，类似于增强版的通配符功能

正则表达式被很多程序和开发语言所广泛支持：vim, less,grep,sed,awk, nginx,mysql 等

正则表达式分两类：

• 基本正则表达式：BRE
• 扩展正则表达式：ERE

正则表达式引擎：

采用不同算法，检查处理正则表达式的软件模块，如：PCRE（Perl Compatible Regular Expressions）

正则表达式的元字符分类：字符匹配、匹配次数、位置锚定、分组

帮助：man 7 regex

基本正则表达式元字符

1、字符匹配

.   匹配任意单个字符
[]   匹配指定范围内的任意单个字符，示例：[wang]   [0-9]   [a-z]   [a-zA-Z]
[^] 匹配指定范围外的任意单个字符,示例：[^wang] 
[:alnum:] 字母和数字
[:alpha:] 代表任何英文大小写字符，亦即 A-Z, a-z
[:lower:] 小写字母,示例:[[:lower:]],相当于[a-z]
[:upper:] 大写字母
[:blank:] 空白字符（空格和制表符）
[:space:] 水平和垂直的空白字符（比[:blank:]包含的范围广）
[:cntrl:] 不可打印的控制字符（退格、删除、警铃...）
[:digit:] 十进制数字
[:xdigit:]十六进制数字
[:graph:] 可打印的非空白字符
[:print:] 可打印字符
[:punct:] 标点符号

范例：

[[email protected] ~]#ls /etc/ | grep 'rc[.0-6]'
rc0.d
rc1.d
rc2.d
rc3.d
rc4.d
rc5.d
rc6.d
rc.d
rc.local
[[email protected] ~]#ls /etc/ | grep 'rc[.0-6].'
rc0.d
rc1.d
rc2.d
rc3.d
rc4.d
rc5.d
rc6.d
rc.d
rc.local
[[email protected] ~]#ls /etc/ | grep 'rc[.0-6]\.'
rc0.d
rc1.d
rc2.d
rc3.d
rc4.d
rc5.d
rc6.d

2、匹配次数

用在要指定次数的字符后面，用于指定前面的字符要出现的次数

* 匹配前面的字符任意次，包括0次，贪婪模式：尽可能长的匹配
.* 任意长度的任意字符
\? 匹配其前面的字符0或1次,即:可有可无
\+ 匹配其前面的字符至少1次,即:肯定有
\{n\} 匹配前面的字符n次
\{m,n\} 匹配前面的字符至少m次，至多n次
\{,n\} 匹配前面的字符至多n次
\{n,\} 匹配前面的字符至少n次

范例：

[[email protected] ~]#echo /etc/ |grep -E "/etc/?"
/etc/
[[email protected] ~]#echo /etc |grep -E "/etc/?"
/etc

3、位置锚定

^ 行首锚定，用于模式的最左侧
$ 行尾锚定，用于模式的最右侧
^PATTERN$ 用于模式匹配整行
^$ 空行
^[[:space:]]*$ 空白行
\< 或 \b 词首锚定，用于单词模式的左侧
\> 或 \b 词尾锚定，用于单词模式的右侧
\<PATTERN\> 匹配整个单词

4、分组其它

分组：() 将一个或多个字符捆绑在一起，当作一个整体处理，如：\(root\)+

分组括号中的模式匹配到的内容会被正则表达式引擎记录于内部的变量中，这些变量的命名方式为: \1, \2, \3, …

\1 表示从左侧起第一个左括号以及与之匹配右括号之间的模式所匹配到的字符

示例：

\(string1\(string2\)\)
\1 ：string1\(string2\)
\2 ：string2

后向引用：引用前面的分组括号中的模式所匹配字符，而非模式本身

或者：\|

示例：

a\|b #a或b  
C\|cat #C或cat   
\(C\|c\)at #Cat或cat

正则表达式练习

1. 显示/proc/meminfo文件中以大小s开头的行(要求：使用两种方法)
2. 显示/etc/passwd文件中不以/bin/bash结尾的行
3. 显示用户rpc默认的shell程序
4. 找出/etc/passwd中的两位或三位数
5. 显示CentOS7的/etc/grub2.cfg文件中，至少以一个空白字符开头的且后面有非空白字符的行
6. 找出“netstat -tan”命令结果中以LISTEN后跟任意多个空白字符结尾的行
7. 显示CentOS7上所有UID小于1000以内的用户名和UID
8. 添加用户bash、testbash、basher、sh、nologin(其shell为/sbin/nologin),找出/etc/passwd用户 名和shell同名的行
9. 利用df和grep，取出磁盘各分区利用率，并从大到小排序

扩展正则表达式

1、字符匹配元字符

. 任意单个字符
[wang] 指定范围的字符
[^wang] 不在指定范围的字符
[:alnum:] 字母和数字
[:alpha:] 代表任何英文大小写字符，亦即 A-Z, a-z
[:lower:] 小写字母,示例:[[:lower:]],相当于[a-z]
[:upper:] 大写字母
[:blank:] 空白字符（空格和制表符）
[:space:] 水平和垂直的空白字符（比[:blank:]包含的范围广）
[:cntrl:] 不可打印的控制字符（退格、删除、警铃...）
[:digit:] 十进制数字
[:xdigit:]十六进制数字
[:graph:] 可打印的非空白字符
[:print:] 可打印字符
[:punct:] 标点符号

2、次数匹配

*   匹配前面字符任意次
? 0或1次
+ 1次或多次
{n} 匹配n次
{m,n} 至少m，至多n次

3、位置锚定

^ 行首
$ 行尾
\<, \b 语首
\>, \b 语尾

4、分组其它

() 分组
后向引用：\1, \2, ...
| 或者
a|b #a或b
C|cat #C或cat
(C|c)at #Cat或cat

扩展正则表达式练习

• 显示三个用户root、mage、wang的UID和默认shell
• 找出/etc/rc.d/init.d/functions文件中行首为某单词(包括下划线)后面跟一个小括号的行
• 使用egrep取出/etc/rc.d/init.d/functions中其基名
• 使用egrep取出上面路径的目录名
• 统计last命令中以root登录的每个主机IP地址登录次数
• 利用扩展正则表达式分别表示0-9、10-99、100-199、200-249、250-255
• 显示ifconfig命令结果中所有IPv4地址
• 将此字符串：welcome to magedu linux 中的每个字符去重并排序，重复次数多的排到前面