1
00:00:00,000 --> 00:00:02,000
[Powered by Google Translate] [研讨会：正则表达式的模式匹配]

2
00:00:02,000 --> 00:00:04,000
[约翰·Mussman哈佛大学]

3
00:00:04,000 --> 00:00:07,220
[这是CS50. CS50.TV]

4
00:00:07,780 --> 00:00:11,610
好吧。好吧，欢迎大家。这是CS50 2012。

5
00:00:11,780 --> 00:00:16,610
我的名字是约翰，我今天将讨论有关正则表达式。

6
00:00:16,610 --> 00:00:22,530
正则表达式主要是一个工具，但有时也用

7
00:00:22,530 --> 00:00:28,650
积极在代码本质模式和字符串相匹配。

8
00:00:28,650 --> 00:00:33,800
所以这里有一个网络漫画XKCD。

9
00:00:34,440 --> 00:00:42,370
在这个漫画有一个神秘谋杀案，杀手

10
00:00:42,370 --> 00:00:47,860
随后有人在休假中，主角有

11
00:00:47,860 --> 00:00:52,500
通过搜索寻找一个地址的200兆字节的电子邮件。

12
00:00:52,500 --> 00:00:56,090
他们都放弃的时候，别人谁知道正则表达式 - 

13
00:00:56,090 --> 00:01:00,550
大概是一个超级英雄 - 猛扑下来，并写了一些代码

14
00:01:00,550 --> 00:01:02,970
并解决了谋杀之谜。

15
00:01:02,970 --> 00:01:07,370
因此推测，这将是东西，你将有权做

16
00:01:07,370 --> 00:01:09,370
经过本次研讨会。

17
00:01:09,370 --> 00:01:12,250
我们只是要提供一个简洁的语言介绍

18
00:01:12,250 --> 00:01:16,770
给你足够的资金去后，更多的资源在自己的。

19
00:01:17,680 --> 00:01:21,700
>> 因此，正则表达式看起来基本上是这样的。

20
00:01:22,930 --> 00:01:25,550
在Ruby中，这是一个正则表达式。

21
00:01:25,550 --> 00:01:29,280
这是不可怕的跨语言不同。

22
00:01:29,690 --> 00:01:37,630
我们刚刚开始和斜线标记的正则表达式在Ruby。

23
00:01:37,630 --> 00:01:42,880
，这是一个正则表达式来寻找电子邮件地址模式。

24
00:01:42,880 --> 00:01:49,160
所以我们看到在第一位看起来任何字母数字字符。

25
00:01:50,500 --> 00:01:54,880
这是因为电子邮件地址通常以字母字符开始。

26
00:01:55,460 --> 00:01:59,330
然后任何特殊字符，然后由@符号。

27
00:01:59,330 --> 00:02:03,260
然后同样的事情，域名。

28
00:02:03,260 --> 00:02:10,030
，然后在2和4个字符之间寻找。com，。网，等等。

29
00:02:10,850 --> 00:02:13,200
所以这是正则表达式的另一个例子。

30
00:02:13,200 --> 00:02:17,270
因此，正则表达式的协议文本中找到的格局。

31
00:02:17,270 --> 00:02:21,130
他们做比较，选择和更换。

32
00:02:21,690 --> 00:02:27,970
所以第三个例子是查找所有目录中的电话号码54结束。

33
00:02:27,970 --> 00:02:34,360
所以，大卫撕裂了CS50目录中我们可以搜索

34
00:02:34,360 --> 00:02:40,450
一个模式在那里我们有括号，那么3个数​​字，然后结束括号，

35
00:02:40,450 --> 00:02:44,070
3个数字，一个破折号，2个号码，然后54。

36
00:02:44,070 --> 00:02:48,310
基本上，这将是我们如何来用正则表达式搜索。

37
00:02:49,150 --> 00:02:52,960
>> 因此，有 - 我们已经做了一些事情，有点像CS50

