1
00:00:00,000 --> 00:00:11,330

2
00:00:11,330 --> 00:00:12,360
>> DAVID馬蘭：好吧。

3
00:00:12,360 --> 00:00:15,970
這是CS50，這是
9週的結束。

4
00:00:15,970 --> 00:00:18,560
它在被旋風
這幾天。

5
00:00:18,560 --> 00:00:21,580
與問題設置7，如果你的膝蓋
深入到它，實現有相當多

6
00:00:21,580 --> 00:00:23,340
位新這是在那裡。

7
00:00:23,340 --> 00:00:26,660
但是讓我們看看如果我們不能拼湊
一切都聚集在這裡簡要地

8
00:00:26,660 --> 00:00:29,230
在此之前尚未在關閉於水火之中
另一個方向，看到

9
00:00:29,230 --> 00:00:30,510
還有什麼地方可以去。

10
00:00:30,510 --> 00:00:32,630
>> 所以到目前為止，我們已經討論過的HTML。

11
00:00:32,630 --> 00:00:33,740
我們已經談到的CSS。

12
00:00:33,740 --> 00:00:34,705
我們已經談了PHP的。

13
00:00:34,705 --> 00:00:36,520
你開始體驗到的SQL。

14
00:00:36,520 --> 00:00:38,360
今天，我們就商量了一下
關於JavaScript。

15
00:00:38,360 --> 00:00:41,230
但如何做所有這些不同的
語言結合在一起？

16
00:00:41,230 --> 00:00:44,970
>> 所以，我們上週談到了
概念有一個服務器。

17
00:00:44,970 --> 00:00:48,470
所以我們只繪製這個矩形
這裡作為一個Web服務器。

18
00:00:48,470 --> 00:00:52,200
和Web服務器提供一定的文件。

19
00:00:52,200 --> 00:00:54,640
並且其中一些文件
可以是HTML文件。

20
00:00:54,640 --> 00:00:58,270
這樣的事情之一是一個Web服務器
可以吐出可能是一個文件，該文件

21
00:00:58,270 --> 00:01:01,290
我們就得出這樣的
包含一些HTML。

22
00:01:01,290 --> 00:01:04,786
所以，通俗地說，是什麼
沒有HTML讓你做？

23
00:01:04,786 --> 00:01:06,036
>> 觀眾：頁面看起來不錯。

24
00:01:06,036 --> 00:01:09,670

25
00:01:09,670 --> 00:01:12,310
>> DAVID MALAN：好，使一個頁面看起來不錯，
雖然我覺得我已經證明

26
00:01:12,310 --> 00:01:13,370
，否則。

27
00:01:13,370 --> 00:01:18,250
因此，HTML的確讓你鋪陳頁
結構上，它可以讓你

28
00:01:18,250 --> 00:01:22,410
排序的美學標記的頁面，
標記靜態內容，讓你

29
00:01:22,410 --> 00:01:23,640
然後，可以使用Web瀏覽器查看它。

30
00:01:23,640 --> 00:01:24,690
>> 但是，這是關鍵。

31
00:01:24,690 --> 00:01:26,130
這是靜態內容。

32
00:01:26,130 --> 00:01:28,590
你寫它，你保存它，
然後你發貨。

33
00:01:28,590 --> 00:01:31,130
和Web服務器，然後提供
它給您的訪客。

34
00:01:31,130 --> 00:01:35,700
>> 但我們風格化使用不同的事情
語言完全。

35
00:01:35,700 --> 00:01:40,150
我們開始使用一個style屬性
對某些標籤。

36
00:01:40,150 --> 00:01:43,400
和style屬性讓我們設置
事情，比如字體大小和顏色。

37
00:01:43,400 --> 00:01:46,460
而且你可能已經開始發現，
或者你很快就會進行最後的

38
00:01:46,460 --> 00:01:50,160
項目可能的，但其他
屬性，您可以在CSS中使用。

39
00:01:50,160 --> 00:01:54,710
所以通俗地說，是什麼
真的那麼CSS的呢？

40
00:01:54,710 --> 00:01:57,810
這些只是其實例。

41
00:01:57,810 --> 00:02:00,730
是什麼讓你這樣做的HTML
似乎沒有從什麼

42
00:02:00,730 --> 00:02:02,606
我們已經看到了這樣多遠？

43
00:02:02,606 --> 00:02:04,850
>> 觀眾：你自己定義的樣式。

44
00:02:04,850 --> 00:02:06,700
>> DAVID馬蘭：定義樣式
由你自己。

45
00:02:06,700 --> 00:02:10,280
所以定義類的東西類作為你
可能都遇到過，還是唯一

46
00:02:10,280 --> 00:02:13,800
識別文檔中的節點，以便
你可以樣式化它們。

47
00:02:13,800 --> 00:02:16,890
但更確切地說，我想說的是CSS
真的可以讓你把東西

48
00:02:16,890 --> 00:02:20,790
最後一公里，並允許您指定多
更精確的美觀性，

49
00:02:20,790 --> 00:02:24,340
而HTML在大多數情況下可以
你組織你的頁面。

50
00:02:24,340 --> 00:02:27,310
>> 而且即使有一些默認值，
就像我們看到的標籤

51
00:02:27,310 --> 00:02:30,690
一個標題標籤，它粗略地講
做事情的大和大膽。

52
00:02:30,690 --> 00:02:34,250
這是一個非常通用的定義
標籤的 - 大和大膽。

53
00:02:34,250 --> 00:02:35,260
什麼字號是什麼？

54
00:02:35,260 --> 00:02:36,080
是什麼顏色的？

55
00:02:36,080 --> 00:02:36,890
人有多大膽是什麼？

56
00:02:36,890 --> 00:02:39,830
和CSS使您可以更精細地
調類的東西。

57
00:02:39,830 --> 00:02:42,150
以及佈局，由於一些
你們都看到了。

58
00:02:42,150 --> 00:02:45,180
>> 坦率地說，CSS是有點
一片狼藉的語言。

59
00:02:45,180 --> 00:02:48,370
這是非常強大的，你可以做
從字面上，你已經任何網站

60
00:02:48,370 --> 00:02:51,880
今天看到在網絡上與它，但
它是一種在頸部疼痛。

61
00:02:51,880 --> 00:02:54,440
和你們有些人撞你的頭
對牆壁已經只是做

62
00:02:54,440 --> 00:02:58,560
一些愚蠢的中心像一個菜單
問題設置7，如果你已經得到了

63
00:02:58,560 --> 00:02:59,470
這一點了。

64
00:02:59,470 --> 00:03:01,530
>> 但要意識到，那些事
得到隨著時間的推移更加容易。

65
00:03:01,530 --> 00:03:02,820
你開始注意到模式。

66
00:03:02,820 --> 00:03:06,020
再次，谷歌將成為你的朋友
在其中你可以在各種方式

67
00:03:06,020 --> 00:03:07,220
解決這類問題。

68
00:03:07,220 --> 00:03:11,520
>> 我敢說使用CSS和HTML更
通常，你可以解決的問題

69
00:03:11,520 --> 00:03:15,910
所有這些都很多方法，很可能
還有是正確的，比你可以

70
00:03:15,910 --> 00:03:18,900
在像C，甚至
現在的PHP或JavaScript。

71
00:03:18,900 --> 00:03:21,080
只是有很多不同
方法奠定的事情了。

72
00:03:21,080 --> 00:03:22,570
>> 但是，這開始變得
凌亂的，我們說。

73
00:03:22,570 --> 00:03:26,480
只是那種混入你的HTML和
你的CSS的樣式屬性是

74
00:03:26,480 --> 00:03:27,590
有點草率。

75
00:03:27,590 --> 00:03:31,460
所以我們不是說那種，
抽象地說，那你應該

76
00:03:31,460 --> 00:03:34,050
至少開始的因素
出你的CSS可能。

77
00:03:34,050 --> 00:03:37,430
不是你的風格屬性，但至少
使用樣式標籤裡面有什麼

78
00:03:37,430 --> 00:03:38,840
網頁的一部分？

79
00:03:38,840 --> 00:03:39,560
>> 觀眾：頭。

80
00:03:39,560 --> 00:03:40,120
>> DAVID馬蘭：在頭部。

81
00:03:40,120 --> 00:03:43,270
到現在為止，我們只有標題了
在那裡，但你也可以添加一個樣式

82
00:03:43,270 --> 00:03:47,230
標記，而且你可以把你的CSS大致
發言朝向頁面的頂部。

83
00:03:47,230 --> 00:03:52,550
但後​​來我們把事情一步
我們分解了更多

84
00:03:52,550 --> 00:03:54,130
到一個單獨的文件中。

85
00:03:54,130 --> 00:03:57,240
>> 所以這兩個文件分別為
不知何故現在聯繫在一起。

86
00:03:57,240 --> 00:03:59,550
而事實上它是
標籤，這樣做。

87
00:03:59,550 --> 00:04:02,920
什麼是總體的一個
動機分解出我們的CSS

88
00:04:02,920 --> 00:04:04,057
更？

89
00:04:04,057 --> 00:04:05,280
>> 觀眾：可重用性。

90
00:04:05,280 --> 00:04:05,785
>> DAVID馬蘭：可重用性。

91
00:04:05,785 --> 00:04:06,150
對不對？

92
00:04:06,150 --> 00:04:09,470
你可能已經看到在對設置7已經
，很多的網頁時，

93
00:04:09,470 --> 00:04:12,260
購買頁面，銷售頁面，該
投資組合頁面，可能是

94
00:04:12,260 --> 00:04:13,550
結構有些類似。

95
00:04:13,550 --> 00:04:17,579
有一個CS50金融徽標上方
除非你已經決定去改變它。

96
00:04:17,579 --> 00:04:19,839
有一個頁腳在
頁面底部。

97
00:04:19,839 --> 00:04:24,315
和CSS允許，那麼你在要素吧
成一個單獨的文件，這樣，如果

98
00:04:24,315 --> 00:04:27,780
你想在全球範圍內改變一些東西
在您的整個網站，你​​可真

99
00:04:27,780 --> 00:04:29,390
只是改變它在一個地方。

100
00:04:29,390 --> 00:04:32,750
>> 但你可能會付出代價
由已分解出來的

101
00:04:32,750 --> 00:04:38,380
CSS的從我的HTML文件到一個單獨的
文件與引用它

102
00:04:38,380 --> 00:04:40,650
標籤，我們看到在週一。

103
00:04:40,650 --> 00:04:43,850
什麼可能的缺點是這個？

104
00:04:43,850 --> 00:04:48,830
回想一周前，當我們
談論HTTP和TCP / IP和如何

105
00:04:48,830 --> 00:04:52,070
互聯網的工作原理。

106
00:04:52,070 --> 00:04:53,530
這裡有什麼事？

107
00:04:53,530 --> 00:04:54,730
>> 觀眾：它需要更多的時間。

108
00:04:54,730 --> 00:04:55,470
>> DAVID馬蘭：這需要更多的時間。

109
00:04:55,470 --> 00:04:56,750
為什麼呢？

110
00:04:56,750 --> 00:04:59,450
>> 觀眾：[聽不清]。

111
00:04:59,450 --> 00:04:59,750
>> 馬蘭大衛：是的。

112
00:04:59,750 --> 00:05:01,240
因此，它可以說是需要多一點的時間。

113
00:05:01,240 --> 00:05:04,290
因為之一，CSS是很明顯
不在同一文件中。

114
00:05:04,290 --> 00:05:06,920
所以，現在你必須做出不
一個，而是兩個請求。

115
00:05:06,920 --> 00:05:11,230
並且其中的每個請求，因為我們所看到的
鉻在所謂的督察，

116
00:05:11,230 --> 00:05:15,740
我們期待在網絡選項卡，每個
這些文件都需要一個HTTP

117
00:05:15,740 --> 00:05:18,360
的要求，我們需要看到
一定量的時間。

118
00:05:18,360 --> 00:05:19,290
現在，也許它不是很多。

119
00:05:19,290 --> 00:05:20,670
也許這是只有20毫秒。

120
00:05:20,670 --> 00:05:22,260
也許這是200毫秒。

121
00:05:22,260 --> 00:05:25,530
>> 但仔細想想，如Facebook的頁面，
或CNN，還是谷歌，這是多少

122
00:05:25,530 --> 00:05:28,060
比我們的更大的示例
看著迄今。

123
00:05:28,060 --> 00:05:32,070
這些網頁可能有幾十個文件，
其中每一個可能需要一個

124
00:05:32,070 --> 00:05:33,550
一個文件的下載。

125
00:05:33,550 --> 00:05:35,800
這樣的事情，都可能導致
開始放緩。

126
00:05:35,800 --> 00:05:39,280
>> 尤其是這些天，當大家都
擁有移動電話在我們的口袋和

127
00:05:39,280 --> 00:05:43,010
較慢的互聯網連接，不必
等待幾毫秒的時間，幾

128
00:05:43,010 --> 00:05:46,110
額外多毫秒
文件實際上可能會很慢。

129
00:05:46,110 --> 00:05:50,430
延遲是描述字
這種等待，你有你

130
00:05:50,430 --> 00:05:53,110
等待時遇到
一些信息。

131
00:05:53,110 --> 00:05:54,430
>> 但有它的好處。

132
00:05:54,430 --> 00:05:56,600
所以它不是所有形式的 - 

133
00:05:56,600 --> 00:05:58,170
它實際上是一個位在這裡一個蹺蹺板。

134
00:05:58,170 --> 00:06:02,970
現在下行，但什麼瀏覽器都可以做
如果他們是聰明的，以避免

135
00:06:02,970 --> 00:06:08,870
不必請求相同的styles.css
文件又可以做什麼呢？

136
00:06:08,870 --> 00:06:09,390
>> 緩存它。

137
00:06:09,390 --> 00:06:10,370
因此，緩存 - 

138
00:06:10,370 --> 00:06:11,690
C-A-C-H-E  - 

139
00:06:11,690 --> 00:06:15,810
一般是指這裡只是為了保存
提交您所要求的第一時間，

140
00:06:15,810 --> 00:06:17,440
然後檢查你的緩存它。

141
00:06:17,440 --> 00:06:20,400
檢查你的排序存儲容器，
如果你已經有了一個

142
00:06:20,400 --> 00:06:24,520
styles.css的副本，即使其他一些
在p-組，或任何網站頁面，

143
00:06:24,520 --> 00:06:28,560
再次請求它，只是為了給
用戶相同的緩存副本。

144
00:06:28,560 --> 00:06:30,140
不要打擾請求它。

145
00:06:30,140 --> 00:06:32,560
>> 下行那裡，雖然，因為你們中的一些
已在p組絆倒。

146
00:06:32,560 --> 00:06:35,870
如果你做出改變的服務器上，
你回去的瀏覽器，你

147
00:06:35,870 --> 00:06:39,250
重新加載時，有時瀏覽器
你幫一個忙，不打擾

148
00:06:39,250 --> 00:06:43,660
重新下載您的styles.css的文件
因為，來吧，什麼是賠率

149
00:06:43,660 --> 00:06:47,620
這些樣式Facebook的使用
打算小時變更為小時或

150
00:06:47,620 --> 00:06:48,140
一天一天？

151
00:06:48,140 --> 00:06:48,800
這是相當低的。

152
00:06:48,800 --> 00:06:52,260
他們可能會隨時間而改變，但不
按分鐘或一小時。

153
00:06:52,260 --> 00:06:55,810
>> 所以一招，只是FYI在做網頁的時候
發展，往往是按住

154
00:06:55,810 --> 00:06:59,500
比如Shift鍵，然後單擊
重新加載在瀏覽器中，這將

155
00:06:59,500 --> 00:07:03,280
通常是告訴瀏覽器重裝
一切，即使你已經有

156
00:07:03,280 --> 00:07:04,180
它在緩存中。

157
00:07:04,180 --> 00:07:06,630
如此反复，積極以及不利的缺點，
但所有的人

158
00:07:06,630 --> 00:07:08,260
最終設計決策。

159
00:07:08,260 --> 00:07:11,520
>> 所以，現在，我們並不只是
在這裡結束的故事。

160
00:07:11,520 --> 00:07:15,790
如果我現在回去，回去和背部
回來了，我們開始引進不只是

161
00:07:15,790 --> 00:07:18,060
HTML，但是PHP。

162
00:07:18,060 --> 00:07:20,786
所以，通俗地說，是什麼
PHP確實讓我們做什麼？

163
00:07:20,786 --> 00:07:22,770
>> 觀眾：[聽不清]。

164
00:07:22,770 --> 00:07:24,258
>> 馬蘭大衛：那是什麼？

165
00:07:24,258 --> 00:07:25,250
>> 觀眾：介紹邏輯
入代碼。

166
00:07:25,250 --> 00:07:26,620
>> DAVID MALAN：是啊，介紹
邏輯到你的代碼。

167
00:07:26,620 --> 00:07:29,570
所以這是一個真正的編程語言
與循環，變量，和

168
00:07:29,570 --> 00:07:32,620
功能，以及所有條件，並
我們一直在使用的方式回來的東西

169
00:07:32,620 --> 00:07:33,780
因為刮的時候。

170
00:07:33,780 --> 00:07:36,780
和PHP，我們已經看到，可以用
或者在命令行中 - 它

171
00:07:36,780 --> 00:07:39,190
不必有什麼關係
與Web，即使那是

172
00:07:39,190 --> 00:07:43,150
它的真正起源和什麼時候往往
是在良好的，有利於 - 

173
00:07:43,150 --> 00:07:47,130
但你可以使用PHP僅僅通過自然
的，它有一個印刷（這一事實）

174
00:07:47,130 --> 00:07:49,660
功能和printf（）函數，
或回波（）函數。

175
00:07:49,660 --> 00:07:52,440
有辦法你一束
可以用PHP打印文本。

176
00:07:52,440 --> 00:07:56,540
>> 因此，您可以使用這個編程
語言準確地輸出

177
00:07:56,540 --> 00:07:58,460
什麼我們之前談論。

178
00:07:58,460 --> 00:08:01,360
你可以動態地生成
您的HTML。

179
00:08:01,360 --> 00:08:02,300
也許不是全部。

180
00:08:02,300 --> 00:08:06,460
也許你硬編碼的東西，像
頭和尾，並且標識，

181
00:08:06,460 --> 00:08:07,950
和你的樣式表，
而所有這一切。

182
00:08:07,950 --> 00:08:11,190
但對於像對設置7，
您要去哪裡操縱股票和

183
00:08:11,190 --> 00:08:14,690
顯示用戶的投資組合，這是
要動態地改變，你可以

184
00:08:14,690 --> 00:08:18,960
當然使用PHP和它給人的邏輯
你作為一個編程語言

185
00:08:18,960 --> 00:08:22,320
輸出子集動態
頁面。

186
00:08:22,320 --> 00:08:25,900
>> 所以，當你談論動態網站，
或web編程，這是

187
00:08:25,900 --> 00:08:27,200
你真正談論。

188
00:08:27,200 --> 00:08:31,450
使用PHP之類的語言，或事物
叫Python或Ruby或Java或

189
00:08:31,450 --> 00:08:35,900
但其他語言，來查詢數據庫
通常，或另一台服務器，

190
00:08:35,900 --> 00:08:38,580
然後動態吐出的HTML。

191
00:08:38,580 --> 00:08:42,470
>> 現在，最終的結果，順便說一句，是
大多數網站的HTML，

192
00:08:42,470 --> 00:08:45,970
包括你對設置7，可能是
將是一個巨大的爛攤子，如果

193
00:08:45,970 --> 00:08:48,060
你看看源
在瀏覽器中的代碼。

194
00:08:48,060 --> 00:08:49,010
這不是什麼大不了的事。

195
00:08:49,010 --> 00:08:51,550
此時，當我們關心
式，我們關心的

196
00:08:51,550 --> 00:08:52,740
你寫的東西。

197
00:08:52,740 --> 00:08:56,240
我們不會在乎的東西
那你的代碼輸出。

198
00:08:56,240 --> 00:08:59,520
所以不用擔心縮進
在這裡，如果是PHP的這

199
00:08:59,520 --> 00:09:01,190
實際輸出的東西。

200
00:09:01,190 --> 00:09:04,430
畢竟，瀏覽器不會在意，
和人將不會被期待

201
00:09:04,430 --> 00:09:05,400
在源反正。

202
00:09:05,400 --> 00:09:09,000
我們的工作人員，例如，將
在看你的PHP。

203
00:09:09,000 --> 00:09:13,440
>> 所以，現在讓我舉一個簡單的例子
否則為什麼這可能是有用的。

204
00:09:13,440 --> 00:09:18,620
所以坦率地說，我不記得最後
一次我用C來解決一個問題，

205
00:09:18,620 --> 00:09:19,620
現實世界中。

206
00:09:19,620 --> 00:09:22,330
這可能是在讀研究生時
我需要使用的語言

207
00:09:22,330 --> 00:09:26,710
是相當低的水平，給了我
做的東西非常高的機會

