1
00:00:00,000 --> 00:00:02,270
>> [Omtale: Quiz 1]

2
00:00:02,270 --> 00:00:04,620
[Ali fant sitt, Oreoluwa Barbarinsa, Lucas Freitas, Rob Bowden] [Harvard University]

3
00:00:04,620 --> 00:00:07,660
[Dette er CS50.] [CS50.TV]

4
00:00:07,660 --> 00:00:11,610
[Lucas Freitas] Velkommen alle sammen. Dette er vurdering for quiz en.

5
00:00:11,610 --> 00:00:15,040
Akkurat som en ansvarsfraskrivelse, dette er - jeg mener, vi kommer til å prøve å dekke

6
00:00:15,040 --> 00:00:17,770
så mye materiale som mulig, men det betyr ikke at

7
00:00:17,770 --> 00:00:20,780
vi kommer til å dekke alle de tingene som kan være i quiz en.

8
00:00:20,780 --> 00:00:25,270
Så vær sikker på at du også ta en titt på forelesning, seksjoner, alt du kan.

9
00:00:25,270 --> 00:00:28,240
Quiz 1 kommer til å være på onsdag, neste onsdag.

10
00:00:28,240 --> 00:00:33,800
Så sørg for å studere. Det kommer til å være, ganske mye, som den første quiz

11
00:00:33,800 --> 00:00:36,390
hensyn til format, men det er trolig kommer til å være mye vanskeligere.

12
00:00:36,390 --> 00:00:39,600
Minst, i fjor da jeg tok 50, jeg trodde det var mye vanskeligere.

13
00:00:39,600 --> 00:00:42,410
Så studere mye.

14
00:00:42,410 --> 00:00:45,190
>> Jeg kommer til å dekke datastrukturer og Huffman koding.

15
00:00:45,190 --> 00:00:47,910
Dette er noe som mange mennesker tror er kompleks,

16
00:00:47,910 --> 00:00:51,930
men jeg skal prøve å gjøre det så enkelt som mulig.

17
00:00:51,930 --> 00:00:56,330
Først av alt, hva ønsker vi dere å vite for quiz 1 er å

18
00:00:56,330 --> 00:01:00,970
forstå de konseptuelle beskrivelser av hver av de datastrukturer som jeg kommer til å presentere.

19
00:01:00,970 --> 00:01:03,960
Det betyr at du ikke trenger å faktisk

20
00:01:03,960 --> 00:01:07,020
gjennomføre en hash tabell i quiz en.

21
00:01:07,020 --> 00:01:10,250
Vi ønsker ikke å gjennomføre en hel hash table, kanskje vi skal prøve

22
00:01:10,250 --> 00:01:13,090
for at du skal gjennomføre noen funksjoner,

23
00:01:13,090 --> 00:01:16,940
de vanligste operasjonene, men vi kommer ikke til å gjøre deg gjennomføre alt.

24
00:01:16,940 --> 00:01:21,010
Så det er viktig at du forstår konseptet bak hver datastruktur

25
00:01:21,010 --> 00:01:23,510
og også at du er i stand til å kode i C,

26
00:01:23,510 --> 00:01:27,880
kun de mest vanlige operasjoner de har for hver datastruktur.

27
00:01:27,880 --> 00:01:30,090
Og også kunne gjennomgå pekere og structs,

28
00:01:30,090 --> 00:01:33,470
fordi de synes mye i disse datastrukturer.

29
00:01:33,470 --> 00:01:37,380
>> Først knyttet lister. Koplede listene er faktisk veldig lik matriser,

30
00:01:37,380 --> 00:01:39,930
men forskjellen mellom en lenket liste og en matrise,

31
00:01:39,930 --> 00:01:45,160
først og fremst er at en lenket liste har en meget fleksibel størrelse,

32
00:01:45,160 --> 00:01:50,060
mens i matriser må du enten velge en veldig stor størrelse for matrisen,

33
00:01:50,060 --> 00:01:53,710
slik at du vet at du kommer til å være i stand til å lagre alle dine data i denne matrisen,

34
00:01:53,710 --> 00:01:59,370
eller du må bruke malloc å ha en fleksibel lengde på array.

35
00:01:59,370 --> 00:02:03,680
I lenkede lister er det veldig lett å bare få flere elementer,

36
00:02:03,680 --> 00:02:07,210
sette flere elementer i lenket liste eller fjerne elementer.

37
00:02:07,210 --> 00:02:09,370
Og faktisk, hvis du ikke vil at lenket liste skal sorteres,

38
00:02:09,370 --> 00:02:13,950
du kan søke og fjerne elementer i konstant tid,

39
00:02:13,950 --> 00:02:16,800
så O (1) tid, så det er veldig praktisk.

40
00:02:16,800 --> 00:02:20,660
Du må bare være forsiktig med å alltid huske å malloc og gratis nodene,

41
00:02:20,660 --> 00:02:25,510
bare fordi hvis du ikke gjør det, vil du ha minnelekkasjer.

42
00:02:25,510 --> 00:02:31,480
Så lenkede lister - definisjonen av en node er akkurat som det vi har rett der.

43
00:02:31,480 --> 00:02:35,110
Jeg satte int n, men du kan lagre alle data du vil.

44
00:02:35,110 --> 00:02:37,280
Så hvis du ønsker å lagre en streng, er det fint.

45
00:02:37,280 --> 00:02:41,690
Hvis du ønsker å lagre en struct, det er greit, en dobbel, hva du vil.

46
00:02:41,690 --> 00:02:44,630
Jeg bare sette int n for eksemplene her.

47
00:02:44,630 --> 00:02:46,800
Og du har en peker til neste node.

48
00:02:46,800 --> 00:02:51,940
Så, i utgangspunktet, har en lenket liste noen data, og deretter den peker til neste node.

49
00:02:51,940 --> 00:02:56,710
Hvis det er det siste elementet i lenket liste, det kommer til å peke til NULL.

50
00:02:56,710 --> 00:02:59,060
Dette er altså et eksempel på en lenket liste.

51
00:02:59,250 --> 00:03:05,960
>> Ok, så nå får vi se hva vi skal gjøre hvis jeg vil sette inn et element i en lenket liste.

52
00:03:05,960 --> 00:03:08,810
For det første vil en funksjonsinnsats være av typen void

53
00:03:08,810 --> 00:03:11,350
fordi jeg ikke ønsker å returnere noe.

54
00:03:11,350 --> 00:03:14,200
Og jeg kommer til å ta en int som et argument,

55
00:03:14,200 --> 00:03:17,090
fordi jeg ønsker å vite hva jeg vil sette inn.

56
00:03:17,090 --> 00:03:21,840
Så hva er det første jeg bør gjøre? Vel, jeg skal malloc på newnode,

57
00:03:21,840 --> 00:03:24,240
slik at det er den første linje.

58
00:03:24,240 --> 00:03:27,580
Jeg er bare å skape en ny node til å sette i en lenket liste.

59
00:03:27,580 --> 00:03:32,360
Så hva kan jeg gjøre? Vel, vi vet at i våre implementeringer av lenkede lister

60
00:03:32,360 --> 00:03:38,180
i klassen, vi alltid setter hodet som en global variabel.

61
00:03:38,180 --> 00:03:41,800
Så det vi kan gjøre er å endre hodet.

62
00:03:41,800 --> 00:03:44,300
Jeg kan gjøre dette nye noden bli ny leder,

63
00:03:44,300 --> 00:03:46,670
og det kommer til å peke til den forrige hodet.

64
00:03:46,670 --> 00:03:50,390
Hvordan kan vi gjøre det? Det første jeg må gjøre

65
00:03:50,390 --> 00:03:54,770
er å endre 'n' i den nye noden til verdi,

66
00:03:54,770 --> 00:03:57,530
som ble sendes til funksjonen.

67
00:03:57,530 --> 00:04:01,050
Deretter newnode det neste kommer til å være leder.

68
00:04:01,050 --> 00:04:05,800
Hodet kommer til å bli newnode. Så det er ganske enkelt.

69
00:04:05,800 --> 00:04:10,090
For å slette en node, kan vi gjøre det som -

70
00:04:10,090 --> 00:04:14,790
En måte vi kan gjøre det på er å si,

71
00:04:14,790 --> 00:04:18,160
ok, hvis jeg ønsket å slette, for eksempel tre,

72
00:04:18,160 --> 00:04:24,850
hva jeg kan gjøre er å bare peke forrige node

73
00:04:24,850 --> 00:04:27,580
til den neste noden 3.

74
00:04:27,580 --> 00:04:29,400
Så jeg ville bare gjøre noe sånt.

75
00:04:29,400 --> 00:04:33,400
Men hva er problemet med å gjøre det?

76
00:04:33,400 --> 00:04:37,400
Jeg har en minnelekkasje, så jeg har ikke tilgang til nummer tre lenger.

77
00:04:37,400 --> 00:04:42,480
Problemet med det er at jeg ikke kommer til å være i stand til å frigjøre den noden.

78
00:04:42,480 --> 00:04:45,360
Jeg kommer til å ha minnelekkasje og (uforståelig) kommer til å hate meg.

79
00:04:45,360 --> 00:04:49,370
Så i stedet for å gjøre det, bør jeg nok ha en midlertidig peker.

80
00:04:49,370 --> 00:04:53,210
Så jeg satte temp. Det kommer til å peke på noden som jeg ønsker å slette.

81
00:04:53,210 --> 00:04:58,170
Og så kan jeg flytte de tidligere noder til punkt til neste node

82
00:04:58,170 --> 00:05:00,390
av noden som jeg ønsker å slette.

83
00:05:00,390 --> 00:05:02,730
Og til slutt, kan jeg frigjøre pekeren.

84
00:05:02,730 --> 00:05:07,480
Må jeg å frigjøre peker som jeg laget akkurat der?

85
00:05:07,480 --> 00:05:09,560
Jeg trenger ikke å, nettopp fordi -

86
00:05:09,560 --> 00:05:13,430
forskjellen er at denne noden ble opprettet ved hjelp av malloc,

87
00:05:13,430 --> 00:05:17,280
så det er i haugen, mens dette ble nettopp erklært som en NULL-bryteren i bunken.

88
00:05:17,280 --> 00:05:20,000
Så jeg trenger ikke å få det løs.

89
00:05:20,000 --> 00:05:22,030
>> Ok. Så nå la oss snakke om stabler.

90
00:05:22,030 --> 00:05:24,680
Stacks er ganske grei.

91
00:05:24,680 --> 00:05:29,540
Vi gjorde stabler og køer i klassen bare ved hjelp av matriser,

92
00:05:29,540 --> 00:05:32,820
men du bør være kjent - bare vær oppmerksom på

93
00:05:32,820 --> 00:05:40,740
at du også kan gjøre stabler i køer med lenkede lister også.

94
00:05:40,740 --> 00:05:44,460
Så hvis du har en rekke, ville det være en stabel?

95
00:05:44,460 --> 00:05:46,810
En stabel, først, blir nødt til å ha en størrelse.

96
00:05:46,810 --> 00:05:49,950
Du må lagre hva er størrelsen av stabelen at du har akkurat nå.

97
00:05:49,950 --> 00:05:52,980
Og også ville ha en rekke, i dette tilfelle av tall,

98
00:05:52,980 --> 00:05:55,120
men hvis du vil, kan det være en rekke

99
00:05:55,120 --> 00:06:00,380
strenger, en rekke struct, noe som du ønsker å lagre.

100
00:06:00,380 --> 00:06:03,240
Om bunken: Forskjellen mellom en stabel og en lenket liste

101
00:06:03,240 --> 00:06:08,590
er at det i stabelen du kun har tilgang til det siste element som er satt inn i stabelen.

102
00:06:08,590 --> 00:06:11,770
Det kalles sist inn, først ut.

103
00:06:11,770 --> 00:06:15,090
Akkurat som du har en bunke med magasiner,

104
00:06:15,090 --> 00:06:17,670
hvis du setter en skuff på toppen av bunken,

105
00:06:17,670 --> 00:06:22,670
du må fjerne den skuffen først å ha tilgang til de andre skuffene.

106
00:06:22,670 --> 00:06:26,310
Det er det samme med stabler.

107
00:06:26,310 --> 00:06:31,220
Så hvis jeg vil, for eksempel legge til et element i en stabel, hva bør jeg gjøre?

108
00:06:31,220 --> 00:06:34,070
Det kalles push, og det er ganske grei.

109
00:06:34,070 --> 00:06:37,130
Det første du må gjøre er å sjekke om størrelsen på stakken

110
00:06:37,130 --> 00:06:40,150
ikke er større eller lik kapasiteten i stabelen.

111
00:06:40,150 --> 00:06:45,810
Fordi hvis du allerede er på full kapasitet, kan du ikke legge til noe annet.

112
00:06:45,810 --> 00:06:51,140
Og så hvis ikke, du må bare legge til elementet i bunken.

113
00:06:51,140 --> 00:06:54,530
Og til slutt, øke størrelsen. Så det er ganske grei.

114
00:06:54,530 --> 00:06:57,140
Så jeg bare legge til nummeret to.

115
00:06:57,140 --> 00:07:00,350
Og hvis jeg ønsker å pop, noe som betyr at jeg ønsker å fjerne

116
00:07:00,350 --> 00:07:03,870
det siste element som er overført, og returnerer verdien av elementet,

117
00:07:03,870 --> 00:07:09,180
det første jeg må sjekke er at bunken ikke er tom.

118
00:07:09,180 --> 00:07:11,510
Fordi hvis det er tomt, kan jeg ikke gå tilbake noe.

119
00:07:11,510 --> 00:07:14,820
I så fall er jeg tilbake -1.

120
00:07:14,820 --> 00:07:18,960
Ellers kommer jeg til å minske størrelsen på spec,

121
00:07:18,960 --> 00:07:22,510
og returnere tall (s.size).

122
00:07:22,510 --> 00:07:27,230
Hvorfor gjorde jeg minske størrelsen og deretter returnere s.size?

123
00:07:27,230 --> 00:07:30,930
Det er fordi, i dette tilfelle, har de spec størrelse 4,

124
00:07:30,930 --> 00:07:33,810
og jeg ønsker å returnere det fjerde elementet, ikke sant?

125
00:07:33,810 --> 00:07:36,030
Men hva er indeksen for det fjerde elementet? Tre.

126
00:07:36,030 --> 00:07:44,510
Siden jeg størrelse - kommer til å være tre, kan jeg bare gå tilbake s.numbers (s.size)

127
00:07:44,510 --> 00:07:48,410
fordi det er tre. Så det er bare indeksen.

128
00:07:48,410 --> 00:07:50,380
>> Nå køer. Køer er ganske mye det samme.

129
00:07:50,380 --> 00:07:54,950
Den eneste forskjellen er at i stedet for å ha siste inn, først ut,

130
00:07:54,950 --> 00:07:57,480
du har først inn, først ut.

131
00:07:57,480 --> 00:07:59,460
Sannsynligvis hvis du venter på å gå på en konsert,

132
00:07:59,460 --> 00:08:04,260
du vil ikke være fornøyd hvis du hadde en stabel i stedet for en kø.

133
00:08:04,260 --> 00:08:07,730
Å være den siste personen til å komme ville være den første personen til å gå inn i konserten.

134
00:08:07,730 --> 00:08:09,760
Du har sannsynligvis ikke ville være fornøyd.

135
00:08:09,760 --> 00:08:15,020
I køen, er den første personen til å komme inn også den første personen til å komme seg ut.

136
00:08:15,020 --> 00:08:18,720
Så i definisjonen av en kø, foruten å ha en størrelse i matrisen,

137
00:08:18,720 --> 00:08:23,360
må man også ha et innlegg, som er indeksen til hodet på stabelen.

138
00:08:23,360 --> 00:08:29,000
Så det første elementet akkurat nå.

139
00:08:29,000 --> 00:08:32,710
Enqueue er det samme som push for stabler.

140
00:08:32,710 --> 00:08:34,980
Hvis du var veldig naiv, vil du bare si,

141
00:08:34,980 --> 00:08:39,289
vel, jeg kan bare gjøre akkurat det samme som jeg gjorde for push.

142
00:08:39,289 --> 00:08:44,030
Jeg kan bare sjekke om det ikke utover kapasiteten.

143
00:08:44,030 --> 00:08:48,760
Hvis det er, jeg return false, ellers kan jeg bare eksportere den nye verdien

144
00:08:48,760 --> 00:08:50,630
og deretter øke størrelsen.

145
00:08:50,630 --> 00:08:52,750
Men hvorfor er dette galt?

146
00:08:52,750 --> 00:08:55,010
La oss se dette eksemplet.

147
00:08:55,010 --> 00:08:57,020
Jeg prøver å Enqueue en haug med ting,

148
00:08:57,020 --> 00:08:58,390
og da kommer jeg til å dequeue og Enqueue.

149
00:08:58,390 --> 00:09:00,550
Det er mye av kommandoer, men det er veldig enkelt.

150
00:09:00,550 --> 00:09:04,790
Jeg kommer til å Enqueue 5, så legg fem, og deretter 7,

151
00:09:04,790 --> 00:09:09,310
1, 4, 6, og da vil jeg dequeue noe,

152
00:09:09,310 --> 00:09:12,000
noe som betyr at jeg kommer til å fjerne det første elementet.

153
00:09:12,000 --> 00:09:14,640
Så jeg kommer til å fjerne nummeret 3, ikke sant?

154
00:09:14,640 --> 00:09:17,320
Det første elementet. Ok.

155
00:09:17,320 --> 00:09:21,450
Nå hvis jeg prøver å Enqueue noe annet, hva kommer til å skje?

156
00:09:21,450 --> 00:09:24,290
Ifølge min gjennomføring,

157
00:09:24,290 --> 00:09:31,040
Jeg hadde tenkt å sette det neste nummeret i indeksen q.size.

