1
00:00:00,000 --> 00:00:08,070

2
00:00:08,070 --> 00:00:10,430
>> R.J.阿基諾：讓剛上手。

3
00:00:10,430 --> 00:00:12,310
因此，這是測驗1。

4
00:00:12,310 --> 00:00:14,890
下面是一些高層次的信息。

5
00:00:14,890 --> 00:00:19,915
在關於頁面的測驗是在這個
的URL，不再CS50.net，儘管這

6
00:00:19,915 --> 00:00:21,080
仍然可以工作。

7
00:00:21,080 --> 00:00:26,920
這是CS50.harvard.edu/quizzes/2013/1。

8
00:00:26,920 --> 00:00:31,070
這是很大的關於頁面，告訴你
何時何地，也就是下週三

9
00:00:31,070 --> 00:00:32,100
在一堆室。

10
00:00:32,100 --> 00:00:36,120
並通過下週三，我
意味著從現在開始兩天。

11
00:00:36,120 --> 00:00:37,890
所有這些信息是存在的。

12
00:00:37,890 --> 00:00:39,110
但它是累積的。

13
00:00:39,110 --> 00:00:43,790
>> 所以一切從第一的一半
今年是潛在的測驗，

14
00:00:43,790 --> 00:00:50,780
因為你不能真正做到先進
事情在C無，如果條​​件和

15
00:00:50,780 --> 00:00:51,920
for循環等。

16
00:00:51,920 --> 00:00:55,580
但會有一重
材料，因為測驗0覆蓋，

17
00:00:55,580 --> 00:00:59,570
首先是結構和文件
I / O。這是典型的多

18
00:00:59,570 --> 00:01:01,620
比測驗0有挑戰性。

19
00:01:01,620 --> 00:01:03,870
平均得分通常較低。

20
00:01:03,870 --> 00:01:05,980
努力學習。

21
00:01:05,980 --> 00:01:09,340
>> 當你在學習時，一定要使用
CS50/discuss張貼您的問題

22
00:01:09,340 --> 00:01:10,830
和閱讀其他人的問題。

23
00:01:10,830 --> 00:01:13,550
所以，如果你沒有任何問題，
登錄並閱讀

24
00:01:13,550 --> 00:01:14,580
您的朋友的問題。

25
00:01:14,580 --> 00:01:16,560
他們很可能好問題。

26
00:01:16,560 --> 00:01:17,730
並採取實踐測驗。

27
00:01:17,730 --> 00:01:20,750
我們已經給測驗的
七八年了。

28
00:01:20,750 --> 00:01:22,180
他們在網上的所有。

29
00:01:22,180 --> 00:01:25,540
未來的問題是相似的
老問題。

30
00:01:25,540 --> 00:01:26,550
這就是我們如何讓他們。

31
00:01:26,550 --> 00:01:27,740
>> 測驗還不存在。

32
00:01:27,740 --> 00:01:28,670
我們沒有看到它。

33
00:01:28,670 --> 00:01:32,496
但它看起來像
以前的測驗。

34
00:01:32,496 --> 00:01:36,500
對於這種審查會議，這是不
專題的詳盡清單。

35
00:01:36,500 --> 00:01:40,740
你不能只是出席本，然後
是完全準備好測驗。

36
00:01:40,740 --> 00:01:43,330
否則，它不會是
太大的測驗。

37
00:01:43,330 --> 00:01:46,270
這也是不一定
你需要知道的任何一切

38
00:01:46,270 --> 00:01:46,970
給定的主題。

39
00:01:46,970 --> 00:01:50,520
它的意思是暴露你的東西
我們已經介紹了，提醒你我們

40
00:01:50,520 --> 00:01:53,070
覆蓋，並在途中
我們覆蓋它。

41
00:01:53,070 --> 00:01:57,030
但是你將不得不更進一步，
更深層次的，當你學習到仔細檢查

42
00:01:57,030 --> 00:02:00,230
你知道一切關於任何給定的
主題，你已經填寫

43
00:02:00,230 --> 00:02:03,320
一切是那樣的角落
涵蓋講座。

44
00:02:03,320 --> 00:02:07,980
>> 測驗筆記告訴你去
抄寫筆記，觀看講座視頻。

45
00:02:07,980 --> 00:02:10,155
這是一個很好的方式，以確保你已經
涵蓋了所有你的基地。

46
00:02:10,155 --> 00:02:12,670

47
00:02:12,670 --> 00:02:17,340
所以起步，當我做這些
幻燈片中，我試圖把在那裡我發現

48
00:02:17,340 --> 00:02:18,350
信息。

49
00:02:18,350 --> 00:02:22,890
因此，對於文件I / O，例如，第7週，
週一的演講和張貼

50
00:02:22,890 --> 00:02:27,960
第6條和習題集都有
有關文件信息的I / O。我已經做了

51
00:02:27,960 --> 00:02:28,840
這對每一個議題。

52
00:02:28,840 --> 00:02:33,010
因此，那些標題幻燈片可能
對你有所幫助。

53
00:02:33,010 --> 00:02:38,950
>> 所以在這裡我們有文件I / O。請記住，在
習題集5，我們使用的fopen，fclose的，

54
00:02:38,950 --> 00:02:41,210
FWRITE，用fread和fseek的。

55
00:02:41,210 --> 00:02:48,090
經回收30ish JPEG和
經調整大小和混亂

56
00:02:48,090 --> 00:02:50,320
位圖，你應該很熟悉
這些功能

57
00:02:50,320 --> 00:02:51,830
以及它們如何工作。

58
00:02:51,830 --> 00:02:54,420
如果你不再熟悉，
絕對檢討。

59
00:02:54,420 --> 00:02:56,860
並確保您了解什麼
不同的論點是，

60
00:02:56,860 --> 00:02:58,260
當他們使用。

61
00:02:58,260 --> 00:03:03,620
>> 但共同文件相關的錯誤
你可能會問 - 

62
00:03:03,620 --> 00:03:07,270
好吧，如果你忘了檢查
FOPEN實際工作之前，你去

63
00:03:07,270 --> 00:03:08,350
修改文件。

64
00:03:08,350 --> 00:03:09,760
這可能是壞的。

65
00:03:09,760 --> 00:03:13,560
如果你忘了FCLOSE文件
你已經fopened，這是類似於

66
00:03:13,560 --> 00:03:14,400
內存洩漏。

67
00:03:14,400 --> 00:03:15,980
這是非常糟糕的。

68
00:03:15,980 --> 00:03:18,670
而忘記檢查，如果你已經
之前你到達了文件的末尾

69
00:03:18,670 --> 00:03:19,790
開始寫吧。

70
00:03:19,790 --> 00:03:22,320
>> 所以，如果你說，嘿，我在
該文件的末尾。

71
00:03:22,320 --> 00:03:23,750
給我5個字節。

72
00:03:23,750 --> 00:03:27,370
嗯，這可能不會
計算出你所期望的方式。

73
00:03:27,370 --> 00:03:30,930
這真的是對文件I / O，
因為我們做了這麼多了

74
00:03:30,930 --> 00:03:32,300
這個問題設定。

75
00:03:32,300 --> 00:03:36,000
所以，如果你明白發生了什麼事情
在習題集5，記得bitmats

76
00:03:36,000 --> 00:03:40,090
和JPEG文件，那麼你很可能所有
為文件設置I / O。如果這是一個有點

77
00:03:40,090 --> 00:03:44,770
模糊，進行檢討這個問題
置和相關材料。

78
00:03:44,770 --> 00:03:51,110
>> 結構都認為是對的話題
0測驗測驗和1之間的線。

79
00:03:51,110 --> 00:03:53,090
並沒有引起太大的削減測驗0。

80
00:03:53,090 --> 00:03:57,040
所以他們一定會放在
測驗1，第7週，週一。

81
00:03:57,040 --> 00:03:58,150
什麼是結構？

82
00:03:58,150 --> 00:04:00,250
這裡我們給出一個結構。

83
00:04:00,250 --> 00:04:03,140
這就像一個新類型。

84
00:04:03,140 --> 00:04:07,940
這就像一個容器
為多個字段。

85
00:04:07,940 --> 00:04:12,970
>> 在這種情況下，我們聲明一個struct
學生有兩個字段 - 

86
00:04:12,970 --> 00:04:17,750
我們正在調用一個字符串名稱和
我們正在調用的年齡為int。

87
00:04:17,750 --> 00:04:21,450
所以，當我通過各地的學生​​或I
修改學生，我就可以

88
00:04:21,450 --> 00:04:24,430
訪問他們的名字和他們的年齡。

89
00:04:24,430 --> 00:04:26,670
讓我們來看看一些代碼的。

90
00:04:26,670 --> 00:04:29,090
在這裡，我們可以看到，我已經聲明
一個學生的，就像

91
00:04:29,090 --> 00:04:30,300
我聲明任何變量 - 

92
00:04:30,300 --> 00:04:32,430
詮釋十，詮釋y，等等。

93
00:04:32,430 --> 00:04:34,180
>> 這裡的學生的。

94
00:04:34,180 --> 00:04:37,370
他開始沒有在他的領域。

95
00:04:37,370 --> 00:04:38,240
因此，讓我們設置它們。

96
00:04:38,240 --> 00:04:40,681
你設置點一個struct的領域。

97
00:04:40,681 --> 00:04:43,780
所以，我在這裡說s.name = RJ。

98
00:04:43,780 --> 00:04:46,470
和s.age = 21。

99
00:04:46,470 --> 00:04:48,500
您也可以更新字段
你會更新以同樣的方式

100
00:04:48,500 --> 00:04:49,550
一個變量的值。

101
00:04:49,550 --> 00:04:53,270
所以我想從RJ改變我的名字與
無期限至R.J.拼寫

102
00:04:53,270 --> 00:04:54,540
正確的做法。

103
00:04:54,540 --> 00:04:58,890
這將是s.name = RJ，同樣
正如我們所說的它最初。

104
00:04:58,890 --> 00:05:00,030
然後你就可以訪問它們。

105
00:05:00,030 --> 00:05:00,930
>> 因此，我們已經設置它們。

106
00:05:00,930 --> 00:05:01,840
我們已經更新了他們。

107
00:05:01,840 --> 00:05:03,890
您也可以訪問它們
在非常相同的方式。

108
00:05:03,890 --> 00:05:09,330
所以在這裡，我打印出
R.J.是21歲。

109
00:05:09,330 --> 00:05:14,700
而且我訪問這些值
與s.name和s.age。

110
00:05:14,700 --> 00:05:17,040
所以這存取結構
用點符號。

111
00:05:17,040 --> 00:05:17,850
是的，問題嗎？

112
00:05:17,850 --> 00:05:21,176
>> 觀眾：有沒有對一個原因
前一張幻燈片，你沒有把

113
00:05:21,176 --> 00:05:24,848
學生在頂行，像的typedef
結構的學生，然後

114
00:05:24,848 --> 00:05:25,840
學生在結束了嗎？

115
00:05:25,840 --> 00:05:29,040
>> R.J.阿基諾：所以現在的問題是，在
這張幻燈片，我們通常看到的

116
00:05:29,040 --> 00:05:32,400
typedef結構節點，然後
該結構的字段和

117
00:05:32,400 --> 00:05:34,250
然後字節點。

118
00:05:34,250 --> 00:05:37,790
以及如何來到這裡我就不說了，的typedef
結構的學生，然後

119
00:05:37,790 --> 00:05:39,820
的結構，然後學生的領域？

120
00:05:39,820 --> 00:05:44,310
原因是，我不需要
該結構的內部訪問它。

121
00:05:44,310 --> 00:05:46,270
所以，它的確定要離開它沒有名字。

122
00:05:46,270 --> 00:05:49,210
我只能把它作為
匿名結構。

123
00:05:49,210 --> 00:05:53,130
>> 我們這樣做是對鍊錶和原因
事情是因為你內心需要

124
00:05:53,130 --> 00:05:55,360
引用一個結構節點明星。

125
00:05:55,360 --> 00:05:58,220
因此，該結構必須有一個名字，
所以你以後可以訪問它。

126
00:05:58,220 --> 00:05:59,540
這是一個小細節。

127
00:05:59,540 --> 00:06:04,750
但你通常會看到typedef結構
大括號，如果你不需要

128
00:06:04,750 --> 00:06:08,720
的名稱和typedef結構部分名稱
其次是大括號，如果你願意

129
00:06:08,720 --> 00:06:09,520
所需要的名字。

130
00:06:09,520 --> 00:06:12,070
所以這是一個很好的問題。

131
00:06:12,070 --> 00:06:17,000
>> 而在這一點上，我們傾向於修改
結構，並通過周圍結構由

132
00:06:17,000 --> 00:06:18,680
引用，而不是價值。

133
00:06:18,680 --> 00:06:21,940
所以我們只指針傳遞給周圍
結構，而不是在繞過

134
00:06:21,940 --> 00:06:23,150
結構本身。

135
00:06:23,150 --> 00:06:28,050
所以你很頻繁將是
使用，在這種情況下，學生*或

136
00:06:28,050 --> 00:06:34,150
結構*節點或節點，而不是*
培養出來的學生或節點。

137
00:06:34,150 --> 00:06:39,350
所以在這裡，我已經說過了，OK，變量PTR
將是s的地址。

138
00:06:39,350 --> 00:06:45,570
這將是指針
向學生R.J.

139
00:06:45,570 --> 00:06:48,965
>> 因此，我們可以在這些領域得到
因為我們得到什麼一樣。

140
00:06:48,965 --> 00:06:51,460
首先，身份證引用指針
得到的結構。

141
00:06:51,460 --> 00:06:55,530
這就是* PTR，然後
一個點和年齡。

142
00:06:55,530 --> 00:06:58,790
因此，要訪問字段，我已經更新
現在到22，因為，讓我們

143
00:06:58,790 --> 00:07:00,860
說，這是我的生日。

144
00:07:00,860 --> 00:07:03,990
有一個快捷方式語法
這裡使用的箭頭。

145
00:07:03,990 --> 00:07:07,060
所以PTR箭頭年齡只是
一樣* ptr.age。

146
00:07:07,060 --> 00:07:10,150

147
00:07:10,150 --> 00:07:11,550
現在，這件事情你必須
背誦和記憶。

148
00:07:11,550 --> 00:07:15,010
>> 你用了很多的pset6，
在拼寫檢查pset中。

149
00:07:15,010 --> 00:07:18,350
但其實這是怎麼回事
在發動機罩的下面。

150
00:07:18,350 --> 00:07:20,500
它取消引用指針
然後訪問它。

151
00:07:20,500 --> 00:07:21,432
問題？

152
00:07:21,432 --> 00:07:22,682
>> 觀眾：[聽不清]。

153
00:07:22,682 --> 00:07:25,860

154
00:07:25,860 --> 00:07:28,060
>> R.J.阿基諾：那麼，為什麼我們使用
指針作為結構代替

155
00:07:28,060 --> 00:07:29,500
結構本身？

156
00:07:29,500 --> 00:07:33,740
究其原因是，如果你傳遞
一個結構體給一個函數，你可能

157
00:07:33,740 --> 00:07:36,900
要繞過只是4左右
表示指針的字節，作為

158
00:07:36,900 --> 00:07:40,375
相對於潛在的30或
40字節屬於結構。

159
00:07:40,375 --> 00:07:44,410
所以傳遞的東西給一個函數
是容易當的東西

160
00:07:44,410 --> 00:07:48,230
在短較小。

161
00:07:48,230 --> 00:07:49,074
問題？

162
00:07:49,074 --> 00:07:53,026
>> 觀眾：你可能會提到這
在開始的時候，但在那裡

163
00:07:53,026 --> 00:07:56,000
其他幻燈片上[聽不清]？

164
00:07:56,000 --> 00:07:58,960
>> R.J.阿基諾：這些幻燈片將
了審查會議之後。

165
00:07:58,960 --> 00:08:00,210
我們將張貼在網站上。

166
00:08:00,210 --> 00:08:02,450

167
00:08:02,450 --> 00:08:06,870
因此，在移動和移動上略有
快，我們要談的數據

168
00:08:06,870 --> 00:08:07,350
結構。

169
00:08:07,350 --> 00:08:08,040
也有很多。

170
00:08:08,040 --> 00:08:10,080
我們覆蓋的一群人。

171
00:08:10,080 --> 00:08:12,500
這裡是你應該了解
關於數據結構。

172
00:08:12,500 --> 00:08:15,590
>> 你應該明白在一個較高的
每級結構是什麼。

173
00:08:15,590 --> 00:08:21,190
你可以用英語解釋給你
這並沒有採取CS50朋友如何

174
00:08:21,190 --> 00:08:25,580
我們組織我們的數據，以及我們為什麼會
可以使用的東西以這種方式？

175
00:08:25,580 --> 00:08:26,990
這就是事情之一。

176
00:08:26,990 --> 00:08:29,650
東西兩，理解
的實施。

177
00:08:29,650 --> 00:08:34,270
因此，了解如何使用這些東西
在C中，我們會去在這。

178
00:08:34,270 --> 00:08:39,030
>> 然後三件事會被知道
運行時間和的局限性

179
00:08:39,030 --> 00:08:40,470
你使用各種結構。

180
00:08:40,470 --> 00:08:44,059
所以，理解你為什麼會用
哈希表，而不是一個數組。

181
00:08:44,059 --> 00:08:49,570
了解如何快速，平均而言，
訪問一個哈希表。

182
00:08:49,570 --> 00:08:54,010
了解操作速度快什麼
鍊錶但對數組慢，

183
00:08:54,010 --> 00:08:56,080
反之亦然。

184
00:08:56,080 --> 00:08:59,780
因此，要理解這一點，你就必須
了解大O符號只知道

185
00:08:59,780 --> 00:09:01,310
如何談論這些
各種各樣的東西。

186
00:09:01,310 --> 00:09:02,700
我們會談論。

187
00:09:02,700 --> 00:09:06,040
>> 所以第一件事情，鍊錶。

188
00:09:06,040 --> 00:09:07,770
這裡是一個高層次的圖像
的一個鍊錶。

189
00:09:07,770 --> 00:09:08,830
我們發現這在課堂上。

190
00:09:08,830 --> 00:09:11,670
我們通常有10人
站在舞台上。

191
00:09:11,670 --> 00:09:16,790
但我們有一系列節點，其中每個
節點有一定的價值和指針

192
00:09:16,790 --> 00:09:18,610
它的下一個值。

193
00:09:18,610 --> 00:09:21,730
因此，為了從一個節點到下一個，你
只是說，給我的下一個節點。

194
00:09:21,730 --> 00:09:22,530
您有節點。

195
00:09:22,530 --> 00:09:23,770
給我的下一個節點。

196
00:09:23,770 --> 00:09:24,400
您有節點。

197
00:09:24,400 --> 00:09:28,790
給我的下一個節點等
直到沒有節點的左邊。

198
00:09:28,790 --> 00:09:31,850
>> 所以繼續談
它在一個較高的水平。

199
00:09:31,850 --> 00:09:34,100
這是很容易插入的東西
成一個鍊錶。

200
00:09:34,100 --> 00:09:36,010
如果你不關心順序，
你能把它

201
00:09:36,010 --> 00:09:36,840
權利開頭。

202
00:09:36,840 --> 00:09:38,520
這是恆定的時間。

203
00:09:38,520 --> 00:09:39,900
但很難找到一個值。

204
00:09:39,900 --> 00:09:43,060
如果你要問，
是在我的名單7？

205
00:09:43,060 --> 00:09:44,740
你必須要經過
每一個值。

206
00:09:44,740 --> 00:09:45,680
這是7？

207
00:09:45,680 --> 00:09:46,610
這是7？

208
00:09:46,610 --> 00:09:47,770
這是7？

209
00:09:47,770 --> 00:09:48,690
這是7？

210
00:09:48,690 --> 00:09:49,830
一遍又一遍。

211
00:09:49,830 --> 00:09:51,520
這就是為O（n）。

212
00:09:51,520 --> 00:09:53,800
因此，研究在答題時，
使用數組進行比較。

213
00:09:53,800 --> 00:09:57,010

214
00:09:57,010 --> 00:09:58,220
>> 這樣可以嗎？

215
00:09:58,220 --> 00:09:59,220
燈滅暗淡​​。

216
00:09:59,220 --> 00:10:01,110
確定。

217
00:10:01,110 --> 00:10:02,400
當是一個鍊錶更好？

218
00:10:02,400 --> 00:10:04,640
如果是一個數組更好？

219
00:10:04,640 --> 00:10:06,670
因此，讓我們來看看一些代碼。

220
00:10:06,670 --> 00:10:08,960
這裡是一個可能的節點。

221
00:10:08,960 --> 00:10:09,770
這是一個結構。

222
00:10:09,770 --> 00:10:12,220
它有一個int n，它
將是我們的價值。

223
00:10:12,220 --> 00:10:17,780
它有一個結構節點*未來，這
是我們的指針到下一個節點。

224
00:10:17,780 --> 00:10:23,040
所以在這裡，我們可以看到，我們發生了
已經把一個int在我們的節點。

225
00:10:23,040 --> 00:10:27,850
但如果這是字符的鍊錶
星或漂浮的鍊錶，我們

226
00:10:27,850 --> 00:10:28,820
完全可以做到這一點。

227
00:10:28,820 --> 00:10:33,110
>> 記得在pset6，你可能有一個
焦炭星或只是鍊錶

228
00:10:33,110 --> 00:10:34,360
靜態字符數組。

229
00:10:34,360 --> 00:10:37,370

230
00:10:37,370 --> 00:10:39,040
讓我們來看看在這裡的操作。

231
00:10:39,040 --> 00:10:43,570
因此，我們要插入一個新的
n為進我們的鍊錶。

232
00:10:43,570 --> 00:10:48,940
我們有一個頭指針是開始了
一個指向該節點具有

233
00:10:48,940 --> 00:10:53,460
的n值和一個下一個指針的那
指向這個節點是一個值

234
00:10:53,460 --> 00:10:57,760
n和下一個空的，因為
它的最後一個節點。

235
00:10:57,760 --> 00:11:00,440
因此，在時間的關係，我會
把所有的代碼在屏幕上。

236
00:11:00,440 --> 00:11:03,130
我們將通過它走
幾行的時間。

237
00:11:03,130 --> 00:11:05,790
>> 因此，這裡的代碼。

238
00:11:05,790 --> 00:11:07,560
我希望它是可讀的。

239
00:11:07,560 --> 00:11:11,275
我們做的第一件事是
我們用malloc一個新的節點。

240
00:11:11,275 --> 00:11:15,105
因此，它使一個指針到一個新的節點
不太有什麼設置

241
00:11:15,105 --> 00:11:16,450
在它。

242
00:11:16,450 --> 00:11:19,580
我們檢查，以確保
新節點不為null。

243
00:11:19,580 --> 00:11:22,220
否則，我們不得不放棄。

244
00:11:22,220 --> 00:11:27,680
因此，檢查了這一點，我們現在
在節點中設置的值。

245
00:11:27,680 --> 00:11:31,520
所以我們把新的N到我們的n場。

246
00:11:31,520 --> 00:11:36,050
我們設置下一個指針指向
原來的頭，這樣我們就可以

247
00:11:36,050 --> 00:11:38,900
現在已插入此
節點進入我們的名單。

248
00:11:38,900 --> 00:11:44,600
>> 最後，我們有全球主管點
我們的新節點，所以，如果我們要

249
00:11:44,600 --> 00:11:50,300
在開始的頭，我們將在此
新的第一個節點，而不是

250
00:11:50,300 --> 00:11:51,560
舊的第一個節點。

251
00:11:51,560 --> 00:11:55,320
當這個函數退出時，
變量新的節點不再存在，

252
00:11:55,320 --> 00:11:57,130
因為它是本地的功能。

253
00:11:57,130 --> 00:11:59,770
因此，這是世界的狀態。

254
00:11:59,770 --> 00:12:03,570
我們的全球頭指向我們的新
第一結點，它指向了

255
00:12:03,570 --> 00:12:06,346
原來的第一個節點，這點
到後，該節點。

256
00:12:06,346 --> 00:12:09,790
>> 這是插入。

257
00:12:09,790 --> 00:12:12,150
我希望這是相對
簡單的跟隨。

258
00:12:12,150 --> 00:12:14,300
如有疑問，畫一幅畫。

259
00:12:14,300 --> 00:12:17,820
所以，我覺得談論
鍊錶和看

260
00:12:17,820 --> 00:12:19,870
代碼是非常無益的。

261
00:12:19,870 --> 00:12:23,790
而在尋找的鏈接圖片
列表可以讓我覺得，哦，所以

262
00:12:23,790 --> 00:12:24,970
我有這個節點在這裡。

263
00:12:24,970 --> 00:12:28,980
但是，如果我更新指針，
它結束了斷開。

264
00:12:28,980 --> 00:12:34,340
我已經忘了在那裡
節點去。

265
00:12:34,340 --> 00:12:35,390
和代碼退出。

266
00:12:35,390 --> 00:12:37,830
和你有多個節點
被斷開。

267
00:12:37,830 --> 00:12:39,970
而你不結了
你想要的名單。

268
00:12:39,970 --> 00:12:43,320
>> 所以，如果你畫的圖畫和做
一步一步，希望，你會看到

269
00:12:43,320 --> 00:12:46,840
事情來講的正確順序
更新指針，以確保

270
00:12:46,840 --> 00:12:48,830
該列表走到一起。

271
00:12:48,830 --> 00:12:51,240
插入相對比較簡單。

272
00:12:51,240 --> 00:12:55,210
更複雜的是
插入到排序的列表。

273
00:12:55,210 --> 00:12:59,980
一個更複雜的功能是刪除
和發現，所以期待通過列表

274
00:12:59,980 --> 00:13:03,030
看看是否有出現。

275
00:13:03,030 --> 00:13:07,220
也許你在pset6這樣做，當你
鑽進你的哈希表和你說了，

276
00:13:07,220 --> 00:13:10,460
好，這個詞的蘋果
在我的鏈接列表？

277
00:13:10,460 --> 00:13:11,440
>> 所以，你可能已經做到了這一點。

278
00:13:11,440 --> 00:13:15,530
但可以肯定，刷新你的記憶
並嘗試重新實現查找和

279
00:13:15,530 --> 00:13:19,150
重寫刪除一個鍊錶。

280
00:13:19,150 --> 00:13:22,850
有趣的旁注，也有雙重鏈接
列表，在那裡你必須

281
00:13:22,850 --> 00:13:27,490
指向正向和指針
落後的，這樣你可以去

282
00:13:27,490 --> 00:13:29,270
下一個節點，並以前面的節點。

283
00:13:29,270 --> 00:13:33,860
而且是在去年的一個問題
測驗該類型的，會說話

284
00:13:33,860 --> 00:13:36,190
關於雙鍊錶。

285
00:13:36,190 --> 00:13:40,070
>> 現在，這是你的結構
比較熟悉的，因為大多數

286
00:13:40,070 --> 00:13:42,520
你可能使用它們pset6。

287
00:13:42,520 --> 00:13:45,680
這裡有一個有點不太熟悉。

288
00:13:45,680 --> 00:13:51,020
作為一個方面說明，我認為測驗1
主要測驗比0更難，因為

289
00:13:51,020 --> 00:13:54,600
你在做什麼，你的東西
沒有做一樣多。

290
00:13:54,600 --> 00:13:58,100
把那個另一種方式，對於測驗0，
你已經寫了很多C的我們

291
00:13:58,100 --> 00:13:58,880
問你下

292
00:13:58,880 --> 00:14:02,310
>> 對於測驗1，我們要問你
PHP和JavaScript，您

293
00:14:02,310 --> 00:14:03,490
沒有寫一樣的。

294
00:14:03,490 --> 00:14:07,590
我們要問你的C代碼的
你還沒有寫成多少，

295
00:14:07,590 --> 00:14:09,130
這個先進的C的東西。

296
00:14:09,130 --> 00:14:11,520
所以肯定，實踐的東西，我們
演講中談到，你

297
00:14:11,520 --> 00:14:15,260
並不一定做
關於這個問題集。

298
00:14:15,260 --> 00:14:17,870
>> 說到這，你有沒有寫
一個堆棧上的一個問題集。

299
00:14:17,870 --> 00:14:19,610
但它是在課堂上。

300
00:14:19,610 --> 00:14:22,530
這裡有一個高層次的畫面
棧，我們表明，每年。

301
00:14:22,530 --> 00:14:26,180
它的托盤堆疊中
在奧美食堂。

