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

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

3
00:00:04,620 --> 00:00:07,660
[Det här är CS50.] [CS50.TV]

4
00:00:07,660 --> 00:00:11,610
[Lucas Freitas] Välkommen alla. Detta är översyn för frågesport 1.

5
00:00:11,610 --> 00:00:15,040
Precis som en ansvarsfriskrivning, detta är - jag menar, vi kommer att försöka täcka

6
00:00:15,040 --> 00:00:17,770
så mycket material som möjligt, men det betyder inte att

7
00:00:17,770 --> 00:00:20,780
vi kommer att täcka alla de saker som kan vara i frågesport 1.

8
00:00:20,780 --> 00:00:25,270
Så se till att du även ta en titt på föreläsning, sektioner, allt du kan.

9
00:00:25,270 --> 00:00:28,240
Quiz 1 kommer att vara på onsdag, nästa onsdag.

10
00:00:28,240 --> 00:00:33,800
Så se till att studera. Det kommer att bli, ganska mycket, som den första quiz

11
00:00:33,800 --> 00:00:36,390
om dess format, men det är förmodligen kommer att bli mycket svårare.

12
00:00:36,390 --> 00:00:39,600
Åtminstone, förra året när jag tog 50, jag tyckte det var mycket svårare.

13
00:00:39,600 --> 00:00:42,410
Så studera en hel del.

14
00:00:42,410 --> 00:00:45,190
>> Jag kommer att täcka datastrukturer och Huffman kodning.

15
00:00:45,190 --> 00:00:47,910
Detta är något som många människor tycker är komplext,

16
00:00:47,910 --> 00:00:51,930
men jag ska försöka göra det så enkelt som möjligt.

17
00:00:51,930 --> 00:00:56,330
Först och främst, vad vi vill att ni ska veta att quiz 1 är att

18
00:00:56,330 --> 00:01:00,970
förstå de begreppsliga beskrivningar av var och en av de datastrukturer som jag kommer att presentera.

19
00:01:00,970 --> 00:01:03,960
Det innebär att du inte behöver faktiskt

20
00:01:03,960 --> 00:01:07,020
implementera en hashtabell i din quiz 1.

21
00:01:07,020 --> 00:01:10,250
Vi vill inte att du ska genomföra en hel hashtabell, kanske vi ska försöka

22
00:01:10,250 --> 00:01:13,090
att få dig att implementera vissa funktioner,

23
00:01:13,090 --> 00:01:16,940
de vanligaste operationer, men vi kommer inte att göra dig implementera allt.

24
00:01:16,940 --> 00:01:21,010
Så det är viktigt att du förstår konceptet bakom varje datastruktur

25
00:01:21,010 --> 00:01:23,510
och även att du har möjlighet att koda i C,

26
00:01:23,510 --> 00:01:27,880
bara de vanligaste operationer som de har för varje datastruktur.

27
00:01:27,880 --> 00:01:30,090
Och även kunna granska pekare och structs,

28
00:01:30,090 --> 00:01:33,470
eftersom de verkar mycket i dessa datastrukturer.

29
00:01:33,470 --> 00:01:37,380
>> Först länkade listor. Länkade listor är faktiskt mycket lik matriser,

30
00:01:37,380 --> 00:01:39,930
men skillnaden mellan en länkad lista och en matris,

31
00:01:39,930 --> 00:01:45,160
Först av allt, är att en länkad lista har en mycket flexibel storlek,

32
00:01:45,160 --> 00:01:50,060
medan i matriser måste du antingen välja en mycket stor storlek för matrisen,

33
00:01:50,060 --> 00:01:53,710
så vet du att du kommer att kunna lagra alla dina data i matrisen,

34
00:01:53,710 --> 00:01:59,370
eller du måste använda malloc att ha en flexibel längd på array.

35
00:01:59,370 --> 00:02:03,680
I länkade listor är det väldigt lätt att bara få fler element,

36
00:02:03,680 --> 00:02:07,210
sätta fler element i den länkade listan eller ta bort element.

37
00:02:07,210 --> 00:02:09,370
Och faktiskt, om du inte vill att den länkade listan som ska sorteras,

38
00:02:09,370 --> 00:02:13,950
Du kan söka efter och ta bort element i konstant tid,

39
00:02:13,950 --> 00:02:16,800
så O (1) tid, så det är mycket praktiskt.

40
00:02:16,800 --> 00:02:20,660
Du måste bara vara noga med att alltid komma ihåg att malloc och free noderna,

41
00:02:20,660 --> 00:02:25,510
bara för att om du inte gör det, har du minnesläckor.

42
00:02:25,510 --> 00:02:31,480
Så länkade listor - definitionen av en nod är precis vad vi har där.

43
00:02:31,480 --> 00:02:35,110
Jag lägger int n, men du kan lagra alla data som du vill.

44
00:02:35,110 --> 00:02:37,280
Så om du vill lagra en sträng, det är bra.

45
00:02:37,280 --> 00:02:41,690
Om du vill spara en struct, det är bra, en dubbel, vad du vill.

46
00:02:41,690 --> 00:02:44,630
Jag bara sätta int n för exemplen här.

47
00:02:44,630 --> 00:02:46,800
Och du har en pekare till nästa nod.

48
00:02:46,800 --> 00:02:51,940
Så i princip, har en länkad lista en del data, och sedan pekar till nästa nod.

49
00:02:51,940 --> 00:02:56,710
Om det är det sista elementet i den länkade listan, det kommer att peka på NULL.

50
00:02:56,710 --> 00:02:59,060
Så detta är ett exempel på en länkad lista.

51
00:02:59,250 --> 00:03:05,960
>> Okej, så nu ska vi se vad vi ska göra om jag vill sätta in ett element i en länkad lista.

52
00:03:05,960 --> 00:03:08,810
Först kommer en funktion insatsen vara av typen void

53
00:03:08,810 --> 00:03:11,350
eftersom jag inte vill återvända någonting.

54
00:03:11,350 --> 00:03:14,200
Och jag ska ta en int som argument,

55
00:03:14,200 --> 00:03:17,090
för jag vill veta vad jag vill infoga.

56
00:03:17,090 --> 00:03:21,840
Så vad är det första jag ska göra? Tja, ska jag malloc på newnode,

57
00:03:21,840 --> 00:03:24,240
så det är den första raden.

58
00:03:24,240 --> 00:03:27,580
Jag bara skapa en ny nod för att sätta i en länkad lista.

59
00:03:27,580 --> 00:03:32,360
Så vad kan jag göra? Tja, vi vet att i våra implementeringar av länkade listor

60
00:03:32,360 --> 00:03:38,180
i klassen, alltid lägger vi huvudet som en global variabel.

61
00:03:38,180 --> 00:03:41,800
Så vad vi kan göra är att ändra huvudet.

62
00:03:41,800 --> 00:03:44,300
Jag kan göra detta nya noden bli ny chef,

63
00:03:44,300 --> 00:03:46,670
och det kommer att peka på den tidigare chefen.

64
00:03:46,670 --> 00:03:50,390
Hur kan vi göra det? Det första jag måste göra

65
00:03:50,390 --> 00:03:54,770
är att ändra "n" i den nya noden till värde,

66
00:03:54,770 --> 00:03:57,530
som skickas till funktionen.

67
00:03:57,530 --> 00:04:01,050
Sedan newnode händer nu kommer att vara chef.

68
00:04:01,050 --> 00:04:05,800
Huvudet kommer att newnode. Så det är ganska enkelt.

69
00:04:05,800 --> 00:04:10,090
För att ta bort en nod, kan vi göra det som -

70
00:04:10,090 --> 00:04:14,790
Ett sätt vi kan göra det är att säga,

71
00:04:14,790 --> 00:04:18,160
okej, om jag ville ta bort, till exempel, 3,

72
00:04:18,160 --> 00:04:24,850
vad jag skulle kunna göra är att bara peka den föregående noden

73
00:04:24,850 --> 00:04:27,580
till nästa nod av 3.

74
00:04:27,580 --> 00:04:29,400
Så jag skulle bara göra något sådant.

75
00:04:29,400 --> 00:04:33,400
Men vad är problemet med att göra det?

76
00:04:33,400 --> 00:04:37,400
Jag har en minnesläcka, så jag har inte tillgång till antalet 3 längre.

77
00:04:37,400 --> 00:04:42,480
Problemet med det är att jag inte kommer att kunna frigöra den noden.

78
00:04:42,480 --> 00:04:45,360
Jag kommer att ha minnesläcka och (ohörbart) kommer att hata mig.

79
00:04:45,360 --> 00:04:49,370
Så istället för att göra det, skulle jag nog ha en temporär pekare.

80
00:04:49,370 --> 00:04:53,210
Så jag satte temp. Det går att peka på den nod som jag vill ta bort.

81
00:04:53,210 --> 00:04:58,170
Och då kan jag flytta de tidigare noderna att peka på nästa nod

82
00:04:58,170 --> 00:05:00,390
av den nod som jag vill ta bort.

83
00:05:00,390 --> 00:05:02,730
Och slutligen, kan jag befria pekaren.

84
00:05:02,730 --> 00:05:07,480
Måste jag befria pekare som jag skapade där?

85
00:05:07,480 --> 00:05:09,560
Jag behöver inte, bara för att -

86
00:05:09,560 --> 00:05:13,430
Skillnaden är att den här noden skapades med malloc,

87
00:05:13,430 --> 00:05:17,280
så det är i högen, medan detta bara förklaras som en NULL brytare i stacken.

88
00:05:17,280 --> 00:05:20,000
Så jag behöver inte befria den.

89
00:05:20,000 --> 00:05:22,030
>> Okej. Så nu ska vi prata om stackar.

90
00:05:22,030 --> 00:05:24,680
Stacks är ganska enkelt.

91
00:05:24,680 --> 00:05:29,540
Vi gjorde stackar och köer i klassen bara med hjälp av matriser,

92
00:05:29,540 --> 00:05:32,820
men du bör känna - bara vara medvetna om

93
00:05:32,820 --> 00:05:40,740
att du också kan göra högar i köer med hjälp av länkade listor också.

94
00:05:40,740 --> 00:05:44,460
Så om du har en array, skulle det vara en bunt?

95
00:05:44,460 --> 00:05:46,810
En stack första måste ha en storlek.

96
00:05:46,810 --> 00:05:49,950
Du måste lagra vad är storleken på stapeln som du har just nu.

97
00:05:49,950 --> 00:05:52,980
Och även du skulle ha en matris, i detta fall av siffror,

98
00:05:52,980 --> 00:05:55,120
men om du vill, kan det vara en array

99
00:05:55,120 --> 00:06:00,380
strängar, en matris med struct, vad som helst som du vill lagra.

100
00:06:00,380 --> 00:06:03,240
Om stacken: Skillnaden mellan en stack och en länkad lista

101
00:06:03,240 --> 00:06:08,590
är att i bunten har du bara tillgång till det sista elementet som sattes i stacken.

102
00:06:08,590 --> 00:06:11,770
Det kallas sist in, först ut.

103
00:06:11,770 --> 00:06:15,090
Precis som du har en hög med brickor,

104
00:06:15,090 --> 00:06:17,670
om du lägger en bricka på toppen av stacken,

105
00:06:17,670 --> 00:06:22,670
du måste ta bort det facket först för att få tillgång till de andra facken.

106
00:06:22,670 --> 00:06:26,310
Det är samma sak med staplar.

107
00:06:26,310 --> 00:06:31,220
Så om jag vill, till exempel lägga till ett element till en skorsten, vad ska jag göra?

108
00:06:31,220 --> 00:06:34,070
Det kallas push, och det är ganska enkelt.

109
00:06:34,070 --> 00:06:37,130
Det första du behöver göra är att kontrollera om storleken på stacken

110
00:06:37,130 --> 00:06:40,150
inte är större än eller lika med kapaciteten för stapeln.

111
00:06:40,150 --> 00:06:45,810
För om du redan är på full kapacitet, kan du inte lägga till något annat.

112
00:06:45,810 --> 00:06:51,140
Och sedan, om inte, är det bara att lägga till element till stacken.

113
00:06:51,140 --> 00:06:54,530
Och slutligen, öka storleken. Så det är ganska enkelt.

114
00:06:54,530 --> 00:06:57,140
Så jag bara lägga till numret 2.

115
00:06:57,140 --> 00:07:00,350
Och om jag vill dyka, vilket betyder att jag vill ta bort

116
00:07:00,350 --> 00:07:03,870
det sista elementet som tillsattes, och returnera värdet av elementet,

117
00:07:03,870 --> 00:07:09,180
det första jag måste kontrollera är att stacken inte är tom.

118
00:07:09,180 --> 00:07:11,510
För om den är tom, kan jag inte tillbaka något.

119
00:07:11,510 --> 00:07:14,820
I så fall, jag åter -1.

120
00:07:14,820 --> 00:07:18,960
Annars kommer jag att dekrementera storleken på spec,

121
00:07:18,960 --> 00:07:22,510
och returnummer (s.size).

122
00:07:22,510 --> 00:07:27,230
Varför fick jag dekrementera storlek och sedan återvända s.size?

123
00:07:27,230 --> 00:07:30,930
Det är för att, i detta fall, spec har storlek 4,

124
00:07:30,930 --> 00:07:33,810
och jag vill returnera det fjärde elementet, eller hur?

125
00:07:33,810 --> 00:07:36,030
Men vad är index för det fjärde elementet? Tre.

126
00:07:36,030 --> 00:07:44,510
Eftersom jag vet storlek - kommer att vara 3, kan jag bara gå tillbaka s.numbers (s.size)

127
00:07:44,510 --> 00:07:48,410
eftersom det är 3. Så det är bara indexet.

128
00:07:48,410 --> 00:07:50,380
>> Nu köer. Köer är ungefär samma sak.

129
00:07:50,380 --> 00:07:54,950
Den enda skillnaden är att istället för att ha sist in, först ut,

130
00:07:54,950 --> 00:07:57,480
du först in, först ut.

131
00:07:57,480 --> 00:07:59,460
Förmodligen om du väntar på att gå på en konsert,

132
00:07:59,460 --> 00:08:04,260
du inte skulle bli glad om du hade en bunt istället för en kö.

133
00:08:04,260 --> 00:08:07,730
Att vara den sista personen att komma skulle vara den första personen att komma in i konserten.

134
00:08:07,730 --> 00:08:09,760
Du har förmodligen inte skulle bli lycklig.

135
00:08:09,760 --> 00:08:15,020
I kön, är den första personen att komma in också den första personen att komma ut.

136
00:08:15,020 --> 00:08:18,720
Så i definitionen av en kö, förutom att ha storleken i matrisen,

137
00:08:18,720 --> 00:08:23,360
du måste också ha i huvudet, vilket är det index till chefen för stapeln.

138
00:08:23,360 --> 00:08:29,000
Så det första elementet just nu.

139
00:08:29,000 --> 00:08:32,710
Placera i kö är det samma sak som push för stackar.

140
00:08:32,710 --> 00:08:34,980
Om du var väldigt naiv, skulle du bara säga,

141
00:08:34,980 --> 00:08:39,289
Tja, jag kan bara göra exakt samma sak som jag gjorde för push.

142
00:08:39,289 --> 00:08:44,030
Jag kan bara kolla om det inte är bortom kapaciteten.

143
00:08:44,030 --> 00:08:48,760
Om det är, återvänder jag falskt, annars kan jag bara exportera det nya värdet

144
00:08:48,760 --> 00:08:50,630
och sedan öka storleken.

145
00:08:50,630 --> 00:08:52,750
Men varför är det fel?

146
00:08:52,750 --> 00:08:55,010
Låt oss se det här exemplet.

147
00:08:55,010 --> 00:08:57,020
Jag försöker att köa en massa saker,

148
00:08:57,020 --> 00:08:58,390
och sedan ska jag avköa och köa.

149
00:08:58,390 --> 00:09:00,550
Det finns en hel del kommandon, men det är mycket enkelt.

150
00:09:00,550 --> 00:09:04,790
Jag kommer att köa 5, så tillsätt 5, och sedan 7,

151
00:09:04,790 --> 00:09:09,310
1, 4, 6, och då vill jag avköa något,

152
00:09:09,310 --> 00:09:12,000
vilket betyder att jag kommer att ta bort det första elementet.

153
00:09:12,000 --> 00:09:14,640
Så jag kommer att ta bort nummer 3, eller hur?

154
00:09:14,640 --> 00:09:17,320
Det första elementet. Okej.

155
00:09:17,320 --> 00:09:21,450
Nu om jag försöker köa något annat, är det som kommer att hända?

156
00:09:21,450 --> 00:09:24,290
Enligt mina genomförande,

157
00:09:24,290 --> 00:09:31,040
Jag hade tänkt att sätta nästa nummer i index q.size.

158
00:09:31,040 --> 00:09:35,140
I detta fall är storleken 8,

159
00:09:35,140 --> 00:09:38,640
så indexet 8 kommer att vara här i den sista positionen.

160
00:09:38,640 --> 00:09:43,900
Om jag försöker köa 1 här, skulle jag kunna skriva över den senaste positionen

