1
00:00:00,000 --> 00:00:02,000
[Powered by Google Translate] [Seminar: mønstergjenkjenning med Regular Expressions]

2
00:00:02,000 --> 00:00:04,000
[John Mussman-Harvard University]

3
00:00:04,000 --> 00:00:07,220
[Dette er CS50.-CS50.TV]

4
00:00:07,780 --> 00:00:11,610
Okay. Vel, velkommen alle. Dette er CS50 2012.

5
00:00:11,780 --> 00:00:16,610
Mitt navn er John, og jeg vil snakke i dag om regulære uttrykk.

6
00:00:16,610 --> 00:00:22,530
Regulære uttrykk er først og fremst et verktøy, men også noen ganger brukt

7
00:00:22,530 --> 00:00:28,650
i koden aktivt til hovedsak matche mønstre og strenger.

8
00:00:28,650 --> 00:00:33,800
Så her er en web tegneserien fra xkcd.

9
00:00:34,440 --> 00:00:42,370
I denne tegneserien er det en mordgåte der morderen har

10
00:00:42,370 --> 00:00:47,860
fulgt noen på ferie, og hovedpersonene må

11
00:00:47,860 --> 00:00:52,500
søke gjennom 200 megabyte av e-poster på jakt etter en adresse.

12
00:00:52,500 --> 00:00:56,090
Og de er i ferd med å gi opp da noen som vet regulære uttrykk -

13
00:00:56,090 --> 00:01:00,550
formodentlig en superhelt - swoops ned og skriver noen kode

14
00:01:00,550 --> 00:01:02,970
og løser mordgåte.

15
00:01:02,970 --> 00:01:07,370
Så formodentlig som vil være noe som du vil ha fullmakt til å gjøre

16
00:01:07,370 --> 00:01:09,370
etter dette seminaret.

17
00:01:09,370 --> 00:01:12,250
Vi er bare kommer til å gi en kortfattet innføring i språket

18
00:01:12,250 --> 00:01:16,770
og gi deg nok midlene til å gå etter mer ressurser på egen hånd.

19
00:01:17,680 --> 00:01:21,700
>> Så regulære uttrykk ser i utgangspunktet ut som dette.

20
00:01:22,930 --> 00:01:25,550
Dette er et vanlig uttrykk i Ruby.

21
00:01:25,550 --> 00:01:29,280
Det er ikke veldig forskjellig på tvers av språk.

22
00:01:29,690 --> 00:01:37,630
Vi har bare på flenger å begynne og markere det vanlige uttrykket i Ruby.

23
00:01:37,630 --> 00:01:42,880
Og dette er et vanlig uttrykk for å se etter i e-postadresse mønster.

24
00:01:42,880 --> 00:01:49,160
Så ser vi på den første biten ser for vilkårlig tall.

25
00:01:50,500 --> 00:01:54,880
Det er fordi e-postadresser ofte nødt til å starte med et alfabetisk tegn.

26
00:01:55,460 --> 00:01:59,330
Og så noen spesiell karakter etterfulgt av @-symbolet.

27
00:01:59,330 --> 00:02:03,260
Og deretter det samme for domenenavn.

28
00:02:03,260 --> 00:02:10,030
Og deretter mellom 2 og 4 tegn å se etter. Com,. Net, og så videre.

29
00:02:10,850 --> 00:02:13,200
Så det er et annet eksempel på regulært uttrykk.

30
00:02:13,200 --> 00:02:17,270
Så regulære uttrykk er protokoller for å finne patters i teksten.

31
00:02:17,270 --> 00:02:21,130
De gjør sammenligninger, valg, og utskiftninger.

32
00:02:21,690 --> 00:02:27,970
Så en tredje eksempel er å finne alle telefonnumrene som slutter på 54 i en katalog.

33
00:02:27,970 --> 00:02:34,360
Så før David rips opp CS50 katalogen kan vi søke etter

34
00:02:34,360 --> 00:02:40,450
et mønster hvor vi har parentes deretter tre tall så ender parentes,

35
00:02:40,450 --> 00:02:44,070
3 flere numre, en dash, to tall, og deretter 54.

36
00:02:44,070 --> 00:02:48,310
Og det ville være vesentlig hvordan vi kommer opp med et regulært uttrykk for å søke etter det.

37
00:02:49,150 --> 00:02:52,960
>> Så det er - vi har gjort noen ting i CS50 som er litt som