302
00:14:26,180 --> 00:14:30,570
在較高的水平，棧是最後的
入先出的數據結構。

303
00:14:30,570 --> 00:14:32,040
這意味著你要去
把東西 - 

304
00:14:32,040 --> 00:14:36,400
1，3，7，12，14，負0。

305
00:14:36,400 --> 00:14:39,180
有一件事我不能有
說 - 負3，0。

306
00:14:39,180 --> 00:14:40,250
你把所有這些東西英寸

307
00:14:40,250 --> 00:14:42,940
，最後一個你把是第一
一個的走出來。

308
00:14:42,940 --> 00:14:44,170
>> 所以，你有兩個操作 - 

309
00:14:44,170 --> 00:14:45,260
壓入和彈出。

310
00:14:45,260 --> 00:14:49,180
所有投入，我是
手勢像這樣的推動。

311
00:14:49,180 --> 00:14:52,020
然後當我在搶達到
東西或頂部到達搶

312
00:14:52,020 --> 00:14:53,940
什麼東西，這就是流行。

313
00:14:53,940 --> 00:14:55,540
所以，我們要實現堆棧。

314
00:14:55,540 --> 00:14:57,870
而且我們發現他們在講座
使用數組。

315
00:14:57,870 --> 00:14:59,550
但你可以做他們
使用鍊錶。

316
00:14:59,550 --> 00:15:01,770
棧是一種概念上的數據
結構，不喜歡的

317
00:15:01,770 --> 00:15:03,760
特定實現的。

318
00:15:03,760 --> 00:15:06,420
>> 那麼，什麼將是什麼樣子？

319
00:15:06,420 --> 00:15:07,970
它看起來有點像這樣。

320
00:15:07,970 --> 00:15:10,840
你必須為整數的大小。

321
00:15:10,840 --> 00:15:16,000
而且你已經有了值的數組
我們調用托盤，因為這是

322
00:15:16,000 --> 00:15:18,570
圖片是什麼
我們 -  INT托盤 - 

323
00:15:18,570 --> 00:15:21,740
然後一些最大容量。

324
00:15:21,740 --> 00:15:27,100
那麼，什麼將推動樣子？

325
00:15:27,100 --> 00:15:33,250
那麼，如果我們有一個堆棧s，則推
東西到的，相信我們會得到

326
00:15:33,250 --> 00:15:34,620
s的大小。

327
00:15:34,620 --> 00:15:42,270
而這將是下一個
我們的數組的空位。

328
00:15:42,270 --> 00:15:50,510
所以，如果我們有三個東西在我們的協議棧，
然後盤3將是下一個

329
00:15:50,510 --> 00:15:54,290
開放的現場，因為0，1，和
2頃已經填滿。

330
00:15:54,290 --> 00:16:01,790
>> 所以我們把值放入
s.trays [s.size]，第三位。

331
00:16:01,790 --> 00:16:06,290
然後我們增加s.size說，
哎，我們之前有三件事情。

332
00:16:06,290 --> 00:16:07,400
現在，我們有四個。

333
00:16:07,400 --> 00:16:10,180
因此，下一次你推，你
打算把東西放到4。

334
00:16:10,180 --> 00:16:15,560
或者下一次你彈出，你會
來看看3而不是4或什麼的。

335
00:16:15,560 --> 00:16:18,000
然後我們將返回true
比方說，嘿，我們成功了。

336
00:16:18,000 --> 00:16:19,160
這個工作。

337
00:16:19,160 --> 00:16:22,060
作為一個經驗法則，如果一個函數是
應該返回true或

338
00:16:22,060 --> 00:16:26,370
假的總是返回true，則可能
做錯事。

339
00:16:26,370 --> 00:16:28,350
所以做這項工作？

340
00:16:28,350 --> 00:16:32,400
>> 好吧，它工作正常1，和
2，和3和4，和5。

341
00:16:32,400 --> 00:16:34,640
但是，讓我們說我達到我的能力。

342
00:16:34,640 --> 00:16:38,750
然後，我遇到了一個問題，因為
如果大小是一樣的能力，我

343
00:16:38,750 --> 00:16:43,340
現在試圖把東西放到一個
數組，其中我沒有空間。

344
00:16:43,340 --> 00:16:46,980
所以簡單的檢查，以解決這個問題。

345
00:16:46,980 --> 00:16:51,630
如果s.size ==容量，返回false。

346
00:16:51,630 --> 00:16:54,130
否則，去做我們所做的事情。

347
00:16:54,130 --> 00:16:55,660
那麼，我們還有什麼可以問
有關棧？

348
00:16:55,660 --> 00:16:56,460
還有什麼你應該學習？

349
00:16:56,460 --> 00:16:57,690
還有什麼你應該練習？

350
00:16:57,690 --> 00:17:01,030
>> 好吧，實施彈出。

351
00:17:01,030 --> 00:17:02,370
我們已經做了推送。

352
00:17:02,370 --> 00:17:04,280
我會解決這個問題。

353
00:17:04,280 --> 00:17:08,180
非數組實現，其中
你用一個鍊錶，也許。

354
00:17:08,180 --> 00:17:09,390
非整數實現。

355
00:17:09,390 --> 00:17:10,940
我們做了整型這裡。

356
00:17:10,940 --> 00:17:11,880
但它可能是花車。

357
00:17:11,880 --> 00:17:13,010
我本來是字符串。

358
00:17:13,010 --> 00:17:14,290
它可能是字符明星。

359
00:17:14,290 --> 00:17:17,960
看看以往測驗的種類
問題我們已經問棧。

360
00:17:17,960 --> 00:17:20,000
>> 我會說，我們周圍覆蓋棧
正如我們已經討論了他們在同一個

361
00:17:20,000 --> 00:17:20,540
過去幾年。

362
00:17:20,540 --> 00:17:24,400
因此，問答題應
是一個很好的跡象。

363
00:17:24,400 --> 00:17:27,010
展望未來更快，排隊。

364
00:17:27,010 --> 00:17:28,200
他們就像棧。

365
00:17:28,200 --> 00:17:29,960
但他們是先入先出。

366
00:17:29,960 --> 00:17:33,530
如果你是英國人，字隊列
大概做了很多有意義的你。

367
00:17:33,530 --> 00:17:36,390
否則，你可能有
聽說它作為一條線。

368
00:17:36,390 --> 00:17:38,120
他們的工作就像行
在蘋果商店。

369
00:17:38,120 --> 00:17:40,740
的第一人出現在3:00
早晨是第一

370
00:17:40,740 --> 00:17:42,880
人買他的iPad。

371
00:17:42,880 --> 00:17:44,260
>> 因此，我們有兩個操作 - 

372
00:17:44,260 --> 00:17:45,720
入隊和出隊。

373
00:17:45,720 --> 00:17:47,560
入隊把別人的線。

374
00:17:47,560 --> 00:17:50,070
出列拉第一
人斷了線。

375
00:17:50,070 --> 00:17:52,640
同樣，我們可以實現
這同一個數組。

376
00:17:52,640 --> 00:17:54,880
那麼，什麼是結構我們
在演講顯示？

377
00:17:54,880 --> 00:17:57,660
它是這一個。

378
00:17:57,660 --> 00:17:59,300
再次，數字。

379
00:17:59,300 --> 00:18:02,020
再次，大小和這個新事物面前。

380
00:18:02,020 --> 00:18:04,880
為什麼會出現一些所謂的面前？

381
00:18:04,880 --> 00:18:07,050
它的下一個索引
元素出列。

382
00:18:07,050 --> 00:18:12,210
這只是內部保持跟踪
第一個人展現出來，讓大家

383
00:18:12,210 --> 00:18:15,005
可以拉出來的時候，我們需要。

384
00:18:15,005 --> 00:18:19,322
>> 一定要看看講義，並嘗試
實施入隊和出隊

385
00:18:19,322 --> 00:18:21,700
攻讀測驗時。

386
00:18:21,700 --> 00:18:23,190
重要的事情要思考的問題。

387
00:18:23,190 --> 00:18:27,260
環繞著，如果前面加上
大小最終大於能力。

388
00:18:27,260 --> 00:18:32,670
同樣，如果你​​的結構是完整的，
你將有問題。

389
00:18:32,670 --> 00:18:34,780
哈希你以前見過的表。

390
00:18:34,780 --> 00:18:39,820
大多數時候，你可能實現
這些對pset6。

391
00:18:39,820 --> 00:18:44,210
這是一個結構，其目的是為O（1）
固定時間的插入和O（1）

392
00:18:44,210 --> 00:18:46,430
恆定的時間查找。

393
00:18:46,430 --> 00:18:49,760
>> 在CS50，我們實施這個作為
鍊錶的數組。

394
00:18:49,760 --> 00:18:53,690
關鍵部件到一個哈希表
是散列函數。

395
00:18:53,690 --> 00:18:58,350
所以它轉換成你的輸入，讓我們說，
字典中的詞，變成一個數字，

396
00:18:58,350 --> 00:18:59,560
這將是我們的索引。

397
00:18:59,560 --> 00:19:01,410
我們將使用該索引
進入我們的數組。

398
00:19:01,410 --> 00:19:05,374
所以這裡有一個可愛的小圖片
從study.50.net。

399
00:19:05,374 --> 00:19:08,060
我們扔掉所有的話到
我們的哈希函數。

400
00:19:08,060 --> 00:19:10,950
和散列函數告訴我們
在哪裡把這些話。

401
00:19:10,950 --> 00:19:15,650
>> 這是所有偉大的土地上
這裡只有一個用於每個時隙字。

402
00:19:15,650 --> 00:19:20,480
但是當你從pset6記得，有
比插槽更多的單詞。

403
00:19:20,480 --> 00:19:23,080
所以會發生什麼，當你
得到一個碰撞？

404
00:19:23,080 --> 00:19:26,730
相反，在存儲一個值
讓我們說，哈希表3，你

405
00:19:26,730 --> 00:19:27,990
存儲一個鍊錶。

406
00:19:27,990 --> 00:19:32,900
並因此而不必哈密瓜
在這裡，你將有一個鍊錶，

407
00:19:32,900 --> 00:19:34,190
其中的第一個節點是香瓜。

408
00:19:34,190 --> 00:19:35,260
和下一個節點是貓。

409
00:19:35,260 --> 00:19:38,970
和第三節點是碰撞，讓我們
就是說，因為所有的這些詞開始

410
00:19:38,970 --> 00:19:41,110
與C

411
00:19:41,110 --> 00:19:42,700
>> 所以，你最該做的pset6。

412
00:19:42,700 --> 00:19:45,685
如果你沒有做一個哈希表上pset6
而您試圖像

413
00:19:45,685 --> 00:19:47,720
一個線索，進行檢討哈希表。

414
00:19:47,720 --> 00:19:50,650
如果你確實這樣做了就pset6，絕對
檢查哈希表。

415
00:19:50,650 --> 00:19:53,610
如果你做到了對pset6才沒有
制定出完全正確，你

416
00:19:53,610 --> 00:19:56,150
有很多麻煩吧，絕對
檢查哈希表。

417
00:19:56,150 --> 00:20:01,610
所以，真正的教訓肯定是
檢查哈希表。

418
00:20:01,610 --> 00:20:07,130
>> 你試過廣大少數民族
出試穿pset6。

419
00:20:07,130 --> 00:20:08,570
高層次的圖片。

420
00:20:08,570 --> 00:20:15,150
它是這樣的，其中每個
節點有一組兒童，其中每個

421
00:20:15,150 --> 00:20:17,100
孩子對應一個字母。

422
00:20:17,100 --> 00:20:20,520
並且每個節點還表示，
哎，我是一個字。

423
00:20:20,520 --> 00:20:25,933
所以在這種情況下，字麥克斯韋
如果你按照M來了A到

424
00:20:25,933 --> 00:20:28,530
X-W-E-L-L，然後按照它多。

425
00:20:28,530 --> 00:20:32,800
你會得到這個符號，三角形，這
我們要表明的意思是這是一個詞。

426
00:20:32,800 --> 00:20:34,780
因此，麥克斯韋是一個詞。

427
00:20:34,780 --> 00:20:38,430
這些增量在整個符號化
這東西的話，哪些

428
00:20:38,430 --> 00:20:40,360
東西都沒有。

429
00:20:40,360 --> 00:20:46,400
>> 所以在pset6，數據存儲我們
沿著我們的任何節點是“我是一個

430
00:20:46,400 --> 00:20:52,630
一句話。“而關於嘗試的很酷的事情
是他們表現出的插入和

431
00:20:52,630 --> 00:20:55,080
查找在O（一個字的長度）。

432
00:20:55,080 --> 00:20:59,450
因此，只要打通麥克斯韋，它的
M-A-X-W-E-L-L。所以，七，八 - 

433
00:20:59,450 --> 00:21:00,360
我不能指望 - 

434
00:21:00,360 --> 00:21:03,920
步驟到達終點
並檢查出來的東西。

435
00:21:03,920 --> 00:21:06,800
這麼快實現這裡。

436
00:21:06,800 --> 00:21:10,230
羅布通過鏈接去
列出在他死後。

437
00:21:10,230 --> 00:21:11,600
因此，檢查了這一點。

438
00:21:11,600 --> 00:21:11,720
抱歉。

439
00:21:11,720 --> 00:21:13,240
通過他死後一個線索去了。

440
00:21:13,240 --> 00:21:14,260
因此，檢查了這一點。

441
00:21:14,260 --> 00:21:24,410
>> 但你基本上每個節點有27個
指針到下一個節點和一個

442
00:21:24,410 --> 00:21:27,050
布爾對我是一個字。

443
00:21:27,050 --> 00:21:31,530
退房Rob的死後如何
這實際上是落實。

444
00:21:31,530 --> 00:21:34,750
我們的最終結構，我們的樹
和二叉搜索樹。

445
00:21:34,750 --> 00:21:41,530
所以，看著這些，這些被覆蓋
最近8週，週一。

446
00:21:41,530 --> 00:21:46,960
樹是類似於特里，除了你
不一定必須在27個節點

447
00:21:46,960 --> 00:21:47,500
每個點。

448
00:21:47,500 --> 00:21:52,820
而你沒有在每一個有這種數據
一步，標誌著是否 - 

449
00:21:52,820 --> 00:21:54,030
路徑無所謂。

450
00:21:54,030 --> 00:22:00,870
而一個線索，該路徑從頂部到
底，麥克斯韋，重要的是我們。

451
00:22:00,870 --> 00:22:05,270
>> 但每個節點有多個
孩子，也許。

452
00:22:05,270 --> 00:22:07,290
我們有更多的詞彙。

453
00:22:07,290 --> 00:22:09,530
樹的根
是在最高層。

454
00:22:09,530 --> 00:22:12,520
而我們說的很底層
有沒有節點

455
00:22:12,520 --> 00:22:14,530
孩子是樹葉。

456
00:22:14,530 --> 00:22:18,040
所以，像特里，一棵樹是
節點的結構。

457
00:22:18,040 --> 00:22:21,490
樹，我們要去一個常見類型
談的是一個二叉樹，其中

458
00:22:21,490 --> 00:22:26,040
每個節點沒有子節點或
一個孩子或兩個孩子。

459
00:22:26,040 --> 00:22:28,890
所以，這幅畫在這裡就不
一個二叉樹，因為

460
00:22:28,890 --> 00:22:32,890
節點3有三個孩子。

461
00:22:32,890 --> 00:22:38,140
>> 但如果我們忽視這些，剩下的
它是一個二叉樹，因為它

462
00:22:38,140 --> 00:22:43,200
表明每個節點的屬性
具有零個，一個或兩個孩子。

463
00:22:43,200 --> 00:22:46,400
所以，我們怎麼能表達這種代碼？

464
00:22:46,400 --> 00:22:51,460
我們可以有一個節點，其中每個節點有
在它的內部的一個整數，以及

465
00:22:51,460 --> 00:22:55,590
作為指向左側的樹
和一個指向上的樹

466
00:22:55,590 --> 00:22:59,510
對，所以這兩個孩子。

467
00:22:59,510 --> 00:23:00,880
這是怎麼有用嗎？

468
00:23:00,880 --> 00:23:05,740
那麼，如果我們做出有關規定，我們
把節點，我們可以使搜索更快。

469
00:23:05,740 --> 00:23:10,630
>> 所以這是一個二分查找的概念
樹，在那裡上的所有節點

470
00:23:10,630 --> 00:23:14,420
左子樹有一個較小的值
比節點，我們正在尋找。

471
00:23:14,420 --> 00:23:17,880
和右子樹的所有節點
有一個更大的價值

472
00:23:17,880 --> 00:23:18,660
比根節點。

473
00:23:18,660 --> 00:23:20,670
現在，看起來像很多的話。

474
00:23:20,670 --> 00:23:23,770
我打算把它的內部雙
報價和展示你的照片。

475
00:23:23,770 --> 00:23:27,010
因此，這裡是一個例子
二叉搜索樹。

476
00:23:27,010 --> 00:23:28,770
看到我們開始10。

477
00:23:28,770 --> 00:23:31,780
一切向左側
圖10是比它小。

478
00:23:31,780 --> 00:23:33,130
和我的一切的權利
大於它。

479
00:23:33,130 --> 00:23:37,620
>> 但更重要的是，在每個節點
樹表示這個屬性。

480
00:23:37,620 --> 00:23:42,110
所以，節點7具有3到
左和9到右側。

481
00:23:42,110 --> 00:23:44,440
因此，所有這些都小於10。

482
00:23:44,440 --> 00:23:50,470
但看著眼前這些時，有7
3到它的左和9在它的右邊。

483
00:23:50,470 --> 00:23:56,100
同樣在右側，15有14個
到它的左和50在其右側。

484
00:23:56,100 --> 00:24:03,770
所以那邊的三個節點，15，14，
和50，也是一個有效的二進制樹

485
00:24:03,770 --> 00:24:05,480
或有效的二叉搜索樹。

486
00:24:05,480 --> 00:24:07,250
而且他們都大於10。

487
00:24:07,250 --> 00:24:08,960
因此，他們被允許為
就在那裡。

488
00:24:08,960 --> 00:24:09,940
有沒有問題？

489
00:24:09,940 --> 00:24:12,580
>> 觀眾：你如何處理時，
你有兩個七人欖球賽？

490
00:24:12,580 --> 00:24:12,850
>> R.J.阿基諾：是啊。

491
00:24:12,850 --> 00:24:16,550
你如何處理與兩個值
這是一樣的嗎？

492
00:24:16,550 --> 00:24:21,465
一些二叉搜索樹說，你
忽略重複的，因為我們的目標是

493
00:24:21,465 --> 00:24:24,280
只是說，我見過
這些事情至今。

494
00:24:24,280 --> 00:24:28,120
一些二叉搜索樹，你可以說
有節點的內部計數。

495
00:24:28,120 --> 00:24:32,000
其他人可能會說，一切以
左邊是小於或等於。

496
00:24:32,000 --> 00:24:33,470
和我的一切的權利
大於。

497
00:24:33,470 --> 00:24:36,520
>> 這只是取決於什麼
問題是你正在解決。

498
00:24:36,520 --> 00:24:40,840
因此，在一個字典，例如，你
不會在乎重複。

499
00:24:40,840 --> 00:24:41,490
你會扔出來。

500
00:24:41,490 --> 00:24:44,719
但其他一些問題，你可能會在乎。

501
00:24:44,719 --> 00:24:49,242
>> 觀眾：是否有可能有
一個1到​​15的左側，而

502
00:24:49,242 --> 00:24:50,590
小於10？

503
00:24:50,590 --> 00:24:51,885
>> R.J.阿基諾：號

504
00:24:51,885 --> 00:24:56,570
如果這裡的14是一個1，這將
不是一個有效的二叉搜索樹，

505
00:24:56,570 --> 00:25:00,840
因為一切的權利
10必須是大於它。

506
00:25:00,840 --> 00:25:02,300
我們就會明白為什麼。

507
00:25:02,300 --> 00:25:07,960
如果在搜索的土地我的目標是
找到14，我從根開始。

508
00:25:07,960 --> 00:25:08,500
所以我期待。

509
00:25:08,500 --> 00:25:08,710
確定。

510
00:25:08,710 --> 00:25:10,670
我們打算從根開始。

511
00:25:10,670 --> 00:25:12,500
看10。

512
00:25:12,500 --> 00:25:16,050
>> 好了，14，我們的目標，
大於10。

513
00:25:16,050 --> 00:25:17,370
因此它必須是在右側。

514
00:25:17,370 --> 00:25:21,780
這是非常相似的整個電話
本書的事情，我們所做的，二進制

515
00:25:21,780 --> 00:25:23,720
搜索那裡。

516
00:25:23,720 --> 00:25:26,430
但是，而不是二進制搜索
在陣列中，我們的二進制

517
00:25:26,430 --> 00:25:28,490
在搜索這棵樹。

518
00:25:28,490 --> 00:25:31,260
因此，我們仍然在尋找14。

519
00:25:31,260 --> 00:25:32,480
以及，圖14是小於15。

520
00:25:32,480 --> 00:25:36,430
所以，如果它在我們的樹，它必須
在這個區域在這裡。

521
00:25:36,430 --> 00:25:39,680
它必須向右側
10和15的左側。

522
00:25:39,680 --> 00:25:42,250
>> 因此，我們檢查這個節點。

523
00:25:42,250 --> 00:25:45,790
和耶，我們發現有14條。

524
00:25:45,790 --> 00:25:46,760
我不打算走過它。

525
00:25:46,760 --> 00:25:48,090
但這裡的代碼。

526
00:25:48,090 --> 00:25:49,690
它實際上是相對
簡單，

527
00:25:49,690 --> 00:25:52,630
因為這是遞歸的。

528
00:25:52,630 --> 00:25:55,420
還有什麼比我們要求你做一個小測驗？

529
00:25:55,420 --> 00:25:57,000
我們可以要求你寫這段代碼。

530
00:25:57,000 --> 00:25:59,170
我們可以請你看看這個代碼
並修改這個代碼，並解釋

531
00:25:59,170 --> 00:26:00,210
它在幹什麼。

532
00:26:00,210 --> 00:26:00,390
是啊。

533
00:26:00,390 --> 00:26:00,770
問題？

534
00:26:00,770 --> 00:26:04,240
>> 觀眾：難道這些幻燈片將是
提供，因為他們是最後一次？

535
00:26:04,240 --> 00:26:04,740
>> R.J.阿基諾：是的。

536
00:26:04,740 --> 00:26:06,460
所以，這些幻燈片肯定會
發布。

537
00:26:06,460 --> 00:26:08,640
>> 觀眾：他們實際上張貼
現在在網站上。

538
00:26:08,640 --> 00:26:10,020
大衛只是做了。

539
00:26:10,020 --> 00:26:12,720
>> R.J.阿基諾：該幻燈片
現在在網站上。

540
00:26:12,720 --> 00:26:16,420
我可能會修補了幾個
錯別字我注意到和解決這些問題。

541
00:26:16,420 --> 00:26:19,940
但是有一個電流
版本在網站上。

542
00:26:19,940 --> 00:26:21,820
其他的事情，我們可以要求你做 - 

543
00:26:21,820 --> 00:26:23,790
寫插件。

544
00:26:23,790 --> 00:26:27,490
寫一個迭代版本的
遞歸函數，我們剛才給你看

545
00:26:27,490 --> 00:26:32,520
或談論這些事情，就像在
段落，文字，句子。

546
00:26:32,520 --> 00:26:35,760
比較運行時間，並解釋
你想使用二進制什麼

547
00:26:35,760 --> 00:26:39,200
供，而不是一個搜索樹
哈希表，例如。

548
00:26:39,200 --> 00:26:43,580
>> 因此，了解這些結構
在一個相當深的程度。

549
00:26:43,580 --> 00:26:47,440
了解如何編寫它們，如何
使用它們，如何談論他們。

550
00:26:47,440 --> 00:26:50,270
，你會被所有的設置。

551
00:26:50,270 --> 00:26:50,630
問題？

552
00:26:50,630 --> 00:26:55,070
>> 觀眾：當你寫的
二叉搜索樹，你怎麼了

553
00:26:55,070 --> 00:27:01,460
確定什麼樣的價值，以
把它作為根？

554
00:27:01,460 --> 00:27:06,120
>> R.J.阿基諾：所以現在的問題是，是什麼
值做才能讓你以root？

555
00:27:06,120 --> 00:27:08,760
根據你的代碼，你
可能有一個全球性的根源。

556
00:27:08,760 --> 00:27:14,290
所以，你可能已經可能在過
pset6一個全球性的哈希表。

557
00:27:14,290 --> 00:27:18,640
或者你可以通過根
作為一個參數。

558
00:27:18,640 --> 00:27:23,810
所以這個搜索功能在這裡
需要一個參數，一個節點*。

559
00:27:23,810 --> 00:27:27,420
所以任何節點你碰巧是
看到的是你對待一個

560
00:27:27,420 --> 00:27:31,510
作為你的根，當你通過它。

561
00:27:31,510 --> 00:27:32,320
和我都準備好。

562
00:27:32,320 --> 00:27:33,480
這些都是我的幻燈片。

563
00:27:33,480 --> 00:27:35,940
旁邊的人可以來交換
在一台筆記本電腦和麥克風。

564
00:27:35,940 --> 00:27:47,390

565
00:27:47,390 --> 00:27:49,760
>> ROB BOWDEN：我想我可能有
不同的解釋這個問題。

566
00:27:49,760 --> 00:27:53,826
但我把它理解成，如果你有
數字1，2和3，我們如何

567
00:27:53,826 --> 00:27:56,720
知道要2根
相對於1或3？

568
00:27:56,720 --> 00:27:59,480
如果我們讓2根，那麼它的好聽
1和3的左側和右側。

569
00:27:59,480 --> 00:28:04,610
但是，如果1是根，那麼它的1到
頂，2右，3到右側。

570
00:28:04,610 --> 00:28:10,880
因此默認情況下，你不知道
怎樣弄根。

571
00:28:10,880 --> 00:28:15,400
而對於任何算法，我們正在期待
給你，只是你首先

572
00:28:15,400 --> 00:28:16,680
插入將是根。

573
00:28:16,680 --> 00:28:19,890
或者，我們會給您一個二進制樹
已存在有一個根。

574
00:28:19,890 --> 00:28:24,760
但其他的算法存在，使得
根將更新，所以，如果

575
00:28:24,760 --> 00:28:28,370
結束的情況下，其中它的1，2，
3，它會自動更新到

576
00:28:28,370 --> 00:28:30,900
使2新根，使
它還是很好的平衡。

577
00:28:30,900 --> 00:28:33,750

578
00:28:33,750 --> 00:28:34,833
>> 安琪拉李：酷。

579
00:28:34,833 --> 00:28:36,170
嘿，伙計們。

580
00:28:36,170 --> 00:28:37,810
我是安吉拉。

581
00:28:37,810 --> 00:28:42,490
我要去幹掉我們的C
然後進入我們的一些網頁

582
00:28:42,490 --> 00:28:43,120
技術 - 

583
00:28:43,120 --> 00:28:46,570
HTTP，HTML和CSS。

584
00:28:46,570 --> 00:28:49,610
所以，第一件事就是緩衝
溢出攻擊。

585
00:28:49,610 --> 00:28:53,070
因此，讓我們來看看這段代碼。

586
00:28:53,070 --> 00:28:54,260
這是很簡單的。

587
00:28:54,260 --> 00:28:55,460
有一個函數foo。

588
00:28:55,460 --> 00:28:56,990
它不返回任何東西。

589
00:28:56,990 --> 00:29:00,950
但它需要在一個指針
一個叫巴字符串。

590
00:29:00,950 --> 00:29:04,920
>> 並且它要聲明這個
緩衝器，它是一個字符

591
00:29:04,920 --> 00:29:07,690
陣列有12個插槽。

592
00:29:07,690 --> 00:29:11,730
它使用的memcpy，這僅僅是一個
函數，從一個地址拷貝

593
00:29:11,730 --> 00:29:12,910
到另一個。

594
00:29:12,910 --> 00:29:19,400
因此，這是試圖複製到
我們無論從任何緩衝

595
00:29:19,400 --> 00:29:21,140
酒吧指向。

596
00:29:21,140 --> 00:29:24,640
所以任何想法什麼是錯的
與此代碼？

597
00:29:24,640 --> 00:29:27,568

598
00:29:27,568 --> 00:29:30,830
>> 觀眾：如果酒吧是長於
C，它們將覆蓋。

599
00:29:30,830 --> 00:29:31,520
>> 安琪拉李：是的，沒錯。