38
00:02:52,960 --> 00:02:59,740
正则表达式 - 例如 - 在dictionary.C文件

39
00:02:59,740 --> 00:03:04,720
拼写检查问题集，你可能已经使用fscanf

40
00:03:04,720 --> 00:03:07,930
读一个字从字典。

41
00:03:07,930 --> 00:03:16,240
你可以看到的百分比45S正在寻找一个45个字符的字符串。

42
00:03:16,240 --> 00:03:20,020
因此，它是有点像一个基本的正则表达式。

43
00:03:21,150 --> 00:03:26,060
你可以有适合该法案在那里任意45个字符

44
00:03:26,060 --> 00:03:28,080
和挑选那些了。

45
00:03:28,080 --> 00:03:33,480
然后在最近的网络规划问题的第二个例子中

46
00:03:33,480 --> 00:03:40,760
设置的发行代码为PHP，我们其实有一个简单的正则表达式。

47
00:03:40,760 --> 00:03:46,790
而这一次只是简单地检查，如果网页中传递

48
00:03:46,790 --> 00:03:51,940
匹配任何登录或注销登记。PHP。

49
00:03:52,220 --> 00:03:57,910
然后返回真或假的基础上，正则表达式匹配。

50
00:03:59,400 --> 00:04:01,740
>> 因此，当你使用正则表达式？

51
00:04:01,740 --> 00:04:04,820
你为什么在这里呢？

52
00:04:05,330 --> 00:04:08,480
所以你不希望有什么东西时，使用正则表达式

53
00:04:08,480 --> 00:04:11,640
为你做这项工作更容易。

54
00:04:11,640 --> 00:04:15,510
所以，XML和HTML是实际上相当棘手

55
00:04:15,510 --> 00:04:18,480
正如我们将看到在一点点写正则表达式。

56
00:04:19,110 --> 00:04:23,280
因此，有专门的那些语言的解析器。

57
00:04:24,170 --> 00:04:30,060
你也需要经常会没事的权衡和准确性。

58
00:04:30,060 --> 00:04:36,220
如果您正在尝试 - 让我们看到了一个电子邮件地址的正则表达式，

59
00:04:37,370 --> 00:04:42,590
但是说你想要一个特定的电子邮件地址，并逐步

60
00:04:42,590 --> 00:04:48,570
正则表达式可能会变得更加复杂，因为它变得更精确。

61
00:04:49,580 --> 00:04:52,260
因此，这将是一个权衡。

62
00:04:52,260 --> 00:04:55,330
你必须要确保你好吗正则表达式。

63
00:04:55,330 --> 00:04:57,920
如果你确切地知道你正在寻找它可能会更有意义

64
00:04:57,920 --> 00:05:02,070
投入的时间和写更有效的解析器。

65
00:05:02,070 --> 00:05:06,980
最后，有一个历史的规律性问题

66
00:05:06,980 --> 00:05:08,940
表情和语言。

67
00:05:08,940 --> 00:05:12,960
事实上，正则表达式是强大得多

68
00:05:12,960 --> 00:05:16,450
正则表达式的每一个正式意义上说。

69
00:05:17,130 --> 00:05:20,150
>> 所以，我不想去太远的正式理论，

70
00:05:20,150 --> 00:05:24,000
但大多数的语言，我们的代码实际上是不正规的。

71
00:05:24,000 --> 00:05:29,110
这就是为什么有时正则表达式不考虑所有的安全。

72
00:05:29,670 --> 00:05:33,150
所以基本上是一个乔姆斯基语言层次，

73
00:05:33,150 --> 00:05:38,400
和正则表达式建立工会，​​串联，

74
00:05:38,400 --> 00:05:41,810
Kleene星号操作，我们将看到在几分钟之内。

75
00:05:43,130 --> 00:05:48,860
如果你有兴趣在理论上有不少对那里发生的引擎盖下。

76
00:05:50,360 --> 00:05:55,880
>> 所以简史 - 只为这里的语境 - 定期集上来