38
00:02:52,960 --> 00:02:59,740
regulære uttrykk, så - for eksempel - i dictionary.C fil

39
00:02:59,740 --> 00:03:04,720
for stavekontroll oppgavesettet kan du ha brukt fscanf

40
00:03:04,720 --> 00:03:07,930
å lese inn et ord fra ordboken.

41
00:03:07,930 --> 00:03:16,240
Og du kan se den prosentvise 45s er på utkikk etter en streng med 45 tegn.

42
00:03:16,240 --> 00:03:20,020
Så det er noe som en rudimentær regulært uttrykk.

43
00:03:21,150 --> 00:03:26,060
Og du kan ha noen 45 tegn som passer regningen i det

44
00:03:26,060 --> 00:03:28,080
og plukke dem opp.

45
00:03:28,080 --> 00:03:33,480
Og deretter det andre eksemplet i den nyeste web-programmering problem

46
00:03:33,480 --> 00:03:40,760
satt i distro kode for php faktisk vi har et enkelt regulært uttrykk.

47
00:03:40,760 --> 00:03:46,790
Og dette er bare ute for å sjekke om nettside som er vedtatt i

48
00:03:46,790 --> 00:03:51,940
samsvarer enten med innlogging registrer deg. PHP.

49
00:03:52,220 --> 00:03:57,910
Og deretter returnere sann eller usann basert på at regulært uttrykk matching.

50
00:03:59,400 --> 00:04:01,740
>> Så da bruker du vanlig uttrykk?

51
00:04:01,740 --> 00:04:04,820
Hvorfor er du her i dag?

52
00:04:05,330 --> 00:04:08,480
Så du ikke ønsker å bruke vanlig uttrykk når det er noe som

53
00:04:08,480 --> 00:04:11,640
gjør jobben for deg enda lettere.

54
00:04:11,640 --> 00:04:15,510
Så XML og HTML er faktisk ganske vanskelig

55
00:04:15,510 --> 00:04:18,480
å skrive regulære uttrykk for som vi vil se i en liten bit.

56
00:04:19,110 --> 00:04:23,280
Så det er dedikert parsere for disse språkene.

57
00:04:24,170 --> 00:04:30,060
Du må også være i orden med handelen offs og nøyaktighet ofte.

58
00:04:30,060 --> 00:04:36,220
Hvis du prøver - så vi så et regulært uttrykk for en e-postadresse,

59
00:04:37,370 --> 00:04:42,590
men si at du ville ha en bestemt e-postadresse og gradvis

60
00:04:42,590 --> 00:04:48,570
regulært uttrykk kan bli mer komplisert som det ble mer presis.

61
00:04:49,580 --> 00:04:52,260
Så det ville være en avveining.

62
00:04:52,260 --> 00:04:55,330
Du må være sikker på at du er greit å gjøre med det vanlige uttrykket.

63
00:04:55,330 --> 00:04:57,920
Hvis du vet nøyaktig hva du leter etter kan det være mer fornuftig

64
00:04:57,920 --> 00:05:02,070
å sette i gang og skrive en mer effektiv parser.

65
00:05:02,070 --> 00:05:06,980
Og til slutt er det et historisk problem med regulariteten

66
00:05:06,980 --> 00:05:08,940
av uttrykk og språk.

67
00:05:08,940 --> 00:05:12,960
Regulære uttrykk er faktisk mye kraftigere enn

68
00:05:12,960 --> 00:05:16,450
regulære uttrykk pr sier i en formell forstand.

69
00:05:17,130 --> 00:05:20,150
>> Så jeg ønsker ikke å gå for langt inn i den formelle teorien,

70
00:05:20,150 --> 00:05:24,000
men de fleste språk som vi koden i faktisk ikke er vanlig.

71
00:05:24,000 --> 00:05:29,110
Og dette er grunnen til regulære uttrykk noen ganger ikke regnes alt som sikker.

72
00:05:29,670 --> 00:05:33,150
Så i utgangspunktet er det en Chomsky hierarki for språk,

73
00:05:33,150 --> 00:05:38,400
og regulære uttrykk er bygd opp ved hjelp av union, sammensetning,

74
00:05:38,400 --> 00:05:41,810
og Kleene stjerners operasjon som vi vil se i noen få minutter.

75
00:05:43,130 --> 00:05:48,860
Hvis du er interessert i teorien er det ganske mye som skjer der under panseret.