600
00:29:31,520 --> 00:29:34,200
我們不能保證吧
將是小於12。

601
00:29:34,200 --> 00:29:36,080
我們只是做了一些任意數量的12。

602
00:29:36,080 --> 00:29:38,380
和我們一樣，讓我們希望，
我們的用戶輸入小於

603
00:29:38,380 --> 00:29:40,440
12個字符長。

604
00:29:40,440 --> 00:29:46,320
因此，在一個理想的世界，如果我們的輸入是
總是不如預期，那麼我們會得到

605
00:29:46,320 --> 00:29:47,550
類似的東西，你好。

606
00:29:47,550 --> 00:29:48,920
這是少於12個字符。

607
00:29:48,920 --> 00:29:51,870
它被讀入字符角

608
00:29:51,870 --> 00:29:53,280
然後我們用它做什麼。

609
00:29:53,280 --> 00:29:54,800
這其實並不重要。

610
00:29:54,800 --> 00:29:59,740
>> 但是惡意的人可以做
更多的東西像這樣，他們在那裡

611
00:29:59,740 --> 00:30:04,760
給我們什麼吧指向，
它會指向這個巨大的數組

612
00:30:04,760 --> 00:30:06,280
只是A的。

613
00:30:06,280 --> 00:30:10,680
這是比12路更長。

614
00:30:10,680 --> 00:30:13,830
所以它會一路走下去
到這裡，以那裡的回報

615
00:30:13,830 --> 00:30:15,420
地址曾經是。

616
00:30:15,420 --> 00:30:17,860
所以我們可以說這個功能
被叫做foo。

617
00:30:17,860 --> 00:30:20,970
也許富被稱為由其他
功能，這是由主程序調用的。

618
00:30:20,970 --> 00:30:24,890
因此，當foo的運行，它需要
知道在哪裡返回。

619
00:30:24,890 --> 00:30:29,130
>> 如果foo調用一些函數命名
巴茲，它必須知道它​​的

620
00:30:29,130 --> 00:30:30,250
得回去巴茲。

621
00:30:30,250 --> 00:30:34,040
而這正是這個返回地址
這兒告訴我們。

622
00:30:34,040 --> 00:30:38,340
但是，如果我們覆蓋它與其他一些
地址，在這種情況下，這是一個

623
00:30:38,340 --> 00:30:42,650
在地址的表示
最開始這個緩衝區，然後

624
00:30:42,650 --> 00:30:45,240
什麼實際將要發生的是，
而不是返回回巴茲，

625
00:30:45,240 --> 00:30:48,470
這被稱為我們的函數，它只是
要去這段代碼的前面。

626
00:30:48,470 --> 00:30:53,930
>> 如果這是因為有一個
惡意黑客的傢伙來了，

627
00:30:53,930 --> 00:30:56,820
注射這一點，那麼也許這個數額
A的實際上不是的。

628
00:30:56,820 --> 00:31:02,030
它實際上只是代碼的休息
你的電腦什麼的。

629
00:31:02,030 --> 00:31:05,930
因此，為了防守這類型的
首先，你必須永遠不能假定

630
00:31:05,930 --> 00:31:09,120
用戶輸入是在一定
數目的字符。

631
00:31:09,120 --> 00:31:13,310
例如，當你在做
拼寫檢查，你被告知的話是

632
00:31:13,310 --> 00:31:15,580
只有將是40個字符
長的最大值。

633
00:31:15,580 --> 00:31:16,570
那是不錯的。

634
00:31:16,570 --> 00:31:20,150
>> 但如果沒有，那麼你就必須
請務必閱讀只是在45

635
00:31:20,150 --> 00:31:21,520
字符的時間。

636
00:31:21,520 --> 00:31:24,430
否則，你可能會覆蓋
您的緩衝區。

637
00:31:24,430 --> 00:31:26,140
上的任何問題。

638
00:31:26,140 --> 00:31:26,733
是啊。

639
00:31:26,733 --> 00:31:28,850
>> 觀眾：你能不能談談
多一點關於這些？

640
00:31:28,850 --> 00:31:29,790
>> 安琪拉李：對不起。

641
00:31:29,790 --> 00:31:31,040
是。

642
00:31:31,040 --> 00:31:32,813

643
00:31:32,813 --> 00:31:35,870
>> 觀眾：麥克只是視頻。

644
00:31:35,870 --> 00:31:37,640
我會盡量和項目。

645
00:31:37,640 --> 00:31:39,900
嗨，伙計們。

646
00:31:39,900 --> 00:31:40,920
燮？

647
00:31:40,920 --> 00:31:45,330
所以，讓我們在不多的事在
CS50庫，你一直在使用這

648
00:31:45,330 --> 00:31:49,072
所有學期，主要是
獲取用戶輸入。

649
00:31:49,072 --> 00:31:53,140
如你所知，你包括CS50
只是在做CS50.h，圖書館，

650
00:31:53,140 --> 00:31:55,660
包含了所有的原型
功能，您可以使用，像

651
00:31:55,660 --> 00:31:58,640
GetString和調用getInt，並
GetFloat和等等。

652
00:31:58,640 --> 00:32:02,870
還有的這一行中的CS50
庫，它定義了一個字符串，它

653
00:32:02,870 --> 00:32:05,380
你們都知道了吧
僅僅是一個char *。

654
00:32:05,380 --> 00:32:07,900
>> 但是，讓我們看一下在
GetString的是如何工作的。

655
00:32:07,900 --> 00:32:10,010
這是一個非常刪節版。

656
00:32:10,010 --> 00:32:15,090
你可以拉起CS50庫文件
從，我認為，manuals.CS50.net。

657
00:32:15,090 --> 00:32:16,750
而且你可以通過閱讀
實際的功能。

658
00:32:16,750 --> 00:32:19,330
但是，這涉及一些
的重要組成部分。

659
00:32:19,330 --> 00:32:23,870
因此，我們已經創造了一些緩衝
有一些能力。

660
00:32:23,870 --> 00:32:27,570
而我們做的是我們得到一個字符
從標準的N時間。

661
00:32:27,570 --> 00:32:30,910
這就是用戶輸入
在文本控制台。

662
00:32:30,910 --> 00:32:33,430
>> 所以我們要讀入
字符，只要它不是一個新的

663
00:32:33,430 --> 00:32:37,220
行，它不是最終的文件，其中
是標準輸入的結束。

664
00:32:37,220 --> 00:32:45,690
為此，我們在閱讀每一個字，
如果該字符結束了加入

665
00:32:45,690 --> 00:32:50,120
到的字符數，我們讀過
在那超過我們的能力，

666
00:32:50,120 --> 00:32:53,490
那麼我們做的是我們剛剛調整了
緩衝區，以便它的兩倍長。

667
00:32:53,490 --> 00:32:56,950
如此反复，這樣可以防止緩存
溢出攻擊，因為你讀的

668
00:32:56,950 --> 00:32:58,315
一個字符的時間。

669
00:32:58,315 --> 00:33:02,290
如果在任何時候你在閱讀過
許多人來說，你只是擴大你的緩衝區。

670
00:33:02,290 --> 00:33:03,330
你乘以2。

671
00:33:03,330 --> 00:33:05,510
然後你有更多的空間。

672
00:33:05,510 --> 00:33:09,120
>> 否則，你只需要添加
一個字符緩衝區。

673
00:33:09,120 --> 00:33:15,080
和你讀過的所有後
字符，它會收縮緩衝

674
00:33:15,080 --> 00:33:18,510
回落到正常大小，加
null結束，然後返回。

675
00:33:18,510 --> 00:33:21,880

676
00:33:21,880 --> 00:33:24,960
現在，讓我們來看看調用getInt。

677
00:33:24,960 --> 00:33:27,700
你們可以看嗎？

678
00:33:27,700 --> 00:33:30,710
我可以在一個位放大。

679
00:33:30,710 --> 00:33:33,410

680
00:33:33,410 --> 00:33:34,660
我不知道怎麼的計算機。

681
00:33:34,660 --> 00:33:40,840

682
00:33:40,840 --> 00:33:41,270
沒關係。

683
00:33:41,270 --> 00:33:42,520
我不能放大正常。

684
00:33:42,520 --> 00:33:47,500

685
00:33:47,500 --> 00:33:48,770
>> 這真的很難。

686
00:33:48,770 --> 00:33:49,180
對不起。

687
00:33:49,180 --> 00:33:51,490
就讓我們看看這個。

688
00:33:51,490 --> 00:33:57,140
那麼，什麼調用getInt所做的是它首先讀取
從GetString的，一個字符串，它

689
00:33:57,140 --> 00:33:59,250
我們之前已經實現。

690
00:33:59,250 --> 00:34:02,945
和重要組成部分，這裡要注意
如果是這種共享，它結束了

691
00:34:02,945 --> 00:34:06,400
閱讀是像也不是一個字符串，
那麼我們就返回到INT_MAX

692
00:34:06,400 --> 00:34:09,409
代表失敗。

693
00:34:09,409 --> 00:34:12,645
為什麼我們返回INT_MAX而不是
負1或1？

694
00:34:12,645 --> 00:34:13,895
任何想法？

695
00:34:13,895 --> 00:34:16,853

696
00:34:16,853 --> 00:34:19,350
>> 觀眾：[聽不清]
負1的之一。

697
00:34:19,350 --> 00:34:20,070
>> 安琪拉李：是的，沒錯。

698
00:34:20,070 --> 00:34:24,560
所以你的方式更可能只是想
輸入1或負1時提示

699
00:34:24,560 --> 00:34:27,469
為第n個和第n個什麼馬克塞斯。

700
00:34:27,469 --> 00:34:27,969
這是巨大的。

701
00:34:27,969 --> 00:34:29,690
你可能不打算使用它。

702
00:34:29,690 --> 00:34:32,690
因此，這就像一個設計決定
確保你不小心

703
00:34:32,690 --> 00:34:38,540
返回一個錯誤或你不回
1，可能被解析

704
00:34:38,540 --> 00:34:41,199
作為一個正確的答案。

705
00:34:41,199 --> 00:34:45,110
因此，如果一個行不存在，則
我們返回INT-MAX。

706
00:34:45,110 --> 00:34:48,090
否則，我們使用sscanf的，
這就好比scanf函數。

707
00:34:48,090 --> 00:34:49,449
但它讀取一個字符串。

708
00:34:49,449 --> 00:34:54,310
>> 我們有這樣的格式化
字符串，是我％％C。

709
00:34:54,310 --> 00:34:57,440
我們嘗試和匹配，與
無論用戶給我們。

710
00:34:57,440 --> 00:35:01,420
我們要的東西​​相匹配的數量
為1，這意味著我們只

711
00:35:01,420 --> 00:35:04,940
確實想匹配一個整數
由也許包圍的白色

712
00:35:04,940 --> 00:35:06,840
空間，也許不是。

713
00:35:06,840 --> 00:35:10,710
在這種情況下，如果你把東西
像酒吧，酒吧不匹配可言，

714
00:35:10,710 --> 00:35:14,400
因為需要有
在開始的整數。

715
00:35:14,400 --> 00:35:17,060
所以sscan從來沒有把0。

716
00:35:17,060 --> 00:35:19,640
這樣你就不會返回。

717
00:35:19,640 --> 00:35:23,850
>> 另外，如果你把東西
如1，2，3，A，B，C，那場比賽

718
00:35:23,850 --> 00:35:27,180
無論是整數，但也
後的字符。

719
00:35:27,180 --> 00:35:29,990
這樣的sscanf會返回2，這
也並不理想。

720
00:35:29,990 --> 00:35:34,620
你不想1，2，3，A，
B，C是有效的int。

721
00:35:34,620 --> 00:35:36,990
這樣也不起作用。

722
00:35:36,990 --> 00:35:38,530
但是，說你把喜歡的東西50。

723
00:35:38,530 --> 00:35:42,460
我就要匹配％，這意味著
它會讀成n。

724
00:35:42,460 --> 00:35:44,790
而現在，正將包含數50。

725
00:35:44,790 --> 00:35:46,110
然後你就可以返回。

726
00:35:46,110 --> 00:35:49,270
>> 否則，你打重試。

727
00:35:49,270 --> 00:35:55,790
然後它只是一次又一次，直到
您從用戶得到正確的輸入。

728
00:35:55,790 --> 00:35:56,891
上有問題嗎？

729
00:35:56,891 --> 00:36:02,182
>> 觀眾：所以，如果你要打印出
調用getInt在[聽不清]的值

730
00:36:02,182 --> 00:36:06,250
會是公正的整數和最大？

731
00:36:06,250 --> 00:36:07,440
>> 安琪拉李：是啊。

732
00:36:07,440 --> 00:36:11,780
所以，如果你使用調用getInt，你應該假設
你不希望第n為最大

733
00:36:11,780 --> 00:36:15,328
是一個有效的輸入，因為你會
假設這是不好的。

734
00:36:15,328 --> 00:36:27,740
>> 觀眾：如果我們沒有字符c和
有人把在1，2，3，山姆，它會

735
00:36:27,740 --> 00:36:29,430
1，2，3還有效嗎？

736
00:36:29,430 --> 00:36:29,750
>> 安琪拉李：我覺得這是可行的。

737
00:36:29,750 --> 00:36:33,340
但你不想123Sam到
是有效的由用戶輸入的。

738
00:36:33,340 --> 00:36:34,670
這是不是一個真正的整數。

739
00:36:34,670 --> 00:36:36,840
因此，它似乎不公平
解析它作為一個int。

740
00:36:36,840 --> 00:36:40,910

741
00:36:40,910 --> 00:36:42,160
確定。

742
00:36:42,160 --> 00:36:45,800
在這種情況下，讓我們繼續前進
上到互聯網。

743
00:36:45,800 --> 00:36:49,120
因此，HTTP是不是一種語言。

744
00:36:49,120 --> 00:36:56,060
HTTP是只是一組標準
你如何從客戶端發送的東西，

745
00:36:56,060 --> 00:36:57,280
這就是你，給服務器。

746
00:36:57,280 --> 00:36:59,730
這是其他人在網絡上。

747
00:36:59,730 --> 00:37:02,900
>> 所以HTTP代表超文本
傳輸協議。

748
00:37:02,900 --> 00:37:04,610
它的心臟和靈魂
整個網絡的。

749
00:37:04,610 --> 00:37:07,050
超文本只是部分
指的是HTML。

750
00:37:07,050 --> 00:37:10,690
轉移是像客戶端
您將請求發送到

751
00:37:10,690 --> 00:37:13,060
服務器，這給反應。

752
00:37:13,060 --> 00:37:16,380
而協議只是，怎麼辦
你期望一個服務器的行為？

753
00:37:16,380 --> 00:37:19,960
怎麼是你應該表現
這樣，您可以簡化這個

754
00:37:19,960 --> 00:37:21,920
溝通過程？

755
00:37:21,920 --> 00:37:26,650
>> 所以HTTP請求看起來很像這個。

756
00:37:26,650 --> 00:37:28,070
GET是請求的類型。

757
00:37:28,070 --> 00:37:31,220
你們已經看到的GET請求
和POST請求。

758
00:37:31,220 --> 00:37:36,690
這第二件事情有，/我來說，這
只是URI或您所在的URL

759
00:37:36,690 --> 00:37:38,140
要在主機內去。

760
00:37:38,140 --> 00:37:44,140
因此，這要求是要求有
頁，像www.facebook.com /我。

761
00:37:44,140 --> 00:37:45,300
這是一個GET請求。

762
00:37:45,300 --> 00:37:51,020
然後這個HTTP/1.1，這只是
HTTP的你正在使用的版本。

763
00:37:51,020 --> 00:37:55,020
它幾乎總是1.1。

764
00:37:55,020 --> 00:37:56,880
>> 然後有一堆
其他的東西了。

765
00:37:56,880 --> 00:38:02,510
實際上，你可以看到這些，如果你
打開你的控制台，當你

766
00:38:02,510 --> 00:38:03,770
瀏覽網頁。

767
00:38:03,770 --> 00:38:07,290
反應看起來
更多同類產品。

768
00:38:07,290 --> 00:38:09,620
頂部的部分是，同樣，
您正在使用HTTP的類型

769
00:38:09,620 --> 00:38:12,310
其次是狀態代碼。

770
00:38:12,310 --> 00:38:14,700
所以200 OK是一切工作。

771
00:38:14,700 --> 00:38:16,200
這裡是您的內容。

772
00:38:16,200 --> 00:38:17,390
您的內容將會隨之而來。

773
00:38:17,390 --> 00:38:21,730
然後它會告訴你什麼樣的
的內容和其他東西太多。

774
00:38:21,730 --> 00:38:24,620
>> 該狀態碼，也有少數
重要的是你應該知道。

775
00:38:24,620 --> 00:38:26,460
200 OK是像一切的金色。

776
00:38:26,460 --> 00:38:28,490
一切正常。

777
00:38:28,490 --> 00:38:29,710
403禁止。

778
00:38:29,710 --> 00:38:32,910
這一點，你可能已經看到了，如果你忘了
正確搭配chmod東西。

779
00:38:32,910 --> 00:38:34,510
這意味著，你不必
正確的權限

780
00:38:34,510 --> 00:38:36,210
訪問該服務器上。

781
00:38:36,210 --> 00:38:38,110
這就像，不，你不能看到它。

782
00:38:38,110 --> 00:38:39,780
404指的事情不存在。

783
00:38:39,780 --> 00:38:40,400
沒有找到。

784
00:38:40,400 --> 00:38:41,640
你可能已經看到了很多。

785
00:38:41,640 --> 00:38:45,510
>> 500內部服務器錯誤通常是
好像出事了就在身邊

786
00:38:45,510 --> 00:38:46,460
服務器。

787
00:38:46,460 --> 00:38:50,830
所以，當你正在實施pset7，
如果你有PHP錯誤，你可以

788
00:38:50,830 --> 00:38:53,890
其實去的網頁，看到一個
一大堆的PHP的錯誤的東西。

789
00:38:53,890 --> 00:38:56,900
但是，這並不常發生，
因為網站並不真的想

790
00:38:56,900 --> 00:38:58,830
告訴你為什麼他們的網站被打破。

791
00:38:58,830 --> 00:39:03,370
他們可能會只返回一個
500內部服務器錯誤。

792
00:39:03,370 --> 00:39:06,120
>> 再有就是418我是一個茶壺。

793
00:39:06,120 --> 00:39:07,910
有大約原委
為什麼這是一個事。

794
00:39:07,910 --> 00:39:09,860
但你可以閱讀有關
在你自己的時間。

795
00:39:09,860 --> 00:39:11,450
還有一大堆的
其他狀態碼了。

796
00:39:11,450 --> 00:39:12,700
但這些是那些
你應該知道。

797
00:39:12,700 --> 00:39:15,660

798
00:39:15,660 --> 00:39:18,610
因此，讓我們來談談HTML。

799
00:39:18,610 --> 00:39:22,180
HTML，記住，不是
編程語言。

800
00:39:22,180 --> 00:39:23,510
這是一種標記語言。

801
00:39:23,510 --> 00:39:25,210
這意味著它描述的內容。

802
00:39:25,210 --> 00:39:30,440
它會告訴你什麼是HTML文檔看起來
喜歡與否是什麼樣子

803
00:39:30,440 --> 00:39:32,230
但它是如何構成的。

804
00:39:32,230 --> 00:39:36,110
>> 因此它定義了一個結構和
網頁的語義。

805
00:39:36,110 --> 00:39:37,830
這就像，這是一個段落。

806
00:39:37,830 --> 00:39:40,060
這是一個有序列表。

807
00:39:40,060 --> 00:39:42,360
這就像我的網頁的一部分。

808
00:39:42,360 --> 00:39:43,260
這裡的標題。

809
00:39:43,260 --> 00:39:44,310
它類似的東西。

810
00:39:44,310 --> 00:39:48,770
它沒有任何樣式的，由於
這就是你在CSS中做。

811
00:39:48,770 --> 00:39:50,270
它看起來像一個系列
嵌套標籤。

812
00:39:50,270 --> 00:39:54,720
因此，要使用的一個非常基本的一個例子
HTML頁面，您可以在DOCTYPE

813
00:39:54,720 --> 00:39:56,720
聲明那裡。

814
00:39:56,720 --> 00:40:00,940
>> 這DOCTYPE聲明
說，我們正在使用HTML5。

815
00:40:00,940 --> 00:40:03,370
那麼你有很大的HTML標籤。

816
00:40:03,370 --> 00:40:05,230
它包含一個頭部和主體。

817
00:40:05,230 --> 00:40:06,970
裡面的頭，你的標題。

818
00:40:06,970 --> 00:40:12,950
這就是所發生的稱號
巴您的瀏覽器。

819
00:40:12,950 --> 00:40:15,810
我們有一個鏈接一個鏈接標籤
在外部的樣式表。

820
00:40:15,810 --> 00:40:19,880
然後我們有一個拉一個腳本
從外部JavaScript以及。

821
00:40:19,880 --> 00:40:23,750
>> 然後我們的身體裡面實際上是
什麼被顯示在頁面上。

822
00:40:23,750 --> 00:40:28,210
我們已經有了一個段落，然後一個
像那款內。

823
00:40:28,210 --> 00:40:32,000
這一個是小貓的圖片。

824
00:40:32,000 --> 00:40:35,840
請注意，該圖像
標籤關閉本身。

825
00:40:35,840 --> 00:40:41,760
所以不是開口與圖像
然後做一套/圖像，你

826
00:40:41,760 --> 00:40:47,500
只是有這個小斜線
在這裡，它會關閉它。

827
00:40:47,500 --> 00:40:53,670
和圖像標籤也有這個鍵
value屬性稱為ALT。

828
00:40:53,670 --> 00:40:56,970
這就是替代文本
當你懸停發生。

829
00:40:56,970 --> 00:41:03,170
>> 大多數HTML元素有一定的鍵值
的東西，你可以給它，各種

830
00:41:03,170 --> 00:41:04,420
定制。

831
00:41:04,420 --> 00:41:06,230

832
00:41:06,230 --> 00:41:08,705
是啊。

833
00:41:08,705 --> 00:41:09,955
>> 觀眾：[聽不清]。

834
00:41:09,955 --> 00:41:17,510

835
00:41:17,510 --> 00:41:19,680
>> 安琪拉李：嗯，所以它是一個
標籤的屬性。

836
00:41:19,680 --> 00:41:25,320
所以，如果你使用jQuery，你可以
做選擇image.getAttribute。

837
00:41:25,320 --> 00:41:27,930
然後你就可以搜索
得到的alt屬性。

838
00:41:27,930 --> 00:41:31,040
它會給你的小貓。

839
00:41:31,040 --> 00:41:37,400
如果你還記得的形式在HTML中，輸入
元素將名稱屬性。

840
00:41:37,400 --> 00:41:41,870
而這正是PHP使用發送
當表單被提交請求。

841
00:41:41,870 --> 00:41:44,762

842
00:41:44,762 --> 00:41:50,064
>> 觀眾：你提的東西
有關如何如果你使用kittens.jpg或

843
00:41:50,064 --> 00:41:54,410
一些有缺失
文件夾或其他文件？

844
00:41:54,410 --> 00:41:54,750
>> 安琪拉李：是的。

845
00:41:54,750 --> 00:41:57,010
因此，這是什麼所謂的相對
路徑，因為我不會放棄

846
00:41:57,010 --> 00:41:58,740
您的完整路徑。

847
00:41:58,740 --> 00:42:05,160
這就像當以C，如果你做的fopen
一些文件，如果你的fopen hi.txt，那

848
00:42:05,160 --> 00:42:09,190
hi.txt預計是在同一
目錄，除非你給它一個更

849
00:42:09,190 --> 00:42:11,530
複雜的路徑。

850
00:42:11,530 --> 00:42:14,900
>> 觀眾：所以，你可以指定
該文件夾[聽不清]？

851
00:42:14,900 --> 00:42:17,660
>> 安琪拉李：是啊。

852
00:42:17,660 --> 00:42:19,370
並且你可以看看該怎麼做。

853
00:42:19,370 --> 00:42:23,480
但是，如果我想獲得kittens.jpg出
父目錄的，我會做

854
00:42:23,480 --> 00:42:24,730
。/ kittens.jpg。

855
00:42:24,730 --> 00:42:29,680

856
00:42:29,680 --> 00:42:30,930
是啊。

857
00:42:30,930 --> 00:42:32,960

858
00:42:32,960 --> 00:42:33,760
抱歉。

859
00:42:33,760 --> 00:42:34,045
是啊。

860
00:42:34,045 --> 00:42:35,700
哦，天哪，我忘了這個問題。

861
00:42:35,700 --> 00:42:36,460
究竟是什麼問題？

862
00:42:36,460 --> 00:42:39,570
呵呵，問題是就是，kittens.jpg
預計將在同一目錄下？

863
00:42:39,570 --> 00:42:40,630
在這種情況下，它是。

864
00:42:40,630 --> 00:42:44,030
但你也可以給它一定的路徑
例如，它不必須是。

865
00:42:44,030 --> 00:42:47,100

866
00:42:47,100 --> 00:42:48,350
好？

867
00:42:48,350 --> 00:42:50,190

868
00:42:50,190 --> 00:42:51,350
>> CSS。

869
00:42:51,350 --> 00:42:55,420
這樣的CSS，HTML一樣，是不是
一種編程語言。

870
00:42:55,420 --> 00:42:58,250
CSS是只是一系列的樣式規則。

871
00:42:58,250 --> 00:43:00,130
它代表了層疊樣式表。

872
00:43:00,130 --> 00:43:03,910
和你一起使用
使用HTML樣式的頁面。

873
00:43:03,910 --> 00:43:08,140
因此，有三種方式
你可以包含它。

874
00:43:08,140 --> 00:43:11,950
你可以做到這一點的方法之一是在頭部
你的HTML的一部分，你可以只

875
00:43:11,950 --> 00:43:15,410
打開一個風格標籤，然後堅持
一些CSS規則在裡面。

876
00:43:15,410 --> 00:43:16,759
這是非常確定。

877
00:43:16,759 --> 00:43:17,228
是啊。

878
00:43:17,228 --> 00:43:21,449
>> 觀眾：你能不能把那些
風格標籤之間，讓我們

879
00:43:21,449 --> 00:43:22,860
比方說，身體和/身體。

880
00:43:22,860 --> 00:43:27,400
然後你會造型
只有在身體。

881
00:43:27,400 --> 00:43:28,840
>> 安琪拉李：你能。

882
00:43:28,840 --> 00:43:29,590
它會工作。

883
00:43:29,590 --> 00:43:33,990
但你不應該，因為造型
一種元數據，應該在去

884
00:43:33,990 --> 00:43:35,890
您的文檔的頭部。

885
00:43:35,890 --> 00:43:38,280
身體真的應該只包含
什麼是究竟要

886
00:43:38,280 --> 00:43:39,420
顯示您的網頁上。

887
00:43:39,420 --> 00:43:42,155
>> 觀眾：所以你把風格
在你的腦袋樣式化

888
00:43:42,155 --> 00:43:43,930
整個網頁，對不對？

889
00:43:43,930 --> 00:43:44,300
>> 安琪拉李：是啊。

890
00:43:44,300 --> 00:43:50,470
所以把這裡的風格，這些CSS規則
將適用於基於整個頁面

891
00:43:50,470 --> 00:43:52,100
他們的選擇。

892
00:43:52,100 --> 00:43:57,090
所以更好的方式來做到這一點是不是
具有在你的腦袋風格標籤，

893
00:43:57,090 --> 00:44:00,430
你有這樣的鏈接到一個外部的樣式
表像我在向您展示

894
00:44:00,430 --> 00:44:01,980
前面的例子。

895
00:44:01,980 --> 00:44:05,920
這裡做的事情是它嘗試並找到
文件style.css文件，然後拉它

896
00:44:05,920 --> 00:44:08,470
中，並將其用作本
樣式的頁面。

897
00:44:08,470 --> 00:44:10,500
和你的style.css會
只是看起來像這樣。

898
00:44:10,500 --> 00:44:13,330
這純粹是一堆的CSS。

899
00:44:13,330 --> 00:44:16,210
>> 最後，還有另一種方式，你
可以包括CSS，真的你

900
00:44:16,210 --> 00:44:17,480
不應該永遠做。

901
00:44:17,480 --> 00:44:18,950
這是調用內聯樣式。

902
00:44:18,950 --> 00:44:22,650
所以任何HTML元素也可以
取樣式屬性。

903
00:44:22,650 --> 00:44:26,320
然後在該樣式屬性，
你可以給它的CSS規則。