161
00:09:43,900 --> 00:09:45,870
till antalet 1, vilket är helt fel.

162
00:09:45,870 --> 00:09:49,870
Vad jag vill göra är att linda runt och gå till den första positionen.

163
00:09:49,870 --> 00:09:52,870
Kanske vill du bara säga, ja, jag måste bara kolla

164
00:09:52,870 --> 00:09:55,600
om jag faktiskt kan sätta något där.

165
00:09:55,600 --> 00:09:58,560
Om inte, jag bara säger, åh, den nya fulla kapacitet

166
00:09:58,560 --> 00:10:02,010
är faktiskt kapacitet - 1, och du kan inte sätta ett element där.

167
00:10:02,010 --> 00:10:06,150
Men vad är problemet? Problemet är att om jag avköa precis allt här

168
00:10:06,150 --> 00:10:08,240
och då jag försöker lägga till något annat, det skulle bara säga,

169
00:10:08,240 --> 00:10:11,210
bra, du var full kapacitet, vilket är 0.

170
00:10:11,210 --> 00:10:13,620
Så ditt kön är borta.

171
00:10:13,620 --> 00:10:16,990
Du måste linda runt, och ett sätt att linda runt

172
00:10:16,990 --> 00:10:22,040
att ni lärt på visionära och andra psets använde mod.

173
00:10:22,040 --> 00:10:29,090
Du kan prova hemma för att förstå varför du skulle göra q.size + q.head

174
00:10:29,090 --> 00:10:31,080
mod kapacitet, men om du kolla här,

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

176
00:10:34,760 --> 00:10:37,760
Så i det sista exemplet, q.size var 8

177
00:10:37,760 --> 00:10:47,590
och huvudet var 1, eftersom det var denna position här i matrisen.

178
00:10:47,590 --> 00:10:51,970
Så det blir 8 + 1, 9. Mod kapacitet 9 skulle vara 0.

179
00:10:51,970 --> 00:10:56,640
Det skulle gå till index 0. Vi kommer att vara i rätt position.

180
00:10:56,640 --> 00:10:59,750
Och sedan försöka kön hemma.

181
00:10:59,750 --> 00:11:04,950
Några viktiga saker: att försöka förstå skillnaden mellan en stack och en kö.

182
00:11:04,950 --> 00:11:11,620
Hemma, försöka få väl förtrogen med att genomföra enqueue, dequeue, tryck och pop.

183
00:11:11,620 --> 00:11:16,560
Och också förstå när du skulle använda var och en av dem.

184
00:11:16,560 --> 00:11:22,830
>> Så låt oss slappna av i 10 sekunder med ett gäng Pokemons.

185
00:11:22,830 --> 00:11:26,080
Och nu ska vi gå tillbaka till datastrukturer.

186
00:11:26,080 --> 00:11:29,770
Hash tabeller. Många var rädda för hashtabeller.

187
00:11:29,770 --> 00:11:33,650
i problem set 6, stavningskontroll.

188
00:11:33,650 --> 00:11:35,980
Hashtabeller och försöker, en hel del människor blir rädda för dem.

189
00:11:35,980 --> 00:11:38,540
De tror att de är så svåra att förstå. Yeah?

190
00:11:38,540 --> 00:11:41,490
[Rob Bowden] Problem set 5. >> Problem set 5, ja. Tack Rob.

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

192
00:11:43,370 --> 00:11:49,340
Problem set 5 var stavningskontroll, och du var tvungen att använda antingen en hashtabell eller ett försök.

193
00:11:49,340 --> 00:11:55,360
Många trodde att de var super svårt att förstå, men de är faktiskt ganska enkelt.

194
00:11:55,360 --> 00:12:01,290
Vad är en hashtabell, i grund och botten? En hash-tabell är en array av länkade listor.

195
00:12:01,290 --> 00:12:06,730
Den enda skillnaden mellan en matris och en hashtabell

196
00:12:06,730 --> 00:12:09,730
är att i hash bord du har något som kallas en hashfunktion.

197
00:12:09,730 --> 00:12:12,080
Vad är en hash-funktion?

198
00:12:12,080 --> 00:12:13,970
Jag vet inte om ni kan läsa här.

199
00:12:13,970 --> 00:12:16,090
Detta är ett exempel på en hash-tabell.

200
00:12:16,090 --> 00:12:19,220
Så du kan se att du har en array med 31 element.

201
00:12:19,220 --> 00:12:22,440
Och vad gör vi i en hashtabell är en hashfunktion

202
00:12:22,440 --> 00:12:26,660
som kommer att översätta en nyckel, varje int till ett index.

203
00:12:26,660 --> 00:12:31,740
Om, till exempel, om jag vill välja för B. Harrison,

204
00:12:31,740 --> 00:12:34,190
Jag skulle sätta B. Harrison i mina hashfunktioner,

205
00:12:34,190 --> 00:12:36,960
och hashfunktion skulle återvända 24.

206
00:12:36,960 --> 00:12:40,930
Så jag vet att jag vill lagra B. Harrison i 24.

207
00:12:40,930 --> 00:12:46,580
Så det är skillnaden mellan att bara ha en matris och en hash-tabell.

208
00:12:46,580 --> 00:12:48,740
I hash tabellen har du en funktion som kommer att berätta för dig

209
00:12:48,740 --> 00:12:54,740
var du vill lagra de data som du vill lagra.

210
00:12:54,740 --> 00:12:57,040
För hashfunktion, vill du leta efter en hashfunktion

211
00:12:57,040 --> 00:13:00,600
som är deterministisk och väl fördelad.

212
00:13:00,600 --> 00:13:07,810
Som ni kan se här, ser du att en hel del av de uppgifter som jag ville butik var faktiskt 19

213
00:13:07,810 --> 00:13:12,470
istället för att använda 31 och 30 och 29, som var alla fria.

214
00:13:12,470 --> 00:13:16,920
Så hash-funktion som jag använde var inte mycket väl fördelad.

215
00:13:16,920 --> 00:13:20,710
När vi säger väl fördelad, innebär det att vi vill ha,

216
00:13:20,710 --> 00:13:26,520
ungefär, åtminstone 1 eller 2 för var och en av de -

217
00:13:26,520 --> 00:13:32,190
liknande, en skillnad på 1 eller 2 för varje index i arrayer.

218
00:13:32,190 --> 00:13:43,950
Du vill ha, ungefär, samma antal element i varje länkad lista i arrayen.

219
00:13:43,950 --> 00:13:48,600
Och det är lätt att kontrollera om det är giltigt i hash-tabellen, se som hashtabeller.

220
00:13:48,600 --> 00:13:51,770
>> Då träd. Detta är ett träd.

221
00:13:51,770 --> 00:13:56,400
Träd i datavetenskap är upp och ner av någon anledning.

222
00:13:56,400 --> 00:14:00,150
Så här har du roten av trädet och sedan bladen.

223
00:14:00,150 --> 00:14:05,630
Du ska bara veta nomenklaturen för föräldrar och barn.

224
00:14:05,630 --> 00:14:12,880
Varje nod har sina barn, som är de noder som är lägre än den överordnade.

225
00:14:12,880 --> 00:14:19,660
Så, till exempel, 2 kommer att vara den överordnade för 3 och för det andra barnet just där,

226
00:14:19,660 --> 00:14:25,290
medan 3 kommer att vara den överordnade för 1 och de andra barnen som är där.

227
00:14:25,290 --> 00:14:29,990
Och 1 kommer att bli 3: s barn, och så vidare.

228
00:14:29,990 --> 00:14:34,610
Vi har något mycket mer intressant, som kallas ett binärt sökträd,

229
00:14:34,610 --> 00:14:39,040
där alla värden till höger om en nod

230
00:14:39,040 --> 00:14:41,660
kommer att vara till höger, just här - på höger,

231
00:14:41,660 --> 00:14:46,780
kommer att vara större än den del av roten.

232
00:14:46,780 --> 00:14:49,780
Så om jag har nummer 5 här, alla delar på rätt

233
00:14:49,780 --> 00:14:51,940
kommer att vara större än 5, och på vänster

234
00:14:51,940 --> 00:14:56,770
alla element kommer att vara mindre än fem.

235
00:14:56,770 --> 00:14:58,780
Varför är detta bra?

236
00:14:58,780 --> 00:15:01,660
Om jag vill kontrollera om antalet 7 är här, till exempel,

237
00:15:01,660 --> 00:15:05,960
Jag går bara till 5 först och jag kommer att se, är 7 större eller mindre än 5?

238
00:15:05,960 --> 00:15:09,540
Den är större, så jag vet att det kommer att vara på höger sida om trädet.

239
00:15:09,540 --> 00:15:13,980
Så jag har mycket mindre saker att titta på.

240
00:15:13,980 --> 00:15:19,520
Vid genomförandet av ett binärt sökträd, noden, jag bara kommer att behöva ha uppgifter,

241
00:15:19,520 --> 00:15:21,750
så int n, du kan också ha en sträng

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

243
00:15:23,630 --> 00:15:28,100
Du måste bara vara noga med att definiera vad som är större, det som är mindre.

244
00:15:28,100 --> 00:15:30,390
Så om du hade strängar, till exempel, kan du definiera

245
00:15:30,390 --> 00:15:34,690
att alla dessa saker till höger kommer att ha större längd,

246
00:15:34,690 --> 00:15:40,940
vänster kommer att ha lägre längder, så det är verkligen upp till dig.

247
00:15:40,940 --> 00:15:44,930
>> Hur kan jag genomföra hitta för BST?

248
00:15:44,930 --> 00:15:47,840
Det första vi måste göra är att kontrollera om roten är NULL.

249
00:15:47,840 --> 00:15:50,920
Om det är NULL, betyder det att saken är inte där

250
00:15:50,920 --> 00:15:53,330
eftersom du inte ens har ett träd, eller hur?

251
00:15:53,330 --> 00:15:55,790
Så jag returnera false.

252
00:15:55,790 --> 00:15:58,740
Annars kommer jag att kontrollera om antalet är större

253
00:15:58,740 --> 00:16:01,720
än värdet i roten.

254
00:16:01,720 --> 00:16:04,250
Jag ska försöka hitta elementet till höger

255
00:16:04,250 --> 00:16:08,590
av trädet.

256
00:16:08,590 --> 00:16:11,310
Du ser att jag använder rekursion här.

257
00:16:11,310 --> 00:16:14,150
Och sedan om det är mindre, jag kommer att titta till vänster.

258
00:16:14,150 --> 00:16:18,330
Och slutligen, annars, om det inte är mindre eller inte högre,

259
00:16:18,330 --> 00:16:20,660
Det innebär att det är själva värdet.

260
00:16:20,660 --> 00:16:23,010
Så jag återvänder bara sant.

261
00:16:23,010 --> 00:16:26,360
Du kan se här att jag använt, om, om, om.

262
00:16:26,360 --> 00:16:30,820
Och kom ihåg, i frågesport 0, uppstod ett problem som hade, om, om, om,

263
00:16:30,820 --> 00:16:32,780
och du skulle hitta den ineffektivitet,

264
00:16:32,780 --> 00:16:35,180
och ineffektivitet var som du använde vid.

265
00:16:35,180 --> 00:16:39,060
Du skulle ha använt om det, annars om, annars om, och annat.

266
00:16:39,060 --> 00:16:44,240
Så ska jag använda annars om och annars om och annan här?

267
00:16:44,240 --> 00:16:46,200
Finns det någon - ja?

268
00:16:46,200 --> 00:16:51,140
[Student tala, ohörbart]

269
00:16:51,140 --> 00:16:53,480
Det var perfekt. Så hon säger att det inte spelar någon roll,

270
00:16:53,480 --> 00:16:55,930
bara för att den ineffektivitet som vi hade innan

271
00:16:55,930 --> 00:16:59,550
var det därför, kanske om något villkor var uppfyllt,

272
00:16:59,550 --> 00:17:03,570
så du har utfört en åtgärd, men då du skulle kontrollera alla de andra villkoren.

273
00:17:03,570 --> 00:17:06,319
Men i detta fall, återvände det direkt, så det spelar ingen roll.

274
00:17:06,319 --> 00:17:09,220
Så du behöver inte använda annan om.

275
00:17:09,220 --> 00:17:11,740
>> Och slutligen, låt oss tala om försök,

276
00:17:11,740 --> 00:17:13,800
som är allas favorit.

277
00:17:13,800 --> 00:17:15,980
Ett försök är ett träd av matriser.

278
00:17:15,980 --> 00:17:20,369
Det är väldigt snabbt att slå upp värden, men den använder mycket minne.

279
00:17:20,369 --> 00:17:22,530
Och det är oftast att filtrera ord, så när du

280
00:17:22,530 --> 00:17:27,920
vill genomföra, till exempel, jag vet inte, som en telefonbok i telefonen

281
00:17:27,920 --> 00:17:30,440
och du vill kunna skriva B

282
00:17:30,440 --> 00:17:32,510
och bara ha namn på personer som har B.

283
00:17:32,510 --> 00:17:37,960
Det är väldigt lätt att genomföra det med hjälp av ett försök, till exempel.

284
00:17:37,960 --> 00:17:39,820
Hur definierar du en nod i ett försök?

285
00:17:39,820 --> 00:17:43,910
Du måste bara ha en bool som kommer att is_word.

286
00:17:43,910 --> 00:17:48,660
Det innebär att använda alla tecken innan den noden,

287
00:17:48,660 --> 00:17:51,920
man kunde bilda ett ord,

288
00:17:51,920 --> 00:17:57,230
och då har du en mängd pekare till noder.

289
00:17:57,230 --> 00:18:03,120
Kan du se att vi har en rad överordnade noder, så nod * array? Yeah?

290
00:18:03,120 --> 00:18:06,050
Så låt oss se hur det kommer att fungera. För stavningskontroll,

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

292
00:18:08,230 --> 00:18:12,150
eftersom vi har alla bokstäver plus apostrof.

293
00:18:12,150 --> 00:18:17,800
Innan här jag ska bara använda 2 eftersom jag vill kunna skriva på tavlan.

294
00:18:17,800 --> 00:18:20,230
Okej. Så detta är ett exempel på ett försök.

295
00:18:20,230 --> 00:18:25,600
Om jag bara definierar den första noden, jag har en matris med två element

296
00:18:25,600 --> 00:18:29,290
det finns 2 pekare till NULL, så jag bara sätta "a" och "b".

297
00:18:29,290 --> 00:18:32,430
Och jag kommer att ha en bool som säger is_word.

298
00:18:32,430 --> 00:18:34,420
Det kommer att vara falskt för det första,

299
00:18:34,420 --> 00:18:37,370
bara för att, innan att du inte har några tecken.

300
00:18:37,370 --> 00:18:40,900
Så ett tomt ord är inte ett ord. Så det är falskt.

301
00:18:40,900 --> 00:18:46,320
Om jag vill lägga till "a" till denna ordbok, vad skulle jag göra?

302
00:18:46,320 --> 00:18:49,760
Jag skulle bara behöva malloc en ny nod för "a",

303
00:18:49,760 --> 00:18:54,630
och sedan lägga sitt ord till true.

304
00:18:54,630 --> 00:19:00,180
Så det bara innebär att ha "a" kommer att bli sann. Vettigt?

305
00:19:00,180 --> 00:19:04,120
Sen om jag vill lägga till "ba", jag måste malloc 1 för "b",

306
00:19:04,120 --> 00:19:07,550
och sedan ska jag ställa in boolean false

307
00:19:07,550 --> 00:19:10,160
eftersom "b" i sig är inte ett ord.

308
00:19:10,160 --> 00:19:13,010
Sen kommer jag att malloc ett annat för "a", så 'ba',

309
00:19:13,010 --> 00:19:16,290
och sedan ska jag ställa in det är ett ord till true.

310
00:19:16,290 --> 00:19:18,950
Eftersom 'ba' är ett ord.

311
00:19:18,950 --> 00:19:21,910
Och sedan om jag vill se om "b" är i denna ordbok,

312
00:19:21,910 --> 00:19:26,730
Jag kan bara gå till den första, "b". Jag går ner, och jag tittar på är ordet, och det står falskt.

313
00:19:26,730 --> 00:19:30,110
Så det är inte ett ord. Om jag vill kontrollera 'ba',

314
00:19:30,110 --> 00:19:38,010
Jag går till den första, "b", och gå sedan till "a", och jag ser sant, så det är ett ord. Vettigt?

315
00:19:38,010 --> 00:19:41,950
Många människor blir förvirrade av försök. Nej?

316
00:19:41,950 --> 00:19:44,740
>> Slutligen Huffmankodning. Huffman-kodning är mycket användbar

317
00:19:44,740 --> 00:19:47,550
för att spara minne och komprimera textfiler,

318
00:19:47,550 --> 00:19:52,270
bara för att många gånger du använder "a" och "e", till exempel,

319
00:19:52,270 --> 00:19:57,710
i dina dokument, men jag vet inte om ni använder "q" och "z" så mycket.

