正则表达式

个人根据《正则指引》内容总结记录，侵删！！

转载至我的博客

最近看了编译原理方面的书，觉得正则表达式非常重要，在各个语言当中都有支持，所以总结了这篇文章，作为学习总结以及记录～

正则表达式

Regular Expression 即描述某种规则的表达式。

字符组

普通字符组

字符组（Character Class）是一组字符，表示 “在同一个位置可能出现的各种字符”

其写法是在一对方括号[和]之间列出所有可能出现的字符。

#只要字符串中包含数字、字符就可以匹配
re.search("[0123456789]","2") != None               #=>True

默认情况下re.search(pattern,string)只判断string的某个子串能否由pattern匹配，为了测试整个string能否被pattern匹配，在pattern两端加上^和 $。它们并不匹配任何字符，只表示“定位到字符串的起始位置”和“定位到字符串的结束位置”。

#使用^和$测试string被pattern完整匹配
#只要字符串中包含数字、字符就可以匹配
re.search("[0123456789]","2") != None               #=>True
re.search("[0123456789]","a2") != None              #=>True
#整个字符串就是一个数字字符，才可以匹配
re.search("^[0123456789]$","2") != None             #=>True
re.search("^[0123456789]$","12") != None            #=>False

字符组中的字符排列顺序并不影响字符组的功能，出现重复字符也不影响，但是并不推荐在字符组中出现重复字符。

例如上例中匹配数字就要把所有数字都列出来还是有些繁琐，为此正则表达式提供了范围表示法（range）,它更直观，能进一步简化字符组。

在字符组中-表示范围，一般是根据字符对应的码值（Code Point）也就是字符在对应码表中的编码数值来确定的。小的在前，大的在后，所以[0-9]正确，而[9-0]会报错。

在字符组中可以同时并列多个-范围表示法。

#[0-9a-fA-F]准确判断十六进制字符
re.search("^[0-9a-fA-F]$","0") != None              #=>True
re.search("^[0-9a-fA-F]$","c") != None              #=>True
re.search("^[0-9a-fA-F]$","i") != None              #=>True

还可以用转义序列\xhex来表示一个字符，其中\x是固定前缀。字符组中有时会出现这种表示法，它可以表现一些难以输入或者难以显示的字符。依靠这种表示法可以很方便的匹配所有的中文字符。

#[\x00-\x7F]准确判断ASCII字符
re.search("^[\x00-\x7F]$","c") != None              #=>True
re.search("^[\x00-\x7F]$","I") != None              #=>True
re.search("^[\x00-\x7F]$","<") != None              #=>True
re.search("^[\x00-\x7F]$","0") != None              #=>True

元字符与转义

字符组中的-并不能匹配横线字符，这类字符叫做元字符。[、]、^、$都算元字符。