904
00:44:26,320 --> 00:44:29,140
因此，在這種情況下，我是什麼格
定義就在這裡，它要

905
00:44:29,140 --> 00:44:32,580
有一個黑色的背景和
白色的文字顏色。

906
00:44:32,580 --> 00:44:35,620
但你不應該這樣做，因為什麼
但這是它把你的造型

907
00:44:35,620 --> 00:44:36,850
在你的HTML。

908
00:44:36,850 --> 00:44:40,530
>> 我知道，我們一直在談論的HTML
是結構和CSS是樣式。

909
00:44:40,530 --> 00:44:42,790
如果你這樣做，它混合
它們連接在一起。

910
00:44:42,790 --> 00:44:44,550
它不是很乾淨。

911
00:44:44,550 --> 00:44:45,800
所以不要做。

912
00:44:45,800 --> 00:44:47,690

913
00:44:47,690 --> 00:44:52,100
使用CSS的一個例子，在那裡，我們
只需選擇HTML的身體

914
00:44:52,100 --> 00:44:52,380
紀錄片。

915
00:44:52,380 --> 00:44:55,110
和我們一樣，一切都
將是Comic Sans字體。

916
00:44:55,110 --> 00:44:57,290
我也不建議。

917
00:44:57,290 --> 00:44:59,940
但你能做到這一點。

918
00:44:59,940 --> 00:45:03,140
>> 第二條規則就在這裡，這是怎麼回事
選擇的元素

919
00:45:03,140 --> 00:45:04,880
頁面ID為主要。

920
00:45:04,880 --> 00:45:11,690
所以，無論HTML元素，我說的ID
=主，我要去給一個

921
00:45:11,690 --> 00:45:16,020
20像素的邊距和對齊的一切，
所有的文字，到中心。

922
00:45:16,020 --> 00:45:19,030
過去的事情由CSS類選擇。

923
00:45:19,030 --> 00:45:24,450
所以，在頁面上，我給任何元素
一節課，我要使它

924
00:45:24,450 --> 00:45:26,602
淡藍色的背景色。

925
00:45:26,602 --> 00:45:29,380

926
00:45:29,380 --> 00:45:30,040
沒錯。

927
00:45:30,040 --> 00:45:30,700
這就是我的一切。

928
00:45:30,700 --> 00:45:30,890
問題？

929
00:45:30,890 --> 00:45:34,020
>> 觀眾：什麼包括hashtag
之前主要做什麼？

930
00:45:34,020 --> 00:45:36,310
>> 安琪拉李：現在的問題是有哪些呢
之前主要做這個標籤？

931
00:45:36,310 --> 00:45:40,770
在這種情況下，在哈希
CSS是指通過ID選擇。

932
00:45:40,770 --> 00:45:47,490
所以，如果我有一些HTML元素，如
DIVID =主，這個CSS規則選擇

933
00:45:47,490 --> 00:45:49,260
東西用的ID為主。

934
00:45:49,260 --> 00:45:53,940
類似地，在週期中的前
部分是通過CSS類選擇或

935
00:45:53,940 --> 00:45:56,558
通過HTML類選擇。

936
00:45:56,558 --> 00:46:00,940
>> 觀眾：為什麼會出現一個有前
在背景顏色6？

937
00:46:00,940 --> 00:46:01,270
>> 安琪拉李：是啊。

938
00:46:01,270 --> 00:46:03,360
所以，問題是，為什麼會出現
6前一個哈希？

939
00:46:03,360 --> 00:46:05,320
這是比散列不同。

940
00:46:05,320 --> 00:46:09,500
這意味著，你給
一個十六進制顏色。

941
00:46:09,500 --> 00:46:14,260
所以十六進制的顏色，這只是
代表色。

942
00:46:14,260 --> 00:46:17,860
你還記得的RGB三元組時，
你做了取證PSET？

943
00:46:17,860 --> 00:46:18,770
這是類似的。

944
00:46:18,770 --> 00:46:21,590
前兩個數字代表
多少是紅色的顏色。

945
00:46:21,590 --> 00:46:23,260
後兩個代表
多少綠色。

946
00:46:23,260 --> 00:46:25,450
和第三指
多少藍。

947
00:46:25,450 --> 00:46:30,060
和散列這是怎麼回事
來表示一種顏色。

948
00:46:30,060 --> 00:46:35,660
>> 所以從0，0，0，0，0，0的任何
高達F，F，F，F，F，F是有效的。

949
00:46:35,660 --> 00:46:39,550
這是一些有效的顏色，可以
您的瀏覽器顯示。

950
00:46:39,550 --> 00:46:39,790
問題？

951
00:46:39,790 --> 00:46:43,590
>> 觀眾：什麼是之間的區別
利用ID和類？

952
00:46:43,590 --> 00:46:46,470
>> 安琪拉李：現在的問題是什麼
之間的差

953
00:46:46,470 --> 00:46:48,950
利用ID和類？

954
00:46:48,950 --> 00:46:54,390
你只能有一個一個元素
具有給定的ID的HTML文檔。

955
00:46:54,390 --> 00:46:58,660
所以只有一件事在我的網頁
允許有ID為主。

956
00:46:58,660 --> 00:47:02,580
所以你使用它，這是頭。

957
00:47:02,580 --> 00:47:03,850
這是導航。

958
00:47:03,850 --> 00:47:05,230
這是頁腳。

959
00:47:05,230 --> 00:47:09,070
類是不同的，因為你可以
應用類，以盡可能多的HTML元素

960
00:47:09,070 --> 00:47:10,100
只要你想。

961
00:47:10,100 --> 00:47:15,860
>> 因此，舉例來說，我做了類部分，
因為有可能不止一個

962
00:47:15,860 --> 00:47:17,540
部分在我的網頁。

963
00:47:17,540 --> 00:47:20,200
你只是允許有多達
用相同的頁面上的元素

964
00:47:20,200 --> 00:47:23,190
類，但只有一個具有一定標識。

965
00:47:23,190 --> 00:47:25,600
>> 觀眾：所以圓點代表
類？

966
00:47:25,600 --> 00:47:26,090
>> 安琪拉李：是啊。

967
00:47:26,090 --> 00:47:27,380
一個點代表一個類。

968
00:47:27,380 --> 00:47:29,990

969
00:47:29,990 --> 00:47:31,540
涼爽。

970
00:47:31,540 --> 00:47:32,370
這就是我的一切，伙計們。

971
00:47:32,370 --> 00:47:33,544
謝謝。

972
00:47:33,544 --> 00:48:13,380
>> [掌聲]

973
00:48:13,380 --> 00:48:14,290
>> ZAMYLA陳：嗨，大家好。

974
00:48:14,290 --> 00:48:14,880
我Zamyla。

975
00:48:14,880 --> 00:48:18,830
我將要覆蓋的PHP，
MVC和SQL今天。

976
00:48:18,830 --> 00:48:22,350

977
00:48:22,350 --> 00:48:26,110
很多，我會的材料
覆蓋將是相當多

978
00:48:26,110 --> 00:48:29,100
右出pset7的。

979
00:48:29,100 --> 00:48:29,700
好的。

980
00:48:29,700 --> 00:48:31,180
那麼，什麼是PHP？

981
00:48:31,180 --> 00:48:35,150
PHP代表PHP超文本
預處理器。

982
00:48:35,150 --> 00:48:38,740
所以，本身是一個遞歸
命名，這是很酷。

983
00:48:38,740 --> 00:48:42,220
PHP是一種服務器端腳本語言，
和它所提供的後端

984
00:48:42,220 --> 00:48:44,610
和邏輯基礎
我們的網站。

985
00:48:44,610 --> 00:48:48,520
>> 所以安吉拉談了很多有關HTML
和CSS，這將使結構

986
00:48:48,520 --> 00:48:49,530
本網站。

987
00:48:49,530 --> 00:48:53,210
但是，如果你想改變什麼
動態或者如果它的內容各不相同

988
00:48:53,210 --> 00:48:55,240
基於用戶或
一定條件下？

989
00:48:55,240 --> 00:48:57,060
這就是PHP的用武之地。

990
00:48:57,060 --> 00:49:02,610
現在，通常情況下，PHP可能需要幾分鐘
少來實現同樣的事情線

991
00:49:02,610 --> 00:49:07,380
在C這是因為PHP處理內存
管理的程序員，

992
00:49:07,380 --> 00:49:11,170
而不是我們不得不的malloc
自由，這樣的事情。

993
00:49:11,170 --> 00:49:15,430
>> 但是，由於PHP是一種解釋
語言，典型地，它可能執行

994
00:49:15,430 --> 00:49:19,540
比C多一點緩慢，這
是編譯型語言。

995
00:49:19,540 --> 00:49:23,150
因為我們正在規劃
語言，讓我們來看看如何

996
00:49:23,150 --> 00:49:24,570
語法將有所不同。

997
00:49:24,570 --> 00:49:28,770
讓我們必須非常小心，不要
感到困惑與此有關。

998
00:49:28,770 --> 00:49:33,750
綜上所述，使用PHP語法，無論你是
嵌入你的PHP的HTML裡面

999
00:49:33,750 --> 00:49:40,430
文件或在。php文件本身，你
需要附上代碼開放

1000
00:49:40,430 --> 00:49:45,270
PHP和封閉的PHP標籤像
如下，喜歡在屏幕上。

1001
00:49:45,270 --> 00:49:46,660
>> PHP中的變量。

1002
00:49:46,660 --> 00:49:51,490
每一個變量將開始
$符號後面的名字

1003
00:49:51,490 --> 00:49:53,150
您的變量。

1004
00:49:53,150 --> 00:49:56,530
現在，在PHP中的變量鬆散類型，
這意味著你不需要

1005
00:49:56,530 --> 00:50:00,030
要說明什麼數據類型
是當你聲明它。

1006
00:50:00,030 --> 00:50:03,505
然而，這並不意味著它們
不具有任何類型的。

1007
00:50:03,505 --> 00:50:09,370
所以，如果我聲明了一個變量，只設置
它等於1，然後我聲明

1008
00:50:09,370 --> 00:50:15,140
另一個變量，將其設置為“1”
然後另外一個1.0，好了，

1009
00:50:15,140 --> 00:50:19,410
根據平等的類型
運營商我用，如果我想比較

1010
00:50:19,410 --> 00:50:21,830
在所有類型，然後
他們將是平等的。

1011
00:50:21,830 --> 00:50:25,570
但是，如果我想確保了
類型相同，PHP還可以做

1012
00:50:25,570 --> 00:50:28,690
如此，即使我們並不表明
它是什麼類型時，我們

1013
00:50:28,690 --> 00:50:31,170
先使文件。

1014
00:50:31,170 --> 00:50:33,990
>> 現在，在PHP中，即使我們
從編程切換

1015
00:50:33,990 --> 00:50:39,360
在C語言中，我們仍然有我們的
值得信賴的if條件，就是這樣。

1016
00:50:39,360 --> 00:50:43,270
我們仍然有我們的while循環，只
這樣，你把你的

1017
00:50:43,270 --> 00:50:47,300
狀態，然後在
體循環。

1018
00:50:47,300 --> 00:50:50,360
然後我們也有我們的for循環，
通常看起來像這樣。

1019
00:50:50,360 --> 00:50:55,330
所以，如果我想遍歷所有
9 pset和提交，並調用

1020
00:50:55,330 --> 00:50:58,960
功能submitPset，那麼我就可以做到這一點
在這裡，這你們都

1021
00:50:58,960 --> 00:50:59,830
由這點做的。

1022
00:50:59,830 --> 00:51:01,080
恭喜，順便說一句。

1023
00:51:01,080 --> 00:51:04,560

1024
00:51:04,560 --> 00:51:07,550
>> 對於攝像頭，人
說，謝謝你。

1025
00:51:07,550 --> 00:51:11,220
現在，如果你不想只是用這個
for循環，那麼PHP居然還

1026
00:51:11,220 --> 00:51:13,580
有東西叫做foreach循環。

1027
00:51:13,580 --> 00:51:22,210
所以，如果我有一個整數數組，0
通過8中，存儲在陣列的pset，

1028
00:51:22,210 --> 00:51:27,290
然後我可以有一個foreach循環，
遍歷在pset中的每一個數字。

1029
00:51:27,290 --> 00:51:30,640
然後我可以調用相同
功能8倍，

1030
00:51:30,640 --> 00:51:31,910
就像我以前那樣。

1031
00:51:31,910 --> 00:51:36,480
因此，這對每個迴路是好的，因為
你不必，如果你不知道

1032
00:51:36,480 --> 00:51:39,470
陣列的確切長度，你
有，然後使用這個foreach循環

1033
00:51:39,470 --> 00:51:42,800
將採取照顧你。

1034
00:51:42,800 --> 00:51:45,410
>> 所以我做的pset為一個數組。

1035
00:51:45,410 --> 00:51:46,700
讓我們來看看這個。

1036
00:51:46,700 --> 00:51:51,290
在PHP數組通常是一樣的
我們已經在C中，那些地方

1037
00:51:51,290 --> 00:51:52,960
你可以聲明一個數組。

1038
00:51:52,960 --> 00:51:59,200
在這裡，我可以聲明一個空數組
然後動態地使用建立

1039
00:51:59,200 --> 00:52:00,850
指數為整數。

1040
00:52:00,850 --> 00:52:04,140
所以索引0，我要存儲
一個整數命名1。

1041
00:52:04,140 --> 00:52:09,210
在我的清單索引1，我要去
存儲值2。

1042
00:52:09,210 --> 00:52:12,670
以及第三索引，但在
第二個數字，我要去

1043
00:52:12,670 --> 00:52:14,870
儲存號碼12。

1044
00:52:14,870 --> 00:52:17,250
>> 現在，這是罰款，這
工作效果很好。

1045
00:52:17,250 --> 00:52:21,310
但說是我的問題
什麼每個索引保存。

1046
00:52:21,310 --> 00:52:24,500
對於我來說，索引0表示如何
許多貓我有。

1047
00:52:24,500 --> 00:52:27,400
和索引1表示如何
許多貓頭鷹我。

1048
00:52:27,400 --> 00:52:29,450
和下一個意思有多少狗。

1049
00:52:29,450 --> 00:52:34,140
好吧，那麼它來指定，而不是
不必記住0涉及

1050
00:52:34,140 --> 00:52:38,090
貓和1至貓頭鷹，我可以使用
關聯數組，表示

1051
00:52:38,090 --> 00:52:42,260
而不是整數作為我的指標，
其實我可以使用字符串。

1052
00:52:42,260 --> 00:52:43,290
>> 所以這是非常有用的。

1053
00:52:43,290 --> 00:52:47,130
你已經基本上只是更換
整數與字符串。

1054
00:52:47,130 --> 00:52:50,074
有你有一個
關聯數組。

1055
00:52:50,074 --> 00:52:51,930
是啊。

1056
00:52:51,930 --> 00:52:55,800
>> 觀眾：還有一個原因為什麼有
下劃線第二

1057
00:52:55,800 --> 00:52:58,750
的一部分，因為我的列表中有數組。

1058
00:52:58,750 --> 00:53:01,330
>> ZAMYLA陳：現在的問題是，現在是
還有一個原因是有一個

1059
00:53:01,330 --> 00:53:03,320
我和列表之間的底線？

1060
00:53:03,320 --> 00:53:03,610
號

1061
00:53:03,610 --> 00:53:06,878
這只是我如何命名
我的變量。

1062
00:53:06,878 --> 00:53:11,670
>> 觀眾：在第一
線，它的一個字。

1063
00:53:11,670 --> 00:53:12,560
>> ZAMYLA陳：我的道歉。

1064
00:53:12,560 --> 00:53:13,410
我會解決這個問題。

1065
00:53:13,410 --> 00:53:13,620
是啊。

1066
00:53:13,620 --> 00:53:15,460
他們應該是相同的變量名。

1067
00:53:15,460 --> 00:53:16,710
良好的漁獲物。

1068
00:53:16,710 --> 00:53:19,640

1069
00:53:19,640 --> 00:53:19,950
確定。

1070
00:53:19,950 --> 00:53:22,610
所以，讓我們繼續為字符串
串聯。

1071
00:53:22,610 --> 00:53:27,500
如果我想採取兩個字符串，
然後我就可以將它們串聯

1072
00:53:27,500 --> 00:53:28,550
用點操作符。

1073
00:53:28,550 --> 00:53:32,440
所以，如果我有米洛的名字
與香蕉作為姓氏，然後

1074
00:53:32,440 --> 00:53:35,430
與點運算符和串聯
然後把一個空間之間

1075
00:53:35,430 --> 00:53:39,210
將包含米洛的字符串
香蕉，我就可以回顯或，

1076
00:53:39,210 --> 00:53:41,280
相反，打印出來。

1077
00:53:41,280 --> 00:53:44,465
>> 說到迴聲，讓我們來談談
約了幾個有用的 - 

1078
00:53:44,465 --> 00:53:44,920
哎呀。

1079
00:53:44,920 --> 00:53:46,030
對不起。

1080
00:53:46,030 --> 00:53:52,920
一些有用的PHP函數。

1081
00:53:52,920 --> 00:53:56,240
所以，我們有 - 

1082
00:53:56,240 --> 00:53:57,444
技術上的困難。

1083
00:53:57,444 --> 00:53:58,694
一秒鐘。

1084
00:53:58,694 --> 00:54:16,960

1085
00:54:16,960 --> 00:54:19,550
我送它。

1086
00:54:19,550 --> 00:54:22,320
PowerPoint中的問題。

1087
00:54:22,320 --> 00:54:29,200
我們回來了PHP函數。

1088
00:54:29,200 --> 00:54:32,010

1089
00:54:32,010 --> 00:54:35,150
我們回來了PHP函數。

1090
00:54:35,150 --> 00:54:39,890
>> 因此，我們需要的函數，其中
如果你傳遞一個文件，這裡的只是

1091
00:54:39,890 --> 00:54:43,300
一個文件的一個例子是
我可能會傳遞英寸

1092
00:54:43,300 --> 00:54:47,605
然後，將包含PHP代碼
從該文件中，我指出。

1093
00:54:47,605 --> 00:54:49,940
它會評估，在。

1094
00:54:49,940 --> 00:54:54,450
那麼我們也有回音，這
是一個平行的printf。

1095
00:54:54,450 --> 00:54:57,710
退出是一個平行的斷裂，
其中出口的塊

1096
00:54:57,710 --> 00:54:58,570
你是英寸代碼

1097
00:54:58,570 --> 00:55:03,180
然後空檢查是否給定的
變量就像是null或零或

1098
00:55:03,180 --> 00:55:08,482
無論是等同於為空。

1099
00:55:08,482 --> 00:55:09,438
是啊。

1100
00:55:09,438 --> 00:55:15,341
>> 觀眾：對於字符串連接
點運算符之一，在PHP中，就是

1101
00:55:15,341 --> 00:55:20,158
相同的JavaScript那裡它使用
點串聯的意思加？

1102
00:55:20,158 --> 00:55:27,440
因此，對於全名，你可以有美元
簽署第一+，然後+持續多久？

1103
00:55:27,440 --> 00:55:27,720
>> ZAMYLA陳：是的。

1104
00:55:27,720 --> 00:55:32,150
所以現在的問題是，是否在PHP中，我們
可以使用相同的字符串連接

1105
00:55:32,150 --> 00:55:33,890
如在JavaScript中的加號。

1106
00:55:33,890 --> 00:55:35,410
約瑟將進入的後來。

1107
00:55:35,410 --> 00:55:36,620
我想他對一個幻燈片。

1108
00:55:36,620 --> 00:55:37,570
其實，這是不同的。

1109
00:55:37,570 --> 00:55:41,310
所以在JavaScript中，你需要使用
加來連接字符串。

1110
00:55:41,310 --> 00:55:43,280
而在PHP中，你必須
使用點運算符。

1111
00:55:43,280 --> 00:55:44,530
因此，它們是不同的。

1112
00:55:44,530 --> 00:55:46,680

1113
00:55:46,680 --> 00:55:46,910
>> 確定。

1114
00:55:46,910 --> 00:55:49,500
所以，現在我們已經涵蓋了所有
這個PHP，它在哪裡

1115
00:55:49,500 --> 00:55:50,490
真正派上用場？

1116
00:55:50,490 --> 00:55:54,470
那麼，它派上用場的時候，我們
可以與我們的HTML相結合。

1117
00:55:54,470 --> 00:55:59,550
所以，我們的PHP會給我們的力量
改變頁面的HTML內容之前，

1118
00:55:59,550 --> 00:56:00,000
它的加載。

1119
00:56:00,000 --> 00:56:04,270
這樣根據不同的條件，
通常在特定的用戶那

1120
00:56:04,270 --> 00:56:07,520
登錄後，我們就可以顯示
不同的信息。

1121
00:56:07,520 --> 00:56:08,800
琳達，你有問題嗎？

1122
00:56:08,800 --> 00:56:15,510
>> 觀眾：你能串連
一個整數也？

1123
00:56:15,510 --> 00:56:16,760
>> ZAMYLA陳：是的，可以。

1124
00:56:16,760 --> 00:56:19,530

1125
00:56:19,530 --> 00:56:23,270
所以現在的問題是，如果你能
串連整數或其他

1126
00:56:23,270 --> 00:56:28,920
variable.s現在，我們進入到MVC，這
的是，我們在使用一個範例

1127
00:56:28,920 --> 00:56:33,380
pset7和很多網頁設計者使用
組織代碼中的文件

1128
00:56:33,380 --> 00:56:34,490
在他們的網站。

1129
00:56:34,490 --> 00:56:35,870
M代表模型。

1130
00:56:35,870 --> 00:56:41,450
基本上，模型文件將處理
與數據庫交互。

1131
00:56:41,450 --> 00:56:44,640
查看文件，它們涉及到了
本網站的美觀性。

1132
00:56:44,640 --> 00:56:47,550
和控制器處理
用戶請求，解析

1133
00:56:47,550 --> 00:56:49,230
數據，做其他的邏輯。

1134
00:56:49,230 --> 00:56:52,520
>> 在pset7，我們結合模型
和控制器。

1135
00:56:52,520 --> 00:56:55,880
我們只是叫他們和控制器
把它們放在公共目錄。

1136
00:56:55,880 --> 00:57:01,730
和視圖文件，我們把它們作為
模板中的模板目錄。

1137
00:57:01,730 --> 00:57:07,260
所以這裡這個圖也代表
與同類型的劃分

1138
00:57:07,260 --> 00:57:10,510
模型和紫色控制器
這裡在左邊和

1139
00:57:10,510 --> 00:57:12,770
右邊的圖。

1140
00:57:12,770 --> 00:57:16,020
因此，這是一個示意圖，是你們中的一些
可能已經看到在辦公時間或

1141
00:57:16,020 --> 00:57:19,130
我們被繪製為您圖解
是搞清楚你的​​pset中。

1142
00:57:19,130 --> 00:57:25,030
>> 因此，這裡，在一個給定的控制器，一個模型
控制器，我們有功能

1143
00:57:25,030 --> 00:57:30,490
這涉及到查詢的SQL
數據庫，PHP的執行邏輯。

1144
00:57:30,490 --> 00:57:32,370
也許你會抬頭
在雅虎股票

1145
00:57:32,370 --> 00:57:34,590
財務。

1146
00:57:34,590 --> 00:57:37,390
或許，你只是要檢查
看看用戶是否提交了一份

1147
00:57:37,390 --> 00:57:40,250
有之前就已經形成
訪問你的頁面。

1148
00:57:40,250 --> 00:57:43,390
然後你會渲染
一個形成在這裡。

1149
00:57:43,390 --> 00:57:48,210
已提交的表單後曾
由用戶，這是動作

1150
00:57:48,210 --> 00:57:53,470
在表單的HTML標記指定
將指示該頁面，它

1151
00:57:53,470 --> 00:57:55,620
返回的數據。

1152
00:57:55,620 --> 00:57:59,460
>> 因此，所有這些信息將
發送回您的控制器。

1153
00:57:59,460 --> 00:58:02,620
那麼你可能會做多一點
在這一邏輯，也許執行了幾個

1154
00:58:02,620 --> 00:58:06,510
在SQL數據庫的詳細查詢和
然後，終於，想出了一個很好的

1155
00:58:06,510 --> 00:58:11,930
包裝組信息，你會
傳遞到一些其他的模板

1156
00:58:11,930 --> 00:58:13,950
所顯示的信息。

1157
00:58:13,950 --> 00:58:17,030
現在，我們到底怎麼打包
這些信息呢？

1158
00:58:17,030 --> 00:58:23,980
好了，我們有一個叫做渲染功能
那是在functions.php文件

1159
00:58:23,980 --> 00:58:29,950
pset7，在那裡你傳遞的名義
一個文件，一個模板的名稱。

1160
00:58:29,950 --> 00:58:32,160
>> 然後你也傳遞
一個關聯數組。

1161
00:58:32,160 --> 00:58:37,150
並且使關聯數組表示
不同的信息

1162
00:58:37,150 --> 00:58:39,040
要傳遞英寸

1163
00:58:39,040 --> 00:58:43,460
現在，將是在不斷的
這些例子是，鑰匙，或

1164
00:58:43,460 --> 00:58:47,070
而是，關聯的鍵
數組，這些都是正在發生的事情是

1165
00:58:47,070 --> 00:58:51,050
預期由模板常數，
因為它知道它需要

1166
00:58:51,050 --> 00:58:53,990
一些所謂的消息
或者叫名字。

1167
00:58:53,990 --> 00:58:56,940
然後在右邊的東西，在
實際值，所以在這種情況下，誰的

1168
00:58:56,940 --> 00:59:00,750
一個好男孩和米洛，那些打算
是正在改變的值

1169
00:59:00,750 --> 00:59:05,610
該控制器每一次改變
或基於某一條件和

1170
00:59:05,610 --> 00:59:07,120
將傳遞英寸

1171
00:59:07,120 --> 00:59:12,790
>> 所以在這裡在模板中，我們看到我們
使用HTML特殊字符，

1172
00:59:12,790 --> 00:59:16,370
這只是基本上意味著我們要
得到同行的字符串，該

1173
00:59:16,370 --> 00:59:17,580
用戶放進去。

1174
00:59:17,580 --> 00:59:20,880
我們想替換
在那裡的消息。

1175
00:59:20,880 --> 00:59:26,110
所以後來當我們真正看到
該文件，該特定

1176
00:59:26,110 --> 00:59:28,700
信息傳入

1177
00:59:28,700 --> 00:59:33,850
請注意，關鍵是如何呈現的作品是
該締合的鍵

1178
00:59:33,850 --> 00:59:37,170
數組，這些成為變量
名字在這裡。

1179
00:59:37,170 --> 00:59:40,720
所以在該鍵的值
關聯數組，然後成為

1180
00:59:40,720 --> 00:59:41,970
該變量的值。

1181
00:59:41,970 --> 00:59:44,800

1182
00:59:44,800 --> 00:59:46,040
>> 現在，讓我們進入到SQL。

1183
00:59:46,040 --> 00:59:48,010
它代表結構
查詢語言。

1184
00:59:48,010 --> 00:59:50,460
所以這只是一個編程
語言設計

1185
00:59:50,460 --> 00:59:51,880
用於管理數據庫。

1186
00:59:51,880 --> 00:59:56,860
它派上了用場，我們在
我們pset7財經網站。

1187
00:59:56,860 --> 01:00:00,510
從本質上講，它只是一個簡單的方法來
跟踪和管理對象和表

1188
01:00:00,510 --> 01:00:02,070
並將其鏈接到對方。

1189
01:00:02,070 --> 01:00:06,860
現在，想想你的SQL數據庫中
基本上作為一個Excel文件，或許，

1190
01:00:06,860 --> 01:00:10,040
多標籤頁。

1191
01:00:10,040 --> 01:00:13,820
>> 所以，你可以有多個表，
也許，彼此連接。

1192
01:00:13,820 --> 01:00:19,420
而就像Excel中，我們有很多的
我們想要的功能。

1193
01:00:19,420 --> 01:00:22,300
例如，我們可以選擇
某些行。

1194
01:00:22,300 --> 01:00:24,110
我們可以插入信息。

1195
01:00:24,110 --> 01:00:25,560
我們可以更新的行。

1196
01:00:25,560 --> 01:00:27,440
而且我們還可以刪除的東西。

1197
01:00:27,440 --> 01:00:30,920

1198
01:00:30,920 --> 01:00:36,560
>> 通過選擇行的SQL選擇作品
或行從一個指定的列