320
00:19:57,710 --> 00:20:02,040
Med bara 1 byte för varje enskilt tecken,

321
00:20:02,040 --> 00:20:08,520
varje - de 256 tecken som vi har i ASCII-tabellen är inte särskilt optimalt,

322
00:20:08,520 --> 00:20:11,410
bara för att det finns vissa tecken som du använder mycket mer,

323
00:20:11,410 --> 00:20:15,180
så du bör nog använda mindre minne för dem.

324
00:20:15,180 --> 00:20:17,560
Hur använder jag Huffman kodning?

325
00:20:17,560 --> 00:20:20,010
Vi måste göra en Huffman träd.

326
00:20:20,010 --> 00:20:23,370
 En Huffman träd har noder

327
00:20:23,370 --> 00:20:27,760
som har en symbol som kommer att vara som, "a", "b", "c", brevet,

328
00:20:27,760 --> 00:20:32,990
vilken bokstav du har, en frekvens som är den frekvens som ordet förekommer i texten,

329
00:20:32,990 --> 00:20:36,280
att du skapar den Huffman träd för,

330
00:20:36,280 --> 00:20:41,800
och sedan en nod som kommer att peka åt vänster av Huffmanträdet

331
00:20:41,800 --> 00:20:47,210
och en annan nod som kommer att peka åt höger. Så precis som ett träd.

332
00:20:47,210 --> 00:20:49,440
Hur du bygger en Huffman träd?

333
00:20:49,440 --> 00:20:54,020
Du kommer att plocka de två noder som har de lägsta frekvenserna.

334
00:20:54,020 --> 00:20:56,490
Om du har en slips du kommer att plocka de två noder

335
00:20:56,490 --> 00:20:59,870
som har de lägsta ASCII-värden också.

336
00:20:59,870 --> 00:21:02,420
Då du kommer att skapa ett nytt träd ur dessa två noder

337
00:21:02,420 --> 00:21:08,030
som kommer att ha den kombinerade frekvensen i den överordnade noden.

338
00:21:08,030 --> 00:21:13,240
Och då du kommer att ta bort de 2 barnen från skogen

339
00:21:13,240 --> 00:21:15,570
och ersätta dem med föräldern.

340
00:21:15,570 --> 00:21:18,930
Och du kommer att upprepa det tills du bara har 1 träd i skogen.

341
00:21:18,930 --> 00:21:23,840
Så låt oss se hur du skulle göra en Huffman träd för ZAMYLA.

342
00:21:23,840 --> 00:21:29,220
Du kan se här att alla bokstäver har frekvensen 1 med undantag för "A", som har frekvensen 2.

343
00:21:29,220 --> 00:21:34,090
Så jag skapade noder för alla brev jag in i ordning av ASCII-värde och frekvens.

344
00:21:34,090 --> 00:21:40,090
Så om jag vill skapa det första trädet, kommer det att vara med "L" och "M".

345
00:21:40,090 --> 00:21:43,100
Så det är här. Frekvensen hos paret kommer att vara två

346
00:21:43,100 --> 00:21:49,470
eftersom det är 1 + 1, sedan nästa 2 med de lägsta frekvenserna är "Y" och "Z".

347
00:21:49,470 --> 00:21:53,180
Och då har jag alla av dem är - ha en frekvens på 2.

348
00:21:53,180 --> 00:22:00,470
Så vilka som är de som har de lägsta ASCII-värdet för nästa?

349
00:22:00,470 --> 00:22:04,830
"A" och "L". Så jag skapar den nya noden,

350
00:22:04,830 --> 00:22:09,930
och slutligen, det är 4 och 2, så 2 kommer att vara på vänster sida.

351
00:22:09,930 --> 00:22:12,430
Och detta är Huffman träd.

352
00:22:12,430 --> 00:22:16,060
Sen om jag vill skriva en text,

353
00:22:16,060 --> 00:22:24,440
som i binär att konvertera till text, med hjälp av Huffman-träd är mycket enkelt.

354
00:22:24,440 --> 00:22:30,220
Till exempel, om jag säger att flytta till vänster är en 0 och flyttar till höger är en 1,

355
00:22:30,220 --> 00:22:32,410
Vad är det som går att representera?

356
00:22:32,410 --> 00:22:35,530
Så som 1, 1, så rätt, rätt,

357
00:22:35,530 --> 00:22:40,370
och sedan 0, så kvar skulle vara L, och sedan 1, 0, 0.

358
00:22:40,370 --> 00:22:43,950
Så 1, 0, så det är bara 1, 0, "A".

359
00:22:43,950 --> 00:22:47,540
Och sedan 0, 1, så 'Z'.

360
00:22:47,540 --> 00:22:52,170
Och sedan 1, 0, 0 - nej.

361
00:22:52,170 --> 00:22:56,780
0, 0 kommer att vara 'Y', så lat.

362
00:22:56,780 --> 00:23:06,060
Så det är allt för mig, Rob kommer att ta över.

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

364
00:23:08,400 --> 00:23:11,390
Vi har mycket att gå över väldigt snabbt.

365
00:23:11,390 --> 00:23:13,430
Bitvis operatörer, buffertspill,

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

367
00:23:16,760 --> 00:23:20,990
Sammantaget som 15 till 20 minuter.

368
00:23:20,990 --> 00:23:24,330
Bitvis operatörer. Det finns 6 av dem som du behöver veta.

369
00:23:24,330 --> 00:23:31,200
Bitvis och, bitvis eller, XOR, vänster shift, högerskift, och inte.

370
00:23:31,200 --> 00:23:35,420
Höger skift och inte du knappt såg i föreläsning alls.

371
00:23:35,420 --> 00:23:40,480
Vi ska gå igenom det snabbt här, men det är bra att veta att dessa är de 6 som finns.

372
00:23:40,480 --> 00:23:45,070
Kom ihåg att bitvisa operatörer är som när du gör 3 + 4.

373
00:23:45,070 --> 00:23:49,420
Du inte har att göra med den binära av 3 och 4.

374
00:23:49,420 --> 00:23:56,550
Med bitvisa operatörer du faktiskt hantera de enskilda bitarna i siffrorna 3 och 4.

375
00:23:56,550 --> 00:23:59,120
>> Så det första som vi säger är bitvis inte,

376
00:23:59,120 --> 00:24:02,340
och allt det gör är att vända alla bitarna.

377
00:24:02,340 --> 00:24:05,500
Så här, om du skriver detta i C, skulle du inte skriva det

378
00:24:05,500 --> 00:24:09,380
som ~ 11011 eller vad skulle du skriva det gillar ~ 4,

379
00:24:09,380 --> 00:24:12,970
och då det skulle vända den binära representationen av 4.

380
00:24:12,970 --> 00:24:24,800
Så här, ~ av vissa binära talet 1101101 ska precis vända alla 1 s till 0 s och alla 0 s till 1 s.

381
00:24:24,800 --> 00:24:27,600
När jag säger det, den frekventa användningen av detta,

382
00:24:27,600 --> 00:24:30,830
och vi får se det i lite, är som vi vill komma med några nummer

383
00:24:30,830 --> 00:24:35,460
där alla bitar är 1, med undantag för en av dem.

384
00:24:35,460 --> 00:24:38,560
Så det är oftast lättare att uttrycka antalet

385
00:24:38,560 --> 00:24:40,630
var just det enda bit är satt,

386
00:24:40,630 --> 00:24:44,650
och sedan ta ~ av den, så att varje annan bit är satt med undantag för att en.

387
00:24:44,650 --> 00:24:50,300
Så det är vad vi kommer att använda mer i lite.

388
00:24:50,300 --> 00:24:58,220
>> Bitvis eller. Här finns 2 binära tal, och dessa två siffror

389
00:24:58,220 --> 00:25:00,780
är ganska representativa, eftersom de representerar alla möjliga

390
00:25:00,780 --> 00:25:07,290
kombination av bitar kan du behöva för att driva på.

391
00:25:07,290 --> 00:25:13,540
Här, när jag or'd varje bit, vi kommer bara att jämföra rakt ner.

392
00:25:13,540 --> 00:25:15,410
Så på vänster sida har vi en 1 och en 1.

393
00:25:15,410 --> 00:25:20,510
När jag bitvis | dem, vad ska jag få? One.

394
00:25:20,510 --> 00:25:25,320
Sedan bitvis | 0 och 1 kommer att ge mig? One.

395
00:25:25,320 --> 00:25:27,840
Bitvis 1 och 0 kommer att vara samma sak, en.

396
00:25:27,840 --> 00:25:31,880
Bitvis 0 | 0 kommer att ge mig 0.

397
00:25:31,880 --> 00:25:37,300
Så det enda fall där jag får 0 är i 0 | 0 fall.

398
00:25:37,300 --> 00:25:40,020
Och du kan tänka på att precis som dina logiska ors.

399
00:25:40,020 --> 00:25:44,830
Så om du tänker på en så sann och 0 som falskt, samma sak gäller här.

400
00:25:44,830 --> 00:25:50,040
Så sant eller sant är sant, sant eller falskt är sant.

401
00:25:50,040 --> 00:25:57,150
Falskt eller sant är sant, falskt eller falskt är det enda som faktiskt är falska.

402
00:25:57,150 --> 00:26:00,100
Här är det exempel som du bör veta

403
00:26:00,100 --> 00:26:05,160
som ett ganska bra exempel på när bitvisa operatörer används.

404
00:26:05,160 --> 00:26:08,660
Här om vi eller kapital "A" med OX20,

405
00:26:08,660 --> 00:26:11,830
och vi kommer att titta på dessa i en andra, vi får något.

406
00:26:11,830 --> 00:26:16,020
Och om vi eller gement "a" med OX20, vi får något.

407
00:26:16,020 --> 00:26:26,750
Så låt oss dra upp ASCII-tabellen.

408
00:26:26,750 --> 00:26:34,000
Okej. Här ser vi att "A" är -

409
00:26:34,000 --> 00:26:36,920
Här har vi "A" är decimal 65.

410
00:26:36,920 --> 00:26:45,120
Men jag ska gå med hexadecimal, vilket är Ox41.

411
00:26:45,120 --> 00:26:48,280
Ganska säker på att vi såg det i klassen. Jag tror att vi såg det i klassen

412
00:26:48,280 --> 00:26:52,730
att det är ganska lätt att konvertera från hexadecimalt till binärt.

413
00:26:52,730 --> 00:26:55,280
Så här, om jag vill sätta 4 till binär,

414
00:26:55,280 --> 00:26:59,550
som bara kommer att bli 0100.

415
00:26:59,550 --> 00:27:03,620
Det här är en plats, 2 plats, 4 plats, så det är 4.

416
00:27:03,620 --> 00:27:08,550
Då kan jag dela upp 1 till binär, vilket kommer att bli 0001.

417
00:27:08,550 --> 00:27:14,280
Och så det här kommer att bli representationen av "A" i binärt.

418
00:27:14,280 --> 00:27:22,720
Med gement "a", det nu kommer att bli Ox61,

419
00:27:22,720 --> 00:27:27,050
där, att dela upp dessa i sin binära, så en 6 -

420
00:27:27,050 --> 00:27:37,830
Låt oss faktiskt gör det - finns det ingen suddgummi? Suddgummi.

421
00:27:37,830 --> 00:27:48,220
Ox61. Så dela 6 i binär kommer att bli 0 + 4 + 2 + 0.

422
00:27:48,220 --> 00:27:54,610
Och uppdelningen 1 kommer att bli 0001.

423
00:27:54,610 --> 00:27:56,520
Om man tittar på skillnaden mellan dessa två,

424
00:27:56,520 --> 00:28:04,250
Vi ser att den enda skillnaden mellan ett gement och stort "A" är det enda bit.

425
00:28:04,250 --> 00:28:11,810
Så kommer tillbaka till här - okej.

426
00:28:11,810 --> 00:28:15,920
Kommer tillbaka till här, om vi tittar på vad det lite OX20 är,

427
00:28:15,920 --> 00:28:22,210
så klyvningen OX20 in i dess binära,

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

429
00:28:27,310 --> 00:28:33,470
OX20, den enda bit som är satt är det lite som vi sysslar med,

430
00:28:33,470 --> 00:28:38,210
med att växla mellan stora och små bokstäver "a".

431
00:28:38,210 --> 00:28:47,610
Om jag eller "A", som är här en, "A",

432
00:28:47,610 --> 00:28:50,580
om jag eller "A" med OX20,

433
00:28:50,580 --> 00:28:53,490
vad ska jag få?

434
00:28:53,490 --> 00:28:58,960
[Student, ohörbart] >> Gemener "a", eftersom det kommer att vända denna bit till en 1.

435
00:28:58,960 --> 00:29:04,170
Och om jag eller "a" med OX20, vad ska jag få?

436
00:29:04,170 --> 00:29:08,780
Små bokstäver a, eftersom bara oring 'a' med OX20,

437
00:29:08,780 --> 00:29:14,580
Jag ska bara vara oring denna enda bit till en 1, det är redan en 1, så det spelar ingen roll.

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

439
00:29:17,960 --> 00:29:24,820
>> Bitvis och. Återigen kan vi se det som vår logiska och motsvarighet.

440
00:29:24,820 --> 00:29:28,180
På vänster sida har vi sanna och äkta.

441
00:29:28,180 --> 00:29:31,160
Det kommer att vara sant, och för alla de fall,

442
00:29:31,160 --> 00:29:36,270
false & sant eller sant och falskt, eller false & falskt,

443
00:29:36,270 --> 00:29:38,550
Ingen av dessa saker är sanna.

444
00:29:38,550 --> 00:29:44,170
Så vad vi i slutändan får är 1000.

445
00:29:44,170 --> 00:29:48,830
Så nu, här, här är där jag har använt den pålitliga bitvis inte,

446
00:29:48,830 --> 00:29:52,230
där vi hade OX20.

447
00:29:52,230 --> 00:29:54,350
Så det här är OX20.

448
00:29:54,350 --> 00:29:59,570
Nu vad jag vill göra, bitvis ~ för OX20.

449
00:29:59,570 --> 00:30:03,600
Det kommer att vända alla bitar.

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

451
00:30:09,330 --> 00:30:18,940
Och så "A" anded med ~ OX20 kommer att ge mig det?

452
00:30:18,940 --> 00:30:22,430
Den enda bit som vi verkligen måste tänka på är den här,

453
00:30:22,430 --> 00:30:26,020
eftersom, om alla dessa bitar är satta till 1,

454
00:30:26,020 --> 00:30:29,000
då vi kommer att få exakt vad "A" var,

455
00:30:29,000 --> 00:30:31,260
utom, möjligen, vad denna bit är.

456
00:30:31,260 --> 00:30:34,460
För om det var en 1, nu det kommer att ställas in på 0,

457
00:30:34,460 --> 00:30:39,810
eftersom allt detta är, anded med detta kommer att bli 0.

458
00:30:39,810 --> 00:30:43,280
Så vad är "A" & ~ OX20 kommer att ge mig?

459
00:30:43,280 --> 00:30:48,200
[Eleverna svarar, ohörbart] >> Och vad är "a" och - det är "A".

460
00:30:48,200 --> 00:30:52,170
Och vad är "a" & ~ OX20 kommer att ge mig?

461
00:30:52,170 --> 00:30:56,720
"A." Eftersom detta är för närvarande en 1.

462
00:30:56,720 --> 00:30:59,570
Anding med detta 0 kommer att göra det till en 0,

463
00:30:59,570 --> 00:31:02,530
och nu ska vi få ett "A".

464
00:31:02,530 --> 00:31:06,600
>> Båda är "A", och sist men inte minst av denna typ,

465
00:31:06,600 --> 00:31:10,830
vi har XOR. Det är väldigt likt eller,

466
00:31:10,830 --> 00:31:14,400
förutom att det innebär uteslutande eller.

467
00:31:14,400 --> 00:31:18,420
Detta är precis vad du brukar tänka på när eller i den verkliga världen.

468
00:31:18,420 --> 00:31:23,190
Så du gör antingen "x" eller "y", men inte båda.

469
00:31:23,190 --> 00:31:28,700
Här 1 ^ 1 kommer att vara 0.

470
00:31:28,700 --> 00:31:33,650
Eftersom sant, är detta - det fungerar inte så bra med den logiska sant och falskt

471
00:31:33,650 --> 00:31:37,150
som bitvis & och eller göra,

472
00:31:37,150 --> 00:31:40,100
men sant ^ sant är falskt.

473
00:31:40,100 --> 00:31:44,810
Eftersom vi bara vill återvända sant om endast en av dem är sann.

474
00:31:44,810 --> 00:31:50,950
Så 1 ^ 1 är 0. Hur är 0 ^ 1?

475
00:31:50,950 --> 00:31:56,010
Är 1. 1 ^ 0 är 1, 0 ^ 0 är 0.

476
00:31:56,010 --> 00:32:03,890
Så under alla omständigheter, är 0 bitvis något 0 kommer att vara 0.

477
00:32:03,890 --> 00:32:10,270
1 bitvis något 0 eller 0 bitvis 1,