77
00:05:55,880 --> 00:05:59,580
在20世纪50年代，然后我们有简单的编辑器

78
00:05:59,580 --> 00:06:03,300
注册成立的正则表达式 - 只搜索字符串。

79
00:06:03,570 --> 00:06:09,110
grep的 - 这是一个命令行工具 - 是第一个

80
00:06:09,110 --> 00:06:14,160
纳入正则表达式在20世纪60年代非常流行的工具。

81
00:06:14,160 --> 00:06:20,560
在八十年代，Perl是 - 是一种编程语言，

82
00:06:20,560 --> 00:06:24,110
采用正则表达式非常突出。

83
00:06:24,550 --> 00:06:30,130
然后最近我们曾与Perl兼容的正则表达式

84
00:06:30,130 --> 00:06:35,870
协议基本上在其他语言中使用许多相同的语法。

85
00:06:36,630 --> 00:06:39,840
当然，最重要的事件是在2008年

86
00:06:39,840 --> 00:06:43,040
那里是第一届全国正则表达式日，

87
00:06:43,040 --> 00:06:47,350
我相信这是6月1日，如果你想庆祝。

88
00:06:48,430 --> 00:06:50,840
>> 同样，只是一点点的理论在这里。

89
00:06:52,180 --> 00:06:55,320
因此，有几种不同的方法构造正则表达式。

90
00:06:55,950 --> 00:07:02,050
一个简单的方法是，你要构建的表达

91
00:07:02,050 --> 00:07:07,500
上运行的字符串解释 - 基本上是建立一个小的迷你节目，

92
00:07:07,500 --> 00:07:11,870
将分析一个字符串的作品看，“哦，这符合正则表达式或不？”

93
00:07:12,250 --> 00:07:14,250
然后运行。

94
00:07:14,250 --> 00:07:17,300
所以，如果你有一个非常小的正则表达式，这可能是

95
00:07:17,300 --> 00:07:19,380
最有效的方式做到这一点。

96
00:07:20,090 --> 00:07:25,420
然后，如果您 - 另一种选择，就是保持重建

97
00:07:25,420 --> 00:07:30,260
表达你走了，那是模拟的可能性。

98
00:07:30,440 --> 00:07:37,690
这些早期的尝试正则表达式算法

99
00:07:37,690 --> 00:07:44,330
相对简单，比较快的，但没有很大的灵活性。

100
00:07:44,330 --> 00:07:47,500
因此，做一些事情，我们要看看

101
00:07:47,500 --> 00:07:52,860
我们今天不得不做更复杂的正则表达式

102
00:07:52,860 --> 00:07:56,650
实现可能要慢得多，所以是牢记

103
00:07:57,510 --> 00:08:02,920
还有一个正则表达式拒绝攻击品种

104
00:08:02,920 --> 00:08:08,330
这些新的实现利用的潜力

105
00:08:08,330 --> 00:08:10,930
正则表达式变得非常复杂。

106
00:08:11,570 --> 00:08:15,650
在大致相同的意义上，我们看到在缓冲区溢出攻击，

107
00:08:15,650 --> 00:08:21,610
你有工作做出递归循环，攻击

108
00:08:21,610 --> 00:08:24,400
溢出的内存容量。

109
00:08:24,780 --> 00:08:29,540
部分内容的方式是一个正则表达式的官方复数

110
00:08:29,540 --> 00:08:32,890
牛在盎格鲁 - 撒克逊的比喻。

111
00:08:33,500 --> 00:08:40,169
>> 好吧，所以Python库，许多人在这里你的Mac计算机，

112
00:08:40,169 --> 00:08:43,860
所以你实际上可以拉在你的屏幕上。

113
00:08:43,860 --> 00:08:47,480
Python内建正则表达式。

114
00:08:48,070 --> 00:08:53,020
所以Python预装在Mac电脑上，也可在网上在这个环节。

115
00:08:53,770 --> 00:08:57,350
所以，如果你看，你可以暂停，并确保了Python

