1
00:00:00,000 --> 00:00:05,616

2
00:00:05,616 --> 00:00:07,030
>> 漢娜布隆伯格：大家好。

3
00:00:07,030 --> 00:00:09,530
我們將開始
短短幾分鐘的早期

4
00:00:09,530 --> 00:00:11,738
因為我們有一大堆
材料打通。

5
00:00:11,738 --> 00:00:12,790
我是漢娜。

6
00:00:12,790 --> 00:00:13,865
我是一個TF。

7
00:00:13,865 --> 00:00:16,239
瑪麗亞將要加盟
我們在短短的幾分鐘。

8
00:00:16,239 --> 00:00:17,560
她右側前教節。

9
00:00:17,560 --> 00:00:19,351
我教的部分權
之後，所以我們要

10
00:00:19,351 --> 00:00:21,200
把它存到一個半小時​​。

11
00:00:21,200 --> 00:00:25,490
>> 所以你會看到在這裡，我們有很
幾個主題，我們需要打通，

12
00:00:25,490 --> 00:00:27,200
因此我們將快速去一點點。

13
00:00:27,200 --> 00:00:31,140
但是，如果在任何時候，我們說些什麼
太快或者你不明白，

14
00:00:31,140 --> 00:00:33,170
隨意中斷與問題。

15
00:00:33,170 --> 00:00:36,610
我們希望能夠使這一個
審查會議是有益的各位

16
00:00:36,610 --> 00:00:37,973
越好。

17
00:00:37,973 --> 00:00:38,920
真棒。

18
00:00:38,920 --> 00:00:41,650
>> 因此，讓我們直接與
有些話題，我們實際上

19
00:00:41,650 --> 00:00:46,980
非常非常簡要介紹了
測驗0的測驗0審查會議。

20
00:00:46,980 --> 00:00:48,840
所以先從鍊錶。

21
00:00:48,840 --> 00:00:52,090
因此，只要確保你有一些
關於鍊錶的基本知識

22
00:00:52,090 --> 00:00:55,110
並在方便執行
一些基本操作的。

23
00:00:55,110 --> 00:00:58,560
>> 因此，只要審查，鏈接
列表比數組更好

24
00:00:58,560 --> 00:01:01,020
因為它們可以動態地增長。

25
00:01:01,020 --> 00:01:03,300
因此，我們有一個巨大的優勢。

26
00:01:03,300 --> 00:01:06,031
我們已經看到了他們使用
在哈希表的時候，我們

27
00:01:06,031 --> 00:01:08,280
不知道到底有多少
我們將事情想

28
00:01:08,280 --> 00:01:10,900
插入到我們的數據結構。

29
00:01:10,900 --> 00:01:15,700
不幸的是，我們有件
鏈接目錄上的內存，

30
00:01:15,700 --> 00:01:20,820
所以我們不一定會
能夠做到一定的時間訪問

31
00:01:20,820 --> 00:01:22,502
到在該鏈接的表的任意元素。

32
00:01:22,502 --> 00:01:24,210
為了找到一個
特定的元素，我們

33
00:01:24,210 --> 00:01:26,510
必須遍歷所有的
從一開始的方式。

34
00:01:26,510 --> 00:01:30,610
所以，請記住，大部分
基本操作是1歐米加。

35
00:01:30,610 --> 00:01:32,130
所以插入只是要取1。

36
00:01:32,130 --> 00:01:37,520
刪除是要取n，因為我們
必須去從列表中找到它。

37
00:01:37,520 --> 00:01:39,260
而搜索可以採取，在最壞的情況，正。

38
00:01:39,260 --> 00:01:42,330
我們不能做這樣的事情
上鍊錶二進制搜索

39
00:01:42,330 --> 00:01:45,101
因為我們不能只是
隨機跳躍到中間。

40
00:01:45,101 --> 00:01:45,600
涼。

41
00:01:45,600 --> 00:01:48,160

42
00:01:48,160 --> 00:01:48,960
真棒。

43
00:01:48,960 --> 00:01:50,270
>> 成堆的一點點。

44
00:01:50,270 --> 00:01:53,980
這又來了個測驗0，那麼你
應該是超級舒服。

45
00:01:53,980 --> 00:01:57,210
但是對於棧，我們請你
記住一摞托盤。

46
00:01:57,210 --> 00:01:59,940
而且這將是先入後出。

47
00:01:59,940 --> 00:02:02,272
因此，我們疊的事情了
在紙疊，然後

48
00:02:02,272 --> 00:02:04,980
如果我們試圖採取一些
off--我們稱之為突然離開

49
00:02:04,980 --> 00:02:06,581
在stack--我們來頂掉。

50
00:02:06,581 --> 00:02:09,289
如果我們想要把東西
在堆棧中，我們把它推。

51
00:02:09,289 --> 00:02:13,170
所以它總是會被成長
從像堆疊托盤的底部。

52
00:02:13,170 --> 00:02:14,540
真棒。

53
00:02:14,540 --> 00:02:17,607
>> 我們已經看到了堆實現
既鍊錶和數組。

54
00:02:17,607 --> 00:02:19,440
如果你正在實施
數組，你想

55
00:02:19,440 --> 00:02:22,350
以確保保持跟踪
的大小和容量。

56
00:02:22,350 --> 00:02:27,540
這樣大小將是當前
物聯網的籌碼數量，

57
00:02:27,540 --> 00:02:32,900
而容量是總數
事情你可以存儲在您的堆棧。

58
00:02:32,900 --> 00:02:34,220
涼。

59
00:02:34,220 --> 00:02:35,767
>> 非常相似，我們有隊列。

60
00:02:35,767 --> 00:02:38,850
在這種情況下，代替考慮
一摞托盤，認為一行。

61
00:02:38,850 --> 00:02:40,697
這將是第一個先出。

62
00:02:40,697 --> 00:02:42,780
所以，如果你正在排隊等候
東西在商店，

63
00:02:42,780 --> 00:02:46,920
我們希望這個人首先在
線將被第一幫助。

64
00:02:46,920 --> 00:02:49,350
>> 與其說推及
流行像我們這樣的堆棧，

65
00:02:49,350 --> 00:02:52,000
我們只說入隊和出隊。

66
00:02:52,000 --> 00:02:54,970
再次，如果你是
以與陣列實現此，

67
00:02:54,970 --> 00:02:56,720
我們需要跟踪
不僅大小

68
00:02:56,720 --> 00:03:02,390
和容量，而且頭，這
將是我們的隊列的前面。

69
00:03:02,390 --> 00:03:03,010
涼。

70
00:03:03,010 --> 00:03:05,770
在任何的任何問題嗎？

71
00:03:05,770 --> 00:03:06,320
真棒。

72
00:03:06,320 --> 00:03:07,640
運動沿著正確的。

73
00:03:07,640 --> 00:03:08,564
>> OK，哈希表。

74
00:03:08,564 --> 00:03:10,605
在此處，它開始
得到真正有趣。

75
00:03:10,605 --> 00:03:14,150
所以一個哈希表是一個實施
一個關聯數組中。

76
00:03:14,150 --> 00:03:16,700
所以基本上發生了什麼
是我們這一切的投入，

77
00:03:16,700 --> 00:03:18,750
我們給它一個散列
功能它說，

78
00:03:18,750 --> 00:03:21,840
OK，這就是在
哈希表它屬於。

79
00:03:21,840 --> 00:03:24,860
>> 所以，最簡單的散列函數
我們已經看到的只是說，

80
00:03:24,860 --> 00:03:28,170
好吧，假設我們希望把
在我們的哈希表的字符串。

81
00:03:28,170 --> 00:03:30,870
而一個非常簡單的想法
可能是說好，

82
00:03:30,870 --> 00:03:34,350
讓我們只用排序
這個詞的第一個字母。

83
00:03:34,350 --> 00:03:37,570
所以，你可以在這裡看到，我們採取的香蕉，
我們把它通過一個散列函數，

84
00:03:37,570 --> 00:03:40,190
它說，嘿，這
應該去索引1。

85
00:03:40,190 --> 00:03:45,120
>> 所以，我們基本上可以認為散列
表作為一群不同桶。

86
00:03:45,120 --> 00:03:49,880
而且每個桶是怎麼回事
持有的一個鍊錶的頭部。

87
00:03:49,880 --> 00:03:55,030
而在這鍊錶，我們可以
居然把不同的數據塊。

88
00:03:55,030 --> 00:03:57,820
>> 更使潛水一點點
成散列函數，這裡的

89
00:03:57,820 --> 00:03:59,870
這個例子我只是
說明了我們剛剛說的，

90
00:03:59,870 --> 00:04:02,460
OK，取第一個字母
這個詞和我們

91
00:04:02,460 --> 00:04:03,990
將它整理成桶。

92
00:04:03,990 --> 00:04:08,490
所以大概就會有26桶，
一個用於每個字母。

93
00:04:08,490 --> 00:04:10,090
為什麼不是一個很好的散列函數？

94
00:04:10,090 --> 00:04:13,461
是什麼讓這個不理想？

95
00:04:13,461 --> 00:04:13,960
是啊。

96
00:04:13,960 --> 00:04:15,790
>> 聽眾：你會
有衝突。

97
00:04:15,790 --> 00:04:16,390
>> 漢娜布隆伯格：是的，沒錯。

98
00:04:16,390 --> 00:04:18,000
你將有碰撞。

99
00:04:18,000 --> 00:04:18,954
所以這是一件事。

100
00:04:18,954 --> 00:04:21,620
我們將討論我們如何能夠
解決衝突，在短短一秒鐘。

101
00:04:21,620 --> 00:04:23,980
與此另一個問題
特別是哈希函數

102
00:04:23,980 --> 00:04:25,980
是我們的不同
水桶將要

103
00:04:25,980 --> 00:04:28,960
漂亮截然不同的大小。

104
00:04:28,960 --> 00:04:33,840
>> 我們知道，有一大堆
更多的單詞開始與比X，

105
00:04:33,840 --> 00:04:38,980
所以我們將有很
不平衡的水桶在我們的哈希表。

106
00:04:38,980 --> 00:04:40,050
涼。

107
00:04:40,050 --> 00:04:41,340
所以是的，讓我們回到
點碰撞。

108
00:04:41,340 --> 00:04:42,900
我們該怎麼辦，如果有衝突？

109
00:04:42,900 --> 00:04:44,490
>> 我們有幾個不同的選擇。

110
00:04:44,490 --> 00:04:47,600
所以之一，所以假設我們正在努力
把漿果到我們的哈希表。

111
00:04:47,600 --> 00:04:50,370
而且我們看到，哦，我們要
把它放在索引1，

112
00:04:50,370 --> 00:04:52,070
但香蕉已經住在這裡。

113
00:04:52,070 --> 00:04:53,110
我們會做什麼？

114
00:04:53,110 --> 00:04:54,560
我們有兩個主要的選擇。

115
00:04:54,560 --> 00:04:58,050
>> 排名第一的是我們可以說，OK，
有沒有空間索引1，

116
00:04:58,050 --> 00:05:03,210
但是讓我們只是不停地翻翻
直到我們可以找到另一個空位。

117
00:05:03,210 --> 00:05:08,490
所以我們會說，好吧，
讓我們把它點3。

118
00:05:08,490 --> 00:05:09,240
這是一個選項。

119
00:05:09,240 --> 00:05:11,470
這就是所謂的線性探測。

120
00:05:11,470 --> 00:05:15,500
>> 而第二個選項是說，好了，好了，
我們只是讓這些水桶

121
00:05:15,500 --> 00:05:17,470
是鍊錶的頭。

122
00:05:17,470 --> 00:05:21,910
而且它是確定的，如果有更多的
比水桶的一件事。

123
00:05:21,910 --> 00:05:23,820
我們只是要
追加它推上前台。

124
00:05:23,820 --> 00:05:26,032
所以在這裡你可以看到，OK，
當我們插入的漿果，我們

125
00:05:26,032 --> 00:05:28,240
只是把種香蕉，
推了一點點

126
00:05:28,240 --> 00:05:29,842
，並在那裡扔了漿果。

127
00:05:29,842 --> 00:05:31,050
而這也完全罰款。

128
00:05:31,050 --> 00:05:32,830
這就是所謂的分離鏈。

129
00:05:32,830 --> 00:05:38,100
你可以認為這作為一種像
首腦數組鍊錶。

130
00:05:38,100 --> 00:05:41,950
哈希有任何疑問
表，哈希函數？

131
00:05:41,950 --> 00:05:44,290
真棒。

132
00:05:44,290 --> 00:05:45,470
>> 樹木和嘗試。

133
00:05:45,470 --> 00:05:47,287
所以一棵樹是任何種類的
的數據結構的

134
00:05:47,287 --> 00:05:49,453
其中有某種
層次或某種

135
00:05:49,453 --> 00:05:51,247
的排名你不同的對象。

136
00:05:51,247 --> 00:05:53,580
而這將成為超
清晰的，當我們看一個例子。

137
00:05:53,580 --> 00:05:56,960
而我們看到的嘗試，以及
用哈希表，在pset5--

138
00:05:56,960 --> 00:06:00,700
這又完全公平的遊戲
這quiz--作為另一個數據

139
00:06:00,700 --> 00:06:03,110
結構我們可以
存儲不同的東西。

140
00:06:03,110 --> 00:06:06,782
在字典中的情況下，
我們存儲了一堆話。

141
00:06:06,782 --> 00:06:08,240
因此，讓我們來看看一些樹木。

142
00:06:08,240 --> 00:06:10,190
因此，這是一個樹的一例。

143
00:06:10,190 --> 00:06:13,105
它具有一種結構，
該分層結構中，

144
00:06:13,105 --> 00:06:15,920
在這裡你可以看到，
在上面這1個節點

145
00:06:15,920 --> 00:06:20,750
具有以上職級2和3某種形式，
這是上述4，5和6和7，

146
00:06:20,750 --> 00:06:22,860
這是上述圖8和9。

147
00:06:22,860 --> 00:06:25,210
所以，這就是我們所說的一
樹，這樣你就可以正中下懷

148
00:06:25,210 --> 00:06:26,660
畫面這在你的腦袋。

149
00:06:26,660 --> 00:06:29,050
>> 現在，我們有幾個
更專業化的樹木。

150
00:06:29,050 --> 00:06:31,070
這樣的一個例子是一個二叉樹。

151
00:06:31,070 --> 00:06:33,290
而一個二叉樹，
再次，只是要

152
00:06:33,290 --> 00:06:37,040
數據結構與某種
層次結構，但是每個節點

153
00:06:37,040 --> 00:06:38,650
最多可以有兩個孩子。

154
00:06:38,650 --> 00:06:41,530
這就是這個詞二進制從何而來。

155
00:06:41,530 --> 00:06:43,410
因此，這是一個二進制樹的一例。

156
00:06:43,410 --> 00:06:45,720
所以這是一個小類別的樹木。

157
00:06:45,720 --> 00:06:48,960
>> 現在，讓我們更具體，
談二trees--二進制搜索

158
00:06:48,960 --> 00:06:51,310
樹木，而不是。

159
00:06:51,310 --> 00:06:56,430
因此，這裡的想法是不僅不
每個節點最多有兩個孩子，

160
00:06:56,430 --> 00:07:00,300
但所有的孩子去的
左側將是較小的

161
00:07:00,300 --> 00:07:03,450
和所有的孩子都到了
正確的將是更大的。

162
00:07:03,450 --> 00:07:05,890
因此，通知只是我們
二叉樹，有

163
00:07:05,890 --> 00:07:08,650
數字之間的關係。

164
00:07:08,650 --> 00:07:12,990
但是，在我們的二進制搜索
樹，我們看到了，好了，下面是44。

165
00:07:12,990 --> 00:07:17,080
而每號44的左邊是
體積更小，一切的權利

166
00:07:17,080 --> 00:07:17,920
就越大。

167
00:07:17,920 --> 00:07:20,130
>> 和保持在每個
樹的水平。

168
00:07:20,130 --> 00:07:24,810
所以在這裡，這是小於
22，這是比22大。

169
00:07:24,810 --> 00:07:26,390
而這二叉搜索樹。

170
00:07:26,390 --> 00:07:28,900
為什麼我們認為這就是所謂的
二叉搜索樹？

171
00:07:28,900 --> 00:07:30,651
它想起了什麼算法嗎？

172
00:07:30,651 --> 00:07:31,650
聽眾：二進制搜索。

173
00:07:31,650 --> 00:07:32,480
漢娜布隆伯格：二進制搜索。

174
00:07:32,480 --> 00:07:35,150
因為如果你正在尋找一個
在這棵樹特定數目，

175
00:07:35,150 --> 00:07:38,800
在每一點上，你可以敲
樹，這是偉大的了一半。

176
00:07:38,800 --> 00:07:43,800
所以那將會給我們的東西
看起來很像二進制搜索。

177
00:07:43,800 --> 00:07:45,870
任何問題？

178
00:07:45,870 --> 00:07:47,570
好吧，冷靜。

179
00:07:47,570 --> 00:07:48,560
>> 好吧，嘗試。

180
00:07:48,560 --> 00:07:49,657
大家的喜愛。

181
00:07:49,657 --> 00:07:51,990
因此，這是該示例
我們已經看到了一堆類。

182
00:07:51,990 --> 00:07:54,710
再次，這是另一種
我們可以存儲數據的方式。

183
00:07:54,710 --> 00:07:57,530
在字典中的情況下，再次，
這只是將是字符串。

184
00:07:57,530 --> 00:08:00,870
因此，讓我們看看這實際上
看起來像在稍低的水平。

185
00:08:00,870 --> 00:08:03,690
>> 因此，讓我們一起來看看
在字典樹的一個節點。

186
00:08:03,690 --> 00:08:07,532
而且我們看到，OK，有是怎麼回事
是一個布爾和節點，

187
00:08:07,532 --> 00:08:09,170
的指針的節點。

188
00:08:09,170 --> 00:08:11,400
而我們看到，
布爾被稱為is_word。

189
00:08:11,400 --> 00:08:13,490
所以基本上，這是
要對應

190
00:08:13,490 --> 00:08:16,750
這些小三角這
說，如果你在這裡得到，

191
00:08:16,750 --> 00:08:19,100
你發現了一個完整的單詞。

192
00:08:19,100 --> 00:08:23,670
>> 我們知道，“圖靈”過
這裡是一個完整的字，

193
00:08:23,670 --> 00:08:28,030
而只有T-U-R是不發一言
因為我們沒有看到那個小三角。

194
00:08:28,030 --> 00:08:31,440
而那個小三角，再一次，
對應於該is_word，

195
00:08:31,440 --> 00:08:34,480
此布爾is_word。

196
00:08:34,480 --> 00:08:36,320
然後我們有孩子的數組。

197
00:08:36,320 --> 00:08:39,860
所以在每個級，則
有一個特定節點，

198
00:08:39,860 --> 00:08:42,470
並且該節點指向一個
陣列整個字母表。

199
00:08:42,470 --> 00:08:44,346
>> 所以你可以看到，同樣，
在此picture--我

200
00:08:44,346 --> 00:08:48,170
要保持跳回來，
forth--，這一陣列頂部

201
00:08:48,170 --> 00:08:51,640
有一堆不同的
節點即將關閉它。

202
00:08:51,640 --> 00:08:57,140
它有26個，或27，如果你想
包括一個多餘的字符。

203
00:08:57,140 --> 00:09:01,320
這給了我們一個
方法來存儲我們的數據

204
00:09:01,320 --> 00:09:04,450
在可以看著一個方式
你可以查找超快速。

205
00:09:04,450 --> 00:09:06,650
什麼是查找時間為線索？

206
00:09:06,650 --> 00:09:07,970
>> 聽眾：[聽不清]。

207
00:09:07,970 --> 00:09:08,300
>> 漢娜布隆伯格：是的。

208
00:09:08,300 --> 00:09:09,550
從理論上講，它的恆定時間。

209
00:09:09,550 --> 00:09:13,230
它一定會成為大小
您要查找的單詞。

210
00:09:13,230 --> 00:09:15,950
即使我們增加了無限
更多的話我們的線索，

211
00:09:15,950 --> 00:09:18,160
它不會帶我們
任何更長的時間才能確定

212
00:09:18,160 --> 00:09:19,690
如果一個給定的字是在線索。

213
00:09:19,690 --> 00:09:21,412
所以這是非常好的。

214
00:09:21,412 --> 00:09:23,697
>> 聽眾：您剛才
初始化數組？

215
00:09:23,697 --> 00:09:24,780
你錯過了一個或兩個點。

216
00:09:24,780 --> 00:09:26,130
你能不能說說
對於第二？

217
00:09:26,130 --> 00:09:26,680
>> 漢娜布隆伯格：當然，絕對的。

218
00:09:26,680 --> 00:09:27,590
好問題。

219
00:09:27,590 --> 00:09:31,140
問題是，我們
有一個數組的

220
00:09:31,140 --> 00:09:34,180
將有節點明星作為
而不僅僅是節點，對不對？

221
00:09:34,180 --> 00:09:35,180
涼。

222
00:09:35,180 --> 00:09:37,990
所以在這裡我們在說什麼
是我們陣只是

223
00:09:37,990 --> 00:09:40,035
將是指向其他數組。

224
00:09:40,035 --> 00:09:42,910
因此，它的essentially--它種
感覺就像一個鍊錶以這種方式

225
00:09:42,910 --> 00:09:46,620
其中每個這些兒童
只是點到下一個節點。

226
00:09:46,620 --> 00:09:49,030
>> 和的方式，我們
實際上是決定了，嘿嘿，OK，

227
00:09:49,030 --> 00:09:52,320
我們已經經歷了一個完整的迭代
一句話，就是這個字在字典中，

228
00:09:52,320 --> 00:09:54,476
我們只要檢查該is_word。

229
00:09:54,476 --> 00:09:55,100
大的問題。