478
00:32:10,270 --> 00:32:14,660
om det är | eller ^, det blir en 1, och om det är och det ska vara 0.

479
00:32:14,660 --> 00:32:20,850
Och det enda fall där 1 bitvis 1 är inte 1 är med exklusivt eller.

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

481
00:32:24,580 --> 00:32:36,520
Så här nu, med hjälp av XOR - så vi är tillbaka vid 20.

482
00:32:36,520 --> 00:32:43,480
'A' ^ OX20 är dessa 2 bitar vi jämför.

483
00:32:43,480 --> 00:32:50,020
Så en 1 ^ 0 kommer att ge mig en vad? En en.

484
00:32:50,020 --> 00:32:58,430
'A' ^ OX20 kommer att ge mig? Små bokstäver en.

485
00:32:58,430 --> 00:33:04,010
'A' ^ OX20 kommer att ge mig? Capital A.

486
00:33:04,010 --> 00:33:09,310
Eftersom allt detta gör, detta XOR med OX20

487
00:33:09,310 --> 00:33:15,380
effektivt vända vad denna bit är.

488
00:33:15,380 --> 00:33:21,240
Om detta är en 0, det kommer nu att bli en 1.

489
00:33:21,240 --> 00:33:26,160
Eftersom detta är en 1, 1 ^ 1 är 0.

490
00:33:26,160 --> 00:33:33,280
Så vår "a" har blivit "A", och vår "A" har blivit "a".

491
00:33:33,280 --> 00:33:36,910
Så XOR är ett riktigt bekvämt sätt att bara vända ärendet.

492
00:33:36,910 --> 00:33:39,960
Du vill bara att iterera över en rad bokstäver

493
00:33:39,960 --> 00:33:44,330
och alternera det gäller varje enskilt tecken,

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

495
00:33:50,680 --> 00:33:55,220
>> Nu har vi lämnat skift. Vänster skift är bara att, i princip,

496
00:33:55,220 --> 00:34:01,250
skjuta alla nummer i, eller till vänster, och sätt 0 s bakom dem.

497
00:34:01,250 --> 00:34:05,550
Så här har vi 00.001.101.

498
00:34:05,550 --> 00:34:08,560
Vi kommer att driva 3 0 s in från höger,

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

500
00:34:13,580 --> 00:34:16,380
I icke-binär termer,

501
00:34:16,380 --> 00:34:24,699
Vi ser att det verkligen handlar 13 vänster-skiftat med 3, vilket ger oss 104.

502
00:34:24,699 --> 00:34:32,530
Så vänsterförskjutning, ser vi här, är x << y princip x * 2 ^ y.

503
00:34:32,530 --> 00:34:40,139
13 * 2 ^ 3, 2 ^ 3 är 8, så 13 * 8 är 104.

504
00:34:40,139 --> 00:34:45,679
Om du bara tänker på binär i allmänhet, hur varje siffra,

505
00:34:45,679 --> 00:34:49,530
Om vi ​​börjar från höger, det är en plats, sedan den 2: s plats, då den 4 plats.

506
00:34:49,530 --> 00:34:51,330
Så genom att trycka på 0 s från höger,

507
00:34:51,330 --> 00:34:55,080
vi bara driver saker som var på 4 plats på 8 plats,

508
00:34:55,080 --> 00:34:57,920
och saker som var på 8 plats till 16 plats.

509
00:34:57,920 --> 00:35:01,280
Varje skift multiplicerar bara med 2. Yeah?

510
00:35:01,280 --> 00:35:05,210
[Student] Vad händer om du skiftat med 5?

511
00:35:05,210 --> 00:35:10,790
[Bowden] Om du skiftat med 5 skulle du bara förlora siffror.

512
00:35:10,790 --> 00:35:15,410
Oundvikligen är det samma sak. Liksom, heltal är endast 32 bitar,

513
00:35:15,410 --> 00:35:20,750
så om du lägger två riktigt stora heltal, det bara inte passar i ett heltal.

514
00:35:20,750 --> 00:35:23,660
Så det är samma sak här. Om du skiftat med 5,

515
00:35:23,660 --> 00:35:25,650
vi skulle bara förlora den.

516
00:35:25,650 --> 00:35:28,820
Och det är ungefär vad jag menar med "grovt"

517
00:35:28,820 --> 00:35:37,470
där om du skiftar för långt, förlorar du bitar.

518
00:35:37,470 --> 00:35:39,830
>> Höger skift kommer att bli det motsatta,

519
00:35:39,830 --> 00:35:43,090
där vi ska shove 0 s från slutet,

520
00:35:43,090 --> 00:35:48,400
och för våra syften, fyll i 0 s från vänster.

521
00:35:48,400 --> 00:35:52,910
Så gör det, är vi i princip vända det vi redan hade gjort.

522
00:35:52,910 --> 00:35:57,780
Och vi ser att de tre 0 s till höger precis har fallit bort,

523
00:35:57,780 --> 00:36:02,020
och vi har drivit den 1101 hela vägen till höger.

524
00:36:02,020 --> 00:36:08,380
Detta gör 104 >> 3, som är effektivt, x / 2 ^ y.

525
00:36:08,380 --> 00:36:11,200
Så nu, här, det är en liknande idé.

526
00:36:11,200 --> 00:36:18,720
Varför är det bara ungefär x / 2 ^ y, och inte egentligen x / 2 ^ y?

527
00:36:18,720 --> 00:36:22,240
För om jag hade skiftat med 4, skulle jag ha förlorat en 1.

528
00:36:22,240 --> 00:36:25,950
I grund och botten, vad du tycker om, tänk bara på heltalsdivision i allmänhet.

529
00:36:25,950 --> 00:36:31,070
Så som 5/2 är 2. Det är inte 2.5.

530
00:36:31,070 --> 00:36:35,000
Det är samma idé här. När vi delar med 2,

531
00:36:35,000 --> 00:36:39,910
Vi kan förlora udda bitar på vägen.

532
00:36:39,910 --> 00:36:43,870
Så nu - det är det för bitvis. Det är allt du behöver veta.

533
00:36:43,870 --> 00:36:46,340
Minns de användningsfall som vi såg i klassen,

534
00:36:46,340 --> 00:36:49,340
som en bitmask är användbar för bitvisa operatörer,

535
00:36:49,340 --> 00:36:53,220
eller om du använder dem för bit masker.

536
00:36:53,220 --> 00:36:58,620
Versaler och gemener, konverteringar är en ganska prototypiska exempel.

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

538
00:37:01,640 --> 00:37:05,110
Någon som kommer ihåg vad som var fel med den här funktionen?

539
00:37:05,110 --> 00:37:10,140
Märker vi förklarade en matris med 12 byte, 12 tecken,

540
00:37:10,140 --> 00:37:18,510
och sedan kopierar vi in ​​i vår buffert på 12 tecken hela strängen bar.

541
00:37:18,510 --> 00:37:25,080
Så vad är problemet här?

542
00:37:25,080 --> 00:37:32,270
Det magiska talet 12 bör ganska mycket omedelbart pop ut som - varför 12?

543
00:37:32,270 --> 00:37:35,050
Tänk om bar råkar vara mer än 12 tecken?

544
00:37:35,050 --> 00:37:41,200
Tänk om bar är miljontals tecken?

545
00:37:41,200 --> 00:37:46,010
Här är frågan memcpy. Om bar är tillräckligt lång,

546
00:37:46,010 --> 00:37:50,330
det kommer bara helt - "c", "c" inte bryr sig att det var bara 12 tecken;

547
00:37:50,330 --> 00:37:53,280
"C" inte bryr sig om att det inte får plats så många byte.

548
00:37:53,280 --> 00:37:58,250
Det kommer bara att skriva över röding, de 12 byte som vi har tilldelats för det,

549
00:37:58,250 --> 00:38:01,830
och allt förbi det i minnet som egentligen inte hör till denna buffert

550
00:38:01,830 --> 00:38:06,520
med allt vad det strängfältet är.

551
00:38:06,520 --> 00:38:09,780
Så detta var den bild vi såg i klassen

552
00:38:09,780 --> 00:38:12,220
där vi har vår stack växer upp.

553
00:38:12,220 --> 00:38:16,040
Du bör användas för dessa bilder eller bekanta med dem igen.

554
00:38:16,040 --> 00:38:21,260
Vi har vår stack växer upp, minnesadresser börjar på 0 i toppen

555
00:38:21,260 --> 00:38:26,270
och växa ner att gilla 4 miljarder i botten.

556
00:38:26,270 --> 00:38:28,820
Vi har vår array "c" någonstans i minnet,

557
00:38:28,820 --> 00:38:32,260
då har vi vår pekaren till bar precis under den,

558
00:38:32,260 --> 00:38:38,720
och sedan har vi det här sparade ram pekare i vår returadress och vår moder rutin stack.

559
00:38:38,720 --> 00:38:40,800
Kom ihåg vad avsändaradressen är?

560
00:38:40,800 --> 00:38:45,360
Det är när huvud anropar en funktion foo, anropar en funktion bar,

561
00:38:45,360 --> 00:38:48,100
oundvikligen, bar avkastning.

562
00:38:48,100 --> 00:38:52,610
Så när bar avkastning, måste de veta att det kommer tillbaka till foo som kallade det.

563
00:38:52,610 --> 00:39:01,360
Så avsändaradressen är adressen till den funktion som den har att återvända till när funktionen returnerar.

564
00:39:01,360 --> 00:39:05,830
Anledningen till att det är viktigt för attacker buffertspill är därför, enkelt,

565
00:39:05,830 --> 00:39:09,580
hackare vilja ändra den returadress.

566
00:39:09,580 --> 00:39:14,950
Istället för att gå tillbaka till foo, jag kommer att gå tillbaka dit hacker vill att jag ska gå tillbaka till.

567
00:39:14,950 --> 00:39:17,760
Och, enkelt, där hackaren vill ofta att gå tillbaka till

568
00:39:17,760 --> 00:39:22,400
är början av bufferten som vi ursprungligen hade.

569
00:39:22,400 --> 00:39:26,170
Så märker, återigen, Little Indian.

570
00:39:26,170 --> 00:39:28,490
Apparaten är ett exempel på en liten indiska systemet,

571
00:39:28,490 --> 00:39:34,140
så ett heltal eller en pekare lagras med de bytes omkastade.

572
00:39:34,140 --> 00:39:38,980
Så här ser vi - är det här? 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
Kom ihåg hexadecimala siffror?

575
00:39:48,250 --> 00:39:50,640
Vi vill inte kasta om hexadecimala siffror i Little Indian,

576
00:39:50,640 --> 00:39:56,110
eftersom 2 hexadecimala siffror utgör ett enda byte, och vi vända byte.

577
00:39:56,110 --> 00:40:00,300
Det är därför vi inte lagrar, liksom, 80530CO8.

578
00:40:00,300 --> 00:40:07,520
Vi lagrar, istället, varje par av 2 siffror, med början från höger.

579
00:40:07,520 --> 00:40:10,880
Denna adress hänför sig till adressen för starten

580
00:40:10,880 --> 00:40:15,190
av vår buffert som vi ville verkligen att kopiera in i första hand.

581
00:40:15,190 --> 00:40:19,230
Anledningen till det är användbart är att, tänk om angriparen

582
00:40:19,230 --> 00:40:24,100
hänt, istället för att ha en sträng som var precis

583
00:40:24,100 --> 00:40:27,060
en ofarlig sträng av liknande, deras namn eller något,

584
00:40:27,060 --> 00:40:33,900
tänk om istället att strängen var bara några av godtycklig kod

585
00:40:33,900 --> 00:40:38,610
som gjorde vad de ville göra?

586
00:40:38,610 --> 00:40:45,630
Så de kunde - Jag kan inte komma på något coolt kod.

587
00:40:45,630 --> 00:40:47,780
Det kan vara vad som helst, dock. Varje katastrofala kod.

588
00:40:47,780 --> 00:40:51,440
Om de vill kan de bara göra något på seg fel, men det skulle vara meningslöst.

589
00:40:51,440 --> 00:40:54,950
De gör oftast det att hacka systemet.

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

591
00:40:59,930 --> 00:41:04,800
Detta är, i grunden, getInt, getString, alla de funktioner som vi gett er.

592
00:41:04,800 --> 00:41:10,630
Så vi har char * sträng, och det är den abstraktion som vi blåste bort

593
00:41:10,630 --> 00:41:12,450
någon gång under terminen.

594
00:41:12,450 --> 00:41:18,220
Kom ihåg att en sträng är bara en uppsättning av tecken.

595
00:41:18,220 --> 00:41:23,240
Så här ser vi en förkortad version av getString.

596
00:41:23,240 --> 00:41:25,920
Du bör titta tillbaka på den för att komma ihåg hur det faktiskt har genomförts.

597
00:41:25,920 --> 00:41:30,950
Viktiga detaljer är, märker vi i ett enda tecken i taget

598
00:41:30,950 --> 00:41:34,570
från standard in, vilket är precis som oss att skriva på tangentbordet.

599
00:41:34,570 --> 00:41:37,890
Så ett tecken åt gången, och om vi får för många tecken,

600
00:41:37,890 --> 00:41:40,580
så om n + 1 är större än kapaciteten

601
00:41:40,580 --> 00:41:44,140
då måste vi öka kapaciteten i vår buffert.

602
00:41:44,140 --> 00:41:47,780
Så här är vi fördubbla storleken på vår buffert.

603
00:41:47,780 --> 00:41:51,840
Och det fortsätter att gå, vi infoga tecknet i vår buffert

604
00:41:51,840 --> 00:41:56,220
tills vi får en ny linje eller slutet av filen eller vad som helst,

605
00:41:56,220 --> 00:41:59,380
i vilket fall, vi gjort med strängen och sedan den verkliga getString

606
00:41:59,380 --> 00:42:05,120
krymper minnet, som om vi tilldelats för mycket minne det ska gå tillbaka och krympa lite.

607
00:42:05,120 --> 00:42:08,830
Så vi inte visar det, men huvudtanken är

608
00:42:08,830 --> 00:42:11,960
det måste läsas i ett enda tecken i taget.

609
00:42:11,960 --> 00:42:17,140
Det kan inte bara läsa i en hela på en gång,

610
00:42:17,140 --> 00:42:19,550
eftersom deras buffert är bara av en viss storlek.

611
00:42:19,550 --> 00:42:26,590
Så om strängen som den försöker att infoga i bufferten är för stor, då skulle det svämma över.

612
00:42:26,590 --> 00:42:28,940
Så här förhindrar vi att genom att bara läsa i ett enda tecken

613
00:42:28,940 --> 00:42:33,750
i taget och växer när vi behöver.

614
00:42:33,750 --> 00:42:40,270
Så getInt och de andra CS50 bibliotek funktioner tenderar att använda getString

615
00:42:40,270 --> 00:42:42,310
i deras implementeringar.

616
00:42:42,310 --> 00:42:45,370
Så jag lyfte fram viktiga saker här.

617
00:42:45,370 --> 00:42:49,460
Den uppmanar getString att få en sträng.

618
00:42:49,460 --> 00:42:51,710
Om getString misslyckades att återvända minne,

619
00:42:51,710 --> 00:42:54,270
kom ihåg att getString mallocs något, så när du ringer getString

620
00:42:54,270 --> 00:42:57,820
du bör inte (ohörbart) befria den strängen som du fick.

621
00:42:57,820 --> 00:43:02,870
Så här, om den inte malloc något, återvänder vi INT_MAX som bara en flagga som,

622
00:43:02,870 --> 00:43:05,650
hey, vi var faktiskt inte kunna få ett heltal.

623
00:43:05,650 --> 00:43:10,830
Du bör ignorera vad jag tillbaka till dig, eller

624
00:43:10,830 --> 00:43:15,540
ska du inte behandla detta som en giltig inmatning.

625
00:43:15,540 --> 00:43:21,360
Slutligen, om man antar att lyckades använder vi sscanf med den speciella flaggan,

626
00:43:21,360 --> 00:43:23,820
vilket innebär, först matcha ett heltal,

627
00:43:23,820 --> 00:43:26,770
sedan matcha alla tecken efter det heltal.

628
00:43:26,770 --> 00:43:29,070
Så märker vi vill att det ska vara lika med 1.

629
00:43:29,070 --> 00:43:32,940
Så sscanf avkastning hur många matcher om framgångsrikt gjort?

630
00:43:32,940 --> 00:43:37,010
Det kommer tillbaka 1 om det framgångsrikt matchas ett heltal,

631
00:43:37,010 --> 00:43:40,890
den ger 0 om det inte matchar ett heltal, och den ger 2

632
00:43:40,890 --> 00:43:45,920
om det matchade ett heltal följt av vissa tecken.

633
00:43:45,920 --> 00:43:49,780
Så märker vi försöka igen om vi matchar allt annat än 1.

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

635
00:43:55,230 --> 00:43:57,400
därefter 1, 2, 3 skulle få lagras i heltal,

636
00:43:57,400 --> 00:43:59,620
X skulle få lagras i karaktären,