116
00:08:58,080 --> 00:09:00,170
我们玩在这里。

117
00:09:00,780 --> 00:09:06,420
有一个手动网上，所以如果你只需要输入到您的计算机的Python

118
00:09:06,420 --> 00:09:10,500
你将看到的版本出现在终端。

119
00:09:11,070 --> 00:09:17,720
所以我提供了一个链接的手册第2版的Python以及小抄。

120
00:09:17,720 --> 00:09:23,100
有一个版本的Python，但你的Mac不一定

121
00:09:23,100 --> 00:09:25,130
配备预加载。

122
00:09:25,130 --> 00:09:27,360
所以不可怕不同。

123
00:09:27,360 --> 00:09:33,270
好了，所以使用正则表达式在Python中的一些基本知识。

124
00:09:34,080 --> 00:09:42,650
>> 所以在这里我用一个非常简单的表达，所以我做了Python的进口重

125
00:09:43,750 --> 00:09:47,070
然后拿了re.search中的结果。

126
00:09:47,070 --> 00:09:49,910
搜索需要两个参数。

127
00:09:49,910 --> 00:09:56,040
第一个是正则表达式，而第二个是文本

128
00:09:56,040 --> 00:09:58,290
或者你要分析的字符串。

129
00:09:58,290 --> 00:10:01,210
然后我打印出来的result.group。

130
00:10:01,580 --> 00:10:05,860
因此，这些都是我们要看到今天的2个基本功能

131
00:10:06,790 --> 00:10:10,170
学习正则表达式。

132
00:10:10,170 --> 00:10:12,880
因此，只要打破这个正则表达式

133
00:10:12,880 --> 00:10:21,770
h后，\ W，则m \ W只是在那里接受任何字母字符。

134
00:10:21,850 --> 00:10:26,820
所以，在这里，我们正在寻找一个“H”，然后另一个字母字符

135
00:10:26,820 --> 00:10:30,060
然后米，所以这里将匹配火腿

136
00:10:30,060 --> 00:10:34,480
“亚伯拉罕·林肯和火腿的三明治。”

137
00:10:35,040 --> 00:10:37,150
这是该组的结果。

138
00:10:37,680 --> 00:10:43,130
我们可以做的另一件事是在Python中使用我们之前的文本字符串。

139
00:10:43,130 --> 00:10:46,220
所以我想我会继续前进，拉在此处进行。

140
00:10:46,220 --> 00:10:49,210
Python的进口重。

141
00:10:50,070 --> 00:10:54,000
如果我是做同样的事情 - 让我们说文字是，

142
00:10:55,390 --> 00:11:00,800
“亚伯拉罕，”让我们放大 - 我们去那里。

143
00:11:01,610 --> 00:11:06,430
文字是：“亚伯拉罕吃火腿肠。”

144
00:11:07,460 --> 00:11:15,260
好吧，然后导致= re.search。

145
00:11:16,260 --> 00:11:22,020
，然后我们的表达可以是小时，然后我会做点米。

146
00:11:22,020 --> 00:11:26,280
所以只需点的任何字符，包括数字是不是一个新的行，

147
00:11:26,280 --> 00:11:28,650
个标志，类似的事情。

148
00:11:28,650 --> 00:11:38,030
文本 - 繁荣 - 然后result.group  - 耶。

149
00:11:38,030 --> 00:11:41,820
所以这是如何实现的基本功能在这里。

150
00:11:42,300 --> 00:11:55,110
如果我们有一个文本环 - 那个疯狂的文本 - 包括很多回斜线说

151
00:11:55,110 --> 00:12:01,180
字符串里面的东西，可能看起来像转义序列，

152
00:12:01,180 --> 00:12:08,480
那么我们可能想要使用原始的文本输入，以确保接受。

153
00:12:08,480 --> 00:12:14,120
只是看起来像。

154
00:12:14,120 --> 00:12:17,810
因此，如果我们正在寻找我们不应该为他们每个人在那里找到任何东西。