158
00:09:31,040 --> 00:09:35,140
I dette tilfelle er størrelsen 8,

159
00:09:35,140 --> 00:09:38,640
så indeksen 8 vil være her i den siste posisjonen.

160
00:09:38,640 --> 00:09:43,900
Hvis jeg prøver å Enqueue en rett her, ville jeg være å overskrive den siste plassen

161
00:09:43,900 --> 00:09:45,870
til tallet 1, som er fullstendig feil.

162
00:09:45,870 --> 00:09:49,870
Hva jeg vil gjøre er å vikle seg rundt og gå til den første posisjonen.

163
00:09:49,870 --> 00:09:52,870
Kanskje du ville bare si, vel, jeg må bare sjekke

164
00:09:52,870 --> 00:09:55,600
hvis jeg kan faktisk sette noe der.

165
00:09:55,600 --> 00:09:58,560
Hvis ikke, jeg bare sier, oh, den nye full kapasitet

166
00:09:58,560 --> 00:10:02,010
er faktisk kapasitet - en, og du kan ikke sette et element der.

167
00:10:02,010 --> 00:10:06,150
Men hva er problemet? Problemet er at hvis jeg bare dequeue alt rett her

168
00:10:06,150 --> 00:10:08,240
og da jeg prøver å legge til noe annet, det ville bare si,

169
00:10:08,240 --> 00:10:11,210
vel, du var på full kapasitet, noe som er 0.

170
00:10:11,210 --> 00:10:13,620
Så din køen er borte.

171
00:10:13,620 --> 00:10:16,990
Du må brytes rundt, og en måte å pakke rundt

172
00:10:16,990 --> 00:10:22,040
at dere lært i visjonære og andre psets brukte mod.

173
00:10:22,040 --> 00:10:29,090
Du kan prøve det hjemme å forstå hvorfor du ville gjøre q.size + q.head

174
00:10:29,090 --> 00:10:31,080
mod kapasitet, men hvis du sjekker akkurat her,

175
00:10:31,080 --> 00:10:34,760
Vi kan se at det fungerer.

176
00:10:34,760 --> 00:10:37,760
Så i det siste eksemplet, q.size var åtte

177
00:10:37,760 --> 00:10:47,590
og hodet var 1, fordi det var denne posisjonen her i matrisen.

178
00:10:47,590 --> 00:10:51,970
Så det vil være 8 + 1, 9. Mod kapasitet ni ville være 0.

179
00:10:51,970 --> 00:10:56,640
Det ville gå til indeksen 0. Vi vil være i riktig posisjon.

180
00:10:56,640 --> 00:10:59,750
Og så prøve køen hjemme.

181
00:10:59,750 --> 00:11:04,950
Noen viktige ting: prøv å forstå forskjellen mellom en stabel og en kø.

182
00:11:04,950 --> 00:11:11,620
Hjemme, prøve å få veldig kjent med å implementere enqueue, dequeue, push og pop.

183
00:11:11,620 --> 00:11:16,560
Og også forstå når du skal bruke hver av dem.

184
00:11:16,560 --> 00:11:22,830
>> Så la oss slappe av i 10 sekunder med en haug av Pokemons.

185
00:11:22,830 --> 00:11:26,080
Og nå la oss gå tilbake til datastrukturer.

186
00:11:26,080 --> 00:11:29,770
Hash tabeller. Mange var redd for hash tabeller.

187
00:11:29,770 --> 00:11:33,650
i oppgavesettet 6, stavekontroll.

188
00:11:33,650 --> 00:11:35,980
Hash tabeller og prøver, mange mennesker blir skremt av dem.

189
00:11:35,980 --> 00:11:38,540
De tror de er så vanskelig å forstå. Yeah?

190
00:11:38,540 --> 00:11:41,490
[Rob Bowden] Problem satt fem. >> Problem satt fem, ja. Takket Rob.

191
00:11:41,490 --> 00:11:43,370
Yeah. Seks var Huff n 'Puff, ja.

192
00:11:43,370 --> 00:11:49,340
Problem satt fem ble stavekontroll, og du måtte bruke enten en hash tabell eller en prøve.

193
00:11:49,340 --> 00:11:55,360
Mange trodde at de var super vanskelig å forstå, men de er faktisk ganske enkelt.

194
00:11:55,360 --> 00:12:01,290
Hva er en hash table, i utgangspunktet? En hash table er en rekke lenkede lister.

195
00:12:01,290 --> 00:12:06,730
Den eneste forskjellen mellom en matrise og en hash table

196
00:12:06,730 --> 00:12:09,730
er at i hash table du har noe som kalles en hash-funksjon.

197
00:12:09,730 --> 00:12:12,080
Hva er en hash-funksjon?

198
00:12:12,080 --> 00:12:13,970
Jeg vet ikke om dere kan lese her.

199
00:12:13,970 --> 00:12:16,090
Dette er et eksempel på en nøkkeltabell.

200
00:12:16,090 --> 00:12:19,220
Så du kan se at du har en rekke med 31 elementer.

201
00:12:19,220 --> 00:12:22,440
Og hva vi gjør i en hash tabellen har en hash-funksjon

202
00:12:22,440 --> 00:12:26,660
som kommer til å oversette en nøkkel, hver int til en indeks.

203
00:12:26,660 --> 00:12:31,740
Hvis, for eksempel, hvis jeg ønsker å velge for B. Harrison,

204
00:12:31,740 --> 00:12:34,190
Jeg ville sette B. Harrison i mine hash funksjoner,

205
00:12:34,190 --> 00:12:36,960
og hash-funksjon vil returnere 24.

206
00:12:36,960 --> 00:12:40,930
Så jeg vet at jeg ønsker å lagre B. Harrison i 24.

207
00:12:40,930 --> 00:12:46,580
Så det er forskjellen mellom bare å ha en matrise og ha en hash table.

208
00:12:46,580 --> 00:12:48,740
I hash tabellen vil du ha en funksjon som kommer til å fortelle deg

209
00:12:48,740 --> 00:12:54,740
hvor du vil lagre dataene som du ønsker å lagre.

210
00:12:54,740 --> 00:12:57,040
For den hash-funksjon, vil du se etter en hash-funksjon

211
00:12:57,040 --> 00:13:00,600
som er deterministisk og godt fordelt.

212
00:13:00,600 --> 00:13:07,810
Som du kan se her, ser du at mye av dataene som jeg ønsket å butikken var faktisk 19

213
00:13:07,810 --> 00:13:12,470
i stedet for ved hjelp av 31 og 30 og 29, som alle var fri.

214
00:13:12,470 --> 00:13:16,920
Så hash-funksjon som jeg brukte var ikke veldig godt fordelt.

215
00:13:16,920 --> 00:13:20,710
Når vi sier godt fordelt, betyr det at vi ønsker å ha,

216
00:13:20,710 --> 00:13:26,520
lag, i det minste en eller to for hver av de -

217
00:13:26,520 --> 00:13:32,190
som, en forskjell på en eller to for hver av indeksene i matriser.

218
00:13:32,190 --> 00:13:43,950
Du ønsker å ha, omtrent det samme antallet elementer i hver lenket liste i rekken.

219
00:13:43,950 --> 00:13:48,600
Og det er lett å sjekke om det er gyldig i hash table, se som hash tabeller.

220
00:13:48,600 --> 00:13:51,770
>> Så trær. Dette er et tre.

221
00:13:51,770 --> 00:13:56,400
Trær i informatikk er opp ned eller annen grunn.

222
00:13:56,400 --> 00:14:00,150
Så akkurat her har du roten av treet og deretter bladene.

223
00:14:00,150 --> 00:14:05,630
Du bør bare vite nomenklatur for foreldre og barn.

224
00:14:05,630 --> 00:14:12,880
Hver node har sine barn, som er de nodene som er under den overordnede.

225
00:14:12,880 --> 00:14:19,660
Så, for eksempel 2 til å være den overordnede til 3 og for det annet barn der,

226
00:14:19,660 --> 00:14:25,290
mens tre kommer til å være forelder for en og de andre barna som er der.

227
00:14:25,290 --> 00:14:29,990
Og en kommer til å være tre er barn, og så videre.

228
00:14:29,990 --> 00:14:34,610
Vi har noe mye mer interessant, kalles et binært søketre,

229
00:14:34,610 --> 00:14:39,040
hvor alle verdiene på høyre for en node

230
00:14:39,040 --> 00:14:41,660
kommer til å være på høyre side, rett her - til høyre,

231
00:14:41,660 --> 00:14:46,780
kommer til å være større enn det element i roten.

232
00:14:46,780 --> 00:14:49,780
Så hvis jeg har nummer fem akkurat her, alle elementer på høyre

233
00:14:49,780 --> 00:14:51,940
kommer til å være større enn 5, og på venstre

234
00:14:51,940 --> 00:14:56,770
alle elementene kommer til å være mindre enn fem.

235
00:14:56,770 --> 00:14:58,780
Hvorfor er dette nyttig?

236
00:14:58,780 --> 00:15:01,660
Vel, hvis jeg ønsker å sjekke om tallet 7 er her, for eksempel,

237
00:15:01,660 --> 00:15:05,960
Jeg bare gå til fem første, og jeg kommer til å se, er syv større eller mindre enn 5?

238
00:15:05,960 --> 00:15:09,540
Det er større, så jeg vet at det kommer til å være på høyre side av treet.

239
00:15:09,540 --> 00:15:13,980
Så jeg har mye mindre ting å se på.

240
00:15:13,980 --> 00:15:19,520
I gjennomføringen av et binært søketre, noden, jeg er bare nødt til å ha data,

241
00:15:19,520 --> 00:15:21,750
så int n, du kan også ha en streng

242
00:15:21,750 --> 00:15:23,630
eller noe du ville.

243
00:15:23,630 --> 00:15:28,100
Du må bare være forsiktig med å definere hva som er større, hva er mindre.

244
00:15:28,100 --> 00:15:30,390
Så hvis du hadde strenger, for eksempel, kan du definere

245
00:15:30,390 --> 00:15:34,690
at alle disse tingene på den rette kommer til å ha større lengde,

246
00:15:34,690 --> 00:15:40,940
venstre kommer til å ha lavere lengder, så det er egentlig opp til deg.

247
00:15:40,940 --> 00:15:44,930
>> Hvordan kan jeg implementere finne for BST?

248
00:15:44,930 --> 00:15:47,840
Det første vi må gjøre er å sjekke om roten er NULL.

249
00:15:47,840 --> 00:15:50,920
Hvis det er NULL, betyr det at ting ikke er der

250
00:15:50,920 --> 00:15:53,330
fordi du ikke engang har et tre, ikke sant?

251
00:15:53,330 --> 00:15:55,790
Så jeg return false.

252
00:15:55,790 --> 00:15:58,740
Ellers kommer jeg til å sjekke om tallet er større

253
00:15:58,740 --> 00:16:01,720
enn verdien i roten.

254
00:16:01,720 --> 00:16:04,250
Jeg kommer til å prøve å finne elementet på høyre

255
00:16:04,250 --> 00:16:08,590
av treet.

256
00:16:08,590 --> 00:16:11,310
Du ser at jeg bruker rekursjon her.

257
00:16:11,310 --> 00:16:14,150
Og så hvis det er mindre, kommer jeg til å se på venstre side.

258
00:16:14,150 --> 00:16:18,330
Og til slutt, ellers, hvis det ikke er mindre eller ikke større,

259
00:16:18,330 --> 00:16:20,660
det betyr at det er selve verdien.

260
00:16:20,660 --> 00:16:23,010
Så jeg bare returnere true.

261
00:16:23,010 --> 00:16:26,360
Du kan se her at jeg brukte hvis, hvis, hvis.

262
00:16:26,360 --> 00:16:30,820
Og husk, i quiz 0, hadde vi et problem som hadde hvis, hvis, hvis,

263
00:16:30,820 --> 00:16:32,780
og du skulle finne på ineffektivitet,

264
00:16:32,780 --> 00:16:35,180
og ineffektiviteten var at du brukte om.

265
00:16:35,180 --> 00:16:39,060
Du bør ha brukt hvis, annet hvis, annet hvis, og annet.

266
00:16:39,060 --> 00:16:44,240
Så, bør jeg bruke annet hvis og annet hvis og annet her?

267
00:16:44,240 --> 00:16:46,200
Er det noen som - ja?

268
00:16:46,200 --> 00:16:51,140
[Student taler, uhørlig]

269
00:16:51,140 --> 00:16:53,480
Det er perfekt. Så hun sier at det ikke spiller noen rolle,

270
00:16:53,480 --> 00:16:55,930
bare fordi den ineffektivitet som vi hadde før

271
00:16:55,930 --> 00:16:59,550
var det fordi, kanskje hvis noen kravet var oppfylt,

272
00:16:59,550 --> 00:17:03,570
slik at du har utført en handling, men da du skulle sjekke alle de andre forholdene.

273
00:17:03,570 --> 00:17:06,319
Men i dette tilfellet, det kom tilbake med en gang, så det spiller ingen rolle.

274
00:17:06,319 --> 00:17:09,220
Så du trenger ikke å bruke annet hvis.

275
00:17:09,220 --> 00:17:11,740
>> Og til slutt, la oss snakke om prøver,

276
00:17:11,740 --> 00:17:13,800
som er alles favoritt.

277
00:17:13,800 --> 00:17:15,980
En prøve er et tre av arrays.

278
00:17:15,980 --> 00:17:20,369
Det er veldig fort å lete opp verdier, men den bruker mye minne.

279
00:17:20,369 --> 00:17:22,530
Og det er som regel å filtrere ord, så når du

280
00:17:22,530 --> 00:17:27,920
ønsker å gjennomføre, for eksempel, vet jeg ikke, som en telefonboken på telefonen

281
00:17:27,920 --> 00:17:30,440
og du vil være i stand til å skrive B

282
00:17:30,440 --> 00:17:32,510
og bare ha navn på personer som har B.

283
00:17:32,510 --> 00:17:37,960
Det er svært enkelt å implementere at bruk av en prøve, for eksempel.

284
00:17:37,960 --> 00:17:39,820
Hvordan definerer du en node i et forsøk?

285
00:17:39,820 --> 00:17:43,910
Du må bare ha en bool som kommer til å bli is_word.

286
00:17:43,910 --> 00:17:48,660
Det representerer at bruk av alle tegnene før den noden,

287
00:17:48,660 --> 00:17:51,920
du var i stand til å danne et ord,

288
00:17:51,920 --> 00:17:57,230
og da vil du ha en rekke pekere til noder.

289
00:17:57,230 --> 00:18:03,120
Kan du se at vi har en rekke overordnede noder, slik node * array? Yeah?

290
00:18:03,120 --> 00:18:06,050
Så la oss se hvordan det vil fungere. For stavekontroll,

291
00:18:06,050 --> 00:18:08,230
vi har en matrise med 27 elementer,

292
00:18:08,230 --> 00:18:12,150
fordi vi har alle bokstavene pluss apostrof.

293
00:18:12,150 --> 00:18:17,800
Før her jeg bare kommer til å bruke to fordi jeg ønsker å være i stand til å skrive på tavlen.

294
00:18:17,800 --> 00:18:20,230
Ok. Så dette er et eksempel på en prøve.

295
00:18:20,230 --> 00:18:25,600
Hvis jeg bare definere den første noden, vil jeg ha en rekke to elementer

296
00:18:25,600 --> 00:18:29,290
som er to pekere til NULL, så jeg bare sette 'a' og 'b'.

297
00:18:29,290 --> 00:18:32,430
Og jeg kommer til å ha en bool som sier is_word.

298
00:18:32,430 --> 00:18:34,420
Det kommer til å være falsk for den første,

299
00:18:34,420 --> 00:18:37,370
bare fordi, før at du ikke har noen tegn.

300
00:18:37,370 --> 00:18:40,900
Så et tomt ord er ikke et ord. Så det er falsk.

301
00:18:40,900 --> 00:18:46,320
Hvis jeg ønsker å legge til 'a' til denne ordboken, hva ville jeg gjøre?

302
00:18:46,320 --> 00:18:49,760
Jeg ville bare ha til malloc en ny node for 'a',

303
00:18:49,760 --> 00:18:54,630
og deretter legge sitt ord til sann.

304
00:18:54,630 --> 00:19:00,180
Så det bare representerer det å ha 'a' kommer til å være sant. Fornuftig?

305
00:19:00,180 --> 00:19:04,120
Så hvis jeg ønsker å legge til 'ba', vil jeg måtte malloc 1 for 'b',

306
00:19:04,120 --> 00:19:07,550
og da kommer jeg til å sette opp boolean til false,

307
00:19:07,550 --> 00:19:10,160
fordi 'b' i seg selv er ikke et ord.

308
00:19:10,160 --> 00:19:13,010
Så jeg kommer til malloc en annen for 'a', så 'ba',

309
00:19:13,010 --> 00:19:16,290
og da kommer jeg til å sette opp det er et ord til sann.

310
00:19:16,290 --> 00:19:18,950
Fordi 'ba' er et ord.

311
00:19:18,950 --> 00:19:21,910
Og så hvis jeg ønsker å se om 'b' er i denne ordboken,

312
00:19:21,910 --> 00:19:26,730
Jeg kan bare gå til den første, 'b'. Jeg går ned, og jeg ser på er ordet, og det sier falsk.

313
00:19:26,730 --> 00:19:30,110
Så det er ikke et ord. Hvis jeg ønsker å sjekke 'ba',

314
00:19:30,110 --> 00:19:38,010
Jeg går til den første, 'b', og deretter gå til 'a', og jeg ser sant, så det er et ord. Fornuftig?

315
00:19:38,010 --> 00:19:41,950
Mange mennesker blir forvirret av prøver. Nei?

316
00:19:41,950 --> 00:19:44,740
>> Endelig Huffman koding. Huffman koding er svært nyttig

