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]