76
00:05:50,360 --> 00:05:55,880
>> Så en kort historie - bare for sammenhengen her - regelmessige sett kom opp

77
00:05:55,880 --> 00:05:59,580
i 1950, og da hadde vi enkle redaktører som

78
00:05:59,580 --> 00:06:03,300
innlemmet regulære uttrykk - bare å søke etter strenger.

79
00:06:03,570 --> 00:06:09,110
Grep - som er et kommandolinje verktøy - var en av de første

80
00:06:09,110 --> 00:06:14,160
svært populære verktøy som innlemmet regulære uttrykk i 1960.

81
00:06:14,160 --> 00:06:20,560
På 80-tallet, ble Perl bygget - er et programmeringsspråk som

82
00:06:20,560 --> 00:06:24,110
inkorporerer regulære uttrykk svært fremtredende.

83
00:06:24,550 --> 00:06:30,130
Og deretter mer nylig har vi hatt Perl kompatible regulære uttrykk

84
00:06:30,130 --> 00:06:35,870
protokoller i utgangspunktet på andre språk som bruker mye av den samme syntaksen.

85
00:06:36,630 --> 00:06:39,840
Selvfølgelig den viktigste hendelsen var i 2008

86
00:06:39,840 --> 00:06:43,040
hvor det var den første nasjonale Regular Expressions Day,

87
00:06:43,040 --> 00:06:47,350
som jeg tror er juni 1 hvis du vil feire det.

88
00:06:48,430 --> 00:06:50,840
>> Igjen, bare litt mer teori her.

89
00:06:52,180 --> 00:06:55,320
Så det finnes et par forskjellige måter å konstruere regulære uttrykk.

90
00:06:55,950 --> 00:07:02,050
En enkel måte er å bygge uttrykket at du kommer til å

91
00:07:02,050 --> 00:07:07,500
kjøre på strengen tolke - i utgangspunktet bygge en liten mini-program som

92
00:07:07,500 --> 00:07:11,870
vil analysere deler av en streng og se, "Oh, passer dette det vanlige uttrykket eller ikke?"

93
00:07:12,250 --> 00:07:14,250
Og deretter kjøre det.

94
00:07:14,250 --> 00:07:17,300
Så hvis du har et veldig lite vanlig uttrykk, er dette sannsynligvis

95
00:07:17,300 --> 00:07:19,380
den mest effektive måten å gjøre det.

96
00:07:20,090 --> 00:07:25,420
Og så hvis du - et annet alternativ er å holde rekonstruere

97
00:07:25,420 --> 00:07:30,260
uttrykk som du går, og det er simulere mulighet.

98
00:07:30,440 --> 00:07:37,690
Og disse tidlige forsøk på regulære uttrykk algoritmer var

99
00:07:37,690 --> 00:07:44,330
relativt enkel og relativt rask, men hadde ikke mye fleksibilitet.

100
00:07:44,330 --> 00:07:47,500
Så for å gjøre enda noen av de tingene som vi kommer til å se på

101
00:07:47,500 --> 00:07:52,860
i dag har vi måtte gjøre mer komplekse regulære uttrykk

102
00:07:52,860 --> 00:07:56,650
implementeringer som er potensielt mye tregere, så det er noe å huske på

103
00:07:57,510 --> 00:08:02,920
Det er også en vanlig uttrykk fornektelse av angrep utvalg

104
00:08:02,920 --> 00:08:08,330
som utnytter potensialet for disse nyere implementeringer av

105
00:08:08,330 --> 00:08:10,930
regulære uttrykk til å bli svært komplisert.

106
00:08:11,570 --> 00:08:15,650
Og på samme måte som vi så i buffer overflow angrep,

107
00:08:15,650 --> 00:08:21,610
du har angrep som fungerer ved å gjøre rekursive løkker som

108
00:08:21,610 --> 00:08:24,400
overkjørt kapasiteten på minnet.

109
00:08:24,780 --> 00:08:29,540
Og forresten Regexen er en av de offisielle Flertall av regulære uttrykk

110
00:08:29,540 --> 00:08:32,890
ved analogi til okser i Anglo-Saxon.

111
00:08:33,500 --> 00:08:40,169
>> OK, så Python Library mange av dere her i person har Mac,

112
00:08:40,169 --> 00:08:43,860
slik at du faktisk kan trekke dette opp på skjermen.

113
00:08:43,860 --> 00:08:47,480
Regulære uttrykk er bygget inn i Python.