208
00:09:26,710 --> 00:09:30,720
執行真正保存盡可能多的CPU
盡我所能，在很大程度上週期

209
00:09:30,720 --> 00:09:33,990
因為我用的是龐大的數據集，
每個CPU週期數。

210
00:09:33,990 --> 00:09:37,750
坦率地說，即使是在手機之類的東西
這些天，其他設備

211
00:09:37,750 --> 00:09:39,910
在那裡，你不太有盡可能多的
內存和你不太有

212
00:09:39,910 --> 00:09:44,160
太多的CPU，採用更快的語言
仍然有吸引力。

213
00:09:44,160 --> 00:09:47,290
>> 但在現實世界中，當你只是
想拋出一些程序一起

214
00:09:47,290 --> 00:09:50,340
分析一些數據，或者你已經收集
一大堆註冊

215
00:09:50,340 --> 00:09:53,330
一些學生組，並且希望非常
快速自動發送郵件

216
00:09:53,330 --> 00:09:56,240
一個由一到每一個
註冊，你要達到

217
00:09:56,240 --> 00:09:59,240
高級語言
比C可以這麼說。

218
00:09:59,240 --> 00:10:04,060
類似PHP或Python或Ruby，
或半打其他存在

219
00:10:04,060 --> 00:10:04,550
這些天。

220
00:10:04,550 --> 00:10:07,200
但是，這三個可能
現在最時髦的權利。

221
00:10:07,200 --> 00:10:10,840
>> 這是什麼意思是，你可以打開
一個文本編輯器，如gedit或

222
00:10:10,840 --> 00:10:14,030
大部分其他事情，然後就開始
編寫代碼，而不必擔心

223
00:10:14,030 --> 00:10:17,800
編譯，而無需
真的擔心內存管理，

224
00:10:17,800 --> 00:10:20,820
雖然，一點點牢記
草率最終會回來

225
00:10:20,820 --> 00:10:24,790
如果數據集得到咬你
較大或問題得到很大。

226
00:10:24,790 --> 00:10:27,230
但是這意味著什麼
我們的是以下內容。

227
00:10:27,230 --> 00:10:29,860
>> 讓我繼續運行的拼寫
從問題設置6。

228
00:10:29,860 --> 00:10:33,480
所以這是我基於特里實施
我用大

229
00:10:33,480 --> 00:10:35,500
董事會在那裡我表現不是那麼好。

230
00:10:35,500 --> 00:10:38,720
我們會回來的一個星期的時間，
重溫那些誰也結束了頂上

231
00:10:38,720 --> 00:10:40,430
大板在我們的最後一次演講。

232
00:10:40,430 --> 00:10:44,520
但現在，讓我繼續前進，只是
運行文字，我的解決方案，我們會盡

233
00:10:44,520 --> 00:10:48,460
國王詹姆斯聖經，在這裡我們去。

234
00:10:48,460 --> 00:10:51,080
>> 因此，這些都是假想
出拼寫錯誤的單詞

235
00:10:51,080 --> 00:10:52,240
國王詹姆斯聖經。

236
00:10:52,240 --> 00:10:55,560
和我實施了
半秒總。

237
00:10:55,560 --> 00:10:58,270
所以，這不是太糟糕
特定的計算機。

238
00:10:58,270 --> 00:11:01,540
但認為多少
代碼中，我不得不寫。

239
00:11:01,540 --> 00:11:02,880
想想你有多少代碼寫。

240
00:11:02,880 --> 00:11:06,170
想想你花了多少時間在
D-大廳或你的宿舍或其它地方

241
00:11:06,170 --> 00:11:07,890
實際上編碼的解決方案。

242
00:11:07,890 --> 00:11:11,850
>> 好吧，如果我真的有一個較高的水平
語言，如PHP，請注意

243
00:11:11,850 --> 00:11:13,350
在這裡我能做些什麼。

244
00:11:13,350 --> 00:11:16,410
首先，假定，這是代替
分佈代碼。

245
00:11:16,410 --> 00:11:17,790
這是一個名為的拼寫。

246
00:11:17,790 --> 00:11:20,220
這是今天的一部分可作為
分發代碼。

247
00:11:20,220 --> 00:11:22,670
我要揮揮手最
的細節，但是這實際上是

248
00:11:22,670 --> 00:11:25,500
一個有趣的例子，如何
你可能語言移植

249
00:11:25,500 --> 00:11:28,870
像C到PHP。

250
00:11:28,870 --> 00:11:33,420
我硬是開了兩個文本窗口，
1我C版speller.c的，

251
00:11:33,420 --> 00:11:36,960
我只是在我開始翻譯
前往PHP和打字使用

252
00:11:36,960 --> 00:11:38,840
最接近的等效功能。

253
00:11:38,840 --> 00:11:40,100
>> 所以這些東西有些是不同的。

254
00:11:40,100 --> 00:11:43,730
上一次我們看到，PHP不使用
包括在以同樣的方式。

255
00:11:43,730 --> 00:11:47,050
它使用需要通常情況下，雖然
包括確實存在。

256
00:11:47,050 --> 00:11:50,330
定義稍有不同
在C＃定義，但是這

257
00:11:50,330 --> 00:11:51,890
我們如何做一個常數。

258
00:11:51,890 --> 00:11:55,860
$ ARGC事實證明，在PHP中，存在
因此，我們已經看到過。

259
00:11:55,860 --> 00:11:58,650
這些僅僅是變量，所有
開始與美元的跡象。

260
00:11:58,650 --> 00:12:00,590
回想這些都只是一堆
浮動點。

261
00:12:00,590 --> 00:12:03,970
>> 所以長話短說，歡迎你來
翻閱如果好奇的話，這是

262
00:12:03,970 --> 00:12:10,010
幾乎一條線換線轉換
C版speller.c到PHP。

263
00:12:10,010 --> 00:12:12,630
你能做到這一點再次
半打其他語言。

264
00:12:12,630 --> 00:12:14,910
>> 但有趣的是這一點。

265
00:12:14,910 --> 00:12:16,910
坦白地說，令人沮喪的
是這樣的。

266
00:12:16,910 --> 00:12:20,790
讓我繼續前進，鍵入有關
dictionary.php，我的要求

267
00:12:20,790 --> 00:12:23,670
要繼續前進，並重新實現
問題在這裡設置了6。

268
00:12:23,670 --> 00:12:27,530
>> 因此，讓我們第一次提出，在這
文件，該文件將實施

269
00:12:27,530 --> 00:12:30,550
PHP的，所以讓我開我的標籤那樣。

270
00:12:30,550 --> 00:12:34,780
讓我給自己一個全球性的
變量$尺寸變零。

271
00:12:34,780 --> 00:12:36,710
我要給
自己一個哈希表。

272
00:12:36,710 --> 00:12:38,110
為這件事，我將使用一個哈希表。

273
00:12:38,110 --> 00:12:42,070
我如何宣告一個哈希表，在PHP中呢？

274
00:12:42,070 --> 00:12:42,990
完成。

275
00:12:42,990 --> 00:12:43,980
確定。

276
00:12:43,980 --> 00:12:48,870
>> 因此，開放式支架接近支架代表
在PHP中，正如我們已經看到的？

277
00:12:48,870 --> 00:12:51,850
一個數組，而是一個數組，可以
是一個關聯數組。

278
00:12:51,850 --> 00:12:54,320
關聯數組
一種數據結構，

279
00:12:54,320 --> 00:12:55,860
聯營鍵與值。

280
00:12:55,860 --> 00:12:59,430
>> 現在在簡單的數字作為索引
陣列，這些鍵是什麼？

281
00:12:59,430 --> 00:13:02,250

282
00:13:02,250 --> 00:13:03,960
零個，一個，兩個，三個，對不對？

283
00:13:03,960 --> 00:13:08,780
舊學校的東西回來從C，但它可以
類似foo是字符串，酒吧，

284
00:13:08,780 --> 00:13:12,210
麥克斯韋，或任何這樣的字符串。

285
00:13:12,210 --> 00:13:14,240
這樣我就可以利用這一點
在短短的時刻。

286
00:13:14,240 --> 00:13:17,550
>> 讓我繼續前進，並宣布
這樣的函數 - 

287
00:13:17,550 --> 00:13:19,020
讓我們做的load（）第一。

288
00:13:19,020 --> 00:13:20,690
所以load（）函數。

289
00:13:20,690 --> 00:13:23,440
和PHP是一個有點不同，
你從字面上輸入功能，但你

290
00:13:23,440 --> 00:13:24,930
不鍵入一個返回類型。

291
00:13:24,930 --> 00:13:28,760
我要繼續前進，並說，
load（）函數應採取

292
00:13:28,760 --> 00:13:31,000
參數$字典，只是
做像C版本。

293
00:13:31,000 --> 00:13:32,510
我在做什麼，從內存中。

294
00:13:32,510 --> 00:13:34,910
>> 我建議我
要做到這一點。

295
00:13:34,910 --> 00:13:37,080
我只是做的foreach。

296
00:13:37,080 --> 00:13:40,710
我要調用一個函數叫做
文件（），通過那名

297
00:13:40,710 --> 00:13:44,990
文件，它是變量
$ $字字典。

298
00:13:44,990 --> 00:13:49,410
然後在裡面我的for循環在這裡，我
要繼續前進，並存儲在我的

299
00:13:49,410 --> 00:13:57,440
$表$詞得到真實的。

300
00:13:57,440 --> 00:13:57,918
Done（完成）。

301
00:13:57,918 --> 00:14:01,264
哦，等等。

302
00:14:01,264 --> 00:14:02,422
Done（完成）。

303
00:14:02,422 --> 00:14:02,760
確定。

304
00:14:02,760 --> 00:14:04,970
>> 那就是load（）函數
說在PHP。

305
00:14:04,970 --> 00:14:05,865
現在，為什麼這項工作？

306
00:14:05,865 --> 00:14:07,010
樣的，我欺騙在這裡。

307
00:14:07,010 --> 00:14:09,980
>> 因此，一，的foreach我們看到
簡要最後一次。

308
00:14:09,980 --> 00:14:13,680
它只是意味著你可以遍歷
沒有與我打擾數組

309
00:14:13,680 --> 00:14:16,150
n和加上加號，和所有的。

310
00:14:16,150 --> 00:14:21,350
詞典當然是文件名，
像大或小，這兩個

311
00:14:21,350 --> 00:14:22,830
我們的字典使用最後一次。

312
00:14:22,830 --> 00:14:26,715
文件是打開了文本的函數
文件，按行讀取它的路線，

313
00:14:26,715 --> 00:14:29,840
你的雙手背一個巨大的數組，
每個其元素是一個

314
00:14:29,840 --> 00:14:31,340
線從該文件。

315
00:14:31,340 --> 00:14:36,040
所以這是的FOPEN相結合，
用fread和while循環，和fclose的，

316
00:14:36,040 --> 00:14:37,080
而所有這一切。

317
00:14:37,080 --> 00:14:40,150
最後，詞只是意味著這就是
可變我要去訪問

318
00:14:40,150 --> 00:14:41,890
在這個循環中每次迭代。

319
00:14:41,890 --> 00:14:46,910
>> 因此，在短期，在這裡單行指
開拓其名稱是在文件

320
00:14:46,910 --> 00:14:50,750
字典，變量，迭代
但每次得到的時間逐行，和

321
00:14:50,750 --> 00:14:54,290
一條線，存儲在一個變量叫做字，
然後做一些事情的話。

322
00:14:54,290 --> 00:14:55,280
我想要什麼做的？

323
00:14:55,280 --> 00:14:58,110
我希望把字到我的哈希表。

324
00:14:58,110 --> 00:15:00,860
>> 好了，我可以把東西在我
哈希表類似於C

325
00:15:00,860 --> 00:15:02,140
使用方括號。

326
00:15:02,140 --> 00:15:03,660
這是我的哈希表的名稱。

327
00:15:03,660 --> 00:15:07,180
我要索引的散列
表在這個位置。

328
00:15:07,180 --> 00:15:08,920
所以不是零括起來，不括起來的。

329
00:15:08,920 --> 00:15:11,990
支架報價引文的東西，
不管這個詞是。

330
00:15:11,990 --> 00:15:15,200
而且就像你可能在你的
哈希表的工作特里，你只是存儲

331
00:15:15,200 --> 00:15:17,650
實際上是一個布爾值，隱式
或明確。

332
00:15:17,650 --> 00:15:18,260
Done（完成）。

333
00:15:18,260 --> 00:15:20,000
我存儲的值為true。

334
00:15:20,000 --> 00:15:23,150
>> 現在有幾件事情
我就割這裡的角落。

335
00:15:23,150 --> 00:15:27,720
從技術上講，有將是一個
惱人的新生產線，/ n在年底

336
00:15:27,720 --> 00:15:28,820
這些字。

337
00:15:28,820 --> 00:15:31,770
所以我也許應該調用PHP函數
所謂的印章（），這將

338
00:15:31,770 --> 00:15:33,460
毫不誇張地砍了斷。

339
00:15:33,460 --> 00:15:35,020
而且我確實需要
做一件事。

340
00:15:35,020 --> 00:15:38,380
我也許應該增加尺寸上的每個
迭代，所以我跟踪

341
00:15:38,380 --> 00:15:39,560
它是什麼全球。

342
00:15:39,560 --> 00:15:43,180
坦率地說，這是一
PHP的愚蠢問題，如果你是

343
00:15:43,180 --> 00:15:46,950
使用全局變量，你需要
明確地說，你是。

344
00:15:46,950 --> 00:15:51,670
所以，我要實際鍵入全球
$規模，全球$表，現在

345
00:15:51,670 --> 00:15:52,690
我的功能是完整的。

346
00:15:52,690 --> 00:15:57,475
>> 所以不是那麼簡單過，但
大概花了比C時間少

347
00:15:57,475 --> 00:15:58,220
版本，也許？

348
00:15:58,220 --> 00:15:58,730
確定。

349
00:15:58,730 --> 00:16:00,390
>> 所以，現在讓我們做的檢查（）函數。

350
00:16:00,390 --> 00:16:04,300
讓我們來看看這至少拿了
幾個小時就結束，它把我們的C。所以

351
00:16:04,300 --> 00:16:06,500
讓我繼續前進，並宣布
檢查的功能。

352
00:16:06,500 --> 00:16:09,070
發生在說法的話，這是
從哪兒來的拼寫。

353
00:16:09,070 --> 00:16:13,410
而我只是要檢查
下面的變量使用isset，表

354
00:16:13,410 --> 00:16:18,400
字的支架用strtolower  - 

355
00:16:18,400 --> 00:16:20,590
讓我們來平衡我所有​​的括號 - 

356
00:16:20,590 --> 00:16:24,275
然後返回true。

357
00:16:24,275 --> 00:16:27,020

358
00:16:27,020 --> 00:16:28,460
其他 - 

359
00:16:28,460 --> 00:16:30,330
這是真正的硬
這項計劃的一部分。

360
00:16:30,330 --> 00:16:31,940
否則，返回false。

361
00:16:31,940 --> 00:16:32,630
Done（完成）。

362
00:16:32,630 --> 00:16:33,460
這是檢查（）。

363
00:16:33,460 --> 00:16:34,520
>> 現在，為什麼這工作？

364
00:16:34,520 --> 00:16:37,040
那麼，一個我通過一個字，
它是一個字符串。

365
00:16:37,040 --> 00:16:41,400
二，我檢查的哈希裡面
表，誰就是所謂的$表。

366
00:16:41,400 --> 00:16:45,470
我迫使它通過調用為小寫
一個函數的tolower（）的非常相似

367
00:16:45,470 --> 00:16:48,580
C，但這樣做的整個單詞，
不是一個單一的字符。

368
00:16:48,580 --> 00:16:52,680
如果它被設置，也就是說有
是一個值設置，換言之，

369
00:16:52,680 --> 00:16:54,880
如果這是真的，那麼，
這是一個字。

370
00:16:54,880 --> 00:16:56,530
因為我把它放在那裡與負載（）。

371
00:16:56,530 --> 00:16:59,100
如果沒有，我將返回false。

372
00:16:59,100 --> 00:17:00,090
>> 現在，其他人很容易。

373
00:17:00,090 --> 00:17:03,570
功能尺寸（），我該怎麼辦呢？

374
00:17:03,570 --> 00:17:05,230
我基本上是做回​​$大小。

375
00:17:05,230 --> 00:17:07,770
但我在技術上需要
這樣做討厭的事。

376
00:17:07,770 --> 00:17:10,640
而實際上聽到了，我被切割
一個角落裡太多了。

377
00:17:10,640 --> 00:17:12,920
我真的需要做全局$表中。

378
00:17:12,920 --> 00:17:16,260
>> 但話雖如此，卸載）。

379
00:17:16,260 --> 00:17:17,380
卸載（）是驚人的。

380
00:17:17,380 --> 00:17:20,500
功能卸載（）。

381
00:17:20,500 --> 00:17:23,990
我想得到怎樣實現卸載（）？

382
00:17:23,990 --> 00:17:25,079
Done（完成）。

383
00:17:25,079 --> 00:17:25,450
確定。

384
00:17:25,450 --> 00:17:28,900
>> 所以卸載（），內存管理是
完全採取為你照顧

385
00:17:28,900 --> 00:17:31,800
像PHP和很多
的高級語言。

386
00:17:31,800 --> 00:17:32,600
因此，這是驚人的。

387
00:17:32,600 --> 00:17:36,080
像你到底為什麼我們花了過去
八加週的C寫的

388
00:17:36,080 --> 00:17:41,030
顯然很慢，真的時間
消費問題與數十小時

389
00:17:41,030 --> 00:17:42,530
根據我們的皮帶工作？

390
00:17:42,530 --> 00:17:46,110
>> 那麼，對於一件事，這可能工作
精緻的小程序。

391
00:17:46,110 --> 00:17:47,840
這當然加速了我
開發時間。

392
00:17:47,840 --> 00:17:49,790
但是，讓我們看看會發生什麼
在現實世界中。

393
00:17:49,790 --> 00:17:52,370
>> 讓我進入這個目錄
在終端窗口。

394
00:17:52,370 --> 00:17:53,370
還有的拼寫。

395
00:17:53,370 --> 00:17:56,570
並注意順便說一句，你可能會
已遇到問題該設置

396
00:17:56,570 --> 00:17:58,190
六，問題設置7。

397
00:17:58,190 --> 00:18:01,610
你不必嚴格到
結束PHP文件與書籍。php。

398
00:18:01,610 --> 00:18:05,250
如果你把一條線一樣，第一次以
極頂，這是一個特殊的行

399
00:18:05,250 --> 00:18:10,980
語法，基本上意味著找到
叫PHP和使用它的程序

400
00:18:10,980 --> 00:18:12,270
解釋這個文件。

401
00:18:12,270 --> 00:18:15,410
所以現在沒有人真正知道，
我運行一個PHP程序。

402
00:18:15,410 --> 00:18:19,860
我可以運行它，就好像它
被編譯的東西在C

403
00:18:19,860 --> 00:18:20,650
>> 但這裡的東西。

404
00:18:20,650 --> 00:18:21,600
其實，讓我們再次做到這一點。

405
00:18:21,600 --> 00:18:23,530
Dropbox/pset6 /。

406
00:18:23,530 --> 00:18:25,390
還有的拼寫。

407
00:18:25,390 --> 00:18:26,720
確定0.44秒。

408
00:18:26,720 --> 00:18:28,080
它得到了更快的這段時間。

409
00:18:28,080 --> 00:18:29,745
>> 現在，讓我們進入PHP版本。

410
00:18:29,745 --> 00:18:43,070

411
00:18:43,070 --> 00:18:44,320
很好的接觸。

412
00:18:44,320 --> 00:18:50,830

413
00:18:50,830 --> 00:18:53,285
但只是覺得多少時間
我保存於辦公時間。

414
00:18:53,285 --> 00:18:56,990

415
00:18:56,990 --> 00:18:57,790
確定。

416
00:18:57,790 --> 00:19:01,020
>> 所以3.59秒，這實際上
聽起來並不準確要么。

417
00:19:01,020 --> 00:19:03,710
那是因為長話短說，
當你打印出一個巨大的數額

418
00:19:03,710 --> 00:19:06,840
東西到屏幕上，那
本身會減慢速度。

419
00:19:06,840 --> 00:19:11,260
什麼是真正把CPU中的
家電為3.59秒，在

420
00:19:11,260 --> 00:19:15,260
相反，C，歷時0.44
秒最近。

421
00:19:15,260 --> 00:19:17,620
這是真正的命令
幅度不同。

422
00:19:17,620 --> 00:19:20,280
>> 那麼，是這個價格來自哪裡？

423
00:19:20,280 --> 00:19:21,790
為什麼這麼慢得多？

424
00:19:21,790 --> 00:19:24,220
PHP為什麼表現如此糟糕？

425
00:19:24,220 --> 00:19:25,242
達尼埃爾？