如果-紧邻字符组中的[那么它就是普通字符，其他情况都是元字符。

取消特殊含义的做法是在元字符前加上反斜杠\。

#作为普通字符
re.search("^[-09]$","3") != None                    #=>False
re.search("^[-09]$","-") != None                    #=>True
#作为元字符
re.search("^[0-9]$","3") != None                    #=>True
re.search("^[0-9]$","-") != None                    #=>False
#转义之后作为普通字符
re.search("^[0\\-9]$","3") != None                  #=>False
re.search("^[0\\-9]$","-") != None                  #=>True

这段例子中，正则表达式是以字符串的方式传入的，而字符串本身也有关于转义的规定，所以要加两个反斜杠\\。

针对这种问题Python提供了原生字符串（Raw String）,不需要考虑正则表达式之外的转义（只有双引号是例外，必须转义成\"）。

#原生字符串的使用
r"^[0\-9]$" == "^[0\\-9]$"                          #=>True
#原生字符串的转义要简单许多
re.search(r"^[0\-9]$","3") != None                  #=>False
re.search(r"^[0\-9]$","-") != None                  #=>True

#]出现的位置不同含义不同
#未转义的]
re.search(r"^[012]345$","2345") != None             #=>True
re.search(r"^[012]345]$","5") != None               #=>False
re.search(r"^[012]345]$","]") != None               #=>False
#转义的]
re.search(r"^[012\]345]$","2345") != None           #=>False
re.search(r"^[012\]345]$","5") != None              #=>True
re.search(r"^[012\]345]$","]") != None              #=>True

请注意，只有开方括号[需要转义，闭方括号]不用。

#取消其他元字符的特殊含义
re.search(r"^[012]345]$","3") != None               #=>False
re.search(r"^[012\\]345]$","3") != None             #=>False
re.search(r"^[012]$","[012]") != None               #=>False
re.search(r"^\[012]$","[012]") != None              #=>True

排除型字符组

排除型字符组（Negated Character Class）只是在**方括号[之后紧跟一个脱字符^**，所以[^0-9]表示0-9之外的字符，也就是“非数字字符”。

#使用排除型字符组
re.search(r"^[^0-9][0-9]$","A8") != None            #=>True
re.search(r"^[^0-9][0-9]$","x6") != None            #=>True

#排除型字符组必须匹配一个字符
re.search(r"^[0-9][0-9]$","8") != None              #=>False

#排除型字符组中，紧跟在"^"之后的一个"-"不是元字符
#匹配一个"-"、"0"、"9"之外的字符
re.search(r"^[^0-9]$","-") != None                  #=>False
re.search(r"^[^-09]$","8") != None                  #=>True

在排除型字符组中，^是一个元字符，但只有它紧跟在[之后时才是元字符，如果想表示这个字符组中可以出现^字符，不要让它紧挨着[，否则要转义。

#匹配4个字符之一:"0","^","1","2"
re.search(r"^[0^12]$","^") != None                  #=>True
#"^"紧跟在"["之后，但经过转义变为普通字符，等于上一个表达式，不推荐。
re.search(r"^[\^012]$","^") != None                 #=>True

字符组的简记法

字符组间记法（shorthands）：对于常用的表示数字字符、小写字母这类字符组提供的简单记法。

常见的有\d、\w、\s，其中\d等价于[0-9]，d代表“数字（digit）”；\w等价于[0-9a-zA-Z_]，w代表“单词（word）”；\s等价于[ \t\r\n\v\f](第一个字符是空格)，s代表“空白字符（space）”。（这些等价前提是采用ASCII匹配规则，采用Unicode匹配规则就不对了）。

#如果没有原声字符串\d就必须写作\\d
re.search(r"^\d$","8") != None                      #=>True
re.search(r"^\d$","a") != None                      #=>False
re.search(r"^\w$","8") != None                      #=>True
re.search(r"^\w$","a") != None                      #=>True
re.search(r"^\w$","_") != None                      #=>True
re.search(r"^\s$"," ") != None                      #=>True
re.search(r"^\s$","\t") != None                     #=>True
re.search(r"^\s$","\n") != None                     #=>True

\w能匹配下划线_。

#字符组简记法与普通字符组混用
#用在普通字符组内部
re.search(r"^[\da-zA-Z]$","8") != None              #=>True
re.search(r"^[\da-zA-Z]$","a") != None              #=>True
re.search(r"^[\da-zA-Z]$","c") != None              #=>True

#用在排除型字符组内部
re.search(r"^[^\w]$","8") != None                   #=>False
re.search(r"^[^\w]$","_") != None                   #=>False
re.search(r"^[^\w]$",",") != None                   #=>True

相对于\d、\w和\s这三个普通字符组简记法，正则表达式也提供了对应的排除型字符组的简记法：\D、\W和\S——字母完全一样，只是改为大写。

这些简记法匹配字符互补：\s能匹配的字符，\S一定不能匹配，其他同理。

#\d和\D
re.search(r"^\d$","8") != None                      #=>True
re.search(r"^\d$","a") != None                      #=>False
re.search(r"^\D$","8") != None                      #=>False
re.search(r"^\D$","a") != None                      #=>True

#\w和\W
re.search(r"^\w$","c") != None                      #=>True
re.search(r"^\w$","!") != None                      #=>False
re.search(r"^\W$","c") != None                      #=>False
re,search(r"^\W$","!") != None                      #=>True

#\s和\S
re.search(r"^\s$","\t") != None                     #=>True
re.search(r"^\s$","0") != None                      #=>False
re.search(r"^\S$","\t") != None                     #=>False
re.search(r"^\S$","0") != None                      #=>True

量词

一般形式

字符组只能匹配单个字符，为此正则表达式提供了量词（quantifier），来支持匹配多个字符的功能。

#重复确定次数的量词
re.search(r"^\d{6}$","100859") != None              #=>True
re.search(r"^\d{6}$","20103") != None               #=>False

量词还可以表示不确定的长度，其通用形式是{m,n}，其中m和n是两个数字（逗号之后绝不能有空格），它限定之前的元素能够出现的次数,m是下限，n是上限（均为闭区间）。如果不确定长度的上限，也可以省略，写成\d{m,}。量词限定一般都有明确的下限，如果没有，则默认为0。有些语言支持{,n}的记法，省略下限为0的情况，但这种用法并不是所有语言都通用的，最好使用{0,n}的记法。

量词 说明
{n} 之前的元素必须出现n次
{m,n} 之前的元素最少出现m次，最多出现n次
{m,} 之前的元素最少出现m次，出现次数无上限
{0,n} 之前的元素可以不出现，也可以出现，最多出现n次（在某些语言中可以写为{,n}） 
#表示不确定长度的量词 
re.search(r"^\d{4,6}$","123") != None               #=>False
re.search(r"^\d{4,5}$","1234") != None              #=>True
re.search(r"^\d{4,6}$","123456") != None            #=>True
re.search(r"^\d{4,6}$","1234567") != None           #=>False
re.search(r"^\d{4,}$","123") != None                #=>False
re.search(r"^\d{4,}$","1234") != None               #=>True
re.search(r"^\d{4,}","123456") != None              #=>True
re.search(r"^\d{0,6}$","12345") != None             #=>True
re.search(r"^\d{0,6}$","123456") != None            #=>True
re.search(r"^\d{0,6}$","1234567") != None           #=>False

常用量词

{m,n}是通用形式的量词，正则表达式还有三个常用量词，分别是+、?、*。它们形态虽然不同于{m,n},功能却相同。（可以理解为“量词简记法”）

常用量词 {m,n}等价形式 说明
* {0,} 可能出现，也可能不出现，出现次数没有上限
+ {1,} 至少出现1次，出现次数没有上限
? {0,1} 至多出现1次，也可能不出现 
#量词?的应用
re.search(r"^travell?er$","traveler") != None       #=>True
re.search(r"^travell?er$","traveller") != None      #=>True

#量词+的应用
re.search(r"^<[^>]+>$","<bold>") != None            #=>True
re.search(r"^<[^>]+>$","</table>") != None          #=>True
re.search(r"^<[^>]+>$","<>") != None                #=>False

#量词*的使用
re.search(r"^\"[^\"]*\"$","\"some\"") != None       #=>True
re.search(r"^\"[^\"]*\"$","\"\"") != None           #=>True

点号

一般文档都说点号可以匹配“任意字符”，但是换行符\n不能匹配，如果非要匹配"任意字符"，有两种办法：可以使用单行匹配；或者使用[\s\S]（也可以使用[\w\W]、[\d\D]）。

#点号.的匹配
re.search(r"^.$","a") != None                       #=>True
re.search(r"^.$","0") != None                       #=>True
re.search(r"^.$","*") != None                       #=>True

#换行符的匹配
re.search(r"^.$","\n") != None                      #=>False
#单行匹配
re.search(r"(?s)^.$","\n") != None                  #=>True
re.search(r"^[\s\S]$","\n") != None                 #=>True

贪婪与懒惰

当使用量词匹配字符串有时会出现意料之外的错误情况。

#字符串的值是"quoted string"
print(re.search(r"\".*\"","\"quoted string\"").group())
"quoted string"

#字符串的值是"string" and another"
print(re.search(r"\".*\"","\"quoted string\" and another\"").group())
"quoted string" and another"

我们只想匹配"quoted string"但是下面的语句匹配到了错误的"quoted string" and another"，这是因为默认的量词匹配采用贪婪规则。就是在拿不准是否要匹配时，先尝试匹配，并且记下这个状态，以备将来"反悔"。这个“反悔”的过程叫做回溯（backtracking）。

#准确匹配双引号字符串，采用懒惰规则
print(re.search(r"\".*?\"","\"quoted string\" and another\"").group())
"quoted string"
贪婪匹配量词 懒惰匹配量词 限定次数
* *? 可能不出现，也可能出现，出现次数没有上限
+ +? 至少出现1次，出现次数没有上限
? ?? 至多出现1次，也可能不出现
{m,n} {m,n}? 出现次数最少为m次，最多为n次
{m,} {m,}? 出现次数最少为m次，没有上限
{,n} {,n}? 可能不出现，也可能出现，最多出现n次 
jsStr = '''
<script type="text/javascript">
alert("1");
</script>
<br />
<script type="text/javascript">
alert("2");
</script>
'''


#贪婪匹配
jsRegex = r"<script type=\"text/javascript\">[\s\S]*</script>"
print(re.search(jsRegex,jsStr).group())

#输出
'''
<script type="text/javascript">
alert("1");
</script>
<br />
<script type="text/javascript">
alert("2");
</script>
'''

#懒惰匹配
jsRegex = r"<script type=\"text/javascript\">[\s\S]*?</script>"
print(re.search(jsRegex,jsStr).group())

#输出
'''
<script type="text/javascript">
alert("1");
</script>
'''

转义

各种量词的转义形式

量词 转义形式
{n} \{n}
{m,n} \{m,n}
{m,} \{m,}
{,n} \{,n}
* \*
+ \+
? \?
*? \*\?
+? \+\?
?? \?\?
. \. 
#忽略转义点号可能导致错误
#错误判断浮点数
re.search(r"^\d+.\d+$","3.14") != None              #=>True
re.search(r"^\d+.\d+$","3a14") != None              #=>True

#准确判断浮点数
re.search(r"^\d+\.\d+$","3.14") != None             #=>True
re.search(r"^\d+\.\d+$","3a14") != None             #=>False

括号

分组

使用括号()可以将一个字符、字符组或表达式包围起来作为一个整体，再用量词限定它们出现的次数，这种功能叫做分组。

#用括号改变量词的作用元素
re.search(r"^ab+$","ab") != None                    #=>True
re.search(r"^ab+$","abb") != None                   #=>True
re.search(r"^ab+$","abab") != None                  #=>True
re.search(r"^(ab)+$","ab") != None                  #=>True
re.search(r"^(ab)+$","abb") != None                 #=>False
re.search(r"^(ab)+$","abab") != None                #=>True

#身份证号码的准确匹配
r"^[1-9]\d{14}(\d{2}[0-9xX])?$"

多选结构

多选结构的形式是(...|…),在括号内以竖线|分隔开多个子表达式，这些表达式也叫多选分支（option）；在一个多选结构内，多选分支的数目没有限制。在匹配时，整个多选结构被视为单个元素，只要其中某个子表达式能够匹配，整个多选结构的匹配就成功了；如果所有子表达式都不能匹配，则整个多选结构匹配失败。

#用多选结构匹配身份证号码
r"^([1-9\d{14}|[1-9]{16}[0-9xX]])$"

#准确匹配0-255之间的字符串
r"^([0-9]|[0-9]{2}|1[0-9][0-9]|2[0-4][0-9]|25[0-5])$"

多选结构的补充：

第一、多选结构一般会同时使用括号()和竖线|；但是没有括号()，只出现竖线|，仍然是多选结构。

第二、多选结构并不等于字符组。字符组匹配要比多选结构效率高很多，字符组只能匹配单个字符，多选结构的每个分支长度没有限制。

第三、多选结构应当避免某段文字可以被多个分支同时匹配的情况，这将大大增加回溯的计算量，影响效率。如果遇到多个分支都能匹配的字符串，大多数语言优先匹配左侧分支。

#多选结构的匹配顺序
re.search(r"^jeffrey|jeff$","jeffrey").group()
'jeffrey'
re.search(r"^jeff|jeffrey$","jeffrey").group()
'jeff'

引用分组

使用括号之后，正则表达式会保存每个分组真正匹配的文本，等到匹配完成后，通过group(num)之类的方法"引用"分组在匹配时捕获的内容。其中num表示对应括号的编号，无论括号如何嵌套，分组编号都是根据开括号出现的顺序来计数的；开括号是从左到右数起第多少个开括号，整个括号分组的编号就是多少。编号从1开始计数，不过也有0号分组，它是默认存在的，对应整个表达式匹配的文本。

#引用捕获分组
re.search(r"(\d{4})-(\d{2})-(\d{2})","2018-10-24").group()
'2018-10-24'
re.search(r"(\d{4})-(\d{2})-(\d{2})","2018-10-24").group(0)
'2018-10-24'
re.search(r"(\d{4})-(\d{2})-(\d{2})","2018-10-24").group(1)
'2018'
re.search(r"(\d{4})-(\d{2})-(\d{2})","2018-10-24").group(2)
'10'
re.search(r"(\d{4})-(\d{2})-(\d{2})","2018-10-24").group(3)
'24'

#嵌套的括号
nestedGroupingRegex = r"(((\d{4})-(\d{2}))-(\d{2}))"
re.search(nestedGroupingRegex,"2018-10-24").group(0)
'2018-10-24'
re.search(nestedGroupingRegex,"2018-10-24").group(1)
'2018-10-24'
re.search(nestedGroupingRegex,"2018-10-24").group(2)
'2018-10'
re.search(nestedGroupingRegex,"2018-10-24").group(3)
'2018'
re.search(nestedGroupingRegex,"2018-10-24").group(4)
'10'
re.search(nestedGroupingRegex,"2018-10-24").group(5)
'24'

容易错误的情况：

#容易弄错的分组的结构
re.search(r"^(\d){4}-(\d{2})-(\d{2})$","2018-10-24").group(1)
'8'

这个表达式中编号为1的括号是(\d)，其中\d是“匹配一个数字字符“的子表达式，因为之后有量词{4}，所以整个括号作为单个元素，要重复4次，而且编号都是1；于是每重复一次，就要更新一次匹配结果。所以在匹配过程中，编号为1的分组匹配文本的值，依次是2、0、1、0，最后的结果是0。

#正则表达式的替换
re.sub(r"[a-z]"," ","1a2b3c")
'1 2 3 '
#在替换中使用分组
re.sub(r"(\d{4})-(\d{2})-(\d{2})",r"\2/\3/\1","2018-10-24")
'10/24/2018'
re.sub(r"(\d{4})-(\d{2})-(\d{2})",r"\1年\2月\3日","2018-10-24")
'2018年10月24日'

反向引用

反向引用（back-reference）它允许在正则表达式内部引用之前的捕获分组匹配的文本（也就是左侧），其形式也是\num,其中num表示所引用分组的编号，编号规则与之前介绍的相同。

#用反向引用匹配重复字符
re.search(r"^([a-z])\1$","aa") != None              #=>True
re.search(r"^([a-z])\1$","ac") != None              #=>False

#用反向引用匹配成对的tag
pairedTagRegex = r"^<([^>]+)[\s\S]*?</\1>$"
re.search(pairedTagRegex,"<h1>title</h1>") != None          #=>True
re.search(pairedTagRegex,"<h1>title</bold>") != None        #=>False

#用反向引用匹配更复杂的成对tag
pairedTagRegex = r"^<([a-zA-Z0-9]+)(\s[^>]+)?>[\s\S]*?</\1>$"
re.search(pairedTagRegex,"<h1>title</h1>") != None                          #=>True
re.search(pairedTagRegex,"<span class=\"class1\">text</span>") != None      #=>True
re.search(pairedTagRegex,"<h1>title</bold>") != None                        #=>False

反向引用重复的是对应捕获分组匹配的文本，而不是之前的表达式；也就是说，反向引用的是由之前表达式决定的具体文本，而不是符合某种规则的位置文本。

#匹配IP地址的正则表达式
#匹配其中一段的表达式
segment = r"(0{0,2}[0-9]|0?[0-9]{2}|1[0-9][0-9]|2[0-4][0-9]|25[0-5])"
#正确的表达式
idAddressRegex = r"(" + segment + r"\.){3}" + segment
#错误的表达式
idAddressRegex = segment + r"\.\1.\1.\1"

各种引用的记法

语言 表达式中的反向引用 替换中的反向引用
.NET \num $num
Java \num $num
JavaScript $num $num
PHP \num \num或$num(PHP4.0.4以上版本)
Python \num \num
Ruby \num \num

一般来说，num要好于\num。原因在于，**\0可以准确表示“第0个分组”，而\0则不行，因为不少语言的字符串中，\num本身是一个有意义的转义序列，它表示值为num的ASCII字符，所以\0会被解释为“ASCII编码为0的字符”。但是反向引用不存在这个问题，因为不能在正则表达式还没匹配结束时，就用\0**引用整个表达式匹配的文本。

但是无论是\num还是num**，都有可能遇到二义性的问题：如果出现了**\10**（或者**10），它到底是表示第10个捕获分组，还是第1个捕获分组之后跟着一个字符0？

Python将\10解释成“第10个捕获分组匹配的文本”，如果想表示第1个分组之后跟一个0，需要消除二义性。

#使用g<n>消除二义性
re.sub(r"(\d)",r"\g<1>0","123")
'102030'

Python和PHP的规定明确，所以避免了\num的二义性；Java、Ruby、Javascript这样规定\num，如果一位数，则引用对应的捕获分组；如果是两位数且存在对应的捕获分组时，引用对应的捕获分组，如果不存在则引用一位数编号的捕获分组。这样如果存在编号为10的捕获分组，无法用\10表示“编号为1的捕获分组和字符0”，如果在开发中遇到这个问题，现有规则下无解，但可以使用明明分组解决此问题。

命名分组

为了解决捕获分组数字编号不够直观和会引起冲突的问题，一些语言提供了命名分组（named grouping）。

在Python中用(?P<name>regex)来分组，其中的name是赋予这个分组的名字，regex则是分组内的正则表达式。

#命名分组捕获
namedRegex = r"(?P<year>\d{4})-(?P<month>\d{2})-(?P<day>\d{2})"
result = re.search(namedRegex, "2018-10-24")
print(result.group("year"))
2018
print(result.group("month"))
10
print(result.group("day"))
24

#命名分组捕获时仍然保留了数字编号
print(result.group(1))
2018
print(result.group(2))
10
print(result.group(3))
24

#命名分组的引用方法
re.search(r"^(?P<char>[a-z])(?P=char)$","aa") != None           #=>True
re.sub("(?P<digit>\d)",r"\g<digit>0","123")
'102030'

不同语言中命名分组的记法

语言 分组记法 表达式中的引用记法 替换时的引用记法
.NET (?<name>...) \k<name> ${name}
Java7开始支持 (?<name>...) \k<name> ${name}
PHP (?P<name>...) (?P=name) 不支持，只能使用\{num},其中num
为对应分组的数字编号
Python (?P<name>...) (?P=name) \g<name>
Ruby (?<name>...) \k<name> \k<name>

非捕获分组

在使用分组时，只要出现了括号，正则表达式在匹配时就会把括号内的子表达式存储起来，提供引用。如果不需要引用，保存这些信息无疑会影响正则表达式的性能；如果表达式比较复杂，要处理的文本又很多，更可能严重影响性能。

为解决这种问题，提供了非捕获分组（non-capturing group），非捕获分组类似普通分组，只是在开括号后紧跟一个问号和冒号(?:...)，这样的括号叫做非捕获型括号。在引用分组时，分组的编号同样会按开括号的顺序从左到右递增，只不过必须以捕获分组为准，非捕获分组会掠过。

re.search(r"(\d{4})-(\d{2})-(\d{2})","2018-10-24").group(1)
'2018'
re.search(r"(?:\d{4})-(\d{2})-(\d{2})","2018-10-24").group(1)
'10'

转义

括号的转义必须转义与括号有关的所有元字符包括(、)和|。因为括号非常重要，所以无论时开括号还是闭括号，只要出现，正则表达式就会尝试寻找整个括号，如果只转义了开括号而没有转义闭括号，一般会报告"括号不匹配"的错误。另外，多选结构中的|也必须转义。

#括号的转义
re.search(r"^\(a\)$","(a)") != None                         #=>True
re.search(r"^\(a)$","(a)") != None                          #=>报错

#未转义|
re.search(r"^(\(a|b\))$","(a|b)") != None                   #=>False
re.search(r"^(\(a\|b\))$","(a|b)") != None                  #=>True

断言

正则表达式中的大多数的结构匹配的文本会出现在最终的匹配结果中，但是有些结构并不真正匹配文本，而只负责判断某个位置左/右侧的文本是否符合要求，这种结构被称为断言（assertion）。常见的断言有三类：单词边界、行起始/结束位置、环视。

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 159,835评论 4赞 364
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 67,598评论 1赞 295
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 109,569评论 0赞 244
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 44,159评论 0赞 213
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 52,533评论 3赞 287
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 40,710评论 1赞 222
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 31,923评论 2赞 313
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 30,674评论 0赞 203
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 34,421评论 1赞 246
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 30,622评论 2赞 245
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 32,115评论 1赞 260
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 28,428评论 2赞 254
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 33,114评论 3赞 238
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 26,097评论 0赞 8
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 26,875评论 0赞 197
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 35,753评论 2赞 276
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 35,649评论 2赞 271

推荐阅读更多精彩内容

  • 正则表达式
    初衷：看了很多视频、文章，最后却通通忘记了，别人的知识依旧是别人的，自己却什么都没获得。此系列文章旨在加深自己的印...
    DCbryant阅读 3,899评论 0赞 20
  • JS正则表达式
    JS正则表达式一条龙讲解，从原理和语法到JS正则、ES6正则扩展，最后再到正则实践思路 Stinson 关注 20...
    小杰的简书阅读 610评论 0赞 2
  • 正则表达式 For Python
    正则表达式有很多流派，也有很多的特性，不同的语言支持度也是不一样的。本篇文章是写Python中的正则表达式的用法的...
    Moscow1147阅读 1,038评论 0赞 0
  • 正则表达式详解
    几个正则表达式编辑器 Debuggex ：https://www.debuggex.com/ PyRegex：ht...
    没技术的BUG开发攻城狮阅读 4,554评论 0赞 23
  • js中的正则表达式
    注：参考《JavaScript语言精粹》第七章和第八章。 一、正则表达式的概念，作用 1.概念：正则表达式是一门简...
    yaya520阅读 746评论 0赞 1