1199
01:00:36,560 --> 01:00:39,640
數據庫匹配有一定
標準，你指出。

1200
01:00:39,640 --> 01:00:44,930
所以，在這裡，當我看到選擇*從
巫師那裡的房子=拉文克勞，然後

1201
01:00:44,930 --> 01:00:48,340
我選擇*，這意味著我
在選擇每一個列

1202
01:00:48,340 --> 01:00:56,340
從奇才表，但只有當排
房子列等於拉文克勞。

1203
01:00:56,340 --> 01:00:57,840
現在，這是純粹的或SQL。

1204
01:00:57,840 --> 01:01:02,680
所以，如果我進入phpMyAdmin的，這是
我們使用管理的具體辦法

1205
01:01:02,680 --> 01:01:07,040
我們的SQL數據庫，那麼我可以插入
即進入phpMyAdmin的網站。

1206
01:01:07,040 --> 01:01:08,290
並且將執行。

1207
01:01:08,290 --> 01:01:11,280
>> 但我們真正想要做的
這在PHP端。

1208
01:01:11,280 --> 01:01:12,580
那麼，如何才能做到這一點？

1209
01:01:12,580 --> 01:01:20,180
好了，我們使用查詢功能，
基本上執行的SQL查詢。

1210
01:01:20,180 --> 01:01:21,830
使用？

1211
01:01:21,830 --> 01:01:25,850
作為一個佔位符，我們可以通過在某些
值，以我們的字符串，我們

1212
01:01:25,850 --> 01:01:26,920
要更換。

1213
01:01:26,920 --> 01:01:32,110
所以也許我存儲不同
在curr_house值，這

1214
01:01:32,110 --> 01:01:34,400
代表了目前房子
我正在經歷的一切。

1215
01:01:34,400 --> 01:01:39,040
這樣我就可以把它傳遞作為佔位符
與問號。

1216
01:01:39,040 --> 01:01:43,290
然後我就基本上執行
同樣的事情，我做之前，除

1217
01:01:43,290 --> 01:01:45,550
現在，我在PHP。

1218
01:01:45,550 --> 01:01:51,300
>> 和查詢將返回一個
關聯數組。

1219
01:01:51,300 --> 01:01:53,470
我要去把它存儲在列。

1220
01:01:53,470 --> 01:01:56,880
現在，查詢可以總是失敗。

1221
01:01:56,880 --> 01:02:02,870
也許SQL查詢不能執行
因為表不存在。

1222
01:02:02,870 --> 01:02:04,310
或者，該列中不存在。

1223
01:02:04,310 --> 01:02:05,400
出事了。

1224
01:02:05,400 --> 01:02:08,170
那麼，在這種情況下，你會希望
確保您檢查是否

1225
01:02:08,170 --> 01:02:09,700
查詢返回false。

1226
01:02:09,700 --> 01:02:15,590
這就是使用三
等於操作有。

1227
01:02:15,590 --> 01:02:19,660
>> 然後我道歉，這是另一種
CS50函數，傳遞一個消息。

1228
01:02:19,660 --> 01:02:23,435
如果你看看道歉，這一切
確實是呈現apology.php。

1229
01:02:23,435 --> 01:02:26,100

1230
01:02:26,100 --> 01:02:26,410
是啊。

1231
01:02:26,410 --> 01:02:29,630
>> 觀眾：你能解釋一下是什麼
選擇並從恆星之間呢？

1232
01:02:29,630 --> 01:02:30,710
>> ZAMYLA陳：是的，絕對。

1233
01:02:30,710 --> 01:02:35,220
因此，在選擇和之間的明星
也就是說，我要選擇整個

1234
01:02:35,220 --> 01:02:37,440
從我的桌子整行。

1235
01:02:37,440 --> 01:02:41,900
我可能已經表示選擇
名稱，年份，房子。

1236
01:02:41,900 --> 01:02:46,160
而我只得到這三個
列在我的表。

1237
01:02:46,160 --> 01:02:51,560
但如果我說選擇*，然後我會
得到一切在該列中。

1238
01:02:51,560 --> 01:02:53,760
然後我會去你
在後面的第一個。

1239
01:02:53,760 --> 01:02:57,656
>> 觀眾：所以這仍然是
在SQL中，對不對？

1240
01:02:57,656 --> 01:02:59,610
這是查詢還是這個PHP？

1241
01:02:59,610 --> 01:03:00,550
>> ZAMYLA陳：我們正處在一個查詢中。

1242
01:03:00,550 --> 01:03:01,940
所以這是在PHP。

1243
01:03:01,940 --> 01:03:06,280
因此，使用PHP函數查詢，
我們正在執行一個SQL查詢。

1244
01:03:06,280 --> 01:03:11,988

1245
01:03:11,988 --> 01:03:15,364
>> 觀眾：是在SQL什麼
區分大小寫，如選擇

1246
01:03:15,364 --> 01:03:17,834
或嚮導或房子？

1247
01:03:17,834 --> 01:03:20,050
>> ZAMYLA陳：是什麼
在SQL區分大小寫？

1248
01:03:20,050 --> 01:03:21,760
我相信是這樣，是的。

1249
01:03:21,760 --> 01:03:24,620
我相信，選擇和
和WHERE是區分大小寫的。

1250
01:03:24,620 --> 01:03:25,535
沒有？

1251
01:03:25,535 --> 01:03:27,500
>> ROB BOWDEN：所以，這是相反的。

1252
01:03:27,500 --> 01:03:32,030
列名和表的手段，
所有這些都是區分大小寫的。

1253
01:03:32,030 --> 01:03:35,470
但任何MySQL的關鍵詞，如
SELECT，FROM和WHERE，這些都不是

1254
01:03:35,470 --> 01:03:36,140
區分大小寫。

1255
01:03:36,140 --> 01:03:36,420
確定。

1256
01:03:36,420 --> 01:03:37,780
所以，我說的是相反的。

1257
01:03:37,780 --> 01:03:40,420
因此，所有的MySQL的關鍵字 - 

1258
01:03:40,420 --> 01:03:42,670
選擇從，在那裡 - 那些
不區分大小寫。

1259
01:03:42,670 --> 01:03:44,630
但一切是。

1260
01:03:44,630 --> 01:03:45,210
確定。

1261
01:03:45,210 --> 01:03:46,500
你在前面。

1262
01:03:46,500 --> 01:03:52,041
>> 觀眾：如果我有$來講行
多行，意思是

1263
01:03:52,041 --> 01:03:53,640
只是變成一個關聯數組？

1264
01:03:53,640 --> 01:03:59,550
>> ZAMYLA陳：所以現在的問題是，如果行
有一個以上的列在其中，並

1265
01:03:59,550 --> 01:04:01,800
它成為一個關聯數組？

1266
01:04:01,800 --> 01:04:05,680
因此它是可結合的陣列
陣列了。

1267
01:04:05,680 --> 01:04:10,730
所以，即使只有一個行
回來了，那麼你必須去

1268
01:04:10,730 --> 01:04:12,690
這一結果的索引為0。

1269
01:04:12,690 --> 01:04:15,316
然後你就會有第一行。

1270
01:04:15,316 --> 01:04:17,482
是的，貝琳達？

1271
01:04:17,482 --> 01:04:21,258
>> 觀眾：當你使用===，
這是唯一的實例？

1272
01:04:21,258 --> 01:04:22,210
還是有其他人呢？

1273
01:04:22,210 --> 01:04:26,815
>> ZAMYLA陳：所以在這種情況下，===
是跨類型的比較。

1274
01:04:26,815 --> 01:04:29,870

1275
01:04:29,870 --> 01:04:34,050
抱歉。 ===是一個比較
用於比較的類型。

1276
01:04:34,050 --> 01:04:37,620
然後==在所有類型的比較。

1277
01:04:37,620 --> 01:04:41,620
>> 觀眾：你能解釋一下
行是在這種情況呢？

1278
01:04:41,620 --> 01:04:45,120
它是一行數據？

1279
01:04:45,120 --> 01:04:48,100
>> ZAMYLA陳：在接下來的幻燈片，我
將解釋什麼是行。

1280
01:04:48,100 --> 01:04:49,890
所以，如果你不介意持有
關上了。

1281
01:04:49,890 --> 01:04:50,620
然後你在後面？

1282
01:04:50,620 --> 01:04:54,699
>> 觀眾：對於像查詢功能，
渲染和道歉[聽不清]？

1283
01:04:54,699 --> 01:04:59,050

1284
01:04:59,050 --> 01:05:03,050
>> ZAMYLA陳：現在的問題是，是否
這些功能 - 查詢，道歉，

1285
01:05:03,050 --> 01:05:04,510
和渲染 - 

1286
01:05:04,510 --> 01:05:05,930
是通用的PHP。

1287
01:05:05,930 --> 01:05:09,460
這些都是那些CS50
寫了pset7。

1288
01:05:09,460 --> 01:05:09,910
和傑伊？

1289
01:05:09,910 --> 01:05:15,333
>> 觀眾：當你需要說
$ _SESSION，是只為ID嗎？

1290
01:05:15,333 --> 01:05:17,310
或者可能你說過嗎？

1291
01:05:17,310 --> 01:05:23,440
>> ZAMYLA陳：所以現在的問題是，當
我們使用$ _SESSION，這是一個特定的

1292
01:05:23,440 --> 01:05:25,290
我們正在使用的全局變量。

1293
01:05:25,290 --> 01:05:32,080
在這裡，這個變量將
是本地的我們的函數。

1294
01:05:32,080 --> 01:05:36,588
所以，我們只是聲明
一個新的變量。

1295
01:05:36,588 --> 01:05:38,460
>> 觀眾：如何道歉
實施？

1296
01:05:38,460 --> 01:05:40,960
>> ZAMYLA陳：現在的問題是，
是如何實現的道歉？

1297
01:05:40,960 --> 01:05:44,180
我認為這實際上是一個非常
好習慣為你們進入

1298
01:05:44,180 --> 01:05:49,260
在functions.php的部分和看
道歉，看看你可以有

1299
01:05:49,260 --> 01:05:50,670
做你自己。

1300
01:05:50,670 --> 01:05:55,620
所以，我可以留給你，但只是
說，如果你道歉，

1301
01:05:55,620 --> 01:06:02,110
那麼它需要的信息是，你
提交道歉，然後將其

1302
01:06:02,110 --> 01:06:06,570
呈現該消息。

1303
01:06:06,570 --> 01:06:08,240
還有什麼問題嗎？

1304
01:06:08,240 --> 01:06:08,710
我愛的問題。

1305
01:06:08,710 --> 01:06:09,555
所以回頭率。

1306
01:06:09,555 --> 01:06:11,888
>> 觀眾：[聽不清]

1307
01:06:11,888 --> 01:06:13,840
echo或print那裡？

1308
01:06:13,840 --> 01:06:15,900
>> ZAMYLA陳：現在的問題是，
我們不能只是已經把

1309
01:06:15,900 --> 01:06:17,000
echo或print那裡。

1310
01:06:17,000 --> 01:06:19,710
讓會做什麼
略有不同。

1311
01:06:19,710 --> 01:06:23,750
那將打印出來的查詢
沒成 - 

1312
01:06:23,750 --> 01:06:27,420
好了，現在，我們實際上
在我們的控制器。

1313
01:06:27,420 --> 01:06:30,350
所以我們實際上沒有
HTML設在這裡。

1314
01:06:30,350 --> 01:06:34,946
通過渲染apologize.php道歉
實際上將您重定向到apology.php。

1315
01:06:34,946 --> 01:06:39,560

1316
01:06:39,560 --> 01:06:42,200
確定。

1317
01:06:42,200 --> 01:06:45,880
>> 所以，現在，讓我們去解決
從早期的問題是關於什麼

1318
01:06:45,880 --> 01:06:47,330
真的是行。

1319
01:06:47,330 --> 01:06:51,960
那麼，查詢將返回
列的陣列。

1320
01:06:51,960 --> 01:06:55,020
而每一行代表
通過一個關聯數組。

1321
01:06:55,020 --> 01:07:02,840
所以，如果我執行一些SQL查詢，
我已經存儲的結果行，然後

1322
01:07:02,840 --> 01:07:07,850
使用foreach循環，那麼陣列
名字是有第一個 - 行。

1323
01:07:07,850 --> 01:07:13,170
然後我要去打電話
每一行中有$行。

1324
01:07:13,170 --> 01:07:20,060
>> 這樣遍歷了，然後我就可以
訪問給定行的名稱列，

1325
01:07:20,060 --> 01:07:22,340
年柱，和房子列。

1326
01:07:22,340 --> 01:07:28,010
請注意，我不會已經能夠
做這個行，因為行的索引

1327
01:07:28,010 --> 01:07:29,290
名稱不存在。

1328
01:07:29,290 --> 01:07:31,970
行是只是一個數組
關聯數組。

1329
01:07:31,970 --> 01:07:34,870
所以，你有兩個層面存在。

1330
01:07:34,870 --> 01:07:37,170
一旦你有行的數組，
你必須去那個。

1331
01:07:37,170 --> 01:07:39,110
然後你就可以訪問該列。

1332
01:07:39,110 --> 01:07:41,636
這是否說清楚？

1333
01:07:41,636 --> 01:07:42,520
是啊，在前面？

1334
01:07:42,520 --> 01:07:45,490
>> 觀眾：[聽不清]打開
括號內為[聽不清]？

1335
01:07:45,490 --> 01:07:46,220
>> ZAMYLA陳：請原諒我嗎？

1336
01:07:46,220 --> 01:07:49,740
>> 觀眾：開括號。

1337
01:07:49,740 --> 01:07:52,420
>> ZAMYLA陳：這些嗎？

1338
01:07:52,420 --> 01:07:58,520
這讓我有
該變量。

1339
01:07:58,520 --> 01:07:58,670
是啊。

1340
01:07:58,670 --> 01:08:01,900
>> 觀眾：當您打印，是您
打印到的HTML代碼？

1341
01:08:01,900 --> 01:08:03,110
>> ZAMYLA陳：是的。

1342
01:08:03,110 --> 01:08:07,720
當我打印，這在這裡是內
我的模板，因此

1343
01:08:07,720 --> 01:08:10,310
我的看法MVC的方法。

1344
01:08:10,310 --> 01:08:12,750
所以我打印到HTML。

1345
01:08:12,750 --> 01:08:16,670
>> 觀眾：所以，如果我們走進開發商
運行此工具後，我們可以

1346
01:08:16,670 --> 01:08:17,160
實際上在代碼中？

1347
01:08:17,160 --> 01:08:18,410
>> ZAMYLA陳：這是一個偉大的
的問題，是的。

1348
01:08:18,410 --> 01:08:22,359
所以，如果你走進了開發者工具
使用Firebug的或Firefox中

1349
01:08:22,359 --> 01:08:26,109
Chrome瀏覽器，那麼是的，你可以
請參閱特定的HTML。

1350
01:08:26,109 --> 01:08:28,470
所以它不會顯示$行[“名稱”]。

1351
01:08:28,470 --> 01:08:32,524
它會顯示為準
名字是該行。

1352
01:08:32,524 --> 01:08:36,268
>> 觀眾：只是一個一般性的問題，
什麼是TR和TD定義為？

1353
01:08:36,268 --> 01:08:37,672
為什麼我們[聽不清]？

1354
01:08:37,672 --> 01:08:41,850

1355
01:08:41,850 --> 01:08:44,814
>> ZAMYLA陳：表列TR，
表，然後TD列。

1356
01:08:44,814 --> 01:08:48,060

1357
01:08:48,060 --> 01:08:49,310
確定。

1358
01:08:49,310 --> 01:08:55,771

1359
01:08:55,771 --> 01:08:56,835
>> 觀眾：是的，這是表中的數據。

1360
01:08:56,835 --> 01:08:58,770
>> ZAMYLA陳：表數據。

1361
01:08:58,770 --> 01:08:59,894
是啊。

1362
01:08:59,894 --> 01:09:08,670
>> 觀眾：這是一個排在其中
行被視為一個列？

1363
01:09:08,670 --> 01:09:08,910
>> ZAMYLA陳：對不起。

1364
01:09:08,910 --> 01:09:10,570
你能再說一遍嗎？

1365
01:09:10,570 --> 01:09:14,450
>> 觀眾：你將如何
可視化行？

1366
01:09:14,450 --> 01:09:16,310
>> ZAMYLA陳：你將如何顯現
以什麼樣的方式行？

1367
01:09:16,310 --> 01:09:21,796
你說的是這些
這裡的行或TR行？

1368
01:09:21,796 --> 01:09:22,630
>> 觀眾：該行。

1369
01:09:22,630 --> 01:09:25,229
>> ZAMYLA陳：這裡這些行？

1370
01:09:25,229 --> 01:09:28,620
我會想像這是
我執行我的查詢。

1371
01:09:28,620 --> 01:09:38,729
它說，好吧，我是0到n
符合條件的行的金額

1372
01:09:38,729 --> 01:09:40,510
你曾質疑。

1373
01:09:40,510 --> 01:09:43,740
所以，我有行的某個數字。

1374
01:09:43,740 --> 01:09:51,450
所以行時，$行，每個門店
1陣列中的那些行。

1375
01:09:51,450 --> 01:09:58,110
因此，即使它只是其中之一，它的
還是它相匹配的行的數組。

1376
01:09:58,110 --> 01:10:03,010
>> 是這樣，那麼，舉例來說，這是
類似的，當你取出

1377
01:10:03,010 --> 01:10:05,390
從用戶的緩存。

1378
01:10:05,390 --> 01:10:10,810
與標準有地方
ID等於會話ID。

1379
01:10:10,810 --> 01:10:14,250
真的只能是一行
可能匹配。

1380
01:10:14,250 --> 01:10:18,960
但仍行剛剛返回一行。

1381
01:10:18,960 --> 01:10:22,620
所以你必須去行，
指數為0，索引緩存到

1382
01:10:22,620 --> 01:10:26,195
實際進行緩存。

1383
01:10:26,195 --> 01:10:29,650
>> 觀眾：是對打印功能
在呼應同樣的事情？

1384
01:10:29,650 --> 01:10:30,670
>> ZAMYLA陳：是的。

1385
01:10:30,670 --> 01:10:31,190
是。

1386
01:10:31,190 --> 01:10:33,304
打印相同的迴聲。

1387
01:10:33,304 --> 01:10:42,400
>> 觀眾：是對foreach循環的
只有這樣，才能索引行？

1388
01:10:42,400 --> 01:10:46,110
>> ZAMYLA陳：是foreach循環
唯一的辦法，你可以

1389
01:10:46,110 --> 01:10:47,030
通過行迭代？

1390
01:10:47,030 --> 01:10:47,180
號

1391
01:10:47,180 --> 01:10:51,000
您也可以使用for循環，提供
你知道的長度

1392
01:10:51,000 --> 01:10:53,024
行的數組。

1393
01:10:53,024 --> 01:10:58,500
>> 觀眾：你能訪問它
使用行為[聽不清]？

1394
01:10:58,500 --> 01:11:01,640
>> ZAMYLA陳：所以你不能訪問它
只是使用行，如果你沒有一個

1395
01:11:01,640 --> 01:11:05,160
foreach循環條件是
您還沒有宣布一行。

1396
01:11:05,160 --> 01:11:08,150

1397
01:11:08,150 --> 01:11:09,660
是。

1398
01:11:09,660 --> 01:11:10,810
是啊，在白色的。

1399
01:11:10,810 --> 01:11:13,990
>> 聽眾：那TR和TD呢？

1400
01:11:13,990 --> 01:11:16,790
>> ZAMYLA陳：所以tr和
TD是HTML標籤。

1401
01:11:16,790 --> 01:11:19,590
TR表示開始
的表行。

1402
01:11:19,590 --> 01:11:26,625
而每個TD表示
新表中的數據列。

1403
01:11:26,625 --> 01:11:32,275
>> 觀眾：對於一個視覺的東西一排
很喜歡，只是想像中的SQL語句，如何

1404
01:11:32,275 --> 01:11:33,510
它們具有一排。

1405
01:11:33,510 --> 01:11:35,980
[聽不清]。

1406
01:11:35,980 --> 01:11:36,390
>> ZAMYLA陳：是的。

1407
01:11:36,390 --> 01:11:37,630
這是一個很大的問題。

1408
01:11:37,630 --> 01:11:41,510
你可以想像行作為剛
像在Excel表中，只

1409
01:11:41,510 --> 01:11:44,540
的行的列表。

1410
01:11:44,540 --> 01:11:46,870
確定。

1411
01:11:46,870 --> 01:11:47,230
好的。

1412
01:11:47,230 --> 01:11:50,740
所以，現在我們已經討論了選擇，如果
不會有任何問題，我們將

1413
01:11:50,740 --> 01:11:52,970
在去到插入。

1414
01:11:52,970 --> 01:11:58,220
所以，如果我想插入一些
表並插入某些列

1415
01:11:58,220 --> 01:12:02,320
價值觀，我可以自己插入
進入拉文克勞的7年。

1416
01:12:02,320 --> 01:12:07,245
但有時可能會有重複的
價值觀，正如我們在pset7看到，當我們

1417
01:12:07,245 --> 01:12:09,240
更新了我們的產品組合。

1418
01:12:09,240 --> 01:12:15,610
>> 因此，在這種情況下，我們希望使用開啟
重複鍵更新，讓我們不

1419
01:12:15,610 --> 01:12:18,280
存儲多個行具有相同
珍惜而是對其進行更新。

1420
01:12:18,280 --> 01:12:21,780

1421
01:12:21,780 --> 01:12:25,560
那麼我們其實有更新，
這不是一個插入。

1422
01:12:25,560 --> 01:12:30,100
它只是在那裡你更新的更新
在一定的表與一個給定

1423
01:12:30,100 --> 01:12:34,403
條件，然後，最後，刪除
這確實一個非常類似的事情。

1424
01:12:34,403 --> 01:12:40,200
>> 您能否簡要：觀眾
走在重複鍵？

1425
01:12:40,200 --> 01:12:40,850
>> ZAMYLA陳：是的。

1426
01:12:40,850 --> 01:12:48,340
從本質上講這裡，我有INSERT INTO
古靈閣，是，帆船，這些值。

1427
01:12:48,340 --> 01:12:56,900
但ID，想必，是一個獨特的關鍵
值設置在MySQL表。

1428
01:12:56,900 --> 01:13:06,750
所以，如果我已經有了這個ID設置，
然後我不能插入新行。

1429
01:13:06,750 --> 01:13:10,961
因此，如果它不存在，則
那我也來更新它。

1430
01:13:10,961 --> 01:13:16,040

1431
01:13:16,040 --> 01:13:17,722
在白色的中間。

1432
01:13:17,722 --> 01:13:21,570
>> 觀眾：所以插入，更新，刪除，
和選擇，是那些所有可用

1433
01:13:21,570 --> 01:13:22,875
當地[聽不清]？

1434
01:13:22,875 --> 01:13:27,320

1435
01:13:27,320 --> 01:13:29,630
>> ZAMYLA陳：所以插入，
更新，刪除和

1436
01:13:29,630 --> 01:13:31,120
選擇是所有的SQL查詢。

1437
01:13:31,120 --> 01:13:34,970
所以每當你使用SQL，
你有那些可用。

1438
01:13:34,970 --> 01:13:38,226

1439
01:13:38,226 --> 01:13:40,706
>> 觀眾：回到過去的測驗 - 

1440
01:13:40,706 --> 01:13:44,178
有一個問題，處理
如果你有一個表，並希望

1441
01:13:44,178 --> 01:13:52,610
插入測試成績中的一個，你插入
你的名字，所以它不會讓你

1442
01:13:52,610 --> 01:13:54,594
[聽不清]你的朋友的測試成績。

1443
01:13:54,594 --> 01:13:59,060
你會怎麼做，與插入？

1444
01:13:59,060 --> 01:14:02,490
>> ZAMYLA陳：所以現在的問題是關於
前一期中的問題。

1445
01:14:02,490 --> 01:14:04,320
我不知道其中的
一方面，這是現在。

1446
01:14:04,320 --> 01:14:06,790
因此，也許以後，如果你想
上來，告訴我，然後我就可以

1447
01:14:06,790 --> 01:14:08,155
肯定給你提示。

1448
01:14:08,155 --> 01:14:11,250

1449
01:14:11,250 --> 01:14:15,460
但講的東西插入，像
走別人的分數，當你

1450
01:14:15,460 --> 01:14:18,800
不應該，讓我們來談談
SQL注入攻擊。

1451
01:14:18,800 --> 01:14:22,050
因此，SQL注入攻擊本質上是
如果有人需要

1452
01:14:22,050 --> 01:14:27,680
優勢的低安全性
你正在服用的數據的方式。

1453
01:14:27,680 --> 01:14:35,660
>> 所以在這裡，就像在CS50金融，
當我們登錄的，我們可以在輸入

1454
01:14:35,660 --> 01:14:39,510
用戶名的登錄表單，
第一個文本框，

1455
01:14:39,510 --> 01:14:41,570
然後在密碼輸入。

1456
01:14:41,570 --> 01:14:45,610
也許我們的PHP代碼看起來可能
這樣的事情，$ username的

1457
01:14:45,610 --> 01:14:51,410
是後數據的用戶名和密碼
是後數據的密碼。

1458
01:14:51,410 --> 01:14:55,110
然後，我們只是執行我們的查詢，比如，
好了，好了，我們的查詢是要

1459
01:14:55,110 --> 01:14:57,990
從我們的用戶選擇，其中
用戶名是

1460
01:14:57,990 --> 01:14:58,970
一個他們提交。

1461
01:14:58,970 --> 01:15:06,870
而密碼是密碼，
這意味著口令匹配。

1462
01:15:06,870 --> 01:15:12,670
>> 現在，如果不是實際
提交一個實際的密碼，如

1463
01:15:12,670 --> 01:15:16,850
12345和猜測叉，上面寫著
密碼，並試圖破解他們的

1464
01:15:16,850 --> 01:15:21,460
帳戶，如果有什麼，而不是
他們提交了這一點。

1465
01:15:21,460 --> 01:15:24,380
他們可以鍵入也許
一個猜測的密碼。

1466
01:15:24,380 --> 01:15:30,480
然後，他們將完成
報價然後輸入或1 = 1。

1467
01:15:30,480 --> 01:15:35,160
這將直接踱步到SQL
查詢到是這個樣子。

1468
01:15:35,160 --> 01:15:38,200
從用戶選擇其中的username
=插腳和密碼

1469
01:15:38,200 --> 01:15:41,450
等於百合或1 = 1。

1470
01:15:41,450 --> 01:15:45,450
>> 因此，無論密碼有
為正確或1 = 1，

1471
01:15:45,450 --> 01:15:47,870
這始終是真實的。

1472
01:15:47,870 --> 01:15:52,780
所以在這種情況下，基本上，使用者可
利用這一優勢，只要登錄

1473
01:15:52,780 --> 01:15:55,240
自己在和黑客
別人的賬戶。

1474
01:15:55,240 --> 01:15:58,950
所以這就是為什麼我們要避免
有人不得不這樣做。

1475
01:15:58,950 --> 01:16:03,890
但幸運的是，通過查詢功能
通過在佔位符會

1476
01:16:03,890 --> 01:16:04,800
這種照顧你。

1477
01:16:04,800 --> 01:16:08,570
此外，你通常會永遠都不想
實際提交的密碼

1478
01:16:08,570 --> 01:16:09,310
他們自己。

1479
01:16:09,310 --> 01:16:14,115
這就是為什麼我們散列或加密
他們在CS50融資。

1480
01:16:14,115 --> 01:16:17,553
>> 觀眾：過去談到測驗
關於MySQL的轉義字符串。

1481
01:16:17,553 --> 01:16:21,800
我們要擔心？

1482
01:16:21,800 --> 01:16:22,670
>> ZAMYLA陳：這是一個很好的問題。

1483
01:16:22,670 --> 01:16:29,050
MySQL的轉義字符串肯定是一個
函數是在我們的查詢中使用。

1484
01:16:29,050 --> 01:16:30,420
但一定要看看那。

1485
01:16:30,420 --> 01:16:32,950
我會說這是公平的遊戲知道
那你需要調用

1486
01:16:32,950 --> 01:16:34,370
功能上的繩子。

1487
01:16:34,370 --> 01:16:35,245
是啊，貝琳達？

1488
01:16:35,245 --> 01:16:38,606
>> 觀眾：你怎麼知道什麼時候
單引號或雙引號？

1489
01:16:38,606 --> 01:16:43,516
而且，我覺得自己像在課堂上你
提及有關沒有