155
00:12:19,070 --> 00:12:21,680
但是，这是你将如何实现它;只是之前的字符串

156
00:12:21,680 --> 00:12:24,990
正则表达式，你把字母r。

157
00:12:26,150 --> 00:12:30,260
>> 好了，让我们继续下去。

158
00:12:30,260 --> 00:12:33,730
好吧 - 所以让我们来看看一对夫妇重复模式。

159
00:12:34,750 --> 00:12:39,150
所以，你想要做的一件事，是重复的东西

160
00:12:40,040 --> 00:12:42,480
因为你是通过搜索文本。

161
00:12:42,480 --> 00:12:48,300
因此，做一个由任意数量的b  - 你槟*。

162
00:12:48,630 --> 00:12:51,620
然后还有一系列的其他规则。

163
00:12:51,620 --> 00:12:54,380
你可以看看所有这些了，我只是通过一些运行

164
00:12:54,380 --> 00:12:57,630
最常用的。

165
00:12:57,630 --> 00:13:03,920
所以AB +是一个由任意n大于0的b。

166
00:13:04,510 --> 00:13:08,000
AB？是一个0或1的b。

167
00:13:09,190 --> 00:13:18,580
AB {N}是一个由N b的，然后依此类推。

168
00:13:18,580 --> 00:13:22,820
如果你有2个大括号中的数字，你指定范围

169
00:13:23,300 --> 00:13:25,440
可以是可能的匹配。

170
00:13:26,390 --> 00:13:30,420
因此，我们将看看一对夫妇在一分钟内重复模式。

171
00:13:31,960 --> 00:13:42,300
因此，两件事情要记住，当使用这些模式匹配工具。

172
00:13:42,300 --> 00:13:52,120
所以说，我们想看看HM，“亚伯拉罕·林肯使得火腿的三明治。”

173
00:13:52,120 --> 00:13:55,230
因此，我改变亚伯拉罕亚伯拉罕·林肯的名字。

174
00:13:55,230 --> 00:14:00,290
现在我们正在寻找什么是返回此搜索功能，

175
00:14:00,290 --> 00:14:03,270
并且在这种情况下，只返回火腿。

176
00:14:03,620 --> 00:14:08,080
它，只是因为搜索时，自然需要最左边的队列。

177
00:14:08,080 --> 00:14:12,130
所有的正则表达式，除非你指定，否则将这样做。

178
00:14:12,830 --> 00:14:18,880
如果我们想找到所有有一项功能 - 全部找到。

179
00:14:18,880 --> 00:14:35,100
所以这可能只是看起来像所有：=通过re.findall（'h.m'，文字）

180
00:14:35,100 --> 00:14:44,540
然后all.group（）。

181
00:14:44,540 --> 00:14:51,040
所有生产火腿及火腿，在这种情况下，两者的字符串亚伯拉罕每个火腿。

182
00:14:51,610 --> 00:14:55,110
因此，这是另一种选择。

183
00:14:56,250 --> 00:15:06,940
>> 太好了。要记住的另一件事是，正则表达式取最大直观的。

184
00:15:06,940 --> 00:15:09,520
让我们看看下面这个例子。

185
00:15:10,200 --> 00:15:16,070
这里我们做了最左边的搜索，然后我尝试更大的搜索

186
00:15:16,070 --> 00:15:18,800
使用Kleene星操作。

187
00:15:18,800 --> 00:15:24,180
因此，“亚伯拉罕·林肯使火腿三文治，”我只回来

188
00:15:24,180 --> 00:15:26,280
米作为一个结果。

189
00:15:26,280 --> 00:15:31,670
该错误的原因是，我可以采取任何数量的

190
00:15:31,670 --> 00:15:36,140
H公司的，因为我没有指定什么去H和M之间。

191
00:15:36,140 --> 00:15:42,010
唯一的例子，有米 - 唯一的例子米

192
00:15:42,010 --> 00:15:46,220
h的任意数量的串m。