426
00:19:25,242 --> 00:19:26,550
>> 觀眾：你不會是真的
使用一個哈希表。

427
00:19:26,550 --> 00:19:27,710
>> DAVID馬蘭：我真的不
使用一個哈希表。

428
00:19:27,710 --> 00:19:28,760
所以，我有種做。

429
00:19:28,760 --> 00:19:29,870
所以這是一個關聯數組。

430
00:19:29,870 --> 00:19:33,650
最有可能的，如果人們在PHP都是
真的很聰明，他們用下面的

431
00:19:33,650 --> 00:19:39,520
引擎蓋實現一個實際的哈希表
在像C或C + +。

432
00:19:39,520 --> 00:19:41,290
不過。

433
00:19:41,290 --> 00:19:42,760
嗯。

434
00:19:42,760 --> 00:19:44,010
>> 觀眾：[聽不清]。

435
00:19:44,010 --> 00:19:46,690

436
00:19:46,690 --> 00:19:47,080
>> 馬蘭大衛：是的。

437
00:19:47,080 --> 00:19:50,780
所以，每一個我現在寫的功能 - 
實際上，你可以說，一旦更多的是

438
00:19:50,780 --> 00:19:51,480
大聲一點好嗎？

439
00:19:51,480 --> 00:19:54,509
>> 觀眾：每個函數
您收錄了很多更全面

440
00:19:54,509 --> 00:19:56,610
能力比 - 

441
00:19:56,610 --> 00:19:57,550
>> 馬蘭大衛：所以這是非常真實的。

442
00:19:57,550 --> 00:20:01,490
還有很多更多的開銷，我們是
不是真的由只注重看

443
00:20:01,490 --> 00:20:03,730
dictionary.php，我只是寫。

444
00:20:03,730 --> 00:20:08,020
與此相反，有一個整體解釋器
將在後台進行。

445
00:20:08,020 --> 00:20:12,040
事實上，當我運行這個程序時，它
沒有運行編譯零和壹

446
00:20:12,040 --> 00:20:14,290
專為我的英特爾CPU。

447
00:20:14,290 --> 00:20:19,270
相反，它是由線運行線路
PHP代碼看起來完全

448
00:20:19,270 --> 00:20:20,350
像我們鍵入它。

449
00:20:20,350 --> 00:20:22,475
所以每當你使用
解釋型語言，你

450
00:20:22,475 --> 00:20:23,850
其實也付出這個代價。

451
00:20:23,850 --> 00:20:27,010
這將需要一些時間來閱讀
您的文件從上到下，從左

452
00:20:27,010 --> 00:20:30,740
右，然後執行各
線連連。

453
00:20:30,740 --> 00:20:34,250
>> 現在在現實中，尤其是在網絡上，
實際上你可以加速這一進程

454
00:20:34,250 --> 00:20:38,660
通過緩存的結果
PHP代碼被解釋。

455
00:20:38,660 --> 00:20:41,640
而這是有道理的在網絡上，因為
如果你還沒有一個用戶喜歡

456
00:20:41,640 --> 00:20:46,300
我在這裡，但1,000或10,000個用戶，然後
也許是第一次該文件是

457
00:20:46,300 --> 00:20:49,050
訪問它的緩慢，但此後
它的速度更快。

458
00:20:49,050 --> 00:20:51,000
>> 然而，這也再一次是一個權衡。

459
00:20:51,000 --> 00:20:53,870
而對於一個類似的研究數據
設置，甚至一些大的像

460
00:20:53,870 --> 00:20:58,330
這一點，你的用戶將最終
開始覺得放緩。

461
00:20:58,330 --> 00:21:02,670
>> 因此，在短期，解釋語言
非常流行，非常受歡迎，

462
00:21:02,670 --> 00:21:06,710
坦率地說可能是你的語言
要達到解決問題的時

463
00:21:06,710 --> 00:21:08,200
到CS50後續。

464
00:21:08,200 --> 00:21:12,720
但要意識到你是多麼真的
理所當然的引擎蓋下

465
00:21:12,720 --> 00:21:15,910
真的那些過去的幾個星期中的散列
表和樹，並嘗試，

466
00:21:15,910 --> 00:21:20,770
這是用來實際上最終
實現類的東西打開支架，

467
00:21:20,770 --> 00:21:24,200
方括號，這是我們現在可以
感激地想當然。

468
00:21:24,200 --> 00:21:26,360
>> 因此，讓我們來看看現在
在本網站範圍內。

469
00:21:26,360 --> 00:21:29,890
和我上次提到的有
在PHP中一堆超全局變量的

470
00:21:29,890 --> 00:21:32,490
是不是真的有關
在命令行中。

471
00:21:32,490 --> 00:21:36,210
他們是在上下文中更相關
用在web環境的PHP。

472
00:21:36,210 --> 00:21:41,220
因此，為了在Web服務器上運行PHP
生成的東西，如HTML。

473
00:21:41,220 --> 00:21:44,540
>> 我們看了一眼$ _GET和$ _POST和
這就是自動用戶

474
00:21:44,540 --> 00:21:49,100
輸入端起來簡單，如果你提交
形成在結尾的文件。關於php的網頁

475
00:21:49,100 --> 00:21:50,460
服務器類的設備。

476
00:21:50,460 --> 00:21:53,310
但是，讓我們簡要地看
$ _COOKIE和$ _SESSION。

477
00:21:53,310 --> 00:21:56,670
>> 通俗地說，什麼是Cookie作為
你了解它的背景

478
00:21:56,670 --> 00:21:58,220
使用網絡？

479
00:21:58,220 --> 00:21:59,450
>> 觀眾：文件的計算機上。

480
00:21:59,450 --> 00:21:59,920
>> 馬蘭大衛：是的。

481
00:21:59,920 --> 00:22:03,500
它是在用戶的計算機上的文件
用任何網站栽

482
00:22:03,500 --> 00:22:04,410
你碰巧訪問。

483
00:22:04,410 --> 00:22:07,334
所以當你去到Facebook，當你去
到bankofamerica.com，當你去

484
00:22:07,334 --> 00:22:10,330
到google.com，當你去到幾乎任何
網站在世界上的這些天，

485
00:22:10,330 --> 00:22:14,850
包括cs50.net，一個cookie種植
您的計算機上，這是

486
00:22:14,850 --> 00:22:19,800
無論是存儲在RAM中的值的
計算機在您的瀏覽器的內存，或

487
00:22:19,800 --> 00:22:22,800
有時確實是一個文件存儲
在您的硬盤驅動器。

488
00:22:22,800 --> 00:22:26,960
>> ，什麼是通常存儲在該文件中
是不是你的用戶名，而不是你的

489
00:22:26,960 --> 00:22:31,060
密碼，通常不是
敏感的，除非該網站是不是這樣

490
00:22:31,060 --> 00:22:35,040
用好他們的安全，而是
它是其中一個很大的唯一標識符

491
00:22:35,040 --> 00:22:35,680
其他的事情。

492
00:22:35,680 --> 00:22:38,920
這是一個大的隨機數栽在您的
計算機，但你能想到的作為

493
00:22:38,920 --> 00:22:42,740
有點像從虛擬郵戳
一個俱樂部或者一些遊樂園的

494
00:22:42,740 --> 00:22:47,160
使工作人員介紹，業主
服務，要記住你是誰。

495
00:22:47,160 --> 00:22:51,030
因此，如果大的隨機數是一樣
12345678，儘管這顯然

496
00:22:51,030 --> 00:22:54,180
不要太隨意，認為那是的
郵戳，當您訪問

497
00:22:54,180 --> 00:22:57,930
facebook.com首次，它們
郵票上的手數。

498
00:22:57,930 --> 00:23:01,510
然後，因為你講的HTTP，您
是一個瀏覽器，並因為Facebook

499
00:23:01,510 --> 00:23:06,440
顯然可以使用相同的網絡
服務器，該協議的HTTP說，

500
00:23:06,440 --> 00:23:09,930
任何時候你隨後參觀
facebook.com，無論是第二

501
00:23:09,930 --> 00:23:13,560
以後，一個小時後，甚至在第二天，
所以只要你有沒有明確

502
00:23:13,560 --> 00:23:17,050
註銷，其有效
就像洗手。

503
00:23:17,050 --> 00:23:20,280
HTTP說，你應該出示您的
用手戳你每次

504
00:23:20,280 --> 00:23:22,020
返回到該網站。

505
00:23:22,020 --> 00:23:24,390
>> Facebook上有什麼不那麼它們是
看那個郵戳及

506
00:23:24,390 --> 00:23:26,850
他們說，哦，123456789。

507
00:23:26,850 --> 00:23:30,260
我不知道第一眼就這
是大衛·馬蘭在劍橋，

508
00:23:30,260 --> 00:23:34,690
馬薩諸塞州，但他們可以檢查自己
數據庫和說，哦，這個人

509
00:23:34,690 --> 00:23:39,930
在其計算機上，我們種植123456789
是大衛·馬蘭劍橋，

510
00:23:39,930 --> 00:23:40,440
馬薩諸塞州。

511
00:23:40,440 --> 00:23:46,000
讓我們顯示，用戶隨後他的個人資料
頁面或他的新聞聯播。

512
00:23:46,000 --> 00:23:49,660
>> 但這裡有一個問題，如果這
是如何網絡確實。

513
00:23:49,660 --> 00:23:51,390
讓我們來看看一個簡單的例子。

514
00:23:51,390 --> 00:23:55,190
其實，讓我們去說facebook.com。

515
00:23:55,190 --> 00:23:58,130
但在此之前，我們可以去那裡，讓
我去進取，不斷開拓Chrome的

516
00:23:58,130 --> 00:23:59,790
這裡督察下降。

517
00:23:59,790 --> 00:24:01,140
讓我看看“網絡”選項卡。

518
00:24:01,140 --> 00:24:06,020
現在讓我們繼續前進，並鍵入
在https://facebook.com。

519
00:24:06,020 --> 00:24:09,410
我這樣做，讓我們看不到
所有那些重定向和廢物

520
00:24:09,410 --> 00:24:10,660
經過了那麼多的時間去尋找。

521
00:24:10,660 --> 00:24:12,690
讓我按回車鍵。

522
00:24:12,690 --> 00:24:13,130
>> 好的。

523
00:24:13,130 --> 00:24:14,580
我們看到一大堆的請求。

524
00:24:14,580 --> 00:24:15,640
有自帶臉譜。

525
00:24:15,640 --> 00:24:16,930
有一個整體的一堆文件。

526
00:24:16,930 --> 00:24:19,290
而在這裡，我提到每
去年延遲時間，這是

527
00:24:19,290 --> 00:24:21,240
很多的HTTP請求。

528
00:24:21,240 --> 00:24:23,700
但是，第一個可能是
最有趣的。

529
00:24:23,700 --> 00:24:26,420
>> 因此，讓我們在這裡向下滾動，
我會在第二放大。

530
00:24:26,420 --> 00:24:29,090
這將是一種
一個爛攤子，但讓我們來看看。

531
00:24:29,090 --> 00:24:31,660
Facebook正在向我們發送
一大堆東西。

532
00:24:31,660 --> 00:24:33,490
>> 但是，哇，有意思。

533
00:24:33,490 --> 00:24:37,880
他們種植不是一個，而是四個
到這裡我的手手郵票。

534
00:24:37,880 --> 00:24:40,400
設置Cookie，設置Cookie，設置的cookie，
設置的cookie。

535
00:24:40,400 --> 00:24:44,030
有幾個功能。

536
00:24:44,030 --> 00:24:46,170
他們提一些
樣的到期。

537
00:24:46,170 --> 00:24:50,090
它看起來像Facebook是希望
記得我，直到2015年。

538
00:24:50,090 --> 00:24:53,670
所以這是大概的時間
我必須註銷或他們就會

539
00:24:53,670 --> 00:24:55,710
自動假設我
不回來了。

540
00:24:55,710 --> 00:24:57,840
所以，這實際上是一個體面
的時間量。

541
00:24:57,840 --> 00:24:59,170
>> 還有一些其他的
事情就在這裡。

542
00:24:59,170 --> 00:25:03,036
此cookie被強行
刪除的說，它在1970年屆滿

543
00:25:03,036 --> 00:25:04,460
餅乾之前存在。

544
00:25:04,460 --> 00:25:06,510
因此，瀏覽器只是
承擔OK，就像

545
00:25:06,510 --> 00:25:07,910
洗滌雙手郵票。

546
00:25:07,910 --> 00:25:11,240
>> 但現在當我的瀏覽器，使
後續請求 - 

547
00:25:11,240 --> 00:25:14,340
讓我繼續前進，這樣做
並重新裝載。

548
00:25:14,340 --> 00:25:18,170
現在讓我回滾動
頂部的請求，並下井

549
00:25:18,170 --> 00:25:20,760
在這裡，請求頭。

550
00:25:20,760 --> 00:25:21,390
請注意這一點。

551
00:25:21,390 --> 00:25:25,280
所以我現在在不響應頭
但要注意它說，請求頭。

552
00:25:25,280 --> 00:25:29,220
注意到我的瀏覽器的一部分，
其要求有擊球重裝後

553
00:25:29,220 --> 00:25:32,780
發送至少以下
信息。

554
00:25:32,780 --> 00:25:34,670
沒有設置的cookie，但cookie中。

555
00:25:34,670 --> 00:25:38,750
因此，這是行，HTTP頭，所以
說話，我的瀏覽器排序

556
00:25:38,750 --> 00:25:43,340
沒有我知道它的呈現
我的手為Facebook的檢查。

557
00:25:43,340 --> 00:25:46,020
>> 因此，這些cookie可以
使用的是什麼？

558
00:25:46,020 --> 00:25:49,420
要記住你是誰，或記得如何
多少次你去過那裡，或

559
00:25:49,420 --> 00:25:50,280
真的沒有什麼東西。

560
00:25:50,280 --> 00:25:52,742
>> 因此，這裡是counter.php。

561
00:25:52,742 --> 00:25:53,780
並讓我的字體放大。

562
00:25:53,780 --> 00:25:58,380
而每一次我重新加載頁面，請注意
記住多少次

563
00:25:58,380 --> 00:25:59,250
我一直在那裡。

564
00:25:59,250 --> 00:26:00,570
嗯，這是不是所有的，令人印象深刻。

565
00:26:00,570 --> 00:26:03,140
讓我們只關閉該選項卡，
現在讓我們回到

566
00:26:03,140 --> 00:26:07,860
http://localhost/counter.php。

567
00:26:07,860 --> 00:26:08,970
>> 哦，那很有趣。

568
00:26:08,970 --> 00:26:10,960
它仍然記得，即使
雖然我關閉標籤。

569
00:26:10,960 --> 00:26:14,010
坦率地說，如果我關閉瀏覽器，
如果以正確的方式實現，我

570
00:26:14,010 --> 00:26:18,950
還記得該用戶
誰他或她是第一次，

571
00:26:18,950 --> 00:26:22,840
只有一次，我去到Chrome的菜單，
在這裡在這裡，去

572
00:26:22,840 --> 00:26:25,990
歷史，並單擊“清除瀏覽數據，
你們有些人可能有

573
00:26:25,990 --> 00:26:33,050
過去，只有這樣，你的餅乾
實際上在網上被刪除

574
00:26:33,050 --> 00:26:33,970
的發展。

575
00:26:33,970 --> 00:26:35,340
>> 所以，如果我們去 - 

576
00:26:35,340 --> 00:26:37,080
讓收盤上漲gedit的。

577
00:26:37,080 --> 00:26:38,910
如果我們現在去這個文件。

578
00:26:38,910 --> 00:26:44,210
讓我進入我們的
虛擬主機/本地/市民，並讓我做

579
00:26:44,210 --> 00:26:46,340
counter.php。

580
00:26:46,340 --> 00:26:48,350
請注意，這是一個相當
簡單的程序。

581
00:26:48,350 --> 00:26:50,250
這是一個非常簡單的網站。

582
00:26:50,250 --> 00:26:51,770
>> 因此，在文件頂部
是僅有評論。

583
00:26:51,770 --> 00:26:54,930
但在這裡，你可能是一個新的行
已經看到，已經在一套七對，

584
00:26:54,930 --> 00:26:56,000
在session_start（）。

585
00:26:56,000 --> 00:27:00,380
這是一條線的PHP代碼，
基本上告訴Web服務器，

586
00:27:00,380 --> 00:27:03,400
一定要杜絕的手，使
一定要檢查手的郵票。

587
00:27:03,400 --> 00:27:06,810
這是這一行的，它
這一進程我們。

588
00:27:06,810 --> 00:27:09,510
然後注意到我剛剛拿到了
這裡的兩個分支。

589
00:27:09,510 --> 00:27:14,150
如果計數器的關鍵，在這裡面
特殊的全局變量稱為

590
00:27:14,150 --> 00:27:18,010
$ _SESSION  - 換句話說，
如果有一些價值 - 

591
00:27:18,010 --> 00:27:22,440
讓我們得到它，並將其存儲在本地
變量名為$計數器。

592
00:27:22,440 --> 00:27:27,000
否則，我們的分配計數器
默認值0。

593
00:27:27,000 --> 00:27:30,320
>> 現在，這裡的一個方面的PHP
既是祝福，也是詛咒。

594
00:27:30,320 --> 00:27:32,080
PHP是一點不馬虎。

595
00:27:32,080 --> 00:27:35,160
因此，而在C語言中，會是什麼
計數器的範圍已經

596
00:27:35,160 --> 00:27:36,725
無論是在這裡或這裡？

597
00:27:36,725 --> 00:27:39,270

598
00:27:39,270 --> 00:27:41,690
>> 這本來被限制
那些大括號。

599
00:27:41,690 --> 00:27:42,090
你猜怎麼著？

600
00:27:42,090 --> 00:27:46,920
在PHP中，它的存在甚至外面的那些
大括號，在這裡，在這裡，

601
00:27:46,920 --> 00:27:49,120
在這裡，在這裡，
甚至向下跌破。

602
00:27:49,120 --> 00:27:52,400
所以我說這是一個祝福在這個意義上
你不認為，作為

603
00:27:52,400 --> 00:27:54,070
我們最大的努力幾週前做。

604
00:27:54,070 --> 00:27:56,880
但它也是一個位一個詛咒
無論你在哪裡使用變量

605
00:27:56,880 --> 00:28:00,020
PHP的，至少在這樣的程序，
它的全局訪問

606
00:28:00,020 --> 00:28:01,170
或好或壞。

607
00:28:01,170 --> 00:28:06,130
所以，你必須要記住，現在
可能是不確定的變量。

608
00:28:06,130 --> 00:28:07,640
您可能已經定義了他們在別處。

609
00:28:07,640 --> 00:28:09,460
>> 但是我最終要做的事情嗎？

610
00:28:09,460 --> 00:28:13,160
我要去，全球內儲存
的值，作為變量

611
00:28:13,160 --> 00:28:17,060
計數器鍵的結果
做計數器加1。

612
00:28:17,060 --> 00:28:18,910
因此，這僅僅是算術
做

613
00:28:18,910 --> 00:28:20,590
該計數器遞增。

614
00:28:20,590 --> 00:28:24,850
而事實上，我存儲
在這裡的返回值是手段

615
00:28:24,850 --> 00:28:29,970
基本上是將數據庫更新到
記住，一直是用戶123456789

616
00:28:29,970 --> 00:28:31,010
這裡兩次。

617
00:28:31,010 --> 00:28:33,780
而當我再次這樣做，下一次我
重新加載頁面時，它要檢查

618
00:28:33,780 --> 00:28:36,710
我的手蓋章，說，哦，
現在有用戶123456789

619
00:28:36,710 --> 00:28:38,410
來過這裡三次。

620
00:28:38,410 --> 00:28:43,390
>> 還等什麼PHP和類似的語言
這樣做對我們來說是他們盤算

621
00:28:43,390 --> 00:28:47,720
如何以及在何處以及多長時間
存儲在這個特殊值

622
00:28:47,720 --> 00:28:48,830
超全局。

623
00:28:48,830 --> 00:28:52,750
而這個超級全局下一次我
訪問的頁面是有點神奇

624
00:28:52,750 --> 00:28:57,440
預填充，填充值
在那裡你訪問的最後時間，

625
00:28:57,440 --> 00:29:02,310
這是否是在一秒鐘前，一個星期
前，或在2013年，我們現在談

626
00:29:02,310 --> 00:29:03,790
大約在2015年。

627
00:29:03,790 --> 00:29:07,600
PHP和Web服務器打理
的所有的給你。

628
00:29:07,600 --> 00:29:08,850
>> 觀眾：[聽不清]。

629
00:29:08,850 --> 00:29:11,900

630
00:29:11,900 --> 00:29:15,760
>> DAVID馬蘭：PHP中的變量是
本質上始終是全局的，除非你

631
00:29:15,760 --> 00:29:18,400
在函數中聲明它們，
然後他們是本地的

632
00:29:18,400 --> 00:29:19,420
該功能只。