114
00:08:48,070 --> 00:08:53,020
Og så Python er forhåndsinstallert på Mac og også tilgjengelig på nettet på denne linken.

115
00:08:53,770 --> 00:08:57,350
Så hvis du ser at du kan pause og sørg for at du har Python

116
00:08:58,080 --> 00:09:00,170
som vi spiller rundt her.

117
00:09:00,780 --> 00:09:06,420
Det er en manuell nettet, så hvis du bare skriver Python inn i datamaskinen

118
00:09:06,420 --> 00:09:10,500
vil du se at den versjonen kommer opp i terminalen.

119
00:09:11,070 --> 00:09:17,720
Så jeg laget en link til manualen for versjon 2 av Python, samt en jukselapp.

120
00:09:17,720 --> 00:09:23,100
Det er en versjon 3 av Python, men Mac-maskinen ikke nødvendigvis

121
00:09:23,100 --> 00:09:25,130
komme med det forhåndsinstallert.

122
00:09:25,130 --> 00:09:27,360
Så ikke veldig annerledes.

123
00:09:27,360 --> 00:09:33,270
Ok, så noen grunnleggende bruk av regulære uttrykk i Python.

124
00:09:34,080 --> 00:09:42,650
>> Så her brukte jeg et veldig enkelt uttrykk, så jeg gjorde Python import re

125
00:09:43,750 --> 00:09:47,070
og deretter tok et resultat av re.search.

126
00:09:47,070 --> 00:09:49,910
Og søket tar to argumenter.

127
00:09:49,910 --> 00:09:56,040
Den første er det vanlige uttrykket, og den andre er teksten

128
00:09:56,040 --> 00:09:58,290
eller streng du vil analysere.

129
00:09:58,290 --> 00:10:01,210
Og da jeg skrevet ut result.group.

130
00:10:01,580 --> 00:10:05,860
Så disse er de to grunnleggende funksjonene vi kommer til å se i dag

131
00:10:06,790 --> 00:10:10,170
i å lære om regulære uttrykk.

132
00:10:10,170 --> 00:10:12,880
Så bare bryte ned dette regulære uttrykket her

133
00:10:12,880 --> 00:10:21,770
t og deretter \ w og m så \ w godtar bare noe alfabetisk tegn på det.

134
00:10:21,850 --> 00:10:26,820
Så her er vi på jakt etter en "h" og deretter en annen alfabetisk tegn

135
00:10:26,820 --> 00:10:30,060
og deretter m, så her som ville matche skinke

136
00:10:30,060 --> 00:10:34,480
i, "Abraham Lincoln og skinke smørbrød."

137
00:10:35,040 --> 00:10:37,150
Dette er resultatet av denne gruppen.

138
00:10:37,680 --> 00:10:43,130
En annen ting som vi kan gjøre er å bruke våre før tekststrenger i Python.

139
00:10:43,130 --> 00:10:46,220
Så jeg antar jeg vil gå foran og trekke det opp her.

140
00:10:46,220 --> 00:10:49,210
Python import re.

141
00:10:50,070 --> 00:10:54,000
Og hvis jeg skulle gjøre det samme - la oss si teksten er,

142
00:10:55,390 --> 00:11:00,800
"Abraham," la oss zoome inn - det vi går.

143
00:11:01,610 --> 00:11:06,430
Teksten er: "Abraham spiser skinke."

144
00:11:07,460 --> 00:11:15,260
Ok, og deretter resultere = re.search.

145
00:11:16,260 --> 00:11:22,020
Og da er vårt uttrykk kan være h, og da vil jeg gjøre dot m.

146
00:11:22,020 --> 00:11:26,280
Så dot tar bare noen tegn som ikke er en ny linje inkludert tall,

147
00:11:26,280 --> 00:11:28,650
prosentpoeng skilt, noe sånt.

148
00:11:28,650 --> 00:11:38,030
Og deretter tekst - bom - og deretter result.group--ja.

149
00:11:38,030 --> 00:11:41,820
Så det er bare hvordan man skal gjennomføre grunnleggende funksjonalitet her.

150
00:11:42,300 --> 00:11:55,110
Hvis vi hadde en tekst ring som - som gal tekst - inkludert si masse tilbake skråstreker

151
00:11:55,110 --> 00:12:01,180
og strenger inne og ting som kunne se ut som escape-sekvenser,