637
00:43:59,620 --> 00:44:06,410
sscanf skulle återvända 2, och vi skulle försöka igen, eftersom vi bara vill ha ett heltal.

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

639
00:44:09,810 --> 00:44:15,340
Hypertext Markup Language är strukturen och semantik av banan.

640
00:44:15,340 --> 00:44:19,960
Här är exempel från föreläsningen där vi har HTML-taggar.

641
00:44:19,960 --> 00:44:22,110
Vi har huvudet taggar, body-taggarna,

642
00:44:22,110 --> 00:44:27,770
Vi har exempel på tomma taggar där vi faktiskt inte har en start och nära tag,

643
00:44:27,770 --> 00:44:30,820
vi bara få länk och bild.

644
00:44:30,820 --> 00:44:38,480
Det finns ingen stängningsbildtaggen, det finns bara en enda tagg som åstadkommer allt taggen behöver göra.

645
00:44:38,480 --> 00:44:41,950
Länken är ett exempel, vi får se hur du länkar till CSS,

646
00:44:41,950 --> 00:44:45,910
skriptet är ett exempel på hur du länkar till en extern JavaScript.

647
00:44:45,910 --> 00:44:53,100
Det är ganska enkelt, och kom ihåg, HTML är inte ett programmeringsspråk.

648
00:44:53,100 --> 00:44:58,250
Här, kom ihåg hur man skulle definiera en form eller åtminstone vad det skulle göra?

649
00:44:58,250 --> 00:45:01,740
Ett sådant formulär har en handling och en metod.

650
00:45:01,740 --> 00:45:06,210
Metoderna du bara någonsin kommer att se är GET och POST.

651
00:45:06,210 --> 00:45:09,040
Så få är den version där saken får sätta i webbadressen.

652
00:45:09,040 --> 00:45:11,680
POST är där det inte sätts i webbadressen.

653
00:45:11,680 --> 00:45:18,520
Istället är alla data från formuläret infogas mer dold i HTTP-begäran.

654
00:45:18,520 --> 00:45:22,390
Så här definierar åtgärder där HTTP-begäran går.

655
00:45:22,390 --> 00:45:27,490
Om det händer är google.com / search.

656
00:45:27,490 --> 00:45:32,890
Method. Tänk på skillnaderna mellan GET och POST,

657
00:45:32,890 --> 00:45:37,200
och, bara säga som ett exempel, om du vill bokmärka något.

658
00:45:37,200 --> 00:45:40,660
Du kommer aldrig att kunna bokmärka en POST-URL

659
00:45:40,660 --> 00:45:44,970
eftersom data inte finns med i webbadressen.

660
00:45:44,970 --> 00:45:49,790
>> HTTP, nu, är Hypertext Transfer Protocol.

661
00:45:49,790 --> 00:45:54,080
Hypertext Transfer Protocol, skulle du förvänta dig det att överföra

662
00:45:54,080 --> 00:45:57,710
Hypertext Markup Language, och det gör det.

663
00:45:57,710 --> 00:46:00,170
Men den överför också några bilder som du hittar på webben,

664
00:46:00,170 --> 00:46:05,400
någon nedladdning du gör börjar som en HTTP-begäran.

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

666
00:46:10,350 --> 00:46:15,610
Och här måste du känna igen denna typ av en HTTP-begäran.

667
00:46:15,610 --> 00:46:19,300
Här HTTP/1.1 på sidan bara säger att det är den versionen

668
00:46:19,300 --> 00:46:21,570
av protokollet jag använder.

669
00:46:21,570 --> 00:46:25,770
Det är ganska mycket alltid att vara HTTP/1.1, som du ser det.

670
00:46:25,770 --> 00:46:30,110
Då ser vi att detta var GET, alternativet är POST, som du kan se.

671
00:46:30,110 --> 00:46:40,790
Och den URL som jag försökte besöka var www.google.com/search?q = bla, bla, bla.

672
00:46:40,790 --> 00:46:44,240
Så kom ihåg att detta frågetecken q = bla bla bla,

673
00:46:44,240 --> 00:46:49,040
är den typ av saker som lämnas in av ett formulär.

674
00:46:49,040 --> 00:46:51,830
Svaret kan det tillbaka till mig skulle se ut så här.

675
00:46:51,830 --> 00:46:54,050
Återigen, med början i protokollet, som kommer att bli det,

676
00:46:54,050 --> 00:46:59,190
följt av statuskoden. Här är det 200 OK.

677
00:46:59,190 --> 00:47:05,060
Och slutligen, kommer webbsidan att jag faktiskt bad om att följas.

678
00:47:05,060 --> 00:47:08,210
Det möjliga statuskoden kan du se, och du bör känna flera av dem.

679
00:47:08,210 --> 00:47:12,770
200 OK har du förmodligen sett förut.

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
vanligtvis om du går till en webbplats och något är trasigt eller deras PHP-kod kraschar,

682
00:47:22,140 --> 00:47:24,930
medan apparaten vi har den stora orange ruta

683
00:47:24,930 --> 00:47:27,830
som kommer upp och säger, liksom, är fel någonting, denna kod inte fungerar

684
00:47:27,830 --> 00:47:30,380
eller denna funktion är dåliga.

685
00:47:30,380 --> 00:47:33,230
Vanligtvis webbplatser inte vill att du veta vilka funktioner är faktiskt dåligt,

686
00:47:33,230 --> 00:47:37,880
så istället de ska bara ge dig 500 Interna Server fel.

687
00:47:37,880 --> 00:47:43,050
>> TCP / IP är ett lager under HTTP.

688
00:47:43,050 --> 00:47:47,550
Kom ihåg att det finns Internet utanför webben.

689
00:47:47,550 --> 00:47:52,270
Som om du spelar ett online spel som inte går via HTTP,

690
00:47:52,270 --> 00:47:55,740
det går igenom en annan - det är fortfarande med hjälp av Internet,

691
00:47:55,740 --> 00:47:58,900
men den inte använder HTTP.

692
00:47:58,900 --> 00:48:02,470
HTTP är bara ett exempel på protokoll som bygger på TCP / IP.

693
00:48:02,470 --> 00:48:07,820
IP betyder bokstavligen Internet Protocol.

694
00:48:07,820 --> 00:48:11,500
Varje dator har en IP-adress, de är de 4-siffriga saker

695
00:48:11,500 --> 00:48:16,510
som 192.168.2.1, eller vad, som tenderar att vara en lokal.

696
00:48:16,510 --> 00:48:23,390
Men det är ett mönster av en IP-adress.

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

698
00:48:29,060 --> 00:48:33,410
det är det som översätter saker som google.com till en verklig IP-adress.

699
00:48:33,410 --> 00:48:37,700
Så om du skriver att IP-adressen till en URL,

700
00:48:37,700 --> 00:48:40,850
som skulle ta dig till Google, men du brukar inte komma ihåg dessa saker.

701
00:48:40,850 --> 00:48:45,470
Du tenderar att minnas google.com istället.

702
00:48:45,470 --> 00:48:51,560
Det sista vi har är hamnar, där detta är TCP delen av undersökningsperioden.

703
00:48:51,560 --> 00:48:54,880
TCP gör mer. Fundera på, liksom, du har din webbläsare igång.

704
00:48:54,880 --> 00:48:58,670
Kanske du har någon e-postprogram kör;

705
00:48:58,670 --> 00:49:02,150
kanske du har något annat program som använder Internet igång.

706
00:49:02,150 --> 00:49:05,090
De behöver alla tillgång till Internet,

707
00:49:05,090 --> 00:49:08,100
men datorn har bara 1 WiFi-kort eller vad som helst.

708
00:49:08,100 --> 00:49:10,780
Så hamnar är det sätt som vi kan dela upp

709
00:49:10,780 --> 00:49:13,550
hur dessa program kan använda Internet.

710
00:49:13,550 --> 00:49:17,230
Varje ansökan får en specifik port att den kan lyssna på,

711
00:49:17,230 --> 00:49:19,670
och som standard, HTTP använder port 80.

712
00:49:19,670 --> 00:49:22,410
Vissa e-tjänster använder 25.

713
00:49:22,410 --> 00:49:24,490
De låg-numrerade dem tenderar att vara reserverade.

714
00:49:24,490 --> 00:49:29,270
Du brukar kunna få högre numrerade dem för dig själv.

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

716
00:49:32,010 --> 00:49:36,030
Vi utformar webbsidor med CSS, inte med HTML.

717
00:49:36,030 --> 00:49:38,440
Det finns 3 platser du kan sätta din CSS.

718
00:49:38,440 --> 00:49:46,300
Det kan vara inline, mellan stil taggar, eller i ett helt separat fil och sedan kopplas in

719
00:49:46,300 --> 00:49:48,470
Och här är bara ett exempel på CSS.

720
00:49:48,470 --> 00:49:50,450
Du bör känna igen detta mönster,

721
00:49:50,450 --> 00:49:54,310
där det första exemplet har vi matchande body-taggen,

722
00:49:54,310 --> 00:49:56,680
och här vi centre body-taggen.

723
00:49:56,680 --> 00:50:00,420
Det andra exemplet, vi matchar den sak

724
00:50:00,420 --> 00:50:04,740
med ID sidfot, och vi tillämpar vissa stilar till det.

725
00:50:04,740 --> 00:50:07,310
Lägg märke till att ID-sidfot text-Ansluter till vänster,

726
00:50:07,310 --> 00:50:09,840
medan kroppen text-justeras centrum.

727
00:50:09,840 --> 00:50:13,180
Sidfot är inuti kroppen.

728
00:50:13,180 --> 00:50:16,470
Det kommer i stället, text-align kvar, även om kroppen säger text-align center.

729
00:50:16,470 --> 00:50:18,880
Detta är hela kaskad del av den.

730
00:50:18,880 --> 00:50:22,110
Du kan ha - du kan ange färger för kroppen,

731
00:50:22,110 --> 00:50:25,320
och sedan saker i kroppen kan du ange mer specifika stilar,

732
00:50:25,320 --> 00:50:28,160
och saker och ting fungerar som du förväntar dig.

733
00:50:28,160 --> 00:50:34,420
Mer specifika CSS specifice företräde.

734
00:50:34,420 --> 00:50:46,140
Jag tror det är det.

735
00:50:46,140 --> 00:50:49,260
>> [Ali Nahm] Hej alla. Om jag bara kunde få din uppmärksamhet.

736
00:50:49,260 --> 00:50:53,990
Jag är Ali och jag kommer att gå igenom PHP och SQL riktigt snabbt.

737
00:50:53,990 --> 00:51:00,310
Så vi kan börja. PHP står för PHP: Hypertext Preprocessor.

738
00:51:00,310 --> 00:51:03,730
Och som ni alla borde veta, det är en server-side skriptspråk,

739
00:51:03,730 --> 00:51:06,800
och vi använder den för den bakre änden av webbplatser,

740
00:51:06,800 --> 00:51:12,540
och hur det gör en hel del av beräkningarna, att bakom kulisserna del.

741
00:51:12,540 --> 00:51:17,510
Syntax. Det är inte som C, surprise, surprise.

742
00:51:17,510 --> 00:51:22,060
Det måste alltid börja med det, om du kan se den - jag kan inte gå vidare.

743
00:51:22,060 --> 00:51:31,340
Du kan se att du behöver nya typer av hängslen och då behöver du också? Php.

744
00:51:31,340 --> 00:51:35,780
Det är alltid hur du måste rama in PHP-text, din PHP-kod.

745
00:51:35,780 --> 00:51:39,180
Så det kan inte bara vara som C, där du slags lägga den på första.

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

747
00:51:42,290 --> 00:51:47,610
Och nu är den stora syntax att alla variabler måste börja med tecknet $.

748
00:51:47,610 --> 00:51:49,490
Du måste göra det när du definierar dem, du behöver för att göra det

749
00:51:49,490 --> 00:51:51,860
När du hänvisar till dem senare.

750
00:51:51,860 --> 00:51:56,510
Du måste alltid att $. Det är din nya bästa vän, ganska mycket.

751
00:51:56,510 --> 00:52:01,690
Du behöver inte - till skillnad från C, du behöver inte sätta vilken typ av variabel typ det är.

752
00:52:01,690 --> 00:52:04,940
Så när du behöver den $, behöver du inte att sätta, liksom,

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

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

755
00:52:11,490 --> 00:52:15,590
Som ett resultat av detta så innebär det att PHP är en svagt typen.

756
00:52:15,590 --> 00:52:19,310
PHP är ett svagt språk, och det har svagt skrivit variabler.

757
00:52:19,310 --> 00:52:24,020
Med andra ord innebär det att du kan växla mellan olika typer av variabeltyper.

758
00:52:24,020 --> 00:52:27,230
Du kan spara ditt nummer 1 som en int,

759
00:52:27,230 --> 00:52:29,650
du kan spara den som en sträng, och du kan spara den som en flottör,

760
00:52:29,650 --> 00:52:33,550
och det kommer allt att bli som nummer 1.

761
00:52:33,550 --> 00:52:36,080
Även om du lagrar den i olika former,

762
00:52:36,080 --> 00:52:39,120
det är fortfarande - de variabeltyper håller fortfarande i slutändan.

763
00:52:39,120 --> 00:52:41,540
Så om du ser här, om du kommer ihåg från pset 7,

764
00:52:41,540 --> 00:52:43,500
många av er förmodligen hade problem med detta.

765
00:52:43,500 --> 00:52:47,280
Två likhetstecken, 3 likhetstecken, 4 likhetstecken.

766
00:52:47,280 --> 00:52:49,990
Okej, det finns inga 4 likhetstecken, men det finns 2 och 3.

767
00:52:49,990 --> 00:52:53,320
Du använder två likhetstecken för att kontrollera värdena.

768
00:52:53,320 --> 00:52:55,830
Det kan kontrollera över typer.

769
00:52:55,830 --> 00:52:58,770
Så om du kan se i det första exemplet,

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

771
00:53:02,210 --> 00:53:06,710
Så din int och din sträng är både tekniskt, 1,

772
00:53:06,710 --> 00:53:10,790
men de är olika typer. Men för de dubbla jämlikar, kommer det fortfarande passera.

773
00:53:10,790 --> 00:53:15,510
Men för de tredubbla jämlikar, kontrollerar den värdet samt de olika typerna.

774
00:53:15,510 --> 00:53:18,760
Det betyder att det inte kommer att passera i det andra fallet här,

775
00:53:18,760 --> 00:53:22,350
där du använder 3 likhetstecken istället.

776
00:53:22,350 --> 00:53:26,590
Så det är en stor skillnad som du borde alla ha visat nu.

777
00:53:26,590 --> 00:53:31,570
>> String sammanslagning är ett annat kraftfullt sak som du kan använda i PHP.

778
00:53:31,570 --> 00:53:34,080
Det är i princip bara denna behändiga punktnotation,

779
00:53:34,080 --> 00:53:36,230
och det är hur du kan binda strängar tillsammans.

780
00:53:36,230 --> 00:53:40,800
Så om du har katt och du har hund, och du vill placera de 2 strängar tillsammans,

781
00:53:40,800 --> 00:53:44,080
du kan använda den tid, och det är typ av hur det fungerar.

782
00:53:44,080 --> 00:53:46,660
Du kan också bara ställa dem bredvid varandra,

783
00:53:46,660 --> 00:53:49,030
som ni kan se här i botten exempel

784
00:53:49,030 --> 00:53:51,610
där jag har eko sträng 1, rymd sträng 2.

785
00:53:51,610 --> 00:53:56,930
PHP vet att ersätta dem som sådana.

786
00:53:56,930 --> 00:53:59,780
Matriser. Nu, i PHP, det finns 2 olika typer av matriser.

787
00:53:59,780 --> 00:54:03,180
Du kan ha regelbundna arrayer, och du kan även ha associativa arrayer,

788
00:54:03,180 --> 00:54:06,040
och vi kommer att gå igenom dem just nu.

789
00:54:06,040 --> 00:54:08,280
Regelbundna arrayer är just detta i C,

790
00:54:08,280 --> 00:54:11,240
och så du har index som är numrerade.

791
00:54:11,240 --> 00:54:13,160
Just nu är vi bara kommer att skapa en och sätta -

792
00:54:13,160 --> 00:54:15,500
så detta är hur vi skapar en tom array, då vi kommer att

793
00:54:15,500 --> 00:54:17,310
tas i indexnumret 0.

794
00:54:17,310 --> 00:54:19,200
Vi ska sätta siffran 6, värdet 6.

795
00:54:19,200 --> 00:54:21,500
Du kan se det längst ner här.

796
00:54:21,500 --> 00:54:24,240
Where's - vid indexnummer 1 vi ska sätta värde nummer 4,

797
00:54:24,240 --> 00:54:26,720
och så att du kan se att det finns en 6, finns det en 4,

798
00:54:26,720 --> 00:54:29,160
och sedan när vi skriver ut saker och ting,

799
00:54:29,160 --> 00:54:33,550
när vi försöker och skriva ut värdet lagras vid indexnummer 0,

800
00:54:33,550 --> 00:54:36,900
sedan får vi se värdet 6 att skrivas ut. Cool?