633
00:29:19,420 --> 00:29:22,300
但是因為我沒有寫任何
功能，他們現在有效

634
00:29:22,300 --> 00:29:25,090
全球在我這裡整個文件。

635
00:29:25,090 --> 00:29:26,040
>> 觀眾：是否有辦法
讓他們本地的？

636
00:29:26,040 --> 00:29:28,470
>> 馬蘭國寶：有沒有
方法，使他們本地的？

637
00:29:28,470 --> 00:29:30,680
只有通過包裝成的功能。

638
00:29:30,680 --> 00:29:32,790
這在最新版本的
PHP中，你可以用這個做

639
00:29:32,790 --> 00:29:34,130
一個匿名函數。

640
00:29:34,130 --> 00:29:35,930
但更多的，在
JavaScript的情況下。

641
00:29:35,930 --> 00:29:37,260
但簡單的答案是否定的。

642
00:29:37,260 --> 00:29:40,888
較長的答案是肯定的。

643
00:29:40,888 --> 00:29:42,380
尼斯。

644
00:29:42,380 --> 00:29:43,380
良好的測驗問題。

645
00:29:43,380 --> 00:29:43,930
好的。

646
00:29:43,930 --> 00:29:47,760
>> 所以最後，頁面本身是
其實很簡單。

647
00:29:47,760 --> 00:29:51,470
請注意，一旦我退出PHP模式，召回
所有的這些東西下來

648
00:29:51,470 --> 00:29:53,700
下面只是要得到吐
出生到瀏覽器。

649
00:29:53,700 --> 00:29:57,050
這是很好的，因為我也想送
一些HTML，但我確實希望用戶

650
00:29:57,050 --> 00:29:59,140
動態更新HTML。

651
00:29:59,140 --> 00:30:03,930
我可以做到這一點的方法之一是進行排序
非常迅速回落到PHP

652
00:30:03,930 --> 00:30:07,730
模式，採用開放式支架問號
等號，然後輸出值

653
00:30:07,730 --> 00:30:08,650
的計數器。

654
00:30:08,650 --> 00:30:12,360
>> 或者，如果這看起來有點神秘，這
等號，其實只是一些

655
00:30:12,360 --> 00:30:16,190
語法糖這
的printf（$計數器）。

656
00:30:16,190 --> 00:30:19,160
但坦率地說，這只是一點點醜
和一點點討厭的類型。

657
00:30:19,160 --> 00:30:23,660
所以PHP的非常漂亮，提供此功能
在那裡你可以說它更

658
00:30:23,660 --> 00:30:25,450
簡潔地以同樣的方式。

659
00:30:25,450 --> 00:30:26,940
>> 那麼什麼是底下怎麼回事
油煙機？

660
00:30:26,940 --> 00:30:31,210
讓我們來快速瀏覽一下網絡
選項卡這裡counter.php。

661
00:30:31,210 --> 00:30:35,090
讓我繼續前進，第一
讓我們來清理cookies。

662
00:30:35,090 --> 00:30:38,670
因為讓我們清除瀏覽數據
剛開始的時候。

663
00:30:38,670 --> 00:30:39,680
現在，讓我們回到了這裡。

664
00:30:39,680 --> 00:30:41,340
現在讓我們來重新加載頁面。

665
00:30:41,340 --> 00:30:42,170
而我回到零。

666
00:30:42,170 --> 00:30:44,810
因為我的手的郵票已經洗淨，
我現在得到一個新的cookie。

667
00:30:44,810 --> 00:30:48,780
>> 事實上，如果我看網絡選項卡，
看響應頭，另行通知

668
00:30:48,780 --> 00:30:51,960
該設備是給我
他的名字是有點一個cookie

669
00:30:51,960 --> 00:30:55,820
隨意但那種，
合理，PHPSESSID。

670
00:30:55,820 --> 00:30:58,440
並且它送我這真的
大隨機數。

671
00:30:58,440 --> 00:30:59,440
這不是不少。

672
00:30:59,440 --> 00:31:00,390
它不是相當的十六進制。

673
00:31:00,390 --> 00:31:03,600
這是某種字母數字字符串，
但據推測這是隨機的。

674
00:31:03,600 --> 00:31:06,830
那就是郵戳所以
說話那我指的是。

675
00:31:06,830 --> 00:31:11,960
>> 同時，如果我重裝一下，然後
看看這個第二行第二個我

676
00:31:11,960 --> 00:31:17,600
要求，現在通知我的要求
頭文件包含PHPSESSID等於這一點，

677
00:31:17,600 --> 00:31:19,390
沒有設置cookie的，但只是餅乾。

678
00:31:19,390 --> 00:31:22,950
這是我的瀏覽器的演示文稿
我手裡的郵票。

679
00:31:22,950 --> 00:31:28,820
>> 所以，現在作為傳情，我們將討論更多
這在一個星期左右，但

680
00:31:28,820 --> 00:31:31,590
以什麼方式這使你
脆弱的，你的Facebook帳戶

681
00:31:31,590 --> 00:31:34,137
脆弱的，和其他類似
賬戶脆弱？

682
00:31:34,137 --> 00:31:35,510
>> 觀眾：如果有人有你的cookie。

683
00:31:35,510 --> 00:31:36,750
>> DAVID MALAN：是啊，如果有人
有你的cookie。

684
00:31:36,750 --> 00:31:39,920
我是說真的，就像你們中的一些
可能試圖在像一個俱樂部或

685
00:31:39,920 --> 00:31:44,030
遊樂園，如果你嘗試的東西
這樣的複製郵票，雖然

686
00:31:44,030 --> 00:31:47,560
倒退到另一個人的手，
然後他或她提出它作為

687
00:31:47,560 --> 00:31:53,250
自己的，如果它實際上看起來確實
同樣，123456789，那麼網絡

688
00:31:53,250 --> 00:31:57,980
服務器顯然只是要
相信，該用戶就是你。

689
00:31:57,980 --> 00:32:01,450
>> 這確實是一個根本性的
威脅你使用cookies的任何時間

690
00:32:01,450 --> 00:32:05,420
因為如果有人只是欺騙所以
說出你的cookie，計算出它是什麼

691
00:32:05,420 --> 00:32:08,660
是，無論是真正的將其複製
通過看你的電腦

692
00:32:08,660 --> 00:32:09,890
和被喜歡，確定。

693
00:32:09,890 --> 00:32:14,520
大衛的cookie是JJ3JIK等等，
然後他們夠聰明，知道

694
00:32:14,520 --> 00:32:18,080
怎麼樣的手動發送
從瀏覽器或一個cookie

695
00:32:18,080 --> 00:32:22,350
計劃他們寫，他們完全可以
登錄到一個網站，你​​。

696
00:32:22,350 --> 00:32:28,560
它是不是很難假裝
別人，除非我們重新對集

697
00:32:28,560 --> 00:32:30,790
2，介紹什麼？

698
00:32:30,790 --> 00:32:32,065
>> 觀眾：密碼學。

699
00:32:32,065 --> 00:32:33,860
>> DAVID馬蘭：有點
密碼學位。

700
00:32:33,860 --> 00:32:36,550
簡單的密碼系統，至少在
標準版，但加密

701
00:32:36,550 --> 00:32:36,870
不過。

702
00:32:36,870 --> 00:32:37,410
少。

703
00:32:37,410 --> 00:32:41,440
所以，事實證明，如果你加密所有的
這些頭文件使用的東西，你

704
00:32:41,440 --> 00:32:48,770
現在可能知道作為SSL的詳細親切，
安全套接字層，或https://開頭的URL，

705
00:32:48,770 --> 00:32:51,890
那麼所有的這些事情，我們一直
瞥了一眼實際上是加密的，

706
00:32:51,890 --> 00:32:54,800
這意味著它就像你
無法讀取郵戳。

707
00:32:54,800 --> 00:32:59,350
只有facebook.com可以了，或者google.com，
或者在這種情況下，該設備可以

708
00:32:59,350 --> 00:33:00,550
閱讀郵戳。

709
00:33:00,550 --> 00:33:04,020
>> 可悲的是，雖然，並再次，這是
太合適了NSA的東西

710
00:33:04,020 --> 00:33:06,410
後期，甚至是SSL是易碎的。

711
00:33:06,410 --> 00:33:09,850
它實際上並不難
即使破解了加密。

712
00:33:09,850 --> 00:33:12,040
沒那麼通過破解加密了，
但通過欺騙的

713
00:33:12,040 --> 00:33:15,720
瀏覽器到解密
數據過早。

714
00:33:15,720 --> 00:33:17,880
但同樣，我們會挑逗你
與之前長。

715
00:33:17,880 --> 00:33:21,242
現在，只是害怕。

716
00:33:21,242 --> 00:33:23,070
它是可悲的一種真實。

717
00:33:23,070 --> 00:33:23,760
>> 好的。

718
00:33:23,760 --> 00:33:27,910
因此，如果沒有這個現在離開我們呢？

719
00:33:27,910 --> 00:33:29,010
那麼，讓我們做到這一點。

720
00:33:29,010 --> 00:33:31,790
讓我們繼續前進，並採取快速
傳情之前，我們休息一下。

721
00:33:31,790 --> 00:33:33,790
我想我們會一直這樣時間長一點
今天，但我們要潛入

722
00:33:33,790 --> 00:33:37,850
一些全新的性感，這將
激起你的食慾，甚至更多。

723
00:33:37,850 --> 00:33:38,950
所以這是玩笑話。

724
00:33:38,950 --> 00:33:41,520
>> 因此SQL，我們開始談論
曾經如此短暫最後一次。

725
00:33:41,520 --> 00:33:44,670
你會真正得到你的手臟
有一些它在對設置7。

726
00:33:44,670 --> 00:33:46,480
和通俗地說，這是什麼SQL  - 

727
00:33:46,480 --> 00:33:47,110
S-Q-L  - 

728
00:33:47,110 --> 00:33:49,850
為你做點什麼？

729
00:33:49,850 --> 00:33:50,310
這是什麼？

730
00:33:50,310 --> 00:33:51,546
是啊。

731
00:33:51,546 --> 00:33:53,240
>> 觀眾：讓您存取數據。

732
00:33:53,240 --> 00:33:53,360
>> 馬蘭大衛：是的。

733
00:33:53,360 --> 00:33:55,120
它讓你的數據訪問
在數據庫中。

734
00:33:55,120 --> 00:33:56,710
結構化查詢語言。

735
00:33:56,710 --> 00:33:59,890
這實質上是一個
編程語言。

736
00:33:59,890 --> 00:34:03,400
有它的功能，
我們不會在課堂上什至使用。

737
00:34:03,400 --> 00:34:04,710
但是你可以有效地
定義函數。

738
00:34:04,710 --> 00:34:06,870
他們被稱為存儲
在SQL過程。

739
00:34:06,870 --> 00:34:09,860
但我們會保持它相當簡單，只是
使用它的一些基本操作

740
00:34:09,860 --> 00:34:14,320
如選擇數據，插入數據，
更新數據和刪除數據。

741
00:34:14,320 --> 00:34:17,400
>> 而你真的可以想到一個數據庫，
就像一個SQL數據庫，只需

742
00:34:17,400 --> 00:34:18,800
即Microsoft Excel中。

743
00:34:18,800 --> 00:34:21,989
因為SQL是指一個關係
數據庫，其中

744
00:34:21,989 --> 00:34:23,480
就只是意味著表。

745
00:34:23,480 --> 00:34:24,739
行和列。

746
00:34:24,739 --> 00:34:27,929
所以，只要你可以把電子表格
這樣或谷歌文檔，

747
00:34:27,929 --> 00:34:32,460
你可以放入一個SQL數據庫
通過聲明一個表。

748
00:34:32,460 --> 00:34:34,800
>> 現在，你如何實際訪問
這些信息？

749
00:34:34,800 --> 00:34:38,239
那麼，與命令或
查詢是這樣的。

750
00:34:38,239 --> 00:34:40,199
SELECT，INSERT，UPDATE和DELETE。

751
00:34:40,199 --> 00:34:44,489
並且在大多數情況下，這些都是
你需要到四只成份

752
00:34:44,489 --> 00:34:47,370
做的東西很有力
在問題設置7。

753
00:34:47,370 --> 00:34:49,940
>> 現在又回到了一天，你居然會
在一個數據庫交互

754
00:34:49,940 --> 00:34:52,730
黑色和白色終端窗口
閃爍的提示是這樣的。

755
00:34:52,730 --> 00:34:56,370
而我們在運行數據庫
器具被稱為MySQL的，這是

756
00:34:56,370 --> 00:34:58,560
自由和開放源碼的數據庫引擎。

757
00:34:58,560 --> 00:35:02,240
如果谷歌和閱讀維基百科
的文章，你就會知道這個名字是

758
00:35:02,240 --> 00:35:05,060
對於一些有點過渡
Linux版本。

759
00:35:05,060 --> 00:35:10,460
瑪麗亞數據庫實際上是一個
叉這麼說的MySQL。

760
00:35:10,460 --> 00:35:12,740
>> 長話短說，甲骨文收購了MySQL。

761
00:35:12,740 --> 00:35:13,870
甲骨文是一家大公司。

762
00:35:13,870 --> 00:35:17,010
人們一直擔心，它會
不再停留相當開源，

763
00:35:17,010 --> 00:35:20,930
所以這是MySQL的只是一個副本，這是
還是免費的，還是開源的，

764
00:35:20,930 --> 00:35:23,550
默認安裝在Fedora Linux系統。

765
00:35:23,550 --> 00:35:26,130
>> 但是，這是一種在痛
脖子上結識一

766
00:35:26,130 --> 00:35:27,310
數據庫這種方式。

767
00:35:27,310 --> 00:35:30,560
所以我們在CS50包括家電
一個免費的開源工具，稱為

768
00:35:30,560 --> 00:35:31,700
phpMyAdmin的。

769
00:35:31,700 --> 00:35:33,940
僅僅是巧合
它是用PHP編寫的。

770
00:35:33,940 --> 00:35:36,450
有沒有根本
需要為PHP在這裡。

771
00:35:36,450 --> 00:35:40,090
但是這僅僅是一個基於Web的工具，
我們免費下載，安裝在

772
00:35:40,090 --> 00:35:43,850
家電，這使我們能夠有一個
與該圖形用戶界面

773
00:35:43,850 --> 00:35:48,610
探索對集合7個數據庫
要創建新的數據庫，

774
00:35:48,610 --> 00:35:51,980
說為自己最後的項目，如果你願意
像，並最終創造

775
00:35:51,980 --> 00:35:55,900
動態網站像CS50財經
使您可以查詢數據和

776
00:35:55,900 --> 00:35:58,140
動態更新數據。

777
00:35:58,140 --> 00:36:01,420
>> 你不會有只使用
一個簡單的文本文件或CSV。

778
00:36:01,420 --> 00:36:05,950
實際上，你可以使用智能資料庫
程序使您可以執行更多

779
00:36:05,950 --> 00:36:10,240
不僅僅是閱讀複雜的查詢
通過線性的一切。

780
00:36:10,240 --> 00:36:14,150
>> 因此，例如，這就是我們給
你對P-集合7個盒子。

781
00:36:14,150 --> 00:36:18,280
這是顯然的至少一個表
三列，其中之一是

782
00:36:18,280 --> 00:36:21,450
用戶名，其中一個是散，
而另一個是識別碼。

783
00:36:21,450 --> 00:36:26,200
>> 但有趣的東西，只是為了
這裡梳理出一個念頭，用戶名

784
00:36:26,200 --> 00:36:29,270
大概是已經獨一無二的，對不對？

785
00:36:29,270 --> 00:36:31,190
我的意思是，幾乎所有的網站，如果
你有一個用戶名，有

786
00:36:31,190 --> 00:36:32,370
不能由兩個凱撒。

787
00:36:32,370 --> 00:36:33,440
不能有兩個malans。

788
00:36:33,440 --> 00:36:34,950
不能有兩個jharvards。

789
00:36:34,950 --> 00:36:35,600
其獨特的。

790
00:36:35,600 --> 00:36:38,610
否則，他們不知道哪個
jharvard它實際上是。

791
00:36:38,610 --> 00:36:42,710
所以，可能是什麼動機也
具有在左邊的第三列

792
00:36:42,710 --> 00:36:46,970
還有所謂的ID，它看起來像一個
數字是同樣獨特之處？

793
00:36:46,970 --> 00:36:51,300
感覺有點多餘
我第一眼。

794
00:36:51,300 --> 00:36:54,910
為什麼它可能引人注目的有
不僅是唯一的用戶名，

795
00:36:54,910 --> 00:36:56,837
而且唯一的數字？

796
00:36:56,837 --> 00:36:59,460
>> 觀眾：他們可以有
相同的密碼。

797
00:36:59,460 --> 00:37:01,720
>> DAVID馬蘭：人們可能有
相同的密碼，確保萬無一失。

798
00:37:01,720 --> 00:37:03,900
這可能完全發生。

799
00:37:03,900 --> 00:37:08,270
但是，如果他們有這樣的唯一的用戶名，我
會說，其實並不

800
00:37:08,270 --> 00:37:11,630
事，因為如果他們在鍵入他們的
用戶名，我只需要檢查他們的

801
00:37:11,630 --> 00:37:15,060
密碼，其自己的哈希值。

802
00:37:15,060 --> 00:37:15,970
否則為什麼？

803
00:37:15,970 --> 00:37:17,950
>> 觀眾：更快速的搜尋。

804
00:37:17,950 --> 00:37:18,680
>> DAVID馬蘭：更快速的搜尋。

805
00:37:18,680 --> 00:37:19,548
為什麼呢？

806
00:37:19,548 --> 00:37:21,460
>> 觀眾：ID是只有一個。

807
00:37:21,460 --> 00:37:24,040
>> DAVID馬蘭：ID是一個字符，
或者更確切地說，它是一個數字，

808
00:37:24,040 --> 00:37:26,910
因此它可能是32位
或者類似的東西。

809
00:37:26,910 --> 00:37:30,270
而用戶名，顯然傑森
赫塞豪恩的上升有幾分

810
00:37:30,270 --> 00:37:33,900
可笑的長，而且它要
帶我去了很多時間轉換為字符串

811
00:37:33,900 --> 00:37:40,910
比較H-I-R-S-C-H-H-O-R-N，也許
一/ 0或類似的東西，為了

812
00:37:40,910 --> 00:37:45,100
查找傑森，而不是僅僅
說給我的用戶排名第二。

813
00:37:45,100 --> 00:37:46,510
這是32位。

814
00:37:46,510 --> 00:37:48,550
它是一個單一的詮釋
你要比較。

815
00:37:48,550 --> 00:37:52,150
事實上，這也正是為什麼數據庫
傾向於分配唯一的ID來

816
00:37:52,150 --> 00:37:53,710
列在其中。

817
00:37:53,710 --> 00:37:56,280
>> 現在，還有什麼其他的數據類型是有
除了INT和明顯

818
00:37:56,280 --> 00:37:57,160
像這樣的字符串？

819
00:37:57,160 --> 00:37:59,700
嗯，更正確，
SQL數據庫，如

820
00:37:59,700 --> 00:38:02,060
MySQL中，有煤焦領域。

821
00:38:02,060 --> 00:38:05,320
和char一個有點誤導
不是一個單一的煤焦。

822
00:38:05,320 --> 00:38:10,290
在MySQL數據庫是一個char場
一個或多個字符，但它是一個

823
00:38:10,290 --> 00:38:11,780
固定數目的字符。

824
00:38:11,780 --> 00:38:15,710
>> 因此，舉例來說，如果我去到
phpMyAdmin的，因為你可能已經或

825
00:38:15,710 --> 00:38:21,340
很快將問題設置七，和我一起去
到我的數據庫，只是為了好玩，

826
00:38:21,340 --> 00:38:25,700
讓我們來創建一個新的表稱為
測試只有兩列。

827
00:38:25,700 --> 00:38:27,160
我會然後單擊“轉到”。

828
00:38:27,160 --> 00:38:30,070
這將成為相當熟悉，
尤其是當你鼓搗

829
00:38:30,070 --> 00:38:31,130
在自己的周圍。

830
00:38:31,130 --> 00:38:34,140
在這裡，我可以鍵入ID來創建
INT類型的新表。

831
00:38:34,140 --> 00:38:37,770
但在這裡我可以鍵入用戶名
重新早些時候表。

832
00:38:37,770 --> 00:38:40,700
注意到我有一大堆
類型可供選擇。

833
00:38:40,700 --> 00:38:43,610
>> 而這也就是為什麼phpMyAdmin的
是一種不錯的。

834
00:38:43,610 --> 00:38:46,770
這是一種自我教學，
可以只是一種點，然後按一下，

835
00:38:46,770 --> 00:38:50,730
在下拉菜單中，並推斷
，什麼權力SQL給您。

836
00:38:50,730 --> 00:38:54,090
>> 事實上，如果讓我選擇CHAR，然後我
有指定長度，或者如何