1490
01:16:43,516 --> 01:16:48,426
在[聽不清]或某事或
在結束第二個單引號。

1491
01:16:48,426 --> 01:16:56,407

1492
01:16:56,407 --> 01:17:00,825
我覺得他指出，在該演講
你應該有撇號1

1493
01:17:00,825 --> 01:17:04,290
再沒有撇號
什麼的。

1494
01:17:04,290 --> 01:17:05,540
>> 觀眾：[聽不清]。

1495
01:17:05,540 --> 01:17:14,860

1496
01:17:14,860 --> 01:17:18,657
>> 觀眾：事情是最後一個
報價有在第二個框

1497
01:17:18,657 --> 01:17:19,391
不應該存在。

1498
01:17:19,391 --> 01:17:21,840
[聽不清]

1499
01:17:21,840 --> 01:17:26,730
因為當你把去年單
引述出來，匹配這些內容

1500
01:17:26,730 --> 01:17:30,522
其中的密碼，如果你有
查詢中，有在一個單引號

1501
01:17:30,522 --> 01:17:31,340
結束了。

1502
01:17:31,340 --> 01:17:36,580
你要使用單引號
作為面向1所述一個

1503
01:17:36,580 --> 01:17:37,574
[聽不清]。

1504
01:17:37,574 --> 01:17:42,820
那麼什麼是真正的文本
盒子不應該有。

1505
01:17:42,820 --> 01:17:44,070
>> ZAMYLA陳：我會改變這種狀況。

1506
01:17:44,070 --> 01:17:56,490

1507
01:17:56,490 --> 01:17:56,880
確定。

1508
01:17:56,880 --> 01:18:00,435
如果沒有任何問題，然後我會
將它傳遞給約瑟夫談

1509
01:18:00,435 --> 01:18:04,332
有關JavaScript的，等等。

1510
01:18:04,332 --> 01:18:09,540
>> [掌聲]

1511
01:18:09,540 --> 01:18:11,660
>> 王陽：所以我們正在運行
有點落後。

1512
01:18:11,660 --> 01:18:13,280
所以，如果你要離開，那也無妨。

1513
01:18:13,280 --> 01:18:16,540
但我們要求你保持你的頭向下
如果你是在中間，所以你

1514
01:18:16,540 --> 01:18:19,560
不要擋住相機，並使用
如果你有到後面退出。

1515
01:18:19,560 --> 01:18:25,010

1516
01:18:25,010 --> 01:18:26,306
我是約瑟夫的方式。

1517
01:18:26,306 --> 01:18:27,556
你好。

1518
01:18:27,556 --> 01:18:37,910

1519
01:18:37,910 --> 01:18:38,630
測試，測試。

1520
01:18:38,630 --> 01:18:39,630
丹，是好？

1521
01:18:39,630 --> 01:18:40,880
涼爽。

1522
01:18:40,880 --> 01:18:44,460

1523
01:18:44,460 --> 01:18:47,600
>> 因此視頻也將發布
網上的那些

1524
01:18:47,600 --> 01:18:48,850
現在不得不離開。

1525
01:18:48,850 --> 01:18:51,350

1526
01:18:51,350 --> 01:18:52,600
彆扭。

1527
01:18:52,600 --> 01:18:56,300

1528
01:18:56,300 --> 01:18:57,510
確定。

1529
01:18:57,510 --> 01:18:59,730
所以測驗複習。

1530
01:18:59,730 --> 01:19:00,980
這是一隻貓。

1531
01:19:00,980 --> 01:19:03,150

1532
01:19:03,150 --> 01:19:07,170
現在，JavaScript中，這也許是不
作為AWW一些你們的。

1533
01:19:07,170 --> 01:19:07,370
確定。

1534
01:19:07,370 --> 01:19:09,280
所以這是第一次，記得Zamyla。

1535
01:19:09,280 --> 01:19:11,270
請記住，PHP是
在服務器上運行。

1536
01:19:11,270 --> 01:19:15,230
和很多次，你們寫循環
在PHP中打印出來的HTML，對不對？

1537
01:19:15,230 --> 01:19:19,170
所以一旦該代碼執行，即
你打印出HTML輸出

1538
01:19:19,170 --> 01:19:20,500
被發送給用戶。

1539
01:19:20,500 --> 01:19:25,960
而一旦出現這種情況，沒有更多的PHP可以
運行的，除非你重新加載頁面，

1540
01:19:25,960 --> 01:19:27,660
當然，這重新執行PHP的。

1541
01:19:27,660 --> 01:19:30,080
但是，一旦你打印出的HTML，
你不能去任何地方。

1542
01:19:30,080 --> 01:19:33,580
>> 使得HTML被發送給用戶，
這是瀏覽器在這裡，在這裡

1543
01:19:33,580 --> 01:19:35,470
高粱是使用計算機。

1544
01:19:35,470 --> 01:19:40,340
和這麼好，有幾件事情
一旦我們發送HTML給用戶。

1545
01:19:40,340 --> 01:19:43,350
有時候，我們想這樣做
當你點擊的東西，我們要

1546
01:19:43,350 --> 01:19:47,350
彈出，那些各種各​​樣的警告框
相互作用，當您按下喜歡

1547
01:19:47,350 --> 01:19:50,740
鍵，當您單擊上的東西
頁，我想要的東西發生。

1548
01:19:50,740 --> 01:19:54,550
嗯，你可以不重新執行PHP
一旦代碼的HTML設置。

1549
01:19:54,550 --> 01:19:55,900
那麼，你如何做到這一點？

1550
01:19:55,900 --> 01:19:59,930
>> 我們引入了一個新的語言稱為
JavaScript中，它運行在瀏覽器中

1551
01:19:59,930 --> 01:20:02,890
可以讓你做的事情
您收到後為HTML

1552
01:20:02,890 --> 01:20:04,020
他們從服務器。

1553
01:20:04,020 --> 01:20:07,050
這就是為什麼我們稱之為客戶端
編程語言。

1554
01:20:07,050 --> 01:20:09,110
它可以在電腦上 - 

1555
01:20:09,110 --> 01:20:11,400
客戶端。

1556
01:20:11,400 --> 01:20:13,830
有關迄今有問題嗎？

1557
01:20:13,830 --> 01:20:15,650
這種格局是有道理的人呢？

1558
01:20:15,650 --> 01:20:16,010
確定。

1559
01:20:16,010 --> 01:20:16,790
好。

1560
01:20:16,790 --> 01:20:17,340
好的。

1561
01:20:17,340 --> 01:20:20,850
所以，首先要注意
是JavaScript是不是PHP。

1562
01:20:20,850 --> 01:20:23,010
>> 他們有一些不同的語法，
我們將去成。

1563
01:20:23,010 --> 01:20:24,530
和他們有很不同的用途。

1564
01:20:24,530 --> 01:20:26,640
JavaScript中，再次為您
瀏覽器，用於客戶端。

1565
01:20:26,640 --> 01:20:30,640
服務器在某處運行在別人的
計算機發送信息

1566
01:20:30,640 --> 01:20:31,720
對你，對不對？

1567
01:20:31,720 --> 01:20:36,730
因此，如果我們要求你寫PHP代碼
關於考試的問題，不寫

1568
01:20:36,730 --> 01:20:38,710
JavaScript的，反之亦然。

1569
01:20:38,710 --> 01:20:41,710
你只失分，
它不會是正確的。

1570
01:20:41,710 --> 01:20:43,690
>> 所以，讓我們來看看一些
語法差異 - 

1571
01:20:43,690 --> 01:20:46,140
JavaScript的左側
而右邊的PHP。

1572
01:20:46,140 --> 01:20:48,670
你會注意到的第一件事情
JavaScript中，我們聲明變量

1573
01:20:48,670 --> 01:20:49,440
var關鍵字 - 

1574
01:20:49,440 --> 01:20:53,590
V-A-R。 PHP中的美元符號，
作為Zamyla前面所討論的。

1575
01:20:53,590 --> 01:20:57,570
如果你想聲明一個關聯
數組，我們看到了熟悉的語法上

1576
01:20:57,570 --> 01:20:59,030
右側用PHP。

1577
01:20:59,030 --> 01:21:01,630
在左邊，而不是
您使用大括號。

1578
01:21:01,630 --> 01:21:03,280
然後你的鑰匙是在左邊。

1579
01:21:03,280 --> 01:21:04,670
那麼你有一個冒號。

1580
01:21:04,670 --> 01:21:06,560
然後你有值
你想要的。

1581
01:21:06,560 --> 01:21:09,840
>> 因此，這是你將如何做到這一點在PHP
在右側與該第二

1582
01:21:09,840 --> 01:21:10,955
，在米洛啟動線。

1583
01:21:10,955 --> 01:21:14,540
那就是你將如何做到這一點的
左側在JavaScript中，如果你想

1584
01:21:14,540 --> 01:21:16,110
我們所說的對象。

1585
01:21:16,110 --> 01:21:19,340
而在JavaScript中的對象是
只是關聯數組。

1586
01:21:19,340 --> 01:21:23,710
所以，如果您要訪問的字段，在
PHP中使用這種支架的語法。

1587
01:21:23,710 --> 01:21:27,170
而這樣一來，您可以重新分配
這個所有者字段勞倫。

1588
01:21:27,170 --> 01:21:30,150
>> 那麼，在JavaScript中，如果一個人想
訪問一個字段並改變它，你可以

1589
01:21:30,150 --> 01:21:31,370
使用點語法。

1590
01:21:31,370 --> 01:21:33,860
您也可以使用括號語法。

1591
01:21:33,860 --> 01:21:35,550
但你不能使用
點語法在PHP。

1592
01:21:35,550 --> 01:21:36,525
這是行不通的。

1593
01:21:36,525 --> 01:21:38,910
它僅適用於PHP的。

1594
01:21:38,910 --> 01:21:42,060
最後，要打印的東西到
控制台，您可以使用console.log的，這

1595
01:21:42,060 --> 01:21:43,720
你們在pset8使用了很多。

1596
01:21:43,720 --> 01:21:45,260
您可以CONSOLE.LOG的。

1597
01:21:45,260 --> 01:21:50,030
>> 如果你想在打印一個數組
PHP中，你必須使用打印河

1598
01:21:50,030 --> 01:21:53,240
而在右邊，你看我哈希
字符串串聯那邊。

1599
01:21:53,240 --> 01:21:54,070
早些時候有人問。

1600
01:21:54,070 --> 01:21:55,850
我在JavaScript中使用一個加號。

1601
01:21:55,850 --> 01:21:59,800
如果我想的東西串連
在PHP中，我使用點。

1602
01:21:59,800 --> 01:22:00,800
這些是不同的。

1603
01:22:00,800 --> 01:22:03,420
如果你正在編寫PHP代碼，
不要用一個加號。

1604
01:22:03,420 --> 01:22:06,810
如果你正在編寫的JavaScript
代碼，不寫一個點。

1605
01:22:06,810 --> 01:22:08,230
這將是錯誤的。

1606
01:22:08,230 --> 01:22:09,640
，你會傷心。

1607
01:22:09,640 --> 01:22:11,000
>> 所以語法的差異。

1608
01:22:11,000 --> 01:22:14,710
了解你的語法，因為如果你有
寫一個問題，你用語法

1609
01:22:14,710 --> 01:22:16,890
從錯誤的語言，
它不會工作。

1610
01:22:16,890 --> 01:22:19,520
這將是錯誤的。

1611
01:22:19,520 --> 01:22:22,420
因此，讓我們來談談一些控制
流的差異，你如何使用

1612
01:22:22,420 --> 01:22:24,040
循環在他們每個人。

1613
01:22:24,040 --> 01:22:26,610
Zamyla走到右邊。

1614
01:22:26,610 --> 01:22:27,780
東西的右側
應該很熟悉。

1615
01:22:27,780 --> 01:22:29,670
讓我們來看看在左側。

1616
01:22:29,670 --> 01:22:34,830
>> 當您使用在JavaScriptÑ環，
你的循環變量，變種我在那邊，

1617
01:22:34,830 --> 01:22:37,210
遍歷數組的鍵。

1618
01:22:37,210 --> 01:22:39,150
所以你看名字，房子和作用。

1619
01:22:39,150 --> 01:22:42,440
如果我CONSOLE.LOG我，我得到
名稱，門牌和作用。

1620
01:22:42,440 --> 01:22:44,720
這些是密鑰。

1621
01:22:44,720 --> 01:22:50,080
在JavaScript中，foreach循環進入
在這個數組的值。

1622
01:22:50,080 --> 01:22:52,040
那麼，你注意到他們倆都是我。

1623
01:22:52,040 --> 01:22:56,000
但在這裡在PHP端，它打印
出米洛，CS50，和吉祥物。

1624
01:22:56,000 --> 01:22:57,390
這些都是在PHP中的值。

1625
01:22:57,390 --> 01:23:00,180
>> 因此，這些都是怎麼這兩個是不同的
在不同的語言。

1626
01:23:00,180 --> 01:23:02,970
所以，如果你正在使用一個foreach
循環，不要以為它

1627
01:23:02,970 --> 01:23:03,760
給你鑰匙。

1628
01:23:03,760 --> 01:23:08,010
如果您使用的是n個循環，不
假設它可以讓你的價值觀。

1629
01:23:08,010 --> 01:23:10,420
這是否有道理這麼遠嗎？

1630
01:23:10,420 --> 01:23:13,630
下一張幻燈片是要告訴你
您如何訪問在對面

1631
01:23:13,630 --> 01:23:15,160
他們每個人。

1632
01:23:15,160 --> 01:23:18,550
>> 好吧，如果你有鑰匙在JavaScript
和你想要的值了，

1633
01:23:18,550 --> 01:23:20,440
你只是索引到
數組這一點。

1634
01:23:20,440 --> 01:23:23,640
所以我米洛將讓你什麼
你想要的 - 值。

1635
01:23:23,640 --> 01:23:25,260
有一個在PHP中，這不同的語法。

1636
01:23:25,260 --> 01:23:28,140
如果你真的想知道的話，我不
認為我們已經把它拿給你呢。

1637
01:23:28,140 --> 01:23:31,740
但是，如果你有興趣，你可以使用
右邊這個附加的語法

1638
01:23:31,740 --> 01:23:35,130
側，實際上將讓你的
當你使用PHP的一鍵

1639
01:23:35,130 --> 01:23:35,880
foreach循環。

1640
01:23:35,880 --> 01:23:39,640
瑣事所以只是一點點
如果你有興趣。

1641
01:23:39,640 --> 01:23:42,630
>> 所以，這只是為了演示
這兩個循環之間的差異。

1642
01:23:42,630 --> 01:23:47,060
不要混淆起來，當你
編程的問題。

1643
01:23:47,060 --> 01:23:49,774
有關的任何問題。

1644
01:23:49,774 --> 01:23:50,770
涼爽。

1645
01:23:50,770 --> 01:23:51,310
好的。

1646
01:23:51,310 --> 01:23:52,250
JavaScript對象。

1647
01:23:52,250 --> 01:23:53,040
我談到了他們。

1648
01:23:53,040 --> 01:23:54,650
他們就像關聯數組。

1649
01:23:54,650 --> 01:23:57,730
有一件事我想請你注意
這裡是在關聯的值

1650
01:23:57,730 --> 01:23:59,540
數組可以在JavaScript的任何東西。

1651
01:23:59,540 --> 01:24:02,240
>> 它甚至可以是一個函數，
就像那邊。

1652
01:24:02,240 --> 01:24:04,600
我有一個函數，
是一個關鍵的值。

1653
01:24:04,600 --> 01:24:07,030
如果我想調用該函數，
我剛剛接觸樹皮。

1654
01:24:07,030 --> 01:24:08,490
然後我把括號
後。

1655
01:24:08,490 --> 01:24:09,790
並且工作。

1656
01:24:09,790 --> 01:24:15,570
因此，任何問題嗎？

1657
01:24:15,570 --> 01:24:16,370
沒有？

1658
01:24:16,370 --> 01:24:16,650
確定。

1659
01:24:16,650 --> 01:24:18,190
好。

1660
01:24:18,190 --> 01:24:20,130
JavaScript中，如PHP，
是弱類型。

1661
01:24:20,130 --> 01:24:20,970
這是什麼意思？

1662
01:24:20,970 --> 01:24:22,380
>> 它也有類型。

1663
01:24:22,380 --> 01:24:24,800
但是，當你聲明一個JavaScript
變量，你說我變種。

1664
01:24:24,800 --> 01:24:25,850
你不用說了吧。

1665
01:24:25,850 --> 01:24:26,460
這不是一個東西。

1666
01:24:26,460 --> 01:24:28,000
你剛才說這是一個變量。

1667
01:24:28,000 --> 01:24:31,590
然後用JavaScript處理
引擎蓋為你種下的。

1668
01:24:31,590 --> 01:24:34,390
我們之間自由轉換
類型，因為這個原因。

1669
01:24:34,390 --> 01:24:37,360
所以我開始了作為一個數
在這種情況下。

1670
01:24:37,360 --> 01:24:38,790
然後，我有一個字符串。

1671
01:24:38,790 --> 01:24:39,710
而我想補充我給它。

1672
01:24:39,710 --> 01:24:41,810
我重新分配它放回我。

1673
01:24:41,810 --> 01:24:43,640
>> 因此，在首行，
i是數量。

1674
01:24:43,640 --> 01:24:47,310
在第二行，我現在變成了
字符串後，我做了重新分配。

1675
01:24:47,310 --> 01:24:52,820
在這裡，我只是串連
該數字到字符串。

1676
01:24:52,820 --> 01:24:56,210
所以你看，即使我是一個
在第一部分的整數，它的排序

1677
01:24:56,210 --> 01:24:58,500
像被轉換為
字符串，然後被添加

1678
01:24:58,500 --> 01:25:00,510
到那個打招呼的字符串。

1679
01:25:00,510 --> 01:25:02,340
所以這就是我的意思
由鬆散打字。

1680
01:25:02,340 --> 01:25:04,760
這就是你轉換之間
類型變得非常容易。

1681
01:25:04,760 --> 01:25:08,840
而且它不會拋出警告
在你如同C那樣。

1682
01:25:08,840 --> 01:25:12,420
>> 所以我現在包含打招呼
123的字符串。

1683
01:25:12,420 --> 01:25:13,270
下一步。

1684
01:25:13,270 --> 01:25:15,610
我們還可以比較自如
類型之間。

1685
01:25:15,610 --> 01:25:19,310
所以，如果你只是用==，很
像在PHP中，JavaScript的

1686
01:25:19,310 --> 01:25:20,480
做了類似的事情。

1687
01:25:20,480 --> 01:25:24,780
字符串123是相同的數
123，當你使用雙等號。

1688
01:25:24,780 --> 01:25:27,820
當使用三重等號，但也
要確保

1689
01:25:27,820 --> 01:25:29,240
的類型是一樣的。

1690
01:25:29,240 --> 01:25:31,960
所以，因為這是一個字符串，這是
一個數字，儘管它們都是

1691
01:25:31,960 --> 01:25:35,280
123，當你使用三
等於，你會得到錯誤的。

1692
01:25:35,280 --> 01:25:39,330
在雙相等的情況下，你會得到真正的，
因為雙等於沒有

1693
01:25:39,330 --> 01:25:40,020
在乎的類型。

1694
01:25:40,020 --> 01:25:42,500
三重等號並不關心類型。

1695
01:25:42,500 --> 01:25:43,750
有問題嗎？

1696
01:25:43,750 --> 01:25:45,790

1697
01:25:45,790 --> 01:25:48,390
確定。

1698
01:25:48,390 --> 01:25:52,870
>> 而關於JavaScript的另一件事是
範圍是一種全球除非你

1699
01:25:52,870 --> 01:25:53,460
中的函數。

1700
01:25:53,460 --> 01:25:55,660
它的工作原理相同
方法在PHP實際上。

1701
01:25:55,660 --> 01:25:57,500
所以，讓我們通過這個例子。

1702
01:25:57,500 --> 01:25:59,110
我設置我999。

1703
01:25:59,110 --> 01:26:00,900
然後，我進入這個循環。

1704
01:26:00,900 --> 01:26:06,110
所以，如果我打印我在此對
環，我希望0，1，2，3，4。

1705
01:26:06,110 --> 01:26:07,390
我得到到i = 4。

1706
01:26:07,390 --> 01:26:10,770
它增加我現在到5日
在fo​​r循環的結束。

1707
01:26:10,770 --> 01:26:13,300
然後它打破跳出循環，
因為它不符合

1708
01:26:13,300 --> 01:26:14,550
調理了。

1709
01:26:14,550 --> 01:26:16,650
>> 什麼你認為你未來
的console.log打印出來？

1710
01:26:16,650 --> 01:26:20,570

1711
01:26:20,570 --> 01:26:24,790
所以，這就是它會做在C在C中，
因為如果你有一個像我變種外

1712
01:26:24,790 --> 01:26:28,855
和你有一個循環內變種我，像一個
for循環，那麼它使得如

1713
01:26:28,855 --> 01:26:30,690
它的範圍內的，兩
我的是不同的。

1714
01:26:30,690 --> 01:26:34,630
在JavaScript中，它只是
把它當作同一個我。

1715
01:26:34,630 --> 01:26:37,870
我得到5，因為那是價值
後退出圈外。

1716
01:26:37,870 --> 01:26:39,120
因此，那些我的是一樣的我。

1717
01:26:39,120 --> 01:26:42,620

1718
01:26:42,620 --> 01:26:44,130
這是否有道理？

1719
01:26:44,130 --> 01:26:45,720
>> 嗯，這是有道理的
一個JavaScript的立場。

1720
01:26:45,720 --> 01:26:49,510
但是，同樣的模式不
結轉到下他們有

1721
01:26:49,510 --> 01:26:50,310
不同的作用域規則。

1722
01:26:50,310 --> 01:26:50,630
是。

1723
01:26:50,630 --> 01:26:52,566
>> 觀眾：[聽不清]

1724
01:26:52,566 --> 01:26:54,990
在函數外[聽不清]？

1725
01:26:54,990 --> 01:26:58,340
>> 王陽：所以外面哪個函數？

1726
01:26:58,340 --> 01:27:00,810
所以，我會得到，在短短一秒鐘。

1727
01:27:00,810 --> 01:27:02,580
所以我們調用foo（i）條。

1728
01:27:02,580 --> 01:27:06,920
這傳遞我到foo中，增量
它，然後記錄它。

1729
01:27:06,920 --> 01:27:07,750
所以這是5。

1730
01:27:07,750 --> 01:27:09,210
因此它成為6。

1731
01:27:09,210 --> 01:27:11,670
但我說的是
我在該函數。

1732
01:27:11,670 --> 01:27:14,430
因為它是一個參數，它的
作用域的函數。

1733
01:27:14,430 --> 01:27:17,800
所以一旦我真正擺脫這
功能，它現在打算去

1734
01:27:17,800 --> 01:27:19,860
回到舊我。

1735
01:27:19,860 --> 01:27:23,000
我只是因為範圍
它是在一個函數。

1736
01:27:23,000 --> 01:27:24,200
我們有範圍和職能。

1737
01:27:24,200 --> 01:27:29,080
但我們沒有範圍
在JavaScript函數。

1738
01:27:29,080 --> 01:27:31,170
這是否有道理？

1739
01:27:31,170 --> 01:27:31,320
是。

1740
01:27:31,320 --> 01:27:31,660
問題。

1741
01:27:31,660 --> 01:27:34,030
>> 觀眾：同[聽不清]？

1742
01:27:34,030 --> 01:27:34,500
>> 王陽：所以呀。

1743
01:27:34,500 --> 01:27:36,260
在PHP中，這是同樣的類型的東西。

1744
01:27:36,260 --> 01:27:37,680
有一個輕微的微妙實際。

1745
01:27:37,680 --> 01:27:40,130
但是你可以問我
該複查。

1746
01:27:40,130 --> 01:27:43,930
你並不真正需要知道的
這微妙的測驗。

1747
01:27:43,930 --> 01:27:47,600
對於所有意圖和目的，如
變量，全局和PHP，除非

1748
01:27:47,600 --> 01:27:49,150
他們是在一個函數，同一
在JavaScript中的事情。

1749
01:27:49,150 --> 01:27:49,480
是。

1750
01:27:49,480 --> 01:27:52,890
>> 觀眾：這是為什麼在允許
JavaScript和沒有別的地方？

1751
01:27:52,890 --> 01:27:55,010
>> 王陽：那麼，為什麼它讓
在JavaScript中，而不是C語言？

1752
01:27:55,010 --> 01:27:58,180
這只是誰想出了
JavaScript的決定，這是在確定

1753
01:27:58,180 --> 01:27:59,510
JavaScript的。

1754
01:27:59,510 --> 01:28:02,430
所以，它就像一門編程語言
約定我們會說。

1755
01:28:02,430 --> 01:28:02,580
是。

1756
01:28:02,580 --> 01:28:04,480
>> 觀眾：那麼，為什麼
他走6至5？

1757
01:28:04,480 --> 01:28:08,280
>> 王陽：所以從6到5，
因為當我通過我到foo中，該

1758
01:28:08,280 --> 01:28:13,420
我的foo裡面，現在範圍為foo，
因為範圍存在於功能

1759
01:28:13,420 --> 01:28:15,050
JavaScript的。

1760
01:28:15,050 --> 01:28:18,720
但是，一旦我離開這裡，因為它
在作用域的功能，我只是

1761
01:28:18,720 --> 01:28:24,300
使用常規的我這是內
控制流的其餘部分。

1762
01:28:24,300 --> 01:28:25,210
有意義嗎？

1763
01:28:25,210 --> 01:28:26,910
我可以繼續前進？

1764
01:28:26,910 --> 01:28:27,320
好的。

1765
01:28:27,320 --> 01:28:29,180
涼爽。

1766
01:28:29,180 --> 01:28:31,890
>> 這樣做的接受對象是
通過引用傳遞。

1767
01:28:31,890 --> 01:28:33,990
你知道當你通過
一個數組轉換成C你可以

1768
01:28:33,990 --> 01:28:35,810
其實修改數組？

1769
01:28:35,810 --> 01:28:37,350
這是在JavaScript中同樣的事情。

1770
01:28:37,350 --> 01:28:42,960
如果我通過一個對象，在這種情況下，我
米洛傳遞到這個catify功能。

1771
01:28:42,960 --> 01:28:44,490
米洛開始了。

1772
01:28:44,490 --> 01:28:46,310
他的名字叫米洛香蕉。

1773
01:28:46,310 --> 01:28:51,670
我通過該對象到一個函數
因為它是一個對象，一個關聯

1774
01:28:51,670 --> 01:28:53,730
數組中的JavaScript。

1775
01:28:53,730 --> 01:28:57,110
>> 當我執行一個操作
在該函數中，它會

1776
01:28:57,110 --> 01:28:58,560
真正改變的對象。

1777
01:28:58,560 --> 01:29:01,720
因此，這只會發生的對象
在JavaScript中，就像它發生

1778
01:29:01,720 --> 01:29:09,230
為C。所以米羅的名字裡面陣列
實際上將變成貓了。

1779
01:29:09,230 --> 01:29:10,090
這是否有道理？

1780
01:29:10,090 --> 01:29:11,840
因此，這僅適用於對象。

1781
01:29:11,840 --> 01:29:13,090
對象是通過引用傳遞。

1782
01:29:13,090 --> 01:29:13,400
是。

1783
01:29:13,400 --> 01:29:16,850
>> 觀眾：所以你說
相反，變量i。

1784
01:29:16,850 --> 01:29:17,240
>> 王陽：是啊。

1785
01:29:17,240 --> 01:29:20,330
其中變量i只是
一個數字，對不對？

1786
01:29:20,330 --> 01:29:25,280
這就像C語言，當你傳遞一個
一個整數，它使一個副本。

1787
01:29:25,280 --> 01:29:28,130
而當你傳遞一個數組，它實際上
改變了實際的數組

1788
01:29:28,130 --> 01:29:32,870
C.同樣的事情發生與
中的JavaScript這種情況。

1789
01:29:32,870 --> 01:29:34,070
好的。

1790
01:29:34,070 --> 01:29:38,134
而接下來，米洛是可悲的，因為
他現在是一隻貓。

1791
01:29:38,134 --> 01:29:40,790

1792
01:29:40,790 --> 01:29:45,060
這實際上米洛後
一些一趟獸醫。

1793
01:29:45,060 --> 01:29:46,860
>> 那麼，我們如何使用JavaScript
在一個網頁？