801
00:54:36,900 --> 00:54:40,160
Så det är regelbundna arrayer för dig.

802
00:54:40,160 --> 00:54:42,750
Ett annat sätt du kan även lägga till saker till vanliga arrayer nu

803
00:54:42,750 --> 00:54:44,780
är att du kan bara lägga dem i slutet.

804
00:54:44,780 --> 00:54:47,240
Det innebär att du inte behöver ange specifikt index.

805
00:54:47,240 --> 00:54:51,000
Du kan se numret, och sedan i hakparenteserna finns det inget index anges.

806
00:54:51,000 --> 00:54:56,270
Och det kommer att veta - PHP vet att bara lägga till det i slutet av listan, nästa lediga plats.

807
00:54:56,270 --> 00:54:59,190
Så du kan se ett direkt vid det 0 fläck,

808
00:54:59,190 --> 00:55:02,690
den 2 gick rätt där på första plats.

809
00:55:02,690 --> 00:55:04,690
Den 3 går - läggs där.

810
00:55:04,690 --> 00:55:06,720
Så det slags vettigt. Du är bara hela tiden till det,

811
00:55:06,720 --> 00:55:09,360
och sedan när vi ekande index för nummer 1,

812
00:55:09,360 --> 00:55:13,080
det kommer att skriva ut värdet 2.

813
00:55:13,080 --> 00:55:16,800
>> Sedan har vi arrayer som är associativa arrayer.

814
00:55:16,800 --> 00:55:19,370
Associativa arrayer, i stället för att ha numeriska index,

815
00:55:19,370 --> 00:55:23,630
vad de gör är, har de index som är med snöre.

816
00:55:23,630 --> 00:55:25,670
Du kan se, i stället för - Jag blev av med alla dessa sifferindex,

817
00:55:25,670 --> 00:55:32,140
och nu är det nyckel1, KEY2, KEY3, och de är inom citationstecken för att markera att de är alla strängar.

818
00:55:32,140 --> 00:55:34,470
Så vi kan få ett exempel på detta.

819
00:55:34,470 --> 00:55:38,790
Exemplet på detta är att vi har tf, och det är indexnamnet.

820
00:55:38,790 --> 00:55:42,030
Vi kommer att sätta "Ali" som namn på index, kalorier ätit,

821
00:55:42,030 --> 00:55:47,640
Vi kan sätta en int den här gången istället för en sträng,

822
00:55:47,640 --> 00:55:52,240
och sedan på index gillar, kan vi sätta en hel rad i den.

823
00:55:52,240 --> 00:55:55,490
Så det här är sådan - det är ett liknande koncept för hur vi hade

824
00:55:55,490 --> 00:55:58,930
index med siffror, men nu kan vi ändra indexen runt

825
00:55:58,930 --> 00:56:03,890
att ha dem som strängar i stället.

826
00:56:03,890 --> 00:56:06,070
Du kan också göra detta, förutom att bara göra det för sig,

827
00:56:06,070 --> 00:56:09,400
du kan göra allt på en bit. Så du kan se att tf av denna samling,

828
00:56:09,400 --> 00:56:13,350
och sedan vi satt dem alla i en gigantisk fyrkantig fäste set.

829
00:56:13,350 --> 00:56:15,220
Så det kan snabba upp saker och ting.

830
00:56:15,220 --> 00:56:19,730
Det är mer av en stilistisk val än inte.

831
00:56:19,730 --> 00:56:21,550
Vi har även slingor.

832
00:56:21,550 --> 00:56:26,020
I C har vi loopar som fungerar så här.

833
00:56:26,020 --> 00:56:29,690
Vi hade vår samling, och vi gick från index 0 till slutet av listan,

834
00:56:29,690 --> 00:56:31,740
och vi skriver ut allt, eller hur?

835
00:56:31,740 --> 00:56:33,880
Förutom problemet är, för associativa arrayer,

836
00:56:33,880 --> 00:56:36,610
Vi behöver inte nödvändigtvis vet de numeriska index

837
00:56:36,610 --> 00:56:39,610
för nu har vi de strängindex.

838
00:56:39,610 --> 00:56:44,800
Nu använder vi foreach loopar, som, igen, förhoppningsvis använt dig pset 7.

839
00:56:44,800 --> 00:56:48,930
Foreach loopar kommer bara vet varenda del av listan.

840
00:56:48,930 --> 00:56:52,450
Och det behöver inte veta exakt det numeriska index som du har.

841
00:56:52,450 --> 00:56:56,490
Så du har foreach syntaxen, så det är foreach, du sätter matrisen.

842
00:56:56,490 --> 00:57:00,430
Så min samling heter pset, och sedan som ordet som,

843
00:57:00,430 --> 00:57:04,530
och då du sätter denna lokal temporär variabel som du ska använda

844
00:57:04,530 --> 00:57:10,690
bara för specifik sak som kommer att hålla den specifika -

845
00:57:10,690 --> 00:57:14,770
en instans eller en del av matrisen.

846
00:57:14,770 --> 00:57:18,350
Pset num kommer att hålla 1, och då kanske det kommer att hålla i nummer 6,

847
00:57:18,350 --> 00:57:20,410
och så kommer det att hålla numret 2.

848
00:57:20,410 --> 00:57:26,630
Men det är garanterat att gå igenom varje enskilt värde som finns i arrayen.

849
00:57:26,630 --> 00:57:30,530
Praktiska funktioner som du bör veta i PHP är de kräver,

850
00:57:30,530 --> 00:57:35,880
så som ser till att du även vissa filer, eko, avfart, tom.

851
00:57:35,880 --> 00:57:40,490
Jag rekommenderar att du tittar på pset 7 och titta på dessa funktioner.

852
00:57:40,490 --> 00:57:42,810
Du kanske måste känna dem,

853
00:57:42,810 --> 00:57:47,060
så jag skulle definitivt vet vad, exakt, som alla gör.

854
00:57:47,060 --> 00:57:50,080
>> Nu ska vi gå igenom omfattningen riktigt snabbt.

855
00:57:50,080 --> 00:57:53,490
I omfattning, är PHP typ av en funky sak, till skillnad från C,

856
00:57:53,490 --> 00:57:56,170
och så vi ska bara gå igenom det snabbt.

857
00:57:56,170 --> 00:57:58,930
Så låt oss säga att vi börjar på den pil som vi har där.

858
00:57:58,930 --> 00:58:02,900
Och vi kommer att börja med $ i. Så variabeln "i" kommer att vara 0,

859
00:58:02,900 --> 00:58:06,730
och vi kommer bara att fortsätta att skriva ut det i den stora vita rutan där borta.

860
00:58:06,730 --> 00:58:09,220
Vi ska börja med I0, och sedan ska vi upprepa det.

861
00:58:09,220 --> 00:58:12,670
Så det finns det 0.

862
00:58:12,670 --> 00:58:15,210
Och då kommer vi att öka den genom att slingan,

863
00:58:15,210 --> 00:58:17,810
och då det kommer att vara värdet 1.

864
00:58:17,810 --> 00:58:20,070
En är mindre än 3, så det kommer att passera genom det för loop,

865
00:58:20,070 --> 00:58:23,230
och då kommer vi att se den tryckt igen.

866
00:58:23,230 --> 00:58:25,520
Vi kommer att öka igen till 2,

867
00:58:25,520 --> 00:58:29,860
och 2 är mindre än 3, så det ska passera för loop, och det kommer att skriva ut 2.

868
00:58:29,860 --> 00:58:35,100
Då kommer du att notera att 3 är inte mindre än 3, så vi kommer att bryta sig ur den för slingan.

869
00:58:35,100 --> 00:58:40,050
Så nu har vi avslutat, och sedan ska vi gå in aFunction.

870
00:58:40,050 --> 00:58:45,010
Okej. Så du måste notera att denna variabel som vi har skapat,

871
00:58:45,010 --> 00:58:48,270
"i" variabel, inte lokalt scoped.

872
00:58:48,270 --> 00:58:50,280
Det betyder att det inte är lokala till slingan,

873
00:58:50,280 --> 00:58:58,060
och den variabeln vi kan fortfarande komma åt och ändra i efterhand, och det kommer fortfarande att vara effektiv.

874
00:58:58,060 --> 00:59:02,160
Så om du går in i funktionen nu, ser du att vi använder även "i" variabel,

875
00:59:02,160 --> 00:59:05,320
och vi kommer att öka "i" + +.

876
00:59:05,320 --> 00:59:09,410
Man skulle kunna tro, först, baserat på C, att det är en kopia av "i" variabel.

877
00:59:09,410 --> 00:59:12,830
Det är en helt annan sak, vilket är korrekt.

878
00:59:12,830 --> 00:59:16,560
Så när vi skriver ut det, kommer vi att skriva ut 'i' + +, som kommer att skriva ut den 4,

879
00:59:16,560 --> 00:59:19,640
och sedan ska vi - tyvärr.

880
00:59:19,640 --> 00:59:22,030
Sen ska vi avsluta ur denna funktion,

881
00:59:22,030 --> 00:59:24,820
och vi kommer att vara där som pilen är just nu.

882
00:59:24,820 --> 00:59:29,190
Det innebär att dess emellertid, trots att funktionen ändrat värdet för "i",

883
00:59:29,190 --> 00:59:32,620
Det ändrade inte utanför funktionen,

884
00:59:32,620 --> 00:59:35,060
eftersom funktionen har en separat räckvidd.

885
00:59:35,060 --> 00:59:38,960
Det betyder att när vi echo "i", det har inte förändrats inom ramen för funktionen,

886
00:59:38,960 --> 00:59:43,660
och så då ska vi ut 3 igen.

887
00:59:43,660 --> 00:59:47,520
Olika saker om utrymme i PHP än i C.

888
00:59:47,520 --> 00:59:51,130
>> Nu i PHP och HTML.

889
00:59:51,130 --> 00:59:53,510
PHP används för att göra webbsidor dynamiska.

890
00:59:53,510 --> 00:59:58,660
Det gör slags saker annorlunda.

891
00:59:58,660 --> 01:00:02,090
Vi har det sig från HTML.

892
01:00:02,090 --> 01:00:05,230
Med HTML, vi alltid bara har samma statiska sak, liksom hur Rob visade,

893
01:00:05,230 --> 01:00:09,370
medan PHP, kan du ändra saker baserat på vem användaren är.

894
01:00:09,370 --> 01:00:11,830
Så om jag har det, jag har, "Du är inloggad som -" och sedan namnet,

895
01:00:11,830 --> 01:00:14,420
och jag kan ändra namnet. Så just nu namnet är Josef,

896
01:00:14,420 --> 01:00:18,880
och det har den "om mig", men då kan jag också byta namn för att ha Tommy.

897
01:00:18,880 --> 01:00:21,700
Och det skulle vara en annan sak.

898
01:00:21,700 --> 01:00:23,840
Så då kan vi också ändra olika saker om honom,

899
01:00:23,840 --> 01:00:27,070
och det kommer att visa olika innehåll baserat på namnet.

900
01:00:27,070 --> 01:00:31,430
Så PHP kan slags ändra vad som händer på din webbplats.

901
01:00:31,430 --> 01:00:33,540
Samma här. Ändå, notera att de har olika innehåll,

902
01:00:33,540 --> 01:00:38,870
även om du är tekniskt sett fortfarande tillgång till samma webbsida på ytan.

903
01:00:38,870 --> 01:00:43,450
Generera HTML. Det finns två olika sätt som du kan göra här.

904
01:00:43,450 --> 01:00:48,980
Så vi ska gå igenom det just nu. Det första sättet är, du har - ja, förlåt.

905
01:00:48,980 --> 01:00:51,150
Så du bara har din vanliga för loop i PHP,

906
01:00:51,150 --> 01:00:56,270
och då ekar i PHP och du echo ut HTML.

907
01:00:56,270 --> 01:00:58,720
Använda vad Rob visade dig av HTML-skript

908
01:00:58,720 --> 01:01:04,030
och sedan med hjälp av PHP-print att bara skriva ut den på webbsidan.

909
01:01:04,030 --> 01:01:09,520
Det alternativa sättet är att göra det som om du skilja ut PHP och HTML.

910
01:01:09,520 --> 01:01:11,940
Så du kan ha en rad av PHP som startar för slingan,

911
01:01:11,940 --> 01:01:16,020
då kan du ha den raden i HTML i en separat sak,

912
01:01:16,020 --> 01:01:19,700
och sedan avsluta slingan, återigen, med en PHP.

913
01:01:19,700 --> 01:01:21,800
Så det är typ att skilja ut det.

914
01:01:21,800 --> 01:01:24,020
På vänster sida kan du att du har all den -

915
01:01:24,020 --> 01:01:26,360
det är bara 1 bit av PHP.

916
01:01:26,360 --> 01:01:28,510
Till höger kan du se att du har en linje av PHP,

917
01:01:28,510 --> 01:01:32,540
du har en linje av HTML, och du har en rad av PHP igen.

918
01:01:32,540 --> 01:01:36,870
Så separera ut i vad de gör.

919
01:01:36,870 --> 01:01:39,330
Och du kommer att notera att båda hållen, för någon av dem,

920
01:01:39,330 --> 01:01:41,980
de fortfarande skriva ut bilden, bilden, bilden,

921
01:01:41,980 --> 01:01:44,540
så att HTML fortfarande skrivs ut på samma sätt.

922
01:01:44,540 --> 01:01:49,870
Och då kommer du fortfarande se de 3 bilderna visas på din webbplats.

923
01:01:49,870 --> 01:01:52,820
Så det är två olika sätt att göra samma sak.

924
01:01:52,820 --> 01:01:55,060
>> Nu har vi blanketter och ansökningar. Som Rob visade dig,

925
01:01:55,060 --> 01:01:59,400
det finns former av HTML, och vi kommer bara vind genom detta.

926
01:01:59,400 --> 01:02:02,040
Du har en handling och du har en metod, och din handling

927
01:02:02,040 --> 01:02:04,350
typ av visar var du ska skicka det, och metoden är om

928
01:02:04,350 --> 01:02:06,960
det kommer att bli en GET eller POST.

929
01:02:06,960 --> 01:02:11,220
Och en begäran GET, som Rob sa, innebär att du kommer att lägga den i en form

930
01:02:11,220 --> 01:02:15,760
och du ser det som en URL, medan en begäran POST du inte kommer att se i en webbadress.

931
01:02:15,760 --> 01:02:17,840
Så en liten skillnad.

932
01:02:17,840 --> 01:02:19,950
Men en sak som är en liknande sak

933
01:02:19,950 --> 01:02:22,560
är att POST och GET är lika osäkra.

934
01:02:22,560 --> 01:02:26,430
Så du kanske tror att bara för att du inte ser det i URL,

935
01:02:26,430 --> 01:02:28,790
det betyder att POST är säkrare,

936
01:02:28,790 --> 01:02:34,420
men du kan fortfarande se det i dina cookies i den information som du skickar.

937
01:02:34,420 --> 01:02:38,260
Så tror inte att ungefär ena eller det andra.

938
01:02:38,260 --> 01:02:42,160
En annan sak att notera är att du även har sektionsvariabler.

939
01:02:42,160 --> 01:02:45,850
Ni använde detta i pset 7 för att få ditt användar-ID.

940
01:02:45,850 --> 01:02:48,550
Det som hände var att du kan använda denna associativ array,

941
01:02:48,550 --> 01:02:53,310
de $ _SESSION, och då du kan komma åt olika saker

942
01:02:53,310 --> 01:02:57,720
och förvara olika saker över sidorna.

943
01:02:57,720 --> 01:03:00,750
>> Senaste är att vi har SQL, Structured Query Language,

944
01:03:00,750 --> 01:03:04,360
och detta är ett programmeringsspråk för att hantera databaser.

945
01:03:04,360 --> 01:03:08,220
Vad, exakt, är databaser? De är samlingar av tabeller,

946
01:03:08,220 --> 01:03:10,630
och varje tabell kan ha liknande typer av objekt.

947
01:03:10,630 --> 01:03:14,990
Så vi hade en tabell för användare i din ekonomi pset.

948
01:03:14,990 --> 01:03:20,610
Och varför är de användbara? Eftersom det är ett sätt att permanent lagra information.

949
01:03:20,610 --> 01:03:22,840
Det är ett sätt att spåra saker och hantera saker

950
01:03:22,840 --> 01:03:25,890
och faktiskt se det på olika sidor och hålla koll.

951
01:03:25,890 --> 01:03:29,930
Medan om du bara lagra den på att en omedelbar ögonblicket

952
01:03:29,930 --> 01:03:33,720
och sedan använda den senare, kommer du inte att kunna komma åt något som du har sparat.

953
01:03:33,720 --> 01:03:37,660
Vi har 4 stora saker som vi använder för SQL-kommandon.

954
01:03:37,660 --> 01:03:40,190
Vi har att välja, infoga, ta bort och uppdatera.

955
01:03:40,190 --> 01:03:42,880
Det är verkligen viktigt för er att veta för din frågesport.