152
00:12:01,180 --> 00:12:08,480
da vi sannsynligvis vil bruke rå skriving å sørge for at blir akseptert.

153
00:12:08,480 --> 00:12:14,120
Og som bare ser slik ut.

154
00:12:14,120 --> 00:12:17,810
Så hvis vi var ute for hver av dem der vi ikke skal finne noe.

155
00:12:19,070 --> 00:12:21,680
Men det er hvordan du ville gjennomføre det, like før streng av

156
00:12:21,680 --> 00:12:24,990
det vanlige uttrykket du la brevet r.

157
00:12:26,150 --> 00:12:30,260
>> Ok, så la oss holde det gående.

158
00:12:30,260 --> 00:12:33,730
Greit - så la oss se på et par repetitive mønstre her.

159
00:12:34,750 --> 00:12:39,150
Så en ting som du ønsker å gjøre er å gjenta ting

160
00:12:40,040 --> 00:12:42,480
som du søker gjennom tekst.

161
00:12:42,480 --> 00:12:48,300
Så for å gjøre en etterfulgt av en rekke b - du gjør ab *.

162
00:12:48,630 --> 00:12:51,620
Og så er det en rekke andre regler også.

163
00:12:51,620 --> 00:12:54,380
Og du kan se alle disse opp, jeg vil bare kjøre gjennom noen av de

164
00:12:54,380 --> 00:12:57,630
mest brukte seg.

165
00:12:57,630 --> 00:13:03,920
Så ab + er et etterfulgt av en hvilken som helst n er større enn 0 av B.

166
00:13:04,510 --> 00:13:08,000
ab? er et etterfulgt av 0 eller 1 av f..

167
00:13:09,190 --> 00:13:18,580
ab N {} er et etterfulgt av N for B, og deretter så videre.

168
00:13:18,580 --> 00:13:22,820
Hvis du har to tallene i klammeparentes du spesifisere et område

169
00:13:23,300 --> 00:13:25,440
som kan være muligens matchet.

170
00:13:26,390 --> 00:13:30,420
Så vil vi se mer på et par repeterende mønstre i et minutt.

171
00:13:31,960 --> 00:13:42,300
Så to ting å huske på når du bruker disse mønstergjenkjenning verktøy her.

172
00:13:42,300 --> 00:13:52,120
Så si at vi ønsker å se på hm av, "Abraham Lincoln gjør skinke smørbrød."

173
00:13:52,120 --> 00:13:55,230
Så jeg endret Abraham Lincolns navn til Abraham.

174
00:13:55,230 --> 00:14:00,290
Og nå er vi på jakt etter hva som er returnert av denne søkefunksjonen,

175
00:14:00,290 --> 00:14:03,270
og den returnerer bare skinke i dette tilfellet.

176
00:14:03,620 --> 00:14:08,080
Og det gjør at fordi søk bare naturlig tar venstre mest køen.

177
00:14:08,080 --> 00:14:12,130
Og alle regulære uttrykk med mindre du angir noe annet vil gjøre det.

178
00:14:12,830 --> 00:14:18,880
Hvis vi ønsket å finne alt det er en funksjon for det - finne alle.

179
00:14:18,880 --> 00:14:35,100
Slik at vi kunne bare se ut som alle = re.findall ('h.m', text)

180
00:14:35,100 --> 00:14:44,540
og deretter all.group ().

181
00:14:44,540 --> 00:14:51,040
Alle produserer både skinke og skinke, i dette tilfellet både av strengene i Abraham hver skinke.

182
00:14:51,610 --> 00:14:55,110
Så det er et annet alternativ.

183
00:14:56,250 --> 00:15:06,940
>> Flott. Den andre ting å huske på er at regulære uttrykk ta den største intuitivt.

184
00:15:06,940 --> 00:15:09,520
La oss se på dette eksempelet.

185
00:15:10,200 --> 00:15:16,070
Vi gjorde det venstre mest søket her, og da jeg forsøkte et større søk

186
00:15:16,070 --> 00:15:18,800
bruker Kleene stjerners operatør.

187
00:15:18,800 --> 00:15:24,180
Så for, "Abraham Lincoln gjør skinke smørbrød", og jeg bare kom tilbake

188
00:15:24,180 --> 00:15:26,280
m som resultat.

189
00:15:26,280 --> 00:15:31,670
Grunnen til at feilen var at jeg kunne ha tatt en rekke

