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からWebコミックです。

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
だから正規表現は、テキスト内のpattersを見つけるためのプロトコルです。

31
00:02:17,270 --> 00:02:21,130
彼らは、比較、選択、および置換を行う。

32
00:02:21,690 --> 00:02:27,970
ディレクトリ内の54で終わるすべての電話番号を見つけることです3番目の例では、そう。

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
そして、あなたは割合の45秒は、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
そして、最新のWebプログラミングの問題の2番目の例

46
00:03:33,480 --> 00:03:40,760
PHPのためのディストリビューションのコードで設定我々は実際に単純な正規表現を持っている。

47
00:03:40,760 --> 00:03:46,790
、この1つは、単にWebページが渡されているかどうかをチェックするために探しています

48
00:03:46,790 --> 00:03:51,940
どちらかのログインを一致または登録ログアウト。PHPは。

49
00:03:52,220 --> 00:03:57,910
そして、その正規表現のマッチングに基づいて、trueまたはfalseを返す。

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
だから1のトレードオフになります。

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
我々は数分で表示されるとクリーネスター操作。

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
1950年代に、そして我々は、単純なエディタを持っていた

78
00:05:59,580 --> 00:06:03,300
正規表現を組み込む - ちょうど文字列を検索。

79
00:06:03,570 --> 00:06:09,110
グレップ - コマンドラインツールである - 最初の一人だった

80
00:06:09,110 --> 00:06:14,160
1960で正規表現を組み込むことは非常に一般的なツール。

81
00:06:14,160 --> 00:06:20,560
80年代では、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
ところでRegexen、正規表現の公式の複数形の一つである

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
だから私は、Pythonのバージョン2のためのマニュアルへのリンクと同様にチートシートを提供した。

120
00:09:17,720 --> 00:09:23,100
そこのPythonのバージョン3がありますが、お使いの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のimport再やった

125
00:09:43,750 --> 00:09:47,070
その後re.searchの結果を取った。

126
00:09:47,070 --> 00:09:49,910
そして、検索は2つの引数をとります。

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
その後、mは、ので、ここでハムにマッチしている

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のimport再。

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
そして、私たちの式は、Hすることができますし、私はドットMを行います。

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
あなたが行うのab *  - だから、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 bは0より大きいが続いています。

166
00:13:04,510 --> 00:13:08,000
AB？ bは0または1が続いています。

167
00:13:09,190 --> 00:13:18,580
AB {N}は、bのNが続き、その後、というようにです。

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
だから我々は1分でカップル反復パターンでより多くを見ていきます。

171
00:13:31,960 --> 00:13:42,300
だからここのツールをマッチングこれらのパターンを使用する場合に留意すべき2つのこと。

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
クリーネスター演算子を使用して。

187
00:15:18,800 --> 00:15:24,180
だからために、 "エイブラハム·リンカーンは、ハムのサンドイッチを作りました"と私は戻ってきた

188
00:15:24,180 --> 00:15:26,280
結果としてM。

189
00:15:26,280 --> 00:15:31,670
その間違いの理由は、私は、任意の数をとっているということでした

190
00:15:31,670 --> 00:15:36,140
私はHとMの間に行くには何も指定しなかったため、時間です。

191
00:15:36,140 --> 00:15:42,010
その中にMとしか例 -  Mを持っていたそこだけ例

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、単にhおよびmの任意の数の文字を返すように。

195
00:16:00,280 --> 00:16:02,950
そして、あなたはちょうど出始めているといい、よくこの、 "ああ、う考えている場合

196
00:16:02,950 --> 00:16:11,560
私にハムを取得するには、 "実際にはエイブラハム·リンカーンの時間からすべてを取る

197
00:16:11,560 --> 00:16:13,690
ハムの終わりまでのすべての方法。

198
00:16:14,040 --> 00:16:18,110
それは貪欲であり、それは時間を見ている - すべてのこの他のテキスト -  M、

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
すなわち、このを使用する1つの方法である。

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
あなたは、sは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
今日は検索を見ましたが、あなたはまた、マッチ、スプリット、findallの、およびグループを使用することができます。

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
>> したがって、1つのより高度なアプリケーションでは、ファジー·マッチングである。

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
grepのがUnixの中にある、Perlは内蔵されており、C CのPCREがあります

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、Rubyの、というように。

289
00:24:56,080 --> 00:24:58,980
>> Googleソースコード検索は、実際には特筆すべきであり、それは、次のいずれかです。

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
あなたは、Googleコード検索で調べるのであれば、コードを見つけることができます

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]