837
00:38:54,090 --> 00:38:55,940
許多價值觀，多少個字符。

838
00:38:55,940 --> 00:39:00,090
所以很普遍的價值觀之類的東西
255，但是這是一個有點長。

839
00:39:00,090 --> 00:39:02,250
通常是8個用戶名。

840
00:39:02,250 --> 00:39:03,590
但是，這是小了點，這些天。

841
00:39:03,590 --> 00:39:05,430
因此，這是一個設計決定。

842
00:39:05,430 --> 00:39:08,630
最多8個字符，
32，255，1000？

843
00:39:08,630 --> 00:39:09,830
它真的給你。

844
00:39:09,830 --> 00:39:12,350
但是，煤焦場是一個固定數。

845
00:39:12,350 --> 00:39:16,420
因此，選擇太少，你是那種
擰緊，如果你想有一個較長的用戶名。

846
00:39:16,420 --> 00:39:19,132
選擇太多，什麼是
缺點？

847
00:39:19,132 --> 00:39:20,820
>> 觀眾：[聽不清]。

848
00:39:20,820 --> 00:39:21,620
>> DAVID馬蘭：這是一種浪費。

849
00:39:21,620 --> 00:39:24,835
就像在C中，如果你有一個更大
你比你需要的內存塊，

850
00:39:24,835 --> 00:39:27,190
只是在浪費時間和浪費的空間。

851
00:39:27,190 --> 00:39:31,430
因此，作為一種替代，存在
VARCHAR，解決了這個問題

852
00:39:31,430 --> 00:39:36,390
處理而不是作為一個固定長度的長度，
但作為最大長度，並使用

853
00:39:36,390 --> 00:39:40,990
可變的字符數，然後
往往只使用盡可能多的字符作為你

854
00:39:40,990 --> 00:39:42,710
的實際需要。

855
00:39:42,710 --> 00:39:43,670
這聽起來很完美的。

856
00:39:43,670 --> 00:39:45,640
>> 我們為什麼不擺脫了
CHAR數據類型，然後呢？

857
00:39:45,640 --> 00:39:48,500
可能是什麼缺點
使用VARCHAR的，這聽起來

858
00:39:48,500 --> 00:39:51,644
就像是一個不錯的雙贏？

859
00:39:51,644 --> 00:39:52,596
是嗎？

860
00:39:52,596 --> 00:39:53,846
>> 觀眾：[聽不清]。

861
00:39:53,846 --> 00:39:57,360

862
00:39:57,360 --> 00:39:57,790
>> 國寶馬蘭：OK，好。

863
00:39:57,790 --> 00:40:01,101
所以，如果你的數據是一樣的
長度，有什麼值得關注？

864
00:40:01,101 --> 00:40:05,250
>> 觀眾：因為你在浪費
告訴他們所有的數據。

865
00:40:05,250 --> 00:40:09,060
>> DAVID馬蘭：所以，如果您的數據是
相同的長度，不過，我認為

866
00:40:09,060 --> 00:40:12,300
，指定的最大長度
在VARCHAR是沒有什麼不同

867
00:40:12,300 --> 00:40:16,070
如果指定一個固定長度的CHAR
你知道提前號碼。

868
00:40:16,070 --> 00:40:19,500
但確實是有，我會整理
從這個問題的答案提取現實

869
00:40:19,500 --> 00:40:22,610
還是有一個最大，這可能
是惱人的，特別是如果你

870
00:40:22,610 --> 00:40:25,920
遇到一個人的名字，這是
你沒有特別長

871
00:40:25,920 --> 00:40:26,860
預料到的。

872
00:40:26,860 --> 00:40:31,420
而且，這也是少高效
實際上搜索VARCHAR的

873
00:40:31,420 --> 00:40:35,620
搜索字符的，尤其是反對
長條桌，有很多

874
00:40:35,620 --> 00:40:36,510
大量的數據。

875
00:40:36,510 --> 00:40:40,060
所以在這裡也再次專題
沒有明顯的選擇。

876
00:40:40,060 --> 00:40:42,870
>> 因此，只是給你一個其他感
您可能會感興趣的數據類型

877
00:40:42,870 --> 00:40:45,400
無論是對一套七或
未來，INT。

878
00:40:45,400 --> 00:40:47,270
有BIGINT，
就像是很長很長。

879
00:40:47,270 --> 00:40:48,880
它往往是64位。

880
00:40:48,880 --> 00:40:51,640
有小數，你會看到
設置的問題，這是一個非常

881
00:40:51,640 --> 00:40:55,300
吸塵器的問題的答案，我們
遇到浮浮

882
00:40:55,300 --> 00:40:55,980
點不精確。

883
00:40:55,980 --> 00:40:57,390
再有就是DATETIME。

884
00:40:57,390 --> 00:41:01,530
有字面上的數據類型
看起來像一年，一個月，一天，

885
00:41:01,530 --> 00:41:03,730
小時，分鐘，秒。

886
00:41:03,730 --> 00:41:07,470
>> 但是，SQL數據庫也有
的事情，我們會打電話給索引。

887
00:41:07,470 --> 00:41:11,630
和一個指數的東西，你
創建表的時候指定

888
00:41:11,630 --> 00:41:15,720
搜索和其他操作
更高效。

889
00:41:15,720 --> 00:41:18,550
具體來說，有一種叫做
你可以在主索引

890
00:41:18,550 --> 00:41:19,440
聲明如下。

891
00:41:19,440 --> 00:41:22,330
>> 我們這樣做是為您提供
用戶表，我們給你。

892
00:41:22,330 --> 00:41:26,160
但是請注意，如果我是手動重新創建
這裡的用戶表給

893
00:41:26,160 --> 00:41:27,110
它的用戶名。

894
00:41:27,110 --> 00:41:28,125
我已經指定的ID。

895
00:41:28,125 --> 00:41:29,330
我指定的詮釋。

896
00:41:29,330 --> 00:41:32,000
我指定的用戶名
最多32個字符。

897
00:41:32,000 --> 00:41:36,140
但是，如果我們繼續在這個相當滾動
寬大的窗戶，看到有一個

898
00:41:36,140 --> 00:41:38,260
一堆其他的事情，我可以指定。

899
00:41:38,260 --> 00:41:40,950
>> 一，我可以指定屬性
喜歡，你知道嗎，這

900
00:41:40,950 --> 00:41:42,190
詮釋應該是無符號。

901
00:41:42,190 --> 00:41:45,510
我不想負數，
所以讓我們做無符號。

902
00:41:45,510 --> 00:41:48,660
空是不相關的，因為這裡
我希望每個用戶

903
00:41:48,660 --> 00:41:49,640
有一個唯一的編號。

904
00:41:49,640 --> 00:41:50,830
我不希望它是空的。

905
00:41:50,830 --> 00:41:52,330
>> 但是，這很有趣。

906
00:41:52,330 --> 00:41:57,780
我可以指定該ID要么是
這個數據庫主鍵，或者它

907
00:41:57,780 --> 00:42:00,620
獨特，或它的索引或全文。

908
00:42:00,620 --> 00:42:05,630
因此，對於今天的目的，很長的故事
總之，主要手段，這將

909
00:42:05,630 --> 00:42:10,570
概念上和技術上都
我們用獨特的領域

910
00:42:10,570 --> 00:42:12,140
識別用戶。

911
00:42:12,140 --> 00:42:16,140
>> 所以，當我們仰望用戶來說，這是一種
的承諾，看看他們大多是由

912
00:42:16,140 --> 00:42:17,370
那唯一的標識符。

913
00:42:17,370 --> 00:42:21,930
數據庫將確保，如果你
有一個用戶號碼3，你不能

914
00:42:21,930 --> 00:42:25,400
物理插入另一用戶
具有同樣數量3。

915
00:42:25,400 --> 00:42:28,380
該數據庫將只是拒絕
保存您的更改。

916
00:42:28,380 --> 00:42:32,310
這是一件好事，因為你可以
從自己保護自己。自我

917
00:42:32,310 --> 00:42:34,270
>> 另外，對於用戶名。

918
00:42:34,270 --> 00:42:37,670
所以排第二，召回，
是“用戶名”字段。

919
00:42:37,670 --> 00:42:41,860
因此，第二行是用戶名，
因為我們所做的遠遠離開那裡。

920
00:42:41,860 --> 00:42:43,940
>> 所以，我要指定什麼？

921
00:42:43,940 --> 00:42:47,840
我不允許的，根據SQL，
指定兩個主鍵。

922
00:42:47,840 --> 00:42:50,750
您可以指定一個聯合密鑰，你
看著這兩個領域，但他們不能

923
00:42:50,750 --> 00:42:52,260
分別是主鍵。

924
00:42:52,260 --> 00:42:54,750
所以這是不可能的。

925
00:42:54,750 --> 00:42:56,040
所以，這可能我想選擇？

926
00:42:56,040 --> 00:42:59,710
>> 好吧，獨特的是在精神上有類似
在那裡你指定這個主鍵

927
00:42:59,710 --> 00:43:03,570
域應是唯一的，但它的
不會是一

928
00:43:03,570 --> 00:43:04,410
我用所有的時間。

929
00:43:04,410 --> 00:43:08,450
而且我們不打算使用這一個所有
時間為的是什麼了嗎？

930
00:43:08,450 --> 00:43:10,490
它的速度較慢，如果可能
這是一個漫長的用戶名。

931
00:43:10,490 --> 00:43:11,740
這只是在浪費時間。

932
00:43:11,740 --> 00:43:16,140
>> 指數，同時，指定它的
不會是唯一的，但我想

933
00:43:16,140 --> 00:43:19,470
你的工作你的魔法下的
油煙機，使其更快地為我

934
00:43:19,470 --> 00:43:21,420
搜索這個領域。

935
00:43:21,420 --> 00:43:23,320
因此，這可能不是與此有關。

936
00:43:23,320 --> 00:43:26,500
對於用戶名，我要說的卻是
獨特之處是一個很好的答案。

937
00:43:26,500 --> 00:43:31,200
但是假設我們做了更多用戶
不僅僅是用戶名有意思，

938
00:43:31,200 --> 00:43:32,430
哈希，和身份證號碼。

939
00:43:32,430 --> 00:43:33,860
如果我們給了人們充分的名字呢？

940
00:43:33,860 --> 00:43:37,700
如果我們給他們的地址
以及關於它們的其他數據？

941
00:43:37,700 --> 00:43:43,360
>> 好吧，如果你指定了一個列
數據庫建立索引，這意味著

942
00:43:43,360 --> 00:43:47,730
的MySQL或Oracle，或者任何數據庫
你使用，應該工作它的魔力

943
00:43:47,730 --> 00:43:51,300
並使用某種奇特的數據
就像一棵樹，或一個線索，或結構

944
00:43:51,300 --> 00:43:55,940
哈希表，什麼保證
當你使用搜索數據

945
00:43:55,940 --> 00:43:58,150
選擇在那個特定的領域 - 

946
00:43:58,150 --> 00:44:01,310
就像告訴我大家，
住在牛津街。

947
00:44:01,310 --> 00:44:02,540
查詢這樣的。

948
00:44:02,540 --> 00:44:06,250
如果事先已指定
你想在該領域中的指數，

949
00:44:06,250 --> 00:44:09,050
搜索將是非常非常快。

950
00:44:09,050 --> 00:44:12,090
>> 如果不指定索引，最好
你可以做的是，如果一個線性搜索

951
00:44:12,090 --> 00:44:13,030
它沒有排序。

952
00:44:13,030 --> 00:44:16,220
但如果指定索引，智能
人誰做的資料庫 - 

953
00:44:16,220 --> 00:44:19,340
你這樣的人誰知道現在樹
並試圖和哈希表 - 

954
00:44:19,340 --> 00:44:23,220
會自動建立這樣一個數據
結構在RAM中，以確保

955
00:44:23,220 --> 00:44:26,050
這些搜索速度更快。

956
00:44:26,050 --> 00:44:29,660
>> FULLTEXT同時也是世界上精神相似，
但可以讓你做通配符

957
00:44:29,660 --> 00:44:35,480
搜索，就像告訴我大家，
住在開頭的街道

958
00:44:35,480 --> 00:44:36,960
字母O無論出於何種原因。

959
00:44:36,960 --> 00:44:38,850
你可以做通配符搜索
這樣的。

960
00:44:38,850 --> 00:44:45,880
或者，像表演更引人注目的東西
我大家誰都有這個詞 - 

961
00:44:45,880 --> 00:44:49,400
告訴我每個人都為名稱開頭
與一個特定的字母。

962
00:44:49,400 --> 00:44:51,880
您可以搜索關鍵字
在這種方式。

963
00:44:51,880 --> 00:44:52,630
好的。

964
00:44:52,630 --> 00:44:55,760
>> 因此，設計機會
可能有。

965
00:44:55,760 --> 00:44:57,740
另外有一些人，我會
我揮動雙手。

966
00:44:57,740 --> 00:45:00,530
事實證明，你可以有
不同的存儲引擎。

967
00:45:00,530 --> 00:45:04,390
這是更神秘的比我們需要的
肯定是問題設置7。

968
00:45:04,390 --> 00:45:06,920
默認情況下，你們正在使用
一些所謂的InnoDB。

969
00:45:06,920 --> 00:45:10,910
你會看到提到這個地方在
phpMyAdmin的界面最有可能的。

970
00:45:10,910 --> 00:45:14,130
但是要知道，還有其他的設計
這是潛在的決定

971
00:45:14,130 --> 00:45:18,030
興趣來最終項目是否
你做一些基於Web的。

972
00:45:18,030 --> 00:45:19,330
>> 但是，讓我們做到這一點。

973
00:45:19,330 --> 00:45:23,130
讓我們繼續前進，把這點
屏幕作為傳情的故事

974
00:45:23,130 --> 00:45:26,330
包括你，一個室友，
和一杯牛奶。

975
00:45:26,330 --> 00:45:28,240
讓我們在兩分鐘
左右突破這裡。

976
00:45:28,240 --> 00:45:31,060
如果你能留下來，讓我們來
回來了，看起來有點多在SQL和

977
00:45:31,060 --> 00:45:35,160
然後有點用的JavaScript
對設置在腦海8。

978
00:45:35,160 --> 00:45:36,120
>> 好的。

979
00:45:36,120 --> 00:45:40,420
所以，讓我們給你思考一個
可以非常容易出現極端狀況

980
00:45:40,420 --> 00:45:44,240
在使用數據庫，或上下文
坦率地說，即使使用真實世界的事情

981
00:45:44,240 --> 00:45:46,280
像自動取款機取錢。

982
00:45:46,280 --> 00:45:47,640
所以這裡有一個冰箱。

983
00:45:47,640 --> 00:45:50,040
假設你已經有一個了
你的宿舍或者你的房子。

984
00:45:50,040 --> 00:45:54,990
你已經得到了一個室友的都有，和
你真的喜歡牛奶的實例。

985
00:45:54,990 --> 00:45:57,210
>> 所以，你回家從類一天。

986
00:45:57,210 --> 00:45:58,490
他或她還沒有回來。

987
00:45:58,490 --> 00:45:59,180
你打開冰箱。

988
00:45:59,180 --> 00:46:00,870
你真的想要的一大杯牛奶。

989
00:46:00,870 --> 00:46:01,820
有沒有牛奶。

990
00:46:01,820 --> 00:46:02,920
所以，你會怎麼做？

991
00:46:02,920 --> 00:46:03,840
你關閉了冰箱。

992
00:46:03,840 --> 00:46:04,670
你搶你的鑰匙。

993
00:46:04,670 --> 00:46:05,930
你出去到廣場。

994
00:46:05,930 --> 00:46:09,240
而你在得到線在CVS的那些
自助結帳的東西，它總是

995
00:46:09,240 --> 00:46:11,180
需要更長的時間比實際
有收銀員。

996
00:46:11,180 --> 00:46:11,820
總之。

997
00:46:11,820 --> 00:46:15,490
>> 那麼，與此同時，小點小點小點，你的
室友回家，他或她

998
00:46:15,490 --> 00:46:17,440
類似地具有一個渴望
對於一些牛奶。

999
00:46:17,440 --> 00:46:20,380
於是，他或她打開冰箱，
看起來裡面，哦，該死的。

1000
00:46:20,380 --> 00:46:21,160
沒有牛奶。

1001
00:46:21,160 --> 00:46:24,750
於是，他或她領導了，偏偏去
到其它的CVS，只有這是一個

1002
00:46:24,750 --> 00:46:27,900
方框相差出於某種原因，他或
她會在網上買一些牛奶。

1003
00:46:27,900 --> 00:46:30,480
>> 同時，你回家的時候，他或
她回家，和做什麼

1004
00:46:30,480 --> 00:46:31,980
你最終有嗎？

1005
00:46:31,980 --> 00:46:33,080
兩倍的牛奶。

1006
00:46:33,080 --> 00:46:34,620
但你真的不喜歡
牛奶那麼多。

1007
00:46:34,620 --> 00:46:37,300
所以，現在你有這麼多的牛奶，現在
其中之一是剛準備去酸

1008
00:46:37,300 --> 00:46:37,820
最終。

1009
00:46:37,820 --> 00:46:39,370
所以這是一個非常糟糕的問題。

1010
00:46:39,370 --> 00:46:39,900
對不對？

1011
00:46:39,900 --> 00:46:41,990
>> 所以，發生了什麼事？

1012
00:46:41,990 --> 00:46:44,810
所以從根本上，這是一種
荒謬的例子。

1013
00:46:44,810 --> 00:46:48,580
但引擎蓋下，我們已經有
在這裡發生的是你們兩個檢查

1014
00:46:48,580 --> 00:46:52,390
某一段的狀態
存儲器，該冰箱。

1015
00:46:52,390 --> 00:46:54,420
你們倆檢查狀態
一些變量。

1016
00:46:54,420 --> 00:46:57,360
你們都畫了一個結論，
那你再採取行動。

1017
00:46:57,360 --> 00:47:01,420
但不幸的是，當你的室友
是在商店，那狀態

1018
00:47:01,420 --> 00:47:05,670
變變了，他或她回來
現在想改變狀態，但

1019
00:47:05,670 --> 00:47:07,480
它已經被改變
他或她。

1020
00:47:07,480 --> 00:47:11,120
當然，他或她會不會有
去商店，如果他們知道

1021
00:47:11,120 --> 00:47:13,010
您已經在途中。

1022
00:47:13,010 --> 00:47:16,430
>> 所以，在現實世界中，你怎麼能這樣
避免這個問題，假設你有

1023
00:47:16,430 --> 00:47:18,940
冰箱，你有一個室友，
而你居然喜歡牛奶？

1024
00:47:18,940 --> 00:47:19,760
>> 觀眾：溝通。

1025
00:47:19,760 --> 00:47:20,580
>> DAVID馬蘭：溝通。

1026
00:47:20,580 --> 00:47:21,160
確定。

1027
00:47:21,160 --> 00:47:22,500
但如何可能你溝通？

1028
00:47:22,500 --> 00:47:23,990
>> 觀眾：留一個便條。

1029
00:47:23,990 --> 00:47:25,480
>> DAVID馬蘭：留一個便條，對不對？

1030
00:47:25,480 --> 00:47:28,025
總是留下一張紙條，為
該節目的球迷。

1031
00:47:28,025 --> 00:47:31,580
好吧，所以總是留下一張紙條，或
把真正喜歡一個掛鎖或某事

1032
00:47:31,580 --> 00:47:35,440
上，讓您的冰箱
從檢查的狀態室友

1033
00:47:35,440 --> 00:47:36,540
該變量。

1034
00:47:36,540 --> 00:47:40,800
>> 現在，為什麼會這樣有密切關係
問題設置7，或到自動取款機。

1035
00:47:40,800 --> 00:47:46,780
那麼，想像在一個ATM的世界裡
你也許可以去到一個ATM

1036
00:47:46,780 --> 00:47:48,920
機器在這裡，並在這裡另一個自動取款機。

1037
00:47:48,920 --> 00:47:50,680
而這經常發生。

1038
00:47:50,680 --> 00:47:54,150
並假設您有兩個ATM卡，
這有可能獲得。

1039
00:47:54,150 --> 00:47:57,420
和您登錄到兩台機器
同時有效，希望

1040
00:47:57,420 --> 00:47:58,660
雖然沒有人在找。

1041
00:47:58,660 --> 00:48:01,260
然後你在你的PIN碼輸入
大致同時。

1042
00:48:01,260 --> 00:48:06,280
然後，你做一個查詢餘額
就看你有多少現金。

1043
00:48:06,280 --> 00:48:08,920
讓我們說你有100元，
留在您的帳戶。

1044
00:48:08,920 --> 00:48:13,310
所以基本上同時，你
說一，零，零，輸入。

1045
00:48:13,310 --> 00:48:16,000
而你希望拿回一些錢。

1046
00:48:16,000 --> 00:48:18,440
>> 但多少錢可能你回來？