190
00:15:31,670 --> 00:15:36,140
h er fordi jeg ikke har angitt noe å gå i mellom h og m.

191
00:15:36,140 --> 00:15:42,010
Den eneste eksempel der som hadde m - de eneste eksemplene der med m i det

192
00:15:42,010 --> 00:15:46,220
og en rekke h-tallet var bare strengen m.

193
00:15:46,490 --> 00:15:51,850
Da jeg prøvde det igjen, jeg sa: "Ok, la oss få den faktiske største gruppen her."

194
00:15:51,850 --> 00:15:59,670
Og så gjorde jeg h.. * M, slik at bare returnerer et vilkårlig antall bokstaver mellom h og m.

195
00:16:00,280 --> 00:16:02,950
Og hvis du bare starte opp og tenker: "Å, vil okay, vel dette

196
00:16:02,950 --> 00:16:11,560
få meg skinke, "det tar faktisk alt fra t på Abraham Lincoln

197
00:16:11,560 --> 00:16:13,690
helt opp til slutten av skinke.

198
00:16:14,040 --> 00:16:18,110
Det er grådig, det ser h - alt dette andre tekst - m,

199
00:16:18,110 --> 00:16:21,280
og det er det som trengs i.

200
00:16:22,060 --> 00:16:27,480
Dette er en spesielt skjerpende - dette er en funksjon vi kan også

201
00:16:27,480 --> 00:16:30,670
angir for det ikke være grådig bruker andre funksjoner.

202
00:16:31,480 --> 00:16:34,490
Men dette er noe vi må huske på spesielt

203
00:16:34,490 --> 00:16:38,720
når man ser på HTML-teksten, som er en grunn til at

204
00:16:38,720 --> 00:16:41,500
regulære uttrykk er vanskelig for HTML.

205
00:16:42,460 --> 00:16:46,310
Fordi hvis du har en HTML åpen tag og så mange ting i midten

206
00:16:46,310 --> 00:16:49,820
og deretter noen andre HTML stengt tag mye senere i programmet,

207
00:16:49,820 --> 00:16:55,420
du nettopp har spist opp mye av HTML-koden muligens ved en feiltakelse.

208
00:16:56,200 --> 00:17:01,840
>> All right - så flere spesialtegn, som mange andre språk,

209
00:17:01,840 --> 00:17:04,780
vi slippe å bruke slash.

210
00:17:04,780 --> 00:17:10,329
Så vi kan bruke dot å spesifisere hvilket som helst tegn unntatt for en ny linje.

211
00:17:10,329 --> 00:17:14,550
Vi kan bruke flukten w for å angi en alfabetisk tegn.

212
00:17:14,550 --> 00:17:20,329
Og ved analogi flukt d for alle heltall - numerisk karakter.

213
00:17:20,630 --> 00:17:27,440
Vi kan spesifisere - vi kan bruke parentes for å angi beslektede uttrykk.

214
00:17:27,440 --> 00:17:30,970
Så dette ville godta a, b eller c.

215
00:17:31,320 --> 00:17:37,000
Og vi kan også angi eller alternativer for enten a eller b.

216
00:17:37,000 --> 00:17:41,110
For eksempel - hvis vi leter etter flere muligheter

217
00:17:41,110 --> 00:17:44,940
i parentes kan vi bruke eller operatør som i -

218
00:17:44,940 --> 00:17:52,480
så la oss gå tilbake til dette eksempelet her.

219
00:17:53,000 --> 00:17:59,790
Og nå la oss ta - la oss gå tilbake til dette eksempelet her, og deretter

220
00:17:59,790 --> 00:18:12,290
ta ae - så dette bør gå tilbake - Jeg antar dette er fremdeles Abraham.

221
00:18:12,290 --> 00:18:17,410
Så dette - hvis vi gjør alt - flott.

222
00:18:17,410 --> 00:18:22,700
Så la oss oppdatere teksten her.

223
00:18:22,700 --> 00:18:34,690
"Abraham spiser skinke mens hemming hans -. Mens hemming" Flott.

224
00:18:44,090 --> 00:18:47,330
Alle. Flott. Nå får vi skinke, skinke, og hem.

225
00:18:48,510 --> 00:18:59,370
Mens hemming - mens nynner til ham - mens nynner til hem ham. Flott.

226
00:19:00,350 --> 00:19:03,250
Samme.