230
00:09:55,100 --> 00:09:55,675
是啊。

231
00:09:55,675 --> 00:09:56,216
聽眾：OK。

232
00:09:56,216 --> 00:09:57,470
那麼，什麼是運行時間為線索？

233
00:09:57,470 --> 00:09:58,386
>> 漢娜布隆伯格：當然。

234
00:09:58,386 --> 00:10:01,852
因此，運行時為線索的
查找將是恆定的時間。

235
00:10:01,852 --> 00:10:04,310
所以它只是將是
在單詞的字母數。

236
00:10:04,310 --> 00:10:06,310
它不依賴於
字典的大小

237
00:10:06,310 --> 00:10:09,510
或數據結構的大小。

238
00:10:09,510 --> 00:10:12,170
所以這裡有一個稍微簡單的例子。

239
00:10:12,170 --> 00:10:15,430
>> 在這種情況下，你可以看到，
字蝙蝠是在詞典

240
00:10:15,430 --> 00:10:18,900
你有變焦，但你
沒有像動物園。

241
00:10:18,900 --> 00:10:20,050
如何將我們做的動物園？

242
00:10:20,050 --> 00:10:24,276
我們如何加入動物園我們
字典，我們的線索？

243
00:10:24,276 --> 00:10:24,776
是啊。

244
00:10:24,776 --> 00:10:27,014
>> 聽眾：請is_word
真正的[聽不清]。

245
00:10:27,014 --> 00:10:27,930
漢娜布隆伯格：好。

246
00:10:27,930 --> 00:10:31,731
所以我們會說Z-O-O，然後我們會
要檢查了該框為好。

247
00:10:31,731 --> 00:10:32,230
大。

248
00:10:32,230 --> 00:10:35,160

249
00:10:35,160 --> 00:10:37,930
讓我們非常簡要地比較
試圖與哈希表。

250
00:10:37,930 --> 00:10:39,770
嘗試是真正偉大
因為，正如我們所說，

251
00:10:39,770 --> 00:10:41,610
他們提供恆定的時間查找。

252
00:10:41,610 --> 00:10:44,285
但巨大的劣勢
是他們堆積如山。

253
00:10:44,285 --> 00:10:46,160
你可以得到的感覺，
甚至看它，

254
00:10:46,160 --> 00:10:48,454
它要採取
大量的內存。

255
00:10:48,454 --> 00:10:50,620
因此，他們將是多少
大於哈希表，

256
00:10:50,620 --> 00:10:52,270
但他們打算給
我們更快的查找時間。

257
00:10:52,270 --> 00:10:54,478
這就是那種你
權衡，你關心什麼，

258
00:10:54,478 --> 00:10:57,350
無論是速度還是內存。

259
00:10:57,350 --> 00:11:02,251
在任何的任何問題，
所有的C數據結構。

260
00:11:02,251 --> 00:11:02,750
美麗。

261
00:11:02,750 --> 00:11:03,250
好。

262
00:11:03,250 --> 00:11:07,322
我們將進入到一個小
Web開發與瑪麗亞位。

263
00:11:07,322 --> 00:11:08,280
MARIA ZLATKOVA：可愛。

264
00:11:08,280 --> 00:11:09,036
好。

265
00:11:09,036 --> 00:11:10,380
>> 漢娜布隆伯格：你可以用我的筆記本電腦。

266
00:11:10,380 --> 00:11:11,255
>> MARIA ZLATKOVA：好的。

267
00:11:11,255 --> 00:11:13,320

268
00:11:13,320 --> 00:11:14,912
嗯不錯。

269
00:11:14,912 --> 00:11:17,120
正如我們現在轉移到網絡
發展，我們談了一點

270
00:11:17,120 --> 00:11:20,680
有關更改權限
文件和目錄

271
00:11:20,680 --> 00:11:24,190
以便它們可以被訪問
其他用戶，走向世界，

272
00:11:24,190 --> 00:11:28,640
所以，我們可以看到
基本上我們可以傳達他們

273
00:11:28,640 --> 00:11:32,600
當我們開發像網站
我們已經大多被做。

274
00:11:32,600 --> 00:11:36,400
>> 因此，我們看到了chmod命令，
這是改變模式，基本上是這樣。

275
00:11:36,400 --> 00:11:39,300
這是一個Linux命令和
它改變了訪問權限

276
00:11:39,300 --> 00:11:40,410
的文件系統對象。

277
00:11:40,410 --> 00:11:43,370
和文件系統對象是
只是一個目錄，文件，

278
00:11:43,370 --> 00:11:46,810
什麼，你可以
更改的權限。

279
00:11:46,810 --> 00:11:53,750
>> 所以看到文件的權限，
我們輸入ls命令，列表，-l。

280
00:11:53,750 --> 00:11:56,500
當我們鍵入我們
平時看的一些權限

281
00:11:56,500 --> 00:11:59,660
看起來有點像這個
在目錄名的前面。

282
00:11:59,660 --> 00:12:01,260
因此，D表示目錄。

283
00:12:01,260 --> 00:12:05,930
然後我們有三個
黑社會基本上

284
00:12:05,930 --> 00:12:11,675
指代的權限
一個用戶，一個組，或世界。

285
00:12:11,675 --> 00:12:16,490
>> 權限的類型，我們可以
對這些三組人

286
00:12:16,490 --> 00:12:20,830
要么是r代表讀，W代表
寫，x代表執行。

287
00:12:20,830 --> 00:12:23,650
我們可以有那些
本集團與世界。

288
00:12:23,650 --> 00:12:26,940
棘手的是，有時
當我們鍵入chmod命令，

289
00:12:26,940 --> 00:12:32,960
我們會輸入一些數字
這包括三位。

290
00:12:32,960 --> 00:12:36,990
因此，我們可以做的像
777和基本

291
00:12:36,990 --> 00:12:40,450
所指的附加價值
這些黑社會的

292
00:12:40,450 --> 00:12:45,060
因為R.將參考4，W會
指2，且x要提到1，

293
00:12:45,060 --> 00:12:50,020
因此，當相加，每個號碼
會回落到一個累計數

294
00:12:50,020 --> 00:12:52,750
以0到7之間的累積值。

295
00:12:52,750 --> 00:12:55,150
所以，我們也可以有0
在所有沒有權限。

296
00:12:55,150 --> 00:12:58,200
這將基本上給我們
該權限或者用戶，

297
00:12:58,200 --> 00:13:00,450
的組，或世界。

298
00:13:00,450 --> 00:13:02,620
在這個任何問題這麼遠嗎？

299
00:13:02,620 --> 00:13:05,331
>> 聽眾：你說讀了4？

300
00:13:05,331 --> 00:13:06,164
MARIA ZLATKOVA：是的。

301
00:13:06,164 --> 00:13:07,568
聽眾：[聽不清]。

302
00:13:07,568 --> 00:13:08,504
漢娜布隆伯格：是的。

303
00:13:08,504 --> 00:13:11,790
聽眾：再加入所有
其他人則表示你的電話號碼。

304
00:13:11,790 --> 00:13:12,665
MARIA ZLATKOVA：是的。

305
00:13:12,665 --> 00:13:14,970
是啊。

306
00:13:14,970 --> 00:13:17,810
這些都是很大的問題。

307
00:13:17,810 --> 00:13:20,490
可愛。

308
00:13:20,490 --> 00:13:25,340
接下來，我們跳進HTML和
更多有關Web開發位。

309
00:13:25,340 --> 00:13:27,990
因此，HTML只是手段
超文本標記語言。

310
00:13:27,990 --> 00:13:30,460
那就是標記
語，是一個標準

311
00:13:30,460 --> 00:13:32,720
即它被用來製作網頁。

312
00:13:32,720 --> 00:13:35,750
>> 這就是所謂的標記語言
因為它實際上沒有編制。

313
00:13:35,750 --> 00:13:40,310
這並不是說一些代碼應該如何
執行或類似的東西。

314
00:13:40,310 --> 00:13:44,800
它只是界定和
描述了一個網頁

315
00:13:44,800 --> 00:13:46,840
頁面應設置
與它的每個元素

316
00:13:46,840 --> 00:13:48,460
以及他們如何應該給用戶。

317
00:13:48,460 --> 00:13:53,090

318
00:13:53,090 --> 00:13:57,110
>> 一些HTML標籤，我們
走到有以下幾種。

319
00:13:57,110 --> 00:14:00,500
我們所有的HTML文檔
開始使用DOCTYPE HTML。

320
00:14:00,500 --> 00:14:02,550
然後，我們總是有html標記。

321
00:14:02,550 --> 00:14:03,930
我們有一個頭部和主體。

322
00:14:03,930 --> 00:14:07,890
而且，重要的是HTML有
這種嵌套結構

323
00:14:07,890 --> 00:14:09,280
因為它是很清楚的。

324
00:14:09,280 --> 00:14:13,200
然後，它變得很清楚，當我們
需要打開和實際關閉的標籤。

325
00:14:13,200 --> 00:14:18,400
而我們總是需要關閉
我們已經打開的標籤。

326
00:14:18,400 --> 00:14:23,170
>> 在這裡，我們有一些類型的
超前的事情，我們希望有。

327
00:14:23,170 --> 00:14:26,580
因此，我們有，例如，
CS50的稱號。

328
00:14:26,580 --> 00:14:31,980
然後我們實際上
可以鏈接樣式表

329
00:14:31,980 --> 00:14:34,030
它定義如何樣式我們的網站。

330
00:14:34,030 --> 00:14:35,650
這是CSS。

331
00:14:35,650 --> 00:14:39,320
我們將去在它的
接下來的幻燈片以及。

332
00:14:39,320 --> 00:14:42,580
>> 在人體中，我們設置
一些類和ID。

333
00:14:42,580 --> 00:14:45,860
而作為一個提醒，一次，
ID是唯一和類

334
00:14:45,860 --> 00:14:47,390
可以分配給多個項目。

335
00:14:47,390 --> 00:14:52,110
而這只是意味著
我們可以使用類和ID

336
00:14:52,110 --> 00:14:55,860
內的其它structures--所以，對於
例如，在CSS文件或樣式

337
00:14:55,860 --> 00:15:00,940
sheets--提及特定元素
基本上說，我們想要的風格

338
00:15:00,940 --> 00:15:03,280
或者設計一些元素
在一些特定的方式。

339
00:15:03,280 --> 00:15:06,440
我們稱它們通過
他們的ID和班級。

340
00:15:06,440 --> 00:15:09,870
而且我們也可以指
通過標記不同的東西為好，

341
00:15:09,870 --> 00:15:13,830
但ID和班級只是給我們一些
多功能性和具體是什麼我們

342
00:15:13,830 --> 00:15:15,850
想參考。

343
00:15:15,850 --> 00:15:19,620
>> 所以，只是一個例子。

344
00:15:19,620 --> 00:15:22,730
我們可以再次內
一個CSS文件，我們

345
00:15:22,730 --> 00:15:25,770
要定義一些
style--這樣的顏色，字體，

346
00:15:25,770 --> 00:15:30,340
和類似的東西that--我們可以
定義樣式的身體。

347
00:15:30,340 --> 00:15:32,640
因此，這將定義它
整個身體標記。

348
00:15:32,640 --> 00:15:36,160
但是，我們也可以定義
風格的#title。

349
00:15:36,160 --> 00:15:40,390
再次，包括hashtag是指我們
ID和點指的是我們班的。

350
00:15:40,390 --> 00:15:44,760
>> 然後為.INFO，我們
還可以設置一些屬性。

351
00:15:44,760 --> 00:15:49,750
再次，當我們回去，我們有我們的
類調用的信息和我們的ID稱號。

352
00:15:49,750 --> 00:15:53,422
我們可以看到，我們參考
給他們#title和.INFO。

353
00:15:53,422 --> 00:15:55,380
聽眾：你會說
井號 [？採納我？ ？]

354
00:15:55,380 --> 00:15:55,725
MARIA ZLATKOVA：對不起？

355
00:15:55,725 --> 00:15:58,120
聽眾：你會說
井號 [？採納我？ ？]

356
00:15:58,120 --> 00:16:01,400
MARIA ZLATKOVA：包括hashtag
裝置ID，因此#title

357
00:16:01,400 --> 00:16:07,890
指的是什麼元素
這個ID叫做稱號。

358
00:16:07,890 --> 00:16:10,735
然後將點是指一類。

359
00:16:10,735 --> 00:16:14,590
因此，.INFO是指該元素
因為它具有類信息。

360
00:16:14,590 --> 00:16:15,090
對。

361
00:16:15,090 --> 00:16:17,905
>> 聽眾：你為什麼
區分它們在HTML？

362
00:16:17,905 --> 00:16:20,985
為什麼這麼說有些事情是
ID和某些事情是類？

363
00:16:20,985 --> 00:16:22,610
瑪麗亞ZLATKOVA：這只是達到你 - 

364
00:16:22,610 --> 00:16:24,151
漢娜布隆伯格：重複的問題。

365
00:16:24,151 --> 00:16:25,370
MARIA ZLATKOVA：哦，對不起。

366
00:16:25,370 --> 00:16:29,480
我們為什麼要區分某些元素
作為ID和其他元素如類？

367
00:16:29,480 --> 00:16:34,760
這只是因為它是
真的經常設計選擇。

368
00:16:34,760 --> 00:16:38,520
它給你很多
多功能性是

369
00:16:38,520 --> 00:16:43,250
可以說，我想這個特定項目
因為他們希望能有這個ID

370
00:16:43,250 --> 00:16:45,300
做了很多的事情
有了它，我只

371
00:16:45,300 --> 00:16:50,010
要定義一種風格，某種風格
或顏色無論該項目。

372
00:16:50,010 --> 00:16:52,630
而辦法做到這一點
只是給它一個ID。

373
00:16:52,630 --> 00:16:55,060
>> 然後，如果我想有
幾個不同的項目

374
00:16:55,060 --> 00:16:58,940
具有，而不是
去和設置their--

375
00:16:58,940 --> 00:17:03,840
而不是通過這樣做
標籤，因為標籤會

376
00:17:03,840 --> 00:17:07,369
設置單元格為整個標籤
對於每一次的標籤時，

377
00:17:07,369 --> 00:17:09,740
你可以設置一個類的多個項目。

378
00:17:09,740 --> 00:17:15,109
然後就是訪問類，並說
我想這個樣式類的方式。

379
00:17:15,109 --> 00:17:17,579
>> 再次，這個類可以
是多個不同的項目

380
00:17:17,579 --> 00:17:21,150
和ID必須是唯一的。

381
00:17:21,150 --> 00:17:21,849
大的問題。

382
00:17:21,849 --> 00:17:25,339
其他問題嗎？

383
00:17:25,339 --> 00:17:26,220
OK，真棒。

384
00:17:26,220 --> 00:17:30,680

385
00:17:30,680 --> 00:17:35,330
再次，這是這些選擇器如何
在CSS中引用，與包括hashtag，

386
00:17:35,330 --> 00:17:40,031
與點，或沒有任何東西
分配一些標籤的風格，

387
00:17:40,031 --> 00:17:40,530
狀體。

388
00:17:40,530 --> 00:17:43,500

389
00:17:43,500 --> 00:17:47,860
在這裡，我們有通用
這是如何實現的語法。

390
00:17:47,860 --> 00:17:52,830

391
00:17:52,830 --> 00:17:55,680
>> 要重複一些最佳
對HTML和CSS的做法，

392
00:17:55,680 --> 00:17:59,170
我們需要再次關閉所有
我們打開HTML標記。

393
00:17:59,170 --> 00:18:03,950
而我們推薦您
為你的最後的項目，

394
00:18:03,950 --> 00:18:10,560
以及為CS50金融，就是讓
確保所有的HTML驗證。

395
00:18:10,560 --> 00:18:12,920
而這樣做了與W3驗證。

396
00:18:12,920 --> 00:18:16,940
>> 然後呢，我們沒有和
我們建議這樣做

397
00:18:16,940 --> 00:18:19,790
是分離式的，所以
CSS從HTML標記。

398
00:18:19,790 --> 00:18:24,210
因此，涉及到如何什麼
你的頁面會在視覺上看起來

399
00:18:24,210 --> 00:18:27,330
以及它如何會被修改
應該進入一個CSS文件。

400
00:18:27,330 --> 00:18:33,880
然後你的標記說怎麼會事
是在相對於彼此是HTML，

401
00:18:33,880 --> 00:18:37,550
這應該進去
你的HTML文檔。

402
00:18:37,550 --> 00:18:38,590
任何問題？

403
00:18:38,590 --> 00:18:39,226
MHM。

404
00:18:39,226 --> 00:18:42,628
>> 聽眾：究竟是怎麼回事
在與頁面驗證

405
00:18:42,628 --> 00:18:47,945
當我們驗證
[聽不清]創建的HTML？

406
00:18:47,945 --> 00:18:49,850
>> MARIA ZLATKOVA：所以what--想你。

407
00:18:49,850 --> 00:18:53,020
那麼究竟是怎麼回事
與頁面驗證

408
00:18:53,020 --> 00:18:55,570
為什麼我們需要做的是什麼？

409
00:18:55,570 --> 00:18:59,180
基本上，我們需要做的
因為很多時候，您的瀏覽器，

410
00:18:59,180 --> 00:19:01,390
如果你不關閉一個標籤
或類似的東西，

411
00:19:01,390 --> 00:19:05,680
您的瀏覽器仍然會
呈現一個頁面，可能仍然工作，

412
00:19:05,680 --> 00:19:10,840
但它是最好的做法，以確保
你再次關閉所有的標籤，

413
00:19:10,840 --> 00:19:13,190
您的所有元素
它們應該是這樣，

414
00:19:13,190 --> 00:19:18,470
基本上，它是由
所預設的約定。

415
00:19:18,470 --> 00:19:21,970
>> 這，再次，只是一個
的事情，你應該

416
00:19:21,970 --> 00:19:24,040
要學習做，
相對於具有

417
00:19:24,040 --> 00:19:25,696
更模糊代碼之類的東西。

418
00:19:25,696 --> 00:19:26,688
是啊。

419
00:19:26,688 --> 00:19:27,680
噢對不起。

420
00:19:27,680 --> 00:19:29,221
我還以為你養你的手。

421
00:19:29,221 --> 00:19:31,240
聽眾：不，我只是[聽不清]。

422
00:19:31,240 --> 00:19:33,800
>> MARIA ZLATKOVA：OK。

423
00:19:33,800 --> 00:19:34,640
>> 聽眾：謝謝。

424
00:19:34,640 --> 00:19:36,181
>> MARIA ZLATKOVA：當然，謝謝。

425
00:19:36,181 --> 00:19:41,680
如此反复，馬上就要到如何
信息被傳

426
00:19:41,680 --> 00:19:44,630
和通信模型
傳送信息。

427
00:19:44,630 --> 00:19:45,730
的TCP / IP。

428
00:19:45,730 --> 00:19:48,600
TCP只是意味著傳播
控制協議和IP

429
00:19:48,600 --> 00:19:51,260
指互聯網協議。

430
00:19:51,260 --> 00:19:54,275
而這僅僅是指
數據的方式被遞送。

431
00:19:54,275 --> 00:19:59,470

432
00:19:59,470 --> 00:20:02,710
>> 如果我們有一些數據
需要輸送到你 - 如此

433
00:20:02,710 --> 00:20:06,770
你為某個服務器的請求。

434
00:20:06,770 --> 00:20:09,800
例如，當我們
嘗試訪問cs50.net，

435
00:20:09,800 --> 00:20:12,420
我們提出要求
在CS50服務器與我們

436
00:20:12,420 --> 00:20:14,720
看到我們想要得到
這類信息。

437
00:20:14,720 --> 00:20:19,294
然後基於該協議
這個信息是如何傳遞，

438
00:20:19,294 --> 00:20:21,460
服務器對信息
回到我們的客戶端。

439
00:20:21,460 --> 00:20:25,590
然後我們可以查看
的信息的頁

440
00:20:25,590 --> 00:20:26,390
然後用它。

441
00:20:26,390 --> 00:20:29,300

442
00:20:29,300 --> 00:20:33,050
>> 於是超文本傳輸協議
只是另一種協議或一組

443
00:20:33,050 --> 00:20:37,470
公約的定義如何
web瀏覽器和web服務器

444
00:20:37,470 --> 00:20:38,890
應該溝通。

445
00:20:38,890 --> 00:20:43,730
並把所有這一切
一起，HTTP，再次，

446
00:20:43,730 --> 00:20:50,960
只是定義了這個超界定
由我們一直在它的HTML，

447
00:20:50,960 --> 00:20:59,500
應該如何交付給你，
如何被傳遞到你的數據

448
00:20:59,500 --> 00:21:00,540
得到你。

449
00:21:00,540 --> 00:21:05,990
>> 這就是為什麼，如果你們還記得
從一個類，我們有很多的請求

450
00:21:05,990 --> 00:21:08,970
我們有很多語法
對於這些要求，我們是

451
00:21:08,970 --> 00:21:10,250
要去了現在。

452
00:21:10,250 --> 00:21:13,270
如此反复，當我們發送
一請求到服務器，

453
00:21:13,270 --> 00:21:15,920
我們必須定義一個幾件事情。

454
00:21:15,920 --> 00:21:18,520
因此，我們需要找到的類型
的要求，我們正在設置。

455
00:21:18,520 --> 00:21:22,180
再次，我們有，例如，
GET是一種方法，

456
00:21:22,180 --> 00:21:25,290
我們有我們的要求。

457
00:21:25,290 --> 00:21:31,710
>> 然後HTTP / 1.1僅僅是
我們目前使用該協議。

458
00:21:31,710 --> 00:21:34,224

459
00:21:34,224 --> 00:21:36,890
大部分時間，那將
以我們正在使用的協議。

460
00:21:36,890 --> 00:21:40,290
所以，如果你有一個問題
像你的測驗。