1794
01:29:46,860 --> 01:29:47,790
我們可以將其包含。

1795
01:29:47,790 --> 01:29:50,090
這是與帶標籤的HTML代碼。

1796
01:29:50,090 --> 01:29:51,300
所以，我必須帶標籤存在。

1797
01:29:51,300 --> 01:29:54,820
然後我把一些JavaScript
腳本標籤中的代碼。

1798
01:29:54,820 --> 01:29:56,390
然後執行此。

1799
01:29:56,390 --> 01:29:58,830
當我只是不喜歡這樣，它的
所謂內聯JavaScript。

1800
01:29:58,830 --> 01:30:02,400
這有點凌亂，因為
JavaScript是實際上在HTML。

1801
01:30:02,400 --> 01:30:07,010
>> 一個更好的方法來做到這一點，更漂亮，
是寫在你的JavaScript

1802
01:30:07,010 --> 01:30:10,920
外部文件，然後提供
腳本標記與源。

1803
01:30:10,920 --> 01:30:14,920
這將轉到該JavaScript文件
和讀取JavaScript代碼

1804
01:30:14,920 --> 01:30:15,960
該文件來代替。

1805
01:30:15,960 --> 01:30:18,820
而這樣一來，你沒有很多的
JavaScript的在你的開始

1806
01:30:18,820 --> 01:30:20,760
HTML文件，這使得
它非常的混亂。

1807
01:30:20,760 --> 01:30:21,860
你只要把它在其他地方。

1808
01:30:21,860 --> 01:30:24,310
然後它會從那裡讀取它。

1809
01:30:24,310 --> 01:30:25,560
這樣做是有道理的？

1810
01:30:25,560 --> 01:30:27,990

1811
01:30:27,990 --> 01:30:29,640
>> 安置事宜。

1812
01:30:29,640 --> 01:30:32,620
在這種特殊情況下，
劇本是身體。

1813
01:30:32,620 --> 01:30:36,090
所以，當我執行了，有
沒有在身體呢。

1814
01:30:36,090 --> 01:30:39,920
也許這會讓多一點點
當我告訴這下一部分的感覺。

1815
01:30:39,920 --> 01:30:43,210
在這種情況下，腳本
自帶的分區之後。

1816
01:30:43,210 --> 01:30:46,620
因此，格實際上出現
在第一頁上。

1817
01:30:46,620 --> 01:30:49,470
在這裡，在這個小小的紅色圓圈，
你看到顯示的文本。

1818
01:30:49,470 --> 01:30:51,810
然後警報顯示出來。

1819
01:30:51,810 --> 01:30:54,890
>> 在第一種情況中，因為腳本
是格前，

1820
01:30:54,890 --> 01:30:56,170
警報顯示第一。

1821
01:30:56,170 --> 01:30:59,250
然後在div後顯示出來
您關閉了對話框。

1822
01:30:59,250 --> 01:31:01,330
所以執行事項。

1823
01:31:01,330 --> 01:31:02,290
因此，我們將記住這一點。

1824
01:31:02,290 --> 01:31:03,640
這將是非常重要
在一點點。

1825
01:31:03,640 --> 01:31:08,730

1826
01:31:08,730 --> 01:31:09,540
確定。

1827
01:31:09,540 --> 01:31:12,750
這麼好，你怎麼等到
加載那麼在你整個頁面

1828
01:31:12,750 --> 01:31:13,580
執行一些代碼？

1829
01:31:13,580 --> 01:31:15,540
我們將進入這個有點
位以後了。

1830
01:31:15,540 --> 01:31:19,016
但只要保持這個位置
記事項時，我們

1831
01:31:19,016 --> 01:31:20,570
走到另一張幻燈片。

1832
01:31:20,570 --> 01:31:22,030
>> 所以我們得到的DOM現在。

1833
01:31:22,030 --> 01:31:23,550
什麼是DOM？

1834
01:31:23,550 --> 01:31:26,830
所以，如果你看一下HTML代碼，它只是
一群在屏幕上的文字。

1835
01:31:26,830 --> 01:31:30,560
那麼，如何的JavaScript知道
這是一個HTML元素？

1836
01:31:30,560 --> 01:31:33,410
因此，我們必須有一些記憶
這種表示法

1837
01:31:33,410 --> 01:31:34,930
結構，我們有。

1838
01:31:34,930 --> 01:31:40,240
每當我們有這個在內存中
在JavaScript中表示，我們稱之為

1839
01:31:40,240 --> 01:31:41,750
該DOM。

1840
01:31:41,750 --> 01:31:45,130
它只是一種方式，人們決定
我們應該代表這

1841
01:31:45,130 --> 01:31:46,400
HTML結構。

1842
01:31:46,400 --> 01:31:47,940
>> 而這是什麼DOM的樣子？

1843
01:31:47,940 --> 01:31:50,460
那麼，在內存中的表示，
我們把這個文本。

1844
01:31:50,460 --> 01:31:52,870
我們把它變成記憶
表示。

1845
01:31:52,870 --> 01:31:54,400
因此，這是HTML。

1846
01:31:54,400 --> 01:31:58,090
所以，我們首先發現，每
DOM樹中有一個文件。

1847
01:31:58,090 --> 01:31:59,400
它看起來像一棵樹。

1848
01:31:59,400 --> 01:32:03,550
並且文檔包含HTML
標籤，其實一切

1849
01:32:03,550 --> 01:32:05,150
在這裡面，現在。

1850
01:32:05,150 --> 01:32:06,970
HTML標記有兩個孩子。

1851
01:32:06,970 --> 01:32:08,630
它有一個頭。

1852
01:32:08,630 --> 01:32:12,380
這頭，如果你看一下縮進
那邊怎麼它的結構

1853
01:32:12,380 --> 01:32:14,960
結束標籤之間，
頭上有一個孩子。

1854
01:32:14,960 --> 01:32:17,130
孩子是冠軍。

1855
01:32:17,130 --> 01:32:18,370
沒錯。

1856
01:32:18,370 --> 01:32:21,000
>> 現在，我們有一個身體的孩子。

1857
01:32:21,000 --> 01:32:24,870
然後是身體有
孩子所謂的家庭。

1858
01:32:24,870 --> 01:32:27,950
而且家裡有三個孩子 - 

1859
01:32:27,950 --> 01:32:29,550
最古老的，中間和最年輕的。

1860
01:32:29,550 --> 01:32:31,960
所以，你應該知道如何畫一個圖
這樣，當我們問你怎麼

1861
01:32:31,960 --> 01:32:34,270
畫一個圖，當我們給
您左方的HTML。

1862
01:32:34,270 --> 01:32:36,350
知道如何生產的DOM樹。

1863
01:32:36,350 --> 01:32:38,930
而這些東西在裡面，但只是
一些文字，我已經代表

1864
01:32:38,930 --> 01:32:40,180
作為小盒子。

1865
01:32:40,180 --> 01:32:42,750

1866
01:32:42,750 --> 01:32:47,980
>> 這是否DOM樹結構，使
感和DOM是什麼？

1867
01:32:47,980 --> 01:32:49,300
那麼，在p代表什麼？

1868
01:32:49,300 --> 01:32:51,850
在這裡，在p那邊
在該標籤代表一個

1869
01:32:51,850 --> 01:32:54,510
段落標記在HTML中。

1870
01:32:54,510 --> 01:32:57,080
所以，你可以看看它。

1871
01:32:57,080 --> 01:32:59,290
但它只是意味著它的一些
空間的一些文字。

1872
01:32:59,290 --> 01:33:02,910
它有一些默認的CSS樣式，
因為它是一個段落標記。

1873
01:33:02,910 --> 01:33:05,130
但真的不擔心
該部分太多。

1874
01:33:05,130 --> 01:33:07,510
只知道它是一個佔位符
對於一些文字。

1875
01:33:07,510 --> 01:33:08,480
是。

1876
01:33:08,480 --> 01:33:10,200
問題？

1877
01:33:10,200 --> 01:33:11,021
是。

1878
01:33:11,021 --> 01:33:12,374
>> 觀眾：你剛才提到的CSS。

1879
01:33:12,374 --> 01:33:15,492
哈希家庭和散列
所有的東西基本上是

1880
01:33:15,492 --> 01:33:17,400
即在CSS中的ID？

1881
01:33:17,400 --> 01:33:18,440
>> 王陽：是的，沒錯。

1882
01:33:18,440 --> 01:33:20,380
我會得到什麼這些哈希
是指在一秒鐘。

1883
01:33:20,380 --> 01:33:23,480
當安吉拉走過去的CSS，她
談到CSS選擇器。

1884
01:33:23,480 --> 01:33:26,770
這些是CSS選擇器的
她在說什麼。

1885
01:33:26,770 --> 01:33:28,268
是的，羅布？

1886
01:33:28,268 --> 01:33:32,060
>> ROB BOWDEN：我也想發表評論
標題標籤裡面的DOM

1887
01:33:32,060 --> 01:33:35,385
也是一個文本節點。

1888
01:33:35,385 --> 01:33:36,070
>> 王陽：對。

1889
01:33:36,070 --> 01:33:38,370
所以標題標籤裡面，
我有一些文字的DOM。

1890
01:33:38,370 --> 01:33:42,730
因此，其實，這個稱號應該有一個像
小箱脫落的它。

1891
01:33:42,730 --> 01:33:45,740
但它其實並不重要
在這種情況下，太多。

1892
01:33:45,740 --> 01:33:49,620
我們真的不關心文本節點，
當我們打電話給他們，太多了。

1893
01:33:49,620 --> 01:33:50,270
OK，我們做的。

1894
01:33:50,270 --> 01:33:51,520
顯然，我們做的。

1895
01:33:51,520 --> 01:33:54,260

1896
01:33:54,260 --> 01:33:57,100
我會解決，當
我再次上​​傳。

1897
01:33:57,100 --> 01:33:59,830
這是否有道理？

1898
01:33:59,830 --> 01:34:01,160
>> 那麼，我們如何使用DOM工作？

1899
01:34:01,160 --> 01:34:03,790
每當你處理DOM中
JavaScript中，有兩個步驟。

1900
01:34:03,790 --> 01:34:05,030
你選擇一個DOM元素。

1901
01:34:05,030 --> 01:34:06,580
然後你做的東西出來。

1902
01:34:06,580 --> 01:34:11,480
因此，在這種情況下，抽象的，我
選擇的中間元素。

1903
01:34:11,480 --> 01:34:14,530
然後做的東西的一個例子
它會改變的文本。

1904
01:34:14,530 --> 01:34:16,020
曾經是鮑勃。

1905
01:34:16,020 --> 01:34:19,930
現在，我所做的是我改變
鮑勃米洛在這種情況下。

1906
01:34:19,930 --> 01:34:22,130
>> 那麼，我們實際上做如何？

1907
01:34:22,130 --> 01:34:23,440
我們如何做選擇？

1908
01:34:23,440 --> 01:34:26,560
我們如何做的做的東西
事情一旦我們去的嗎？

1909
01:34:26,560 --> 01:34:30,470
嗯，順便你們已經學會了
在這個類是通過使用我們的東西

1910
01:34:30,470 --> 01:34:32,420
所謂的jQuery。

1911
01:34:32,420 --> 01:34:33,910
那麼，什麼是jQuery的？

1912
01:34:33,910 --> 01:34:37,220
jQuery是一個庫，它使得
JavaScript的更容易編寫。

1913
01:34:37,220 --> 01:34:39,500
所以有人花時間
並寫了jQuery的。

1914
01:34:39,500 --> 01:34:41,530
>> jQuery的實際寫入
在JavaScript中。

1915
01:34:41,530 --> 01:34:44,550
然後，因為他們現在這樣做，我們
有一大堆的函數，

1916
01:34:44,550 --> 01:34:46,020
我們可以使用，使我們的
生活真的很容易。

1917
01:34:46,020 --> 01:34:48,580

1918
01:34:48,580 --> 01:34:50,030
那麼，什麼是一些
它的東西呢？

1919
01:34:50,030 --> 01:34:51,650
這使得選擇的元素更容易。

1920
01:34:51,650 --> 01:34:54,020
這使得改變的HTML，
添加類更容易。

1921
01:34:54,020 --> 01:34:55,360
它使阿賈克斯更容易。

1922
01:34:55,360 --> 01:34:58,230
我們會得到，在第二。

1923
01:34:58,230 --> 01:35:00,630
>> 而且它類似於C庫。

1924
01:35:00,630 --> 01:35:03,090
所以，你有string.h中，
你得到strlen的。

1925
01:35:03,090 --> 01:35:04,680
你得到的strcpy，所有這些事情。

1926
01:35:04,680 --> 01:35:09,650
當你有jQuery的，你會得到很好的
方式選擇要素的變化

1927
01:35:09,650 --> 01:35:10,390
活動，等等。

1928
01:35:10,390 --> 01:35:12,990
你會得到額外的功能，
JavaScript不給你。

1929
01:35:12,990 --> 01:35:15,310
所以jQuery的JavaScript不。

1930
01:35:15,310 --> 01:35:18,660
jQuery是那是寫在庫
的JavaScript，使JavaScript的

1931
01:35:18,660 --> 01:35:20,440
更容易編寫。

1932
01:35:20,440 --> 01:35:23,170
>> 所以，jQuery是不是一種編程
語言。

1933
01:35:23,170 --> 01:35:24,540
但JavaScript。

1934
01:35:24,540 --> 01:35:27,420

1935
01:35:27,420 --> 01:35:27,590
做。

1936
01:35:27,590 --> 01:35:30,420
確保你正確的術語。

1937
01:35:30,420 --> 01:35:32,490
有問題嗎？

1938
01:35:32,490 --> 01:35:33,882
是。

1939
01:35:33,882 --> 01:35:35,132
那是一個問題嗎？

1940
01:35:35,132 --> 01:35:37,910

1941
01:35:37,910 --> 01:35:38,350
好的。

1942
01:35:38,350 --> 01:35:40,080
那麼，你如何使用jQuery？

1943
01:35:40,080 --> 01:35:42,390
那麼，當你在寫一些
JavaScript代碼和你有一個

1944
01:35:42,390 --> 01:35:45,570
jQuery的在您的文件的頂部為
腳本文件，可以使用美元符號

1945
01:35:45,570 --> 01:35:47,310
現在可以訪問jQuery的。

1946
01:35:47,310 --> 01:35:49,860
這是從不同的
美元符號在PHP。

1947
01:35:49,860 --> 01:35:51,590
>> 這是相同的符號，你
輸入您的鍵盤上。

1948
01:35:51,590 --> 01:35:52,780
但他們的意思非常不同的事情。

1949
01:35:52,780 --> 01:35:56,090
在PHP中美元符號表示該
是我聲明一個變量。

1950
01:35:56,090 --> 01:35:59,120
在JavaScript中，當你拍了
jQuery的，它代表的jQuery。

1951
01:35:59,120 --> 01:36:01,280
所以記住這一點。

1952
01:36:01,280 --> 01:36:03,420
那麼，如何可能，我們選擇DOM元素？

1953
01:36:03,420 --> 01:36:06,500
那麼，當你這樣做的醜陋的JavaScript
這樣，您訪問

1954
01:36:06,500 --> 01:36:08,240
記錄全局變量。

1955
01:36:08,240 --> 01:36:11,170
然後你通過ID家人得到元素。

1956
01:36:11,170 --> 01:36:15,270
這真是漫長而羅嗦
而且不是很好。

1957
01:36:15,270 --> 01:36:18,190
>> 或者，你可以得到所有元素
這是一個p標籤。

1958
01:36:18,190 --> 01:36:20,080
這在JavaScript中工作過。

1959
01:36:20,080 --> 01:36:22,470
但我們從來沒有真正表現出
你的語法太多。

1960
01:36:22,470 --> 01:36:24,620
我們向您展示了jQuery的。

1961
01:36:24,620 --> 01:36:28,720
使整個選擇了那裡，
有人在JavaScript中只是得到

1962
01:36:28,720 --> 01:36:33,320
濃縮至這個很不錯的美元
簽署包括hashtag家庭。

1963
01:36:33,320 --> 01:36:38,480
和$ P，只是它是這樣的。

1964
01:36:38,480 --> 01:36:41,690
如果你想選擇所有p標籤
一個家庭裡面，我們把空間

1965
01:36:41,690 --> 01:36:42,890
兩者之間。

1966
01:36:42,890 --> 01:36:44,815
而現在，我們得到所有的p
標記一個家庭裡面。

1967
01:36:44,815 --> 01:36:48,740

1968
01:36:48,740 --> 01:36:50,380
>> 和看起來很熟悉？

1969
01:36:50,380 --> 01:36:52,880
那麼，安吉拉談到
CSS選擇器。

1970
01:36:52,880 --> 01:36:54,200
給我一秒鐘。

1971
01:36:54,200 --> 01:36:57,230
因此，為了選擇一個元素，
你只需要使用同樣的事情，你

1972
01:36:57,230 --> 01:36:58,530
會做一個CSS選擇器。

1973
01:36:58,530 --> 01:37:00,910
如果你把一個哈希在前面
它，它會選擇通過ID。

1974
01:37:00,910 --> 01:37:02,220
一個點按類選擇。

1975
01:37:02,220 --> 01:37:06,230
如果你只是有一點不
哈希或點，它選擇這些標籤。

1976
01:37:06,230 --> 01:37:07,140
的問題。

1977
01:37:07,140 --> 01:37:07,470
是嗎？

1978
01:37:07,470 --> 01:37:11,510
>> 觀眾：當我們使用點在我們的
HTML，是不jQuery的？

1979
01:37:11,510 --> 01:37:13,520
>> 王陽：點在我們的HTML
是一個JavaScript的事情。

1980
01:37:13,520 --> 01:37:14,750
這不是一個jQuery的事情。

1981
01:37:14,750 --> 01:37:17,620
你們學會了它的方式
jQuery是使用。HTML。

1982
01:37:17,620 --> 01:37:21,510
然後你通過它的任何
在HTML將是。

1983
01:37:21,510 --> 01:37:23,480
所以，我會得到，在剛剛
第二個實際上。

1984
01:37:23,480 --> 01:37:27,800
那麼，我們如何做的東西到元
一旦我們選擇了它？

1985
01:37:27,800 --> 01:37:30,130
所以這是一個例子
選擇一個元素。

1986
01:37:30,130 --> 01:37:32,280
所以，現在，我們想要做的東西給它。

1987
01:37:32,280 --> 01:37:35,730
>> 因此，在這種情況下，讓我回去
到上一張幻燈片。

1988
01:37:35,730 --> 01:37:37,360
之前，它是鮑勃。

1989
01:37:37,360 --> 01:37:40,660
我想改變這種狀況
裡面的HTML米洛。

1990
01:37:40,660 --> 01:37:43,240
所以，我所說的HTML功能
從元素。

1991
01:37:43,240 --> 01:37:45,580
該HTML功能
元件的方法。

1992
01:37:45,580 --> 01:37:47,430
然後我給它什麼
我想在HTML的人。

1993
01:37:47,430 --> 01:37:50,560
它只是取代了什麼裡面
該標籤與任何我給它。

1994
01:37:50,560 --> 01:37:50,830
是。

1995
01:37:50,830 --> 01:37:51,170
問題？

1996
01:37:51,170 --> 01:37:57,397
>> 觀眾：這個標籤是用來
只對jQuery的。

1997
01:37:57,397 --> 01:37:59,313
[聽不清]

1998
01:37:59,313 --> 01:38:01,230
我們不會使用它。

1999
01:38:01,230 --> 01:38:01,960
>> 王陽：是的，沒錯。

2000
01:38:01,960 --> 01:38:03,750
不過不要太擔心
關於純JavaScript。

2001
01:38:03,750 --> 01:38:06,670
我只是想讓你們把重點放在如何
會做它用jQuery，因為

2002
01:38:06,670 --> 01:38:10,020
這將是重要的
部分的測驗。

2003
01:38:10,020 --> 01:38:10,400
右。

2004
01:38:10,400 --> 01:38:10,880
沒錯。

2005
01:38:10,880 --> 01:38:16,025
所以你看到，包括hashtag，使
對應於與選擇元件

2006
01:38:16,025 --> 01:38:18,310
因為該主題標籤的ID中。

2007
01:38:18,310 --> 01:38:19,670
包括hashtag指證。

2008
01:38:19,670 --> 01:38:22,870
而這種元素具有中等的ID。

2009
01:38:22,870 --> 01:38:24,366
所以這是我們選擇的元素。

2010
01:38:24,366 --> 01:38:27,160
>> 觀眾：[聽不清]。

2011
01:38:27,160 --> 01:38:31,090
美元符號包括hashtag [聽不清]？

2012
01:38:31,090 --> 01:38:31,710
>> 王陽：因此，沒有。

2013
01:38:31,710 --> 01:38:33,280
現在的問題是，您可以使用。值。

2014
01:38:33,280 --> 01:38:36,445
和。值僅適用於元素
是輸入。

2015
01:38:36,445 --> 01:38:40,950

2016
01:38:40,950 --> 01:38:45,495
在jQuery中，這將是
，纈氨酸，不是。價值。

2017
01:38:45,495 --> 01:38:49,080
所以，我會得到一個小例子，
演示這一切組合

2018
01:38:49,080 --> 01:38:49,850
在第二個。

2019
01:38:49,850 --> 01:38:53,130
但我認為這提供一個小片段
有意義的人為止。

2020
01:38:53,130 --> 01:38:55,450
要更改HTML，
調用HTML的方法。

2021
01:38:55,450 --> 01:38:56,432
是。

2022
01:38:56,432 --> 01:38:58,200
>> 觀眾：你能解釋一下
再次的方法？

2023
01:38:58,200 --> 01:39:01,900
>> 王陽：所以一個方法僅僅是一個
功能屬於1，在該

2024
01:39:01,900 --> 01:39:04,590
情況下，這些DOM元素之一，
因為你看到我

2025
01:39:04,590 --> 01:39:05,940
第一個選擇的元素。

2026
01:39:05,940 --> 01:39:07,320
其實，讓我用鼠標。

2027
01:39:07,320 --> 01:39:09,330
我選擇的第一個元素。

2028
01:39:09,330 --> 01:39:12,310
然後我打電話給這個HTML
功能，它有。

2029
01:39:12,310 --> 01:39:15,710
而且由於該功能屬於
這件事情，我們把它的方法。

2030
01:39:15,710 --> 01:39:19,480
這是因為它只是一個花哨的名字。

2031
01:39:19,480 --> 01:39:20,730
再說一遍。

2032
01:39:20,730 --> 01:39:22,880

2033
01:39:22,880 --> 01:39:25,170
所以請記住，我們選擇
現在的元素。

2034
01:39:25,170 --> 01:39:27,810
我們已經把它的內部
元素變量。

2035
01:39:27,810 --> 01:39:28,600
正確嗎？

2036
01:39:28,600 --> 01:39:34,380
>> 因此，當我們想改變的HTML上
在裡面，因為它是鮑勃之前，您

2037
01:39:34,380 --> 01:39:36,420
希望該文本更改為米洛。

2038
01:39:36,420 --> 01:39:37,920
所以我們稱之為的HTML。

2039
01:39:37,920 --> 01:39:41,610
我們告訴它什麼是HTML中
該元素應該是現在。

2040
01:39:41,610 --> 01:39:44,107
所以它改變它米洛，
因為我給它米洛。

2041
01:39:44,107 --> 01:39:46,542
>> 觀眾：所以他們一起工作。

2042
01:39:46,542 --> 01:39:47,030
[聽不清]

2043
01:39:47,030 --> 01:39:47,390
>> 王陽：是啊，是啊。

2044
01:39:47,390 --> 01:39:48,180
他們一起工作。

2045
01:39:48,180 --> 01:39:50,210
所以，他們中的一個選擇
該元素。

2046
01:39:50,210 --> 01:39:52,863
和第二個不
什麼東西。

2047
01:39:52,863 --> 01:39:53,790
是。

2048
01:39:53,790 --> 01:39:56,168
>> 觀眾：[聽不清]。

2049
01:39:56,168 --> 01:40:01,280
如果此方法是從不同的HTML
你有法等於實際。

2050
01:40:01,280 --> 01:40:01,560
>> 王陽：是啊。

2051
01:40:01,560 --> 01:40:03,370
這是一種不同的方法。

2052
01:40:03,370 --> 01:40:04,670
這是一種不同的方法。

2053
01:40:04,670 --> 01:40:07,860
我們可以覆蓋，在短短一秒鐘
當我們到達一個例子。

2054
01:40:07,860 --> 01:40:12,000
我想確保我們加快
因為我們的時間不多了。

2055
01:40:12,000 --> 01:40:15,360
但是我們現在運行的方式隨著時間的推移。

2056
01:40:15,360 --> 01:40:15,490
確定。

2057
01:40:15,490 --> 01:40:16,430
涼爽。

2058
01:40:16,430 --> 01:40:20,130
所以，如果你想添加一個類，有
還有一個附加的類方法。

2059
01:40:20,130 --> 01:40:24,300
這是什麼只是一個例子
你可以使用jQuery做。

2060
01:40:24,300 --> 01:40:25,950
這只是增加了一個類。

2061
01:40:25,950 --> 01:40:28,660
>> 如果你想刪除它，
你可以調用刪除。

2062
01:40:28,660 --> 01:40:32,280
這只是另一件你可以做的。

2063
01:40:32,280 --> 01:40:35,680
因此，更多的例子可以做的事。

2064
01:40:35,680 --> 01:40:37,510
所以，我可以只把它放在
像這樣的頂部？

2065
01:40:37,510 --> 01:40:38,760
老三刪除。

2066
01:40:38,760 --> 01:40:42,470

2067
01:40:42,470 --> 01:40:45,930
如果我只是執行的JavaScript在
我的文件的頂部，將這項工作？

2068
01:40:45,930 --> 01:40:48,540

2069
01:40:48,540 --> 01:40:48,920
右。

2070
01:40:48,920 --> 01:40:50,530
因為中間不存在。

2071
01:40:50,530 --> 01:40:51,840
因此，這是行不通的。

2072
01:40:51,840 --> 01:40:52,800
執行順序。

2073
01:40:52,800 --> 01:40:55,040
它去頂第一。

2074
01:40:55,040 --> 01:40:55,540
什麼？

2075
01:40:55,540 --> 01:40:57,450
>> 觀眾：老三不存在了嗎？

2076
01:40:57,450 --> 01:40:57,810
>> 王陽：是啊。

2077
01:40:57,810 --> 01:40:58,710
年齡最小的還不存在。

2078
01:40:58,710 --> 01:40:59,600
沒錯。

2079
01:40:59,600 --> 01:41:01,320
>> 觀眾：你說中間。

2080
01:41:01,320 --> 01:41:01,510
>> 王陽：對不起。

2081
01:41:01,510 --> 01:41:02,720
年齡最小的還不存在。

2082
01:41:02,720 --> 01:41:04,510
而另一件事是我沒有
包含了jQuery

2083
01:41:04,510 --> 01:41:06,580
文件要求腳本的src。

2084
01:41:06,580 --> 01:41:07,960
所以這是行不通的。

2085
01:41:07,960 --> 01:41:09,580
其實，我並沒有這樣做，在
下一張幻燈片，這是

2086
01:41:09,580 --> 01:41:10,700
應該解決，要么。

2087
01:41:10,700 --> 01:41:14,120
但我們這樣做的方式是JavaScript的
是事件驅動的。

2088
01:41:14,120 --> 01:41:17,410
所以，我們做的是我們使用一個事件
處理程序來實現這一目標。

2089
01:41:17,410 --> 01:41:19,510
所以，我選擇文檔
設置第一。

2090
01:41:19,510 --> 01:41:23,810
我說好，當文檔
準備好了，讓我運行一個函數。

2091
01:41:23,810 --> 01:41:25,470
所以，這是所有的語法手段。

2092
01:41:25,470 --> 01:41:27,100
>> 我選擇的文件。

2093
01:41:27,100 --> 01:41:29,530
現在，當該文件是
準備好後，運行該函數。

2094
01:41:29,530 --> 01:41:32,970
所以在這裡當文檔
準備好了，這意味著所有的HTML有

2095
01:41:32,970 --> 01:41:36,140
裝，然後我運行功能
去除該元素。

2096
01:41:36,140 --> 01:41:40,270
所以現在，當我運行這個功能
我傳遞給準備好了，我

2097
01:41:40,270 --> 01:41:43,780
保證在所有的HTML
頁面會先存在。

2098
01:41:43,780 --> 01:41:44,100
是。