193
00:15:46,490 --> 00:15:51,850
然后我尝试一遍，我说：“好吧，让我们得到实际这里最大的群体。”

194
00:15:51,850 --> 00:15:59,670
，然后我做小时。*米，使刚刚返回任意数量的H和M之间的字符。

195
00:16:00,280 --> 00:16:02,950
而且，如果你是刚刚开始，想，“哦，没关系，这将

196
00:16:02,950 --> 00:16:11,560
让我火腿“，它实际上需要一切从H亚伯拉罕·林肯

197
00:16:11,560 --> 00:16:13,690
一路攀升至年底的火腿。

198
00:16:14,040 --> 00:16:18,110
它是贪婪的，它看到小时 - 这一切其他文本 - 米，

199
00:16:18,110 --> 00:16:21,280
这是它的需要。

200
00:16:22,060 --> 00:16:27,480
这是一个特别令人震惊的 - 这是一个功能，我们也可以

201
00:16:27,480 --> 00:16:30,670
为它指定使用其他功能不能贪。

202
00:16:31,480 --> 00:16:34,490
但是，这是我们必须牢记，特别是

203
00:16:34,490 --> 00:16:38,720
看着HTML文本时，这是一个原因，

204
00:16:38,720 --> 00:16:41,500
正则表达式是很难的HTML。

205
00:16:42,460 --> 00:16:46,310
因为如果你有一个HTML的开放标记，然后在中间的东西很多

206
00:16:46,310 --> 00:16:49,820
然后一些其他HTML关闭标签很久以后在节目中，

207
00:16:49,820 --> 00:16:55,420
你刚才吃了不少你的HTML代码中可能的错误。

208
00:16:56,200 --> 00:17:01,840
>> 所有权利 - 让更多的特殊字符，像许多其他语言，

209
00:17:01,840 --> 00:17:04,780
我们逃避使用斜线。

210
00:17:04,780 --> 00:17:10,329
所以我们可以使用点新行指定以外的任何字符。

211
00:17:10,329 --> 00:17:14,550
我们可以使用逃生w来指定任何字母字符。

212
00:17:14,550 --> 00:17:20,329
类推逃生d为任意整数 - 数字字符。

213
00:17:20,630 --> 00:17:27,440
我们可以指定 - 我们可以使用括号来指定相关的表达式。

214
00:17:27,440 --> 00:17:30,970
因此，这将接受A，B，或C。

215
00:17:31,320 --> 00:17:37,000
我们也可以指定或为A或B的选项。

216
00:17:37,000 --> 00:17:41,110
例如 - 如果我们所期待的多种可能性

217
00:17:41,110 --> 00:17:44,940
如在括号中，我们可以使用或操作 - 

218
00:17:44,940 --> 00:17:52,480
所以让我们回到这个例子在这里。

219
00:17:53,000 --> 00:17:59,790
现在，就让我们来 - 让我们回到这个例子，然后

220
00:17:59,790 --> 00:18:12,290
AE  - 所以这应该返回 - 我想这仍然是亚伯拉罕。

221
00:18:12,290 --> 00:18:17,410
因此，这 - 如果我们这样做 - 伟大。

222
00:18:17,410 --> 00:18:22,700
所以，让我们这里的文字更新。

223
00:18:22,700 --> 00:18:34,690
“亚伯拉罕吃火腿肠，而卷边缝边，而他 - 。”太好了。

224
00:18:44,090 --> 00:18:47,330
所有。太好了。现在，我们得到的火腿，火腿和下摆。

225
00:18:48,510 --> 00:18:59,370
尽管边饰 - 一边哼着他 - 边哼着下摆他。太好了。

226
00:19:00,350 --> 00:19:03,250
同样的事情。

227
00:19:03,820 --> 00:19:09,180
现在，所有仍然只是返回火腿，火腿和下摆的嗡嗡声或他不拿起。

228
00:19:09,940 --> 00:19:22,600
大 - 还等什么，如果我们想看看在任 - 所以我们也可以做