461
00:21:40,290 --> 00:21:43,120
這是該公約
我們有這麼遠。

462
00:21:43,120 --> 00:21:46,580
>> 反斜杠指的是什麼樣的
事情我們請求。

463
00:21:46,580 --> 00:21:52,810
然後，我們的主機是，例如，在這
情況下，我們試圖去到google.com。

464
00:21:52,810 --> 00:21:57,070
所以這是一個主機的值。

465
00:21:57,070 --> 00:21:59,330
這是一種類型的請求
可能被發送的。

466
00:21:59,330 --> 00:22:02,890
>> 然後某種響應可能
被發送，再次，根據該協議，

467
00:22:02,890 --> 00:22:05,190
再次，HTTP / 1.1。

468
00:22:05,190 --> 00:22:07,150
所以這一次的HTTP版本。

469
00:22:07,150 --> 00:22:09,730
200行僅有的狀態代碼。

470
00:22:09,730 --> 00:22:12,860
而這行只是一個短語
基於該狀態碼。

471
00:22:12,860 --> 00:22:15,520
>> 然後將內容類型
指型

472
00:22:15,520 --> 00:22:20,295
即返回給你，是
對您收到該網頁

473
00:22:20,295 --> 00:22:22,570
和您的瀏覽器
可事後渲染。

474
00:22:22,570 --> 00:22:24,401
這是text / html的。

475
00:22:24,401 --> 00:22:26,660
>> 聽眾：什麼是1.1是什麼意思？

476
00:22:26,660 --> 00:22:29,910
>> 瑪麗亞ZLATKOVA：這僅僅是
版本of--哦，這是什麼意思1.1？

477
00:22:29,910 --> 00:22:37,075
這僅僅是個版本中，HTTP
版本，我們正在使用的協議。

478
00:22:37,075 --> 00:22:37,700
大的問題。

479
00:22:37,700 --> 00:22:38,366
其他的問題嗎？

480
00:22:38,366 --> 00:22:41,222

481
00:22:41,222 --> 00:22:45,080
>> 聽眾：你能否總結
內容類型真正的快？

482
00:22:45,080 --> 00:22:48,150
>> MARIA ZLATKOVA：所以這
是服務器。

483
00:22:48,150 --> 00:22:51,020
information--的類型是什麼
內容類型是問題。

484
00:22:51,020 --> 00:22:53,400
所以這是類型
那你回來的信息

485
00:22:53,400 --> 00:22:58,200
從服務器的類型
數據，瀏覽器然後可以

486
00:22:58,200 --> 00:23:00,604
使你使用。

487
00:23:00,604 --> 00:23:03,020
聽眾：難道這就是這
協議是在告訴你做什麼？

488
00:23:03,020 --> 00:23:03,390
MARIA ZLATKOVA：對不起？

489
00:23:03,390 --> 00:23:05,380
聽眾：那是什麼樣的協議說什麼？

490
00:23:05,380 --> 00:23:05,915
MARIA ZLATKOVA：本p​​rotocol--

491
00:23:05,915 --> 00:23:07,940
聽眾： - 什麼的
內容類型是或what--

492
00:23:07,940 --> 00:23:12,040
MARIA ZLATKOVA：該協議是基於
on--什麼是協議告訴你？

493
00:23:12,040 --> 00:23:16,070
這是現在的樣子
這一信息

494
00:23:16,070 --> 00:23:18,610
被送到您根據
在什麼樣的協議

495
00:23:18,610 --> 00:23:21,830
該信息得到
交付還給你。

496
00:23:21,830 --> 00:23:23,500
這是否有道理樣的？

497
00:23:23,500 --> 00:23:28,320

498
00:23:28,320 --> 00:23:30,070
漢娜布隆伯格：你
能想到的協議

499
00:23:30,070 --> 00:23:33,300
作為A--我覺得教授
馬蘭形容它

500
00:23:33,300 --> 00:23:36,910
在課堂上那種像A--這就像
人類握手的等價物。

501
00:23:36,910 --> 00:23:44,930
說，喜歡，嘿嘿，我的請求，我
知道如何處理的1.1版本的HTTP。

502
00:23:44,930 --> 00:23:48,770
然後在服務器說
哦，好吧，我 - 和同時存在。

503
00:23:48,770 --> 00:23:51,337
我也知道如何處理HTTP / 1.1。

504
00:23:51,337 --> 00:23:53,170
我想給
你背一些內容。

505
00:23:53,170 --> 00:23:56,230
在這種情況下，它將會
為text / html類型的。

506
00:23:56,230 --> 00:23:58,480
因此，這只是一種方式
他們的communicating--

507
00:23:58,480 --> 00:24:00,480
>> MARIA ZLATKOVA：這只是
確認你

508
00:24:00,480 --> 00:24:03,290
兩個按照相同的
協議和兩個

509
00:24:03,290 --> 00:24:06,620
在客戶端和server--所以
您的瀏覽器和server--

510
00:24:06,620 --> 00:24:09,280
那種知道你在做什麼
談論，並有

511
00:24:09,280 --> 00:24:12,557
會議傳遞數據。

512
00:24:12,557 --> 00:24:17,022
>> 聽眾：所以內容類型part--
內容類型的文本/ html--那

513
00:24:17,022 --> 00:24:18,521
同一消息的一個單獨部分？

514
00:24:18,521 --> 00:24:20,509
或者是讓我們說，200的一部分嗎？

515
00:24:20,509 --> 00:24:22,010
200是否告訴他們或is--

516
00:24:22,010 --> 00:24:23,770
>> MARIA ZLATKOVA：200說明了一切去確定。

517
00:24:23,770 --> 00:24:27,900
然後，內容類型為形式的
同一消息的單獨部分，

518
00:24:27,900 --> 00:24:34,274
並說了一句讓我
返回的有這種類型text / html的。

519
00:24:34,274 --> 00:24:35,690
它只是提供更多的信息。

520
00:24:35,690 --> 00:24:38,700

521
00:24:38,700 --> 00:24:39,995
有什麼補充？

522
00:24:39,995 --> 00:24:40,495
好。

523
00:24:40,495 --> 00:24:43,590

524
00:24:43,590 --> 00:24:46,530
>> 在這個沒有其他問題？

525
00:24:46,530 --> 00:24:48,370
真棒。

526
00:24:48,370 --> 00:24:54,070
因此，一些其他HTTP狀態的
我們可以得到除了200 OK，

527
00:24:54,070 --> 00:24:59,500
那些我們所看到的可能
可能很多是403和404。

528
00:24:59,500 --> 00:25:05,190
所以404，如果你想
不存在訪問的東西。

529
00:25:05,190 --> 00:25:10,460
因此，例如，在你的
CS50財務pset時，

530
00:25:10,460 --> 00:25:15,640
如果你已經被渲染quote.html
而你沒有這個文件，

531
00:25:15,640 --> 00:25:19,740
而是你有quote.php，即
將導致404未找​​到

532
00:25:19,740 --> 00:25:21,600
因為該文件可能不存在。

533
00:25:21,600 --> 00:25:25,690
>> 對於一個403禁止的，這
指的權限。

534
00:25:25,690 --> 00:25:31,150
因此，如果某些文件不是由可讀
世界中，你可能會得到一個403返回。

535
00:25:31,150 --> 00:25:34,510

536
00:25:34,510 --> 00:25:37,810
有些人認為你可能
get-- 301，永久移動;

537
00:25:37,810 --> 00:25:41,300
302，找到; 304，修正;
400，錯​​誤的請求;

538
00:25:41,300 --> 00:25:47,330
和然後內部服務器錯誤
500和503，服務不可用。

539
00:25:47,330 --> 00:25:48,140
是。

540
00:25:48,140 --> 00:25:51,490
>> 聽眾：我們會預期
記住所有這些狀態？

541
00:25:51,490 --> 00:25:53,739
瑪麗亞ZLATKOVA：我會
他們在你的備忘單。

542
00:25:53,739 --> 00:25:55,146
[笑聲]

543
00:25:55,146 --> 00:25:59,954
聽眾：我們預計
知道什麼觸發每一個？

544
00:25:59,954 --> 00:26:00,995
MARIA ZLATKOVA：是嗎？

545
00:26:00,995 --> 00:26:03,870
漢娜布隆伯格：對於那些我們已經
運行into--這樣的問題was--

546
00:26:03,870 --> 00:26:08,010
MARIA ZLATKOVA：他們有望
知道這些情況了每個

547
00:26:08,010 --> 00:26:09,330
代碼可能會被觸發？

548
00:26:09,330 --> 00:26:13,240
因此，對於我們已經使用的那些
跑進，我會說，是的。

549
00:26:13,240 --> 00:26:16,610
因此，我們肯定看到200
確定在pset中演講了。

550
00:26:16,610 --> 00:26:19,071
我們已經看到了403，404。

551
00:26:19,071 --> 00:26:20,550
對於其他的呢？

552
00:26:20,550 --> 00:26:22,690
>> 漢娜布隆伯格：我
500說似乎是公平的遊戲。

553
00:26:22,690 --> 00:26:23,330
>> MARIA ZLATKOVA：500，是的。

554
00:26:23,330 --> 00:26:24,246
>> 漢娜布隆伯格：是的。

555
00:26:24,246 --> 00:26:27,006
只要有一個一般意義
是什麼使他們。

556
00:26:27,006 --> 00:26:28,880
而且也只有這些
名字，你可以種

557
00:26:28,880 --> 00:26:32,890
就像讓一個受過教育的猜測
什麼實際造成他們。

558
00:26:32,890 --> 00:26:36,919
例如，將永久，大概
該文件已被永久移動。

559
00:26:36,919 --> 00:26:39,328
>> 聽眾：但在以前的
考試中，有一個如此

560
00:26:39,328 --> 00:26:41,050
你怎麼指望我們回答這個問題？

561
00:26:41,050 --> 00:26:42,883
>> 漢娜布隆伯格：那
值得零分。

562
00:26:42,883 --> 00:26:45,870
在茶壺上418的問題
在技​​術上是一個HTTP狀態，

563
00:26:45,870 --> 00:26:47,090
但它是值得零分。

564
00:26:47,090 --> 00:26:48,320
很顯然，你不
預計認識他們。

565
00:26:48,320 --> 00:26:49,670
>> 聽眾：這是一個真實的？

566
00:26:49,670 --> 00:26:51,970
>> 漢娜布隆伯格：這是一個真正的
之一，但它並不意味著什麼。

567
00:26:51,970 --> 00:26:52,700
這只是一個玩笑。

568
00:26:52,700 --> 00:26:55,480

569
00:26:55,480 --> 00:26:57,010
互聯網讓人感到滑稽。

570
00:26:57,010 --> 00:26:59,680
>> MARIA ZLATKOVA：大問題，球員。

571
00:26:59,680 --> 00:27:01,452
其他問題嗎？

572
00:27:01,452 --> 00:27:04,891
>> 聽眾：什麼是內部服務器錯誤？

573
00:27:04,891 --> 00:27:06,640
MARIA ZLATKOVA：內部
服務器錯誤只

574
00:27:06,640 --> 00:27:10,050
意味著你已經
無法溝通

575
00:27:10,050 --> 00:27:13,400
與服務器的某些原因。

576
00:27:13,400 --> 00:27:15,400
因此，它不一定
一些已經做的

577
00:27:15,400 --> 00:27:19,170
與客戶端或類似的東西。

578
00:27:19,170 --> 00:27:22,170
我不知道任何特定的實施例的
我們已經討論了解釋，

579
00:27:22,170 --> 00:27:23,000
但是，是的。

580
00:27:23,000 --> 00:27:23,250
>> 漢娜布隆伯格：當然。

581
00:27:23,250 --> 00:27:25,625
因此，例如，像我們
說你正在處理混搭

582
00:27:25,625 --> 00:27:30,440
而谷歌的服務器停機一段
因此，停電，讓我們說。

583
00:27:30,440 --> 00:27:33,400
這將是一個內部服務器
錯誤或某種of--喜歡你

584
00:27:33,400 --> 00:27:34,630
不會得到響應。

585
00:27:34,630 --> 00:27:35,260
>> MARIA ZLATKOVA：是的。

586
00:27:35,260 --> 00:27:37,050
這只是當你
無法溝通

587
00:27:37,050 --> 00:27:40,299
與服務器出於某種原因，因為
它的下降或其他一些原因。

588
00:27:40,299 --> 00:27:44,430

589
00:27:44,430 --> 00:27:47,690
所以跳進PHP。

590
00:27:47,690 --> 00:27:49,930
PHP，不像HTML，是一個
編程語言。

591
00:27:49,930 --> 00:27:54,820
我們開始使用它，因為它是
非常有用的Web開發。

592
00:27:54,820 --> 00:27:56,940
>> 我們首先用它在CS50融資。

593
00:27:56,940 --> 00:28:02,240
它基本上可以幫助我們把
同時該標記，設計，

594
00:28:02,240 --> 00:28:07,460
以及我們如何實際使用信息
要在網頁上顯示的東西。

595
00:28:07,460 --> 00:28:11,870
所以PHP本身就意味著PHP
超文本預處理器，

596
00:28:11,870 --> 00:28:15,360
所以這是一個遞歸backnorym本身。

597
00:28:15,360 --> 00:28:22,330
開放標籤PHP，我們左
並用問號右箭頭

598
00:28:22,330 --> 00:28:23,060
和PHP。

599
00:28:23,060 --> 00:28:25,890
>> 因此，我們已經看到了一堆了。

600
00:28:25,890 --> 00:28:29,150
現在，我們只是走了過來
一些關於它的基本的東西。

601
00:28:29,150 --> 00:28:32,280
綜上所述，使用PHP，變量
名稱以美元符號。

602
00:28:32,280 --> 00:28:35,660
我們沒有指定，再次，
變量類型了。

603
00:28:35,660 --> 00:28:38,450
就像我們用C做了，
我們不需要這麼做。

604
00:28:38,450 --> 00:28:41,670

605
00:28:41,670 --> 00:28:44,490
>> 我們可以做很多不同的
東西與變量。

606
00:28:44,490 --> 00:28:47,750
我們可以把它們放在一起
通過將它們

607
00:28:47,750 --> 00:28:52,900
用點符號，這
我們不能用C做了。

608
00:28:52,900 --> 00:28:57,490
再次，我們有更多的靈活性
同的變量方面的PHP。

609
00:28:57,490 --> 00:29:00,080
再次，我們沒有一個主要功能。

610
00:29:00,080 --> 00:29:03,370
>> 而PHP解釋
相對於編譯

611
00:29:03,370 --> 00:29:09,970
因此，只要我們如何做沒有為C文件，
我們沒有這樣做，為PHP。

612
00:29:09,970 --> 00:29:15,440
而是，該方法的語言
由本身運行，則將其解釋。

613
00:29:15,440 --> 00:29:18,550
然後鬆散類型
只是意味著我們

614
00:29:18,550 --> 00:29:22,490
不必指定一個可變
類型和變量類型

615
00:29:22,490 --> 00:29:25,415
理解在運行時。

616
00:29:25,415 --> 00:29:29,185
>> 聽眾：但你是怎麼
由點串聯的意思嗎？

617
00:29:29,185 --> 00:29:30,060
MARIA ZLATKOVA：當然。

618
00:29:30,060 --> 00:29:37,660
當我們想要把東西together--
所以，如果我們有一些變量

619
00:29:37,660 --> 00:29:41,500
具有3的值，我們有另一個
變量有字符串的值，

620
00:29:41,500 --> 00:29:45,920
我們可以把這些變量一起
通過把一個點在它們之間

621
00:29:45,920 --> 00:29:46,970
和連接它們。

622
00:29:46,970 --> 00:29:52,670
或者，我們可以創建一個
變量調用名

623
00:29:52,670 --> 00:29:56,900
並把它在一起
連接兩個字符串。

624
00:29:56,900 --> 00:30:00,680
>> 所以，如果我們有一個字符串用雙
報價和我們把一個點後，

625
00:30:00,680 --> 00:30:03,660
然後我們有另外的字符串，
將共創一個字符串。

626
00:30:03,660 --> 00:30:05,242
>> 聽眾：OK。

627
00:30:05,242 --> 00:30:06,450
MARIA拉脫維亞：是清楚了嗎？

628
00:30:06,450 --> 00:30:07,099
聽眾：是的。

629
00:30:07,099 --> 00:30:07,890
MARIA ZLATKOVA：OK。

630
00:30:07,890 --> 00:30:08,766
是。

631
00:30:08,766 --> 00:30:11,146
>> 聽眾：當你說
解釋而非編譯

632
00:30:11,146 --> 00:30:14,160
你在說什麼你不
需要是作為特定時

633
00:30:14,160 --> 00:30:15,906
它涉及到PHP對C？

634
00:30:15,906 --> 00:30:18,085

635
00:30:18,085 --> 00:30:20,710
MARIA ZLATKOVA：當我們說
解釋，而不是編譯

636
00:30:20,710 --> 00:30:21,850
是什麼呢？

637
00:30:21,850 --> 00:30:26,220
這樣就意味著我們並不需要
可執行文件運行PHP。

638
00:30:26,220 --> 00:30:29,870
這意味著它運行自有其道理。

639
00:30:29,870 --> 00:30:31,650
那有意義嗎？

640
00:30:31,650 --> 00:30:32,495
多一點。

641
00:30:32,495 --> 00:30:34,620
漢娜布隆伯格：所以你
能想到的解釋

642
00:30:34,620 --> 00:30:38,980
作為另一方案，是負責
通過PHP一行去一行

643
00:30:38,980 --> 00:30:42,745
而實際執行它，而不是
在編譯了這一切為二進制。

644
00:30:42,745 --> 00:30:46,050
實際上它並不意味著什麼
我們如何具體需。

645
00:30:46,050 --> 00:30:49,470
我們仍然需要精確，並且不
忘記了分號，並確保

646
00:30:49,470 --> 00:30:51,470
你有你的美元符號，
之類的東西。

647
00:30:51,470 --> 00:30:52,240
好問題。

648
00:30:52,240 --> 00:30:53,115
>> MARIA ZLATKOVA：是的。

649
00:30:53,115 --> 00:30:55,590
因此，一行行，因為
反對與C文件，

650
00:30:55,590 --> 00:30:59,100
我們必須讓整個決賽
之前，我們實際上可以運行它。

651
00:30:59,100 --> 00:31:00,360
這是主要的區別。

652
00:31:00,360 --> 00:31:02,655
但同樣，我們不能
真的那麼具體。

653
00:31:02,655 --> 00:31:08,760

654
00:31:08,760 --> 00:31:13,950
因此，在PHP數組代表
實際上是一個有序圖。

655
00:31:13,950 --> 00:31:17,550
>> 所以數組準值的鍵。

656
00:31:17,550 --> 00:31:23,350
這兩種方式申報
陣列，基於該語法，

657
00:31:23,350 --> 00:31:26,380
我們可以更加明確
在說我們有一個數組

658
00:31:26,380 --> 00:31:31,010
我們有這個鍵1映射到
這個值1，密鑰2映射值2。

659
00:31:31,010 --> 00:31:34,660
或者我們可以創建一個數組
包含該值本身

660
00:31:34,660 --> 00:31:38,360
然後鍵是
理解的方式。

661
00:31:38,360 --> 00:31:40,000
在這個有問題嗎？

662
00:31:40,000 --> 00:31:42,500
>> 聽眾：會是什麼鍵
在第二個例子嗎？

663
00:31:42,500 --> 00:31:47,100

664
00:31:47,100 --> 00:31:47,920
0，1，2，3→

665
00:31:47,920 --> 00:31:50,650

666
00:31:50,650 --> 00:31:55,780
>> MARIA ZLATKOVA：例如，它只是
在此按鍵不一定

667
00:31:55,780 --> 00:31:56,550
做出改變。

668
00:31:56,550 --> 00:32:01,720
他們只是定義你怎麼能
用它裡面的值。

669
00:32:01,720 --> 00:32:08,660
所以，如果我們有一個foreach
循環在PHP中會

670
00:32:08,660 --> 00:32:14,760
讓我們走過所有的值，
我們可以通過所有的值，

671
00:32:14,760 --> 00:32:19,570
即使我們有或沒有定義
內的網站的特定鍵

672
00:32:19,570 --> 00:32:20,820
以前的語法。

673
00:32:20,820 --> 00:32:23,460
>> 因此，即使這種
陣中，我們仍然可以

674
00:32:23,460 --> 00:32:26,260
有一個foreach循環
是經過各

675
00:32:26,260 --> 00:32:31,240
在陣列中的關鍵值。

676
00:32:31,240 --> 00:32:36,180
所以在foreach的語法
循環中，我們先從一個數組。

677
00:32:36,180 --> 00:32:38,720

678
00:32:38,720 --> 00:32:43,900
這$ ARR變量是我們實際的數組
我們在上一張幻燈片定義

679
00:32:43,900 --> 00:32:47,550
作為值，從字面上去
通過每個值，

680
00:32:47,550 --> 00:32:50,122
不管是否
我們有一個鍵或不。

681
00:32:50,122 --> 00:32:53,080
然後我們可以做一些與
foreach循環內的值。

682
00:32:53,080 --> 00:32:57,730
如此反复，如果我們有一個數組
像這樣在這裡created--

683
00:32:57,730 --> 00:33:03,270
所以我們有foo和價值的關鍵
酒吧，巴茲的關鍵和qux--的價值

684
00:33:03,270 --> 00:33:09,730
我們可以有一個foreach循環
經過數組作為鍵值

685
00:33:09,730 --> 00:33:11,900
然後做一些事情
用鍵和/或值。

686
00:33:11,900 --> 00:33:15,980
但是，我們不一定總是
必須有一個foreach循環，

687
00:33:15,980 --> 00:33:19,410
經過數組作為鍵映射到值。