1047
00:48:18,440 --> 00:48:21,710
現在在一天結束電腦，
特別是如果他們在跟誰說話

1048
00:48:21,710 --> 00:48:27,360
服務器，不一定做的事情
在該命令中的預期。

1049
00:48:27,360 --> 00:48:30,860
>> 因此，假設會發生什麼，因為，
無論網絡速度問題有

1050
00:48:30,860 --> 00:48:34,530
是，或CPU的問題有​​，或
這樣的事情，假設

1051
00:48:34,530 --> 00:48:38,530
第一台ATM檢查您的平衡和
看，哦，這個人有100元。

1052
00:48:38,530 --> 00:48:41,840
但隨後被分心，因為也許
備份正在發生，所以它的

1053
00:48:41,840 --> 00:48:42,500
放緩。

1054
00:48:42,500 --> 00:48:45,080
或者，也許在檢查時，網絡
連接有一點點慢，因為

1055
00:48:45,080 --> 00:48:45,910
這只是發生。

1056
00:48:45,910 --> 00:48:47,100
他們是物理設備。

1057
00:48:47,100 --> 00:48:49,330
如此同時，第二ATM是
問同樣的問題。

1058
00:48:49,330 --> 00:48:53,030
多少錢，大衛有哪些？
100元的答案。

1059
00:48:53,030 --> 00:48:58,930
但是，因為第一個ATM尚未
發送的消息減去100元，兩者

1060
00:48:58,930 --> 00:49:03,000
自動取款機已視察該銀行的金庫，
看到有100美元那裡，而現在

1061
00:49:03,000 --> 00:49:07,160
兩台機器都可能
要吐出一個答案。

1062
00:49:07,160 --> 00:49:12,240
>> 現在，這是偉大的，你在某種意義上
如果銀行做什麼，最終

1063
00:49:12,240 --> 00:49:17,200
由量改變至負100
設置變量等於你

1064
00:49:17,200 --> 00:49:21,570
銀行賬戶等於0，而不是
幹嘛減去100。

1065
00:49:21,570 --> 00:49:24,410
現在，在最壞的情況下為銀行 - 

1066
00:49:24,410 --> 00:49:27,470
或者在最好的銀行，同時，
他們給你200美元，

1067
00:49:27,470 --> 00:49:31,690
您的銀行帳戶現在顯示負
100元，這確實不

1068
00:49:31,690 --> 00:49:32,950
有利於你的。

1069
00:49:32,950 --> 00:49:36,500
但問題是，這個比賽
條件兩個室友越來越

1070
00:49:36,500 --> 00:49:40,660
牛奶，或兩個自動取款機試圖獲得現金
和更改保管庫的狀態

1071
00:49:40,660 --> 00:49:44,510
在同一時間存在任何
時間，你有一個數據庫。

1072
00:49:44,510 --> 00:49:48,290
>> 現在，在問題設置7，本次發行
出現在這個意義上，如果你買了

1073
00:49:48,290 --> 00:49:52,110
股Facebook股票，然後對
比如你買的第二份額

1074
00:49:52,110 --> 00:49:55,160
Facebook股票，你需要做
決定作為編程器。

1075
00:49:55,160 --> 00:49:58,710
為了決定如何更新
數據庫，賠率是你要

1076
00:49:58,710 --> 00:50:02,250
有一個行的股票，而這
是實現它的方法之一。

1077
00:50:02,250 --> 00:50:06,640
而你將有一股
FB，這是他們的股票代碼

1078
00:50:06,640 --> 00:50:10,120
這個用戶名，或該用戶
ID，該唯一標識符。

1079
00:50:10,120 --> 00:50:12,340
>> 但是，同樣的故事可以發生在這裡。

1080
00:50:12,340 --> 00:50:15,800
如果你做一個選擇在SQL中，你會看到
在問題設置7，當你看到，

1081
00:50:15,800 --> 00:50:18,460
哦，大衛有一股
Facebook股票。

1082
00:50:18,460 --> 00:50:23,240
現在讓我改變這是兩股，
因為他想買一個

1083
00:50:23,240 --> 00:50:24,120
第二份額。

1084
00:50:24,120 --> 00:50:27,860
但是，假設大衛實際上有兩個
瀏覽器窗口打開，或假設

1085
00:50:27,860 --> 00:50:32,150
它與夫妻雙方聯名賬戶，
和他們兩人都試圖執行

1086
00:50:32,150 --> 00:50:36,770
相同的操作，有，同樣，
可能存在的決定是

1087
00:50:36,770 --> 00:50:39,670
基於以前提出
世界上的國家 - 

1088
00:50:39,670 --> 00:50:41,290
該帳戶擁有一股股份 - 

1089
00:50:41,290 --> 00:50:45,630
並且兩個人，或者兩個服務器，現在
試試再說吧遞增到兩股。

1090
00:50:45,630 --> 00:50:49,020
但在這種情況下，您可能已落案起訴
我的錢為股份，但

1091
00:50:49,020 --> 00:50:50,830
增加只是一次。

1092
00:50:50,830 --> 00:50:54,730
>> 所以，總之，最根本的問題
在這裡，與笑話留下

1093
00:50:54,730 --> 00:50:58,750
注意，或把掛鎖就可以了，是
如果兩個人，或者兩個線程 - 

1094
00:50:58,750 --> 00:50:59,930
回想起刮 - 

1095
00:50:59,930 --> 00:51:03,220
可以檢查一些變量的狀態
然後試圖更改變量，

1096
00:51:03,220 --> 00:51:07,950
但這兩件事情不要發生在
同一時間，但可以被打斷

1097
00:51:07,950 --> 00:51:11,500
其他的事情發生，數據可
進入一個非常奇怪的狀態。

1098
00:51:11,500 --> 00:51:15,450
而且你可以受益，或者您可以承受
在金錢例的意義。

1099
00:51:15,450 --> 00:51:18,110
>> 因此，在問題設置7，我們給你
這一行代碼，其中長

1100
00:51:18,110 --> 00:51:21,000
總而言之，解決了這個
問題在MySQL。

1101
00:51:21,000 --> 00:51:24,950
這個很長的指令不
甚至適合到上一行

1102
00:51:24,950 --> 00:51:30,370
屏幕在這裡可以確保您的操作
是所謂的原子。

1103
00:51:30,370 --> 00:51:33,720
這一切都發生在一次，或者
它不會發生的。

1104
00:51:33,720 --> 00:51:37,530
這個很長的短語不能
得到部分中斷。

1105
00:51:37,530 --> 00:51:39,840
>> 和它做什麼簡直是
它說什麼。

1106
00:51:39,840 --> 00:51:44,200
插入一些表如下
三場的那些特定的值，

1107
00:51:44,200 --> 00:51:47,280
但重複鍵，
不要做一個插入。

1108
00:51:47,280 --> 00:51:48,280
做一個更新。

1109
00:51:48,280 --> 00:51:52,450
因此，這就像做一個SELECT和
INSERT可以這麼說在同一時間。

1110
00:51:52,450 --> 00:51:55,150
什麼是關鍵這可能是
被引用到這裡？

1111
00:51:55,150 --> 00:51:58,300

1112
00:51:58,300 --> 00:52:01,380
>> 事實證明，你會看到這一點
問題設置7的規格，因為

1113
00:52:01,380 --> 00:52:06,040
我們已經宣布那裡是一個唯一的密鑰
這個特定的表上，使得

1114
00:52:06,040 --> 00:52:08,480
你不能有多個行
用於與相同的用戶

1115
00:52:08,480 --> 00:52:10,150
同樣一分錢的股票代碼 - 

1116
00:52:10,150 --> 00:52:13,780
在這裡這個例子中，DVN.V是
一個愚蠢的仙股，我們

1117
00:52:13,780 --> 00:52:14,980
是指在規範中。

1118
00:52:14,980 --> 00:52:17,860
因為我們已經宣布它是唯一的，
這是什麼意思是，如果你

1119
00:52:17,860 --> 00:52:23,580
嘗試插入重複行，你
而不是去而不更新它

1120
00:52:23,580 --> 00:52:27,020
任何人有機會改變
世界上的任何國家。

1121
00:52:27,020 --> 00:52:29,400
因此，在短期，這確保
事情是原子的。

1122
00:52:29,400 --> 00:52:32,530
>> 更一般地，雖然，數據庫
如MySQL  - 

1123
00:52:32,530 --> 00:52:35,460
而你不需要這個功能的
對設置7，但請記住它的

1124
00:52:35,460 --> 00:52:36,200
未來 - 

1125
00:52:36,200 --> 00:52:38,870
支持所謂的交易，
在那裡你可以說

1126
00:52:38,870 --> 00:52:40,990
從字面上START TRANSACTION。

1127
00:52:40,990 --> 00:52:43,270
然後，您可以執行
兩個SQL語句。

1128
00:52:43,270 --> 00:52:45,710
和一個SQL語句，你會看到
在對設置7，顯得有些

1129
00:52:45,710 --> 00:52:46,750
這樣的事情。

1130
00:52:46,750 --> 00:52:48,820
更新的表中調用帳戶。

1131
00:52:48,820 --> 00:52:52,550
設置餘額列等於什麼
目前餘額欄

1132
00:52:52,550 --> 00:52:57,280
是減去1,000，其中的數量，
帳戶號碼，如用戶ID，

1133
00:52:57,280 --> 00:53:00,830
等於2，然後更新
賬戶點綴點點。

1134
00:53:00,830 --> 00:53:04,350
>> 因此，在外行人的術語，什麼這兩個
查詢似乎在做的

1135
00:53:04,350 --> 00:53:05,840
銀行業的現實世界有意義嗎？

1136
00:53:05,840 --> 00:53:07,440
>> 觀眾：轉移到儲蓄。

1137
00:53:07,440 --> 00:53:08,020
>> DAVID馬蘭：沒錯。

1138
00:53:08,020 --> 00:53:10,470
從一個轉移資金
向另一方。

1139
00:53:10,470 --> 00:53:14,400
這是另一個例子，你
真的想這兩件事情發生

1140
00:53:14,400 --> 00:53:15,570
或不會發生。

1141
00:53:15,570 --> 00:53:18,880
你不想要的東西，得到的
他們中間，有可能陷入困境

1142
00:53:18,880 --> 00:53:22,220
算算，還是搞砸了多少
錢，你有，或有多少

1143
00:53:22,220 --> 00:53:23,170
錢的銀行都有。

1144
00:53:23,170 --> 00:53:26,890
那麼什麼是真正好的關於交易
在MySQL的是，和

1145
00:53:26,890 --> 00:53:30,160
數據庫更一般地，是它們
以及誰已經實現的聰明人

1146
00:53:30,160 --> 00:53:33,670
這些特性弄清楚如何使
確保兩個的事情發生

1147
00:53:33,670 --> 00:53:35,120
或根本沒有。

1148
00:53:35,120 --> 00:53:38,580
>> 如果你是真正有志於做
這是由人使用的網站上

1149
00:53:38,580 --> 00:53:41,490
校園裡，人們在現實世界中，做
東西在啟動意義上說，

1150
00:53:41,490 --> 00:53:43,300
這些都是種
設計決策

1151
00:53:43,300 --> 00:53:45,020
變得比以往那麼重要。

1152
00:53:45,020 --> 00:53:48,240
否則，你就開始失去數據，輸
用戶，或者在最壞的情況下為

1153
00:53:48,240 --> 00:53:51,800
我們在這裡看到的，潛在的
賠錢。

1154
00:53:51,800 --> 00:53:56,180
如此反复，更多，在問題設置
7，還有可能對某些

1155
00:53:56,180 --> 00:53:57,530
你在最後的項目。

1156
00:53:57,530 --> 00:54:01,870
>> 因此，讓我們改變圖片中我們有
剛才只是一種方式。

1157
00:54:01,870 --> 00:54:04,070
因此，讓我能不能我居然看到 - 

1158
00:54:04,070 --> 00:54:06,030
不，那已經走了。

1159
00:54:06,030 --> 00:54:06,690
在那裡，它是。

1160
00:54:06,690 --> 00:54:09,020
>> 所以這是我們離開最後一次。

1161
00:54:09,020 --> 00:54:12,390
而事實證明，我們要去折騰
一件事情到這裡混 - 

1162
00:54:12,390 --> 00:54:14,510
一個名為JavaScript語言。

1163
00:54:14,510 --> 00:54:18,060
所以，JavaScript實際上適合
進入這片 - 

1164
00:54:18,060 --> 00:54:22,086
而且我也不太留有足夠的空間，
所以這不是現在的規模。

1165
00:54:22,086 --> 00:54:23,900
OK，這是值得同情的。

1166
00:54:23,900 --> 00:54:27,075
好了，這就是JavaScript的。

1167
00:54:27,075 --> 00:54:27,340
好的。

1168
00:54:27,340 --> 00:54:28,760
我真的這樣做了倒忙。

1169
00:54:28,760 --> 00:54:29,390
好的。

1170
00:54:29,390 --> 00:54:34,790
>> 因此，JavaScript是另一種編程
語言和我們的最後，有沒有什麼幫助

1171
00:54:34,790 --> 00:54:37,770
放心，有沒有什麼更
的消防栓在這裡。

1172
00:54:37,770 --> 00:54:41,100
這樣的JavaScript也是一種解釋
語言，這意味著你不

1173
00:54:41,100 --> 00:54:42,670
它編譯成零和一。

1174
00:54:42,670 --> 00:54:43,690
你只要運行它。

1175
00:54:43,690 --> 00:54:47,680
但是，什麼是有根本不同的
JavaScript的通常是你

1176
00:54:47,680 --> 00:54:49,815
不要在Web服務器上運行它。

1177
00:54:49,815 --> 00:54:52,570
它不會在運行
家電本身。

1178
00:54:52,570 --> 00:54:57,490
相反，它就會被用戶下載
通過HTTP到他們的瀏覽器 - 

1179
00:54:57,490 --> 00:55:00,260
Chrome瀏覽器，Safari瀏覽器，IE瀏覽器，
Firefox的，不管是誰 - 

1180
00:55:00,260 --> 00:55:03,860
並且它是執行這個瀏覽器
特定的編程語言。

1181
00:55:03,860 --> 00:55:08,000
>> 所以要清楚，PHP迄今已
無論是執行在命令行

1182
00:55:08,000 --> 00:55:11,290
我們的黑與白的窗口，在服務器上
像設備，計算機

1183
00:55:11,290 --> 00:55:14,490
喜歡該設備，或者它已經
由Web服務器執行

1184
00:55:14,490 --> 00:55:15,860
在計算機上運行。

1185
00:55:15,860 --> 00:55:20,490
但這裡的主題是，PHP迄今
已被執行的服務器端，所以

1186
00:55:20,490 --> 00:55:24,820
用戶和用戶的瀏覽器
永遠看不到一行PHP代碼。

1187
00:55:24,820 --> 00:55:28,530
>> 事實上，如果你曾經打開一個瀏覽器
您的網站或其他和你

1188
00:55:28,530 --> 00:55:32,400
實際看到的PHP代碼在你的窗口，
有人搞砸了。

1189
00:55:32,400 --> 00:55:34,950
因為它並不意味著是
直接發送到一個瀏覽器。

1190
00:55:34,950 --> 00:55:38,150
它應該被執行轉身
成類似HTML。

1191
00:55:38,150 --> 00:55:40,120
>> 但JavaScript的本質
相反。

1192
00:55:40,120 --> 00:55:44,350
它的意思是典型的內部運行
的用戶的瀏覽器窗口。

1193
00:55:44,350 --> 00:55:46,840
和使用什麼類型的網站
然後，JavaScript的這些日子？

1194
00:55:46,840 --> 00:55:49,640

1195
00:55:49,640 --> 00:55:52,180
>> 如同字面上每個受歡迎的網站。

1196
00:55:52,180 --> 00:55:55,430
每一個網站，你​​們大概
每天使用使用JavaScript的

1197
00:55:55,430 --> 00:55:57,330
最簡單的，甚至
最性感的特點。

1198
00:55:57,330 --> 00:55:59,800
>> 因此，像Fac​​ebook的
聊天，如果您使用。

1199
00:55:59,800 --> 00:56:01,040
如何實際工作？

1200
00:56:01,040 --> 00:56:05,090
以及迄今，所有的東西，我們已經
完成了HTML和PHP假定

1201
00:56:05,090 --> 00:56:08,750
你拉了一個網址，你敲回車，
和你看到一些HTML內容。

1202
00:56:08,750 --> 00:56:11,970
而你點擊鏈接，即改變
網址，改變了頁面，並重新加載

1203
00:56:11,970 --> 00:56:12,740
一些新的內容。

1204
00:56:12,740 --> 00:56:16,340
點擊另一個URL或者提交一個表單，你
獲得護送到另一個頁面，

1205
00:56:16,340 --> 00:56:17,420
你看到了一些新的內容。

1206
00:56:17,420 --> 00:56:22,710
>> 但使用類似Facebook的聊天，
或Gchat，或谷歌地圖，很少

1207
00:56:22,710 --> 00:56:27,350
沒有整個頁面刷新，使得
你看到一個白色屏幕片刻，

1208
00:56:27,350 --> 00:56:28,470
然後新的內容。

1209
00:56:28,470 --> 00:56:32,610
更確切地說，網頁今天是動態
再次得到更新

1210
00:56:32,610 --> 00:56:35,570
一次又一次的所有排序
幕後。

1211
00:56:35,570 --> 00:56:38,560
而事實證明，當你去
像Facebook或Gchat，

1212
00:56:38,560 --> 00:56:43,050
或Gmail和頁面更新
無自動重裝

1213
00:56:43,050 --> 00:56:47,630
整個屏幕上，發生的是，
您的瀏覽器已排序的秘密

1214
00:56:47,630 --> 00:56:49,410
額外的HTTP請求 - 

1215
00:56:49,410 --> 00:56:52,740
不是整個網頁，但只為
數據的小的塊，如

1216
00:56:52,740 --> 00:56:55,740
即時消息，你的朋友剛剛
送你，或狀態的更新，

1217
00:56:55,740 --> 00:56:58,210
剛剛有人送你，或鳴叫
有人剛剛發。

1218
00:56:58,210 --> 00:57:02,120
它只是讓小請求
數據，然後使用JavaScript，這

1219
00:57:02,120 --> 00:57:06,370
編程語言，要改變什麼
網頁看起來像沒有

1220
00:57:06,370 --> 00:57:09,860
服務器的幫助，無需服務器
生成的HTML。

1221
00:57:09,860 --> 00:57:13,820
>> 所以，總之，可以使用JavaScript的再
不僅從獲取新數據

1222
00:57:13,820 --> 00:57:16,750
無需重新加載整個服務器
頁面或提交表單。

1223
00:57:16,750 --> 00:57:20,060
它也可以用來改變
所謂的DOM  - 

1224
00:57:20,060 --> 00:57:21,520
文檔對象模型 - 

1225
00:57:21,520 --> 00:57:24,620
這僅僅是看中方式
說的HTML的樹

1226
00:57:24,620 --> 00:57:26,220
我們看到最後一次。

1227
00:57:26,220 --> 00:57:31,640
>> 所以安撫，JavaScript是
所以語法類似於C為好。

1228
00:57:31,640 --> 00:57:32,820
有沒有主函數。

1229
00:57:32,820 --> 00:57:35,430
你剛開始寫代碼
它會得到執行，或

1230
00:57:35,430 --> 00:57:36,900
更恰當的解釋。

1231
00:57:36,900 --> 00:57:38,660
條件如下所示。

1232
00:57:38,660 --> 00:57:41,230
無異於C或
PHP為此事。

1233
00:57:41,230 --> 00:57:43,890
布爾表達式或 - 編在一起
看起來就像這樣。

1234
00:57:43,890 --> 00:57:45,590
相與在一起看起來像這樣。

1235
00:57:45,590 --> 00:57:47,750
>> 交換機將看起來像這樣。

1236
00:57:47,750 --> 00:57:49,440
for循環看起來會像這樣。

1237
00:57:49,440 --> 00:57:51,060
while循環看起來會像這樣。

1238
00:57:51,060 --> 00:57:53,316
做while循環看起來會像這樣。

1239
00:57:53,316 --> 00:57:54,780
>> 這是新的。

1240
00:57:54,780 --> 00:57:58,753
所以，JavaScript有沒有一個foreach
構造本身，而是該構建

1241
00:57:58,753 --> 00:58:03,870
對於變量i的數組，和我在這
情況變成一個索引值。

1242
00:58:03,870 --> 00:58:06,880
因此，它是從一點點不同
的foreach，雖然新版本

1243
00:58:06,880 --> 00:58:10,280
JavaScript的是走出來的時候，
因此，即使這些語言特性

1244
00:58:10,280 --> 00:58:10,880
正在不斷發展。

1245
00:58:10,880 --> 00:58:16,920
>> 並順便說一句，JavaScript的這些日子
也可以用一台服務器上一樣

1246
00:58:16,920 --> 00:58:19,920
使用PHP名為Node.js的框架