317
00:19:44,740 --> 00:19:47,550
å spare minne og komprimere tekstfiler,

318
00:19:47,550 --> 00:19:52,270
bare fordi mange ganger du bruker 'a' og 'e', ​​for eksempel,

319
00:19:52,270 --> 00:19:57,710
i dokumentene, men jeg vet ikke om dere bruker 'q' eller 'z' så mye.

320
00:19:57,710 --> 00:20:02,040
Å ha bare en byte for hver enkelt karakter,

321
00:20:02,040 --> 00:20:08,520
hver enkelt - de 256 tegnene som vi har i ASCII-tabellen er ikke veldig optimal,

322
00:20:08,520 --> 00:20:11,410
bare fordi det er noen tegn på at du bruker mye mer,

323
00:20:11,410 --> 00:20:15,180
så du bør nok bruke mindre minne for dem.

324
00:20:15,180 --> 00:20:17,560
Hvordan bruker jeg Huffman koding?

325
00:20:17,560 --> 00:20:20,010
Vi må gjøre en Huffman treet.

326
00:20:20,010 --> 00:20:23,370
 En Huffman treet har noder

327
00:20:23,370 --> 00:20:27,760
som har et symbol som kommer til å være som, 'a', 'b', 'c', brevet,

328
00:20:27,760 --> 00:20:32,990
uansett brev du har, en frekvens som er frekvensen at ordet vises i teksten,

329
00:20:32,990 --> 00:20:36,280
at du skulle lage den Huffman treet for,

330
00:20:36,280 --> 00:20:41,800
og deretter en node som kommer til å peke til venstre for Huffman treet

331
00:20:41,800 --> 00:20:47,210
og en annen node som kommer til å peke til høyre. Så akkurat som et tre.

332
00:20:47,210 --> 00:20:49,440
Hvordan kan du bygge en Huffman treet?

333
00:20:49,440 --> 00:20:54,020
Du kommer til å plukke de to noder som har de laveste frekvensene.

334
00:20:54,020 --> 00:20:56,490
Hvis du har et slips du kommer til å plukke de to noder

335
00:20:56,490 --> 00:20:59,870
som har de laveste ASCII-verdier i tillegg.

336
00:20:59,870 --> 00:21:02,420
Da kommer du til å opprette et nytt tre ut av disse to noder

337
00:21:02,420 --> 00:21:08,030
som kommer til å ha den kombinerte frekvens i foreldrenoden.

338
00:21:08,030 --> 00:21:13,240
Og så kommer dere til å fjerne de to barna fra skogen

339
00:21:13,240 --> 00:21:15,570
og erstatte dem med den overordnede.

340
00:21:15,570 --> 00:21:18,930
Og du kommer til å gjenta det til det bare er ett tre i skogen.

341
00:21:18,930 --> 00:21:23,840
Så la oss se hvordan du ville gjøre en Huffman treet for ZAMYLA.

342
00:21:23,840 --> 00:21:29,220
Du kan se her at alle bokstavene har frekvens 1 unntatt for 'A'; som har frekvens to.

343
00:21:29,220 --> 00:21:34,090
Så jeg laget noder for alle bokstavene jeg satt i rekkefølge av ASCII-verdi og frekvens.

344
00:21:34,090 --> 00:21:40,090
Så hvis jeg ønsker å opprette det første treet, vil det være med 'L' og 'M'.

345
00:21:40,090 --> 00:21:43,100
Så det er her. Frekvensen av de to vil være 2

346
00:21:43,100 --> 00:21:49,470
fordi det er en + 1, deretter neste to med de laveste frekvensene er "Y" og "Z".

347
00:21:49,470 --> 00:21:53,180
Og så har jeg alle av dem er - har en frekvens på to.

348
00:21:53,180 --> 00:22:00,470
Så hvilke som er de som har den laveste ASCII verdi for den neste?

349
00:22:00,470 --> 00:22:04,830
'A' og 'L'. Så jeg opprette den nye noden,

350
00:22:04,830 --> 00:22:09,930
og til slutt, er det fire og to, så to kommer til å være på venstre side.

351
00:22:09,930 --> 00:22:12,430
Og dette er den Huffman treet.

352
00:22:12,430 --> 00:22:16,060
Så hvis jeg ønsker å skrive litt tekst,

353
00:22:16,060 --> 00:22:24,440
som i binær å konvertere til tekst ved hjelp av Huffman treet er veldig enkelt.

354
00:22:24,440 --> 00:22:30,220
For eksempel, hvis jeg sier at å flytte til venstre er en 0 og beveger seg til høyre er en 1,

355
00:22:30,220 --> 00:22:32,410
Hva kommer det til å representere?

356
00:22:32,410 --> 00:22:35,530
Så ut som en, en, så høyre, høyre,

357
00:22:35,530 --> 00:22:40,370
og deretter 0, så igjen vil være L, og deretter 1, 0, 0.

358
00:22:40,370 --> 00:22:43,950
Så en, 0, så bare ett, 0, 'A'.

359
00:22:43,950 --> 00:22:47,540
Og deretter 0, 1, slik at 'Z'.

360
00:22:47,540 --> 00:22:52,170
Og så en, 0, 0 - nei.

361
00:22:52,170 --> 00:22:56,780
0, 0 vil være 'Y', så lat.

362
00:22:56,780 --> 00:23:06,060
Så det er alt for meg, Rob kommer til å ta over.

363
00:23:06,060 --> 00:23:08,400
>> [Rob Bowden] Så, uke 7 ting.

364
00:23:08,400 --> 00:23:11,390
Vi har mye å gå over veldig fort.

365
00:23:11,390 --> 00:23:13,430
Bitvis operatører, buffer overflow,

366
00:23:13,430 --> 00:23:16,760
CS50 bibliotek, deretter HTML, HTTP, CSS.

367
00:23:16,760 --> 00:23:20,990
Alt i som 15 til 20 minutter.

368
00:23:20,990 --> 00:23:24,330
Bitvis operatører. Det er seks av dem at du trenger å vite.

369
00:23:24,330 --> 00:23:31,200
Bitvis og, bitvis eller, XOR, venstre shift, høyre shift, og ikke.

370
00:23:31,200 --> 00:23:35,420
Høyre skift og ikke du knapt så på forelesning i det hele tatt.

371
00:23:35,420 --> 00:23:40,480
Vi vil gå over det raskt her, men det er godt å vite at disse er de seks som eksisterer.

372
00:23:40,480 --> 00:23:45,070
Husk at bitvis operatører er som når du gjør 3 + 4.

373
00:23:45,070 --> 00:23:49,420
Du forholder seg ikke med det binære av tre og fire.

374
00:23:49,420 --> 00:23:56,550
Med bitvis operatører er du faktisk arbeider med individuelle biter av tallene 3 og 4.

375
00:23:56,550 --> 00:23:59,120
>> Så det første at vi vil si er bitvis ikke,

376
00:23:59,120 --> 00:24:02,340
og alt den gjør er å snu alle biter.

377
00:24:02,340 --> 00:24:05,500
Så her, hvis du skriver dette i C, du ville ikke skrive det

378
00:24:05,500 --> 00:24:09,380
som ~ 11 011 eller noe, ville du skrive det liker ~ 4,

379
00:24:09,380 --> 00:24:12,970
og da ville det snu den binære representasjonen av fire.

380
00:24:12,970 --> 00:24:24,800
Så her, ~ av noen binære tallet 1101101 kommer til akkurat snu alle 1 til 0 og alle 0 til 1-tallet.

381
00:24:24,800 --> 00:24:27,600
Som jeg sier det, den hyppige bruken av dette,

382
00:24:27,600 --> 00:24:30,830
og vi vil se det i et litt, er som vi ønsker å komme opp med noen tall

383
00:24:30,830 --> 00:24:35,460
hvor alle biter er en, bortsett fra en av dem.

384
00:24:35,460 --> 00:24:38,560
Så det er vanligvis lettere å uttrykke antall

385
00:24:38,560 --> 00:24:40,630
hvor nettopp det enkelt bit er satt,

386
00:24:40,630 --> 00:24:44,650
og deretter ta ~ av det, slik at annenhver bit er innstilt med unntak av at en.

387
00:24:44,650 --> 00:24:50,300
Så det er det vi kommer til å bruke mer i en bit.

388
00:24:50,300 --> 00:24:58,220
>> Bitwise eller. Her er to binære tall, og disse to tallene

389
00:24:58,220 --> 00:25:00,780
er ganske representative, siden de representerer alle mulige

390
00:25:00,780 --> 00:25:07,290
kombinasjon av biter du kan trenger for å operere på.

391
00:25:07,290 --> 00:25:13,540
Her, når jeg ELLER-behandlet hver bit, vi kommer bare til å sammenligne rett ned.

392
00:25:13,540 --> 00:25:15,410
Så på venstre side har vi en 1 og en 1.

393
00:25:15,410 --> 00:25:20,510
Når jeg bitvis | de, hva jeg kommer til å få? One.

394
00:25:20,510 --> 00:25:25,320
Deretter bitvis | 0 og 1 kommer til å gi meg? One.

395
00:25:25,320 --> 00:25:27,840
Bitvis 1 og 0 kommer til å være det samme, en.

396
00:25:27,840 --> 00:25:31,880
Bitvis 0 | 0 kommer til å gi meg 0.

397
00:25:31,880 --> 00:25:37,300
Så det eneste tilfellet hvor jeg får 0 er i 0 | 0 tilfelle.

398
00:25:37,300 --> 00:25:40,020
Og du kan tenke på at akkurat som dine logiske ORS.

399
00:25:40,020 --> 00:25:44,830
Så hvis du tenker på en så ekte og 0 som falsk, gjelder det samme her.

400
00:25:44,830 --> 00:25:50,040
Så sant eller sant er sant, sant eller usant er sant.

401
00:25:50,040 --> 00:25:57,150
Falsk eller sant er sant, usant eller usant er det eneste som faktisk er falske.

402
00:25:57,150 --> 00:26:00,100
Her er et eksempel som du bør vite

403
00:26:00,100 --> 00:26:05,160
som et ganske godt eksempel på når bitvis operatører brukes.

404
00:26:05,160 --> 00:26:08,660
Her hvis vi eller kapital 'A' med OX20,

405
00:26:08,660 --> 00:26:11,830
og vi skal se på disse i et sekund, får vi noe.

406
00:26:11,830 --> 00:26:16,020
Og hvis vi eller små bokstaver 'a' med OX20, får vi noe.

407
00:26:16,020 --> 00:26:26,750
Så la oss trekke opp ASCII-tabellen.

408
00:26:26,750 --> 00:26:34,000
Ok. Her ser vi at "A" er -

409
00:26:34,000 --> 00:26:36,920
her har vi 'A' er desimal 65.

410
00:26:36,920 --> 00:26:45,120
Men jeg skal gå med heksadesimale, som er Ox41.

411
00:26:45,120 --> 00:26:48,280
Ganske sikker på at vi så det i klassen. Jeg tror vi så det i klassen

412
00:26:48,280 --> 00:26:52,730
at det er ganske enkelt å konvertere fra heksadesimale til binære.

413
00:26:52,730 --> 00:26:55,280
Så her, hvis jeg ønsker å sette 4 i binær,

414
00:26:55,280 --> 00:26:59,550
som bare kommer til å være 0100.

415
00:26:59,550 --> 00:27:03,620
Dette er en plass, 2 plass, 4 plass, så dette er fire.

416
00:27:03,620 --> 00:27:08,550
Da kan jeg dele en i binær, som kommer til å være 0001.

417
00:27:08,550 --> 00:27:14,280
Og så dette kommer til å være representasjon av 'A' i binær.

418
00:27:14,280 --> 00:27:22,720
Tar små bokstaver 'a', det er nå kommer til å bli Ox61,

419
00:27:22,720 --> 00:27:27,050
der, dele disse opp i den binære, så en 6 -

420
00:27:27,050 --> 00:27:37,830
La oss faktisk gjør det - er det ingen viskelær? Viskelær.

421
00:27:37,830 --> 00:27:48,220
Ox61. Så splitte 6 i binær kommer til å være 0 + 4 + 2 + 0.

422
00:27:48,220 --> 00:27:54,610
Og splitting en kommer til å være 0001.

423
00:27:54,610 --> 00:27:56,520
Ser vi på forskjellen mellom disse to,

424
00:27:56,520 --> 00:28:04,250
vi ser at den eneste forskjellen mellom en små bokstaver og en kapital "A" er dette eneste bit.

425
00:28:04,250 --> 00:28:11,810
Så kommer tilbake til her - greit.

426
00:28:11,810 --> 00:28:15,920
Kommer tilbake til her, hvis vi ser på hva den litt OX20 er,

427
00:28:15,920 --> 00:28:22,210
så splitting OX20 inn sin binære,

428
00:28:22,210 --> 00:28:27,310
er 0010, 0000.

429
00:28:27,310 --> 00:28:33,470
OX20, den eneste bit som er satt er dette litt som vi er opptatt av,

430
00:28:33,470 --> 00:28:38,210
med veksling mellom kapital og små bokstaver 'a'.

431
00:28:38,210 --> 00:28:47,610
Hvis jeg eller 'A', som er denne, 'A',

432
00:28:47,610 --> 00:28:50,580
hvis jeg eller 'A' med OX20,

433
00:28:50,580 --> 00:28:53,490
hva skal jeg bli?

434
00:28:53,490 --> 00:28:58,960
[Student, uhørlig] >> Små bokstaver 'a', fordi det kommer til å snu dette litt til en 1.

435
00:28:58,960 --> 00:29:04,170
Og hvis jeg eller 'a' med OX20, hva jeg kommer til å få?

436
00:29:04,170 --> 00:29:08,780
Små bokstaver a, fordi bare ORING 'a' med OX20,

437
00:29:08,780 --> 00:29:14,580
Jeg skal bare være ORING dette enkelt bit til en 1, det er allerede en en, så det spiller ingen rolle.

438
00:29:14,580 --> 00:29:17,960
Så vi får 'a' og 'a'.

439
00:29:17,960 --> 00:29:24,820
>> Bitwise og. Igjen, kan vi tenke på dette som vår logiske og motpart.

440
00:29:24,820 --> 00:29:28,180
På venstre side har vi sann og ekte.

441
00:29:28,180 --> 00:29:31,160
Det kommer til å være sant, og for alle de tilfellene

442
00:29:31,160 --> 00:29:36,270
falsk og ekte eller sant og usant, eller falsk og usann,

443
00:29:36,270 --> 00:29:38,550
ingen av disse tingene er sanne.

444
00:29:38,550 --> 00:29:44,170
Så hva vi ender opp med å få er 1000.

445
00:29:44,170 --> 00:29:48,830
Så nå, her, her hvor jeg har brukt den trofaste bitvis ikke,

446
00:29:48,830 --> 00:29:52,230
hvor vi hadde OX20.

447
00:29:52,230 --> 00:29:54,350
Så dette er OX20.

448
00:29:54,350 --> 00:29:59,570
Nå hva jeg ønsker å gjøre, bitvis ~ av OX20.

449
00:29:59,570 --> 00:30:03,600
Det kommer til å snu alle biter.

450
00:30:03,600 --> 00:30:09,330
Så jeg har 1101, 1111.

451
00:30:09,330 --> 00:30:18,940
Og så 'A' anded med ~ OX20 kommer til å gi meg det?

452
00:30:18,940 --> 00:30:22,430
Den eneste bit vi virkelig trenger å tenke på er denne,

453
00:30:22,430 --> 00:30:26,020
siden, dersom alle disse biter er satt til 1,

454
00:30:26,020 --> 00:30:29,000
så vi kommer til å få akkurat det 'A' var,

455
00:30:29,000 --> 00:30:31,260
med unntak av eventuelt hva denne bit er.

456
00:30:31,260 --> 00:30:34,460
Fordi hvis det var en en, nå kommer det til å bli satt til en 0,

457
00:30:34,460 --> 00:30:39,810
fordi uansett hva dette er, anded med dette kommer til å være 0.

458
00:30:39,810 --> 00:30:43,280
Så hva er 'A' & ~ OX20 kommer til å gi meg?

459
00:30:43,280 --> 00:30:48,200
[Studentene svarer, ikke hørbar] >> Og hva er 'a' og - det er 'A'.

460
00:30:48,200 --> 00:30:52,170
Og hva er 'a' & ~ OX20 kommer til å gi meg?

461
00:30:52,170 --> 00:30:56,720
'A.' Fordi dette er i dag en ett.

462
00:30:56,720 --> 00:30:59,570
Anding med dette 0 kommer til å gjøre det en 0,

463
00:30:59,570 --> 00:31:02,530
og nå skal vi få en 'A'.

464
00:31:02,530 --> 00:31:06,600
>> Begge er "A", og sist men ikke minst av denne typen,

465
00:31:06,600 --> 00:31:10,830
vi har XOR. Det er veldig mye som eller,

466
00:31:10,830 --> 00:31:14,400
bortsett fra at det betyr utelukkende eller.

467
00:31:14,400 --> 00:31:18,420
Dette er som det du vanligvis tenker på som eller i den virkelige verden.

468
00:31:18,420 --> 00:31:23,190
Så du gjør enten 'x' eller 'y', men ikke begge deler.

469
00:31:23,190 --> 00:31:28,700
Her en ^ 1 kommer til å være 0.

470
00:31:28,700 --> 00:31:33,650
Fordi sann, er dette - det fungerer ikke så bra med den logiske sant og usant

471
00:31:33,650 --> 00:31:37,150
som bitvis & og eller gjøre,

472
00:31:37,150 --> 00:31:40,100
men sant ^ sant er usant.

473
00:31:40,100 --> 00:31:44,810
Fordi vi bare ønsker å returnere true hvis bare én av dem er ekte.