688
00:33:19,410 --> 00:33:26,060
我們可以通過
foreach循環數組值。

689
00:33:26,060 --> 00:33:28,990
>> 漢娜布隆伯格：我認為，
用於：是你的問題，是什麼

690
00:33:28,990 --> 00:33:31,229
是隱式索引？

691
00:33:31,229 --> 00:33:31,895
聽眾：均田。

692
00:33:31,895 --> 00:33:32,240
MARIA ZLATKOVA：哦。

693
00:33:32,240 --> 00:33:33,406
漢娜布隆伯格：是啊，是啊。

694
00:33:33,406 --> 00:33:36,150
所以基本上，如果你不指定
一個關鍵，這將是01。

695
00:33:36,150 --> 00:33:37,140
>> MARIA ZLATKOVA：是的。

696
00:33:37,140 --> 00:33:41,718
就像使用C，它是零
索引如果不指定密鑰。

697
00:33:41,718 --> 00:33:42,384
聽眾：對不起。

698
00:33:42,384 --> 00:33:43,827
你可以嘗試講
一點點響亮？

699
00:33:43,827 --> 00:33:45,270
我有一點點
麻煩聽到的一切。

700
00:33:45,270 --> 00:33:46,478
>> 瑪麗亞ZLATKOVA：我很抱歉。

701
00:33:46,478 --> 00:33:48,439
嗯，當然咯。

702
00:33:48,439 --> 00:33:50,230
所以，你要我
到過這一次？

703
00:33:50,230 --> 00:33:51,680
或者是this--

704
00:33:51,680 --> 00:33:54,930
聽眾：所以在以往的slide--如果
你可以只回去一秒鐘。

705
00:33:54,930 --> 00:33:57,313
MARIA ZLATKOVA：當然了，對不起。

706
00:33:57,313 --> 00:33:59,237
聽眾：所以第二
陣列這裡不

707
00:33:59,237 --> 00:34:04,135
似乎有一個值加鍵，
有點 [？因果關係。 ？]

708
00:34:04,135 --> 00:34:05,343
MARIA ZLATKOVA：對，對。

709
00:34:05,343 --> 00:34:07,608
聽眾：所以這是如何工作的
當你說這是全或無。

710
00:34:07,608 --> 00:34:08,969
對我來說，看起來像
一個 [？富？]了。

711
00:34:08,969 --> 00:34:10,093
>> MARIA ZLATKOVA：是啊，是啊。

712
00:34:10,093 --> 00:34:12,969
如此反复，這是一
在這個意義上有序圖

713
00:34:12,969 --> 00:34:15,639
有被理解，
例如，索引

714
00:34:15,639 --> 00:34:20,159
這裡可以理解為0，1，2，3。

715
00:34:20,159 --> 00:34:25,929
再次，這是有那些
索引是我們相當於

716
00:34:25,929 --> 00:34:28,980
具有映射到值的鍵。

717
00:34:28,980 --> 00:34:34,710
所以，如果我們的關鍵是0--遺憾。

718
00:34:34,710 --> 00:34:36,524
>> 漢娜布隆伯格：沒有，
還有的粉筆在這裡。

719
00:34:36,524 --> 00:34:36,929
它實際上是非常好的。

720
00:34:36,929 --> 00:34:37,460
>> 瑪麗亞ZLATKOVA：那太好了。

721
00:34:37,460 --> 00:34:38,260
好。

722
00:34:38,260 --> 00:34:49,489
如此反复，$ ARR 0會
鍵為值1。

723
00:34:49,489 --> 00:34:51,138
0將是關鍵的值1。

724
00:34:51,138 --> 00:34:51,971
聽眾：我很抱歉。

725
00:34:51,971 --> 00:34:53,190
它是無形的。

726
00:34:53,190 --> 00:34:53,659
>> 漢娜布隆伯格：好吧，沒關係。

727
00:34:53,659 --> 00:34:54,980
粉筆是個壞主意。

728
00:34:54,980 --> 00:34:58,030
我把它送回去。

729
00:34:58,030 --> 00:35:01,425
你可以把鑰匙
作為0映射到值1。

730
00:35:01,425 --> 00:35:02,300
MARIA ZLATKOVA：是的。

731
00:35:02,300 --> 00:35:04,630
因此，這是0，這是1，2，3。

732
00:35:04,630 --> 00:35:05,760
這些可能是你的鑰匙。

733
00:35:05,760 --> 00:35:10,020
你可以把它們as--呀。

734
00:35:10,020 --> 00:35:12,740
因此，而不是有
明確的按鍵，它們是

735
00:35:12,740 --> 00:35:17,180
那種理解為
該指數從0開始。

736
00:35:17,180 --> 00:35:21,630

737
00:35:21,630 --> 00:35:24,820
粉筆沒有幫助。

738
00:35:24,820 --> 00:35:25,722
是啊。

739
00:35:25,722 --> 00:35:30,914
>> 顧客：foreach循環，
如果我們想查看的值，

740
00:35:30,914 --> 00:35:33,245
它只是自動索引為0？

741
00:35:33,245 --> 00:35:34,120
MARIA ZLATKOVA：是的。

742
00:35:34,120 --> 00:35:35,745
這將通過每個值。

743
00:35:35,745 --> 00:35:39,130
聽眾：[聽不清]作為
0或將只是做0？

744
00:35:39,130 --> 00:35:43,710
>> MARIA ZLATKOVA：你必須
也就是說，作為美元符號，然後

745
00:35:43,710 --> 00:35:46,266
一些變量名，值。

746
00:35:46,266 --> 00:35:47,182
聽眾：[聽不清]。

747
00:35:47,182 --> 00:35:50,048

748
00:35:50,048 --> 00:35:50,964
MARIA ZLATKOVA：對不起？

749
00:35:50,964 --> 00:35:52,839
聽眾：對不起，我
只是想記住。

750
00:35:52,839 --> 00:35:57,190
你會怎麼做，如果你能做到這一點
自動索引僅僅是0？

751
00:35:57,190 --> 00:36:00,780
>> MARIA ZLATKOVA：那麼你會怎麼做
如果你沒有具體的鍵名稱？

752
00:36:00,780 --> 00:36:01,710
>> 聽眾：是的。

753
00:36:01,710 --> 00:36:07,820
>> MARIA ZLATKOVA：你只想define--
只是說自己的一些名字。

754
00:36:07,820 --> 00:36:17,950
因此，在您的pset，你們可能
記住的foreach $行作為$行，

755
00:36:17,950 --> 00:36:24,610
我們創造了我們自己這個$行說
我們想通過排為$行。

756
00:36:24,610 --> 00:36:28,360
儘管我們沒有
行定義了這個明確的$，

757
00:36:28,360 --> 00:36:31,990
我們可以隨便去
說這可能是我們的重點，

758
00:36:31,990 --> 00:36:33,615
而剛剛經過的每個值。

759
00:36:33,615 --> 00:36:37,295

760
00:36:37,295 --> 00:36:41,660
>> 聽眾：那就是價值的新變量
我們要創建存儲[聽不清]？

761
00:36:41,660 --> 00:36:46,820

762
00:36:46,820 --> 00:36:49,990
>> MARIA ZLATKOVA：所以這不是
本質上是一種新的變量。

763
00:36:49,990 --> 00:37:00,310
它是指一個變量
內的陣列他們每個人的。

764
00:37:00,310 --> 00:37:02,060
漢娜布隆伯格：這是
一個新的變量名。

765
00:37:02,060 --> 00:37:04,018
MARIA ZLATKOVA：是啊，
這是一個新的變量名，

766
00:37:04,018 --> 00:37:06,680
但它不是inherently--呀。

767
00:37:06,680 --> 00:37:08,950
這只是一個新的變量
你可以做到這一點。

768
00:37:08,950 --> 00:37:12,680
因此，只要我們怎麼做
$行作為$行，行

769
00:37:12,680 --> 00:37:17,980
是一個新的變量名，我們
可以創建在我們的foreach循環。

770
00:37:17,980 --> 00:37:22,065
它不具有在此之前，對預先存在。

771
00:37:22,065 --> 00:37:25,777
>> 聽眾：你可以去通過
邏輯為每個使用的例子嗎？

772
00:37:25,777 --> 00:37:26,610
MARIA ZLATKOVA：MHM。

773
00:37:26,610 --> 00:37:31,240

774
00:37:31,240 --> 00:37:32,080
噢對不起。

775
00:37:32,080 --> 00:37:33,780
這裡的例子。

776
00:37:33,780 --> 00:37:34,280
當然。

777
00:37:34,280 --> 00:37:38,950
因此，對於每個array--所以
這意味著去這個陣列

778
00:37:38,950 --> 00:37:43,930
關鍵value--這回事
要通過這個數組

779
00:37:43,930 --> 00:37:49,480
和第一去弄foo，那麼
關鍵foo和價值吧。

780
00:37:49,480 --> 00:37:51,570
然後在第二
for循環迭代，

781
00:37:51,570 --> 00:37:55,090
它會通過，並採取
關鍵巴茲和值qux。

782
00:37:55,090 --> 00:38:00,512
然後你就可以做一些事情
其中任何一個或兩個人。

783
00:38:00,512 --> 00:38:03,488
>> 聽眾：所以背後的想法
有一個關鍵點的值，

784
00:38:03,488 --> 00:38:07,470
你到底是什麼了訪問？

785
00:38:07,470 --> 00:38:10,680
>> MARIA ZLATKOVA：是什麼概念
具有一鍵指向價值？

786
00:38:10,680 --> 00:38:16,400
這只是一個慣例，另一
歷盡數組方式

787
00:38:16,400 --> 00:38:22,600
並能夠訪問無論是
鍵或值或兩者並用它們。

788
00:38:22,600 --> 00:38:27,100
>> 聽眾：什麼是對的作用
下令在foreach中運行？

789
00:38:27,100 --> 00:38:29,250
所以，如果我們要添加
元件以陣列以後，

790
00:38:29,250 --> 00:38:32,140
將這些是第一個
所謂在foreach陣列中，

791
00:38:32,140 --> 00:38:33,750
或者會是以後？

792
00:38:33,750 --> 00:38:37,770
>> MARIA ZLATKOVA：那麼，什麼是
的順序在foreach

793
00:38:37,770 --> 00:38:39,210
循環遍歷數組中的？

794
00:38:39,210 --> 00:38:42,220
它經過所述第一
元件到最後一個元素，

795
00:38:42,220 --> 00:38:43,400
到最後添加的元素。

796
00:38:43,400 --> 00:38:48,020
如果您在以後添加元素，它們將
被accessed--的第一要素會

797
00:38:48,020 --> 00:38:51,410
進行訪問，所述第一
的數組的元素，

798
00:38:51,410 --> 00:38:57,620
然後你會去通過每個
元素作為排序的ordered--的

799
00:38:57,620 --> 00:39:02,930
不是一個有序，但方式
他們已經放入數組。

800
00:39:02,930 --> 00:39:06,855
>> 聽眾：那麼新元素
加入以後？

801
00:39:06,855 --> 00:39:10,680
所以他們added--他們將在
最後的在[？迭代。 ？]

802
00:39:10,680 --> 00:39:14,280
>> MARIA ZLATKOVA：新元素can--
基本上，當添加新的元素，

803
00:39:14,280 --> 00:39:16,520
它們是添加到數組的結尾？

804
00:39:16,520 --> 00:39:17,632
>> 聽眾：是的。

805
00:39:17,632 --> 00:39:18,840
瑪麗亞ZLATKOVA：我想是的。

806
00:39:18,840 --> 00:39:20,850
是。

807
00:39:20,850 --> 00:39:24,330
然後用你的foreach循環，
你已經添加了新元素後，

808
00:39:24,330 --> 00:39:26,790
你去通過他們，
新元素會

809
00:39:26,790 --> 00:39:30,930
是accessed--新元素，如果它的
最後加入，這將是最後一次訪問。

810
00:39:30,930 --> 00:39:34,416
>> 聽眾：你能不能舉個例子
的東西會[聽不清]

811
00:39:34,416 --> 00:39:37,404
有一些與價值
像[聽不清]或價值，

812
00:39:37,404 --> 00:39:38,910
喜歡你如何格式化？

813
00:39:38,910 --> 00:39:39,785
>> MARIA ZLATKOVA：當然。

814
00:39:39,785 --> 00:39:42,340

815
00:39:42,340 --> 00:39:46,410
我可以舉的一個例子是什麼
我們將與價值呢？

816
00:39:46,410 --> 00:39:52,440
那麼你們可能熟悉
是我們通過一個數組已經走了

817
00:39:52,440 --> 00:39:55,380
基本上印刷
每個元件，

818
00:39:55,380 --> 00:40:00,910
例如，作為一個部分
有序列表或東西。

819
00:40:00,910 --> 00:40:02,674
這是否有意義呢還是想用於：

820
00:40:02,674 --> 00:40:04,340
聽眾：我們可以打印這些值嗎？

821
00:40:04,340 --> 00:40:13,220
MARIA ZLATKOVA：是的，我們可以打印
然後基本上$值，因為在

822
00:40:13,220 --> 00:40:16,570
特定的價值，我們將
打印它裡面的價值。

823
00:40:16,570 --> 00:40:20,150
因此，如果我們在我們的第一次迭代
它和我們的印刷$值，

824
00:40:20,150 --> 00:40:23,775
我們將打印條碼。

825
00:40:23,775 --> 00:40:27,020
>> 聽眾：是否也有對
循環在PHP或只是foreach循環？

826
00:40:27,020 --> 00:40:30,430
>> MARIA ZLATKOVA：有
還對在PHP環路。

827
00:40:30,430 --> 00:40:33,399
而他們的邏輯是主要的
一樣你一直在使用。

828
00:40:33,399 --> 00:40:34,690
聽眾：所以它的值是零。

829
00:40:34,690 --> 00:40:35,090
MARIA ZLATKOVA：這就像一樣。

830
00:40:35,090 --> 00:40:35,590
是啊。

831
00:40:35,590 --> 00:40:37,747
聽眾：我只是要問。

832
00:40:37,747 --> 00:40:39,695
所以當你宣布一個
數組，你不需要

833
00:40:39,695 --> 00:40:42,617
告訴它要什麼尺寸
是的，這意味著你可以

834
00:40:42,617 --> 00:40:44,417
添加並帶走元素[聽不清]。

835
00:40:44,417 --> 00:40:45,250
MARIA ZLATKOVA：是的。

836
00:40:45,250 --> 00:40:45,750
對。

837
00:40:45,750 --> 00:40:46,251
究竟。

838
00:40:46,251 --> 00:40:48,875
當我們聲明一個數組，我們
不用說，這是什麼規格，

839
00:40:48,875 --> 00:40:51,022
因此，我們可以只添加元素
到後來為好。

840
00:40:51,022 --> 00:40:55,075

841
00:40:55,075 --> 00:40:55,700
更多問題？

842
00:40:55,700 --> 00:40:59,870

843
00:40:59,870 --> 00:41:05,950
所以把PHP和HTML在一起，
我們已經seen--好，

844
00:41:05,950 --> 00:41:15,130
例如，在這個例子中，我們有
具有輸入字段的HTML表格。

845
00:41:15,130 --> 00:41:18,830
>> 輸入框的只是名
然後它有一個提交按鈕。

846
00:41:18,830 --> 00:41:26,040
而當你按下提交
按鈕，在我們的hello.php文件，

847
00:41:26,040 --> 00:41:32,130
因為該方法的形式是
得到的，我們可以訪問無論是在名稱

848
00:41:32,130 --> 00:41:40,360
此得到全局變量，
is--的語法是$ _GET。

849
00:41:40,360 --> 00:41:44,520
然後我們就可以訪問任何的
這種形式的名稱內用戶輸入

850
00:41:44,520 --> 00:41:47,410
通過指定字段的名稱。

851
00:41:47,410 --> 00:41:51,480

852
00:41:51,480 --> 00:41:55,060
>> 任何其他問題或任何
在這個具體的例子嗎？

853
00:41:55,060 --> 00:41:58,275
>> 聽眾：如果是PHP？

854
00:41:58,275 --> 00:41:59,150
MARIA ZLATKOVA：在這裡。

855
00:41:59,150 --> 00:42:01,150
因此，這是我們的PHP開始標記。

856
00:42:01,150 --> 00:42:01,530
>> 聽眾：哦，對了。

857
00:42:01,530 --> 00:42:02,363
>> MARIA ZLATKOVA：是的。

858
00:42:02,363 --> 00:42:05,320

859
00:42:05,320 --> 00:42:09,609
>> 漢娜布隆伯格是否：=的簡寫
因為這是PHP和公正的迴聲。

860
00:42:09,609 --> 00:42:10,150
聽眾：哦。

861
00:42:10,150 --> 00:42:10,720
MARIA ZLATKOVA：是的，對不起。

862
00:42:10,720 --> 00:42:12,040
我應該說的很清楚。

863
00:42:12,040 --> 00:42:13,759
>> 漢娜布隆伯格：打印。

864
00:42:13,759 --> 00:42:16,800
MARIA ZLATKOVA：這只是功能
這使我們能夠打印的東西。

865
00:42:16,800 --> 00:42:19,795

866
00:42:19,795 --> 00:42:20,420
大的問題。

867
00:42:20,420 --> 00:42:24,140

868
00:42:24,140 --> 00:42:25,495
所以going--是的。

869
00:42:25,495 --> 00:42:31,940
>> 聽眾：有沒有將是相當
一點PHP和HTML的手工編碼

870
00:42:31,940 --> 00:42:33,450
在測驗1？

871
00:42:33,450 --> 00:42:36,310

872
00:42:36,310 --> 00:42:38,810
MARIA ZLATKOVA：可以有
解釋相當數量的

873
00:42:38,810 --> 00:42:43,330
php和html，不一定
像一個巨大的量的編碼，

874
00:42:43,330 --> 00:42:46,960
儘管你可能需要寫一個
foreach循環，但是，一個for循環。

875
00:42:46,960 --> 00:42:49,790
任何環的，我們
涵蓋這裡是公平的遊戲。

876
00:42:49,790 --> 00:42:51,889
而這主要是它。

877
00:42:51,889 --> 00:42:53,430
漢娜布隆伯格：我將準備。

878
00:42:53,430 --> 00:42:57,010
以同樣的方式，我們請你來
寫一堆的C函數的測驗0，

879
00:42:57,010 --> 00:42:59,766
我是準備做
同樣在PHP和JavaScript。

880
00:42:59,766 --> 00:43:00,640
MARIA ZLATKOVA：是的。

881
00:43:00,640 --> 00:43:03,210
漢娜布隆伯格：我會說
一個li​​ttle--像我們不是

882
00:43:03,210 --> 00:43:06,251
將讓你寫一個巨大的HTML
頁面只是因為這是一點點

883
00:43:06,251 --> 00:43:08,240
乏味，但你可能有部分。

884
00:43:08,240 --> 00:43:09,310
這是完全公平的遊戲。

885
00:43:09,310 --> 00:43:11,082
喜歡小HTML頁面，完全公平的。

886
00:43:11,082 --> 00:43:11,623
聽眾：OK。

887
00:43:11,623 --> 00:43:13,814
如何在JavaScript中呢？

888
00:43:13,814 --> 00:43:14,730
漢娜布隆伯格：是的。

889
00:43:14,730 --> 00:43:15,250
JavaScript的公平的遊戲。

890
00:43:15,250 --> 00:43:15,635
>> MARIA ZLATKOVA：是的。

891
00:43:15,635 --> 00:43:16,801
這是完全公平的遊戲。

892
00:43:16,801 --> 00:43:19,280
漢娜布隆伯格：我們會得到
於在像10分鐘。

893
00:43:19,280 --> 00:43:23,750
>> 瑪利亞ZLATKOVA：SQL中，再次，
結構化查詢語言。

894
00:43:23,750 --> 00:43:28,651
基本上，它使我們能夠管理數據
在關係數據庫管理

895
00:43:28,651 --> 00:43:29,150
系統。

896
00:43:29,150 --> 00:43:31,149
這只是基本上意味著
我們有地方

897
00:43:31,149 --> 00:43:37,980
存儲一些數據，我們可能要
在網站或以某種其他形式使用。

898
00:43:37,980 --> 00:43:42,190
然後，我們必須查詢來獲得
從我們的數據庫中的信息，

899
00:43:42,190 --> 00:43:44,320
或插入的信息在其中。

900
00:43:44,320 --> 00:43:47,560
很多常見的ones--的更新，
INSERT，SELECT和DELETE。

901
00:43:47,560 --> 00:43:50,790
>> 因此，對於更新，這是語法
用於在數據庫中更新數據。

902
00:43:50,790 --> 00:43:53,330

903
00:43:53,330 --> 00:43:57,340
更新這個表稱為
表說SET，

904
00:43:57,340 --> 00:44:04,170
我們可以設置在所有的一些值
行等於別的東西。

905
00:44:04,170 --> 00:44:09,410
因此，我們也可以指定一些特定的
我們要修改的條目

906
00:44:09,410 --> 00:44:11,240
並且，可以是用在哪裡。

907
00:44:11,240 --> 00:44:16,380
我們可以指定我們只希望
修改某些行所在的房子，

908
00:44:16,380 --> 00:44:19,830
如果我們有學生的表
和所有的學生們的房子，

909
00:44:19,830 --> 00:44:24,890
所以我們只能修改一些值
那裡的房子等於宿舍樓裡，

910
00:44:24,890 --> 00:44:25,430
例如。

911
00:44:25,430 --> 00:44:29,120

912
00:44:29,120 --> 00:44:31,800
>> 對於INSERT，我們可以插入
某些值到表中。

913
00:44:31,800 --> 00:44:35,150
所以INSERT INTO表，
然後這些值，

914
00:44:35,150 --> 00:44:39,080
然後在括號中，我們指定
其值要插入。