956
01:03:42,880 --> 01:03:45,990
>> Vi ska snabbt gå över väljer just nu.

957
01:03:45,990 --> 01:03:48,540
I grund och botten, du väljer rader från en databas.

958
01:03:48,540 --> 01:03:52,400
Så om du har, just här -

959
01:03:52,400 --> 01:03:56,740
vi har dessa två olika saker, och vi vill välja från tabellen klasser

960
01:03:56,740 --> 01:04:01,480
där awesome - var i fantastisk kolumnen värdet är 1.

961
01:04:01,480 --> 01:04:04,460
Så du kan se här, vi har dessa 2 saker av klassnamn,

962
01:04:04,460 --> 01:04:08,490
CS50 och Stat110, och vi har de klass ID och slogan.

963
01:04:08,490 --> 01:04:13,150
Så vi vill markera all denna information.

964
01:04:13,150 --> 01:04:17,480
Sedan kan du se här att det är typ att plocka ut ur det enorma kolumnen

965
01:04:17,480 --> 01:04:25,170
där alla saker är 1, och därefter har den klass-ID, klassnamn och slogan som den kan plocka ut.

966
01:04:25,170 --> 01:04:28,100
Exakt hur gör man det i kod? Du måste använda PHP.

967
01:04:28,100 --> 01:04:33,830
Så det är typ hur PHP och SQL är relaterade till varandra.

968
01:04:33,830 --> 01:04:38,130
Nu har vi vår kod, och vi kommer att använda vår sökfunktion

969
01:04:38,130 --> 01:04:41,370
som vi gjorde i pset 7, och vi kommer att köra SQL-frågan.

970
01:04:41,370 --> 01:04:43,870
Sen ska vi ha -

971
01:04:43,870 --> 01:04:46,280
vi alltid måste kontrollera om rad triple lika om falskt.

972
01:04:46,280 --> 01:04:49,010
Så återigen, vill du kontrollera typ och värde,

973
01:04:49,010 --> 01:04:53,880
och sedan om det inte fungerar, då du vill be om ursäkt, som vanligt, som vi gjorde i pset 7.

974
01:04:53,880 --> 01:04:55,870
Annars vill slinga genom allt med dem som praktiskt

975
01:04:55,870 --> 01:04:59,410
foreach loopar att vi bara gick över.

976
01:04:59,410 --> 01:05:01,280
Nu när vi loopa igenom och vi har gjort det tidigare,

977
01:05:01,280 --> 01:05:05,080
låt oss anta att vår fråga gått, nu har vi vår foreach loop.

978
01:05:05,080 --> 01:05:11,050
Och den första raden har det, så här är raden, just här, det är inramade.

979
01:05:11,050 --> 01:05:14,010
Det kommer att skriva ut all information som det har blivit.

980
01:05:14,010 --> 01:05:18,070
Så det kommer att skrivas ut i botten "Vill du lära HTML?"

981
01:05:18,070 --> 01:05:23,370
Då kommer det att gå till nästa rad, eftersom det är slutfört den första för slinga,

982
01:05:23,370 --> 01:05:26,510
och så då det kommer att skriva ut den andra raden i den,

983
01:05:26,510 --> 01:05:32,120
som kommer att bli STAT110, Hitta alla Moments.

984
01:05:32,120 --> 01:05:34,290
>> En sista sak är på SQL sårbarheter.

985
01:05:34,290 --> 01:05:37,300
Jag vet att David var inne på detta lite i föreläsning.

986
01:05:37,300 --> 01:05:40,730
Du kan läsa det här senare. Det är verkligen roligt.

987
01:05:40,730 --> 01:05:45,320
SQL Injection är en sorts knepig sak.

988
01:05:45,320 --> 01:05:49,890
Låt oss säga att du bara hålla dessa variabler direkt i din fråga,

989
01:05:49,890 --> 01:05:52,290
som ni kan se i den första raden.

990
01:05:52,290 --> 01:05:54,520
Så det verkar bra, eller hur? Du bara sätter in användarnamnet

991
01:05:54,520 --> 01:05:58,820
och lösenord till din SQL-fråga, och du vill skicka bort det och få allt som är i datatabellen.

992
01:05:58,820 --> 01:06:01,450
Det verkar ganska enkelt. Så låt säga någon sätter in,

993
01:06:01,450 --> 01:06:04,910
för lösenord, detta ELLER text här -

994
01:06:04,910 --> 01:06:06,780
borde egentligen vara i den röda rutan.

995
01:06:06,780 --> 01:06:11,920
Så låt oss säga att de sätter det lösenordet i - det är vad de kommer in.

996
01:06:11,920 --> 01:06:16,520
Så de lägger ELLER "1" = 1.

997
01:06:16,520 --> 01:06:20,880
Typ av en enfaldigt lösenord för att ha.

998
01:06:20,880 --> 01:06:25,070
Nu ska vi bara byta ut det, och du kommer att notera att i den SQL-fråga nu,

999
01:06:25,070 --> 01:06:29,090
det utvärderas till alltid sant, eftersom du kommer att notera att

1000
01:06:29,090 --> 01:06:32,240
du kan SQL-fråga markera all denna information

1001
01:06:32,240 --> 01:06:35,420
eller du kan bara ha 1 = 1.

1002
01:06:35,420 --> 01:06:41,030
Så det alltid kommer att utvärderas till true.

1003
01:06:41,030 --> 01:06:46,610
Det kommer inte att verkligen fungerar, eftersom det innebär att hackare kan bryta sig in i ditt system.

1004
01:06:46,610 --> 01:06:49,300
Lösningen på detta är att du måste använda PDO-systemet,

1005
01:06:49,300 --> 01:06:51,360
vilket innebär att du måste använda frågetecken,

1006
01:06:51,360 --> 01:06:53,350
vilket är vad ni killar som används i pset 7,

1007
01:06:53,350 --> 01:06:57,620
där du ska använda ett frågetecken i stället för var du vill lägga något,

1008
01:06:57,620 --> 01:07:01,430
och då du kommer att ha ett kommatecken, och sedan har du efteråt,

1009
01:07:01,430 --> 01:07:07,610
efter din sträng, till de olika variabler som du vill byta in din frågetecken.

1010
01:07:07,610 --> 01:07:10,330
Så du kommer att notera att nu har jag dessa röda frågetecken.

1011
01:07:10,330 --> 01:07:15,420
Sedan satte jag variablerna efter mina strängar så jag vet att ersätta dem i den ordningen efteråt.

1012
01:07:15,420 --> 01:07:18,470
Det kommer att se till att om någon gör det så här,

1013
01:07:18,470 --> 01:07:24,050
och de har eller 1 = 1 situation, som kommer att se,

1014
01:07:24,050 --> 01:07:30,490
i bakändan, se till att det faktiskt inte kommer att bryta SQL-fråga.

1015
01:07:30,490 --> 01:07:33,660
Okej, så det är ganska mycket det, en virvelvind av PHP och SQL.

1016
01:07:33,660 --> 01:07:41,520
Lycka till er alla, och nu till Ore

1017
01:07:41,520 --> 01:07:44,270
>> [Oreoluwatomiwa Babarinsa] Okej alla. Dags att gå igenom några JavaScript

1018
01:07:44,270 --> 01:07:48,840
och en del andra saker väldigt snabbt så vi behöver inte hålla dig i kväll.

1019
01:07:48,840 --> 01:07:56,930
JavaScript. Ja. JavaScript är lite av en cool grej, enligt uppgift.

1020
01:07:56,930 --> 01:07:59,090
De saker som du verkligen behöver veta om JavaScript, det är ungefär som

1021
01:07:59,090 --> 01:08:03,810
klientsidan slutet av vad din web app kommer att göra.

1022
01:08:03,810 --> 01:08:08,280
Det finns några saker som du bara inte vill ta hand om hela tiden på serversidan.

1023
01:08:08,280 --> 01:08:12,880
Alla små interaktioner, lyfta fram en sak, gör något försvinner.

1024
01:08:12,880 --> 01:08:15,340
Du vill verkligen inte att behöva prata med din server hela tiden för det.

1025
01:08:15,340 --> 01:08:18,069
Och en del av det är inte ens möjligt att göra på serversidan.

1026
01:08:18,069 --> 01:08:21,899
Det är därför vi behöver något som JavaScript.

1027
01:08:21,899 --> 01:08:24,359
Coola saker om JavaScript: Det är dynamiskt skrivit.

1028
01:08:24,359 --> 01:08:27,149
Vad detta betyder är att ditt program inte behöver veta

1029
01:08:27,149 --> 01:08:30,970
Vad, exakt, är variablerna när du skriver ut det.

1030
01:08:30,970 --> 01:08:34,510
Det ska bara sorts lista ut det eftersom det är igång.

1031
01:08:34,510 --> 01:08:37,520
Andra saker som är coolt om det: Det är en klammer språk,

1032
01:08:37,520 --> 01:08:41,359
vilket innebär syntaxen liknar C och PHP.

1033
01:08:41,359 --> 01:08:47,050
Du behöver inte göra mycket omarbete när du lär JavaScript.

1034
01:08:47,050 --> 01:08:49,180
Här har vi en liten bit av JavaScript.

1035
01:08:49,180 --> 01:08:52,560
Intressant sak här är att om man ser på det,

1036
01:08:52,560 --> 01:08:56,330
vi har lite av JavaScript direkt i huvudet taggen.

1037
01:08:56,330 --> 01:08:59,479
Vad är gör är i grunden bara innehålla en JavaScript-fil.

1038
01:08:59,479 --> 01:09:02,260
Detta är ett sätt du kan inkludera JavaScript i ditt program.

1039
01:09:02,260 --> 01:09:06,910
Sedan den andra lite är faktiskt en del inline JavaScript

1040
01:09:06,910 --> 01:09:10,790
mycket lik en infogad stil med CSS,

1041
01:09:10,790 --> 01:09:16,180
och du bara skriva lite kod väldigt snabbt där.

1042
01:09:16,180 --> 01:09:18,120
JavaScript har arrayer.

1043
01:09:18,120 --> 01:09:20,850
Bara ett annat sätt att hålla data runt, mycket användbart.

1044
01:09:20,850 --> 01:09:25,180
Mycket trevlig och enkel syntax.

1045
01:09:25,180 --> 01:09:29,870
Du använder hakparenteser för att få tillgång till allt och håller ihop allting.

1046
01:09:29,870 --> 01:09:35,020
Inget alltför komplicerad.

1047
01:09:35,020 --> 01:09:38,630
Det häftiga JavaScript och skriptspråk i allmänhet

1048
01:09:38,630 --> 01:09:40,920
är att du inte behöver oroa dig för arraystorlekar.

1049
01:09:40,920 --> 01:09:43,880
Du kan bara använda Array.length och hålla reda på det,

1050
01:09:43,880 --> 01:09:46,960
och även matrisen kan växa eller krympa när du behöver det.

1051
01:09:46,960 --> 01:09:49,279
Så du behöver inte ens oroa dig för någon form av,

1052
01:09:49,279 --> 01:09:57,050
åh nej, jag måste avsätta mer saker, eller något liknande.

1053
01:09:57,050 --> 01:10:00,090
>> Det häftiga här är att JavaScript har något som kallas objekt.

1054
01:10:00,090 --> 01:10:04,800
Det är ett objektorienterat språk, så vad det har är, i huvudsak,

1055
01:10:04,800 --> 01:10:10,100
ett sätt för dig att gruppera uppgifter tillsammans, något som liknar en struct,

1056
01:10:10,100 --> 01:10:17,280
men du kan komma åt det som en struct eller i en associativ array syntax.

1057
01:10:17,280 --> 01:10:22,520
Det är ganska enkelt, och vad du kan göra med detta är gruppuppgifter tillsammans

1058
01:10:22,520 --> 01:10:24,810
om du har en massa data som är relaterade.

1059
01:10:24,810 --> 01:10:26,850
Eftersom det är allt du behöver för att beskriva en bil,

1060
01:10:26,850 --> 01:10:29,050
du behöver inte ha det i en massa olika ställen.

1061
01:10:29,050 --> 01:10:35,300
Du kan bara hålla den i 1-objekt i JavaScript.

1062
01:10:35,300 --> 01:10:39,090
Som du säkert vet, är iteration en av dessa tråkiga uppgifter.

1063
01:10:39,090 --> 01:10:43,810
Du gör bara det över en igen. Du måste prata med varje föremål i bilen,

1064
01:10:43,810 --> 01:10:47,340
eller du behöver gå igenom varje objekt i en lista eller något liknande.

1065
01:10:47,340 --> 01:10:51,770
Så JavaScript har, likt PHP, en foreach syntax.

1066
01:10:51,770 --> 01:10:54,590
I det här fallet är det en i slinga.

1067
01:10:54,590 --> 01:10:57,300
Du vill använda detta endast på objekt.

1068
01:10:57,300 --> 01:11:01,030
Det finns vissa problem som uppstår om du använder detta på matriser.

1069
01:11:01,030 --> 01:11:03,750
Det är i allmänhet en av de saker, dock är det mycket användbart,

1070
01:11:03,750 --> 01:11:06,590
eftersom du eliminera en hel del overhead

1071
01:11:06,590 --> 01:11:10,270
eftersom du inte behöver dra upp allt i ditt objekt själv.

1072
01:11:10,270 --> 01:11:12,300
Du behöver inte komma ihåg alla viktiga namn.

1073
01:11:12,300 --> 01:11:18,270
Du bara sorts få tillbaka dem i denna syntax.

1074
01:11:18,270 --> 01:11:21,500
I detta, med för, vill du bara komma ihåg

1075
01:11:21,500 --> 01:11:27,180
att du får tillbaka alla nycklar, i ett mycket liknande sätt som hash tabell.

1076
01:11:27,180 --> 01:11:30,880
Om du kommer ihåg från det, när man skulle sätta in en sträng som du kan få ut något

1077
01:11:30,880 --> 01:11:33,840
som skulle ha ett associerat värde med det.

1078
01:11:33,840 --> 01:11:36,360
Vad du kan göra med detta är att du kan säga, okej,

1079
01:11:36,360 --> 01:11:42,120
Jag satt i en bil, och jag kallade det en Ferrari.

1080
01:11:42,120 --> 01:11:45,290
Så du kan sätta i strängen Ferrari igen senare, och du kan få ut det.

1081
01:11:45,290 --> 01:11:50,000
Och du kan göra det i en slinga, med i loopen.

1082
01:11:50,000 --> 01:11:53,320
Så bara mer om objekten. Det viktigaste av detta måste du komma ihåg

1083
01:11:53,320 --> 01:12:00,340
är att du kan använda objektet struct liknande syntax när du vill med dem,

1084
01:12:00,340 --> 01:12:04,590
förutom om vad du ska använda som en sträng är inte ett giltigt variabelnamn.

1085
01:12:04,590 --> 01:12:07,650
Så om du tittar på det där, har vi nyckeln med mellanslag.

1086
01:12:07,650 --> 01:12:12,500
Tja, om du skulle sätta object.key, utrymme, med, utrymme, utrymmen,

1087
01:12:12,500 --> 01:12:15,320
som bara inte skulle vara meningsfullt syntaktiskt.

1088
01:12:15,320 --> 01:12:22,730
Så du bara kan göra det med denna typ av fäste syntax.

1089
01:12:22,730 --> 01:12:26,520
>> Dessutom är JavaScript mycket utrymme-klokt att PHP.

1090
01:12:26,520 --> 01:12:29,050
Du har två sätt att lösa omfattning.

1091
01:12:29,050 --> 01:12:31,960
Du kan inte ha det var framför en variabel,

1092
01:12:31,960 --> 01:12:34,060
och det betyder bara att detta är global.

1093
01:12:34,060 --> 01:12:37,050
Du kan se det från någonstans. Även om du skulle sätta detta i en if-sats,

1094
01:12:37,050 --> 01:12:42,430
någon annanstans i koden efter den punkten att du kunde se att variabeln.

1095
01:12:42,430 --> 01:12:46,730
En annan sak är dock med det var, det är begränsat till vad funktion du befinner dig i.

1096
01:12:46,730 --> 01:12:48,870
Om du inte är i en funktion, ja, det är globalt.

1097
01:12:48,870 --> 01:12:53,900
Men om du är i en funktion är det bara syns i den funktionen.

1098
01:12:53,900 --> 01:12:56,420
Jag har ett exempel, men, ja. Det är en av de saker där

1099
01:12:56,420 --> 01:12:59,900
du kan hantera vilka variabler du vill vara globalt,

1100
01:12:59,900 --> 01:13:03,810
vilka variabler du vill vara lokala, men du måste vara försiktig om det här,

1101
01:13:03,810 --> 01:13:06,890
eftersom du inte har den typen av finkornig kontroll du gör i C,

1102
01:13:06,890 --> 01:13:15,820
där om något deklareras i en for-loop, det kommer att stanna i det för slinga.

1103
01:13:15,820 --> 01:13:18,790
Det vi faktiskt bryr sig om att använda JavaScript för manipulerar webbsidor, eller hur?