474
00:31:44,810 --> 00:31:50,950
Så en ^ 1 er 0. Hva med 0 ^ 1?

475
00:31:50,950 --> 00:31:56,010
Er en. 1 ^ 0 er 1, 0 ^ 0 er 0.

476
00:31:56,010 --> 00:32:03,890
Så under alle omstendigheter, er 0 bitvis noe 0 kommer til å være 0.

477
00:32:03,890 --> 00:32:10,270
En bitvis noe 0 eller 0 bitvis 1,

478
00:32:10,270 --> 00:32:14,660
hvis det er | eller ^, vil det være en 1, og hvis det er og det vil være 0.

479
00:32:14,660 --> 00:32:20,850
Og det eneste tilfellet der en bitvis en er ikke en er med eksklusive eller.

480
00:32:20,850 --> 00:32:24,580
Det er 0110.

481
00:32:24,580 --> 00:32:36,520
Så her nå, ved hjelp av XOR - så vi er tilbake på 20.

482
00:32:36,520 --> 00:32:43,480
'A' ^ OX20 er disse to biter vi sammenlikne.

483
00:32:43,480 --> 00:32:50,020
Så en 1 ^ 0 kommer til å gi meg en hva? En ett.

484
00:32:50,020 --> 00:32:58,430
'A' ^ OX20 kommer til å gi meg? Små bokstaver en.

485
00:32:58,430 --> 00:33:04,010
'A' ^ OX20 kommer til å gi meg? Capital A.

486
00:33:04,010 --> 00:33:09,310
Fordi hva dette gjør, dette XORing med OX20

487
00:33:09,310 --> 00:33:15,380
er effektivt bla hva denne biten er.

488
00:33:15,380 --> 00:33:21,240
Hvis dette er en 0, er det nå kommer til å bli en en.

489
00:33:21,240 --> 00:33:26,160
Siden dette er en 1, 1 ^ 1 er 0.

490
00:33:26,160 --> 00:33:33,280
Så vår 'a' har blitt 'A', og vår 'A' har blitt 'a'.

491
00:33:33,280 --> 00:33:36,910
Så XOR er en veldig praktisk måte å bare bla saken.

492
00:33:36,910 --> 00:33:39,960
Du bare ønsker å iterere over en kombinasjon av bokstaver

493
00:33:39,960 --> 00:33:44,330
og veksle tilfelle av hver enkelt karakter,

494
00:33:44,330 --> 00:33:50,680
du bare XOR alt med OX20.

495
00:33:50,680 --> 00:33:55,220
>> Nå har vi igjen skiftet. Venstre shift er bare kommer til å, i utgangspunktet,

496
00:33:55,220 --> 00:34:01,250
skyve alle tallene inn, eller til venstre, og sette inn 0 er bak dem.

497
00:34:01,250 --> 00:34:05,550
Så her har vi 00001101.

498
00:34:05,550 --> 00:34:08,560
Vi kommer til å presse tre 0-tallet fra høyre,

499
00:34:08,560 --> 00:34:13,580
og vi får 01.101.000.

500
00:34:13,580 --> 00:34:16,380
I ikke-binær form,

501
00:34:16,380 --> 00:34:24,699
vi ser at det er virkelig arbeider 13 venstre-forskjøvet med tre, noe som gir oss 104.

502
00:34:24,699 --> 00:34:32,530
Så venstre skiftende, ser vi her, er x << y utgangspunktet x * 2 ^ y.

503
00:34:32,530 --> 00:34:40,139
13 * 2 ^ 3, 2 ^ 3 er 8, slik at 13 * 8 er 104.

504
00:34:40,139 --> 00:34:45,679
Hvis du bare tenke på binære generelt, hvordan hvert siffer,

505
00:34:45,679 --> 00:34:49,530
Hvis vi starter fra høyre, er det en plass, deretter 2 plass, deretter 4 plass.

506
00:34:49,530 --> 00:34:51,330
Så ved å trykke på 0-er fra høyre,

507
00:34:51,330 --> 00:34:55,080
vi bare skyve ting som var i 4 plass til 8 plass,

508
00:34:55,080 --> 00:34:57,920
og ting som var i 8 plass til 16 plass.

509
00:34:57,920 --> 00:35:01,280
Hvert skift bare multipliserer med to. Yeah?

510
00:35:01,280 --> 00:35:05,210
[Student] Hva skjer hvis du forskjøvet med 5?

511
00:35:05,210 --> 00:35:10,790
[Bowden] Hvis du forskjøvet med 5 ville du bare miste sifre.

512
00:35:10,790 --> 00:35:15,410
Uunngåelig, er det det samme. Som, heltall er bare 32 bits,

513
00:35:15,410 --> 00:35:20,750
så hvis du legger to virkelig store heltall, det bare ikke passer i et heltall.

514
00:35:20,750 --> 00:35:23,660
Så det er det samme her. Hvis du forskjøvet med 5,

515
00:35:23,660 --> 00:35:25,650
vi ville bare miste den.

516
00:35:25,650 --> 00:35:28,820
Og det er litt av hva jeg mener med "grovt,"

517
00:35:28,820 --> 00:35:37,470
der hvis du flytter for langt, mister du biter.

518
00:35:37,470 --> 00:35:39,830
>> Høyre shift kommer til å være det motsatte,

519
00:35:39,830 --> 00:35:43,090
hvor vi kommer til å skubbe 0 er off slutten,

520
00:35:43,090 --> 00:35:48,400
og for vårt formål, fyll inn 0-er fra venstre.

521
00:35:48,400 --> 00:35:52,910
Så gjør dette, er vi i utgangspunktet reversere det vi allerede hadde gjort.

522
00:35:52,910 --> 00:35:57,780
Og vi ser at de tre 0-er på rett har nettopp falt av,

523
00:35:57,780 --> 00:36:02,020
og vi har presset 1,101 hele veien mot høyre.

524
00:36:02,020 --> 00:36:08,380
Dette gjør 104 >> 3, som er effektivt, x / 2 ^ y.

525
00:36:08,380 --> 00:36:11,200
Så nå, her er det en lignende idé.

526
00:36:11,200 --> 00:36:18,720
Hvorfor er det bare omtrent x / 2 ^ y, og ikke faktisk x / 2 ^ y?

527
00:36:18,720 --> 00:36:22,240
Fordi hvis jeg hadde flyttet med fire, ville jeg ha mistet en.

528
00:36:22,240 --> 00:36:25,950
Innerst inne, hva du tenker på, bare tenk på heltallsdivisjon generelt.

529
00:36:25,950 --> 00:36:31,070
Så, som 5/2 er to. Det er ikke 2,5.

530
00:36:31,070 --> 00:36:35,000
Det er den samme ideen her. Når vi deler med to,

531
00:36:35,000 --> 00:36:39,910
vi kan miste merkelig biter underveis.

532
00:36:39,910 --> 00:36:43,870
Så nå - det er det for bitvis. Det er alt du trenger å vite.

533
00:36:43,870 --> 00:36:46,340
Husk bruken sakene vi så i klassen,

534
00:36:46,340 --> 00:36:49,340
som litt maske er nyttig for bitvis operatører,

535
00:36:49,340 --> 00:36:53,220
eller du bruker dem for bit masker.

536
00:36:53,220 --> 00:36:58,620
Store bokstaver og små bokstaver, konverteringer er en ganske prototypisk eksempel.

537
00:36:58,620 --> 00:37:01,640
>> Ok, så buffer overflow angrep.

538
00:37:01,640 --> 00:37:05,110
Noen som husker hva som var galt med denne funksjonen?

539
00:37:05,110 --> 00:37:10,140
Legg merke vi erklært en rekke 12 bytes, 12 tegn,

540
00:37:10,140 --> 00:37:18,510
og da vi kopierer inn vår buffer på 12 chars hele strengen bar.

541
00:37:18,510 --> 00:37:25,080
Så hva er problemet her?

542
00:37:25,080 --> 00:37:32,270
Det magiske tallet 12 skal ganske mye umiddelbart sprette ut som - hvorfor 12?

543
00:37:32,270 --> 00:37:35,050
Hva hvis bar skjer for å være mer enn 12 tegn?

544
00:37:35,050 --> 00:37:41,200
Hva hvis baren er millioner av tegn?

545
00:37:41,200 --> 00:37:46,010
Her er problemet memcpy. Hvis linjen er lang nok,

546
00:37:46,010 --> 00:37:50,330
det vil bare helt - 'c', 'c' bryr seg ikke om at det var bare 12 tegn;

547
00:37:50,330 --> 00:37:53,280
'C' bryr seg ikke at det ikke kan passe på at mange bytes.

548
00:37:53,280 --> 00:37:58,250
Det vil bare helt overskrive røye, de 12 bytes vi har avsatt til det,

549
00:37:58,250 --> 00:38:01,830
og alt forbi det i minnet som ikke egentlig hører til at buffer

550
00:38:01,830 --> 00:38:06,520
med hva strengen linjen er.

551
00:38:06,520 --> 00:38:09,780
Så dette var det bildet vi så i klassen

552
00:38:09,780 --> 00:38:12,220
der vi har vår stabel vokser opp.

553
00:38:12,220 --> 00:38:16,040
Du bør være vant til disse bildene, eller bli kjent med dem igjen.

554
00:38:16,040 --> 00:38:21,260
Vi har vår stabel vokser opp, minneadresser starter på 0 på toppen

555
00:38:21,260 --> 00:38:26,270
og vokse ned å like 4 milliarder nederst.

556
00:38:26,270 --> 00:38:28,820
Vi har vår matrise 'c' et sted i minnet,

557
00:38:28,820 --> 00:38:32,260
da har vi vår pekeren til bar rett under den,

558
00:38:32,260 --> 00:38:38,720
og så har vi dette lagret ramme pekeren i vår returadresse og vårt moder rutine stack.

559
00:38:38,720 --> 00:38:40,800
Husk hva returadresse er?

560
00:38:40,800 --> 00:38:45,360
Det er når hoved kaller en funksjon foo, kaller en funksjon bar,

561
00:38:45,360 --> 00:38:48,100
uunngåelig, bar avkastning.

562
00:38:48,100 --> 00:38:52,610
Så da bar avkastning, de trenger å vite at det kommer tilbake til foo som kalte det.

563
00:38:52,610 --> 00:39:01,360
Så returadresse er adressen til den funksjonen at den har å gå tilbake til når funksjonen returnerer.

564
00:39:01,360 --> 00:39:05,830
Grunnen som er viktig for buffer overflow angrep er fordi, praktisk,

565
00:39:05,830 --> 00:39:09,580
hackere liker å endre det returadresse.

566
00:39:09,580 --> 00:39:14,950
I stedet for å gå tilbake til foo, kommer jeg til å gå tilbake dit hacker vil ha meg til å gå tilbake til.

567
00:39:14,950 --> 00:39:17,760
Og, beleilig, hvor hacker ofte ønsker å gå tilbake til

568
00:39:17,760 --> 00:39:22,400
er starten på bufferen som vi opprinnelig hadde.

569
00:39:22,400 --> 00:39:26,170
Så legger merke til, igjen, Little Indian.

570
00:39:26,170 --> 00:39:28,490
Apparatet er et eksempel på en Little Indian system,

571
00:39:28,490 --> 00:39:34,140
så et heltall eller en peker lagres med byte reversert.

572
00:39:34,140 --> 00:39:38,980
Så her ser vi - er dette? Yeah.

573
00:39:38,980 --> 00:39:45,660
Vi ser Ox80, OxC0, Ox35, OxO8.

574
00:39:45,660 --> 00:39:48,250
Husk de heksadesimale siffer?

575
00:39:48,250 --> 00:39:50,640
Vi trenger ikke reversere de heksadesimale siffer i Little Indian,

576
00:39:50,640 --> 00:39:56,110
fordi to heksadesimale siffer utgjør en enkelt byte, og vi reversere bytes.

577
00:39:56,110 --> 00:40:00,300
Det er derfor vi ikke lagre, som, 80530CO8.

578
00:40:00,300 --> 00:40:07,520
Vi lagrer, i stedet, hvert par av to siffer, med start fra høyre.

579
00:40:07,520 --> 00:40:10,880
At adresse refererer til adressen til start

580
00:40:10,880 --> 00:40:15,190
av vår buffer som vi faktisk ønsket å kopiere inn i første omgang.

581
00:40:15,190 --> 00:40:19,230
Grunnen til det er nyttig er fordi, hva hvis den angriper

582
00:40:19,230 --> 00:40:24,100
skjedde med, i stedet for å ha en streng som var bare

583
00:40:24,100 --> 00:40:27,060
en ufarlig rekke lignende, deres navn eller noe,

584
00:40:27,060 --> 00:40:33,900
hva om, i stedet, at strengen var bare noen vilkårlig kode

585
00:40:33,900 --> 00:40:38,610
som gjorde hva de ville at den skulle gjøre?

586
00:40:38,610 --> 00:40:45,630
Så de kunne - Jeg kan ikke komme på noen kule kode.

587
00:40:45,630 --> 00:40:47,780
Det kan være hva som helst, skjønt. Enhver katastrofal kode.

588
00:40:47,780 --> 00:40:51,440
Hvis de ville, kunne de bare gjøre noe på segmenter feil, men det ville være meningsløst.

589
00:40:51,440 --> 00:40:54,950
De pleier å gjøre det for å hacke systemet ditt.

590
00:40:54,950 --> 00:40:59,930
>> Ok. CS50 bibliotek.

591
00:40:59,930 --> 00:41:04,800
Dette er, i utgangspunktet, getInt, getString, alle de funksjonene vi gitt for deg.

592
00:41:04,800 --> 00:41:10,630
Så vi har char * streng, og det er den abstraksjon som vi blåste bort

593
00:41:10,630 --> 00:41:12,450
på et tidspunkt i løpet av semesteret.

594
00:41:12,450 --> 00:41:18,220
Husk at en streng er bare en rekke tegn.

595
00:41:18,220 --> 00:41:23,240
Så her ser vi en forkortet versjon av getString.

596
00:41:23,240 --> 00:41:25,920
Du bør se tilbake på det å huske hvordan det faktisk blir gjennomført.

597
00:41:25,920 --> 00:41:30,950
Viktige detaljer er, merker vi får i et enkelt tegn om gangen

598
00:41:30,950 --> 00:41:34,570
fra standard i, som er akkurat som oss å skrive på tastaturet.

599
00:41:34,570 --> 00:41:37,890
Så et enkelt tegn om gangen, og hvis vi får for mange tegn,

600
00:41:37,890 --> 00:41:40,580
slik at hvis n + 1 er større enn kapasiteten,

601
00:41:40,580 --> 00:41:44,140
Da må vi øke kapasiteten vår buffer.

602
00:41:44,140 --> 00:41:47,780
Så her er vi dobler størrelsen på vår buffer.

603
00:41:47,780 --> 00:41:51,840
Og det fortsetter å gå, vi sette inn tegnet inn vår buffer

604
00:41:51,840 --> 00:41:56,220
inntil vi får en ny linje eller slutten av filen eller hva,

605
00:41:56,220 --> 00:41:59,380
i så fall er vi ferdige med strengen og deretter den virke getString

606
00:41:59,380 --> 00:42:05,120
krymper minnet, som hvis vi tildelt for mye minne det vil gå tilbake og krympe litt.

607
00:42:05,120 --> 00:42:08,830
Så vi ikke viser det, men hovedideen er

608
00:42:08,830 --> 00:42:11,960
det har å lese i en enkelt tegn om gangen.

609
00:42:11,960 --> 00:42:17,140
Det kan ikke bare lese i en hele greia på en gang,

610
00:42:17,140 --> 00:42:19,550
fordi deres bufferen er bare av en viss størrelse.

611
00:42:19,550 --> 00:42:26,590
Så hvis strengen at den prøver å sette inn i buffer er for stor, så det ville renne over.

612
00:42:26,590 --> 00:42:28,940
Så her er vi forhindre at ved bare å lese i en enkelt karakter

613
00:42:28,940 --> 00:42:33,750
om gangen og voksende når vi må.

614
00:42:33,750 --> 00:42:40,270
Så getInt og de andre CS50 biblioteket funksjoner pleier å bruke getString

615
00:42:40,270 --> 00:42:42,310
i sine implementeringer.

616
00:42:42,310 --> 00:42:45,370
Så jeg uthevet de viktige tingene her.

617
00:42:45,370 --> 00:42:49,460
Det kaller getString å få en streng.

618
00:42:49,460 --> 00:42:51,710
Hvis getString unnlatt å returnere minne,

619
00:42:51,710 --> 00:42:54,270
husk at getString mallocs noe, så når du ringer getString

620
00:42:54,270 --> 00:42:57,820
du bør ikke (uforståelig) frigjøre strengen som du fikk.

621
00:42:57,820 --> 00:43:02,870
Så her, hvis det ikke klarte å malloc noe, returnerer vi INT_MAX som bare et flagg som,

622
00:43:02,870 --> 00:43:05,650
hei, vi var faktisk ikke i stand til å få et heltall.

623
00:43:05,650 --> 00:43:10,830
Du bør ignorere hva jeg kommer tilbake til deg, eller

624
00:43:10,830 --> 00:43:15,540
du bør ikke behandle dette som en gyldig inngang.

625
00:43:15,540 --> 00:43:21,360
Til slutt, forutsatt at det lyktes, bruker vi sscanf med den spesielle flagg,

626
00:43:21,360 --> 00:43:23,820
som betyr først matche et heltall,

627
00:43:23,820 --> 00:43:26,770
deretter med noen tegn etter at heltall.

628
00:43:26,770 --> 00:43:29,070
Så oppdager vi ønsker den skal være lik en.

629
00:43:29,070 --> 00:43:32,940
Så sscanf avkastning hvor mange kamper hvis hell laget?

630
00:43:32,940 --> 00:43:37,010
Den vil returnere en hvis det lykkes matchet et heltall,