915
00:44:39,080 --> 00:44:43,220
所以INSERT INTO表，col1和
COL2，值都是val1和val2。

916
00:44:43,220 --> 00:44:48,930
所以這基本上插入一個新行
包含值1和2的表

917
00:44:48,930 --> 00:44:50,850
下的列1和2。

918
00:44:50,850 --> 00:44:54,760
>> 然後我們要去投奔
如何這看起來簡單的例子

919
00:44:54,760 --> 00:44:56,310
就像在我們的數據庫中一點點。

920
00:44:56,310 --> 00:44:58,685
但是，這最後的查詢，我
認為我們走了過來，

921
00:44:58,685 --> 00:45:01,450
SELECT，它只是讓我們
從表中選擇數據

922
00:45:01,450 --> 00:45:03,080
以可能使用它之後。

923
00:45:03,080 --> 00:45:05,830
我們這樣做的方式是我們
只需將它保存在某個變量。

924
00:45:05,830 --> 00:45:07,780
然後我們可能可以再次使用。

925
00:45:07,780 --> 00:45:10,260
>> 所以選擇星級意味著選擇所有。

926
00:45:10,260 --> 00:45:13,280
這只是一個速記
選擇所有。

927
00:45:13,280 --> 00:45:19,760
FROM表WHERE，我們正在尋找
對於某些特定的條件下，

928
00:45:19,760 --> 00:45:22,290
所以在這裡列等於
東西，例如。

929
00:45:22,290 --> 00:45:24,410
如果我們只是想
從表中選擇所有，

930
00:45:24,410 --> 00:45:28,400
這只是選擇所有列
從表中的所有行。

931
00:45:28,400 --> 00:45:32,040
>> 然後DELETE FROM表
WHERE山坳等於什麼，

932
00:45:32,040 --> 00:45:36,440
這只是刪除了一些
從我們的表行

933
00:45:36,440 --> 00:45:38,860
其中我們有一些特定的條件。

934
00:45:38,860 --> 00:45:41,870
在這種情況下，條件
是列等於什麼。

935
00:45:41,870 --> 00:45:43,460
這所以只是一個簡單的例子。

936
00:45:43,460 --> 00:45:49,100
如果我們有這個表就在這裡和我們
將其插入到一個表，這些值，

937
00:45:49,100 --> 00:45:50,400
這將插入新行。

938
00:45:50,400 --> 00:45:56,380
如果我們有自動遞增，這將
只是增加我們的編號從0到1至2。

939
00:45:56,380 --> 00:46:00,010
>> 如果我們選擇的所有學生，它
剛剛返回的所有領域和所有行。

940
00:46:00,010 --> 00:46:02,430
凡年大
大於或等於2016年，

941
00:46:02,430 --> 00:46:04,390
這將只返回
漢娜和我自己。

942
00:46:04,390 --> 00:46:08,360
然後，如果我們僅僅選擇
今年ID和一年生

943
00:46:08,360 --> 00:46:11,710
那裡的房子是卡博特房子，那
會再次返回漢娜和我自己。

944
00:46:11,710 --> 00:46:14,430
>> 那麼，如果我們從學生中刪除
其中name等於搶，

945
00:46:14,430 --> 00:46:16,760
這將刪除整行。

946
00:46:16,760 --> 00:46:19,696
然後，如果我們設置
名，UPDATE學生

947
00:46:19,696 --> 00:46:21,570
SET名字等於Daven
WHERE房子等於

948
00:46:21,570 --> 00:46:27,010
卡博特之家，那將去
這些行，然後更新名稱。

949
00:46:27,010 --> 00:46:31,470
>> 然後幾個SQL數據類型
CHAR，VARCHAR，INT和浮動。

950
00:46:31,470 --> 00:46:32,760
這些都是公平的遊戲。

951
00:46:32,760 --> 00:46:36,740
我會去一遍又一遍
並確保你知道

952
00:46:36,740 --> 00:46:40,930
並讓它們在你的備忘單，
了每個這些字符的

953
00:46:40,930 --> 00:46:44,140
已被用於，什麼
你用他們在你的pset時，

954
00:46:44,140 --> 00:46:48,050
並確保你熟悉和
舒服不得不選擇

955
00:46:48,050 --> 00:46:51,450
從您的pset不同的數據類型。

956
00:46:51,450 --> 00:46:51,950
是。

957
00:46:51,950 --> 00:46:54,300
>> 聽眾：什麼是表存儲在哪裡？

958
00:46:54,300 --> 00:46:57,119
是啊，這哪裡是表的存儲？

959
00:46:57,119 --> 00:46:59,160
MARIA ZLATKOVA：嗯，
現在，它不保存。

960
00:46:59,160 --> 00:47:00,700
總之，哪裡該表存儲在哪裡？

961
00:47:00,700 --> 00:47:04,503
但它可以儲存在SQL數據庫中。

962
00:47:04,503 --> 00:47:07,330
>> 聽眾：哪裡是SQL數據庫？

963
00:47:07,330 --> 00:47:11,200
在計算機中，在線
某處，服務器？

964
00:47:11,200 --> 00:47:15,000
>> 瑪利亞ZLATKOVA：它可以是一個
不同的東西數目。

965
00:47:15,000 --> 00:47:19,690
>> 漢娜布隆伯格：我們已經接口與
SQL表大多與php​​MyAdmin的。

966
00:47:19,690 --> 00:47:22,060
因此，我們可以問一個服務器
來存儲它們為我們。

967
00:47:22,060 --> 00:47:23,830
我們可以將它們存儲自己的計算機上。

968
00:47:23,830 --> 00:47:27,950
>> MARIA ZLATKOVA：這只是取決於
你要如何為自己而做。

969
00:47:27,950 --> 00:47:30,075
但是，我們一直在存儲
他們，漢娜提到，

970
00:47:30,075 --> 00:47:31,755
在phpMyAdmin的，這是在網上。

971
00:47:31,755 --> 00:47:36,550

972
00:47:36,550 --> 00:47:39,280
然後我們一路使用
PHP和SQL，我們將其存儲

973
00:47:39,280 --> 00:47:43,450
為一些變量
我們已經查詢了。

974
00:47:43,450 --> 00:47:48,370
>> 因此，如果我們選擇所有的歷史
其中，USER_ID等於會話ID，

975
00:47:48,370 --> 00:47:53,900
這將選擇所有行
對於特定人誰

976
00:47:53,900 --> 00:47:58,327
從歷史中記錄
表和排序他們入行。

977
00:47:58,327 --> 00:48:00,410
一個很酷的事情知道的是，
這CS50的查詢功能

978
00:48:00,410 --> 00:48:02,180
防止SQL注入標籤。

979
00:48:02,180 --> 00:48:07,420
這只是意味著它可以確認
所輸入的輸入是正確的

980
00:48:07,420 --> 00:48:09,920
並確定該人誰
正進入輸入

981
00:48:09,920 --> 00:48:15,100
是不是要輸入一些惡意的
代碼要么砸我們的表

982
00:48:15,100 --> 00:48:17,305
或刪除一切
裡面我們的數據庫。

983
00:48:17,305 --> 00:48:20,060

984
00:48:20,060 --> 00:48:23,400
>> 的快速概覽
模型視圖控制器模式，

985
00:48:23,400 --> 00:48:27,360
這是組織的只是一種方式
和思考的代碼。

986
00:48:27,360 --> 00:48:29,100
這是又一個設計範例。

987
00:48:29,100 --> 00:48:33,380
這也就意味著，我們
can--，它是很好的做法

988
00:48:33,380 --> 00:48:37,790
分開不同的部分
我們的代碼和他們

989
00:48:37,790 --> 00:48:40,530
控制進入這三個範式。

990
00:48:40,530 --> 00:48:46,700
>> 因此，我們認為是最常見的我們
模板，我們的佈局，道路

991
00:48:46,700 --> 00:48:48,260
我們設置了如何我們的代碼看起來。

992
00:48:48,260 --> 00:48:55,190
這主要是我們的CSS文件和方式
我們定義的我們的代碼設計，

993
00:48:55,190 --> 00:48:55,710
基本上。

994
00:48:55,710 --> 00:48:59,280
我們的控制器主要是什麼
我們一直在做的PHP文件。

995
00:48:59,280 --> 00:49:03,030
如此反复，正與
我們有信息

996
00:49:03,030 --> 00:49:06,700
並確定怎麼說
信息被使用，

997
00:49:06,700 --> 00:49:10,660
然後傳遞一個信息
要么到視圖或模型。

998
00:49:10,660 --> 00:49:13,880
而模式，即我們已經一路
在使用IS一直是我們的數據庫，

999
00:49:13,880 --> 00:49:17,510
那麼，我們的信息是
存儲，以便它具有某處

1000
00:49:17,510 --> 00:49:21,490
住在和任何的
涉及到的方式代碼

1001
00:49:21,490 --> 00:49:25,410
我們得到的信息或
我們更新信息的方式。

1002
00:49:25,410 --> 00:49:28,940

1003
00:49:28,940 --> 00:49:33,200
>> 因此，在MVC模式，HTTP
請求被發送到網絡服務器。

1004
00:49:33,200 --> 00:49:36,220
然後，控制器解譯
來自用戶的請求

1005
00:49:36,220 --> 00:49:38,260
然後驗證用戶輸入。

1006
00:49:38,260 --> 00:49:41,580
它是可選的，我們有
該控制器通信

1007
00:49:41,580 --> 00:49:44,000
與模型，因此一些
像我們的數據庫

1008
00:49:44,000 --> 00:49:47,500
或某一其它功能性
該轉發信息。

1009
00:49:47,500 --> 00:49:50,340
然後最後，控制器
傳遞信息到視圖

1010
00:49:50,340 --> 00:49:52,090
因此，它可以是
呈現，並且它可以

1011
00:49:52,090 --> 00:49:55,860
成為可見的任何人
訪問網頁。

1012
00:49:55,860 --> 00:49:58,440

1013
00:49:58,440 --> 00:50:01,340
>> 任何問題？

1014
00:50:01,340 --> 00:50:01,840
真棒。

1015
00:50:01,840 --> 00:50:04,530

1016
00:50:04,530 --> 00:50:08,469
如此反复，模型，
其功能，又，

1017
00:50:08,469 --> 00:50:11,260
是信息的持久存儲，
管理和組織數據。

1018
00:50:11,260 --> 00:50:13,890
而我們所看到的
截至目前為止MySQL數據庫

1019
00:50:13,890 --> 00:50:16,200
和任何數據文件，可能會使用。

1020
00:50:16,200 --> 00:50:20,580
>> 查看，介紹信息
用戶時，UI，或用戶界面。

1021
00:50:20,580 --> 00:50:22,350
而這樣做的例子是HTML。

1022
00:50:22,350 --> 00:50:23,950
然後，我們可能有最小的PHP。

1023
00:50:23,950 --> 00:50:28,360
因此，一個for循環迭代
過的數據被打印出來

1024
00:50:28,360 --> 00:50:30,720
是視圖的一部分，作為
相對的控制器。

1025
00:50:30,720 --> 00:50:35,660
然後很多我們的PHP文件
落入控制器類別。

1026
00:50:35,660 --> 00:50:38,410
它只是處理用戶的請求和
獲取模型的信息。

1027
00:50:38,410 --> 00:50:42,880

1028
00:50:42,880 --> 00:50:45,590
>> 跳轉到文檔
對象模型，這只是

1029
00:50:45,590 --> 00:50:47,700
指的是方法的HTML
文件的組織方式。

1030
00:50:47,700 --> 00:50:51,600
而且他們組織成一棵樹
結構具有層次結構。

1031
00:50:51,600 --> 00:50:56,720
因此，如果我們有機會獲得[聽不清]
該文件的表示，

1032
00:50:56,720 --> 00:51:02,750
我們可以使用該文檔，就像
我們基本操作對象。

1033
00:51:02,750 --> 00:51:06,630
>> 而為了讓這一個
點點清晰，當

1034
00:51:06,630 --> 00:51:10,540
我們有很多的我們
不同的標記回應

1035
00:51:10,540 --> 00:51:12,590
在我們的樹不同的路線。

1036
00:51:12,590 --> 00:51:17,070
然後對於這個例子，我們
有開始文檔節點。

1037
00:51:17,070 --> 00:51:20,010
我們有，那麼，我們的HTML節點
即分成頭部和身體。

1038
00:51:20,010 --> 00:51:22,810
頭有標題，然後
標題包含你好，世界。

1039
00:51:22,810 --> 00:51:24,860
而我們的身體只包含
你好，世界也是如此。

1040
00:51:24,860 --> 00:51:28,700

1041
00:51:28,700 --> 00:51:31,900
>> 因此，在任何的任何問題
我們覆蓋到目前為止的事情呢？

1042
00:51:31,900 --> 00:51:35,891
如果沒有的話，漢娜
拿過來用JavaScript。

1043
00:51:35,891 --> 00:51:36,390
真棒。

1044
00:51:36,390 --> 00:51:37,473
>> 漢娜布隆伯格：好，冬暖夏涼。

1045
00:51:37,473 --> 00:51:40,980
如果有什麼想出了PHP或HTML，
或任何東西瑪麗亞覆蓋，

1046
00:51:40,980 --> 00:51:42,700
我們總是可以暫停。

1047
00:51:42,700 --> 00:51:46,430
我們正在做的更好的
一次又一次，這樣真棒。

1048
00:51:46,430 --> 00:51:48,770
而就回去
真的很快到這一點，

1049
00:51:48,770 --> 00:51:51,010
如果你每
過去一年的考試，這

1050
00:51:51,010 --> 00:51:54,120
出現either--這裡
一些HTML，讓這個圖。

1051
00:51:54,120 --> 00:51:58,380
還是這裡的這張圖，使一些
HTML，所以肯定練了。

1052
00:51:58,380 --> 00:52:01,500
然後這都保證
的問題，你可以得到正確的。

1053
00:52:01,500 --> 00:52:02,000
涼。

1054
00:52:02,000 --> 00:52:04,510
因此，讓我們來談談的JavaScript
以及它如何一點點

1055
00:52:04,510 --> 00:52:09,130
例如PHP和語言的不同
C，我們看到了事前的兩種語言。

1056
00:52:09,130 --> 00:52:10,780
因此，第一，它是鬆散類型。

1057
00:52:10,780 --> 00:52:14,630
即如PHP，但不像C.

1058
00:52:14,630 --> 00:52:15,890
>> 這是一種解釋型語言。

1059
00:52:15,890 --> 00:52:19,870
再次，像
PHP，不像C.這

1060
00:52:19,870 --> 00:52:24,630
將會讓我們use--它
作品真的很好地與網頁。

1061
00:52:24,630 --> 00:52:28,350
這將允許我們操作
的內容和它的外觀

1062
00:52:28,350 --> 00:52:30,300
和它做什麼。

1063
00:52:30,300 --> 00:52:32,330
>> 我們將看到阿賈克斯的一點點。

1064
00:52:32,330 --> 00:52:36,140
它使我們能夠溝通
異步不同的服務器

1065
00:52:36,140 --> 00:52:37,950
和獲取信息。

1066
00:52:37,950 --> 00:52:42,820
這是東西真的
從PHP和C分離的JavaScript

1067
00:52:42,820 --> 00:52:45,590
是，它是客戶端。

1068
00:52:45,590 --> 00:52:49,860
PHP和C是
典型的服務器端。

1069
00:52:49,860 --> 00:52:51,960
>> 在大多數情況下，並
幾乎完全是什麼

1070
00:52:51,960 --> 00:52:53,900
我們已經看到，至少在
這個類，JavaScript的

1071
00:52:53,900 --> 00:52:57,040
作用於客戶端，這意味著
該瀏覽器是實際上

1072
00:52:57,040 --> 00:52:58,597
負責運行它。

1073
00:52:58,597 --> 00:53:01,180
這意味著，我們不這樣做
需要與服務器進行交互。

1074
00:53:01,180 --> 00:53:04,380
因此，這意味著它可以是快了不少
因為它實際上只是它的瀏覽器，

1075
00:53:04,380 --> 00:53:10,420
這是Safari瀏覽器，它是火狐，不管你
用實際運行你的JavaScript。

1076
00:53:10,420 --> 00:53:12,290
>> 聽眾：什麼是異步是什麼意思？

1077
00:53:12,290 --> 00:53:13,620
>> 漢娜布隆伯格：啊，什麼
並異步是什麼意思？

1078
00:53:13,620 --> 00:53:14,250
大的問題。

1079
00:53:14,250 --> 00:53:17,890
異步是指：
同時，在內容中

1080
00:53:17,890 --> 00:53:22,140
我們使用它，OK，我們
正在創建一個網頁

1081
00:53:22,140 --> 00:53:23,860
我們需要得到一些信息。

1082
00:53:23,860 --> 00:53:28,250
因此，與混搭的例子中，
一些信息，我們可能要

1083
00:53:28,250 --> 00:53:30,580
就是文章標題。

1084
00:53:30,580 --> 00:53:33,330
現在，我們could--一個選項
是同步做

1085
00:53:33,330 --> 00:53:37,940
這意味著咱們
停下來，去獲得的文章，

1086
00:53:37,940 --> 00:53:41,275
得到的文章回來，然後
渲染，但是這將是很慢。

1087
00:53:41,275 --> 00:53:44,150
這將是一個不好的用戶體驗
因為你只是坐在

1088
00:53:44,150 --> 00:53:46,630
有在等待著什麼回應。

1089
00:53:46,630 --> 00:53:50,020
>> 異步意味著我們將
繼續將我們的業務，

1090
00:53:50,020 --> 00:53:52,529
渲染頁面，
我們會發送了一個請求

1091
00:53:52,529 --> 00:53:54,570
那種那將
發生在後台進行。

1092
00:53:54,570 --> 00:53:57,610
我認為，我們使用的例子
演講呼籲Rob和說的，

1093
00:53:57,610 --> 00:53:59,980
嘿，你可以看看這件事
我和打電話給我，

1094
00:53:59,980 --> 00:54:02,870
而不是只有我
等待的電話。

1095
00:54:02,870 --> 00:54:07,020
因此，異步意味著它發生
從我們的後台走

1096
00:54:07,020 --> 00:54:08,676
在平行下。

1097
00:54:08,676 --> 00:54:10,400
>> 大的問題。

1098
00:54:10,400 --> 00:54:11,830
還要別的嗎？

1099
00:54:11,830 --> 00:54:12,330
大。

1100
00:54:12,330 --> 00:54:15,020
我們會跳很多更進
異步請求使用Ajax。

1101
00:54:15,020 --> 00:54:18,287
>> 聽眾：請問JavaScript--哪裡呢
它與模型 - 視圖 - 控制器下跌呢？

1102
00:54:18,287 --> 00:54:19,620
漢娜布隆伯格：大的問題。

1103
00:54:19,620 --> 00:54:23,320
哪裡的JavaScript下降
與模型 - 視圖 - 控制器？

1104
00:54:23,320 --> 00:54:23,930
嗯。

1105
00:54:23,930 --> 00:54:28,350
我想這可以fall--
所以我們通常不

1106
00:54:28,350 --> 00:54:31,340
喜歡壓扁成的
範式，但我想我會說，

1107
00:54:31,340 --> 00:54:34,280
好了，JavaScript的
實際上會允許

1108
00:54:34,280 --> 00:54:37,587
我們收集的數據，
解釋數據，真正做到

1109
00:54:37,587 --> 00:54:38,920
與數據有意義的事情。

1110
00:54:38,920 --> 00:54:41,100
這樣一來，這是非常控制等。

1111
00:54:41,100 --> 00:54:43,900
>> 但它也將允許我們
顯示事物和打印的東西。

1112
00:54:43,900 --> 00:54:47,021
這樣一來，這是非常視圖等。

1113
00:54:47,021 --> 00:54:47,520
是啊。

1114
00:54:47,520 --> 00:54:51,710
因此，它有點像PHP中
在那裡可以一種是兩者。

1115
00:54:51,710 --> 00:54:53,330
好問題。

1116
00:54:53,330 --> 00:54:55,209
還要別的嗎？

1117
00:54:55,209 --> 00:54:56,000
好了，真棒。

1118
00:54:56,000 --> 00:54:57,120
運動沿著正確的。

1119
00:54:57,120 --> 00:54:59,110
>> 因此，讓我們來看一個例子
我們如何使用

1120
00:54:59,110 --> 00:55:02,250
JavaScript的在我們的Web程序之一。

1121
00:55:02,250 --> 00:55:05,680
所以，我會考慮這個
index.html的一堆的HTML。

1122
00:55:05,680 --> 00:55:08,800
而件事我想你
重點是這個腳本標記。

1123
00:55:08,800 --> 00:55:13,280
這說，OK，我要運行一些
JavaScript和這裡是它生活的地方。

1124
00:55:13,280 --> 00:55:15,400
它生活在hello.js。

1125
00:55:15,400 --> 00:55:21,120
>> 而且非常像CSS，我們可以
把JavaScript中的HTML中。

1126
00:55:21,120 --> 00:55:24,000
為什麼會我們想將它分離出來？

1127
00:55:24,000 --> 00:55:24,500
是啊。

1128
00:55:24,500 --> 00:55:25,486
>> 聽眾：更容易改寫？

1129
00:55:25,486 --> 00:55:26,402
>> 漢娜布隆伯格：是的。

1130
00:55:26,402 --> 00:55:28,450
它更容易使用的跨越
不同的網頁。

1131
00:55:28,450 --> 00:55:29,980
它使事情更清潔。

1132
00:55:29,980 --> 00:55:32,090
這是一個好的做法。

1133
00:55:32,090 --> 00:55:32,590
真棒。

1134
00:55:32,590 --> 00:55:33,930
好答案。

1135
00:55:33,930 --> 00:55:36,690
那麼好，所以這是怎麼回事
是我們的index.html。