1247
00:58:19,920 --> 00:58:24,670
一個CS50的轉錄因子，凱文，導致一
研討會上的Node.js這是可在

1248
00:58:24,670 --> 00:58:26,440
cs50.net/seminars。

1249
00:58:26,440 --> 00:58:28,830
所以，如果你很好奇，知道你
可以在服務器端作為使用本

1250
00:58:28,830 --> 00:58:33,870
好了，但是這是一個相當新的趨勢，
但一個強大的一個。

1251
00:58:33,870 --> 00:58:35,270
>> 這是一個有點不同。

1252
00:58:35,270 --> 00:58:37,910
這是在JavaScript的數組。

1253
00:58:37,910 --> 00:58:40,115
什麼打你不同
與C或PHP？

1254
00:58:40,115 --> 00:58:43,890

1255
00:58:43,890 --> 00:58:47,420
這裡有幾個簡單的故事
我們可以在這裡告訴。

1256
00:58:47,420 --> 00:58:49,367
現在缺少對PHP的？

1257
00:58:49,367 --> 00:58:51,652
>> 觀眾：[聽不清]。

1258
00:58:51,652 --> 00:58:52,110
>> DAVID馬蘭：怎麼了？

1259
00:58:52,110 --> 00:58:53,322
對不起，再說一遍嗎？

1260
00:58:53,322 --> 00:58:54,740
>> 觀眾：不聲明
變量的類型。

1261
00:58:54,740 --> 00:58:56,390
>> DAVID馬蘭：我們不會宣布
變量的類型。

1262
00:58:56,390 --> 00:58:59,630
所以，其實蠻喜歡PHP的，我們不是
指定該變量的類型。

1263
00:58:59,630 --> 00:59:02,670
相反，我們更一般
話說變種變量。

1264
00:59:02,670 --> 00:59:06,690
我們沒有的PHP的滋擾
美元符號，這雖然繁瑣

1265
00:59:06,690 --> 00:59:09,160
類型，並讓更多的清楚，
什麼是一個變量。

1266
00:59:09,160 --> 00:59:11,830
而在這裡，我們是有點回
C'S方法只是通過調用

1267
00:59:11,830 --> 00:59:14,500
按我們想要的變量名稱
給它，像數字。

1268
00:59:14,500 --> 00:59:17,170
也像PHP，我們有
方括號內為

1269
00:59:17,170 --> 00:59:19,170
該數組內的值。

1270
00:59:19,170 --> 00:59:22,490
>> 在JavaScript中這樣的變量也
可能是這樣的。

1271
00:59:22,490 --> 00:59:26,900
注意這裡，這是一個稱為S字符串，
但同樣有我們沒有指定

1272
00:59:26,900 --> 00:59:28,750
這是一個字符串。

1273
00:59:28,750 --> 00:59:33,160
這裡雖然是一種功能，不
存在於恰好在PHP中相同的方式，

1274
00:59:33,160 --> 00:59:34,460
但有點類似。

1275
00:59:34,460 --> 00:59:36,530
這是在JavaScript中的對象。

1276
00:59:36,530 --> 00:59:42,110
而對象是類的瑞士軍刀
的數據結構中，你刀

1277
00:59:42,110 --> 00:59:43,900
可以將它們用於任何數量的東西。

1278
00:59:43,900 --> 00:59:46,860
>> 在這裡，例如，我們正在聲明
一個變量名為報價。

1279
00:59:46,860 --> 00:59:49,110
該變量的類型
是一個對象。

1280
00:59:49,110 --> 00:59:53,550
你可以認為這是一個C結構
有鍵和值。

1281
00:59:53,550 --> 00:59:55,250
符號是一個關鍵。

1282
00:59:55,250 --> 00:59:57,350
FB是一個值，顯然
股票代碼。

1283
00:59:57,350 --> 00:59:57,930
逗號。

1284
00:59:57,930 --> 01:00:02,180
價格是另一個關鍵，它的值是
顯然是浮點，或一個

1285
01:00:02,180 --> 01:00:06,510
更一般地在數字
的JavaScript49.26美元。

1286
01:00:06,510 --> 01:00:09,030
>> 所以，PHP不具備 - 

1287
01:00:09,030 --> 01:00:12,980
我們還沒有看到PHP對象相當
像這樣，但我們也看到一個模擬，

1288
01:00:12,980 --> 01:00:14,093
這是什麼？

1289
01:00:14,093 --> 01:00:14,980
>> 觀眾：[聽不清]。

1290
01:00:14,980 --> 01:00:16,110
>> DAVID馬蘭：關聯數組。

1291
01:00:16,110 --> 01:00:19,990
因此而PHP有關聯數組
其語法是有史以來略等

1292
01:00:19,990 --> 01:00:20,370
不同的 - 

1293
01:00:20,370 --> 01:00:21,780
我們看到了方括號。

1294
01:00:21,780 --> 01:00:23,860
我們看到了奇怪的箭頭符號。

1295
01:00:23,860 --> 01:00:27,330
JavaScript有對象，但這是
大多是語義差異和

1296
01:00:27,330 --> 01:00:29,260
不同的同義詞了。

1297
01:00:29,260 --> 01:00:35,060
不過，順便說一句，PHP也有
在某種程度上對象的Java及其他

1298
01:00:35,060 --> 01:00:37,810
語言有對象
面向對象的編程。

1299
01:00:37,810 --> 01:00:40,440
但是我們將使用這些剛
對於數據類型了。

1300
01:00:40,440 --> 01:00:42,170
對象和關聯數組。

1301
01:00:42,170 --> 01:00:44,140
>> 這其中可能使
更加清楚一點。

1302
01:00:44,140 --> 01:00:45,890
這也是為什麼一個對象是非常有用的。

1303
01:00:45,890 --> 01:00:48,760
當你想聲明一個學生，
像Zamyla，我們實際上可以

1304
01:00:48,760 --> 01:00:52,630
封裝可以這麼說那裡面
使用花括號，就像反對

1305
01:00:52,630 --> 01:00:55,060
一大堆鑰匙的前
在這裡值。

1306
01:00:55,060 --> 01:00:59,150
我們有一個ID，一個房子，一個名字
Zamyla，後跟一個分號作為

1307
01:00:59,150 --> 01:01:00,690
通常在最後。

1308
01:01:00,690 --> 01:01:04,840
>> 到這裡也一樣，這是稍微
不同，但也很強大

1309
01:01:04,840 --> 01:01:05,690
這些天。

1310
01:01:05,690 --> 01:01:08,780
下面是一個數組，我知道，因為
有一個方括號起來

1311
01:01:08,780 --> 01:01:11,090
頂部和方括號
在底部。

1312
01:01:11,090 --> 01:01:16,050
這就是數據的數組
在JavaScript顯然鍵入？

1313
01:01:16,050 --> 01:01:21,260
這是它的外觀的陣列
像三個物體。

1314
01:01:21,260 --> 01:01:24,580
我知道這只是一個對象
因為大括號。

1315
01:01:24,580 --> 01:01:28,760
並注意有大括號，
有些東西，右大括號，逗號，

1316
01:01:28,760 --> 01:01:31,180
然後一些，逗號，
然後一些。

1317
01:01:31,180 --> 01:01:33,800
所以，這三個參數
用兩個逗號隔開。

1318
01:01:33,800 --> 01:01:36,810
>> 因此，這是三個對象的數組。

1319
01:01:36,810 --> 01:01:39,940
並且其中的每個對象似乎是
一些學生或工作人員

1320
01:01:39,940 --> 01:01:42,370
排序，每一個ID，
房子，和名稱。

1321
01:01:42,370 --> 01:01:45,060
但我已經叫這東西
所謂的JSON  - 

1322
01:01:45,060 --> 01:01:47,450
JavaScript對象表示法。

1323
01:01:47,450 --> 01:01:52,060
這是一個數據格式，實際上
那麼很受歡迎，在

1324
01:01:52,060 --> 01:01:55,100
時尚這些天，如果你寫了一個
使用Facebook應用程序

1325
01:01:55,100 --> 01:01:59,150
API，Twitter的API，真的差點
任何API在那裡這些天，

1326
01:01:59,150 --> 01:02:02,820
包括一些CS50自己的
你回來的數據是不是在

1327
01:02:02,820 --> 01:02:04,720
老同學CSV格式。

1328
01:02:04,720 --> 01:02:06,780
>> 因為回想一下，CSV
超簡單。

1329
01:02:06,780 --> 01:02:10,230
這僅僅是分開列
用逗號。

1330
01:02:10,230 --> 01:02:13,190
JSON數據給你更多的元數據。

1331
01:02:13,190 --> 01:02:17,800
它有關聯的每個值一個鍵，以便
他們不必只是假設

1332
01:02:17,800 --> 01:02:22,460
第零列是一個數值，列
一個是另外一個，第二列是另一回事。

1333
01:02:22,460 --> 01:02:26,790
在這裡的JSON對象一切都是排序
自我描述的，因為每一個

1334
01:02:26,790 --> 01:02:30,940
名字在這個文件中的一個具有字面
在它前面的名稱為

1335
01:02:30,940 --> 01:02:32,510
帶引號的字符串。

1336
01:02:32,510 --> 01:02:34,950
>> 因此，讓我們來看看一個
幾個例子在這裡。

1337
01:02:34,950 --> 01:02:36,800
讓我去到設備。

1338
01:02:36,800 --> 01:02:41,000
讓我進入我們的虛擬主機
目錄進入公眾。

1339
01:02:41,000 --> 01:02:45,590
讓我進入
JavaScript的目錄。

1340
01:02:45,590 --> 01:02:49,610
讓我們去進取，不斷開拓
DOM-0.html，其中的DOM只是意味著

1341
01:02:49,610 --> 01:02:51,010
文檔對象模型。

1342
01:02:51,010 --> 01:02:53,490
這是樹的東西到
我前面提到的。

1343
01:02:53,490 --> 01:02:54,950
>> 讓我提出以下建議。

1344
01:02:54,950 --> 01:02:57,720
下面是它的一個網頁
身體是非常簡單的。

1345
01:02:57,720 --> 01:03:00,170
所以這兒的底部，
注意到我有一個表格。

1346
01:03:00,170 --> 01:03:01,500
我們以前見過的那些。

1347
01:03:01,500 --> 01:03:07,600
它有兩個輸入端，其中一個具有一個
其中一個名稱標識，有一種類型的

1348
01:03:07,600 --> 01:03:09,830
提交，並且所述第一
一個人的類型是text。

1349
01:03:09,830 --> 01:03:11,900
因此，這實際上聽起來很簡單。

1350
01:03:11,900 --> 01:03:13,090
>> 讓我們在這裡。

1351
01:03:13,090 --> 01:03:15,390
讓我們回到這個頁面在這裡。

1352
01:03:15,390 --> 01:03:21,030
讓我們進入本地主機，並進入
我們的JavaScript目錄，並轉到

1353
01:03:21,030 --> 01:03:24,640
DOM-0，在這裡，我們有這樣的形式。

1354
01:03:24,640 --> 01:03:26,550
所以這是很明顯
所有的頁面一樣。

1355
01:03:26,550 --> 01:03:28,740
它有一個名字字段
一個提交按鈕。

1356
01:03:28,740 --> 01:03:30,340
但我不打算在這裡使用PHP。

1357
01:03:30,340 --> 01:03:34,310
我將盡一切客戶端
所以要如下在JavaScript中發言。

1358
01:03:34,310 --> 01:03:39,100
>> 請注意，我確實賦予的名稱
這個輸入領域的獨特

1359
01:03:39,100 --> 01:03:42,350
標識符，這實際上
救我一些時間在一個時刻。

1360
01:03:42,350 --> 01:03:45,480
並注意我介紹另一個標籤
在我的網頁的頭部，

1361
01:03:45,480 --> 01:03:46,565
 標記。

1362
01:03:46,565 --> 01:03:50,120
>> 因此，它是在這個意義上說，JavaScript是
一個客戶端編程語言。

1363
01:03:50,120 --> 01:03:55,020
在這種情況下，就像CSS，我已經把
它直接在我的HTML。

1364
01:03:55,020 --> 01:03:58,810
但請注意，我已經聲明的函數
看起來有點像PHP

1365
01:03:58,810 --> 01:04:01,530
語法，但其實這是
JavaScript的，因為再次，它是

1366
01:04:01,530 --> 01:04:03,920
客戶端在瀏覽器中。

1367
01:04:03,920 --> 01:04:07,590
並以此來猜測這是什麼打算
這樣做，即使有些語法

1368
01:04:07,590 --> 01:04:09,338
這裡是新的。

1369
01:04:09,338 --> 01:04:11,760
>> 觀眾：問好誰。

1370
01:04:11,760 --> 01:04:14,020
>> DAVID馬蘭：這是怎麼回事打招呼
對誰訪問這個頁面。

1371
01:04:14,020 --> 01:04:15,120
那麼，如何？

1372
01:04:15,120 --> 01:04:18,070
>> 因此注意到，原來在JavaScript
有一個alert（）函數。

1373
01:04:18,070 --> 01:04:22,840
這是一個非常可悲的排序功能，
真的只是往往惹惱用戶。

1374
01:04:22,840 --> 01:04:25,440
這不是一個你真的應該使用
通常情況下，但它是一個快速和骯髒

1375
01:04:25,440 --> 01:04:27,710
這樣的排序打印的東西
到的圖形用戶

1376
01:04:27,710 --> 01:04:29,180
接口，就像一個瀏覽器。

1377
01:04:29,180 --> 01:04:31,400
請注意，在這裡，我已經有了一個
字符串中的單引號。

1378
01:04:31,400 --> 01:04:36,010
事實證明，與C，JavaScript的
其實可以有使用單

1379
01:04:36,010 --> 01:04:38,730
報價，坦白說這只是一種
當中的文體公約

1380
01:04:38,730 --> 01:04:41,180
JavaScript程序員
使用單引號。

1381
01:04:41,180 --> 01:04:43,750
PHP的，他們實際上有輕微
不同的意義。

1382
01:04:43,750 --> 01:04:45,810
但現在，只要知道
這是唯一的原因。

1383
01:04:45,810 --> 01:04:49,270
在JavaScript中的約定往往是
使用單引號，但我們可以用

1384
01:04:49,270 --> 01:04:50,950
兩地雙引號為好。

1385
01:04:50,950 --> 01:04:52,610
>> 因此，這是有趣的。

1386
01:04:52,610 --> 01:04:56,430
記得最後一次，我們有這樣的
圖片，吸引了一棵樹在屏幕上

1387
01:04:56,430 --> 01:04:59,720
在那裡你有HTML節點，
頭節點，身體節點

1388
01:04:59,720 --> 01:05:00,800
然後一些文本。

1389
01:05:00,800 --> 01:05:04,700
但是有在一個特殊的節點
極頂，我稱為文檔。

1390
01:05:04,700 --> 01:05:08,260
嗯，事實證明在JavaScript中，任何
時間你寫在JavaScript程序

1391
01:05:08,260 --> 01:05:11,040
在瀏覽器中，您可以訪問
一個特殊的全局變量。

1392
01:05:11,040 --> 01:05:14,130
類似的精神，PHP的超全局變量，
這個就是所謂的

1393
01:05:14,130 --> 01:05:16,050
全部小寫的文件。

1394
01:05:16,050 --> 01:05:21,480
>> 這就像一個結構，但這種結構
也有在其內部功能。

1395
01:05:21,480 --> 01:05:23,790
因此，一個C結構只是有數據通常。

1396
01:05:23,790 --> 01:05:29,060
但由於這是一個JavaScript對象
在技​​術上也有功能，

1397
01:05:29,060 --> 01:05:31,830
否則稱為方法
裡面的它。

1398
01:05:31,830 --> 01:05:35,750
而且你可以調用一個函數內
這個對象毫不誇張地做了

1399
01:05:35,750 --> 01:05:39,610
名，點，和然後的名稱
的功能，或再次方法。

1400
01:05:39,610 --> 01:05:41,160
這只是一個代名詞，真的。

1401
01:05:41,160 --> 01:05:42,450
>> 而這是什麼功能呢？

1402
01:05:42,450 --> 01:05:43,840
那種你可以從它的名字猜測。

1403
01:05:43,840 --> 01:05:45,590
通過ID獲取元素。

1404
01:05:45,590 --> 01:05:50,040
因此，這是要搜索的網頁，
搜索那棵樹，尋找

1405
01:05:50,040 --> 01:05:55,210
任何節點，AKA元件，具有
的報價引文名唯一的ID。

1406
01:05:55,210 --> 01:05:56,560
然後我該怎麼辦？

1407
01:05:56,560 --> 01:06:00,350
我要得到裡面的值
在樹中的節點，我要去

1408
01:06:00,350 --> 01:06:02,580
以某種方式打招呼該名稱。

1409
01:06:02,580 --> 01:06:05,360
>> 因此，需要一種猜測，即使我們還沒有
看到這一步，做什麼的加

1410
01:06:05,360 --> 01:06:07,396
符號的意思是在這裡和這裡可能？

1411
01:06:07,396 --> 01:06:08,230
>> 觀眾：串連。

1412
01:06:08,230 --> 01:06:09,220
>> DAVID馬蘭：串聯。

1413
01:06:09,220 --> 01:06:11,290
右，而這些都只是
樣的設計決策

1414
01:06:11,290 --> 01:06:12,280
人民年前。

1415
01:06:12,280 --> 01:06:15,190
在PHP中，您連接
東西點。

1416
01:06:15,190 --> 01:06:18,800
在C語言中，你通過幾個跳火圈和
像打電話或strcopy功能（）

1417
01:06:18,800 --> 01:06:20,600
strcat的（）或其他這樣的功能。

1418
01:06:20,600 --> 01:06:22,060
但在JavaScript中，可以使用加號。

1419
01:06:22,060 --> 01:06:24,770
所以這只是串聯
三個字符串 - 

1420
01:06:24,770 --> 01:06:27,850
你好，一個名稱，然後
感嘆號。

1421
01:06:27,850 --> 01:06:30,390
>> 所以，什麼時候，為什麼是這個函數
所謂的關係嗎？

1422
01:06:30,390 --> 01:06:33,150
那麼，採取從一個猜測
HTML在底部。

1423
01:06:33,150 --> 01:06:35,810
為什麼迎接（）調用，或者什麼時候？

1424
01:06:35,810 --> 01:06:39,730

1425
01:06:39,730 --> 01:06:44,030
>> 顯然，盡我所知道的，在
提交，當這個表單被提交，

1426
01:06:44,030 --> 01:06:47,200
我要採取一切
這裡面的引號。

1427
01:06:47,200 --> 01:06:50,900
具體而言，我要去打電話
迎接（），然後返回false。

1428
01:06:50,900 --> 01:06:53,090
>> 好吧，讓我們來看看網
效果這裡是第一。

1429
01:06:53,090 --> 01:06:58,290
因此，讓我繼續前進，鍵入
，譬如說，羅蘭，提交。

1430
01:06:58,290 --> 01:06:59,440
您好羅蘭。

1431
01:06:59,440 --> 01:07:02,990
讓我們來看看，也許這只是
幸運的實施。

1432
01:07:02,990 --> 01:07:03,200
不。

1433
01:07:03,200 --> 01:07:05,990
所以它的打字了什麼
我的名字居然放在那裡。

1434
01:07:05,990 --> 01:07:07,970
>> 但是請注意，什麼是不發生變化。

1435
01:07:07,970 --> 01:07:10,360
該網址仍是DOM-0.html。

1436
01:07:10,360 --> 01:07:11,820
有沒有register.php。

1437
01:07:11,820 --> 01:07:13,110
有沒有第二個文件。

1438
01:07:13,110 --> 01:07:14,930
有沒有action屬性。

1439
01:07:14,930 --> 01:07:19,720
那麼，什麼是這個返回false
大概是在做什麼？

1440
01:07:19,720 --> 01:07:23,660
為什麼我打電話問候（），然後
返回false可能？

1441
01:07:23,660 --> 01:07:26,420
當你點擊什麼通常發生
提交，即使我們有一個表格上

1442
01:07:26,420 --> 01:07:27,854
在過去的一周見過？

1443
01:07:27,854 --> 01:07:29,900
>> 觀眾：[聽不清]。

1444
01:07:29,900 --> 01:07:30,860
>> DAVID馬蘭：它去的地方，對不對？

1445
01:07:30,860 --> 01:07:32,720
它使用了一些目標URL。

1446
01:07:32,720 --> 01:07:34,120
但我不希望這樣的發生在這裡。

1447
01:07:34,120 --> 01:07:37,620
我想我的網頁是完全
動如Gmail，即一旦你

1448
01:07:37,620 --> 01:07:38,650
在那裡，你呆在那裡。

1449
01:07:38,650 --> 01:07:42,900
該URL不的方式，改變
表示整個頁面重新加載。

1450
01:07:42,900 --> 01:07:46,680
相反，我只是想改變一些東西
像打印出來的東西