631
00:43:37,010 --> 00:43:40,890
det vil returnere 0 hvis det ikke samsvarte med et heltall, og det vil returnere 2

632
00:43:40,890 --> 00:43:45,920
Hvis det passet et helt tall etterfulgt av noen tegn.

633
00:43:45,920 --> 00:43:49,780
Så merker vi prøve på nytt hvis vi matche alt annet enn en.

634
00:43:49,780 --> 00:43:55,230
Så hvis vi angitt 1, 2, 3, C, eller 1, 2, 3, X,

635
00:43:55,230 --> 00:43:57,400
deretter 1, 2, 3 vil bli lagret i det hele tall,

636
00:43:57,400 --> 00:43:59,620
X ville bli lagret på karakteren,

637
00:43:59,620 --> 00:44:06,410
sscanf ville returnere to, og vi ville prøve på nytt, fordi vi bare ønsker et heltall.

638
00:44:06,410 --> 00:44:09,810
>> Raskt blåser gjennom HTML, HTTP, CSS.

639
00:44:09,810 --> 00:44:15,340
Hypertext Markup Language er strukturen og semantikk av nettet.

640
00:44:15,340 --> 00:44:19,960
Her er et eksempel fra foredrag der vi har HTML-koder.

641
00:44:19,960 --> 00:44:22,110
Vi har hodet kodene, kropps koder,

642
00:44:22,110 --> 00:44:27,770
Vi har eksempler på tomme koder der vi faktisk ikke har en start og sluttkode,

643
00:44:27,770 --> 00:44:30,820
vi bare har link og bilde.

644
00:44:30,820 --> 00:44:38,480
Det er ingen avsluttende bildekode, det er bare en enkelt kode som oppnår alt tag trenger å gjøre.

645
00:44:38,480 --> 00:44:41,950
Koblingen er et eksempel, vi får se hvordan du kobler til CSS,

646
00:44:41,950 --> 00:44:45,910
skriptet er et eksempel på hvordan du kobler til en ekstern Javascript.

647
00:44:45,910 --> 00:44:53,100
Det er ganske grei, og husk, HTML er ikke et programmeringsspråk.

648
00:44:53,100 --> 00:44:58,250
Her må du huske hvordan du vil definere en form eller i det minste hva dette ville gjøre?

649
00:44:58,250 --> 00:45:01,740
En slik form har en handling og en fremgangsmåte.

650
00:45:01,740 --> 00:45:06,210
Metodene du vil bare noensinne se er GET og POST.

651
00:45:06,210 --> 00:45:09,040
Så GET er den versjonen der ting blir satt i nettadressen.

652
00:45:09,040 --> 00:45:11,680
POST er der det ikke er satt i nettadressen.

653
00:45:11,680 --> 00:45:18,520
I stedet, noen data fra skjemaet er satt inn mer skjult i HTTP-forespørsel.

654
00:45:18,520 --> 00:45:22,390
Så her, definerer handling der HTTP-forespørsel går.

655
00:45:22,390 --> 00:45:27,490
Hvor det kommer er google.com / search.

656
00:45:27,490 --> 00:45:32,890
Metode. Husk forskjellene mellom GET og POST,

657
00:45:32,890 --> 00:45:37,200
og, bare si som et eksempel, hvis du ønsker å bokmerke noe.

658
00:45:37,200 --> 00:45:40,660
Du vil aldri være i stand til å bokmerke en POST URL

659
00:45:40,660 --> 00:45:44,970
fordi dataene ikke er inkludert i nettadressen.

660
00:45:44,970 --> 00:45:49,790
>> HTTP, nå, er Hypertext Transfer Protocol.

661
00:45:49,790 --> 00:45:54,080
Hypertext Transfer Protocol, ville du forventer det å overføre

662
00:45:54,080 --> 00:45:57,710
Hypertext Markup Language, og det gjør det.

663
00:45:57,710 --> 00:46:00,170
Men det også overfører noen bilder du finner på nettet,

664
00:46:00,170 --> 00:46:05,400
noen nedlastinger du gjør starte som en HTTP-forespørsel.

665
00:46:05,400 --> 00:46:10,350
Så HTTP er bare språket i World Wide Web.

666
00:46:10,350 --> 00:46:15,610
Og her må du kjenne igjen denne typen en HTTP-forespørsel.

667
00:46:15,610 --> 00:46:19,300
Her HTTP/1.1 på siden bare sier det er den versjonen

668
00:46:19,300 --> 00:46:21,570
av protokollen jeg bruker.

669
00:46:21,570 --> 00:46:25,770
Det er stort sett alltid kommer til å være HTTP/1.1, som du får se det.

670
00:46:25,770 --> 00:46:30,110
Da ser vi at dette var GET, alternativet er POST, som du kan se.

671
00:46:30,110 --> 00:46:40,790
Og nettadressen som jeg prøvde å besøke var www.google.com/search?q = blah, blah, blah.

672
00:46:40,790 --> 00:46:44,240
Så husk at dette spørsmålstegnet q = blah blah blah,

673
00:46:44,240 --> 00:46:49,040
er den slags ting som er sendt inn av en form.

674
00:46:49,040 --> 00:46:51,830
Responsen det kanskje tilbake til meg vil se omtrent slik ut.

675
00:46:51,830 --> 00:46:54,050
Igjen, starter med protokollen, noe som kommer til å være det,

676
00:46:54,050 --> 00:46:59,190
etterfulgt av statuskoden. Her er det 200 OK.

677
00:46:59,190 --> 00:47:05,060
Og til slutt, vil nettsiden at jeg faktisk ba om bli fulgt.

678
00:47:05,060 --> 00:47:08,210
Den mulige statuskode du kan se, og du bør vite flere av dem.

679
00:47:08,210 --> 00:47:12,770
200 OK du har sikkert sett før.

680
00:47:12,770 --> 00:47:17,830
403 Forbidden, 404 Not Found, 500 Internal Server Error

681
00:47:17,830 --> 00:47:22,140
er vanligvis hvis du går til et nettsted og noe er ødelagt eller deres PHP-kode krasjer,

682
00:47:22,140 --> 00:47:24,930
mens i apparatet har vi den store oransje boks

683
00:47:24,930 --> 00:47:27,830
som kommer opp og sier, som er noe galt, betyr denne koden fungerer ikke

684
00:47:27,830 --> 00:47:30,380
eller denne funksjonen er ille.

685
00:47:30,380 --> 00:47:33,230
Vanligvis nettsteder ikke ønsker du å vite hvilke funksjoner er faktisk dårlig,

686
00:47:33,230 --> 00:47:37,880
så i stedet de vil bare gi deg 500 Intern serverfeil.

687
00:47:37,880 --> 00:47:43,050
>> TCP / IP er en lag under HTTP.

688
00:47:43,050 --> 00:47:47,550
Husk at det er Internett utenfor av World Wide Web.

689
00:47:47,550 --> 00:47:52,270
Som hvis du spiller et online spill som ikke går gjennom HTTP,

690
00:47:52,270 --> 00:47:55,740
det er å gå gjennom en annen - det er fortsatt bruk av Internett,

691
00:47:55,740 --> 00:47:58,900
men den ikke bruker HTTP.

692
00:47:58,900 --> 00:48:02,470
HTTP er bare ett eksempel på protokoll bygget på TCP / IP.

693
00:48:02,470 --> 00:48:07,820
IP bokstavelig betyr Internet Protocol.

694
00:48:07,820 --> 00:48:11,500
Hver datamaskin har en IP-adresse, de er de fire-sifrede ting

695
00:48:11,500 --> 00:48:16,510
som 192.168.2.1, eller hva, som har en tendens til å være en lokal en.

696
00:48:16,510 --> 00:48:23,390
Men det er et billede av en IP-adresse.

697
00:48:23,390 --> 00:48:29,060
Så DNS, Domain Name Service,

698
00:48:29,060 --> 00:48:33,410
det er det som betyr ting som google.com til en faktisk IP-adresse.

699
00:48:33,410 --> 00:48:37,700
Så hvis du skriver at IP-adressen inn i en URL,

700
00:48:37,700 --> 00:48:40,850
som ville bringe deg til Google, men du har en tendens til ikke å huske disse tingene.

701
00:48:40,850 --> 00:48:45,470
Du har en tendens til å huske google.com i stedet.

702
00:48:45,470 --> 00:48:51,560
Det siste vi har er porter, der dette er TCP del av IP.

703
00:48:51,560 --> 00:48:54,880
TCP gjør mer. Tenk om, som, du har din nettleser kjører.

704
00:48:54,880 --> 00:48:58,670
Kanskje du har noen e-postprogrammet kjører;

705
00:48:58,670 --> 00:49:02,150
kanskje du har noen andre program som bruker Internett i gang.

706
00:49:02,150 --> 00:49:05,090
De trenger tilgang til Internett,

707
00:49:05,090 --> 00:49:08,100
men datamaskinen har bare en WiFi-kort eller hva.

708
00:49:08,100 --> 00:49:10,780
Så porter er den måten at vi er i stand til å splitte opp

709
00:49:10,780 --> 00:49:13,550
hvordan disse programmene er i stand til å bruke Internett.

710
00:49:13,550 --> 00:49:17,230
Hver søknad får en bestemt port at det kan lytte på,

711
00:49:17,230 --> 00:49:19,670
og som standard, bruker HTTP port 80.

712
00:49:19,670 --> 00:49:22,410
Noen e-posttjenester bruker 25.

713
00:49:22,410 --> 00:49:24,490
Den lave-nummerert de pleier å være reservert.

714
00:49:24,490 --> 00:49:29,270
Du er vanligvis i stand til å få høyere nummererte dem for deg selv.

715
00:49:29,270 --> 00:49:32,010
>> CSS, Cascading Style Sheets.

716
00:49:32,010 --> 00:49:36,030
Vi style nettsider med CSS, ikke med HTML.

717
00:49:36,030 --> 00:49:38,440
Det er tre steder du kan sette ditt CSS.

718
00:49:38,440 --> 00:49:46,300
Det kan være inline, mellom stil koder, eller i en helt egen fil og deretter koblet i.

719
00:49:46,300 --> 00:49:48,470
Og her er bare et eksempel på CSS.

720
00:49:48,470 --> 00:49:50,450
Du bør anerkjenne dette mønsteret,

721
00:49:50,450 --> 00:49:54,310
hvor det første eksempelet er vi matchende body-koden,

722
00:49:54,310 --> 00:49:56,680
og her er vi sentre body-koden.

723
00:49:56,680 --> 00:50:00,420
Det andre eksemplet, er vi matche ting

724
00:50:00,420 --> 00:50:04,740
med ID bunntekst, og vi søker noen stiler til det.

725
00:50:04,740 --> 00:50:07,310
Legg merke til at ID-bunntekst justerer til venstre,

726
00:50:07,310 --> 00:50:09,840
mens kroppen tekstjusterer sentrum.

727
00:50:09,840 --> 00:50:13,180
Bunntekst er inne i kroppen.

728
00:50:13,180 --> 00:50:16,470
Det vil, i stedet, text-align igjen, selv om kroppen sier text-align center.

729
00:50:16,470 --> 00:50:18,880
Dette er hele gripende del av det.

730
00:50:18,880 --> 00:50:22,110
Du kan ha - du kan angi stiler for kroppen,

731
00:50:22,110 --> 00:50:25,320
og deretter ting i kroppen kan du angi mer spesifikke stiler,

732
00:50:25,320 --> 00:50:28,160
og ting fungerer som du forventer.

733
00:50:28,160 --> 00:50:34,420
Mer spesifikke CSS bransjen forrang.

734
00:50:34,420 --> 00:50:46,140
Jeg tror det er det.

735
00:50:46,140 --> 00:50:49,260
>> [Ali Nahm] Hei alle sammen. Hvis jeg bare kunne få din oppmerksomhet.

736
00:50:49,260 --> 00:50:53,990
Jeg er Ali og jeg kommer til å gå gjennom PHP og SQL veldig fort.

737
00:50:53,990 --> 00:51:00,310
Så vi kan begynne. PHP er en forkortelse for PHP: Hypertext Preprocessor.

738
00:51:00,310 --> 00:51:03,730
Og som dere alle burde vite, det er en server-side skriptspråk,

739
00:51:03,730 --> 00:51:06,800
og vi bruker det for bakenden av nettsteder,

740
00:51:06,800 --> 00:51:12,540
og hvordan den gjør mye av beregningene, bak-kulissene del.

741
00:51:12,540 --> 00:51:17,510
Syntaks. Det er ikke som C, surprise, surprise.

742
00:51:17,510 --> 00:51:22,060
Det har alltid å starte med det, hvis du kan se, - jeg kan ikke gå videre.

743
00:51:22,060 --> 00:51:31,340
Du kan se du trenger nye typer tannregulering og da trenger du også det? Php.

744
00:51:31,340 --> 00:51:35,780
Det er alltid som man har til å ramme inn PHP tekst, din PHP-kode.

745
00:51:35,780 --> 00:51:39,180
Så det kan ikke bare være som C, hvor du på en måte sette den på første.

746
00:51:39,180 --> 00:51:42,290
Du må alltid omgir den.

747
00:51:42,290 --> 00:51:47,610
Og nå, er den viktigste syntaks at alle variabler må starte med $ tegn.

748
00:51:47,610 --> 00:51:49,490
Du må gjøre det når du definerer dem, du trenger å gjøre det

749
00:51:49,490 --> 00:51:51,860
når du refererer til dem senere.

750
00:51:51,860 --> 00:51:56,510
Du må alltid at $. Det er din nye bestevenn, ganske mye.

751
00:51:56,510 --> 00:52:01,690
Du trenger ikke - i motsetning til C, du trenger ikke å sette hva slags variabel type det er.

752
00:52:01,690 --> 00:52:04,940
Så mens du gjør trenger $, trenger du ikke å sette, som,

753
00:52:04,940 --> 00:52:09,470
int x eller streng y, etcetera, etcetera.

754
00:52:09,470 --> 00:52:11,490
Så en liten forskjell.

755
00:52:11,490 --> 00:52:15,590
Som et resultat av dette, så betyr det at PHP er et svakt type.

756
00:52:15,590 --> 00:52:19,310
PHP er et svakt typen språk, og det har svakt skrevet variabler.

757
00:52:19,310 --> 00:52:24,020
Med andre ord, det betyr at du kan bytte mellom ulike typer variable typer.

758
00:52:24,020 --> 00:52:27,230
Du kan lagre nummeret ditt en som en int,

759
00:52:27,230 --> 00:52:29,650
du kan lagre det som en streng, og du kan lagre det som en dupp,

760
00:52:29,650 --> 00:52:33,550
og det vil være at nummer 1.

761
00:52:33,550 --> 00:52:36,080
Selv om du lagrer den i ulike former,

762
00:52:36,080 --> 00:52:39,120
det er fortsatt - de variable typer er fremdeles holder til slutt.

763
00:52:39,120 --> 00:52:41,540
Så hvis du ser her, hvis du husker fra PSett 7,

764
00:52:41,540 --> 00:52:43,500
mange av dere sikkert har hatt problemer med dette.

765
00:52:43,500 --> 00:52:47,280
To like tegn, tre like tegn, 4 like tegn.

766
00:52:47,280 --> 00:52:49,990
Ok, det er ingen 4 like tegn, men det er to og tre.

767
00:52:49,990 --> 00:52:53,320
Du bruker to like tegn for å sjekke verdiene.

768
00:52:53,320 --> 00:52:55,830
Det kan du sjekke på tvers av typer.

769
00:52:55,830 --> 00:52:58,770
Så hvis du kan se på det første eksemplet,

770
00:52:58,770 --> 00:53:02,210
Jeg har num_int == num_string.

771
00:53:02,210 --> 00:53:06,710
Så din int og strengen er både teknisk, 1,

772
00:53:06,710 --> 00:53:10,790
men de er forskjellige typer. Men for de doble likemenn, vil det fortsatt passere.

773
00:53:10,790 --> 00:53:15,510
Men for trippel likemenn, sjekker den verdi samt de forskjellige typene.

774
00:53:15,510 --> 00:53:18,760
Det betyr at det ikke kommer til å passere i det andre tilfellet her,

775
00:53:18,760 --> 00:53:22,350
hvor du bruker tre like tegn i stedet.

776
00:53:22,350 --> 00:53:26,590
Så det er en stor forskjell at du bør alle har vist nå.

777
00:53:26,590 --> 00:53:31,570
>> String sammensetning er en annen mektig ting du kan bruke i PHP.

778
00:53:31,570 --> 00:53:34,080
Det er i utgangspunktet bare denne hendige dot notasjon,

779
00:53:34,080 --> 00:53:36,230
og det er hvordan du kan binde strenger sammen.

780
00:53:36,230 --> 00:53:40,800
Så hvis du har katt, og du har hund, og du ønsker å sette de to strenger sammen,

781
00:53:40,800 --> 00:53:44,080
du kan bruke den perioden, og det er litt av hvordan det fungerer.

782
00:53:44,080 --> 00:53:46,660
Du kan også bare plassere dem ved siden av hverandre,

783
00:53:46,660 --> 00:53:49,030
som du kan se her i bunnen eksempel

784
00:53:49,030 --> 00:53:51,610
hvor jeg har ekko streng 1, plass streng to.

785
00:53:51,610 --> 00:53:56,930
PHP vil vite å erstatte dem som sådan.

786
00:53:56,930 --> 00:53:59,780
Arrays. Nå, i PHP, det er to forskjellige typer av matriser.

787
00:53:59,780 --> 00:54:03,180
Du kan ha vanlige arrays, og du kan også ha assosiative arrays,

788
00:54:03,180 --> 00:54:06,040
og vi kommer til å gå gjennom dem akkurat nå.

789
00:54:06,040 --> 00:54:08,280
Regelmessige arrays er nettopp dette i C,