1136
00:55:36,690 --> 00:55:39,430
再往下這裡是我們的
小小的JavaScript文件。

1137
00:55:39,430 --> 00:55:42,410
>> 和所有它說的是警覺的Hello，world。

1138
00:55:42,410 --> 00:55:46,040
所以會發生什麼是當
此頁面renders--

1139
00:55:46,040 --> 00:55:49,680
因此，如果你去到任何網站
這is--一切將要發生

1140
00:55:49,680 --> 00:55:53,330
是它會說，好吧，我
要運行這段JavaScript代碼。

1141
00:55:53,330 --> 00:55:56,370
而這段JavaScript代碼
只是說警惕的Hello，world。

1142
00:55:56,370 --> 00:55:59,090
所以，我要得到這
友好的小彈出。

1143
00:55:59,090 --> 00:56:00,360
>> 涼？

1144
00:56:00,360 --> 00:56:04,746
這有點像我們的第一個
JavaScript程序，我們的Hello，world。

1145
00:56:04,746 --> 00:56:07,690

1146
00:56:07,690 --> 00:56:12,190
讓我們看一點點什麼
JavaScript的語法如下所示。

1147
00:56:12,190 --> 00:56:16,330
而具體，讓我們把它比作
C和PHP，這是我們以前見過。

1148
00:56:16,330 --> 00:56:20,610
>> 在JavaScript中，我們將有
變種，該變​​量的名稱，然後

1149
00:56:20,610 --> 00:56:21,690
其實際值。

1150
00:56:21,690 --> 00:56:26,170
而且我們也沒有指定類型，只是
像PHP，但很不像​​C.

1151
00:56:26,170 --> 00:56:28,850
因此，例如，如果我們想
存儲值50，

1152
00:56:28,850 --> 00:56:32,490
在C中，我們不得不說，
哎，C​​，我想要一個整數，

1153
00:56:32,490 --> 00:56:35,076
我要叫它
i和其值是50。

1154
00:56:35,076 --> 00:56:36,450
在PHP中，這是一個稍微容易一些。

1155
00:56:36,450 --> 00:56:41,880
我們說，嘿，我想一個變量
稱為i和它的值是50。

1156
00:56:41,880 --> 00:56:45,890
非常相似，在JavaScript中，我們
說嘿，我要一個變量叫我，

1157
00:56:45,890 --> 00:56:47,080
它的值是50。

1158
00:56:47,080 --> 00:56:52,140
以後每一次我用
我，我不需要寫變種。

1159
00:56:52,140 --> 00:56:53,810
這只是我的一點上。

1160
00:56:53,810 --> 00:56:58,660
以同樣的方式，在C，其中
一旦我們說INT I，我們只是用我。

1161
00:56:58,660 --> 00:57:00,340
涼？

1162
00:57:00,340 --> 00:57:01,800
好吧。

1163
00:57:01,800 --> 00:57:03,710
>> 移動到循環，
幸運的是，這些幾乎

1164
00:57:03,710 --> 00:57:06,720
看exactly--我認為他們是
完全一樣的什麼

1165
00:57:06,720 --> 00:57:09,799
循環要看起來像
類似於C，你的for循環

1166
00:57:09,799 --> 00:57:11,840
將會有三個
parts--初始化，

1167
00:57:11,840 --> 00:57:13,640
的條件，和更新。

1168
00:57:13,640 --> 00:57:15,340
while循環，它看起來完全一樣的。

1169
00:57:15,340 --> 00:57:16,390
我們只是給它一個條件。

1170
00:57:16,390 --> 00:57:18,264
>> 而一個do while循環，
再次，完全一樣的。

1171
00:57:18,264 --> 00:57:20,190
我們給它一個條件。

1172
00:57:20,190 --> 00:57:24,510
比方說，我想遍歷over--
我想做點五倍。

1173
00:57:24,510 --> 00:57:27,840
在C語言中，我們可以這樣寫
用於初始化i等於0。

1174
00:57:27,840 --> 00:57:30,480
i小於5，我+ +。

1175
00:57:30,480 --> 00:57:34,240
唯一的區別，在JavaScript中，
而不是說INT I等於0，

1176
00:57:34,240 --> 00:57:36,820
我們說變種i等於0。

1177
00:57:36,820 --> 00:57:38,370
美麗。

1178
00:57:38,370 --> 00:57:41,320
這是唯一的區別。

1179
00:57:41,320 --> 00:57:43,200
在任何的任何問題嗎？

1180
00:57:43,200 --> 00:57:44,160
是。

1181
00:57:44,160 --> 00:57:48,480
>> 聽眾：所以在PHP中，這是相同的
的事情，但但像一個變量？

1182
00:57:48,480 --> 00:57:49,564
或者是一個變種的例子嗎？

1183
00:57:49,564 --> 00:57:50,480
漢娜布隆伯格：是的。

1184
00:57:50,480 --> 00:57:52,310
因此，在PHP中，這是怎麼回事
是一個美元符號。

1185
00:57:52,310 --> 00:57:59,450
因此，這將$ i等於
0，$ i小於5，$我+ +。

1186
00:57:59,450 --> 00:58:02,490
大的問題。

1187
00:58:02,490 --> 00:58:04,570
>> 現在，讓我們來談談
函數聲明。

1188
00:58:04,570 --> 00:58:07,010
在C中，當我們宣布
功能，我們給它一個名字

1189
00:58:07,010 --> 00:58:08,490
我們給它的一些參數。

1190
00:58:08,490 --> 00:58:10,670
而在一開始，我們寫的類型。

1191
00:58:10,670 --> 00:58:12,440
在JavaScript中，我們所
所要做的就是寫

1192
00:58:12,440 --> 00:58:15,080
關鍵字功能
說，哎，JavaScript中，

1193
00:58:15,080 --> 00:58:16,570
我將要定義一個函數。

1194
00:58:16,570 --> 00:58:18,520
>> 在這種情況下，它具有名稱總和。

1195
00:58:18,520 --> 00:58:20,820
它有兩個參數，x和y。

1196
00:58:20,820 --> 00:58:23,280
請注意，我們不關心
關於x和y的類型。

1197
00:58:23,280 --> 00:58:26,280
就如同C，我們有
此關鍵字的回報，

1198
00:58:26,280 --> 00:58:29,140
因此，我們可以做一些事情
像返回x和y。

1199
00:58:29,140 --> 00:58:32,540
>> 而現在一旦我們已經寫了這首
功能，我們可以在任何地方使用的總和。

1200
00:58:32,540 --> 00:58:34,740
而這完全罰款。

1201
00:58:34,740 --> 00:58:37,530
其中約很酷的事情
JavaScript的，這是非常與C

1202
00:58:37,530 --> 00:58:40,770
是起到能
像對待值。

1203
00:58:40,770 --> 00:58:43,895
因此，我們可以做這樣的事情在這裡
在這裡我想我管這個up--

1204
00:58:43,895 --> 00:58:46,400
我介紹了VAR總和
part--我們剛才說的

1205
00:58:46,400 --> 00:58:49,850
功能XY等於返回X加y。

1206
00:58:49,850 --> 00:58:52,140
>> 這就是將被稱為
匿名函數。

1207
00:58:52,140 --> 00:58:53,920
這是沒有名字的函數。

1208
00:58:53,920 --> 00:58:56,290
鑑於此說功能
總之，等等，等等，等等，

1209
00:58:56,290 --> 00:58:59,340
這將只是說功能。

1210
00:58:59,340 --> 00:59:02,020
但現在，即使我有
該匿名函數，

1211
00:59:02,020 --> 00:59:03,630
該功能實際上只是一個值。

1212
00:59:03,630 --> 00:59:05,160
我們可以把它當作一個值。

1213
00:59:05,160 --> 00:59:10,180
>> 因此，我們可以將其保存在一個變量相同
這樣，我們可以在一個變量存儲50。

1214
00:59:10,180 --> 00:59:13,870
所以我們可以說，OK，我想
可變的，這就是所謂的總和，

1215
00:59:13,870 --> 00:59:16,011
而正是這種功能。

1216
00:59:16,011 --> 00:59:18,760
所以這兩個東西實際上是
會做同樣的事情，

1217
00:59:18,760 --> 00:59:21,576
但是語法有一點
不同類型的一個有趣的註釋。

1218
00:59:21,576 --> 00:59:22,076
是啊。

1219
00:59:22,076 --> 00:59:25,548
>> 聽眾：所以，你可以調用
函數是匿名的說，

1220
00:59:25,548 --> 00:59:28,244
總和括號2,5？

1221
00:59:28,244 --> 00:59:29,160
漢娜布隆伯格：是的。

1222
00:59:29,160 --> 00:59:32,280
您可以撥打這個匿名
功能的方式相同。

1223
00:59:32,280 --> 00:59:33,350
你會做和（2,5）;

1224
00:59:33,350 --> 00:59:36,180

1225
00:59:36,180 --> 00:59:38,200
這將是完全罰款。

1226
00:59:38,200 --> 00:59:41,575
>> 如果我沒有做無功之和等於
功能，如果我只是刪除

1227
00:59:41,575 --> 00:59:45,480
this--我知道這是我的手，
但假裝我刪除this--然後

1228
00:59:45,480 --> 00:59:46,964
那種功能只是走了。

1229
00:59:46,964 --> 00:59:49,630
你永遠可以再次使用，因為它
你不必為它命名。

1230
00:59:49,630 --> 00:59:53,497
很難指什麼
你不知道叫什麼。

1231
00:59:53,497 --> 00:59:54,080
好問題。

1232
00:59:54,080 --> 00:59:54,580
是啊。

1233
00:59:54,580 --> 00:59:59,580
>> 聽眾：你可以參考之在
等地設有X加Y的值？

1234
00:59:59,580 --> 01:00:01,940
>> 漢娜布隆伯格：你能
在其他地方引用總和

1235
01:00:01,940 --> 01:00:03,360
與數值x加y？

1236
01:00:03,360 --> 01:00:05,130
我不完全明白你的意思。

1237
01:00:05,130 --> 01:00:10,582
>> 聽眾：所以你過去半匿名
功能是和等於該

1238
01:00:10,582 --> 01:00:14,452
匿名功能，所以總和是
現在你can--變量

1239
01:00:14,452 --> 01:00:15,410
漢娜布隆伯格：對。

1240
01:00:15,410 --> 01:00:18,980
所以總和是變量，
但它的actually--

1241
01:00:18,980 --> 01:00:23,770
所以總和是一個變量，其
值的功能。

1242
01:00:23,770 --> 01:00:27,030
因此，它是一個功能，這是一種
一個奇怪的東西來包裝你的頭左右

1243
01:00:27,030 --> 01:00:29,880
因為我們一直在玩
C和你不能這樣做，在C.

1244
01:00:29,880 --> 01:00:32,679
但是，現在我們可以調用求和
同樣，我們可以在這裡呼籲總和。

1245
01:00:32,679 --> 01:00:33,220
聽眾：OK。

1246
01:00:33,220 --> 01:00:33,970
漢娜布隆伯格：是的。

1247
01:00:33,970 --> 01:00:34,553
好問題。

1248
01:00:34,553 --> 01:00:35,438
是啊。

1249
01:00:35,438 --> 01:00:39,862
>> 聽眾：所以我們不使用
在PHP或JavaScript的原型？

1250
01:00:39,862 --> 01:00:42,070
漢娜布隆伯格：不，我們
不需要使用原型，

1251
01:00:42,070 --> 01:00:43,880
尤其是在JavaScript中。

1252
01:00:43,880 --> 01:00:49,380
所以有不好的做法件事，我
會說，你不應該這樣做

1253
01:00:49,380 --> 01:00:52,620
是你沒有寫變種I = 50。

1254
01:00:52,620 --> 01:00:54,840
你可能剛開始做我= 50。

1255
01:00:54,840 --> 01:00:57,490
而只想讓我一個全局變量。

1256
01:00:57,490 --> 01:01:00,550
>> 這是非常不好的做法，
從來沒有明確地說我變種，

1257
01:01:00,550 --> 01:01:01,800
但它的東西，你可以做。

1258
01:01:01,800 --> 01:01:03,591
翻譯的不
要罵你。

1259
01:01:03,591 --> 01:01:05,920
JavaScript是非常喜歡，
你可以做你想做的。

1260
01:01:05,920 --> 01:01:09,301

1261
01:01:09,301 --> 01:01:09,800
噢對不起。

1262
01:01:09,800 --> 01:01:10,300
有兩種。

1263
01:01:10,300 --> 01:01:12,150
在橙色褲子。

1264
01:01:12,150 --> 01:01:13,190
前進。

1265
01:01:13,190 --> 01:01:14,390
>> 聽眾：不，你先走。

1266
01:01:14,390 --> 01:01:16,765
>> 聽眾：沒有，我只是說
我沒有我的手。

1267
01:01:16,765 --> 01:01:20,248

1268
01:01:20,248 --> 01:01:20,748
好。

1269
01:01:20,748 --> 01:01:26,604
所以，如果你是打電話
這第一次，現在總結，

1270
01:01:26,604 --> 01:01:29,864
我們把它以同樣的方式，X，
Y，像每一次？

1271
01:01:29,864 --> 01:01:30,780
漢娜布隆伯格：是的。

1272
01:01:30,780 --> 01:01:32,572
因此，這兩個基本
做同樣的事情。

1273
01:01:32,572 --> 01:01:35,113
聽眾：這有什麼好處
用一個或另一個？

1274
01:01:35,113 --> 01:01:37,500
漢娜布隆伯格：沒有優勢
用一個或另一個。

1275
01:01:37,500 --> 01:01:40,080
我只是想顯示兩個
不同部分的語法。

1276
01:01:40,080 --> 01:01:42,770
很多時候在哪裡匿名
功能確實有一個目的，

1277
01:01:42,770 --> 01:01:48,220
是，如果該參數到另一個
功能應該是一個功能。

1278
01:01:48,220 --> 01:01:50,600
我們會看到，在
只是第二，阿賈克斯。

1279
01:01:50,600 --> 01:01:53,577
>> 因此，如果這沒有任何意義，
儲存到您的後腦勺。

1280
01:01:53,577 --> 01:01:55,660
這就是一個匿名
功能可能是有用

1281
01:01:55,660 --> 01:01:58,284
因為它不是真正的價值
給它一個名字，因為我們只是

1282
01:01:58,284 --> 01:01:59,443
將一次使用它。

1283
01:01:59,443 --> 01:02:00,370
是啊。

1284
01:02:00,370 --> 01:02:03,635
>> 聽眾：如果X和Y的變化後
上，將總結隨之改變？

1285
01:02:03,635 --> 01:02:06,510
漢娜布隆伯格：如果x和y的變化
稍後，將總結隨之改變？

1286
01:02:06,510 --> 01:02:08,840
所以，這其實是我
認為東西是，

1287
01:02:08,840 --> 01:02:12,260
再次，它只是感覺很不同
從C這不是一個值。

1288
01:02:12,260 --> 01:02:13,620
這不是5。

1289
01:02:13,620 --> 01:02:15,550
這只是函數本身。

1290
01:02:15,550 --> 01:02:19,110
所以，只要你給它的參數，
那麼你實際計算值。

1291
01:02:19,110 --> 01:02:21,193
>> MARIA ZLATKOVA：然後
你可以調用函數

1292
01:02:21,193 --> 01:02:23,272
並用它來獲得一些價值。

1293
01:02:23,272 --> 01:02:24,230
漢娜布隆伯格：對。

1294
01:02:24,230 --> 01:02:25,250
究竟。

1295
01:02:25,250 --> 01:02:25,863
是啊。

1296
01:02:25,863 --> 01:02:27,946
>> 聽眾：所以，如果你只是
它存儲在變量，

1297
01:02:27,946 --> 01:02:31,430
像變種x等於兩個values​​--總和

1298
01:02:31,430 --> 01:02:32,420
>> 漢娜布隆伯格：是的。

1299
01:02:32,420 --> 01:02:35,320
所以，你可以只是做無功總和
等於兩個值的總和。

1300
01:02:35,320 --> 01:02:37,670
是啊。

1301
01:02:37,670 --> 01:02:38,680
其他問題嗎？

1302
01:02:38,680 --> 01:02:39,642
是啊。

1303
01:02:39,642 --> 01:02:42,047
>> 聽眾：但是會是
混淆之和相加？

1304
01:02:42,047 --> 01:02:45,062
如果你打電話給你的變量之和像，
你會調用該函數之和？

1305
01:02:45,062 --> 01:02:45,895
漢娜布隆伯格：MM。

1306
01:02:45,895 --> 01:02:46,395
毫米。

1307
01:02:46,395 --> 01:02:51,253
如果你做了什麼
像，和等於總和2,5？

1308
01:02:51,253 --> 01:02:53,170
>> 聽眾：是的。

1309
01:02:53,170 --> 01:02:56,465
>> 漢娜布隆伯格：我認為，
將覆蓋總和的價值。

1310
01:02:56,465 --> 01:02:59,290
所以另一個有趣
關於JavaScript的事

1311
01:02:59,290 --> 01:03:02,950
是，單個變量可以取
在一堆不同的類型。

1312
01:03:02,950 --> 01:03:03,790
不好的做法。

1313
01:03:03,790 --> 01:03:06,280
你不應該做的事情
像你剛才說的話。

1314
01:03:06,280 --> 01:03:10,240
>> 但在C，如果我設置
等於一個整數，

1315
01:03:10,240 --> 01:03:13,570
我們知道，這是從來沒有
將成為一個字符串。

1316
01:03:13,570 --> 01:03:15,670
這不是在JavaScript的情況。

1317
01:03:15,670 --> 01:03:17,770
是啊，好問題。

1318
01:03:17,770 --> 01:03:20,151
還要別的嗎？

1319
01:03:20,151 --> 01:03:20,650
好吧。

1320
01:03:20,650 --> 01:03:21,850
這樣做的時候沒事了。

1321
01:03:21,850 --> 01:03:23,050
保持下去。

1322
01:03:23,050 --> 01:03:25,200
好吧。

1323
01:03:25,200 --> 01:03:27,780
>> 如果我們看一下一個數組
在JavaScript中，這裡的

1324
01:03:27,780 --> 01:03:30,250
字符串數組的一個簡單的例子。

1325
01:03:30,250 --> 01:03:31,967
和數組可以動態地增長。

1326
01:03:31,967 --> 01:03:33,675
他們沒有一個
固定大小相同的方式

1327
01:03:33,675 --> 01:03:37,990
他們做的C.我們可以訪問
元素只有在方括號內。

1328
01:03:37,990 --> 01:03:41,720
>> 這看起來很像PHP和很多
像C，其中我們可以說，在這種情況下，

1329
01:03:41,720 --> 01:03:48,360
如果我想的話的JavaScript，我會
別常用3方括號以0，1，2。

1330
01:03:48,360 --> 01:03:51,450

1331
01:03:51,450 --> 01:03:55,390
然後，如果在C記得，當我們
希望得到的陣列的長度，

1332
01:03:55,390 --> 01:03:56,820
這是真的很煩。

1333
01:03:56,820 --> 01:03:58,460
但在JavaScript中，超級簡單。

1334
01:03:58,460 --> 01:03:59,910
我們所做的一切，.length。

1335
01:03:59,910 --> 01:04:01,120
給它的長度。

1336
01:04:01,120 --> 01:04:01,892
而已。

1337
01:04:01,892 --> 01:04:03,140
>> 聽眾：這很簡單。

1338
01:04:03,140 --> 01:04:05,306
>> 漢娜布隆伯格：是的，使得
你的生活輕鬆了許多。

1339
01:04:05,306 --> 01:04:08,950

1340
01:04:08,950 --> 01:04:11,560
OK，object--不存在。

1341
01:04:11,560 --> 01:04:15,480
在JavaScript感覺的對象
很多像C結構

1342
01:04:15,480 --> 01:04:18,280
在PHP關聯數組。

1343
01:04:18,280 --> 01:04:20,270
因此，我們已經看到了
很多是JSON，這

1344
01:04:20,270 --> 01:04:23,150
代表JavaScript對象符號。

1345
01:04:23,150 --> 01:04:25,550
它基本上是一個辦法
對構建我們的數據。

1346
01:04:25,550 --> 01:04:27,880
>> 因此，讓我們來看一個例子，
可能是最簡單的。

1347
01:04:27,880 --> 01:04:32,540
因此，這裡是一個對象的示例
存儲類，CS50。

1348
01:04:32,540 --> 01:04:37,790
當我說課，我的意思當然，
不like--是的，過程中，CS50。

1349
01:04:37,790 --> 01:04:40,730
你會看到，
中的所有對象

1350
01:04:40,730 --> 01:04:43,526
將要被包含
大括號內。

1351
01:04:43,526 --> 01:04:48,260
>> 我們開始字段名關聯
或具有不同的值的鍵。

1352
01:04:48,260 --> 01:04:52,920
所以，你可以開始看到這樣的
感覺就像關聯數組在PHP。

1353
01:04:52,920 --> 01:04:57,450
因此，我們打算到外地關聯或
鍵名，當然，用字符串，

1354
01:04:57,450 --> 01:04:58,510
CS50。

1355
01:04:58,510 --> 01:04:59,940
>> 我們將有一個教練。

1356
01:04:59,940 --> 01:05:00,940
我們將有轉錄因子。

1357
01:05:00,940 --> 01:05:05,240
我們將有pset中的數
我們要去錄製。

1358
01:05:05,240 --> 01:05:10,720
而一個很酷的事情要注意的是所有的
這些東西有不同的類型，

1359
01:05:10,720 --> 01:05:12,020
而這完全罰款。

1360
01:05:12,020 --> 01:05:15,330
>> 這是罰款的對象，事實上，
它可能希望為對象

1361
01:05:15,330 --> 01:05:19,620
有字符串的組合
與數字和布爾值和數組

1362
01:05:19,620 --> 01:05:23,420
你可能其他任何
想擁有你的對象中。