2099
01:41:44,100 --> 01:41:44,425
問題？

2100
01:41:44,425 --> 01:41:48,200
>> 觀眾：什麼是事件關鍵字
中的函數？

2101
01:41:48,200 --> 01:41:51,750
>> 王陽：所以在該事件關鍵字
功能僅僅是一個參數，

2102
01:41:51,750 --> 01:41:53,490
被傳遞給函數
對於任何事件。

2103
01:41:53,490 --> 01:41:55,470
這只是一些
你得到免費的。

2104
01:41:55,470 --> 01:41:59,320
當您在使用密鑰句柄
pset8，該事件可以告訴你，對

2105
01:41:59,320 --> 01:42:01,350
你壓上的例子，其中的關鍵。

2106
01:42:01,350 --> 01:42:05,540
在這種情況下，一個準備好的情況下，
它實際上不是超級有用。

2107
01:42:05,540 --> 01:42:08,640
但是，對於一個鍵按下的事件，它更
有用的，因為你知道哪些

2108
01:42:08,640 --> 01:42:12,330
關鍵你通過訪問鍵按下
代碼關閉該事件的對象。

2109
01:42:12,330 --> 01:42:13,530
正確嗎？

2110
01:42:13,530 --> 01:42:15,160
這是否有道理？

2111
01:42:15,160 --> 01:42:16,280
確定。

2112
01:42:16,280 --> 01:42:16,580
是。

2113
01:42:16,580 --> 01:42:17,150
問題？

2114
01:42:17,150 --> 01:42:19,290
>> 觀眾：所以你能放
腳本標記低了下去？

2115
01:42:19,290 --> 01:42:19,940
>> 王陽：所以呀。

2116
01:42:19,940 --> 01:42:21,500
你可以把腳本
標記低了下去。

2117
01:42:21,500 --> 01:42:23,090
但當時它只是變得非常凌亂。

2118
01:42:23,090 --> 01:42:26,590
我們想集中所有
我們在一個地方的代碼。

2119
01:42:26,590 --> 01:42:28,290
這將使我們能夠做到這一點。

2120
01:42:28,290 --> 01:42:32,010
還記得前面我說，有一個更好的
這樣才能保證元素

2121
01:42:32,010 --> 01:42:33,880
在頁面上你執行代碼之前？

2122
01:42:33,880 --> 01:42:36,079
而這僅僅是一個很好的方式
你會做到這一點。

2123
01:42:36,079 --> 01:42:37,329
>> 觀眾：[聽不清]。

2124
01:42:37,329 --> 01:42:41,710

2125
01:42:41,710 --> 01:42:42,230
>> 王陽：是啊。

2126
01:42:42,230 --> 01:42:43,460
您仍然必須，對不對？

2127
01:42:43,460 --> 01:42:46,930
因為記得，你包括
文件在頁面的頂部。

2128
01:42:46,930 --> 01:42:49,890
所以它會之前，先執行
你到了頁面底部。

2129
01:42:49,890 --> 01:42:54,600

2130
01:42:54,600 --> 01:42:55,180
確定。

2131
01:42:55,180 --> 01:42:59,210
所以你也可以添加不同的
類型的事件處理程序。

2132
01:42:59,210 --> 01:43:00,640
這其中只是處理點擊。

2133
01:43:00,640 --> 01:43:03,910
當我點擊老三，然後
它會彈出一個警告。

2134
01:43:03,910 --> 01:43:05,440
這僅僅是一個不同的
類型的事件。

2135
01:43:05,440 --> 01:43:08,840
相對於ready事件，你現在
使用click事件，當您收到

2136
01:43:08,840 --> 01:43:10,190
點擊一個元素。

2137
01:43:10,190 --> 01:43:13,860
>> 所以在這種情況下，請記住，點擊
處理程序附加到最小。

2138
01:43:13,860 --> 01:43:16,080
因此，它只能發生在
我點擊最小。

2139
01:43:16,080 --> 01:43:19,510
而在另一篇ready事件
被附加到文檔。

2140
01:43:19,510 --> 01:43:23,750
所以它會等待該文件
要準備好。

2141
01:43:23,750 --> 01:43:25,120
有意義嗎？

2142
01:43:25,120 --> 01:43:26,190
我想我可以繼續前進。

2143
01:43:26,190 --> 01:43:26,610
是。

2144
01:43:26,610 --> 01:43:26,980
問題？

2145
01:43:26,980 --> 01:43:28,230
>> 觀眾：[聽不清]。

2146
01:43:28,230 --> 01:43:31,676

2147
01:43:31,676 --> 01:43:33,620
在這種情況下，你使用[聽不清]。

2148
01:43:33,620 --> 01:43:36,650
>> 王陽：哦，是的，因為在這個
情況下，我必須等待最年輕的

2149
01:43:36,650 --> 01:43:40,740
元素出現在屏幕上第一
之前，我可以附加一個單擊處理程序

2150
01:43:40,740 --> 01:43:43,062
它，這就是為什麼我把它放在裡面
的文件準備好。

2151
01:43:43,062 --> 01:43:45,780

2152
01:43:45,780 --> 01:43:46,840
確定。

2153
01:43:46,840 --> 01:43:52,390
而接下來的，所以這是一個很大的例子
你將如何結合起來的一切。

2154
01:43:52,390 --> 01:43:55,930
這僅僅是一個表單驗證的例子
你已經看到了講座。

2155
01:43:55,930 --> 01:43:58,410
因此，需要一步一步來的
你通過這個。

2156
01:43:58,410 --> 01:43:59,590
這將是完全確定。

2157
01:43:59,590 --> 01:44:01,400
剛讀它從上到下。

2158
01:44:01,400 --> 01:44:03,030
>> 我有一個窗體底部。

2159
01:44:03,030 --> 01:44:07,590
當文檔準備好了，我附上
提交處理程序的形式，這樣，

2160
01:44:07,590 --> 01:44:12,910
當我提交表單，我得到的值
裡面每個這些投入。

2161
01:44:12,910 --> 01:44:14,560
我檢查它是否為空。

2162
01:44:14,560 --> 01:44:17,090
如果是空白的，我返回false，因為
我並不想提交表單，

2163
01:44:17,090 --> 01:44:18,950
因為形式是錯誤的。

2164
01:44:18,950 --> 01:44:22,040
如果密碼為空或者它的不足
超過八個字符，不提交

2165
01:44:22,040 --> 01:44:24,470
的形式，因為這也是錯誤的。

2166
01:44:24,470 --> 01:44:28,150
而返回false只是防止
從提交和表單

2167
01:44:28,150 --> 01:44:30,150
去到一個新的頁面。

2168
01:44:30,150 --> 01:44:31,310
>> 並希望，這是有道理的。

2169
01:44:31,310 --> 01:44:34,650
我想你們應該走通
這段代碼一步你自己的一步。

2170
01:44:34,650 --> 01:44:38,350
一旦你明白什麼叫做選擇
元素和做的東西給它

2171
01:44:38,350 --> 01:44:40,520
實際上涉及，這將使
很多道理給你。

2172
01:44:40,520 --> 01:44:41,295
是嗎？

2173
01:44:41,295 --> 01:44:44,150
>> 觀眾：什麼的
名稱=用戶名是什麼意思？

2174
01:44:44,150 --> 01:44:48,530
>> 王陽：所以名=用戶名和
名=密碼只是意味著看

2175
01:44:48,530 --> 01:44:50,730
不論屬性
你選擇。

2176
01:44:50,730 --> 01:44:51,790
再有相匹配。

2177
01:44:51,790 --> 01:44:53,870
所以我們進入註冊。

2178
01:44:53,870 --> 01:44:56,240
然後我們來看看所有輸入
和登記。

2179
01:44:56,240 --> 01:44:59,990
然後我們挑了一個地方的名字
屬性等於用戶名。

2180
01:44:59,990 --> 01:45:04,040
因此，首先選擇只有選擇
用戶名輸入。

2181
01:45:04,040 --> 01:45:08,220
而這第二個選擇只選擇
密碼之一，因為那些有

2182
01:45:08,220 --> 01:45:12,240
他們的名字屬性設置為什麼
他們應該是。

2183
01:45:12,240 --> 01:45:12,575
問題？

2184
01:45:12,575 --> 01:45:17,030
>> 觀眾：在提交，請問該怎麼做
底部化解頂部？

2185
01:45:17,030 --> 01:45:19,350
>> 王陽：所以，這是因為
事件處理程序。

2186
01:45:19,350 --> 01:45:23,000
所以，我們正在等待提交事件
任何從形式發射。

2187
01:45:23,000 --> 01:45:24,730
而這一切都是服從。

2188
01:45:24,730 --> 01:45:26,080
為什麼我打電話提交了那裡？

2189
01:45:26,080 --> 01:45:28,870
它說，當提交表單時，
我得到一個提交事件。

2190
01:45:28,870 --> 01:45:33,480
所以我只截取和
然後運行此代碼來代替。

2191
01:45:33,480 --> 01:45:33,823
是嗎？

2192
01:45:33,823 --> 01:45:35,866
>> 觀眾：你為什麼有
有功能的事件？

2193
01:45:35,866 --> 01:45:38,580
為什麼你就不能[聽不清]？

2194
01:45:38,580 --> 01:45:41,140
>> 王陽：因為在JavaScript中，你
要聲明的函數。

2195
01:45:41,140 --> 01:45:42,910
這就是它是如何工作的
在JavaScript中。

2196
01:45:42,910 --> 01:45:44,800
你不得不說這是怎麼回事
運行一個函數。

2197
01:45:44,800 --> 01:45:47,290
所以，你告訴它你
期待一個函數在這裡，而不是

2198
01:45:47,290 --> 01:45:48,260
只是大括號。

2199
01:45:48,260 --> 01:45:50,460
>> 觀眾：和函數
是什麼如下？

2200
01:45:50,460 --> 01:45:50,650
>> 王陽：是啊。

2201
01:45:50,650 --> 01:45:52,790
該功能是什麼在裡面
後花括號

2202
01:45:52,790 --> 01:45:53,630
該函數的關鍵字。

2203
01:45:53,630 --> 01:45:54,045
是嗎？

2204
01:45:54,045 --> 01:45:55,295
>> 觀眾：[聽不清]。

2205
01:45:55,295 --> 01:46:00,180

2206
01:46:00,180 --> 01:46:00,660
>> 王陽：對於提交？

2207
01:46:00,660 --> 01:46:03,520
>> 觀眾：不，對於功能
沒有事件。

2208
01:46:03,520 --> 01:46:03,770
>> 王陽：是啊。

2209
01:46:03,770 --> 01:46:05,610
因此，如果沒有的情況下，
你可以有。

2210
01:46:05,610 --> 01:46:08,480
如果你並不需要的情況下，
那麼你可以忽略它。

2211
01:46:08,480 --> 01:46:12,220
但如果這樣做，那麼你
只是把它放在那裡。

2212
01:46:12,220 --> 01:46:12,520
是。

2213
01:46:12,520 --> 01:46:13,190
快速的問題？

2214
01:46:13,190 --> 01:46:14,440
>> 觀眾：[聽不清]。

2215
01:46:14,440 --> 01:46:21,170

2216
01:46:21,170 --> 01:46:21,440
>> 王陽：是啊。

2217
01:46:21,440 --> 01:46:24,550
因為你需要做的
的document.ready只是說等待所有

2218
01:46:24,550 --> 01:46:26,540
在頁面上的HTML來首先加載。

2219
01:46:26,540 --> 01:46:30,510
通常，你希望你的元素
在地方，你運行任何代碼之前。

2220
01:46:30,510 --> 01:46:31,030
好的。

2221
01:46:31,030 --> 01:46:32,180
我們必須讓阿賈克斯。

2222
01:46:32,180 --> 01:46:33,110
我們沒有多少時間了。

2223
01:46:33,110 --> 01:46:35,170
所以利弊。

2224
01:46:35,170 --> 01:46:37,450
JavaScript是比較容易的嘗試
寫與jQuery。

2225
01:46:37,450 --> 01:46:38,930
但jQuery是一種緩慢。

2226
01:46:38,930 --> 01:46:42,290
>> 這就像PHP是比C慢，
因為它的解釋。

2227
01:46:42,290 --> 01:46:45,690
和jQuery是不是有點慢
JavaScript的，因為它做了很多

2228
01:46:45,690 --> 01:46:46,630
引擎蓋下的東西。

2229
01:46:46,630 --> 01:46:48,660
所以，如果你正在使用jQuery，它是
不只是一點點慢

2230
01:46:48,660 --> 01:46:51,630
JavaScript的，儘管它
為您提供了很好的優雅。

2231
01:46:51,630 --> 01:46:53,970
最後，阿賈克斯。

2232
01:46:53,970 --> 01:46:59,170
因此，與阿賈克斯遠，你沒見過的Ajax
在pset7的詞條，因為

2233
01:46:59,170 --> 01:47:01,150
當你這樣做，你提交
一種形式的報價。

2234
01:47:01,150 --> 01:47:02,350
它加載一個新的頁面。

2235
01:47:02,350 --> 01:47:04,440
所以，你得到這個大的白色閃光
在頁面上，而

2236
01:47:04,440 --> 01:47:06,820
第二個頁面加載時，是否正確？

2237
01:47:06,820 --> 01:47:08,780
>> 這將是非常好的，如果你
沒有這個閃光燈。

2238
01:47:08,780 --> 01:47:11,600
像Facebook，如果你只是滾動到
底部，它增加了新的內容

2239
01:47:11,600 --> 01:47:13,490
而無需刷新整個頁面。

2240
01:47:13,490 --> 01:47:15,420
因此，像這樣就好了。

2241
01:47:15,420 --> 01:47:17,370
這是JavaScript代碼
在左側。

2242
01:47:17,370 --> 01:47:19,390
你得到的是輸入的內部。

2243
01:47:19,390 --> 01:47:21,340
你從雅虎股票信息

2244
01:47:21,340 --> 01:47:27,440
然後你犯了一個很大的字符串，
說，OK，這是我要留言

2245
01:47:27,440 --> 01:47:28,400
顯示在屏幕上。

2246
01:47:28,400 --> 01:47:32,280
然後你把這個信息裡面
這得到了一些HTML元素

2247
01:47:32,280 --> 01:47:33,970
顯示在屏幕上。

2248
01:47:33,970 --> 01:47:35,540
>> 所以，這一切發生的事情在這裡。

2249
01:47:35,540 --> 01:47:39,410
所以基本上，因為這是所有
JavaScript和你不需要運行

2250
01:47:39,410 --> 01:47:42,980
了PHP的，這將確保
該頁面不刷新。

2251
01:47:42,980 --> 01:47:47,470
所以這只是一個抽象的概念
我是說這裡現在。

2252
01:47:47,470 --> 01:47:50,630
抽象的想法是，如果你這樣做
所有在JavaScript中，你沒有一個

2253
01:47:50,630 --> 01:47:52,330
頁面刷新。

2254
01:47:52,330 --> 01:47:53,800
但你如何真正做到這一點？

2255
01:47:53,800 --> 01:47:56,230
>> 嗯，事實上，讓我們來談談
一個問題，這第一。

2256
01:47:56,230 --> 01:47:59,340
一個問題是在JavaScript中，
執行是同步的。

2257
01:47:59,340 --> 01:48:02,000
所以，你必須等待一個
行前，你完成

2258
01:48:02,000 --> 01:48:03,370
執行下一行。

2259
01:48:03,370 --> 01:48:06,130
而如果我要去了雅虎，
和他們的服務器是很慢，和

2260
01:48:06,130 --> 01:48:08,790
他們花三秒鐘
給我回該股票的信息？

2261
01:48:08,790 --> 01:48:12,620
當我打的價格線，如果
執行是同步的，因為它是由

2262
01:48:12,620 --> 01:48:15,390
默認情況下，它只是要做的是
您的瀏覽器會拖延

2263
01:48:15,390 --> 01:48:15,930
三秒鐘。

2264
01:48:15,930 --> 01:48:18,900
而且你不會是能夠做到
任何事情，而它得到的數據。

2265
01:48:18,900 --> 01:48:20,010
這將被凍結。

2266
01:48:20,010 --> 01:48:20,800
>> 這就是壞的。

2267
01:48:20,800 --> 01:48:23,390
你不希望用戶
具有冷凍網頁。

2268
01:48:23,390 --> 01:48:24,170
正確嗎？

2269
01:48:24,170 --> 01:48:25,480
這只是壞。

2270
01:48:25,480 --> 01:48:26,770
每個人都同意？

2271
01:48:26,770 --> 01:48:29,270
如果你在瀏覽Facebook和它
凍結，你不能做任何事情，你

2272
01:48:29,270 --> 01:48:31,920
得到真正沮喪。

2273
01:48:31,920 --> 01:48:34,960
所以，解決的辦法是我們做什麼
異步代替。

2274
01:48:34,960 --> 01:48:38,910
因此，所有這種異步的事情說
是，我要問這個

2275
01:48:38,910 --> 01:48:40,280
的URL的一些數據。

2276
01:48:40,280 --> 01:48:41,610
然後我會堅持下去。

2277
01:48:41,610 --> 01:48:45,330
我只是要保持執行
不管那是以後的代碼。

2278
01:48:45,330 --> 01:48:49,290
>> 然後每當該數據已準備就緒，
然後，我會處理它。

2279
01:48:49,290 --> 01:48:50,540
這就是它在說什麼。

2280
01:48:50,540 --> 01:48:52,795

2281
01:48:52,795 --> 01:48:56,710
>> 觀眾：阿賈克斯只是使
代碼異步？

2282
01:48:56,710 --> 01:48:58,560
>> 王陽：這是一個異步
取數據的方法。

2283
01:48:58,560 --> 01:49:01,230
所以，關於Ajax的第一件事
是它讓我得到的數據

2284
01:49:01,230 --> 01:49:03,170
從外部網站。

2285
01:49:03,170 --> 01:49:07,045
第二件事是它可以確保
我的頁面不熄火，而我

2286
01:49:07,045 --> 01:49:07,970
取該數據。

2287
01:49:07,970 --> 01:49:09,600
這就是它的異步的一部分。

2288
01:49:09,600 --> 01:49:13,040
因為它熄滅別的地方，
因為我說我堅持去做，而

2289
01:49:13,040 --> 01:49:14,900
它讀取該數據，即
使得異步的。

2290
01:49:14,900 --> 01:49:17,170
我一直在執行。

2291
01:49:17,170 --> 01:49:18,960
>> 因此，保持異步
心裡有數。

2292
01:49:18,960 --> 01:49:22,010
我會告訴你什麼是
所不同的是。

2293
01:49:22,010 --> 01:49:23,920
同步版本
是在左邊。

2294
01:49:23,920 --> 01:49:26,240
異步版本
是在右側。

2295
01:49:26,240 --> 01:49:29,170
看數字，看哪個
步驟對應於哪

2296
01:49:29,170 --> 01:49:30,610
執行在每一行。

2297
01:49:30,610 --> 01:49:32,730
那邊，警報顯示第一。

2298
01:49:32,730 --> 01:49:34,590
因為得到股票信息從雅虎

2299
01:49:34,590 --> 01:49:37,250
需要三秒鐘，停轉
三秒鐘。

2300
01:49:37,250 --> 01:49:39,880
然後它會提醒價格
那些在三秒鐘後。

2301
01:49:39,880 --> 01:49:43,690
>> 所以，現在，該警報顯示
向上當時 - 

2302
01:49:43,690 --> 01:49:44,610
3秒英寸

2303
01:49:44,610 --> 01:49:47,670
再後，提醒了。

2304
01:49:47,670 --> 01:49:48,930
所以它只是一步一步來。

2305
01:49:48,930 --> 01:49:51,200
這就像你們什麼
會接受，是否正確？

2306
01:49:51,200 --> 01:49:54,170
與異步執行，
你第一次提醒。

2307
01:49:54,170 --> 01:49:57,410
然後你去上這個網址。

2308
01:49:57,410 --> 01:49:59,530
和你說，我要去
只要求該數據。

2309
01:49:59,530 --> 01:50:01,170
然後我要去
以後再處理它。

2310
01:50:01,170 --> 01:50:04,230
所以它會立即執行
接下來之後，我做這行

2311
01:50:04,230 --> 01:50:05,710
異步請求。

2312
01:50:05,710 --> 01:50:08,920
>> 所以0.001秒，你看到警報喜。

2313
01:50:08,920 --> 01:50:10,960
執行該功能，警報再見。

2314
01:50:10,960 --> 01:50:14,240
因為我做了一個承諾，我
以後會處理數據，有什麼

2315
01:50:14,240 --> 01:50:17,920
發生時的數據回來
三秒鐘後，然後我運行

2316
01:50:17,920 --> 01:50:21,380
功能，我有在那裡。

2317
01:50:21,380 --> 01:50:21,870
是嗎？

2318
01:50:21,870 --> 01:50:25,750
>> 觀眾：你可以指定或
澄清一下Ajax的意思嗎？

2319
01:50:25,750 --> 01:50:30,460
>> 王陽：那麼Ajax是一種方式，如果我
需要數據時，我在一個網站，我

2320
01:50:30,460 --> 01:50:34,690
不想刷新頁面，則
我使用名為Ajax的這種技術。

2321
01:50:34,690 --> 01:50:40,630
這本質上只是手段，去獲取
從其他網站的數據。

2322
01:50:40,630 --> 01:50:43,724
而做到這一點的方式，只是
不熄火我的網頁。

2323
01:50:43,724 --> 01:50:46,650
>> 觀眾：所以是一種內在的
JavaScript或jQuery的一部分嗎？

2324
01:50:46,650 --> 01:50:50,590
>> 王陽：所以有人寫了一個方法來做到
這在JavaScript中很長一段時間以前。

2325
01:50:50,590 --> 01:50:52,050
在一個點上，它是不存在的。

2326
01:50:52,050 --> 01:50:56,630
於是有人發明了這種技術
讓人們請求此數據

2327
01:50:56,630 --> 01:50:57,680
以這種方式。

2328
01:50:57,680 --> 01:50:59,550
他們寫了一些東西
要為你做它。

2329
01:50:59,550 --> 01:51:01,605
和jQuery只是給你這個
很不錯的辦法做到這一點

2330
01:51:01,605 --> 01:51:03,112
與此$。get函數。

2331
01:51:03,112 --> 01:51:07,200

2332
01:51:07,200 --> 01:51:09,480
問題？

2333
01:51:09,480 --> 01:51:11,560
我可以回答有關問題
阿賈克斯之後了。

2334
01:51:11,560 --> 01:51:13,870
我會在這裡。

2335
01:51:13,870 --> 01:51:16,390
>> 所以，讓我們我們獲取數據而不
刷新頁面。

2336
01:51:16,390 --> 01:51:18,200
它讓我們在這樣做
異步方式

2337
01:51:18,200 --> 01:51:19,450
不凍結的頁面。

2338
01:51:19,450 --> 01:51:22,680

2339
01:51:22,680 --> 01:51:27,310
太長了，沒看過，如果是
解釋是太長了你。

2340
01:51:27,310 --> 01:51:29,430
所以最後，跨站點
腳本攻擊。

2341
01:51:29,430 --> 01:51:30,910
我們認為這與Zamyla。

2342
01:51:30,910 --> 01:51:34,285
如果我的數據庫有人有這個名字，
這是這個腳本標記，而我

2343
01:51:34,285 --> 01:51:38,280
有我的網頁上一些代碼，打印
出人的一排名字，或者我有

2344
01:51:38,280 --> 01:51:43,310
中插入JavaScript代碼
這名進入頁面，

2345
01:51:43,310 --> 01:51:45,680
什麼Html獲取產生的？

2346
01:51:45,680 --> 01:51:47,290
好吧，我打印出來的HTML標記。

2347
01:51:47,290 --> 01:51:48,390
我打印出所有這些標籤。

2348
01:51:48,390 --> 01:51:50,740
>> 我去哪裡，我打印的部分
和朋友們聚會。

2349
01:51:50,740 --> 01:51:52,980
我打印出來勞倫。

2350
01:51:52,980 --> 01:51:54,200
它打印出來米洛。

2351
01:51:54,200 --> 01:51:56,810
然後我在數據庫名稱
是劇本後

2352
01:51:56,810 --> 01:51:58,060
直言不諱的Facebook狀態。

2353
01:51:58,060 --> 01:52:00,740

2354
01:52:00,740 --> 01:52:04,330
因為我這個插入到頁面
因為它看起來像JavaScript中，當

2355
01:52:04,330 --> 01:52:07,930
當前頁被發送給用戶，
它被執行為JavaScript。

2356
01:52:07,930 --> 01:52:10,800
所以這就是我們所說的
跨站點腳本攻擊。

2357
01:52:10,800 --> 01:52:14,570
有人把惡意信息
您可能對應於數據庫

2358
01:52:14,570 --> 01:52:17,080
一些額外的字符串或
一些JavaScript字符串。

2359
01:52:17,080 --> 01:52:20,130
>> 而當它被打印出來的
以這種方式頁面，那麼什麼

2360
01:52:20,130 --> 01:52:22,580
發生的情況是不好的代碼被執行
我沒打算

2361
01:52:22,580 --> 01:52:25,110
它得到執行。

2362
01:52:25,110 --> 01:52:28,230
而這一切，一個跨站點
腳本攻擊。

2363
01:52:28,230 --> 01:52:31,790
和你周圍的路
這就像Zamyla說。

2364
01:52:31,790 --> 01:52:34,340
你只是包裝的東西
HTML特殊字符。

2365
01:52:34,340 --> 01:52:39,460
與此HTML特殊字符是一個PHP
功能，以防止這種

2366
01:52:39,460 --> 01:52:42,000
從發生在你身上的事情
如果你有一個惡意的

2367
01:52:42,000 --> 01:52:43,830
字符串在數據庫中。

2368
01:52:43,830 --> 01:52:47,650
它只是逃脫它，所以它不
得到解釋為HTML。

2369
01:52:47,650 --> 01:52:50,960
它取代了小括號
我們所說的實體。

2370
01:52:50,960 --> 01:52:52,250
於是我們過了這個講座中也。

2371
01:52:52,250 --> 01:52:55,800
所以，我想你們應該有
把握好這一點。

2372
01:52:55,800 --> 01:52:57,420
有問題嗎？

2373
01:52:57,420 --> 01:52:57,820
是。

2374
01:52:57,820 --> 01:53:00,860
>> 觀眾：那麼，如何將
在[聽不清]？

2375
01:53:00,860 --> 01:53:01,555
>> 王陽：再說了。

2376
01:53:01,555 --> 01:53:02,500
>> 觀眾：如何將顯示器 - 

2377
01:53:02,500 --> 01:53:02,860
>> 王陽：對。

2378
01:53:02,860 --> 01:53:06,080
所以，你有什麼事情，說，當
我註冊，輸入我的名字。

2379
01:53:06,080 --> 01:53:09,390
我只需鍵入在這一領域，我的名字是
剝後直言不諱的Facebook

2380
01:53:09,390 --> 01:53:11,570
狀態密切的腳本標記。

2381
01:53:11,570 --> 01:53:15,690
而這只是被放入
數據庫，因為我不能說別人

2382
01:53:15,690 --> 01:53:18,260
在世界上沒有一個名字
用左箭頭，或在

2383
01:53:18,260 --> 01:53:19,036
在它的字的腳本。

2384
01:53:19,036 --> 01:53:21,330
這並沒有真正意義。

2385
01:53:21,330 --> 01:53:24,560
所以，我只是要確保我
消毒的東西之前，我打印出來

2386
01:53:24,560 --> 01:53:25,420
出到頁面中。

2387
01:53:25,420 --> 01:53:27,140
>> 觀眾：所以HTML特殊卡
防止腳本標籤？

2388
01:53:27,140 --> 01:53:28,710
>> 王陽：是啊。

2389
01:53:28,710 --> 01:53:29,960
所以它不會阻止腳本標記。

2390
01:53:29,960 --> 01:53:32,320
它只是可以確保
script標籤沒有得到

2391
01:53:32,320 --> 01:53:35,120
解釋為HTML或 - 

2392
01:53:35,120 --> 01:53:35,400
是的。

2393
01:53:35,400 --> 01:53:38,470
它只是出來作為什麼
它實際上是。

2394
01:53:38,470 --> 01:53:39,220
好的。

2395
01:53:39,220 --> 01:53:40,930
所以這是測驗檢討。

2396
01:53:40,930 --> 01:53:41,830
涼爽。

2397
01:53:41,830 --> 01:53:45,088
>> [掌聲]