790
00:54:08,280 --> 00:54:11,240
og så du har indekser som er nummerert.

791
00:54:11,240 --> 00:54:13,160
Akkurat nå er vi bare nødt til å lage en og sagt -

792
00:54:13,160 --> 00:54:15,500
så dette er hvordan vi skaper en tom array, så vi kommer til å

793
00:54:15,500 --> 00:54:17,310
sette inn indeksnummeret 0.

794
00:54:17,310 --> 00:54:19,200
Vi kommer til å sette nummer seks, verdien seks.

795
00:54:19,200 --> 00:54:21,500
Du kan se det på bunnen her.

796
00:54:21,500 --> 00:54:24,240
Where's - på indeksnummer 1 skal vi sette verdien nummer fire,

797
00:54:24,240 --> 00:54:26,720
og slik at du kan se det er en seks, det er en fire,

798
00:54:26,720 --> 00:54:29,160
og deretter som vi skriver ut ting,

799
00:54:29,160 --> 00:54:33,550
når vi prøver og skrive ut verdien som er lagret på indeksnummer 0,

800
00:54:33,550 --> 00:54:36,900
så får vi se verdien seks som skrives ut. Cool?

801
00:54:36,900 --> 00:54:40,160
Så det er vanlige arrays for deg.

802
00:54:40,160 --> 00:54:42,750
En annen måte du kan også legge ting til vanlige arrays nå

803
00:54:42,750 --> 00:54:44,780
er kan du bare legge dem på slutten.

804
00:54:44,780 --> 00:54:47,240
Det betyr at du ikke trenger å spesifisere nærmere angitt indeks.

805
00:54:47,240 --> 00:54:51,000
Du kan se nummer, og deretter i klammeparenteser er det ingen indeks spesifisert.

806
00:54:51,000 --> 00:54:56,270
Og det vil vite - PHP vil vite å bare legge det til slutten av listen, den neste gratis spot.

807
00:54:56,270 --> 00:54:59,190
Så du kan se en rett der på at 0 spot,

808
00:54:59,190 --> 00:55:02,690
de to gikk der på første plass.

809
00:55:02,690 --> 00:55:04,690
Den tre går - er lagt der også.

810
00:55:04,690 --> 00:55:06,720
Så den slags er fornuftig. Du er bare tiden legger det,

811
00:55:06,720 --> 00:55:09,360
og deretter når vi ekko indeksen av nummer 1,

812
00:55:09,360 --> 00:55:13,080
det vil skrive ut verdien to.

813
00:55:13,080 --> 00:55:16,800
>> Da har vi arrays som er assosiative arrays.

814
00:55:16,800 --> 00:55:19,370
Assosiative arrays, i stedet for å ha numeriske indekser,

815
00:55:19,370 --> 00:55:23,630
hva de gjør er, de har indekser som er av strengen.

816
00:55:23,630 --> 00:55:25,670
Du kan se, i stedet for - jeg ble kvitt alle disse tallindekser,

817
00:55:25,670 --> 00:55:32,140
og nå er det nøkkel1, TAST2, TAST3, og de er i anførselstegn for å markere at de er alle strenger.

818
00:55:32,140 --> 00:55:34,470
Så vi kan ha et eksempel på dette.

819
00:55:34,470 --> 00:55:38,790
Det eksempel på dette er at vi har tf, og det er indeksnavnet.

820
00:55:38,790 --> 00:55:42,030
Vi kommer til å sette "Ali" som navn, på indeksen, kalorier spist,

821
00:55:42,030 --> 00:55:47,640
vi kan sette en int denne gangen i stedet for en streng,

822
00:55:47,640 --> 00:55:52,240
og deretter på indeks liker, kan vi sette en hel rekke innsiden av det.

823
00:55:52,240 --> 00:55:55,490
Så dette er slags - det er et lignende konsept til hvordan vi hadde

824
00:55:55,490 --> 00:55:58,930
indekser med tall, men nå kan vi endre indeksene rundt

825
00:55:58,930 --> 00:56:03,890
å ha dem som strenger i stedet.

826
00:56:03,890 --> 00:56:06,070
Du kan også gjøre dette, i tillegg til bare å gjøre det individuelt,

827
00:56:06,070 --> 00:56:09,400
du kan gjøre alt i én klump. Så du kan se at tf av denne matrisen,

828
00:56:09,400 --> 00:56:13,350
og da vi satt dem alle i én gigantisk hakeparentes sett.

829
00:56:13,350 --> 00:56:15,220
Så det kan øke hastigheten ting opp.

830
00:56:15,220 --> 00:56:19,730
Det er mer av et stilistisk valg enn ikke.

831
00:56:19,730 --> 00:56:21,550
Vi har også løkker.

832
00:56:21,550 --> 00:56:26,020
I C har vi looper som fungerer som dette.

833
00:56:26,020 --> 00:56:29,690
Vi hadde vår rekke, og vi gikk fra indeks 0 til slutten av listen,

834
00:56:29,690 --> 00:56:31,740
og vi skriver ut det hele, ikke sant?

835
00:56:31,740 --> 00:56:33,880
Bortsett problemet er, for assosiative arrays,

836
00:56:33,880 --> 00:56:36,610
vi ikke nødvendigvis vet de numeriske indekser

837
00:56:36,610 --> 00:56:39,610
fordi nå har vi de streng indeksene.

838
00:56:39,610 --> 00:56:44,800
Nå bruker vi foreach løkker, som, igjen, du forhåpentligvis brukes i PSett 7.

839
00:56:44,800 --> 00:56:48,930
Foreach løkker vil bare vite hver eneste del av listen.

840
00:56:48,930 --> 00:56:52,450
Og det trenger ikke å vite nøyaktig numerisk indeks som du har.

841
00:56:52,450 --> 00:56:56,490
Så du har foreach syntaks, så det er foreach, du putter matrisen.

842
00:56:56,490 --> 00:57:00,430
Så min matrise kalles PSett, og deretter som, ordet som,

843
00:57:00,430 --> 00:57:04,530
og deretter sette denne lokale midlertidig variabel som du kommer til å bruke

844
00:57:04,530 --> 00:57:10,690
bare for den spesifikke ting som kommer til å holde den spesifikke -

845
00:57:10,690 --> 00:57:14,770
en forekomst eller en del av matrisen.

846
00:57:14,770 --> 00:57:18,350
PSett num vil holde en, og så kanskje det vil holde nummer seks,

847
00:57:18,350 --> 00:57:20,410
og da vil det holde nummer 2.

848
00:57:20,410 --> 00:57:26,630
Men det er garantert å gå gjennom hver enkelt verdi som er i matrisen.

849
00:57:26,630 --> 00:57:30,530
Nyttige funksjoner som du bør vite i PHP er den krever,

850
00:57:30,530 --> 00:57:35,880
slik som sørger for at du er inkludert visse filer, ekko, exit, tom.

851
00:57:35,880 --> 00:57:40,490
Jeg anbefaler at du ser på PSett 7 og se på disse funksjonene.

852
00:57:40,490 --> 00:57:42,810
Du har kanskje kjent med dem,

853
00:57:42,810 --> 00:57:47,060
så jeg ville definitivt vet hva, akkurat, de alle gjør.

854
00:57:47,060 --> 00:57:50,080
>> Og nå skal vi gå gjennom omfanget veldig raskt.

855
00:57:50,080 --> 00:57:53,490
I omfang, er PHP slags funky ting, i motsetning til C,

856
00:57:53,490 --> 00:57:56,170
og så vi bare kommer til å gå gjennom det raskt.

857
00:57:56,170 --> 00:57:58,930
Så la oss si at vi starter på den pilen som vi har der.

858
00:57:58,930 --> 00:58:02,900
Og vi kommer til å starte med $ i. Så variabelen 'i' kommer til å være 0,

859
00:58:02,900 --> 00:58:06,730
og vi bare kommer til å fortsette å skrive det i det store hvite boksen der borte.

860
00:58:06,730 --> 00:58:09,220
Vi kommer til å starte med i0, og så skal vi til ekko det.

861
00:58:09,220 --> 00:58:12,670
Så det er 0.

862
00:58:12,670 --> 00:58:15,210
Og så kommer vi til å øke den ved for loop,

863
00:58:15,210 --> 00:58:17,810
og da kommer det til å være verdien av en.

864
00:58:17,810 --> 00:58:20,070
Den ene er mindre enn tre, så det kommer til å passere gjennom den for loop,

865
00:58:20,070 --> 00:58:23,230
og da skal vi se det skrevet ut igjen.

866
00:58:23,230 --> 00:58:25,520
Vi kommer til å øke den igjen til 2,

867
00:58:25,520 --> 00:58:29,860
og to er mindre enn tre, så det vil passere for loop, og det vil skrive ut to.

868
00:58:29,860 --> 00:58:35,100
Da vil du merke at 3 er ikke mindre enn tre, så vi vil bryte ut av for-løkken.

869
00:58:35,100 --> 00:58:40,050
Så nå har vi gått ut, og da vi kommer til å gå inn aFunction.

870
00:58:40,050 --> 00:58:45,010
Ok. Så du må være oppmerksom på at denne variabelen at vi har opprettet,

871
00:58:45,010 --> 00:58:48,270
'i' variabel, ikke er lokalt scoped.

872
00:58:48,270 --> 00:58:50,280
Det betyr at det ikke er lokale til løkken,

873
00:58:50,280 --> 00:58:58,060
og den variabelen vi kan fortsatt få tilgang til og endre etterpå, og det vil fortsatt være effektiv.

874
00:58:58,060 --> 00:59:02,160
Så hvis du går inn i funksjonen nå, vil du se at vi også bruke "jeg"-variabelen,

875
00:59:02,160 --> 00:59:05,320
og vi kommer til å øke 'i' + +.

876
00:59:05,320 --> 00:59:09,410
Du skulle tro ved første, basert på C, at det er en kopi av "jeg"-variabelen.

877
00:59:09,410 --> 00:59:12,830
Det er en helt annen ting, som er korrekt.

878
00:59:12,830 --> 00:59:16,560
Så når vi skriver det, kommer vi til å skrive ut 'i' + +, noe som kommer til å skrive ut som fire,

879
00:59:16,560 --> 00:59:19,640
og deretter skal vi - beklager.

880
00:59:19,640 --> 00:59:22,030
Så får vi kommer til å ende ut av denne funksjonen,

881
00:59:22,030 --> 00:59:24,820
og vi kommer til å være der som pilen er akkurat nå.

882
00:59:24,820 --> 00:59:29,190
Det vil si at da har imidlertid selv om funksjonen endres verdien av 'i',

883
00:59:29,190 --> 00:59:32,620
det endret ikke utenfor funksjonen,

884
00:59:32,620 --> 00:59:35,060
fordi funksjonen har en separat omfang.

885
00:59:35,060 --> 00:59:38,960
Det betyr at når vi echo 'i', det har ikke forandret seg i det omfanget av funksjonen,

886
00:59:38,960 --> 00:59:43,660
og så så vi kommer til å skrive ut tre igjen.

887
00:59:43,660 --> 00:59:47,520
Forskjellige ting om omfanget i PHP enn i C.

888
00:59:47,520 --> 00:59:51,130
>> Nå i PHP og HTML.

889
00:59:51,130 --> 00:59:53,510
PHP brukes til å lage websider dynamisk.

890
00:59:53,510 --> 00:59:58,660
Det gjør slags ting annerledes.

891
00:59:58,660 --> 01:00:02,090
Vi har det forskjellig fra HTML.

892
01:00:02,090 --> 01:00:05,230
Med HTML, vi alltid bare har det samme statiske ting, som hvordan Rob viste,

893
01:00:05,230 --> 01:00:09,370
mens PHP, kan du endre ting basert på hvem brukeren er.

894
01:00:09,370 --> 01:00:11,830
Så hvis jeg har dette, jeg har, "Du er logget inn som -" og deretter navnet,

895
01:00:11,830 --> 01:00:14,420
og jeg kan endre navnet. Så akkurat nå navnet er Joseph,

896
01:00:14,420 --> 01:00:18,880
og det har den "om meg", men så kan jeg også endre navnet å ha Tommy.

897
01:00:18,880 --> 01:00:21,700
Og det ville være en annen ting.

898
01:00:21,700 --> 01:00:23,840
Så da kan vi også endre forskjellige ting om ham,

899
01:00:23,840 --> 01:00:27,070
og det vil vise forskjellig innhold basert på navnet.

900
01:00:27,070 --> 01:00:31,430
Så PHP kan slags endre hva som skjer på nettstedet ditt.

901
01:00:31,430 --> 01:00:33,540
Samme her. Men merk at de har forskjellig innhold,

902
01:00:33,540 --> 01:00:38,870
selv om du er teknisk sett fortsatt tilgang til den samme nettsiden på overflaten.

903
01:00:38,870 --> 01:00:43,450
Genererer HTML. Det er to forskjellige måter du kan gjøre dette.

904
01:00:43,450 --> 01:00:48,980
Så får vi gå gjennom det akkurat nå. Den første måten er, du har - ja, beklager.

905
01:00:48,980 --> 01:00:51,150
Så må du bare din vanlige for loop i PHP,

906
01:00:51,150 --> 01:00:56,270
og deretter du ekko i PHP, og du ekko ut HTML.

907
01:00:56,270 --> 01:00:58,720
Bruke hva Rob viste deg av HTML script

908
01:00:58,720 --> 01:01:04,030
og deretter bruke PHP print å bare skrive det ut til websiden.

909
01:01:04,030 --> 01:01:09,520
Alternativet måten er å gjøre det som om du skille ut PHP og HTML.

910
01:01:09,520 --> 01:01:11,940
Så du kan ha en linje av PHP som starter for loop,

911
01:01:11,940 --> 01:01:16,020
så kan du ha linjen av HTML i en egen ting,

912
01:01:16,020 --> 01:01:19,700
og så ender du sløyfen, igjen, med en PHP.

913
01:01:19,700 --> 01:01:21,800
Så det er slags skille det ut.

914
01:01:21,800 --> 01:01:24,020
På venstre side, kan du at du har all den -

915
01:01:24,020 --> 01:01:26,360
det er bare en del av PHP.

916
01:01:26,360 --> 01:01:28,510
På høyre side kan du se at du har en linje av PHP,

917
01:01:28,510 --> 01:01:32,540
du har en linje med HTML, og du har en linje med PHP igjen.

918
01:01:32,540 --> 01:01:36,870
Så skille det ut i hva de gjør.

919
01:01:36,870 --> 01:01:39,330
Og du vil merke at uansett, for en av dem,

920
01:01:39,330 --> 01:01:41,980
de fremdeles skrive ut bildet, bildet, bildet,

921
01:01:41,980 --> 01:01:44,540
slik at HTML fortsatt skrives på samme måte.

922
01:01:44,540 --> 01:01:49,870
Og da vil du fortsatt se de tre bildene vises på nettstedet ditt.

923
01:01:49,870 --> 01:01:52,820
Så det er to forskjellige måter å gjøre det samme.

924
01:01:52,820 --> 01:01:55,060
>> Nå har vi former og forespørsler. Som Rob viste deg,

925
01:01:55,060 --> 01:01:59,400
det finnes former for HTML, og vi vil bare sus gjennom dette.

926
01:01:59,400 --> 01:02:02,040
Du har en handling og du har en metode, og din handling

927
01:02:02,040 --> 01:02:04,350
slags viser deg hvor du skal sende den, og metoden er om

928
01:02:04,350 --> 01:02:06,960
det kommer til å være en GET eller et POST.

929
01:02:06,960 --> 01:02:11,220
Og en GET-forespørsel, som Rob sa, betyr at du kommer til å sette den i en form

930
01:02:11,220 --> 01:02:15,760
og du vil se det som en URL, mens en POST-forespørsel vil du ikke se i en URL.

931
01:02:15,760 --> 01:02:17,840
Så en liten forskjell.

932
01:02:17,840 --> 01:02:19,950
Men en ting som er en lignende ting

933
01:02:19,950 --> 01:02:22,560
er at POST og GET er like usikker.

934
01:02:22,560 --> 01:02:26,430
Så du kan tro at bare fordi du ikke ser det i nettadressen,

935
01:02:26,430 --> 01:02:28,790
det betyr at POST er sikrere,

936
01:02:28,790 --> 01:02:34,420
men du kan fortsatt se det i informasjonskapslene i den informasjonen som du sender.

937
01:02:34,420 --> 01:02:38,260
Så tror ikke at om det ene eller det andre.

938
01:02:38,260 --> 01:02:42,160
En annen ting å merke seg er at du har også seksjons variabler.

939
01:02:42,160 --> 01:02:45,850
Dere brukte dette i PSett 7 for å få din bruker-ID informasjon.

940
01:02:45,850 --> 01:02:48,550
Det som skjedde var at du kan bruke denne assosiativ array,

941
01:02:48,550 --> 01:02:53,310
den $ _SESSION, og da er du i stand til å få tilgang til forskjellige ting

942
01:02:53,310 --> 01:02:57,720
og lagre forskjellige ting på tvers av sider.

943
01:02:57,720 --> 01:03:00,750
>> Siste ting er at vi har SQL, Structured Query Language,

944
01:03:00,750 --> 01:03:04,360
og dette er et programmeringsspråk for å administrere databaser.

945
01:03:04,360 --> 01:03:08,220
Hva, nøyaktig, er databaser? De er samlinger av tabeller,

946
01:03:08,220 --> 01:03:10,630
og hvert bord kan ha lignende typer objekter.

947
01:03:10,630 --> 01:03:14,990
Så vi hadde en tabell med brukere i finans PSett.

948
01:03:14,990 --> 01:03:20,610
Og hvorfor er de nyttige? Fordi det er en måte å permanent lagring av informasjon.

949
01:03:20,610 --> 01:03:22,840
Det er en måte å spore ting og administrere ting