229
00:19:23,510 --> 00:19:33,810
他 - 我们会回来的。

230
00:19:34,810 --> 00:19:45,760
好吧 - 让 - 所有权利 - 位置，你也可以使用插入符号或美元符号

231
00:19:45,760 --> 00:19:49,350
指定你正在寻找的东西在开始或结束的字符串。

232
00:19:50,260 --> 00:19:52,260
或词语的开始或结束。

233
00:19:52,400 --> 00:19:54,470
这是一个使用该方法。

234
00:19:55,630 --> 00:20:01,160
>> 好了 - 所以让我们玩弄一个稍大的文本块。

235
00:20:03,950 --> 00:20:08,310
让我们在这里说此行 - 这一说法在这里。

236
00:20:08,310 --> 00:20:11,360
正则表达式的力量是，他们可以指定图案

237
00:20:11,360 --> 00:20:13,390
不只是固定的字符。

238
00:20:14,900 --> 00:20:18,790
让我们 - 让我们调用该功能块。

239
00:20:22,400 --> 00:20:27,110
然后，我们将读取所有，在。

240
00:20:28,890 --> 00:20:50,820
，然后有一个 - 让我们所有=，那么，有哪些事情是我们可以在这里搜索盈利？

241
00:20:50,820 --> 00:20:54,070
我们可以看看的表达的耳朵。

242
00:20:55,050 --> 00:21:01,520
不是很有趣。怎么样？我们看看会发生什么。

243
00:21:03,710 --> 00:21:05,710
我给它一个问题。

244
00:21:06,380 --> 00:21:10,750
所以任何数量的东西，然后再重新和所有。

245
00:21:10,750 --> 00:21:15,630
所以，应该一切从开始到全部重新也许几次返回。

246
00:21:18,800 --> 00:21:21,970
那么在这里，我们的力量正则表达式是

247
00:21:21,970 --> 00:21:24,900
可以指定图案，这里不仅仅是个字符。

248
00:21:24,900 --> 00:21:28,510
所以最后再一路上涨，最左边的开始和贪婪。

249
00:21:30,710 --> 00:21:32,710
让我们来看看 - 我们还有什么可以期待。

250
00:21:32,710 --> 00:21:39,860
我想一件事，如果你有兴趣寻找代词她和他，

251
00:21:39,860 --> 00:21:44,600
你可以检查是等于0或1

252
00:21:44,600 --> 00:21:49,710
他的表情，那可能是不打算返回 - 

253
00:21:49,710 --> 00:21:58,020
哦，我想还给他，因为我们正在寻找电源，那一天，这里的。

254
00:22:00,590 --> 00:22:06,270
让我们试着指定来的东西开始。

255
00:22:06,640 --> 00:22:09,530
让我们看看是否有脱落。

256
00:22:09,530 --> 00:22:19,630
因此，我们可以做的脂肪，那里，我们没有得到任何东西，因为她和他

257
00:22:19,630 --> 00:22:22,870
不发生在这个短语中。

258
00:22:24,960 --> 00:22:30,410
太好了。好了 - 所以这里的猫。

259
00:22:30,410 --> 00:22:35,720
这么复杂的图案伤害大脑。

260
00:22:35,720 --> 00:22:40,500
所以这就是为什么我们使用正则表达式来避免这些问题。

261
00:22:40,820 --> 00:22:43,520
>> 因此，这里有一些其他有用的模式，你可以玩。

262
00:22:43,520 --> 00:22:50,290
我们期待在今天的搜索，但你也可以使用匹配，分割，谓词和团体。

263
00:22:50,290 --> 00:22:53,970
所以，等凉的东西，你可以用正则表达式除了刚刚

264
00:22:53,970 --> 00:22:58,870
寻找模式，采取一个模式，并保持所有的比赛 - 

265
00:22:58,870 --> 00:23:02,530
其变量 - 然后在你的代码中使用这些以后。