227
00:19:03,820 --> 00:19:09,180
Nå er alt returnerer fortsatt bare skinke, skinke, og hem uten å plukke opp på nynne eller ham.

228
00:19:09,940 --> 00:19:22,600
Stor - så hva om vi ønsket å se på enten det - så vi kan også gjøre

229
00:19:23,510 --> 00:19:33,810
ham eller - vi vil komme tilbake til det.

230
00:19:34,810 --> 00:19:45,760
Ok - så - greit - i stillinger kan du også bruke cirkumflekstegnet eller dollartegn

231
00:19:45,760 --> 00:19:49,350
å spesifisere at du er ute etter noe i starten eller slutten på en streng.

232
00:19:50,260 --> 00:19:52,260
Eller starten eller slutten av et ord.

233
00:19:52,400 --> 00:19:54,470
Det er en måte å bruke som.

234
00:19:55,630 --> 00:20:01,160
>> Ok - så la oss leke seg med en litt større blokk med tekst.

235
00:20:03,950 --> 00:20:08,310
La oss si at denne raden her - denne uttalelsen her.

236
00:20:08,310 --> 00:20:11,360
Kraften i regulært uttrykk er at de kan angi mønstre

237
00:20:11,360 --> 00:20:13,390
ikke bare fikset tegn.

238
00:20:14,900 --> 00:20:18,790
La oss gjøre - la oss kalle denne blokken.

239
00:20:22,400 --> 00:20:27,110
Da vil vi lese alt dette i.

240
00:20:28,890 --> 00:20:50,820
Og deretter har en - la oss gjøre alt =, så hva er noen ting vi kunne søke her lønnsomt?

241
00:20:50,820 --> 00:20:54,070
Vi kunne se for uttrykket øret.

242
00:20:55,050 --> 00:21:01,520
Ikke veldig interessant. Hva om det? Vi får se hva som skjer.

243
00:21:03,710 --> 00:21:05,710
Jeg ga det et problem.

244
00:21:06,380 --> 00:21:10,750
Så en rekke ting før re og alt.

245
00:21:10,750 --> 00:21:15,630
Så det skal returnere alt fra starten til alle re kanskje et par ganger.

246
00:21:18,800 --> 00:21:21,970
Og så her har vi kraften av regulære uttrykk er at de

247
00:21:21,970 --> 00:21:24,900
kan spesifisere mønstre ikke bare tegn her er.

248
00:21:24,900 --> 00:21:28,510
Så hele veien opp til den endelige re, det startet med venstre mest og var grådig.

249
00:21:30,710 --> 00:21:32,710
La oss se - hva annet kan vi se etter.

250
00:21:32,710 --> 00:21:39,860
Jeg antar en ting hvis du var interessert i jakt etter pronomen hun og han,

251
00:21:39,860 --> 00:21:44,600
du kan se etter er å være lik 0 eller 1

252
00:21:44,600 --> 00:21:49,710
og uttrykket han, og det er sannsynligvis ikke kommer til å returnere -

253
00:21:49,710 --> 00:21:58,020
oh, jeg antar det vendte han tilbake fordi det vi ser på kraften, den dagen er her.

254
00:22:00,590 --> 00:22:06,270
La oss forsøke å spesifisere at dette må komme i starten av noe.

255
00:22:06,640 --> 00:22:09,530
La oss se om det faller av.

256
00:22:09,530 --> 00:22:19,630
Så vi kan gjøre fett, og det vi ikke får noe fordi hun og han

257
00:22:19,630 --> 00:22:22,870
ikke forekommer i denne setningen.

258
00:22:24,960 --> 00:22:30,410
Flott. Ok - så tilbake til katten her.

259
00:22:30,410 --> 00:22:35,720
Så komplekse mønstre er skade hjernen.

260
00:22:35,720 --> 00:22:40,500
Så det er derfor vi bruker regulære uttrykk for å unngå disse problemene.

261
00:22:40,820 --> 00:22:43,520
>> Så her er noen andre nyttige moduser du kan spille rundt med.

262
00:22:43,520 --> 00:22:50,290
Vi så på søk i dag, men du kan også bruke kampen, split, findall og grupper.

263
00:22:50,290 --> 00:22:53,970
Så andre kule ting du kan gjøre med regulære uttrykk dessuten bare

264
00:22:53,970 --> 00:22:58,870
på jakt etter mønstre tar et mønster og holder alle kampene -

265
00:22:58,870 --> 00:23:02,530
variablene - og deretter bruke dem i koden senere.