950
01:03:22,840 --> 01:03:25,890
og faktisk se det på forskjellige sider og holde styr.

951
01:03:25,890 --> 01:03:29,930
Mens hvis du bare lagre det på at en umiddelbar øyeblikk

952
01:03:29,930 --> 01:03:33,720
og deretter bruke den senere, vil du ikke kunne få tilgang til noe som du har lagret.

953
01:03:33,720 --> 01:03:37,660
Vi har fire store ting som vi bruker for SQL-kommandoer.

954
01:03:37,660 --> 01:03:40,190
Vi har å velge, sette inn, slette og oppdatere.

955
01:03:40,190 --> 01:03:42,880
De er veldig viktig for dere å vite for quiz.

956
01:03:42,880 --> 01:03:45,990
>> Vi vil raskt gå over velger akkurat nå.

957
01:03:45,990 --> 01:03:48,540
I utgangspunktet, du velge rader fra en database.

958
01:03:48,540 --> 01:03:52,400
Så hvis du har, akkurat her -

959
01:03:52,400 --> 01:03:56,740
vi har disse to forskjellige ting, og vi ønsker å velge fra klassene tabellen

960
01:03:56,740 --> 01:04:01,480
hvor awesome - hvor i fantastisk kolonnen verdien er en.

961
01:04:01,480 --> 01:04:04,460
Så du kan se her, har vi disse to tingene i klassenavnet,

962
01:04:04,460 --> 01:04:08,490
CS50 og STAT110, og vi har klasse IDer og slagordet.

963
01:04:08,490 --> 01:04:13,150
Så vi ønsker å velge all denne informasjonen.

964
01:04:13,150 --> 01:04:17,480
Da kan du se her at det er slags plukke ut av det kjempebra kolonnen,

965
01:04:17,480 --> 01:04:25,170
hvor alle ting er ett, og deretter den har klassen ID, klasse navn og slagord som den kan plukke ut.

966
01:04:25,170 --> 01:04:28,100
Hvor nøyaktig kan du gjøre dette i koden? Du må bruke PHP.

967
01:04:28,100 --> 01:04:33,830
Så det er slags hvordan PHP og SQL er relatert til hverandre.

968
01:04:33,830 --> 01:04:38,130
Nå har vi vår kode, og vi kommer til å bruke vår spørring funksjon

969
01:04:38,130 --> 01:04:41,370
som vi gjorde i PSett 7, og vi kommer til å kjøre SQL-spørringen.

970
01:04:41,370 --> 01:04:43,870
Så skal vi ha -

971
01:04:43,870 --> 01:04:46,280
vi alltid må sjekke om rad trippel lik hvis usann.

972
01:04:46,280 --> 01:04:49,010
Så igjen, du vil sjekke hvilken type og verdi,

973
01:04:49,010 --> 01:04:53,880
og hvis det ikke fungerer, så du ønsker å be om unnskyldning, som vanlig, slik vi gjorde i PSett 7.

974
01:04:53,880 --> 01:04:55,870
Ellers vil du sløyfe gjennom alt med dem hendig

975
01:04:55,870 --> 01:04:59,410
foreach løkker at vi bare gikk over.

976
01:04:59,410 --> 01:05:01,280
Nå som vi er looping gjennom, og vi har gjort det siste,

977
01:05:01,280 --> 01:05:05,080
la oss anta at vår spørring passert, nå har vi vår foreach loop.

978
01:05:05,080 --> 01:05:11,050
Og den første raden den har, så her er rad, akkurat her, det er eske.

979
01:05:11,050 --> 01:05:14,010
Det kommer til å skrive ut all informasjon som det er blitt.

980
01:05:14,010 --> 01:05:18,070
Så det kommer til å skrive ut på bunnen "Wanna Lær HTML?"

981
01:05:18,070 --> 01:05:23,370
Så det kommer til å gå til neste rad, fordi det er fullført den første for-løkken,

982
01:05:23,370 --> 01:05:26,510
og så så det kommer til å skrive ut den andre linjen av det,

983
01:05:26,510 --> 01:05:32,120
som kommer til å være STAT110, Finn alle Moments.

984
01:05:32,120 --> 01:05:34,290
>> En siste ting er på SQL Vulnerabilities.

985
01:05:34,290 --> 01:05:37,300
Jeg vet David berørt dette litt i forelesningen.

986
01:05:37,300 --> 01:05:40,730
Du kan lese dette senere. Det er virkelig morsomt.

987
01:05:40,730 --> 01:05:45,320
SQL Injection er en slags vanskelige ting.

988
01:05:45,320 --> 01:05:49,890
La oss si at du bare holde disse variablene rett inn i søket,

989
01:05:49,890 --> 01:05:52,290
som du kan se i den første linjen.

990
01:05:52,290 --> 01:05:54,520
Så det virker fint, ikke sant? Du er bare å sette inn brukernavnet

991
01:05:54,520 --> 01:05:58,820
og passord til din SQL-spørring, og du ønsker å sende den av og få alt som er i datatabellen.

992
01:05:58,820 --> 01:06:01,450
Det virker ganske enkelt. Så kan si noen setter inn,

993
01:06:01,450 --> 01:06:04,910
for passordet, dette ELLER teksten her -

994
01:06:04,910 --> 01:06:06,780
bør faktisk være i den røde boksen.

995
01:06:06,780 --> 01:06:11,920
Så la oss si at de satt som passord i - det er det de kommer inn.

996
01:06:11,920 --> 01:06:16,520
Så de legger OR "1" = 1.

997
01:06:16,520 --> 01:06:20,880
Slag av en dum passord for å ha.

998
01:06:20,880 --> 01:06:25,070
Nå la oss bare erstatte den i, og du vil merke at i at SQL-spørring nå,

999
01:06:25,070 --> 01:06:29,090
det vurderer å alltid sant, fordi du vil merke at

1000
01:06:29,090 --> 01:06:32,240
du kan SQL-spørring velge all denne informasjonen

1001
01:06:32,240 --> 01:06:35,420
eller du kan bare ha 1 = 1.

1002
01:06:35,420 --> 01:06:41,030
Slik at det alltid kommer til å vurdere å true.

1003
01:06:41,030 --> 01:06:46,610
Det kommer ikke til å virkelig jobbe, fordi det betyr at hackeren kan bryte seg inn i systemet ditt.

1004
01:06:46,610 --> 01:06:49,300
Løsningen på dette er at du må bruke PUD-systemet,

1005
01:06:49,300 --> 01:06:51,360
noe som betyr at du må bruke spørsmålstegn,

1006
01:06:51,360 --> 01:06:53,350
som er det du brukte i PSett 7,

1007
01:06:53,350 --> 01:06:57,620
hvor du kommer til å bruke et spørsmålstegn i stedet for hvor du ønsker å sette noe,

1008
01:06:57,620 --> 01:07:01,430
og så kommer du til å ha et komma, og da vil du ha etterpå,

1009
01:07:01,430 --> 01:07:07,610
etter streng, til de ulike variablene som du vil bytte inn din spørsmålstegn.

1010
01:07:07,610 --> 01:07:10,330
Så du vil merke seg her at nå har jeg disse røde spørsmålstegn.

1011
01:07:10,330 --> 01:07:15,420
Da jeg satte variablene etter mine strenger så jeg vet å erstatte dem i den rekkefølgen etterpå.

1012
01:07:15,420 --> 01:07:18,470
Det vil sørge for at hvis noen gjør det slik,

1013
01:07:18,470 --> 01:07:24,050
og de har den eller en = en situasjon, som vil sørge for,

1014
01:07:24,050 --> 01:07:30,490
i bakenden, sørg for at det ikke vil faktisk bryte SQL-spørringen.

1015
01:07:30,490 --> 01:07:33,660
Ok, så det er ganske mye det, en virvelvind av PHP og SQL.

1016
01:07:33,660 --> 01:07:41,520
Lykke til alle dere, og nå til Ore

1017
01:07:41,520 --> 01:07:44,270
>> [Oreoluwatomiwa Babarinsa] Ok alle. På tide å gå over noen Java

1018
01:07:44,270 --> 01:07:48,840
og noen andre ting veldig fort, så vi trenger ikke holde deg i kveld.

1019
01:07:48,840 --> 01:07:56,930
Javascript. Ja. Javascript er slag av en kul ting, angivelig.

1020
01:07:56,930 --> 01:07:59,090
De tingene du virkelig trenger å vite om Javascript, er det liksom som

1021
01:07:59,090 --> 01:08:03,810
klientsiden slutten av hva din web app kommer til å gjøre.

1022
01:08:03,810 --> 01:08:08,280
Det er noen ting du bare ikke ønsker å ta vare på hele tiden på serversiden.

1023
01:08:08,280 --> 01:08:12,880
Alle de små interaksjoner, fremhever en ting, og gjør noe forsvinner.

1024
01:08:12,880 --> 01:08:15,340
Du virkelig ikke ønsker å ha til å snakke med serveren din hele tiden for det.

1025
01:08:15,340 --> 01:08:18,069
Og noe av det er ikke engang mulig å gjøre på serversiden.

1026
01:08:18,069 --> 01:08:21,899
Dette er grunnen til at vi trenger noe som Javascript.

1027
01:08:21,899 --> 01:08:24,359
Kule ting om Java: Det er dynamisk skrevet.

1028
01:08:24,359 --> 01:08:27,149
Hva dette betyr er at programmet ikke trenger å vite

1029
01:08:27,149 --> 01:08:30,970
hva, akkurat, variablene er når du skriver det ut.

1030
01:08:30,970 --> 01:08:34,510
Det vil bare liksom finne det ut som den kjører.

1031
01:08:34,510 --> 01:08:37,520
Andre ting som er kult om det: Det er en klammeparentes språk,

1032
01:08:37,520 --> 01:08:41,359
noe som betyr at syntaksen er lik C og PHP.

1033
01:08:41,359 --> 01:08:47,050
Du trenger ikke å gjøre mye ekstraarbeid når du lærer Javascript.

1034
01:08:47,050 --> 01:08:49,180
Her har vi en liten bit av Javascript.

1035
01:08:49,180 --> 01:08:52,560
Interessant ting her er at hvis du ser på det,

1036
01:08:52,560 --> 01:08:56,330
vi har en bit av Java rett der i hodet tag.

1037
01:08:56,330 --> 01:08:59,479
Hva er ikke er i utgangspunktet bare omfatter en Javascript-fil.

1038
01:08:59,479 --> 01:09:02,260
Dette er en måte du kan inkludere Java inn i programmet.

1039
01:09:02,260 --> 01:09:06,910
Da den andre litt er faktisk noen inline Javascript,

1040
01:09:06,910 --> 01:09:10,790
svært lik en innebygd stil med CSS,

1041
01:09:10,790 --> 01:09:16,180
og du bare å skrive noen kode svært raskt der.

1042
01:09:16,180 --> 01:09:18,120
Javascript har arrays.

1043
01:09:18,120 --> 01:09:20,850
Bare en annen måte å holde data rundt, veldig nyttig.

1044
01:09:20,850 --> 01:09:25,180
Veldig fin og enkel syntaks.

1045
01:09:25,180 --> 01:09:29,870
Du bruker hakeparenteser for å få tilgang til alt og holde alt sammen.

1046
01:09:29,870 --> 01:09:35,020
Ingenting er for komplisert.

1047
01:09:35,020 --> 01:09:38,630
Den kule ting om Javascript og skriptspråk generelt

1048
01:09:38,630 --> 01:09:40,920
er at du ikke trenger å bekymre deg for array-størrelser.

1049
01:09:40,920 --> 01:09:43,880
Du kan bare bruke tabell.length og holde styr på det,

1050
01:09:43,880 --> 01:09:46,960
og også matrisen kan vokse eller krympe når du trenger det til.

1051
01:09:46,960 --> 01:09:49,279
Så trenger du ikke engang trenger å bekymre deg for noen form for,

1052
01:09:49,279 --> 01:09:57,050
oh no, jeg trenger å bevilge flere ting, eller noe sånt.

1053
01:09:57,050 --> 01:10:00,090
>> Det kule her er at Javascript har noe som kalles gjenstander.

1054
01:10:00,090 --> 01:10:04,800
Det er et objektorientert språk, så hva det har er, i hovedsak,

1055
01:10:04,800 --> 01:10:10,100
en måte for deg å gruppere data sammen, noe som ligner på en struct,

1056
01:10:10,100 --> 01:10:17,280
men du kan få tilgang til det som en struct eller i en assosiativ array syntaks.

1057
01:10:17,280 --> 01:10:22,520
Det er ganske enkelt, og hva du kan gjøre med dette er gruppen data sammen

1058
01:10:22,520 --> 01:10:24,810
hvis du har en haug med data som er relatert.

1059
01:10:24,810 --> 01:10:26,850
Fordi det er alle de tingene du trenger for å beskrive en bil,

1060
01:10:26,850 --> 01:10:29,050
du trenger ikke å ha det i en haug med forskjellige steder.

1061
01:10:29,050 --> 01:10:35,300
Du kan bare stikke den inn i en objekt i Javascript.

1062
01:10:35,300 --> 01:10:39,090
Som du sikkert vet, er itera en av de kjedelige oppgavene.

1063
01:10:39,090 --> 01:10:43,810
Du bare gjør det over en igjen. Du trenger å snakke med hver gjenstand i bilen,

1064
01:10:43,810 --> 01:10:47,340
eller du trenger å gå gjennom hvert eneste element i en liste eller noe sånt.

1065
01:10:47,340 --> 01:10:51,770
Så Java har, i likhet med PHP, en foreach syntaks.

1066
01:10:51,770 --> 01:10:54,590
I dette tilfellet er det et for i loop.

1067
01:10:54,590 --> 01:10:57,300
Du ønsker å bruke dette bare på objekter.

1068
01:10:57,300 --> 01:11:01,030
Det er noen problemer som oppstår hvis du bruker dette på arrays.

1069
01:11:01,030 --> 01:11:03,750
Det er vanligvis en av de tingene, skjønt, er at svært nyttig,

1070
01:11:03,750 --> 01:11:06,590
fordi du eliminere mye av overhead

1071
01:11:06,590 --> 01:11:10,270
fordi du ikke trenger å trekke opp alt i objektet selv.

1072
01:11:10,270 --> 01:11:12,300
Du trenger ikke å huske alle de viktigste navnene.

1073
01:11:12,300 --> 01:11:18,270
Du bare liksom få dem tilbake i denne syntaksen.

1074
01:11:18,270 --> 01:11:21,500
I dette, med for, du bare ønsker å huske

1075
01:11:21,500 --> 01:11:27,180
at du får tilbake alle nøklene, i en svært lik måte til hasj tabellen.

1076
01:11:27,180 --> 01:11:30,880
Hvis du husker fra det, når du vil sette inn en streng du kan få noe ut

1077
01:11:30,880 --> 01:11:33,840
som vil ha en tilknyttet verdi med den.

1078
01:11:33,840 --> 01:11:36,360
Hva du kan gjøre med dette er at du kan si, all right,

1079
01:11:36,360 --> 01:11:42,120
Jeg satt i en bil, og jeg kalte det en Ferrari.

1080
01:11:42,120 --> 01:11:45,290
Så du kan sette i strengen Ferrari igjen senere, og du kan få det ut.

1081
01:11:45,290 --> 01:11:50,000
Og du kan gjøre det i en sløyfe, med for i loop.

1082
01:11:50,000 --> 01:11:53,320
Så bare mer om stedene. Nøkkelen ting fra dette må du huske

1083
01:11:53,320 --> 01:12:00,340
er at du kan bruke objektet struct som syntaks når du vil med disse,

1084
01:12:00,340 --> 01:12:04,590
unntatt hvis hva du kommer til å bruke som en streng er ikke et gyldig variabelnavn.

1085
01:12:04,590 --> 01:12:07,650
Så hvis du ser på det der, har vi nøkkelen med mellomrom.

1086
01:12:07,650 --> 01:12:12,500
Vel, hvis du skulle sette object.key, plass, med, mellomrom, mellomrom,

1087
01:12:12,500 --> 01:12:15,320
som bare ikke ville være fornuftig syntaktisk.

1088
01:12:15,320 --> 01:12:22,730
Slik at du bare kan gjøre det med denne typen brakett syntaks.

1089
01:12:22,730 --> 01:12:26,520
>> Dessuten er Java svært omfang-messig til PHP.

1090
01:12:26,520 --> 01:12:29,050
Du har to måter å møte omfang.

1091
01:12:29,050 --> 01:12:31,960
Du kan ikke ha VaR foran en variabel,

1092
01:12:31,960 --> 01:12:34,060
og det betyr bare dette er global.

1093
01:12:34,060 --> 01:12:37,050
Du kan se den fra hvor som helst. Selv om du skulle sette dette i en if setning,

1094
01:12:37,050 --> 01:12:42,430
noe annet sted i koden etter det punktet du kunne se at variabelen.

1095
01:12:42,430 --> 01:12:46,730
En annen ting, skjønt, er med var, det er begrenset til hva funksjonen du er i.

1096
01:12:46,730 --> 01:12:48,870
Hvis du ikke er i en funksjon, vel, det er global.

1097
01:12:48,870 --> 01:12:53,900
Men hvis du er i en funksjon det er bare synlig innenfor den funksjonen.

1098
01:12:53,900 --> 01:12:56,420
Jeg har ikke et eksempel, men, ja. Det er en av de tingene der

1099
01:12:56,420 --> 01:12:59,900
du kan styre hva variablene du ønsker å være global,

1100
01:12:59,900 --> 01:13:03,810
hva variablene du ønsker å være lokale, men du trenger å være forsiktig med dette,

1101
01:13:03,810 --> 01:13:06,890
fordi du ikke har den type finkornet kontroll du gjør i C,