1363
01:05:23,420 --> 01:05:28,570
並注意，這些都將是
名稱或鑰匙，然後我們就

1364
01:05:28,570 --> 01:05:30,300
設置一個小冒號相等。

1365
01:05:30,300 --> 01:05:32,015
>> 聽眾：這到底是什麼意思JSON？

1366
01:05:32,015 --> 01:05:33,890
漢娜布隆伯格：什麼
究竟JSON是什麼意思？

1367
01:05:33,890 --> 01:05:36,470
JSON只是代表
JavaScript對象符號。

1368
01:05:36,470 --> 01:05:38,430
這是格式化的只是一種方式。

1369
01:05:38,430 --> 01:05:40,040
是啊。

1370
01:05:40,040 --> 01:05:41,800
它是我們的格式化數據的方式。

1371
01:05:41,800 --> 01:05:43,620
>> 在C語言中，它的結構。

1372
01:05:43,620 --> 01:05:45,800
在PHP中，它的關聯數組。

1373
01:05:45,800 --> 01:05:47,120
在JavaScript中，我們擁有的對象。

1374
01:05:47,120 --> 01:05:48,969
>> 聽眾：所以CS50是一個對象？

1375
01:05:48,969 --> 01:05:51,010
漢娜布隆伯格：CS50是
在這種情況下的對象。

1376
01:05:51,010 --> 01:05:54,830

1377
01:05:54,830 --> 01:05:57,880
現在，我們如何真正進入
這些字段或更改這些字段。

1378
01:05:57,880 --> 01:06:03,920
例如，假設我們決定
你想少一個PSET這個學期。

1379
01:06:03,920 --> 01:06:06,300
相反九，我們
只是將有八個。

1380
01:06:06,300 --> 01:06:08,240
我們怎樣改變這種狀況？

1381
01:06:08,240 --> 01:06:09,436
>> 哦，走錯了路。

1382
01:06:09,436 --> 01:06:11,060
有跡象表明，我們可以做到兩種方式。

1383
01:06:11,060 --> 01:06:13,490
排名第一的是用點
符號和第二

1384
01:06:13,490 --> 01:06:15,750
與方括號。

1385
01:06:15,750 --> 01:06:19,720
因此，例如，如果我
想改變或訪問

1386
01:06:19,720 --> 01:06:26,820
在我們的CS50對象pset時現場，
我會做的是CS50.psets，

1387
01:06:26,820 --> 01:06:30,770
所以對象點的名稱
外地或密鑰的名稱。

1388
01:06:30,770 --> 01:06:37,120
>> 非常相似，這正是
相當於做CS50，然後

1389
01:06:37,120 --> 01:06:42,050
在方括號，pset中。

1390
01:06:42,050 --> 01:06:42,837
涼？

1391
01:06:42,837 --> 01:06:44,298
是啊。

1392
01:06:44,298 --> 01:06:47,707
>> 聽眾：原來是JSON
技術上JavaScript的是，

1393
01:06:47,707 --> 01:06:51,814
即使在pset時，我們
分離出來[聽不清]？

1394
01:06:51,814 --> 01:06:52,730
漢娜布隆伯格：當然。

1395
01:06:52,730 --> 01:06:56,290
所以，問題是，有
JavaScript和JSON相同呢？

1396
01:06:56,290 --> 01:07:00,750
因此，JSON是符號，基本
我們寫出的方式

1397
01:07:00,750 --> 01:07:02,700
一個對象從JavaScript。

1398
01:07:02,700 --> 01:07:05,190
因此，他們是不完全一樣的。

1399
01:07:05,190 --> 01:07:08,950
>> 我想說的JavaScript，有
在JavaScript對象。

1400
01:07:08,950 --> 01:07:12,590
JSON需要那些對象和
它們打印並顯示它們

1401
01:07:12,590 --> 01:07:15,160
或者將它們存儲在一個不錯的方式。

1402
01:07:15,160 --> 01:07:18,110
因此，JSON是不是一種編程
語言，JavaScript是一種方式。

1403
01:07:18,110 --> 01:07:20,900
這只是表示法
我們的JavaScript對象。

1404
01:07:20,900 --> 01:07:21,400
是啊。

1405
01:07:21,400 --> 01:07:24,144
>> 聽眾：那麼究竟是什麼
[聽不清]完成？

1406
01:07:24,144 --> 01:07:25,060
漢娜布隆伯格：當然。

1407
01:07:25,060 --> 01:07:27,727
因此，這實際上什麼也不做。

1408
01:07:27,727 --> 01:07:28,935
這僅僅是一個的方式來訪問。

1409
01:07:28,935 --> 01:07:31,393
所以我們可以說，我們希望改變
習題集數

1410
01:07:31,393 --> 01:07:32,450
朝九晚八。

1411
01:07:32,450 --> 01:07:34,383
我們要做的就是做一些事情
像CS50.psets = 8 ;.

1412
01:07:34,383 --> 01:07:38,500

1413
01:07:38,500 --> 01:07:39,400
>> 是的，很好的問題。

1414
01:07:39,400 --> 01:07:40,733
這只是向您展示的語法。

1415
01:07:40,733 --> 01:07:43,620
實際上並沒有做任何有用的。

1416
01:07:43,620 --> 01:07:46,085
任何問題？

1417
01:07:46,085 --> 01:07:48,210
運動沿著正確的。

1418
01:07:48,210 --> 01:07:51,960
>> 因此，讓我們看看如何一個簡單的例子
JavaScript的作品，因為我告訴你它

1419
01:07:51,960 --> 01:07:55,170
做所有這些很酷的事情和
允許我們修改網頁。

1420
01:07:55,170 --> 01:07:56,970
讓我們真正看到它的行動。

1421
01:07:56,970 --> 01:07:59,850
因此，舉個例子來說，這個HTML文件。

1422
01:07:59,850 --> 01:08:04,350
>> 我希望你關注的事情是
這個特定的標記，它是一個按鈕，

1423
01:08:04,350 --> 01:08:06,182
id為search_button。

1424
01:08:06,182 --> 01:08:08,670
這只是在頁面上。

1425
01:08:08,670 --> 01:08:10,690
所以，現在讓我們看看
我們其實可以做。

1426
01:08:10,690 --> 01:08:12,560
>> 那麼，假設當
單擊該按鈕，

1427
01:08:12,560 --> 01:08:16,010
我們要作出alert--
單擊按鈕。

1428
01:08:16,010 --> 01:08:17,840
讓我們來看看我們如何能做到這一點。

1429
01:08:17,840 --> 01:08:23,869
所以window.onload--這不是
你見過在課堂上，因此，

1430
01:08:23,869 --> 01:08:26,180
不需要知道它的測驗。

1431
01:08:26,180 --> 01:08:33,660
但是，這基本上說，OK，呼叫
此功能在窗口的負荷。

1432
01:08:33,660 --> 01:08:35,080
>> 所以，這只是一種設置代碼。

1433
01:08:35,080 --> 01:08:36,390
不要太在乎這一點。

1434
01:08:36,390 --> 01:08:39,170
我希望你關注的是在這裡。

1435
01:08:39,170 --> 01:08:44,020
我們說VAR searchButton等於
的document.getElementById search_button。

1436
01:08:44,020 --> 01:08:46,450
>> 所以您可能已經猜到，
這是什麼做的是它說，

1437
01:08:46,450 --> 01:08:50,920
OK，去找元素
ID為search_button。

1438
01:08:50,920 --> 01:08:52,790
而現在我們有
而我實際元素

1439
01:08:52,790 --> 01:08:56,279
將其存放在
可變searchButton。

1440
01:08:56,279 --> 01:09:00,651
現在，我們實際上可以使用該元素
並改變它，或者訪問其價值，

1441
01:09:00,651 --> 01:09:01,359
像這樣的東西。

1442
01:09:01,359 --> 01:09:04,649
事實上，我們可以開始
接合與網頁。

1443
01:09:04,649 --> 01:09:10,330
>> 所以在這裡我說，好了，現在我有
這個按鈕，它被點擊時，

1444
01:09:10,330 --> 01:09:12,859
調用這個匿名函數。

1445
01:09:12,859 --> 01:09:16,811
因此，這是匿名的
功能變得非常有用。

1446
01:09:16,811 --> 01:09:18,060
又是什麼作用呢？

1447
01:09:18,060 --> 01:09:20,529
那麼，它只是調用這個
報警功能和它說，

1448
01:09:20,529 --> 01:09:22,910
你點擊搜索按鈕。

1449
01:09:22,910 --> 01:09:29,670
>> 所以會發生什麼，如果我去哪裡
這個HTML的生活和我按一下按鈕，

1450
01:09:29,670 --> 01:09:33,729
我會得到一個奇特的小警報
說你單擊該按鈕。

1451
01:09:33,729 --> 01:09:40,710
所以事情專注於
這裡 - 的document.getElementById

1452
01:09:40,710 --> 01:09:44,960
得到一個特殊的HTML
元素與給定的ID。

1453
01:09:44,960 --> 01:09:48,529
而現在，我們可以設置
又該當發生

1454
01:09:48,529 --> 01:09:50,702
該特定元素被點擊。

1455
01:09:50,702 --> 01:09:52,670
>> 聽眾：我們必須把所有這一切的？

1456
01:09:52,670 --> 01:09:53,162
>> 漢娜布隆伯格：對不起？

1457
01:09:53,162 --> 01:09:55,130
>> 聽眾：我們是否要
實際編寫了這一切？

1458
01:09:55,130 --> 01:09:56,340
>> 漢娜布隆伯格：我們要不要
實際編寫了這一切？

1459
01:09:56,340 --> 01:09:56,839
是。

1460
01:09:56,839 --> 01:09:58,120
是不是這樣的煩人？

1461
01:09:58,120 --> 01:10:00,032
這是一個很大的代碼。

1462
01:10:00,032 --> 01:10:01,574
>> 聽眾：你可以導入一些東西。

1463
01:10:01,574 --> 01:10:02,532
漢娜布隆伯格：對。

1464
01:10:02,532 --> 01:10:03,610
我們可以使用的東西。

1465
01:10:03,610 --> 01:10:08,140
而在particular--哦，這是
告訴我，我要教一節。

1466
01:10:08,140 --> 01:10:11,061
尤其是，讓我們
使用圖書館jQuery的，

1467
01:10:11,061 --> 01:10:13,060
因為這是真的
長，真煩人

1468
01:10:13,060 --> 01:10:16,860
我希望能夠簡化其
並使其更短，更容易編寫。

1469
01:10:16,860 --> 01:10:19,810
>> 所以，jQuery是一個JavaScript庫。

1470
01:10:19,810 --> 01:10:24,930
因此，JavaScript是編程
語言; jQuery是一個圖書館。

1471
01:10:24,930 --> 01:10:27,190
這讓一堆事情變得更容易。

1472
01:10:27,190 --> 01:10:33,230
它使變化，去跨越
一個HTML文檔更容易。

1473
01:10:33,230 --> 01:10:35,030
>> 這使得處理事件變得更加容易。

1474
01:10:35,030 --> 01:10:37,580
它使動畫更容易
這讓阿賈克斯更容易。

1475
01:10:37,580 --> 01:10:40,140
因此，讓我們跳進兩
這些東西現在。

1476
01:10:40,140 --> 01:10:40,900
打擾一下。

1477
01:10:40,900 --> 01:10:42,620
在我們這樣做，一些基本的語法。

1478
01:10:42,620 --> 01:10:46,870
>> 這就是大多數調用
jQuery庫的樣子。

1479
01:10:46,870 --> 01:10:50,520
我們用這個美元sign--
無連接跡象PHP，

1480
01:10:50,520 --> 01:10:56,030
只是inconvenient--的名字
選擇器，點，然後一個動作。

1481
01:10:56,030 --> 01:10:58,860
因此，讓我們看到了一些
的該具體例子。

1482
01:10:58,860 --> 01:11:02,980
>> 因此，這實際上是一樣的
從事件滑動代碼。

1483
01:11:02,980 --> 01:11:08,740
所以這漫長的，醜陋的東西變成
這更漂亮，更小的東西。

1484
01:11:08,740 --> 01:11:10,370
因此，讓我們嘗試打破下來。

1485
01:11:10,370 --> 01:11:17,090
這是說，OK，jQuery--這個美元
sign-- jQuery的，找我的窗口。

1486
01:11:17,090 --> 01:11:18,480
所以這是選擇。

1487
01:11:18,480 --> 01:11:21,800
>> 當它加載，調用這個函數。

1488
01:11:21,800 --> 01:11:23,880
所以，這裡面的一切。

1489
01:11:23,880 --> 01:11:24,380
好。

1490
01:11:24,380 --> 01:11:25,740
到目前為止，一切都很好？

1491
01:11:25,740 --> 01:11:26,750
好吧。

1492
01:11:26,750 --> 01:11:32,970
>> 現在，jQuery的，找我的
ID為search_button的事情。

1493
01:11:32,970 --> 01:11:36,090
而且它被點擊，
調用此函數。

1494
01:11:36,090 --> 01:11:37,900
然後這個函數的
一模一樣。

1495
01:11:37,900 --> 01:11:41,052
只要做到警報一點點，
你點擊搜索按鈕。

1496
01:11:41,052 --> 01:11:42,650
>> 所以這是非常好的。

1497
01:11:42,650 --> 01:11:46,260
這真的凝聚和
簡化了我們的代碼。

1498
01:11:46,260 --> 01:11:49,030
我怎麼知道，
它的ID search_button

1499
01:11:49,030 --> 01:11:50,960
而不是像類search_button？

1500
01:11:50,960 --> 01:11:52,024
>> 聽眾：＃標籤？

1501
01:11:52,024 --> 01:11:52,940
漢娜布隆伯格：是的。

1502
01:11:52,940 --> 01:11:56,450
該散列符號，它就像CSS。

1503
01:11:56,450 --> 01:12:00,080
所以請記住，使用CSS，當我們
希望通過標識來選擇的東西，

1504
01:12:00,080 --> 01:12:01,590
我們使用井號。

1505
01:12:01,590 --> 01:12:05,400
而當我們想選擇
一些由一流的，我們使用點。

1506
01:12:05,400 --> 01:12:06,870
大。

1507
01:12:06,870 --> 01:12:08,230
合理？

1508
01:12:08,230 --> 01:12:11,500
所以jQuery的是應該
只是讓我們的生活更輕鬆。

1509
01:12:11,500 --> 01:12:12,000
是啊。

1510
01:12:12,000 --> 01:12:15,660
>> 聽眾：所以我有點困惑，
如何匿名函數的工作原理。

1511
01:12:15,660 --> 01:12:19,027
你命名此anonymouse
功能，功能？

1512
01:12:19,027 --> 01:12:20,594
它是如何叫什麼名字？

1513
01:12:20,594 --> 01:12:21,510
漢娜布隆伯格：當然。

1514
01:12:21,510 --> 01:12:25,812
因此，功能只是一個關鍵字
說，我將要定義一個函數。

1515
01:12:25,812 --> 01:12:26,520
聽眾：哦，好。

1516
01:12:26,520 --> 01:12:27,353
漢娜布隆伯格：OK？

1517
01:12:27,353 --> 01:12:32,120
然後我們把它作為一個
參數用於：讓我們

1518
01:12:32,120 --> 01:12:37,040
這種內在埃德蒙頓的點擊功能。

1519
01:12:37,040 --> 01:12:39,420
所以是的，這樣的功能，
該匿名函數，

1520
01:12:39,420 --> 01:12:40,910
成為一個實際參數。

1521
01:12:40,910 --> 01:12:43,632
所以請記住在JavaScript中，我們
可以把函數作為值。

1522
01:12:43,632 --> 01:12:44,340
聽眾：哦，好。

1523
01:12:44,340 --> 01:12:45,256
漢娜布隆伯格：是的。

1524
01:12:45,256 --> 01:12:46,035
我喜歡說，“哦。”

1525
01:12:46,035 --> 01:12:47,490
美觀大方。

1526
01:12:47,490 --> 01:12:49,915
其他的問題嗎？

1527
01:12:49,915 --> 01:12:50,505
時間？

1528
01:12:50,505 --> 01:12:51,380
MARIA ZLATKOVA：好。

1529
01:12:51,380 --> 01:12:52,760
好。

1530
01:12:52,760 --> 01:12:54,210
>> 漢娜布隆伯格：真棒。

1531
01:12:54,210 --> 01:12:55,720
一些快速有效的jQuery。

1532
01:12:55,720 --> 01:12:57,559
我不打算去
通過所有這些。

1533
01:12:57,559 --> 01:12:59,350
這些幻燈片將
在線一點點

1534
01:12:59,350 --> 01:13:02,040
後來，這樣你就可以檢查
它有點晚。

1535
01:13:02,040 --> 01:13:07,120
但基本上，一般
模式成立，其中說，

1536
01:13:07,120 --> 01:13:11,510
好了，嘿嘿，jQuery的，這裡是我的
選擇，然後在這裡是一個動作。

1537
01:13:11,510 --> 01:13:15,940
你可以做的事情一樣訪問
一種形式的價值，獲得一些HTML，

1538
01:13:15,940 --> 01:13:19,195
控制用戶時，會發生什麼
提交表單，這樣的事情。

1539
01:13:19,195 --> 01:13:20,106
是。

1540
01:13:20,106 --> 01:13:22,090
>> 聽眾：所以在
考試，我們將需要

1541
01:13:22,090 --> 01:13:25,066
從知道了不少
jQuery的文檔。

1542
01:13:25,066 --> 01:13:31,018
因此，鑑於我們複製/粘貼了jQuery
文檔我們的小抄，

1543
01:13:31,018 --> 01:13:32,506
哪來的行畫？

1544
01:13:32,506 --> 01:13:33,957
就像我們需要知道多少？

1545
01:13:33,957 --> 01:13:35,290
漢娜布隆伯格：大的問題。

1546
01:13:35,290 --> 01:13:37,765
問題是
本質上給你

1547
01:13:37,765 --> 01:13:41,330
不能訪問jQuery的文檔
在測試過程中，有多少你應該

1548
01:13:41,330 --> 01:13:41,830
知道？

1549
01:13:41,830 --> 01:13:45,540
我們不希望你來
與一些隨機函數

1550
01:13:45,540 --> 01:13:47,240
我們希望你給谷歌。

1551
01:13:47,240 --> 01:13:52,930
>> 事情是公平的遊戲是我會
說只是一種一般的語法，

1552
01:13:52,930 --> 01:13:58,310
能夠通過標識來選擇和
通過分類 - 所以就像CS​​S。

1553
01:13:58,310 --> 01:14:01,876
然後實際的功能
自理，我們很可能會告訴你。

1554
01:14:01,876 --> 01:14:02,376
是啊。

1555
01:14:02,376 --> 01:14:05,591
>> 聽眾：所以當你選擇
按類將意味著點。

1556
01:14:05,591 --> 01:14:06,840
漢娜布隆伯格：是的，沒錯。

1557
01:14:06,840 --> 01:14:07,340
好。

1558
01:14:07,340 --> 01:14:10,461
如果按類進行選擇，這是怎麼回事
被點，而不是英鎊符號。

1559
01:14:10,461 --> 01:14:10,960
是。

1560
01:14:10,960 --> 01:14:12,710
>> 聽眾：請問你
過去的區別

1561
01:14:12,710 --> 01:14:14,310
通過ID和類之間？

1562
01:14:14,310 --> 01:14:14,560
>> 漢娜布隆伯格：當然。

1563
01:14:14,560 --> 01:14:17,510
選擇之間的差
ID和選擇按類。

1564
01:14:17,510 --> 01:14:20,685
因此，作為瑪麗亞說，
稍早些時候，有

1565
01:14:20,685 --> 01:14:26,280
只能有一個HTML元素
具有給定的ID，而類，

1566
01:14:26,280 --> 01:14:29,740
它可以讓我們組了一堆
不同的元素結合在一起，

1567
01:14:29,740 --> 01:14:34,300
這樣的事情有關係，
但不完全相同。

1568
01:14:34,300 --> 01:14:35,685
這是否回答這個問題？

1569
01:14:35,685 --> 01:14:36,200
真棒。

1570
01:14:36,200 --> 01:14:37,194
是。

1571
01:14:37,194 --> 01:14:40,680
>> 聽眾：如果你有什麼多
事情是在同一個班？

1572
01:14:40,680 --> 01:14:42,150
>> 漢娜布隆伯格：會發生什麼事
如果您有多個東西，

1573
01:14:42,150 --> 01:14:43,280
是同一類？

1574
01:14:43,280 --> 01:14:45,829
因此，例如，如果我們
只使用純JavaScript，

1575
01:14:45,829 --> 01:14:48,120
我們會做這樣的事情
document.getElementsByClass。

1576
01:14:48,120 --> 01:14:52,280

1577
01:14:52,280 --> 01:14:56,320
然後呢，實際上起
是返回元件的陣列。

1578
01:14:56,320 --> 01:14:59,517
>> 你必須要么迭代
他們或找到你想要哪一個。

1579
01:14:59,517 --> 01:15:01,350
它不會放棄
你一個元素。

1580
01:15:01,350 --> 01:15:03,450
這將讓你
元件的陣列。

1581
01:15:03,450 --> 01:15:05,280
大的問題。

1582
01:15:05,280 --> 01:15:07,700
還要別的嗎？

1583
01:15:07,700 --> 01:15:09,520
真棒。

1584
01:15:09,520 --> 01:15:12,860
>> 所以我覺得，如果你熟悉
任何jQuery的你在PSET看到，

1585
01:15:12,860 --> 01:15:15,600
你應該是好去。

1586
01:15:15,600 --> 01:15:16,325
題？

1587
01:15:16,325 --> 01:15:17,610
不好了。

1588
01:15:17,610 --> 01:15:18,859
我真的要教。