1104
01:13:18,790 --> 01:13:21,800
Jag menar, det är därför vi gör det här.

1105
01:13:21,800 --> 01:13:23,840
>> För att göra detta använder vi något som kallas DOM.

1106
01:13:23,840 --> 01:13:25,850
Document Object Model.

1107
01:13:25,850 --> 01:13:29,430
I grund och botten, vad den gör är det tar all din HTML

1108
01:13:29,430 --> 01:13:34,110
och modeller ut den i en massa föremål som är kapslade i varandra.

1109
01:13:34,110 --> 01:13:37,080
Du börjar med något som detta.

1110
01:13:37,080 --> 01:13:44,770
Du har, om rätt för mig, en massa kod där ute som blir liksom -

1111
01:13:44,770 --> 01:13:46,640
Man skulle kunna tro det skulle vara mycket svårt att manipulera,

1112
01:13:46,640 --> 01:13:48,700
eftersom du skulle vara pars igenom en massa text

1113
01:13:48,700 --> 01:13:52,080
och med att pussla isär saker. Och tänk om det inte var korrekt formaterad?

1114
01:13:52,080 --> 01:13:54,880
Dåliga saker skulle hända.

1115
01:13:54,880 --> 01:13:58,140
Så JavaScript tar hand om detta för dig, och du får en fin datastruktur,

1116
01:13:58,140 --> 01:14:01,390
som den på min vänstra, där du bara har ett dokument,

1117
01:14:01,390 --> 01:14:03,530
och inne att du har något som kallas HTML,

1118
01:14:03,530 --> 01:14:05,600
och inne att du har ett huvud och en kropp,

1119
01:14:05,600 --> 01:14:08,420
och inuti det huvudet du har en titel, etcetera, etcetera, etcetera.

1120
01:14:08,420 --> 01:14:11,810
Detta förenklar manipulera en webbsida så att det är bara,

1121
01:14:11,810 --> 01:14:14,190
åh, jag vill bara prata med det här objektet.

1122
01:14:14,190 --> 01:14:21,340
Sortera på ett mycket liknande sätt som du skulle prata med ett annat objekt som du gjort själv.

1123
01:14:21,340 --> 01:14:25,980
Som sagt, allt DOM i dokumentobjektet.

1124
01:14:25,980 --> 01:14:29,290
Antingen är det bara ett ställe och sedan kan du gå i den för att hitta saker,

1125
01:14:29,290 --> 01:14:33,880
och du kan göra det - det är den gamla stilen av att göra det, där uppe,

1126
01:14:33,880 --> 01:14:38,130
där du gör document.getElementById, och sedan namnet,

1127
01:14:38,130 --> 01:14:42,420
och som ni säkert vet, blir det väldigt otymplig efter ett tag.

1128
01:14:42,420 --> 01:14:44,480
Så du kanske inte vill göra det. Det är därför vi har

1129
01:14:44,480 --> 01:14:48,760
nästa sak vi ska prata om efter detta.

1130
01:14:48,760 --> 01:14:52,510
Det viktiga här är att, okej, du har alla dessa element, eller hur?

1131
01:14:52,510 --> 01:14:56,400
Så kanske jag kan ändra färg på något när sidan laddas.

1132
01:14:56,400 --> 01:14:58,380
Så vad? Vad händer om min användare klickar på något?

1133
01:14:58,380 --> 01:15:00,540
Jag vill att det ska göra något intressant när de klickar på något.

1134
01:15:00,540 --> 01:15:02,600
Det är därför vi har händelser.

1135
01:15:02,600 --> 01:15:05,330
Du kan, i princip, hitta alla element i din DOM,

1136
01:15:05,330 --> 01:15:08,560
och sedan säga, hej. När detta läses eller någon klickar på den,

1137
01:15:08,560 --> 01:15:11,410
eller när de musen över den, göra något med den.

1138
01:15:11,410 --> 01:15:15,330
Och det du har är, du har funktioner som hanterar detta åt dig.

1139
01:15:15,330 --> 01:15:17,980
Dessa funktioner är händelsehanterare.

1140
01:15:17,980 --> 01:15:20,440
Vad Dom - det är bara ett finare sätt att säga,

1141
01:15:20,440 --> 01:15:23,500
Denna funktion är endast körs när denna händelse inträffar.

1142
01:15:23,500 --> 01:15:28,070
Så det hanterar händelsen som inträffar.

1143
01:15:28,070 --> 01:15:30,810
Detta är hur du skulle lägga ut en händelsehanterare.

1144
01:15:30,810 --> 01:15:34,750
Jag har lite knapp, och när du klickar på den, exploderar det.

1145
01:15:34,750 --> 01:15:40,560
Så inte klicka på knappen.

1146
01:15:40,560 --> 01:15:42,910
Detta är ett sätt att närma sig det, eller hur?

1147
01:15:42,910 --> 01:15:46,430
Du har en knapp tag, och på klick har du en sträng som säger,

1148
01:15:46,430 --> 01:15:50,460
Åh, förresten, gör jag det exploderande sak för mig.

1149
01:15:50,460 --> 01:15:53,990
Annars är det precis som en vanlig knapp som du just gjorde.

1150
01:15:53,990 --> 01:15:56,550
Du kan också göra det på ett annat sätt,

1151
01:15:56,550 --> 01:16:02,770
genom att ta tag i DOM-elementet, men vi ska spara som när vi talar om jQuery.

1152
01:16:02,770 --> 01:16:07,580
>> JQuery: Det är ett bibliotek som är cross-browser.

1153
01:16:07,580 --> 01:16:09,580
Du kan använda den i stort sett allt.

1154
01:16:09,580 --> 01:16:12,090
Och det bara ger dig en hel del verktyg att arbeta med.

1155
01:16:12,090 --> 01:16:15,850
Eftersom JavaScript, medan kraftfulla, inte har alla verktyg du behöver

1156
01:16:15,850 --> 01:16:20,550
ur lådan för att verkligen ta itu med ett webbprogram som du kanske vill göra.

1157
01:16:20,550 --> 01:16:24,650
Så det förenklar en hel del saker, ger dig en hel del funktioner

1158
01:16:24,650 --> 01:16:28,760
ur lådan som du normalt skulle behöva skriva själv, om och om och om igen.

1159
01:16:28,760 --> 01:16:31,600
Och bara gör saker och ting mycket enklare.

1160
01:16:31,600 --> 01:16:35,780
Du har också väljare, vilket gör att du tar ut alla de element

1161
01:16:35,780 --> 01:16:42,800
från DOM mycket enklare, i stället för att använda dessa mycket långa funktionsanrop.

1162
01:16:42,800 --> 01:16:46,630
Mer om dessa väljare. Du har, där uppe du har, låt oss säga

1163
01:16:46,630 --> 01:16:49,800
Jag vill få ett element med id "rock."

1164
01:16:49,800 --> 01:16:56,450
Tja, i jQuery, det är bara $ och sedan en sträng som har ett halvt kilo, och sedan "rock."

1165
01:16:56,450 --> 01:17:01,960
Det är mycket enkelt och mycket snabbare än den traditionella JavaScript sättet att ta itu med detta problem.

1166
01:17:01,960 --> 01:17:06,120
Och du har liknande saker för klasser och elementtyper.

1167
01:17:06,120 --> 01:17:08,140
jQuery är - en av de häftiga funktioner är att du kan sorts komprimera

1168
01:17:08,140 --> 01:17:14,350
ner dina frågor på ditt DOM väldigt, väldigt snabbt.

1169
01:17:14,350 --> 01:17:18,980
Nu är vi tillbaka till händelsehantering, och det är hur du skulle hantera en händelse i jQuery.

1170
01:17:18,980 --> 01:17:23,090
Så vad vi ska här är vi säger, okej. Jag har en script-tagg, eller hur?

1171
01:17:23,090 --> 01:17:25,400
Så jag har denna inline JavaScript.

1172
01:17:25,400 --> 01:17:27,750
Vad vi ska göra är att vi kommer att säga, okej.

1173
01:17:27,750 --> 01:17:30,860
När dokumentet är färdigt, vilket innebär att dokumentet har laddats,

1174
01:17:30,860 --> 01:17:34,660
vi kommer att gå in på den funktionen, och vi kommer att säga, okej,

1175
01:17:34,660 --> 01:17:37,060
denna funktion är faktiskt att göra något annat.

1176
01:17:37,060 --> 01:17:42,320
Det är i grund och botten säger, okej, ge mig elementet med id "myid."

1177
01:17:42,320 --> 01:17:47,960
Och sedan ge detta en funktion hanterare som körs när du klickar på den.

1178
01:17:47,960 --> 01:17:49,820
I grund och botten vad detta innebär är, den säger, okej.

1179
01:17:49,820 --> 01:17:52,630
Den sidan är laddad, så jag ska in, finner detta element,

1180
01:17:52,630 --> 01:17:56,420
ge den här händelsehanterare, och det i princip sätter upp din sida för dig.

1181
01:17:56,420 --> 01:18:00,520
Och detta är hur du vill tänka på händelsehantering.

1182
01:18:00,520 --> 01:18:06,310
Du vill bara att tänka på, okej, när något inträffar, vad jag vill ska hända?

1183
01:18:06,310 --> 01:18:10,520
Du vill inte att tänka på, okej, jag måste se till att denna sak talar för denna sak,

1184
01:18:10,520 --> 01:18:14,660
denna sak bla bla bla, eftersom du bara vill prata sak när det gäller evenemang.

1185
01:18:14,660 --> 01:18:17,650
När det händer, händer det här. När det händer, händer det.

1186
01:18:17,650 --> 01:18:20,240
Och om saker utlösa andra saker, det är bra.

1187
01:18:20,240 --> 01:18:22,150
Men du vill inte försöka göra komplicerade kod

1188
01:18:22,150 --> 01:18:24,130
där du utlöser flera saker samtidigt,

1189
01:18:24,130 --> 01:18:28,860
eftersom du bara kommer att ge dig själv en huvudvärk.

1190
01:18:28,860 --> 01:18:32,340
>> Okej. Nu kan vi få vår sida att hantera händelser,

1191
01:18:32,340 --> 01:18:35,640
men låt oss säga att min användare klickar på en knapp.

1192
01:18:35,640 --> 01:18:38,040
Vad händer om jag vill skicka begäran tillbaka till servern,

1193
01:18:38,040 --> 01:18:41,100
men jag vill inte ladda om sidan, därför att behöva ladda en ny sida

1194
01:18:41,100 --> 01:18:44,390
varje gång blir typ av tråkiga, och varför behöver jag

1195
01:18:44,390 --> 01:18:47,430
för att dra ner huvudet igen, och sidfoten igen,

1196
01:18:47,430 --> 01:18:49,670
och alla delar av sidan igen

1197
01:18:49,670 --> 01:18:53,180
bara för att uppdatera hälsning eller tiden?

1198
01:18:53,180 --> 01:18:55,290
Så det är därför vi har något som Ajax.

1199
01:18:55,290 --> 01:18:59,150
Det vi kan göra här med Ajax är att vi kan säga, okej,

1200
01:18:59,150 --> 01:19:01,290
Jag vill skicka några data till servern,

1201
01:19:01,290 --> 01:19:04,010
och jag vill få ett svar tillbaka så jag kan uppdatera min sida,

1202
01:19:04,010 --> 01:19:12,120
eller kanske bara göra några algoritmberäkning som inte nödvändigtvis visa något för användaren.

1203
01:19:12,120 --> 01:19:15,500
Vad behöver du för att göra detta? Tja, du behöver en webbadress som du behöver prata med.

1204
01:19:15,500 --> 01:19:18,650
Din server kan inte bara magiskt lyssna in från ingenstans.

1205
01:19:18,650 --> 01:19:21,960
Du måste ha en viss plats du skickar dessa data till.

1206
01:19:21,960 --> 01:19:26,240
Och du behöver också en del data att skicka, eller kanske är det en utan lokala data-fråga.

1207
01:19:26,240 --> 01:19:31,380
Du vill bara att pinga tillbaka till servern och säga hej, jag lever, eller något liknande.

1208
01:19:31,380 --> 01:19:35,150
Och då du vill ha en funktion som i princip hanterar med framgång.

1209
01:19:35,150 --> 01:19:38,250
Låt oss säga att du får tillbaka en del information från din server,

1210
01:19:38,250 --> 01:19:42,960
och du vill ändra användarens titel på sin sida.

1211
01:19:42,960 --> 01:19:44,930
Så du skulle få tillbaka informationen,

1212
01:19:44,930 --> 01:19:48,860
och du skulle driva det till skärmen.

1213
01:19:48,860 --> 01:19:51,170
Vad som händer är, när sidan är klar,

1214
01:19:51,170 --> 01:19:56,500
du skapar en på klickfunktion för den här knappen som heter Greeter.

1215
01:19:56,500 --> 01:19:58,810
Vad detta sedan innebär är, när den knappen trycks,

1216
01:19:58,810 --> 01:20:03,700
du pratar med greetings.php, du gör en förfrågan POST,

1217
01:20:03,700 --> 01:20:07,290
och du säger, hej, ge mig något från din sida.

1218
01:20:07,290 --> 01:20:09,890
Vi behöver egentligen inte att beskriva det, men greetings.php,

1219
01:20:09,890 --> 01:20:12,480
låt oss bara säga, ger tillbaka "hej världen."

1220
01:20:12,480 --> 01:20:15,650
Så vi får tillbaka denna "Hello World", och på framgången av detta,

1221
01:20:15,650 --> 01:20:20,730
antar ingenting går fel, då vi bara gå till detta mål plats

1222
01:20:20,730 --> 01:20:25,720
att vi specificerade och vi bara hålla svaret där.

1223
01:20:25,720 --> 01:20:31,560
Och detta är ett mycket enkelt sätt att skapa en Ajax-fråga.

1224
01:20:31,560 --> 01:20:34,340
>> Mycket snabbt, Rob slags nämnde detta redan,

1225
01:20:34,340 --> 01:20:37,170
saker kan gå fel, kan dåliga saker hända,

1226
01:20:37,170 --> 01:20:42,660
så du vill bekanta dig med dessa HTTP-svarskoder.

1227
01:20:42,660 --> 01:20:46,030
Vilka dessa är är precis, som, 200, allt gick okej.

1228
01:20:46,030 --> 01:20:48,670
Något annat, hände dåliga saker.

1229
01:20:48,670 --> 01:20:50,790
Det är i allmänhet den sak som du vill komma ihåg.

1230
01:20:50,790 --> 01:20:53,440
Men det är skönt att veta alla dessa.

1231
01:20:53,440 --> 01:20:55,970
Och slutligen, när vi har gått igenom allt detta,

1232
01:20:55,970 --> 01:20:58,680
vi behöver prata mycket snabbt om design,

1233
01:20:58,680 --> 01:21:00,620
och då kan vi låta dig alla lämnar.

1234
01:21:00,620 --> 01:21:03,410
Design. Saker som du vill komma ihåg.

1235
01:21:03,410 --> 01:21:06,950
Ställ dig följande frågor: Vem kommer att använda det här?

1236
01:21:06,950 --> 01:21:09,580
Vad kommer de att använda det till? Vad gör mina användare bryr sig om?

1237
01:21:09,580 --> 01:21:11,750
Vad de inte bryr sig om?

1238
01:21:11,750 --> 01:21:14,500
Du vill bara inte att göra en app och låt det bara växa

1239
01:21:14,500 --> 01:21:18,270
och bli denna jätte, allt krävande sak som du inte ens kan avsluta.

1240
01:21:18,270 --> 01:21:23,900
Du vill ha diskreta mål och planer och saker du vill ta upp.

1241
01:21:23,900 --> 01:21:29,000
Gör det enkelt. Allt detta står i grund och botten

1242
01:21:29,000 --> 01:21:34,950
gör det enkelt för användaren att använda det, inte göra det till en jätte klump text som den här bilden är, faktiskt.

1243
01:21:34,950 --> 01:21:38,020
Du vill bara att det ska vara något där det är väldigt lätt för någon att gå in

1244
01:21:38,020 --> 01:21:40,800
och göra vad de vill göra.

1245
01:21:40,800 --> 01:21:42,920
Du vill inte att de ska behöva navigera 5 sidor

1246
01:21:42,920 --> 01:21:45,460
att komma till din främsta funktion på din webbplats.

1247
01:21:45,460 --> 01:21:49,290
Om Google hade 5 sidor innan du kan även söka något,

1248
01:21:49,290 --> 01:21:53,080
ingen skulle använda den.

1249
01:21:53,080 --> 01:21:55,890
Och slutligen, pappersprototyp, fokusgrupp.

1250
01:21:55,890 --> 01:21:59,220
Ha god design och testmetoder.

1251
01:21:59,220 --> 01:22:00,730
Bara för att du tror att det fungerar för dig,

1252
01:22:00,730 --> 01:22:04,860
betyder inte att någon annan tycker det fungerar.

1253
01:22:04,860 --> 01:22:14,490
Men ja, det är det.

1254
01:22:14,490 --> 01:22:17,490
[CS50.TV]