266
00:23:02,850 --> 00:23:05,980
Som kan være ganske nyttig. Andre ting kan være å telle.

267
00:23:05,980 --> 00:23:11,720
Så vi kan telle antall forekomster av et regulært uttrykk mønster,

268
00:23:11,720 --> 00:23:13,960
og det er det vi kan bruke grupper for.

269
00:23:13,960 --> 00:23:17,550
Og andre moduser samt er også mulig.

270
00:23:18,040 --> 00:23:22,980
Så jeg vil bare snakke litt mer om andre måter du kan bruke vanlige uttrykk.

271
00:23:22,980 --> 00:23:29,100
>> Så en mer avansert program er i fuzzy matching.

272
00:23:29,100 --> 00:23:33,450
Så hvis du er ute etter en tekst for uttrykket, Julius Cæsar,

273
00:23:33,450 --> 00:23:37,740
og du ser enten Gaius Julius Caesar eller navnet Julius Caesar i andre språk,

274
00:23:37,740 --> 00:23:44,400
kan dere også vil tildele en viss vekt på disse verdiene.

275
00:23:44,400 --> 00:23:48,930
Og hvis det er nært nok - hvis det krysser en viss terskel - så du vil

276
00:23:48,930 --> 00:23:50,860
å være i stand til å akseptere Julius Cæsar.

277
00:23:50,860 --> 00:24:00,580
Så det er et par ulike implementeringer for at i noen andre språk også.

278
00:24:02,580 --> 00:24:08,420
Her er noen andre verktøy, Regex Pal - en hendig liten app på nettet for å

279
00:24:08,420 --> 00:24:12,190
kontrollere om regulære uttrykk er sammensatt riktig.

280
00:24:12,190 --> 00:24:18,500
Det finnes også frittstående verktøy som du kan kjøre fra skrivebordet

281
00:24:18,500 --> 00:24:22,100
som Ultra Pico, og så vel som bare kokebøker.

282
00:24:22,100 --> 00:24:25,410
Så hvis du gjør et prosjekt som involverer massevis av regulære uttrykk

283
00:24:25,410 --> 00:24:29,810
dette er trolig stedet å gå utenfor i dag.

284
00:24:31,520 --> 00:24:35,770
Og så bare for å gi deg en følelse av hvor vanlig det er

285
00:24:35,770 --> 00:24:44,090
det er grep i Unix, har Perl innebygd, og C er det PCRE for C.

286
00:24:44,090 --> 00:24:48,890
Og så alle disse andre språk har også regulære uttrykk pakker

287
00:24:48,890 --> 00:24:52,020
som opererer med i hovedsak de samme syntaks vi fikk en smak av i dag.

288
00:24:52,020 --> 00:24:54,790
PHP, Java, Ruby, og så videre.

289
00:24:56,080 --> 00:24:58,980
>> Google Code Search er faktisk verdt å nevne, det er en av de

290
00:24:58,980 --> 00:25:05,720
relativt få programmer der ute som gjør det mulig for publikum å få tilgang

291
00:25:05,720 --> 00:25:07,800
sin database ved hjelp av regulære uttrykk.

292
00:25:07,800 --> 00:25:12,920
Så hvis du ser på Google Code Search kan du finne koden

293
00:25:12,920 --> 00:25:16,880
hvis du er ute etter en forekomst av hvordan en funksjon kan benyttes,

294
00:25:16,880 --> 00:25:21,610
du kan bruke et vanlig uttrykk for å finne den funksjonen blir brukt i alle slags forskjellige saker.

295
00:25:21,610 --> 00:25:28,000
Du kan se etter fwrite, og så kan du se etter flagget skrive eller lese

296
00:25:28,000 --> 00:25:32,000
Hvis du ønsker et eksempel på fwrite blir brukt i dette tilfellet.

297
00:25:33,530 --> 00:25:37,010
Så det samme der, og her er noen referanser.

298
00:25:37,010 --> 00:25:40,990
Dette vil være tilgjengelig på nettet også, så det går fremover hvis

299
00:25:40,990 --> 00:25:45,560
Ønsker du å se på Python, grep, Perl - du bare ønsker å få litt inspirasjon

300
00:25:45,560 --> 00:25:50,650
eller hvis du ønsker å se mer på teorien her er noen god hopping av steder.

301
00:25:50,650 --> 00:25:53,870
Tusen takk.

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