1102
01:13:06,890 --> 01:13:15,820
der hvis noe er deklarert i en for loop, det kommer til å bo i det for loop.

1103
01:13:15,820 --> 01:13:18,790
Saken vi faktisk bryr seg om å bruke Javascript for er manipulere websider, ikke sant?

1104
01:13:18,790 --> 01:13:21,800
Jeg mener, det er derfor vi gjør dette.

1105
01:13:21,800 --> 01:13:23,840
>> For å gjøre det, vi bruker noe som kalles DOM.

1106
01:13:23,840 --> 01:13:25,850
The Document Object Model.

1107
01:13:25,850 --> 01:13:29,430
Innerst inne, hva den gjør er det tar all din HTML

1108
01:13:29,430 --> 01:13:34,110
og modeller det ut i en haug med gjenstander som er nestet i hverandre.

1109
01:13:34,110 --> 01:13:37,080
Du starter med noe sånt som dette.

1110
01:13:37,080 --> 01:13:44,770
Du har, på høyre for meg, en haug med kode der ute som er liksom -

1111
01:13:44,770 --> 01:13:46,640
Du skulle tro at ville være svært vanskelig å manipulere,

1112
01:13:46,640 --> 01:13:48,700
fordi du ville bli parsing gjennom en haug med tekst

1113
01:13:48,700 --> 01:13:52,080
og måtte sette fra hverandre ting. Og hva om det ikke var riktig formatert?

1114
01:13:52,080 --> 01:13:54,880
Dårlige ting ville skje.

1115
01:13:54,880 --> 01:13:58,140
Så Java tar seg av dette for deg, og du får en fin datastruktur,

1116
01:13:58,140 --> 01:14:01,390
som en på min venstre side, der du bare har et dokument,

1117
01:14:01,390 --> 01:14:03,530
og inne at du har noe som kalles HTML,

1118
01:14:03,530 --> 01:14:05,600
og inne at du har et hode og en kropp,

1119
01:14:05,600 --> 01:14:08,420
og inne i det hodet du har en tittel, etcetera, etcetera, etcetera.

1120
01:14:08,420 --> 01:14:11,810
Dette forenkler manipulere en nettside, slik at det er bare,

1121
01:14:11,810 --> 01:14:14,190
oh, jeg vil bare snakke til dette objektet.

1122
01:14:14,190 --> 01:14:21,340
Sortering av en svært lik måte som du ville snakke med et annet objekt du har laget selv.

1123
01:14:21,340 --> 01:14:25,980
Som jeg sa, er alt DOM i dokumentobjekt.

1124
01:14:25,980 --> 01:14:29,290
Enten det er bare ett sted, og så kan du gå i det å finne ting,

1125
01:14:29,290 --> 01:14:33,880
og du kan gjøre det - dette er den gamle stil å gjøre det, der oppe,

1126
01:14:33,880 --> 01:14:38,130
hvor du gjør document.getElementById, og deretter navnet,

1127
01:14:38,130 --> 01:14:42,420
og som du kan sikkert fortelle, blir dette veldig uhåndterlig etter en stund.

1128
01:14:42,420 --> 01:14:44,480
Så har du sannsynligvis ikke vil gjøre det. Det er derfor vi har

1129
01:14:44,480 --> 01:14:48,760
neste ting vi kommer til å snakke om etter dette.

1130
01:14:48,760 --> 01:14:52,510
Det viktigste her er at, ok, du har alle disse elementene, ikke sant?

1131
01:14:52,510 --> 01:14:56,400
Så kanskje jeg kan endre fargen på noe når siden lastes.

1132
01:14:56,400 --> 01:14:58,380
Så hva? Hva om min bruker klikker noe?

1133
01:14:58,380 --> 01:15:00,540
Jeg vil at det skal gjøre noe interessant når de klikker noe.

1134
01:15:00,540 --> 01:15:02,600
Det er derfor vi har arrangementer.

1135
01:15:02,600 --> 01:15:05,330
Du kan, i utgangspunktet, finner noe element i DOM,

1136
01:15:05,330 --> 01:15:08,560
og deretter si hei. Når dette laster eller noen klikker det,

1137
01:15:08,560 --> 01:15:11,410
eller når de musen over det, gjør noe med det.

1138
01:15:11,410 --> 01:15:15,330
Og hva du har er, du har funksjoner som håndterer dette for deg.

1139
01:15:15,330 --> 01:15:17,980
Disse funksjonene er hendelsesbehandlinger.

1140
01:15:17,980 --> 01:15:20,440
Hva they're - det er bare en fancy måte å si,

1141
01:15:20,440 --> 01:15:23,500
Denne funksjonen er kun utført når denne hendelsen skjer.

1142
01:15:23,500 --> 01:15:28,070
Så det håndterer hendelsen som inntreffer.

1143
01:15:28,070 --> 01:15:30,810
Dette er hvordan du ville legge ut en hendelseshåndterer.

1144
01:15:30,810 --> 01:15:34,750
Jeg har litt knapp, og når du klikker på den, eksploderer det.

1145
01:15:34,750 --> 01:15:40,560
Så ikke klikk på knappen.

1146
01:15:40,560 --> 01:15:42,910
Dette er en måte å tilnærme seg det, ikke sant?

1147
01:15:42,910 --> 01:15:46,430
Du har en knapp tag, og på klikk du har en streng som sier:

1148
01:15:46,430 --> 01:15:50,460
oh, forresten, jeg gjør dette eksploderende tingen for meg.

1149
01:15:50,460 --> 01:15:53,990
Ellers er det akkurat som en vanlig knapp du nettopp laget.

1150
01:15:53,990 --> 01:15:56,550
Du kan også gjøre dette på en annen måte,

1151
01:15:56,550 --> 01:16:02,770
ved å gripe tak i DOM-element, men sparer vi at etter at vi snakker om jQuery.

1152
01:16:02,770 --> 01:16:07,580
>> JQuery: Det er et bibliotek som er kryss-nettleser.

1153
01:16:07,580 --> 01:16:09,580
Du kan bruke det i stort sett alt.

1154
01:16:09,580 --> 01:16:12,090
Og det bare gir deg en rekke verktøy for å arbeide med.

1155
01:16:12,090 --> 01:16:15,850
Fordi Javascript, mens kraftig, har ikke alle de verktøyene du trenger

1156
01:16:15,850 --> 01:16:20,550
ut av boksen for å virkelig takle en web app du kanskje ønsker å gjøre.

1157
01:16:20,550 --> 01:16:24,650
Så det forenkler en del ting, gir deg en rekke funksjoner

1158
01:16:24,650 --> 01:16:28,760
ut av boksen som du normalt ville ha til å skrive selv, om og om og om igjen.

1159
01:16:28,760 --> 01:16:31,600
Og bare gjør ting veldig enkelt.

1160
01:16:31,600 --> 01:16:35,780
Du har også velgere, som lar deg ta ut alle de elementene

1161
01:16:35,780 --> 01:16:42,800
fra din DOM mye mer rett og slett, i stedet for å måtte bruke disse svært lange funksjonskall.

1162
01:16:42,800 --> 01:16:46,630
Mer om disse velgere. Du har, opp der du har, la oss si

1163
01:16:46,630 --> 01:16:49,800
Jeg ønsker å få et element med ID "rock".

1164
01:16:49,800 --> 01:16:56,450
Vel, i jQuery, det er bare $ og deretter en streng som har en halvkilo, og deretter "rock".

1165
01:16:56,450 --> 01:17:01,960
Det er veldig enkelt og mye raskere enn den tradisjonelle Java måte å takle dette problemet.

1166
01:17:01,960 --> 01:17:06,120
Og du har lignende ting for klasser og elementtyper.

1167
01:17:06,120 --> 01:17:08,140
jQuery er - en av de kule funksjonene er at du kan liksom komprimere

1168
01:17:08,140 --> 01:17:14,350
ned dine spørsmål om din DOM veldig, veldig fort.

1169
01:17:14,350 --> 01:17:18,980
Nå er vi tilbake til hendelseshåndtering, og dette er hvordan du ville håndtere en hendelse i jQuery.

1170
01:17:18,980 --> 01:17:23,090
Så hva skal vi her er vi sier, all right. Jeg har et script tag, ikke sant?

1171
01:17:23,090 --> 01:17:25,400
Så jeg har denne inline Javascript.

1172
01:17:25,400 --> 01:17:27,750
Hva vi skal gjøre er at vi kommer til å si, all right.

1173
01:17:27,750 --> 01:17:30,860
Når dokumentet er ferdig, noe som betyr at dokumentet er blitt lastet,

1174
01:17:30,860 --> 01:17:34,660
vi kommer til å gå inn til den funksjonen, og vi kommer til å si, all right,

1175
01:17:34,660 --> 01:17:37,060
denne funksjonen er faktisk å gjøre noe annet.

1176
01:17:37,060 --> 01:17:42,320
Det har i utgangspunktet si, ok, får meg elementet med ID "myid."

1177
01:17:42,320 --> 01:17:47,960
Og så gir dette en funksjon handler som utføres når du klikker på det.

1178
01:17:47,960 --> 01:17:49,820
I utgangspunktet hva dette betyr er, det sier alt rett.

1179
01:17:49,820 --> 01:17:52,630
Den siden er lastet, så jeg kommer til i, finner dette elementet,

1180
01:17:52,630 --> 01:17:56,420
gi det denne hendelsen handler, og det i utgangspunktet setter opp siden din for deg.

1181
01:17:56,420 --> 01:18:00,520
Og dette er hvordan du ønsker å tenke på hendelsen håndtering.

1182
01:18:00,520 --> 01:18:06,310
Du bare ønsker å tenke på, all right, når noe skjer, hva ønsker jeg å skje?

1183
01:18:06,310 --> 01:18:10,520
Du ønsker ikke å tenke på, ok, jeg trenger å sørge for at denne tingen snakker til denne tingen,

1184
01:18:10,520 --> 01:18:14,660
denne tingen blah blah blah, fordi du bare ønsker å snakke ting i form av arrangementer.

1185
01:18:14,660 --> 01:18:17,650
Når dette skjer, så skjer dette. Når dette skjer, så skjer det.

1186
01:18:17,650 --> 01:18:20,240
Og hvis ting utløse andre ting, det er flott.

1187
01:18:20,240 --> 01:18:22,150
Men du ikke ønsker å prøve og gjøre komplisert kode

1188
01:18:22,150 --> 01:18:24,130
hvor du utløser flere ting samtidig,

1189
01:18:24,130 --> 01:18:28,860
fordi du bare kommer til å gi deg hodepine.

1190
01:18:28,860 --> 01:18:32,340
>> Greit. Nå kan vi få vår side til å håndtere hendelser,

1191
01:18:32,340 --> 01:18:35,640
men la oss si at min bruker klikker på en knapp.

1192
01:18:35,640 --> 01:18:38,040
Hva om jeg ønsker å sende denne anmodningen tilbake til serveren,

1193
01:18:38,040 --> 01:18:41,100
men jeg ønsker ikke å laste siden på nytt, fordi å måtte laste en ny side

1194
01:18:41,100 --> 01:18:44,390
hver eneste gang blir slags kjedelig, og hvorfor trenger jeg

1195
01:18:44,390 --> 01:18:47,430
å trekke ned header igjen, og bunnteksten på nytt,

1196
01:18:47,430 --> 01:18:49,670
og alle elementer på siden igjen

1197
01:18:49,670 --> 01:18:53,180
bare for å oppdatere hilsenen eller tiden?

1198
01:18:53,180 --> 01:18:55,290
Så det er derfor vi har noe som Ajax.

1199
01:18:55,290 --> 01:18:59,150
Hva vi kan gjøre her med Ajax er at vi kan si, all right,

1200
01:18:59,150 --> 01:19:01,290
Jeg ønsker å sende noen data til serveren,

1201
01:19:01,290 --> 01:19:04,010
og jeg ønsker å få et svar tilbake så jeg kan oppdatere siden min,

1202
01:19:04,010 --> 01:19:12,120
eller kanskje bare gjøre noen algoritmisk beregning som ikke nødvendigvis viser noe for brukeren.

1203
01:19:12,120 --> 01:19:15,500
Hva trenger du å gjøre dette? Vel, trenger du en URL du trenger å snakke med.

1204
01:19:15,500 --> 01:19:18,650
Din server kan ikke bare magisk lytte inn fra ingensteds.

1205
01:19:18,650 --> 01:19:21,960
Du må ha et bestemt sted du sender disse dataene til.

1206
01:19:21,960 --> 01:19:26,240
Og du trenger også noen data å sende, eller kanskje det er en dataless spørring.

1207
01:19:26,240 --> 01:19:31,380
Du ønsker bare å pinge tilbake til serveren og si hei, jeg er i live, eller noe sånt.

1208
01:19:31,380 --> 01:19:35,150
Og så du vil ha en funksjon som i utgangspunktet håndterer med suksess.

1209
01:19:35,150 --> 01:19:38,250
La oss si at du får tilbake litt informasjon fra serveren,

1210
01:19:38,250 --> 01:19:42,960
og du ønsker å endre brukerens tittelen på deres side.

1211
01:19:42,960 --> 01:19:44,930
Så du ville få informasjonen tilbake,

1212
01:19:44,930 --> 01:19:48,860
og du ville presse som til skjermen.

1213
01:19:48,860 --> 01:19:51,170
Hva som skjer er, når siden er klar,

1214
01:19:51,170 --> 01:19:56,500
du opprette en på klikk-funksjon for denne knappen som heter Greeter.

1215
01:19:56,500 --> 01:19:58,810
Hva dette så gjør er, når den knappen er trykket,

1216
01:19:58,810 --> 01:20:03,700
du snakke med greetings.php, du gjør en POST-forespørsel,

1217
01:20:03,700 --> 01:20:07,290
og du sier, hei, få meg noe fra din side.

1218
01:20:07,290 --> 01:20:09,890
Vi trenger egentlig ikke å beskrive det, men greetings.php,

1219
01:20:09,890 --> 01:20:12,480
la oss bare si, gir tilbake "hello world."

1220
01:20:12,480 --> 01:20:15,650
Så vi får tilbake denne "hello world", og på suksess av dette,

1221
01:20:15,650 --> 01:20:20,730
forutsatt at ingenting går galt, så vi bare gå til dette målet sted

1222
01:20:20,730 --> 01:20:25,720
at vi spesifisert og vi bare holde responsen der.

1223
01:20:25,720 --> 01:20:31,560
Og dette er en svært enkel måte å sette opp en Ajax spørring.

1224
01:20:31,560 --> 01:20:34,340
>> Svært raskt, Rob slags nevnt dette allerede,

1225
01:20:34,340 --> 01:20:37,170
ting kan gå galt, kan dårlige ting skje,

1226
01:20:37,170 --> 01:20:42,660
slik at du ønsker å bli kjent med disse HTTP svarkoder.

1227
01:20:42,660 --> 01:20:46,030
Hva disse er er bare, som, 200, alt gikk greit.

1228
01:20:46,030 --> 01:20:48,670
Noe annet, som skjedde dårlige ting.

1229
01:20:48,670 --> 01:20:50,790
Det er som regel det ting du ønsker å huske.

1230
01:20:50,790 --> 01:20:53,440
Men det er hyggelig å vite alle disse.

1231
01:20:53,440 --> 01:20:55,970
Og til slutt, når vi har gått gjennom alt dette,

1232
01:20:55,970 --> 01:20:58,680
vi trenger å snakke veldig raskt om utforming,

1233
01:20:58,680 --> 01:21:00,620
og så kan vi fortelle dere alle forlate.

1234
01:21:00,620 --> 01:21:03,410
Design. Ting du ønsker å huske.

1235
01:21:03,410 --> 01:21:06,950
Spør deg selv disse spørsmålene: Hvem skal bruke dette?

1236
01:21:06,950 --> 01:21:09,580
Hva vil de bruke den til? Hva gjør brukerne mine bryr seg om?

1237
01:21:09,580 --> 01:21:11,750
Hva er det de ikke bryr seg om?

1238
01:21:11,750 --> 01:21:14,500
Du ønsker ikke å lage en app, og la det bare vokse

1239
01:21:14,500 --> 01:21:18,270
og bli denne gigantiske, altoppslukende ting som du selv ikke kan fullføre.

1240
01:21:18,270 --> 01:21:23,900
Du ønsker å ha diskrete mål og planer og ting du ønsker å ta opp.

1241
01:21:23,900 --> 01:21:29,000
Gjør det enkelt. Alt dette står i utgangspunktet

1242
01:21:29,000 --> 01:21:34,950
gjør det enkelt for brukeren å bruke det, ikke gjør det til en gigantisk blob av tekst som dette lysbildet er, faktisk.

1243
01:21:34,950 --> 01:21:38,020
Du vil bare at det skal være noe der det er veldig lett for noen å gå inn

1244
01:21:38,020 --> 01:21:40,800
og gjøre hva de vil gjøre.

1245
01:21:40,800 --> 01:21:42,920
Du ønsker ikke at de skal ha for å navigere 5 sider

1246
01:21:42,920 --> 01:21:45,460
å komme til din viktigste funksjon av nettstedet ditt.

1247
01:21:45,460 --> 01:21:49,290
Hvis Google hadde fem sider før kan du også søke noe,

1248
01:21:49,290 --> 01:21:53,080
ingen ville bruke den.

1249
01:21:53,080 --> 01:21:55,890
Og til slutt, papir prototype, fokusgruppe.

1250
01:21:55,890 --> 01:21:59,220
Ha god design og testing praksis.

1251
01:21:59,220 --> 01:22:00,730
Bare fordi du synes det fungerer for deg,

1252
01:22:00,730 --> 01:22:04,860
betyr ikke noen andre mener det fungerer.

1253
01:22:04,860 --> 01:22:14,490
Men ja, det er det.

1254
01:22:14,490 --> 01:22:17,490
[CS50.TV]