266
00:23:02,850 --> 00:23:05,980
这可以是相当有帮助的。其他的事情可能会被计数。

267
00:23:05,980 --> 00:23:11,720
因此，我们可以数一数，正则表达式模式的实例，

268
00:23:11,720 --> 00:23:13,960
而这正是我们可以利用组。

269
00:23:13,960 --> 00:23:17,550
模式和其他模式也是可能的。

270
00:23:18,040 --> 00:23:22,980
所以，我只是想谈多一点点的其他方法，你可以使用正则表达式。

271
00:23:22,980 --> 00:23:29,100
>> 因此，一个更先进的应用程序是在模糊匹配。

272
00:23:29,100 --> 00:23:33,450
所以，如果你正在寻找一个文本的表达，凯撒，

273
00:23:33,450 --> 00:23:37,740
您看到盖乌斯·尤利乌斯·凯撒凯撒大帝的名字在其他语言，

274
00:23:37,740 --> 00:23:44,400
那么你可能还需要一些重量分配到这些值。

275
00:23:44,400 --> 00:23:48,930
而如果是足够接近 - 如果超过一定的阈值 - 然后你想

276
00:23:48,930 --> 00:23:50,860
能够接受凯撒大帝。

277
00:23:50,860 --> 00:24:00,580
因此，有一对夫妇，在不同的实现以及其他一些语言。

278
00:24:02,580 --> 00:24:08,420
这里有一些其他的工具，正则表达式的好朋友 - 一个方便的小应用程序在线

279
00:24:08,420 --> 00:24:12,190
检查如果你的正则表达式是由正确。

280
00:24:12,190 --> 00:24:18,500
也有独立的工具，您可以从您的桌面上运行

281
00:24:18,500 --> 00:24:22,100
像超皮克，以及刚刚食谱。

282
00:24:22,100 --> 00:24:25,410
所以，如果你正在做一个项目，涉及一吨的正则表达式

283
00:24:25,410 --> 00:24:29,810
这大概是今天的范围之外的地方去。

284
00:24:31,520 --> 00:24:35,770
然后只给你的感觉是多么常见

285
00:24:35,770 --> 00:24:44,090
在Unix的grep，Perl也有内置，和C有PCRE C.

286
00:24:44,090 --> 00:24:48,890
然后所有这些其他的语言也有正则表达式包

287
00:24:48,890 --> 00:24:52,020
操作基本上是相同的语法，我们得到了今天的味道。

288
00:24:52,020 --> 00:24:54,790
PHP，Java中，红宝石，等等。

289
00:24:56,080 --> 00:24:58,980
>> 谷歌代码搜索实际上是值得一提，它是一个

290
00:24:58,980 --> 00:25:05,720
相对较少的应用程序，允许公众访问

291
00:25:05,720 --> 00:25:07,800
其数据库使用正则表达式。

292
00:25:07,800 --> 00:25:12,920
所以，如果你看一下谷歌代码搜索，你可以找到代码

293
00:25:12,920 --> 00:25:16,880
如果你正在寻找一个实例如何可能会使用一个函数，

294
00:25:16,880 --> 00:25:21,610
发现功能被用在各种不同的情况下，你可以使用正则表达式。

295
00:25:21,610 --> 00:25:28,000
你可以看看fwrite的，然后你可以看看写的国旗或读

296
00:25:28,000 --> 00:25:32,000
如果你想在这种情况下被使用的fwrite的一个例子。

297
00:25:33,530 --> 00:25:37,010
于是同样的事情，在这里，是一些参考。

298
00:25:37,010 --> 00:25:40,990
这将可在网上，所以转发

299
00:25:40,990 --> 00:25:45,560
你想要看的Python中，grep，Perl的 - 你只是想从中得到一些启发

300
00:25:45,560 --> 00:25:50,650
或者，如果你想看看在这里的理论有一些很好的地方起跳。

301
00:25:50,650 --> 00:25:53,870
非常感谢。

302
00:25:58,470 --> 00:25:59,910
[CS50.TV]