1589
01:15:18,859 --> 01:15:19,358
放鬆。

1590
01:15:19,358 --> 01:15:20,035
它會沒事的。

1591
01:15:20,035 --> 01:15:20,660
我會到達那裡。

1592
01:15:20,660 --> 01:15:24,670

1593
01:15:24,670 --> 01:15:26,870
>> 讓我們來談談阿賈克斯。

1594
01:15:26,870 --> 01:15:31,350
因此，阿賈克斯將是A--好，
讓我們先從它代表什麼。

1595
01:15:31,350 --> 01:15:32,350
這是一個縮寫。

1596
01:15:32,350 --> 01:15:35,855
它代表了異步
JavaScript和XML。

1597
01:15:35,855 --> 01:15:39,800
和XML基本上將是
[聽不清]，類型為我們的數據。

1598
01:15:39,800 --> 01:15:42,100
但是我們還沒有實際使用XML。

1599
01:15:42,100 --> 01:15:43,430
相反，我們只是使用JSON。

1600
01:15:43,430 --> 01:15:48,350
>> 所以基本上，它的一些數據 - 
異步JavaScript和數據，

1601
01:15:48,350 --> 01:15:50,040
在這種情況下，JSON。

1602
01:15:50,040 --> 01:15:52,820
而我們的目標，因為我們提到的
早一點，

1603
01:15:52,820 --> 01:15:56,880
是能夠使一個
要求，有要求做

1604
01:15:56,880 --> 01:16:00,700
其在事
背景，而是繼續

1605
01:16:00,700 --> 01:16:02,550
做任何我們打算做的事。

1606
01:16:02,550 --> 01:16:06,650
然後當該信息是
準備好了，然後我們將其合併。

1607
01:16:06,650 --> 01:16:08,470
>> 因此，讓我們看看這是什麼
實際模樣。

1608
01:16:08,470 --> 01:16:11,210
而這一點，你應該
一點點的熟悉

1609
01:16:11,210 --> 01:16:13,680
從pset8，一個你剛滿研究。

1610
01:16:13,680 --> 01:16:16,200
因此，這裡是一個有效的jQuery
功能，我們可能

1611
01:16:16,200 --> 01:16:18,250
想知道about--這個美元符號。

1612
01:16:18,250 --> 01:16:21,500
所以說jQuery的功能，.getJson。

1613
01:16:21,500 --> 01:16:25,020
>> 什麼這個函數是它
需要一個URL和一些parameters--

1614
01:16:25,020 --> 01:16:28,000
所以我覺得在案件
pset8的，有人喜歡，

1615
01:16:28,000 --> 01:16:33,520
網址是articles.php和
參數是去=一些郵政編碼。

1616
01:16:33,520 --> 01:16:41,580
它說，OK，做一個請求
此URL具有給定參數。

1617
01:16:41,580 --> 01:16:43,480
而這恰好。

1618
01:16:43,480 --> 01:16:47,730
>> 當它完成，它要么
要成功完成

1619
01:16:47,730 --> 01:16:49,370
或者它會失敗。

1620
01:16:49,370 --> 01:16:53,480
因此，這是調用相當於
羅布並要求他做一些事情。

1621
01:16:53,480 --> 01:17:00,260
然後，當他叫回來，他要么
會說我做的還是我失敗了。

1622
01:17:00,260 --> 01:17:04,030
>> 所以，在你的情況下，
這樣做，你說好，我完成了。

1623
01:17:04,030 --> 01:17:05,980
然後調用這個函數。

1624
01:17:05,980 --> 01:17:08,915
在這種情況下，這將是一個
函數，它的某些信息。

1625
01:17:08,915 --> 01:17:12,890
一個我們通常關心的是數據，
我們實際上返回的數據

1626
01:17:12,890 --> 01:17:15,900
作為調用.getJSON的結果。

1627
01:17:15,900 --> 01:17:17,470
>> 你可以用它做什麼。

1628
01:17:17,470 --> 01:17:23,670
所以在pset8的情況下，
我們顯示它作為一個清單。

1629
01:17:23,670 --> 01:17:29,050
失敗將是一個函數
如果請求失敗時調用

1630
01:17:29,050 --> 01:17:30,450
無論出於何種原因。

1631
01:17:30,450 --> 01:17:35,104
和在pset8的情況下，
我們只是CONSOLE.LOG它。

1632
01:17:35,104 --> 01:17:36,020
上有問題嗎？

1633
01:17:36,020 --> 01:17:36,300
是啊。

1634
01:17:36,300 --> 01:17:39,633
>> 聽眾：我們可以只使用功能THETA
而不是函數，textStatus，jqHXR。

1635
01:17:39,633 --> 01:17:43,464

1636
01:17:43,464 --> 01:17:44,380
漢娜布隆伯格：當然。

1637
01:17:44,380 --> 01:17:46,713
所以，是的，我覺得在處理器集，
剛才我們看到的功能數據。

1638
01:17:46,713 --> 01:17:48,700
所以它只是the--是的，OK。

1639
01:17:48,700 --> 01:17:50,510
這就是我們在PSET看到。

1640
01:17:50,510 --> 01:17:51,480
這是完全正常。

1641
01:17:51,480 --> 01:17:54,210
>> 這些都只是如果你想
拉出來的更多信息，

1642
01:17:54,210 --> 01:17:57,190
這些都是事
你可以從.getJSON。

1643
01:17:57,190 --> 01:17:59,040
好問題。

1644
01:17:59,040 --> 01:17:59,706
還要別的嗎？

1645
01:17:59,706 --> 01:18:00,206
是啊。

1646
01:18:00,206 --> 01:18:01,787
>> 聽眾：所以.ge​​tJSON是阿賈克斯？

1647
01:18:01,787 --> 01:18:02,620
漢娜布隆伯格：OK。

1648
01:18:02,620 --> 01:18:05,700
因此，這是那種棘手的部分。

1649
01:18:05,700 --> 01:18:12,390
這是一個jQuery的功能，可以讓
你做的異步調用。

1650
01:18:12,390 --> 01:18:16,080
而那些異步調用，這是
我們一直提到的阿賈克斯。

1651
01:18:16,080 --> 01:18:16,850
是啊。

1652
01:18:16,850 --> 01:18:20,185
這花了我很長的時間來
拉開的時候我還是個學生。

1653
01:18:20,185 --> 01:18:21,560
聽眾：你能再說一遍嗎？

1654
01:18:21,560 --> 01:18:22,476
漢娜布隆伯格：是的。

1655
01:18:22,476 --> 01:18:23,630
我可以再說一遍？

1656
01:18:23,630 --> 01:18:29,010
這.getJSON功能，
這是一個jQuery的功能。

1657
01:18:29,010 --> 01:18:31,970
而這將會使
異步調用。

1658
01:18:31,970 --> 01:18:35,700
而這些異步調用，我們已經
是指那些為阿賈克斯。

1659
01:18:35,700 --> 01:18:39,610

1660
01:18:39,610 --> 01:18:41,872
>> 其他問題嗎？

1661
01:18:41,872 --> 01:18:43,330
我們剛離開幾分鐘。

1662
01:18:43,330 --> 01:18:45,080
而瑪麗亞的打算
包安全

1663
01:18:45,080 --> 01:18:47,464
然後我們要去
將即將完成。

1664
01:18:47,464 --> 01:18:48,630
MARIA ZLATKOVA：真棒，確定。

1665
01:18:48,630 --> 01:18:54,030
因此，這is--只取一對夫婦
幾秒鐘過目這一點。

1666
01:18:54,030 --> 01:18:56,750
這是不是真的很棒。

1667
01:18:56,750 --> 01:18:59,430
而有人可以告訴我為什麼？

1668
01:18:59,430 --> 01:19:05,650
這是怎麼回事在foo和可能能
有可能造成不好的東西，

1669
01:19:05,650 --> 01:19:06,770
而什麼叫？

1670
01:19:06,770 --> 01:19:07,270
是啊。

1671
01:19:07,270 --> 01:19:10,391
聽眾：如果參數這
通過在超過12個字符，

1672
01:19:10,391 --> 01:19:11,454
它可能溢出。

1673
01:19:11,454 --> 01:19:12,370
MARIA ZLATKOVA：對。

1674
01:19:12,370 --> 01:19:14,180
完善。

1675
01:19:14,180 --> 01:19:15,384
它叫什麼？

1676
01:19:15,384 --> 01:19:16,300
你剛才提到它。

1677
01:19:16,300 --> 01:19:16,840
>> 聽眾：緩衝區溢出。

1678
01:19:16,840 --> 01:19:18,381
>> MARIA ZLATKOVA：是啊，緩衝區溢出。

1679
01:19:18,381 --> 01:19:21,230
因此，這是我們
所說的緩衝區溢出。

1680
01:19:21,230 --> 01:19:25,500
而我們看到的foo裡面，
我們已經定義了我們的緩衝區，C，

1681
01:19:25,500 --> 01:19:27,240
與12的尺寸。

1682
01:19:27,240 --> 01:19:32,680
然而，在主，我們不
檢查以任何方式在所有

1683
01:19:32,680 --> 01:19:36,480
是否argv1--使
是第二個參數。

1684
01:19:36,480 --> 01:19:39,630
我們不檢查是否
它的尺寸是否合適。

1685
01:19:39,630 --> 01:19:43,380
>> 因此，如果我們有一個
尤其是惡意用戶

1686
01:19:43,380 --> 01:19:47,170
誰把一些說法，這是
超過12，以及隨後可能

1687
01:19:47,170 --> 01:19:50,850
超出該範圍
的說法，有一些可執行代碼

1688
01:19:50,850 --> 01:19:55,570
他試圖做壞事
用它;那麼這個，會發生什麼，

1689
01:19:55,570 --> 01:19:59,310
將覆蓋回報
foo的函數的地址，

1690
01:19:59,310 --> 01:20:04,370
使所述功能時
返回到執行該代碼。

1691
01:20:04,370 --> 01:20:07,540
再糟糕的事情可能發生。

1692
01:20:07,540 --> 01:20:09,850
這是否有意義給大家？

1693
01:20:09,850 --> 01:20:12,424
>> 我們怎樣才能防止這種？

1694
01:20:12,424 --> 01:20:13,090
有什麼建議麼？

1695
01:20:13,090 --> 01:20:16,480

1696
01:20:16,480 --> 01:20:21,890
基本上，內
潛在FOO，怎麼

1697
01:20:21,890 --> 01:20:28,294
我們可以檢查，以確保
這是不可能發生？

1698
01:20:28,294 --> 01:20:33,879
>> 聽眾：如果大小12超出，
你會分配更多的內存？

1699
01:20:33,879 --> 01:20:37,170
MARIA ZLATKOVA：建議是，分配
大小更多的內存超標。

1700
01:20:37,170 --> 01:20:39,800
事實上，我們可以做的東西
很多比以及更簡單。

1701
01:20:39,800 --> 01:20:44,870
我們剛剛得到的字符串長度
所輸入的說法，

1702
01:20:44,870 --> 01:20:48,590
檢查，如果這是不太
大於或等於12--

1703
01:20:48,590 --> 01:20:50,790
這就是我們想要的
是因為我們不希望

1704
01:20:50,790 --> 01:20:52,373
這超出我們的緩衝區的邊界。

1705
01:20:52,373 --> 01:20:55,690
然後如果沒有，我們
可以帶參數運行。

1706
01:20:55,690 --> 01:21:00,296
然後，如果是的話，我們其實是想
潛在YELLO處的用戶。

1707
01:21:00,296 --> 01:21:01,670
但是，這是我們如何做到這一點。

1708
01:21:01,670 --> 01:21:02,443
是。

1709
01:21:02,443 --> 01:21:04,360
>> 聽眾：莫非你
解釋的memcpy真正的快？

1710
01:21:04,360 --> 01:21:05,443
MARIA ZLATKOVA：哦，對不起。

1711
01:21:05,443 --> 01:21:06,040
是。

1712
01:21:06,040 --> 01:21:11,290
memcpy的需要什麼is--對不起，OK。

1713
01:21:11,290 --> 01:21:15,850
memcpy的需要無論是
在酒吧，無論是通過

1714
01:21:15,850 --> 01:21:18,050
到富作為命令行參數。

1715
01:21:18,050 --> 01:21:19,440
因此，要採取argv1。

1716
01:21:19,440 --> 01:21:21,420
Argv1在此被稱為酒吧。

1717
01:21:21,420 --> 01:21:24,453
因此，要採取酒吧，
這將其複製到c中。

1718
01:21:24,453 --> 01:21:25,402
>> 聽眾：OK。

1719
01:21:25,402 --> 01:21:28,360
MARIA ZLATKOVA：而且它會
copy--第三個參數只是指

1720
01:21:28,360 --> 01:21:30,601
多少它會複製到c中。

1721
01:21:30,601 --> 01:21:31,142
聽眾：嗯。

1722
01:21:31,142 --> 01:21:33,030
所以這一塊的複製這一切呢。

1723
01:21:33,030 --> 01:21:34,310
>> MARIA ZLATKOVA：是啊，
它複製它的全部。

1724
01:21:34,310 --> 01:21:34,810
是的。

1725
01:21:34,810 --> 01:21:38,400

1726
01:21:38,400 --> 01:21:41,910
首先，我們要確保酒吧是不
等於空，因為它是一個指針。

1727
01:21:41,910 --> 01:21:44,680
然後，我們得到欄的字符串長度。

1728
01:21:44,680 --> 01:21:47,530
我們要確保它的
小於或等於12。

1729
01:21:47,530 --> 01:21:50,070
然後，因為我們已經
確信，我們實際上可以

1730
01:21:50,070 --> 01:21:53,122
memcpy和確保沒關係。

1731
01:21:53,122 --> 01:21:53,705
任何問題？

1732
01:21:53,705 --> 01:21:56,280

1733
01:21:56,280 --> 01:21:58,690
大。

1734
01:21:58,690 --> 01:22:00,400
我有兩個真或假的問題。

1735
01:22:00,400 --> 01:22:05,470
誰能告訴我馬上
如果這是真的還是假的？

1736
01:22:05,470 --> 01:22:07,460
是的，這是假的。

1737
01:22:07,460 --> 01:22:07,960
究竟。

1738
01:22:07,960 --> 01:22:09,330
他們兩人都是假的。

1739
01:22:09,330 --> 01:22:12,682
因此，使用單一密碼
從來都不是好主意

1740
01:22:12,682 --> 01:22:14,890
因為如果有人知道
你的密碼，他們可以只

1741
01:22:14,890 --> 01:22:16,260
訪問自己的所有其他帳戶。

1742
01:22:16,260 --> 01:22:19,260
然後圖標什麼都不做
以保證安全。

1743
01:22:19,260 --> 01:22:24,900
我們通常應該尋找HTTPS
而不是HTTP和URL。

1744
01:22:24,900 --> 01:22:28,560
>> 還有一些其他類型的
我們已經提到的攻擊，

1745
01:22:28,560 --> 01:22:31,390
大衛在提到
講座中，SQL注入攻擊。

1746
01:22:31,390 --> 01:22:37,310
我們已經看到，如果我們don't--的
CS50查詢功能可確保SQL

1747
01:22:37,310 --> 01:22:39,530
不能出現注入式攻擊。

1748
01:22:39,530 --> 01:22:42,640
但是，如果我們沒有使用CS50，
報價，引文結束“查詢，”

1749
01:22:42,640 --> 01:22:46,830
我們必須確保該
用戶輸入實際上不是某些SQL

1750
01:22:46,830 --> 01:22:49,670
查詢，將導致所有
被丟棄我們的表

1751
01:22:49,670 --> 01:22:54,070
什麼不好
發生在我們的數據庫。

1752
01:22:54,070 --> 01:22:56,790
>> 會話劫持
另一種類型的攻擊

1753
01:22:56,790 --> 01:23:05,940
這種情況發生了一些不好的時候
人使用了一些受害者的會話

1754
01:23:05,940 --> 01:23:08,740
標識訪問登錄信息。

1755
01:23:08,740 --> 01:23:13,620
所以，一個很簡單的例子是
一樣，如果我們的公共電腦，

1756
01:23:13,620 --> 01:23:21,120
然後再壞的人記錄
他們有保存的cookies。

1757
01:23:21,120 --> 01:23:23,380
而且餅乾不改變會話。

1758
01:23:23,380 --> 01:23:27,620
>> 然後我們有受害人去
然後登錄到該網站。

1759
01:23:27,620 --> 01:23:30,290
的Cookie不會改變
對於一定的會話。

1760
01:23:30,290 --> 01:23:33,060
然後受害人登錄到
該網站，然後離開。

1761
01:23:33,060 --> 01:23:36,190
然後這個人誰追溯到
則仍可使用其會話ID

1762
01:23:36,190 --> 01:23:37,430
來訪問他們的信息。

1763
01:23:37,430 --> 01:23:40,050
所以這是一個例子
怎麼可能發生。

1764
01:23:40,050 --> 01:23:45,570
>> 然後，我就不會太擔心
關於具體的代碼或任何東西

1765
01:23:45,570 --> 01:23:49,270
這樣可能會導致此，
但有某種想法是什麼

1766
01:23:49,270 --> 01:23:51,400
參與這一變量是。

1767
01:23:51,400 --> 01:23:53,897
然後操縱頭
數據是另一種類型的攻擊

1768
01:23:53,897 --> 01:23:55,230
有大衛談到。

1769
01:23:55,230 --> 01:23:59,730
它只是指
有什麼可以當發生

1770
01:23:59,730 --> 01:24:04,300
響應時，HTTP
響應我們的頭裡面

1771
01:24:04,300 --> 01:24:05,720
沒有正確消毒。

1772
01:24:05,720 --> 01:24:14,340
>> 和任何fields--例如，
如果有人將覆蓋頭的一個

1773
01:24:14,340 --> 01:24:18,860
值中包含任何超過
他們應該contain--，實際上

1774
01:24:18,860 --> 01:24:22,720
含有，例如，一個200
OK狀態代碼，然後他們

1775
01:24:22,720 --> 01:24:26,890
可能做惡意
事情時，他們不應該。

1776
01:24:26,890 --> 01:24:30,815
但我不會太擔心
太多關於具體的代碼

1777
01:24:30,815 --> 01:24:34,110
這可能會導致此，
剛剛體悟

1778
01:24:34,110 --> 01:24:37,290
高級別之類的東西。

1779
01:24:37,290 --> 01:24:39,570
>> 我想這是所有
我們必須覆蓋。

1780
01:24:39,570 --> 01:24:40,090
驚人。

1781
01:24:40,090 --> 01:24:43,310
任何人有任何任何問題
那我們討論的東西呢？

1782
01:24:43,310 --> 01:24:44,213
是。

1783
01:24:44,213 --> 01:24:48,077
>> 聽眾：所以有幾分
更多的後勤問題。

1784
01:24:48,077 --> 01:24:53,400
是內容主要集中
在測驗1以後的事情呢？

1785
01:24:53,400 --> 01:24:55,730
>> MARIA ZLATKOVA：所以
問題是，是內容

1786
01:24:55,730 --> 01:24:59,720
主要集中在東西測驗1後？

1787
01:24:59,720 --> 01:25:06,070
所以在重點是
測驗1，除

1788
01:25:06,070 --> 01:25:10,914
我們需要關注的事情
pset5和大量的數據結構的

1789
01:25:10,914 --> 01:25:11,580
我們覆蓋。

1790
01:25:11,580 --> 01:25:14,300
我們不能說我們
可之前忽略任何東西

1791
01:25:14,300 --> 01:25:17,120
因為它是建立在它。

1792
01:25:17,120 --> 01:25:21,845
>> 因此，重點是，加pset5材料
像包括鍊錶，棧，

1793
01:25:21,845 --> 01:25:23,720
隊列和一切
漢娜去了。

1794
01:25:23,720 --> 01:25:24,050
>> 漢娜布隆伯格：對。

1795
01:25:24,050 --> 01:25:27,450
是啊，我們去了所有的C東西
在一開始非常快。

1796
01:25:27,450 --> 01:25:29,090
但是，一定要複查。

1797
01:25:29,090 --> 01:25:32,700
回去看測驗0審查。

1798
01:25:32,700 --> 01:25:36,110
>> 一對夫婦更多的後勤筆記，
只是當我們有您的注意。

1799
01:25:36,110 --> 01:25:39,100
我們將不得不辦公時間
無論在週一和週二晚上。

1800
01:25:39,100 --> 01:25:41,540
他們將在MD 119。

1801
01:25:41,540 --> 01:25:44,220
這是所有網站上的，所以
如果你不聽，無後顧之憂。

1802
01:25:44,220 --> 01:25:45,266
>> MARIA ZLATKOVA：8：30至11:00。

1803
01:25:45,266 --> 01:25:46,260
>> 漢娜布隆伯格：是的，8：30至11:00。

1804
01:25:46,260 --> 01:25:46,910
我們將在那裡。

1805
01:25:46,910 --> 01:25:48,368
我們將在那裡回答問題。

1806
01:25:48,368 --> 01:25:49,480
這是很肅殺和樂趣。

1807
01:25:49,480 --> 01:25:53,240
你們可以問任何問題
你對測驗1。

1808
01:25:53,240 --> 01:25:55,740
而測驗1是
週三，運氣這麼好。

1809
01:25:55,740 --> 01:25:59,770
如果你有任何問題，也許
再來說說我們在這裡一對之一。

1810
01:25:59,770 --> 01:26:00,880
涼。

1811
01:26:00,880 --> 01:26:01,630
非常感謝。

1812
01:26:01,630 --> 01:26:02,880
>> MARIA ZLATKOVA：非常感謝，伙計們。

1813
01:26:02,880 --> 01:26:03,480
>> 聽眾：耶。

1814
01:26:03,480 --> 01:26:05,930
>> [掌聲]

1815
01:26:05,930 --> 01:26:07,530