1451
01:07:46,680 --> 01:07:48,320
這裡在屏幕上。

1452
01:07:48,320 --> 01:07:49,630
>> 那麼，讓我這個清洗
一點點。

1453
01:07:49,630 --> 01:07:55,370
讓我開不DOM-0，但
讓我打開DOM-2。

1454
01:07:55,370 --> 01:07:57,350
只要你在這裡看到了一些語法。

1455
01:07:57,350 --> 01:08:02,080
>> 事實證明，我們剛才
沒被使用原始的JavaScript。

1456
01:08:02,080 --> 01:08:04,420
因此，這是真正的語言
JavaScript的。

1457
01:08:04,420 --> 01:08:07,340
你們當中有些人可能知道的
一個庫名為jQuery的。

1458
01:08:07,340 --> 01:08:09,980
>> 所以jQuery是不一樣的
事為JavaScript。

1459
01:08:09,980 --> 01:08:14,110
這只是一個圖書館，一個真正聰明的
小伙寫和推廣這樣的

1460
01:08:14,110 --> 01:08:18,100
幾乎世界上每個人現在
使用JavaScript時，使用jQuery。

1461
01:08:18,100 --> 01:08:20,890
乍看，說實話，它
看起來多了幾分神秘。

1462
01:08:20,890 --> 01:08:24,990
但你會發現，特別是如果你去
在那裡你與網絡最終項目

1463
01:08:24,990 --> 01:08:29,029
發展，你會發現，這
做清理工作，並節省您不少

1464
01:08:29,029 --> 01:08:30,229
幾行代碼。

1465
01:08:30,229 --> 01:08:33,189
>> 因此，讓我們只要看一眼如何
這種形式的工作。

1466
01:08:33,189 --> 01:08:35,664
請注意我怎麼去掉明顯
從我的HTML嗎？

1467
01:08:35,664 --> 01:08:38,240

1468
01:08:38,240 --> 01:08:40,630
有沒有關於提交處理程序
可以這麼說。

1469
01:08:40,630 --> 01:08:41,470
有沒有屬性。

1470
01:08:41,470 --> 01:08:43,359
因為你知道，
我真的不喜歡？

1471
01:08:43,359 --> 01:08:45,640
我覺得我們被碎成
到老習慣那裡。

1472
01:08:45,640 --> 01:08:49,340
就像它開始感覺邋遢
交融既與CSS

1473
01:08:49,340 --> 01:08:52,149
HTML，因為你是那種扔
不同的語言遍布

1474
01:08:52,149 --> 01:08:56,180
的地方，同樣也該開始感覺
像一個壞的道路往下走的地方

1475
01:08:56,180 --> 01:09:01,069
我把JavaScript代碼在我的
HTML，而不是保出來。

1476
01:09:01,069 --> 01:09:02,279
>> 所以，這是這裡的一課。

1477
01:09:02,279 --> 01:09:05,080
在DOM-2.HTML，我保出來。

1478
01:09:05,080 --> 01:09:07,399
和我正在做的事情略有
不同。

1479
01:09:07,399 --> 01:09:09,630
現在，我要揮揮手
在這到底是什麼呢

1480
01:09:09,630 --> 01:09:10,590
引擎蓋下方。

1481
01:09:10,590 --> 01:09:14,210
但就現在假定，首先
代碼在這個庫行

1482
01:09:14,210 --> 01:09:18,170
所謂的jQuery只是意味著當
文件準備好後，請執行以下操作。

1483
01:09:18,170 --> 01:09:20,080
>> 因為網頁可以採取
一段時間來加載。

1484
01:09:20,080 --> 01:09:23,029
你可能會在一個緩慢的互聯網
連接，並且它可能被紡

1485
01:09:23,029 --> 01:09:25,290
和紡紗，最後它的加載。

1486
01:09:25,290 --> 01:09:29,060
這行代碼只是說等到
整個頁面已準備就緒，文檔

1487
01:09:29,060 --> 01:09:31,189
準備就緒後，在執行這個程式碼。

1488
01:09:31,189 --> 01:09:34,390
>> 現在發現，這可能是
最有用的第一

1489
01:09:34,390 --> 01:09:36,189
採取遠離的jQuery。

1490
01:09:36,189 --> 01:09:42,140
這裡這條線是非常相似的精神
這更長的線在這裡。

1491
01:09:42,140 --> 01:09:46,920
而在原始的JavaScript代碼，有
存在一個全球性的文檔對象，

1492
01:09:46,920 --> 01:09:50,460
有一個稱為的getElementById（）的函數，
誰寫的人

1493
01:09:50,460 --> 01:09:55,720
jQuery的簡化了，只是說
美元符號，然後在裡面的

1494
01:09:55,720 --> 01:10:00,250
括號把兩個引號，然後
把一個散列符號後跟

1495
01:10:00,250 --> 01:10:02,250
你想抓住唯一的ID。

1496
01:10:02,250 --> 01:10:06,170
因此，這是相當於
的document.getElementById。

1497
01:10:06,170 --> 01:10:11,090
>> 同時，。遞交僅僅意味著對
提交任何形式的你是

1498
01:10:11,090 --> 01:10:14,240
參照左側，去
前進，執行這個。

1499
01:10:14,240 --> 01:10:16,600
但是，這是現在的好奇心了。

1500
01:10:16,600 --> 01:10:19,560
有什麼奇怪的是什麼
我在這裡強調？

1501
01:10:19,560 --> 01:10:23,840

1502
01:10:23,840 --> 01:10:28,594
它不僅是一種語法
新的，另外還有一些人失踪。

1503
01:10:28,594 --> 01:10:29,558
>> 觀眾：這只是調用的函數？

1504
01:10:29,558 --> 01:10:31,970
這不是叫提醒？

1505
01:10:31,970 --> 01:10:32,440
>> 馬蘭大衛：是的。

1506
01:10:32,440 --> 01:10:35,450
好了，所以提醒（）是跌
這裡，是公平的。

1507
01:10:35,450 --> 01:10:39,520
但沒有提到的
命名，就像你知道的，或富

1508
01:10:39,520 --> 01:10:40,980
東西在這裡。

1509
01:10:40,980 --> 01:10:43,830
事實上，這是特色之一
JavaScript的那是相當的

1510
01:10:43,830 --> 01:10:45,370
功能強大，但也相當新的。

1511
01:10:45,370 --> 01:10:47,460
和PHP居然有這一點。

1512
01:10:47,460 --> 01:10:49,500
>> 讓我繼續前進，做
一些真正的快。

1513
01:10:49,500 --> 01:10:52,030
讓我繼續前進，把這個在這裡。

1514
01:10:52,030 --> 01:10:52,600
讓我這樣做。

1515
01:10:52,600 --> 01:10:53,690
功能。

1516
01:10:53,690 --> 01:10:56,455
讓我們把這個處理程序（）。

1517
01:10:56,455 --> 01:10:58,290
處理函數可以這麼說。

1518
01:10:58,290 --> 01:11:00,110
處理一些操作的東西。

1519
01:11:00,110 --> 01:11:02,700
讓我收拾我的壓痕。

1520
01:11:02,700 --> 01:11:04,380
並把這個在這裡。

1521
01:11:04,380 --> 01:11:06,090
並把在這裡。

1522
01:11:06,090 --> 01:11:06,470
沒錯。

1523
01:11:06,470 --> 01:11:07,060
確定。

1524
01:11:07,060 --> 01:11:10,300
>> 所以現在我有一個函數調用
handler（）的，我真的不知道

1525
01:11:10,300 --> 01:11:10,890
它做什麼呢。

1526
01:11:10,890 --> 01:11:12,710
它只是仍然擁有的東西。

1527
01:11:12,710 --> 01:11:13,900
哎呀。

1528
01:11:13,900 --> 01:11:15,820
花了太多。

1529
01:11:15,820 --> 01:11:18,490
讓我們做到這一點。

1530
01:11:18,490 --> 01:11:18,990
好的。

1531
01:11:18,990 --> 01:11:20,240
抱歉。

1532
01:11:20,240 --> 01:11:23,140

1533
01:11:23,140 --> 01:11:23,690
好的。

1534
01:11:23,690 --> 01:11:24,720
讓我這樣做。

1535
01:11:24,720 --> 01:11:25,020
確定。

1536
01:11:25,020 --> 01:11:27,040
這看起來不錯，直
現在推進。

1537
01:11:27,040 --> 01:11:29,090
讓我這樣做。

1538
01:11:29,090 --> 01:11:29,860
做到這一點。

1539
01:11:29,860 --> 01:11:30,950
和確定。

1540
01:11:30,950 --> 01:11:33,080
所以，現在，讓我們把在這裡。

1541
01:11:33,080 --> 01:11:35,840

1542
01:11:35,840 --> 01:11:37,270
沒有編程上飛。

1543
01:11:37,270 --> 01:11:37,900
確定。

1544
01:11:37,900 --> 01:11:40,000
>> 所以，現在，讓我們回到
故事開始的地方。

1545
01:11:40,000 --> 01:11:43,530
以前，我說，這條線在這裡
意味著當文檔準備好了，去

1546
01:11:43,530 --> 01:11:44,380
進取，做到這一點。

1547
01:11:44,380 --> 01:11:45,660
我想要做的是什麼呢？

1548
01:11:45,660 --> 01:11:49,070
那麼具體而言，我想去
進取，做到以下幾點。

1549
01:11:49,070 --> 01:11:53,700
執行這行代碼，然後
我要你做的是調用這個

1550
01:11:53,700 --> 01:11:56,370
功能，當表單被提交。

1551
01:11:56,370 --> 01:11:57,730
>> 現在，這就是有趣的。

1552
01:11:57,730 --> 01:11:59,170
這本身不是一個函數。

1553
01:11:59,170 --> 01:12:02,540
請注意，我不是把括號
在以正常的方式。

1554
01:12:02,540 --> 01:12:06,800
我從字面上傳遞一個函數調用
handler（）的另一個功能

1555
01:12:06,800 --> 01:12:10,800
提交（）作為一個參數作為
雖然它像一個變量。

1556
01:12:10,800 --> 01:12:14,290
，這是一個功能的
JavaScript中，函數本身

1557
01:12:14,290 --> 01:12:15,710
真的是剛對象。

1558
01:12:15,710 --> 01:12:18,350
事實上，他們真的只是
某種變量。

1559
01:12:18,350 --> 01:12:21,340
並且如果函數的名稱是
handler（）的，也沒有理由我不能

1560
01:12:21,340 --> 01:12:23,390
在這裡作為一個參數傳遞給它。

1561
01:12:23,390 --> 01:12:27,530
這意味著，當表單
與演示的ID是

1562
01:12:27,530 --> 01:12:29,320
提交，調用這個函數。

1563
01:12:29,320 --> 01:12:32,770
>> 但現在如果我撤消了這一切，
那為什麼我也許做

1564
01:12:32,770 --> 01:12:34,850
這一刻前？

1565
01:12:34,850 --> 01:12:36,840
那麼，這是一個匿名函數。

1566
01:12:36,840 --> 01:12:41,080
因為坦率地說，我才意識到我為什麼
浪費時間困擾聲明

1567
01:12:41,080 --> 01:12:45,540
函數調用處理程序（）只調用
在一個且只有一個地方？

1568
01:12:45,540 --> 01:12:48,640
如果我沒有需要的名字，我不
需要調用多個地方，

1569
01:12:48,640 --> 01:12:51,200
讓我們只是實現的功能
我需要它的地方。

1570
01:12:51,200 --> 01:12:55,190
所以JavaScript和PHP支持
被稱為匿名函數

1571
01:12:55,190 --> 01:12:57,900
請允許我做的正是這一點。

1572
01:12:57,900 --> 01:12:59,570
>> 但我們只是表面。

1573
01:12:59,570 --> 01:13:02,430
讓我們的挑逗，只是一對夫婦
最後的例子在這裡。

1574
01:13:02,430 --> 01:13:04,600
>> 如果我進入quote.php。

1575
01:13:04,600 --> 01:13:07,160

1576
01:13:07,160 --> 01:13:11,870
請注意，這實際上是一個PHP
函數，我寫一個PHP程序

1577
01:13:11,870 --> 01:13:15,270
預計HTTP參數調用
符號，我可以通過在

1578
01:13:15,270 --> 01:13:16,730
FB這樣的值。

1579
01:13:16,730 --> 01:13:20,010
如果我們實際上看一下源
代碼，這是一個免費的網站查詢

1580
01:13:20,010 --> 01:13:23,680
雅虎財經，就像對集
七，它返回給我

1581
01:13:23,680 --> 01:13:26,580
顯然的東西
是JSON格式，稱為 - 

1582
01:13:26,580 --> 01:13:28,010
JavaScript對象符號。

1583
01:13:28,010 --> 01:13:28,810
這只是一個對象。

1584
01:13:28,810 --> 01:13:32,500
注意花括號，引號，
冒號，逗號。

1585
01:13:32,500 --> 01:13:34,720
>> 同時，現在這是很酷。

1586
01:13:34,720 --> 01:13:38,520
因為我也許可以使用一種編程
語言生成URL

1587
01:13:38,520 --> 01:13:40,370
看起來像這樣動態
對不對？

1588
01:13:40,370 --> 01:13:43,340
我可以改變這是谷歌
並獲得谷歌的

1589
01:13:43,340 --> 01:13:47,930
股票價格1,017.55美元。

1590
01:13:47,930 --> 01:13:49,640
因此，讓我們來看看，如果我們現在不能使用此。

1591
01:13:49,640 --> 01:13:56,590
>> 讓我去AJAX-0在這裡，這
看起來像下面這樣。

1592
01:13:56,590 --> 01:13:59,750
這只是一個網站，有
一種形式的按鈕。

1593
01:13:59,750 --> 01:14:05,860
在這裡，讓我繼續前進，鍵入YHOO
雅虎的股票代碼，點擊獲取

1594
01:14:05,860 --> 01:14:10,530
報價，現在發現我已經得到了
一個警覺32.86。

1595
01:14:10,530 --> 01:14:14,050
>> 讓我真正去票友版本
此頁，版本二，

1596
01:14:14,050 --> 01:14:17,530
讓我們的類型微軟MSFT說。

1597
01:14:17,530 --> 01:14:18,410
獲取報價。

1598
01:14:18,410 --> 01:14:19,850
現在注意到，沒有警報。

1599
01:14:19,850 --> 01:14:22,770
請注意，如果說價格
被確定的？

1600
01:14:22,770 --> 01:14:27,060
是最簡單的例子是
提示在什麼Gchat和Facebook

1601
01:14:27,060 --> 01:14:30,070
聊天，和Gmail，其他如
通過實際的網站正在做的

1602
01:14:30,070 --> 01:14:31,290
改變網頁。

1603
01:14:31,290 --> 01:14:31,800
>> 請注意這一點。

1604
01:14:31,800 --> 01:14:33,120
讓我重新加載頁面。

1605
01:14:33,120 --> 01:14:35,080
讓我打開Chrome的督察。

1606
01:14:35,080 --> 01:14:36,890
讓我去的元素
選項卡在這裡。

1607
01:14:36,890 --> 01:14:42,310
現在可以看到，如果我在這裡變焦和
打開這件事，注意，這是我

1608
01:14:42,310 --> 01:14:44,500
HTML DOM  - 我的文檔對象模型。

1609
01:14:44,500 --> 01:14:45,920
這是我的HTML。

1610
01:14:45,920 --> 01:14:48,750
但是現在注意到，儘管這是怎麼回事
是一個有點難以看到它在兩個

1611
01:14:48,750 --> 01:14:52,080
一次的地方，如果我在FB中鍵入
在這裡，看底部

1612
01:14:52,080 --> 01:14:54,110
的屏幕。

1613
01:14:54,110 --> 01:14:57,720
>> 它實際上是在改變
我的HTML飛。

1614
01:14:57,720 --> 01:15:01,670
它這樣做很簡單，
通過做這樣的事情。

1615
01:15:01,670 --> 01:15:06,800
如果我打開了AJAX-2，注意實施
性感的東西

1616
01:15:06,800 --> 01:15:09,560
，即使它是相當難看，
但複雜

1617
01:15:09,560 --> 01:15:11,910
功能，它有一些
HTML的底部。

1618
01:15:11,910 --> 01:15:13,810
但是請注意，我用的標記。

1619
01:15:13,810 --> 01:15:16,640
我們不使用此之前，但是這是
就好了，但它不強制

1620
01:15:16,640 --> 01:15:17,840
一切都邁上了一個新行。

1621
01:15:17,840 --> 01:15:20,830
它只是使一個矩形區域
基本上是在同一行上。

1622
01:15:20,830 --> 01:15:22,870
>> 請注意，我給它一個ID的價格。

1623
01:15:22,870 --> 01:15:26,800
和事實證明，通過使用相同的
JavaScript庫，我有一個函數

1624
01:15:26,800 --> 01:15:30,440
稱為引號（），這就是所謂的時
表單被提交。

1625
01:15:30,440 --> 01:15:31,800
我在做什麼。

1626
01:15:31,800 --> 01:15:35,730
我聲明一個變量在JavaScript
稱為URL，保存價值

1627
01:15:35,730 --> 01:15:38,650
quote.php符號=。

1628
01:15:38,650 --> 01:15:44,220
換句話說，我現在開始
準備一個HTTP請求，然後

1629
01:15:44,220 --> 01:15:49,250
我串聯到加的
任何的元素的ID

1630
01:15:49,250 --> 01:15:54,190
符號，而該通知是
文本字段就在這裡。

1631
01:15:54,190 --> 01:15:56,630
因此，就像我們在過去的形式。

1632
01:15:56,630 --> 01:16:01,450
>> 然後原來的jQuery，如果你
調用值（），它要求一個值

1633
01:16:01,450 --> 01:16:05,900
功能，價值功能，即得到
無論用戶已鍵入英寸

1634
01:16:05,900 --> 01:16:08,920
然後把所有的網絡流量
出現這種情況是這樣的。

1635
01:16:08,920 --> 01:16:11,230
$。的getJSON。

1636
01:16:11,230 --> 01:16:13,720
>> 而作為一個不談，美元符號
只是一個速記符號。

1637
01:16:13,720 --> 01:16:16,860
這真是jQuery.getJSON。

1638
01:16:16,860 --> 01:16:21,520
讓我到JSON從這個URL，而當
請求回來，稱此

1639
01:16:21,520 --> 01:16:26,550
函數並傳入作為參數
無論來自服務器返回。

1640
01:16:26,550 --> 01:16:31,205
>> 所以，換句話說，如果我回去
瀏覽器了，我回去quote.php，

1641
01:16:31,205 --> 01:16:35,590
什麼我的瀏覽器正在做的是越來越
這個塊的數據。

1642
01:16:35,590 --> 01:16:38,930
當我去這個網頁在這裡，
注意，如果我們不是去網絡

1643
01:16:38,930 --> 01:16:43,820
選項卡，然後清除它，然後鍵入
像歌谷歌和獲取

1644
01:16:43,820 --> 01:16:46,340
引號，注意頁沒有改變。

1645
01:16:46,340 --> 01:16:50,990
但一個HTTP請求是，什麼
回到這裡，如果我們看一下

1646
01:16:50,990 --> 01:16:56,130
響應是一大堆的JSON
我們訪問的最後用

1647
01:16:56,130 --> 01:16:58,070
這個簡單的線條在這裡。

1648
01:16:58,070 --> 01:17:00,150
>> 數據是得到了
從服務器。

1649
01:17:00,150 --> 01:17:02,120
價格的名義
關鍵我在乎。

1650
01:17:02,120 --> 01:17:05,230
所以data.price給我的。

1651
01:17:05,230 --> 01:17:07,540
>> 現在同時，與此
是最後一個例子。

1652
01:17:07,540 --> 01:17:09,280
你可以做了更多的頁面。

1653
01:17:09,280 --> 01:17:12,440
實際上之一，還有兩人。

1654
01:17:12,440 --> 01:17:14,780
我們可以帶回
標記，如果你還記得這個。

1655
01:17:14,780 --> 01:17:15,850
這就是JavaScript的。

1656
01:17:15,850 --> 01:17:17,110
我們可以做到這一點。

1657
01:17:17,110 --> 01:17:17,690
非常令人興奮的。

1658
01:17:17,690 --> 01:17:18,800
我們把這個作為一個懸念。

1659
01:17:18,800 --> 01:17:21,590
>> 但更令人興奮的是，你可以
做這樣的事情。

1660
01:17:21,590 --> 01:17:25,940
如果我去的地理定位-1，它的出現
認為Chrome知道我們是在

1661
01:17:25,940 --> 01:17:30,672
緯度經度42.37，-71.10。

1662
01:17:30,672 --> 01:17:32,940
因此，有更多的有
在您的處置。

1663
01:17:32,940 --> 01:17:34,290
但更多的是在下週。

1664
01:17:34,290 --> 01:17:35,540
星期一見。

1665
01:17:35,540 --> 01:17:37,558