1
00:00:00,000 --> 00:00:00,060

2
00:00:00,060 --> 00:00:01,560
>> DAVID MALAN：好吧，我們又回來了。

3
00:00:01,560 --> 00:00:03,830
所以對於令人振奮
總之，我們的最後一節

4
00:00:03,830 --> 00:00:06,900
在網絡編程，我
以為我們會作為一個通用術語使用

5
00:00:06,900 --> 00:00:08,440
捕捉到剩下幾個主題。

6
00:00:08,440 --> 00:00:10,390
因此，在的結束
一天，我們實際上做

7
00:00:10,390 --> 00:00:14,830
動手的網絡編程一點點
與被叫JavaScript語言。

8
00:00:14,830 --> 00:00:17,510
而且我認為，我們將看看
在涉及到圖像的東西

9
00:00:17,510 --> 00:00:20,040
和發現的東西
偷偷藏在圖像中，

10
00:00:20,040 --> 00:00:23,230
也看看谷歌的
地圖API，應用程序編程

11
00:00:23,230 --> 00:00:26,040
接口，東西
代表的軟件類型的

12
00:00:26,040 --> 00:00:28,800
這是越來越多和
今天免費提供。

13
00:00:28,800 --> 00:00:32,029
>> 但是，我們為什麼不來看看
在配料這個世界

14
00:00:32,029 --> 00:00:34,070
我們已經種了
理所當然的存在

15
00:00:34,070 --> 00:00:36,720
一段時間後，一個數據庫。

16
00:00:36,720 --> 00:00:39,150
在過去的一天
我們假定半

17
00:00:39,150 --> 00:00:42,910
我們可以使用一個數據庫，但
確實數據庫解決什麼問題？

18
00:00:42,910 --> 00:00:45,540
這是什麼為我們做什麼？

19
00:00:45,540 --> 00:00:47,030
它是什麼？

20
00:00:47,030 --> 00:00:48,679
>> 聽眾：[聽不清]

21
00:00:48,679 --> 00:00:51,720
DAVID MALAN：保存所有的信息，
OK，什麼類型的信息

22
00:00:51,720 --> 00:00:53,186
你可能會投入嗎？

23
00:00:53,186 --> 00:00:54,590
>> 聽眾：[聽不清]

24
00:00:54,590 --> 00:00:56,450
>> DAVID MALAN：任何信息
你把它，你會得到。

25
00:00:56,450 --> 00:00:57,070
那是真實的。

26
00:00:57,070 --> 00:01:01,900
而一個典型的基於Web的網站或網頁
應用程序，什麼樣的信息，

27
00:01:01,900 --> 00:01:03,385
具體而言，你可能會放？

28
00:01:03,385 --> 00:01:04,260
聽眾：[聽不清]

29
00:01:04,260 --> 00:01:05,051
DAVID MALAN：用戶。

30
00:01:05,051 --> 00:01:07,000
那麼什麼是用戶？

31
00:01:07,000 --> 00:01:09,765
>> 聽眾：[聽不清]

32
00:01:09,765 --> 00:01:11,640
DAVID MALAN：OK，註冊
用戶的網站。

33
00:01:11,640 --> 00:01:15,100
什麼意思
存儲用戶信息？

34
00:01:15,100 --> 00:01:17,260
什麼組成一個用戶？

35
00:01:17,260 --> 00:01:18,331
用戶有什麼？

36
00:01:18,331 --> 00:01:19,206
聽眾：[聽不清]

37
00:01:19,206 --> 00:01:21,040
DAVID MALAN：是的，個人
數據，我喜歡這樣。

38
00:01:21,040 --> 00:01:21,970
讓我們更精確。

39
00:01:21,970 --> 00:01:25,275
因此用戶通常具有一個名字，
還有什麼可能用戶有哪些？

40
00:01:25,275 --> 00:01:26,150
聽眾：[聽不清]

41
00:01:26,150 --> 00:01:29,130
DAVID MALAN：一個addr-- OK，
所以第一個名字，姓氏。

42
00:01:29,130 --> 00:01:29,630
那很好。

43
00:01:29,630 --> 00:01:31,463
其實，我們進行了修復
，因為它會

44
00:01:31,463 --> 00:01:35,010
開闢一個機會
討論中，還進一步。

45
00:01:35,010 --> 00:01:39,090
姓氏，姓名，性別。

46
00:01:39,090 --> 00:01:41,820

47
00:01:41,820 --> 00:01:43,481
某種類型的ID。

48
00:01:43,481 --> 00:01:43,980
還有什麼？

49
00:01:43,980 --> 00:01:45,438
我聽到了別的之前，太多。

50
00:01:45,438 --> 00:01:51,600
電子郵件，郵寄地址。

51
00:01:51,600 --> 00:01:58,170
>> 因此，讓我們停在那裡，現在考慮
不是我們要存儲在數據庫中，

52
00:01:58,170 --> 00:02:01,980
但是 - 而不是為什麼，因為它可能
很明顯，一旦你註冊一個用戶，

53
00:02:01,980 --> 00:02:03,730
你要記住他們一段時間。

54
00:02:03,730 --> 00:02:05,480
你不希望它
剛剛被存儲在RAM中

55
00:02:05,480 --> 00:02:08,690
而如此forgotten--
讓我們關注的是如何。

56
00:02:08,690 --> 00:02:11,700
>> 事實證明，在
數據庫的世界裡，

57
00:02:11,700 --> 00:02:14,410
有至少兩種類型的這些天。

58
00:02:14,410 --> 00:02:20,010
一些所謂的SQL數據庫，
結構化查詢語言，

59
00:02:20,010 --> 00:02:24,770
或命名討人喜歡地，
NOSQL，這是不是SQL。

60
00:02:24,770 --> 00:02:26,980
而後者是一個
例如什麼可能

61
00:02:26,980 --> 00:02:30,660
被稱為面向對象的，
或者對象存儲，數據庫

62
00:02:30,660 --> 00:02:36,010
存儲對象，也不是，藉口
我，我們很快就會看到，行。

63
00:02:36,010 --> 00:02:41,800
>> 因此，我們將重點為只是一個時刻
這些第一，即一個SQL

64
00:02:41,800 --> 00:02:46,850
數據庫中，如果僅僅是因為它是
如此的熟悉已經到任何人

65
00:02:46,850 --> 00:02:51,070
誰使用Excel或
谷歌表或蘋果

66
00:02:51,070 --> 00:02:53,740
數字或任何標準
電子表格程序，

67
00:02:53,740 --> 00:02:56,040
或者，等同地，或
更sophisticatedly，

68
00:02:56,040 --> 00:02:58,610
像微軟
訪問或Oracle

69
00:02:58,610 --> 00:03:03,890
或MySQL或PostgreSQL，所有這一切
是實現產品名稱

70
00:03:03,890 --> 00:03:04,865
的想法如下。

71
00:03:04,865 --> 00:03:10,350
>> 關係數據庫是根本
東西，有行和列。

72
00:03:10,350 --> 00:03:12,850
和由行和列，
我從字面上的意思是什麼

73
00:03:12,850 --> 00:03:21,860
像這樣的，所以我們可能具有
命名一個字段，它的類型在這裡的。

74
00:03:21,860 --> 00:03:25,800
而實際上，讓我
現在就開始繪製這些。

75
00:03:25,800 --> 00:03:29,420
所以實際上，我不知道
為什麼我畫了一個單獨的圖表。

76
00:03:29,420 --> 00:03:30,780
讓我們保持這個簡單。

77
00:03:30,780 --> 00:03:34,830
>> 我們就在這裡
我們的表，其中的開端

78
00:03:34,830 --> 00:03:40,150
這是該領域的名稱
這是數據類型，

79
00:03:40,150 --> 00:03:41,660
並通過I型是指以下。

80
00:03:41,660 --> 00:03:45,510
它是一個數字，它是一個字符串，
一個簡短的字符串像一個字，

81
00:03:45,510 --> 00:03:49,340
它是一個段落，它是
二進制數據，如圖像？

82
00:03:49,340 --> 00:03:51,980
而我們只是逗逗這
除了只是一瞬間。

83
00:03:51,980 --> 00:03:57,575
因此，首先名稱，編號，
串，大塊text--的

84
00:03:57,575 --> 00:03:58,450
聽眾：[聽不清]

85
00:03:58,450 --> 00:03:59,616
DAVID MALAN：是的，所以字符串。

86
00:03:59,616 --> 00:04:04,744
並在數據庫的背景下，我們將
通常稱之為焦炭領域。

87
00:04:04,744 --> 00:04:07,660
我只想說CHAR現在但我們
要在某一時刻細化這一點。

88
00:04:07,660 --> 00:04:09,180
字符字段。

89
00:04:09,180 --> 00:04:11,365
姓可能是相同的。

90
00:04:11,365 --> 00:04:11,865
性別？

91
00:04:11,865 --> 00:04:16,230

92
00:04:16,230 --> 00:04:18,310
>> 男性或女性，所以它
可能是一個char場。

93
00:04:18,310 --> 00:04:21,380
它可以是報價，引文結束
“男”或報價，引文結束“女”

94
00:04:21,380 --> 00:04:23,650
或者它可以為m或f。

95
00:04:23,650 --> 00:04:26,540
如果你想成為更具包容性，
您可能需要第三個值

96
00:04:26,540 --> 00:04:28,640
或某種其他領域完全。

97
00:04:28,640 --> 00:04:31,350
所以你可以使用真正的假。

98
00:04:31,350 --> 00:04:35,036
該字段可以被稱為男性，和
那麼你可以說真的還是假的。

99
00:04:35,036 --> 00:04:38,160
但是，這並不一定是捕捉
所有你可能需要的信息。

100
00:04:38,160 --> 00:04:41,118
>> 因此，原來還有另一種類型
現場的一些可能有用這裡

101
00:04:41,118 --> 00:04:46,040
在一個典型的數據庫，稱為
枚舉，它是一個字符型字段，

102
00:04:46,040 --> 00:04:50,480
但是，設計師，得到
枚舉的可能值，

103
00:04:50,480 --> 00:04:54,630
像報價，引文結束“男性”，報價，
引文結束“女性”，等等。

104
00:04:54,630 --> 00:04:57,620
所以，無論價值
在你的數據庫中，

105
00:04:57,620 --> 00:05:00,670
確實是基於字符的，但
它必須是那些值中的一個。

106
00:05:00,670 --> 00:05:03,520
我們可能不希望的
枚舉的第一個名字或姓氏。

107
00:05:03,520 --> 00:05:05,630
否則，我們將有
列舉，作為名稱

108
00:05:05,630 --> 00:05:09,570
從字面上每一個派生
可能姓和名。

109
00:05:09,570 --> 00:05:13,960
>> 好了，ID應的ID是什麼？

110
00:05:13,960 --> 00:05:15,200
是的，也許一個數字。

111
00:05:15,200 --> 00:05:17,870
因此，讓我們堅持
對於現在一些。

112
00:05:17,870 --> 00:05:22,010
並以數字，數字的
現在有點過於寬泛。

113
00:05:22,010 --> 00:05:23,900
對於第二個的端部
一天，我覺得我們

114
00:05:23,900 --> 00:05:25,280
應該有點更精確。

115
00:05:25,280 --> 00:05:29,280
號碼可能意味著象，它
可能是類似1.236。

116
00:05:29,280 --> 00:05:31,500
而這可能不是
我們通過一個ID的意思。

117
00:05:31,500 --> 00:05:34,635
什麼是我們可能是由一個ID是什麼意思？

118
00:05:34,635 --> 00:05:36,382
>> 聽眾：[聽不清]

119
00:05:36,382 --> 00:05:38,590
DAVID MALAN：哦，好吧，
也許它甚至不是一個數字。

120
00:05:38,590 --> 00:05:42,840
也許它實際上是一個唯一的標識符
這是一個字符串，如用戶名。

121
00:05:42,840 --> 00:05:44,580
那麼絕對，可能是。

122
00:05:44,580 --> 00:05:46,730
我想大概有人
意味著數字，雖然。

123
00:05:46,730 --> 00:05:48,460
因此，讓我們留在那。

124
00:05:48,460 --> 00:05:49,320
什麼樣的號碼？

125
00:05:49,320 --> 00:05:51,960
什麼是更precise--整數。

126
00:05:51,960 --> 00:05:56,710
因此，一些如0，1，2，3，
所以我們稱這個整數。

127
00:05:56,710 --> 00:05:58,909
即使這樣，我就可以
被挑剔，這是

128
00:05:58,909 --> 00:06:00,700
不是真的只是一個
你想一般的整數。

129
00:06:00,700 --> 00:06:04,340
你可能不希望負值，
只是因為，它只是感覺怪怪的。

130
00:06:04,340 --> 00:06:06,070
你可能想正整數。

131
00:06:06,070 --> 00:06:07,920
所以，你也可以表達
在數據庫中，

132
00:06:07,920 --> 00:06:09,450
但現在，我們會說整。

133
00:06:09,450 --> 00:06:10,650
>> 電子郵件？

134
00:06:10,650 --> 00:06:13,550
這可能是just--個什麼東西？

135
00:06:13,550 --> 00:06:14,460
>> 聽眾：[聽不清]

136
00:06:14,460 --> 00:06:16,980
>> DAVID MALAN：這是一封電子郵件，
但是這角色，對不對？

137
00:06:16,980 --> 00:06:19,813
它只是一個時髦的人物像
一個“at”符號或別的東西，

138
00:06:19,813 --> 00:06:21,580
但它仍然是一個字符型字段。

139
00:06:21,580 --> 00:06:23,900
和郵寄地址？

140
00:06:23,900 --> 00:06:25,360
字符字段。

141
00:06:25,360 --> 00:06:31,400
所以這是一個很好的開始，但
我們是一個小更精確了。

142
00:06:31,400 --> 00:06:34,540
>> 因此，原來在
一個數據庫，你經常

143
00:06:34,540 --> 00:06:39,120
有超過更精緻的選擇
這些東西的版本。

144
00:06:39,120 --> 00:06:44,330
事實上，在典型的SQL數據庫，SQL
或更一般地，關係數據庫，

145
00:06:44,330 --> 00:06:46,680
與行數據庫
和列，你經常

146
00:06:46,680 --> 00:06:53,610
獲得指定不僅的類型
field--讓我做一些室內這裡 - 

147
00:06:53,610 --> 00:06:56,600
而且長度。

148
00:06:56,600 --> 00:06:59,900
>> 那麼多久是一個名字？

149
00:06:59,900 --> 00:07:07,060
我認為，D-A-V-I-D。好，知道了我
可能只是喜歡得罪一半

150
00:07:07,060 --> 00:07:11,260
在房間裡的人了吧，
因為你的名字是超過五長

151
00:07:11,260 --> 00:07:16,608
字母，如此五似乎有點自私
不懂事，所以有什麼更好的價值？

152
00:07:16,608 --> 00:07:19,320

153
00:07:19,320 --> 00:07:24,330
10，沒事，我覺得
我們在房間裡確定。

154
00:07:24,330 --> 00:07:26,254
13？

155
00:07:26,254 --> 00:07:27,541
30？

156
00:07:27,541 --> 00:07:29,540
我為什麼不拿
早期的方法時，我們

157
00:07:29,540 --> 00:07:31,081
在談論內存和數組？

158
00:07:31,081 --> 00:07:32,450
為什麼不讓我只是說像1000？

159
00:07:32,450 --> 00:07:35,260
沒有一個人的名字是怎麼回事
比1000更長。

160
00:07:35,260 --> 00:07:36,706
推回。

161
00:07:36,706 --> 00:07:38,005
>> 聽眾：[聽不清]

162
00:07:38,005 --> 00:07:40,130
DAVID MALAN：是的，這
浪費的，正確的，尤其

163
00:07:40,130 --> 00:07:44,630
如果大多數名稱僅5年或10或
15個字符，這是非常浪費的。

164
00:07:44,630 --> 00:07:45,810
所以，你知道嗎？

165
00:07:45,810 --> 00:07:48,020
這是怎樣的一個很難回答的問題的。

166
00:07:48,020 --> 00:07:51,721
現在，我們當然可以分析英語
和任何其他語言的名字

167
00:07:51,721 --> 00:07:54,470
並找出，那麼，什麼是
average--平均不真

168
00:07:54,470 --> 00:07:57,150
幫助us--最大是什麼
也許我們真正想要的。

169
00:07:57,150 --> 00:07:59,920
但事實證明，我們甚至有
有的選擇在這裡的類型。

170
00:07:59,920 --> 00:08:03,400
>> 在一個典型的SQL數據庫，
有一些所謂一個char場

171
00:08:03,400 --> 00:08:07,505
而且一個varchar，V-A-R，
可變字符字段。

172
00:08:07,505 --> 00:08:08,630
與不同的是這個。

173
00:08:08,630 --> 00:08:12,400
一個char字段，設計師，
具有預先指定

174
00:08:12,400 --> 00:08:14,900
該字段的確切長度。

175
00:08:14,900 --> 00:08:20,530
因此，也許名字
像20感覺一種安全。

176
00:08:20,530 --> 00:08:23,950
可能必須做一些谷歌上搜索到
看看是否有足夠安全的實際。

177
00:08:23,950 --> 00:08:26,910
有可能與21名
人物，但現在，假設20

178
00:08:26,910 --> 00:08:27,620
是安全的。

179
00:08:27,620 --> 00:08:30,070
>> 一個char場將意味著
在數據庫中，你

180
00:08:30,070 --> 00:08:33,289
使用的是20和總是20個字符。

181
00:08:33,289 --> 00:08:37,419
現在，如果它只是那些D-A-V-I-D，15
只是要為空白字符，

182
00:08:37,419 --> 00:08:40,450
但你仍然使用所有20個字節。

183
00:08:40,450 --> 00:08:46,302
一個varchar領域，相比之下，意味著
字符串應該是最多20個字符

184
00:08:46,302 --> 00:08:48,260
但如果它的只有五，
你只打算使用

185
00:08:48,260 --> 00:08:51,270
五，或者六為一
在末尾的特殊價值，

186
00:08:51,270 --> 00:08:54,980
像0我們討論了
表示一個字符的結束

187
00:08:54,980 --> 00:08:56,790
序列中的存儲器。

188
00:08:56,790 --> 00:08:59,950
>> 所以，當你覺得
您可以選擇CHAR

189
00:08:59,950 --> 00:09:05,240
與VARCHAR，因為權衡？

190
00:09:05,240 --> 00:09:09,321
字符使用了人物眾多，VARCHAR
使用不超過許多字符。

191
00:09:09,321 --> 00:09:10,196
聽眾：[聽不清]

192
00:09:10,196 --> 00:09:13,859

193
00:09:13,859 --> 00:09:16,900
DAVID MALAN：OK，當你知道
字符串長度相當有吸引力

194
00:09:16,900 --> 00:09:19,316
只使用CHAR，因為如果
你知道它，只是把它放下。

195
00:09:19,316 --> 00:09:23,390
也許這是一個真正的拉鍊
代碼，在美國，至少02138，

196
00:09:23,390 --> 00:09:26,660
它總是會為五
字符，直到你加破折號四人。

197
00:09:26,660 --> 00:09:29,750
但是，你可能有一些值
你總是知道的長度。

198
00:09:29,750 --> 00:09:32,310
或者，也許狀態的符號，
像紐約紐約，

199
00:09:32,310 --> 00:09:33,811
和MA馬薩諸塞在美國。

200
00:09:33,811 --> 00:09:36,560
也許你確實有一些情況
其中，這是完全合理的，

201
00:09:36,560 --> 00:09:39,520
但這一邏輯，為什麼
我們得太多，甚至這個？

202
00:09:39,520 --> 00:09:41,800
為什麼我們不只是使用
VARCHAR，然後我們就

203
00:09:41,800 --> 00:09:46,730
始終使用兩個字符，無論如何，或
總是用五個字符呢？

204
00:09:46,730 --> 00:09:50,300
為什麼不直接保存為varchar
一切，由邏輯是什麼？

205
00:09:50,300 --> 00:09:51,677
必須有一個陷阱。

206
00:09:51,677 --> 00:09:52,552
聽眾：[聽不清]

207
00:09:52,552 --> 00:09:54,952

208
00:09:54,952 --> 00:09:56,660
DAVID MALAN：莫非
寫的東西​​錯了。

209
00:09:56,660 --> 00:09:58,090
所以這是真的。

210
00:09:58,090 --> 00:10:01,030
但即便如此，他們不能使用
更多的內存比我分配。

211
00:10:01,030 --> 00:10:03,340
我還有最後的
說以上的長度，

212
00:10:03,340 --> 00:10:06,780
這樣他們就可以不小心使
那樣的錯誤，但一個好的想法。

213
00:10:06,780 --> 00:10:10,510
這是更微妙的，但它是非常相關
我們的討論，其實，陣列

214
00:10:10,510 --> 00:10:12,390
和更早的鍊錶。

215
00:10:12,390 --> 00:10:16,290
>> 事實證明，一個數據庫，如果
它知道的所有值都

216
00:10:16,290 --> 00:10:19,250
固定長度的，即使
其中的一些值是空白，

217
00:10:19,250 --> 00:10:22,484
諸如此類的審美空白，
D-A-V-I-D，然後15坯，

218
00:10:22,484 --> 00:10:24,650
事實證明，如果每
字段是相同的長度，

219
00:10:24,650 --> 00:10:28,670
就像一個數組有它的所有的東西
背靠背背靠背使

220
00:10:28,670 --> 00:10:33,480
你可以只加1得到下一個
值，在一個數據庫表中同樣的想法。

221
00:10:33,480 --> 00:10:37,550
如果所有你的性格
串是相同的長度，

222
00:10:37,550 --> 00:10:39,390
你有什麼所謂隨機訪問。

223
00:10:39,390 --> 00:10:41,850
如果所有的字符串是的
長20，你做的不只是

224
00:10:41,850 --> 00:10:45,230
做加1你只是做加
20，加20，加20，加20，

225
00:10:45,230 --> 00:10:48,775
並且可以非常迅速滾動
或通過您的所有數據進行搜索。

226
00:10:48,775 --> 00:10:54,420
>> 可變字符字段，相比之下，
並不總是有20個字符。

227
00:10:54,420 --> 00:10:58,000
它可能具有20然後
15，然後19，然後10，

228
00:10:58,000 --> 00:11:00,720
所以，如果你要搜索
通過它，你不能只是一味地

229
00:11:00,720 --> 00:11:03,050
加上20字節才能到下一個。

230
00:11:03,050 --> 00:11:07,280
你從字面上必須通過搜索
因為數據結構的邊緣，

231
00:11:07,280 --> 00:11:08,340
如果你願意，就是衣衫襤褸。

232
00:11:08,340 --> 00:11:11,480
它種去進出基礎
對串的實際長度。

233
00:11:11,480 --> 00:11:14,460
所以，當你知道的長度，如
賈巴爾說，使用一個char領域，

234
00:11:14,460 --> 00:11:16,460
因為你獲得
被效率

235
00:11:16,460 --> 00:11:19,170
能夠通過更快地搜索
當你正在尋找數據，

236
00:11:19,170 --> 00:11:20,550
否則使用的變量。

237
00:11:20,550 --> 00:11:24,450
>> 不幸的是，我沒有很好的答案
這個名字應該有多長，

238
00:11:24,450 --> 00:11:26,360
但對於像
一個名字，我會說

239
00:11:26,360 --> 00:11:28,470
一個varchar是很常見
因為它不會

240
00:11:28,470 --> 00:11:30,430
要對每個人都有固定的長度。

241
00:11:30,430 --> 00:11:33,650
20，我不知道，20
感覺有點緊。

242
00:11:33,650 --> 00:11:36,460
遠的不說50，50。

243
00:11:36,460 --> 00:11:39,210
它並沒有真正花你的
多說，而不是50 40，

244
00:11:39,210 --> 00:11:41,260
但在某些時候，你需要
做出判斷電話。

245
00:11:41,260 --> 00:11:43,090
>> 很常見的，坦率地說，
對於[？歷史？]

246
00:11:43,090 --> 00:11:47,670
原因，即使它是過度的，
是說255，因為前一段時間，

247
00:11:47,670 --> 00:11:51,440
在流行的數據庫系統，如
MySQL的，免費的開源工具

248
00:11:51,440 --> 00:11:53,790
很多公司的
像Facebook的，即使使用，

249
00:11:53,790 --> 00:11:56,654
這是最大默認
所以人們只是去用它。

250
00:11:56,654 --> 00:11:59,070
所以，不是沒有道理，但我們會
使用多一點的直覺

251
00:11:59,070 --> 00:12:02,970
並說，確定50，這是
可能有點過分。

252
00:12:02,970 --> 00:12:05,720
>> 性別，我喜歡枚舉，
所以我們可以因此

253
00:12:05,720 --> 00:12:08,760
枚舉男性或女性，
或者更有效，

254
00:12:08,760 --> 00:12:13,420
米或F或一些其它符號，但
枚舉感覺就像一個不錯的選擇那裡。

255
00:12:13,420 --> 00:12:16,740
需要明確的是，性別
可能只是一個varchar，

256
00:12:16,740 --> 00:12:19,090
我們可以只是所有
達成協議好的人，

257
00:12:19,090 --> 00:12:21,010
要始終把相同的值出現。

258
00:12:21,010 --> 00:12:22,720
男或女，或諸如此類的東西。

259
00:12:22,720 --> 00:12:27,800
>> 但問題的話，就是我們可以
犯了一個錯誤，[聽不清]提出的

260
00:12:27,800 --> 00:12:29,140
先前在不同的上下文中。

261
00:12:29,140 --> 00:12:32,780
如果我們犯了一個錯誤，我們可以得到
在我們的數據庫中不正確的值。

262
00:12:32,780 --> 00:12:36,320
那麼，什麼是關於數據庫不錯
如Oracle和MySQL等人，

263
00:12:36,320 --> 00:12:39,280
是你有這個最後
那裡的防禦層

264
00:12:39,280 --> 00:12:43,010
你的DBA，數據庫管理員，
不管是誰設計這個表像我們

265
00:12:43,010 --> 00:12:46,440
是口頭上，可以把
到位枚舉了

266
00:12:46,440 --> 00:12:51,250
通過指定防止該
男性，女性，因此沒有人

267
00:12:51,250 --> 00:12:54,230
沒有別的程序員可能會意外
插入任何其他值。

268
00:12:54,230 --> 00:12:55,480
所以，這將是一件好事。

269
00:12:55,480 --> 00:12:56,660
這是一個特點。

270
00:12:56,660 --> 00:13:00,760
>> 因此，一個ID，假設一個數字ID，它
也許應該是一個正整數。

271
00:13:00,760 --> 00:13:04,380
我們有時候確實有
機會來討論長度。

272
00:13:04,380 --> 00:13:06,830
你通常不會
在這裡指定一個號碼，

273
00:13:06,830 --> 00:13:11,310
你會，而不是指定
這是一個int或一個大的INT，

274
00:13:11,310 --> 00:13:12,980
因為他們通常被稱為。

275
00:13:12,980 --> 00:13:18,840
但通常情況下，一個整數
會是這樣，讓我們說，4個字節。

276
00:13:18,840 --> 00:13:23,694
而且，如果它是4個字節，
這是多少位？

277
00:13:23,694 --> 00:13:24,630
>> 聽眾：[聽不清]

278
00:13:24,630 --> 00:13:26,610
>> DAVID MALAN：32位。

279
00:13:26,610 --> 00:13:30,270
因此，我們有多少用戶可以在
我們的數據庫，如果他們都有一個ID

280
00:13:30,270 --> 00:13:33,320
而這個ID必須是唯一的？

281
00:13:33,320 --> 00:13:36,780
32位意味著我們有模式
一個，兩個，三個，四個，five--

282
00:13:36,780 --> 00:13:41,000
零所以有多少不同的模式
和那些可以有，如果有32？

283
00:13:41,000 --> 00:13:43,235
這是同樣的事情
問什麼是兩到32？

284
00:13:43,235 --> 00:13:46,472

285
00:13:46,472 --> 00:13:48,430
這是一個很大的數字，
我不能完全得到正確，

286
00:13:48,430 --> 00:13:50,270
但我知道這是約4十億。

287
00:13:50,270 --> 00:13:53,970
因此，這意味著你的數據庫表可以
有四十億用戶，僅此而已。

288
00:13:53,970 --> 00:13:56,410
>> 所以這是一個有趣的
設計寓意。

289
00:13:56,410 --> 00:14:00,840
公司一個體面的數量
已經決定了，也許沒那麼多

290
00:14:00,840 --> 00:14:04,860
為他們的用戶表，因為有
4個十億用戶來說是一個難得的問題。

291
00:14:04,860 --> 00:14:08,410
這是排序的Facebook式
問題，而不是典型的公司的問題。

292
00:14:08,410 --> 00:14:12,670
但也許，如果您有事務日誌
或某種數據的不斷

293
00:14:12,670 --> 00:14:15,610
被寫入到數據庫
這絕對可能有幾億

294
00:14:15,610 --> 00:14:18,900
與數十億行的，和
你用一個整數吧，

295
00:14:18,900 --> 00:14:22,750
這是怎麼回事盡快發生
你排4號十億

296
00:14:22,750 --> 00:14:26,210
然後嘗試插入
4億個和1個，可以這麼說？

297
00:14:26,210 --> 00:14:29,610
我簡化了數字有點。

298
00:14:29,610 --> 00:14:33,740
>> 您可以切回，我的意思是你
必須以某種方式處理它。

299
00:14:33,740 --> 00:14:37,910
什麼電腦通常會做的，
想想甚至從今天上午，

300
00:14:37,910 --> 00:14:42,430
如果你有一個4位值
像1，1，1，1，其中，

301
00:14:42,430 --> 00:14:44,920
剛剛扳平上午
一起到下午，有什麼

302
00:14:44,920 --> 00:14:48,369
沒有這個數字的二進制表示？

303
00:14:48,369 --> 00:14:49,410
好了，我們會更容易。

304
00:14:49,410 --> 00:14:53,310
這是什麼號碼
二進制代表什麼？

305
00:14:53,310 --> 00:14:56,794
好了，我們會更容易，有什麼
這並不代表二進制？

306
00:14:56,794 --> 00:14:57,460
聽眾：三。

307
00:14:57,460 --> 00:14:59,670
DAVID MALAN：三，因
我們有那些column--

308
00:14:59,670 --> 00:15:00,450
[笑聲]

309
00:15:00,450 --> 00:15:01,350
呼！

310
00:15:01,350 --> 00:15:03,980
我們有那些列
和三三兩兩列。

311
00:15:03,980 --> 00:15:07,250
因此，假設，的確，我們的
[？耕地？]不是32位，

312
00:15:07,250 --> 00:15:13,440
但它有兩個位，我們可以
從用戶號碼0，1，2，3計數，

313
00:15:13,440 --> 00:15:18,040
然後我們種
回到用戶再次00。

314
00:15:18,040 --> 00:15:19,739
因此，這是通常會發生。

315
00:15:19,739 --> 00:15:22,780
如果你曾經聽說過expression--
也許沒有，但如果你have--

316
00:15:22,780 --> 00:15:26,500
整數溢出，你在哪裡
保持翻轉所有位

317
00:15:26,500 --> 00:15:29,640
是最大的可能值，
然後你出位，

318
00:15:29,640 --> 00:15:30,850
通常會發生什麼？

319
00:15:30,850 --> 00:15:32,280
為什麼我說00？

320
00:15:32,280 --> 00:15:33,220
那麼，這是三種。

321
00:15:33,220 --> 00:15:34,230
我如何代表4？

322
00:15:34,230 --> 00:15:36,890

323
00:15:36,890 --> 00:15:38,915
我如何代表
在二進制數4？

324
00:15:38,915 --> 00:15:39,790
聽眾：[聽不清]

325
00:15:39,790 --> 00:15:41,780
DAVID MALAN：One--是啊，
不要說100本身，

326
00:15:41,780 --> 00:15:44,190
因為它有錯
內涵，但1-0-0。

327
00:15:44,190 --> 00:15:48,920
所以這個數字1-0-0確實
正確的，但如果你只有兩位，

328
00:15:48,920 --> 00:15:50,820
你有什麼真正做了什麼？

329
00:15:50,820 --> 00:15:53,219
你已經展期到00。

330
00:15:53,219 --> 00:15:54,760
事實上，這是會發生什麼。

331
00:15:54,760 --> 00:15:56,884
其實，你能想到的
這個更親切。

332
00:15:56,884 --> 00:15:59,350
如果你還記得，什麼，
16年前，世界

333
00:15:59,350 --> 00:16:03,380
本來是要結束時，
Y2K問題發生。

334
00:16:03,380 --> 00:16:04,330
這是為什麼呢？

335
00:16:04,330 --> 00:16:08,170
那麼大多數計算機，為
合理的決定，

336
00:16:08,170 --> 00:16:15,320
被存儲喜歡的數字
1975年或1999年

337
00:16:15,320 --> 00:16:19,010
通過僅僅使用兩個數字
在計算機的存儲器中。

338
00:16:19,010 --> 00:16:21,950
所以當然會發生什麼
當你到2000年，

339
00:16:21,950 --> 00:16:25,790
你到這一點，或者說，是的。

340
00:16:25,790 --> 00:16:30,120
所以，你去到2000年，但如果
你只使用兩位數字看起來

341
00:16:30,120 --> 00:16:32,660
想當年00和
所以你翻了個身。

342
00:16:32,660 --> 00:16:36,820
這就是為什麼很多系統
需要的時候進行更新。

343
00:16:36,820 --> 00:16:42,500
>> 因此，與中說，像公司
Facebook上反對這種跑起來。

344
00:16:42,500 --> 00:16:46,147
因此，要處理的唯一途徑
的情況下，坦率地說，是預測它。

345
00:16:46,147 --> 00:16:47,980
或者，最徹底的方法來
處理這種情況

346
00:16:47,980 --> 00:16:50,330
就是讓你不預期它
稍後必須做出改變。

347
00:16:50,330 --> 00:16:51,970
因此，而不是8個字節，你知道嗎？

348
00:16:51,970 --> 00:16:54,261
我將是前瞻性的思維
這裡，即使它是

349
00:16:54,261 --> 00:16:56,760
樂觀一點說
我們將有4個十億

350
00:16:56,760 --> 00:16:58,850
和1個用戶在我們的網站。

351
00:16:58,850 --> 00:17:01,790
但是，我們只需要使用8個字節，或
64位，其通常將是

352
00:17:01,790 --> 00:17:05,640
所謂的大整數，技術性很強。

353
00:17:05,640 --> 00:17:10,280
而這只是意味著你可以有
更位數你的電話號碼。

354
00:17:10,280 --> 00:17:12,599
但是，這是一個重要的
設計決定，

355
00:17:12,599 --> 00:17:16,400
因為如果你選擇一個數字，
具有表現力的比特太少

356
00:17:16,400 --> 00:17:19,089
你實際上可以創建
在軟件中的錯誤。

357
00:17:19,089 --> 00:17:21,750
>> 好吧，讓我們包
與電子郵件和郵寄地址。

358
00:17:21,750 --> 00:17:26,369
因此，電子郵件，要多長時間
電子郵件地址是什麼？

359
00:17:26,369 --> 00:17:26,869
50。

360
00:17:26,869 --> 00:17:29,220
我真的不知道，但它的
也許類似的東西，

361
00:17:29,220 --> 00:17:32,261
因為否則沒有人會
寫你，如果它變得太長，所以50，

362
00:17:32,261 --> 00:17:33,360
讓我們用它去了。

363
00:17:33,360 --> 00:17:35,770
郵政地址，多久會這樣呢？

364
00:17:35,770 --> 00:17:38,325

365
00:17:38,325 --> 00:17:39,200
聽眾：[聽不清]

366
00:17:39,200 --> 00:17:41,900

367
00:17:41,900 --> 00:17:43,890
>> DAVID MALAN：這不是
只是一個郵政編碼，雖然。

368
00:17:43,890 --> 00:17:45,720
郵政地址，我聽說了。

369
00:17:45,720 --> 00:17:50,720
所以，這就像1布拉特爾廣場，
逗號，劍橋馬薩諸塞，逗號，02138。

370
00:17:50,720 --> 00:17:53,860
而事實上，我只是拉
在這裡一點點的工作表。

371
00:17:53,860 --> 00:17:56,510
這種感覺就像是
一個錯失的機會。

372
00:17:56,510 --> 00:18:01,480
如果我們有1布拉特爾廣場，
逗號，劍橋MA 02138，

373
00:18:01,480 --> 00:18:04,510
我覺得我們可以做的更好
不僅僅是郵政地址。

374
00:18:04,510 --> 00:18:07,100
為什麼我們不這樣爆炸一點點？

375
00:18:07,100 --> 00:18:08,030
我是什麼意思如何？

376
00:18:08,030 --> 00:18:10,970
我們應該有代替
在這裡我們行的，也許？

377
00:18:10,970 --> 00:18:12,260
>> 聽眾：[聽不清]

378
00:18:12,260 --> 00:18:17,579
>> DAVID MALAN：是的，讓我們
street_number調用它，

379
00:18:17,579 --> 00:18:20,620
和下劃線只是一個普通
其方式是什麼樣子的空間，

380
00:18:20,620 --> 00:18:22,360
但它不是，其實。

381
00:18:22,360 --> 00:18:26,240
街，然後city--遺憾？

382
00:18:26,240 --> 00:18:28,440
>> 聽眾：[聽不清]

383
00:18:28,440 --> 00:18:29,690
DAVID MALAN：我們能做到這一點。

384
00:18:29,690 --> 00:18:30,702
一條線，線兩條。

385
00:18:30,702 --> 00:18:32,410
我們為什麼不將保持
簡單現在，

386
00:18:32,410 --> 00:18:34,840
但是這絕對
一個可以接受的決定。

387
00:18:34,840 --> 00:18:38,180
然後狀態，然後讓我們
有點美國為中心的，現在

388
00:18:38,180 --> 00:18:42,040
而只是做郵政編碼，只是因為
它會導致一個有趣的錯誤

389
00:18:42,040 --> 00:18:43,090
或者問題就在這裡。

390
00:18:43,090 --> 00:18:44,655
所以，假設現在我們的地址。

391
00:18:44,655 --> 00:18:47,280
這是一個小更煩人
我們擁有所有這些更多的領域，

392
00:18:47,280 --> 00:18:49,200
但現在我們可以標記
事情更好一點。

393
00:18:49,200 --> 00:18:53,210
>> 所以，現在街道號碼可能
不應該是一個字符，應該嗎？

394
00:18:53,210 --> 00:18:54,835
什麼應該是什麼？

395
00:18:54,835 --> 00:18:55,710
聽眾：[聽不清]

396
00:18:55,710 --> 00:18:57,835
DAVID MALAN：也許，一些
再如一個整數？

397
00:18:57,835 --> 00:19:00,170
一個大的整數？

398
00:19:00,170 --> 00:19:02,170
你可能不活
在4十億大街

399
00:19:02,170 --> 00:19:03,490
或任何瘋狂的那樣。

400
00:19:03,490 --> 00:19:06,850
所以，整數可能
不錯，但有沒有人

401
00:19:06,850 --> 00:19:13,880
曾經住在一個地址一樣
布拉特爾1A廣場，或1和1/2？

402
00:19:13,880 --> 00:19:17,030
這些東西存在的，不幸的是，
即使你沒有住在這裡，

403
00:19:17,030 --> 00:19:21,240
有這些異常
像公寓1A，1B，1C。

404
00:19:21,240 --> 00:19:24,260
所以，你知道嗎，我們或許
不應該去的整數，

405
00:19:24,260 --> 00:19:27,440
否則我們將
失去一些銷售。

406
00:19:27,440 --> 00:19:29,920
>> 煤焦領域，也許？

407
00:19:29,920 --> 00:19:30,870
我不知道過了多久。

408
00:19:30,870 --> 00:19:33,370
它可能不會是
那麼長，所以10還是什麼的。

409
00:19:33,370 --> 00:19:34,950
沒有人會寫
更長一些，也許。

410
00:19:34,950 --> 00:19:37,070
但同樣，我們或許應該
更多地考慮到這一點。

411
00:19:37,070 --> 00:19:39,900
也許谷歌，做一些研究，
但我們會用我們的勇氣去了。

412
00:19:39,900 --> 00:19:44,565
街道，焦炭，50，我不知道。

413
00:19:44,565 --> 00:19:46,940
在某些時候，沒有一個人是怎麼回事
把它寫在一個信封，

414
00:19:46,940 --> 00:19:49,350
過，所以有可能是
一些上界在那裡。

415
00:19:49,350 --> 00:19:54,200
市，同樣的，肯定的，所以燒焦50。

416
00:19:54,200 --> 00:19:59,120
>> 國家，可美國為中心的現在。

417
00:19:59,120 --> 00:20:01,850
因此，它可能是一個列表，那麼親切
的主觀判斷，狀態。

418
00:20:01,850 --> 00:20:04,000
它可以像兩個字符。

419
00:20:04,000 --> 00:20:06,140
所以實際上，也許，我不停地說字符。

420
00:20:06,140 --> 00:20:09,420
我大概的意思VARCHAR，
只是對於一些效率，

421
00:20:09,420 --> 00:20:12,240
但我們會回來的
在瞬間決定。

422
00:20:12,240 --> 00:20:16,150
可能是長2狀態的字符。

423
00:20:16,150 --> 00:20:20,670
如果在美國，他們擁有像馬，
馬薩諸塞州，紐約州，紐約，新澤西州，紐約

424
00:20:20,670 --> 00:20:22,100
澤西，等等。

425
00:20:22,100 --> 00:20:23,630
因此它可以是固定在這一點。

426
00:20:23,630 --> 00:20:25,900
DC華盛頓特區。

427
00:20:25,900 --> 00:20:29,915
>> 但我認為，奧利弗，你
提出的另一種方法。

428
00:20:29,915 --> 00:20:30,790
聽眾：[聽不清]

429
00:20:30,790 --> 00:20:33,670
DAVID MALAN：是的，所以這是一個
有點惱人的輸入，

430
00:20:33,670 --> 00:20:37,890
但枚舉可能會更有意義，
因為這樣一來，至少在美國，

431
00:20:37,890 --> 00:20:41,320
你可以列舉，如果繁瑣，但
您在數據庫中做它只是一次

432
00:20:41,320 --> 00:20:47,480
而不必再想想
它，所有50個雙字符代碼。

433
00:20:47,480 --> 00:20:48,660
所以我喜歡枚舉。

434
00:20:48,660 --> 00:20:51,720
我們堅持有，因為
它像是強制執行更加精確。

435
00:20:51,720 --> 00:20:53,620
然後郵編？

436
00:20:53,620 --> 00:20:55,306
我認為安德魯有一個想法上

437
00:20:55,306 --> 00:20:56,180
聽眾：[聽不清]

438
00:20:56,180 --> 00:20:57,240
DAVID MALAN：是啊，五或九。

439
00:20:57,240 --> 00:20:58,323
我們只是保持簡單。

440
00:20:58,323 --> 00:20:59,380
只要做到五個了。

441
00:20:59,380 --> 00:21:03,070
但是，也許我可以只
做一個整數，對不對？

442
00:21:03,070 --> 00:21:08,750
我可以，但你知道嗎，我做了
這個錯誤有一次，在某種意義上。

443
00:21:08,750 --> 00:21:13,110
幾年前，我從遷移
Microsoft Outlook中到Gmail，

444
00:21:13,110 --> 00:21:18,640
和Outlook具有出口的一種方式
所有聯繫人作為一個Excel文件，

445
00:21:18,640 --> 00:21:21,280
CSV文件，逗號分隔值文件。

446
00:21:21,280 --> 00:21:23,950
我犯的錯，我
想雙擊它，

447
00:21:23,950 --> 00:21:27,380
當我下載的出口，以
確保它看起來就像我的預期。

448
00:21:27,380 --> 00:21:31,320
我必須點擊保存，或讓
自動保存在踢什麼的。

449
00:21:31,320 --> 00:21:35,100
因為當我再進口
它到Gmail，它的所有工作。

450
00:21:35,100 --> 00:21:39,910
但多年以來，這一天，
我這樣做5年，10年前，

451
00:21:39,910 --> 00:21:44,380
我還在尋找誰擁有的朋友
看起來這樣的地址。

452
00:21:44,380 --> 00:21:45,700
為什麼？

453
00:21:45,700 --> 00:21:47,900
>> 聽眾：[聽不清]

454
00:21:47,900 --> 00:21:50,650
>> DAVID MALAN：花了
0，好了，相反，它

455
00:21:50,650 --> 00:21:53,810
把整個郵政編碼為
一個數字，因此，它是

456
00:21:53,810 --> 00:21:56,590
以0開頭，這意味著
它沒有什麼意義。

457
00:21:56,590 --> 00:21:59,470
所以，2138似乎是我的郵政編碼。

458
00:21:59,470 --> 00:22:07,100
這是，坦率地說，一個惱人的Excel
特徵，其中我認為在默認情況下，

459
00:22:07,100 --> 00:22:10,980
即使它的意思，只是
是文本，Microsoft Excel中

460
00:22:10,980 --> 00:22:13,780
做出決定，讓我有所幫助，
哦，我看到的只是數字。

461
00:22:13,780 --> 00:22:15,290
讓我們把這些視為數字。

462
00:22:15,290 --> 00:22:16,790
它截斷前導零。

463
00:22:16,790 --> 00:22:19,165
>> 我向上帝發誓，每對夫婦
個月，我發現一個地址，

464
00:22:19,165 --> 00:22:22,300
並出一種強迫症的，我回去
並添加了0，儘管我從來沒有

465
00:22:22,300 --> 00:22:23,700
發送人的信件或任何東西。

466
00:22:23,700 --> 00:22:25,510
但我仍然發現這個遺跡。

467
00:22:25,510 --> 00:22:28,820
因此，這是說，這是一個好主意？

468
00:22:28,820 --> 00:22:31,610
OK，沒有，因為任何人都在
馬薩諸塞州，在這個區域中，

469
00:22:31,610 --> 00:22:33,270
都將有鄰帶領他們。

470
00:22:33,270 --> 00:22:38,070
所以，讓我們像
焦炭，大概五。

471
00:22:38,070 --> 00:22:41,450
>> 在這裡，我們實現
可以使用一個枚舉，我們

472
00:22:41,450 --> 00:22:44,600
可以列舉萬
可能的郵政編碼，

473
00:22:44,600 --> 00:22:48,530
但感覺它可能
幾根線，如，福利。

474
00:22:48,530 --> 00:22:51,350
如果你輸入的
大量的數據到數據庫

475
00:22:51,350 --> 00:22:52,940
以防止一些東西。

476
00:22:52,940 --> 00:22:57,400
因此，焦炭意識到你可以鍵入
在H-E-L-L-O作為您的郵政編碼，

477
00:22:57,400 --> 00:22:59,180
這是不很明顯，數字。

478
00:22:59,180 --> 00:23:01,680
因此，有沒有辦法，在
一個典型的數據庫，

479
00:23:01,680 --> 00:23:05,561
僅指定數字和
只有5個字符，

480
00:23:05,561 --> 00:23:07,310
所以我們將有
要做到這一點的代碼。

481
00:23:07,310 --> 00:23:11,100
我們將做到這一點在PHP或
Java或任何語言我們

482
00:23:11,100 --> 00:23:14,230
使用在服務器上執行
那種約束。

483
00:23:14,230 --> 00:23:14,860
>> 喔！

484
00:23:14,860 --> 00:23:18,322
所有的權利，所以任何問題，只是還沒有？

485
00:23:18,322 --> 00:23:19,780
讓我們把另一個設計決定。

486
00:23:19,780 --> 00:23:22,500
事實證明，你
也得選擇，

487
00:23:22,500 --> 00:23:26,600
設計一個SQL數據庫時，或
典型的關係型數據庫 - 在哪裡

488
00:23:26,600 --> 00:23:28,790
再次，關係只是
裝置的行和列，

489
00:23:28,790 --> 00:23:35,500
這就是你如何組織你的數據 - 
並認識到這是什麼意思是，

490
00:23:35,500 --> 00:23:37,740
我在被誤導
如此，我這drawing--

491
00:23:37,740 --> 00:23:40,190
是所謂的模式
為一個數據庫表。

492
00:23:40,190 --> 00:23:42,810
這就好比
規格為table--

493
00:23:42,810 --> 00:23:48,040
但是當談到時間
實際存儲數據，

494
00:23:48,040 --> 00:23:52,081
我們將僅僅通過例子在這裡做到這一點。

495
00:23:52,081 --> 00:23:55,080
我要去開拓Excel中，因為
Excel中會給我行和列。

496
00:23:55,080 --> 00:23:58,050
而這正是甲骨文和
MySQL和其他工具會給我。

497
00:23:58,050 --> 00:24:02,270
所以，我只是將使用
它討論的緣故。

498
00:24:02,270 --> 00:24:05,250
讓我繼續前進，開拓
代表性的文檔在這裡，

499
00:24:05,250 --> 00:24:06,310
放大一點。

500
00:24:06,310 --> 00:24:15,200
因此，例如，我們的頭現在
姓氏，姓名，性別，身份證，

501
00:24:15,200 --> 00:24:20,980
電子郵件，門牌號，街道，哎呦。

502
00:24:20,980 --> 00:24:25,710
街道，城市，州，只
有關適合在屏幕上。

503
00:24:25,710 --> 00:24:29,080
>> 所以，這是什麼意思是，當一個
用戶第一次註冊了自己的網站，

504
00:24:29,080 --> 00:24:32,880
這將是這樣的
大衛，馬蘭，男，比方說1，

505
00:24:32,880 --> 00:24:42,910
malan@harvard.edu，街道號碼會
像1布拉特爾廣場，馬薩諸塞州劍橋市，

506
00:24:42,910 --> 00:24:44,780
02138，然後依此類推。

507
00:24:44,780 --> 00:24:48,290
所以，當我說關係數據庫
或SQL數據庫是行和列，

508
00:24:48,290 --> 00:24:49,350
我的意思是這一點。

509
00:24:49,350 --> 00:24:51,900
實際的數據被存儲
以行和列。

510
00:24:51,900 --> 00:24:53,950
這僅僅是一個巧合，
我們談話的時候，

511
00:24:53,950 --> 00:24:56,033
而我只是畫它
出以行和列。

512
00:24:56,033 --> 00:24:58,320
這僅僅是架構，
總體定義。

513
00:24:58,320 --> 00:25:01,640
>> 所以在這裡這些領域，
或等同地，在那裡，

514
00:25:01,640 --> 00:25:06,270
這是你認為的字段
我可能要搜索的，如果我是一個用戶

515
00:25:06,270 --> 00:25:09,200
或者，如果我是數據庫管理員？

516
00:25:09,200 --> 00:25:12,426
就像，哪些領域是我
究竟要搜索的？

517
00:25:12,426 --> 00:25:13,830
>> 聽眾：[聽不清]

518
00:25:13,830 --> 00:25:17,690
>> DAVID MALAN：這個名字，是這樣
我喜歡這樣的事實that--呀，

519
00:25:17,690 --> 00:25:19,750
電子郵件可能是很常見的。

520
00:25:19,750 --> 00:25:21,440
對不起，你說的名字。

521
00:25:21,440 --> 00:25:24,030
所以maybe--又一次，我們
那種說話的抽象。

522
00:25:24,030 --> 00:25:25,988
我不知道為什麼你會
要搜索一個名字，

523
00:25:25,988 --> 00:25:29,340
但如果覺得合理
您正在搜索的用戶。

524
00:25:29,340 --> 00:25:31,170
也許指出，當然，ID。

525
00:25:31,170 --> 00:25:34,100

526
00:25:34,100 --> 00:25:36,160
>> 這是一個滑
坡，因為我可以

527
00:25:36,160 --> 00:25:38,890
圖謀這樣一個場景，
也許我的老闆問我，

528
00:25:38,890 --> 00:25:40,417
我們有多少男人在我們的網站？

529
00:25:40,417 --> 00:25:42,000
有多少女人，我們有我們的網站？

530
00:25:42,000 --> 00:25:45,210
所以在這一點上，您可能希望
搜索在性別字段也一樣，

531
00:25:45,210 --> 00:25:45,940
而不是其他。

532
00:25:45,940 --> 00:25:47,350
所以這裡有一個權衡。

533
00:25:47,350 --> 00:25:49,180
同樣，沒有
正確的答案，但有

534
00:25:49,180 --> 00:25:53,760
在大多數SQL數據庫功能
被稱為索引，即

535
00:25:53,760 --> 00:25:56,100
你的設計者，
數據庫管理員，

536
00:25:56,100 --> 00:26:01,730
獲得提前決定哪
域數據庫應優化

537
00:26:01,730 --> 00:26:02,980
對搜索。

538
00:26:02,980 --> 00:26:07,620
>> 你可以很天真地說，優化
這一點，即優化，這個優化，

539
00:26:07,620 --> 00:26:10,300
優化了這個，
而且該數據庫將

540
00:26:10,300 --> 00:26:14,882
做下面的一些神奇的東西
油煙機，並做一些這樣的方式

541
00:26:14,882 --> 00:26:17,090
在下次搜索時
在任何這些領域，

542
00:26:17,090 --> 00:26:18,400
它將，實際上，會更快。

543
00:26:18,400 --> 00:26:19,110
這個有可能。

544
00:26:19,110 --> 00:26:20,530
它不會取消自己的。

545
00:26:20,530 --> 00:26:22,500
但必須有付出了代價。

546
00:26:22,500 --> 00:26:27,220
>> 如果你天真，或者過​​於狂熱
也就是說，指數所有這些領域，

547
00:26:27,220 --> 00:26:29,810
可以這麼說，讓他們所有的
高效檢索，

548
00:26:29,810 --> 00:26:31,625
什麼樣的價格是你可能付出？

549
00:26:31,625 --> 00:26:32,500
聽眾：[聽不清]

550
00:26:32,500 --> 00:26:33,090
DAVID MALAN：性能。

551
00:26:33,090 --> 00:26:33,798
你什麼意思？

552
00:26:33,798 --> 00:26:37,380
好業績，至少在
背景我討論，現在好多了。

553
00:26:37,380 --> 00:26:38,830
這是索引的定義。

554
00:26:38,830 --> 00:26:41,180
它將使搜索速度更快。

555
00:26:41,180 --> 00:26:43,366
所以時間減少，可以這麼說。

556
00:26:43,366 --> 00:26:44,240
聽眾：[聽不清]

557
00:26:44,240 --> 00:26:45,031
DAVID MALAN：太空。

558
00:26:45,031 --> 00:26:46,520
如此反复，這些都是常見的交易。

559
00:26:46,520 --> 00:26:50,820
我可以加快您的搜索，但它的
要花費你的空間，更多的字節。

560
00:26:50,820 --> 00:26:51,610
為什麼？

561
00:26:51,610 --> 00:26:55,230
那麼，在默認情況下，如果我們有沒有的
這些紅色的星星，沒有這些指標，

562
00:26:55,230 --> 00:26:58,797
因為我是說，你怎麼搜索
在這個數據庫中的名字嗎？

563
00:26:58,797 --> 00:27:00,630
因此，讓我們畫
注意這個例子。

564
00:27:00,630 --> 00:27:06,300
如果我們有大衛和Scully和賈巴爾
和阿瓦等人在這些行，

565
00:27:06,300 --> 00:27:06,910
例如。

566
00:27:06,910 --> 00:27:08,390
>> 因此，讓我們這樣做。

567
00:27:08,390 --> 00:27:13,990
斯卡利是在這裡，再
我們擁有賈巴爾和阿瓦，

568
00:27:13,990 --> 00:27:18,390
和大家一樣，如果你​​不
有一個指標定義，可以這麼說，

569
00:27:18,390 --> 00:27:20,160
你能做的最好的是線性搜索。

570
00:27:20,160 --> 00:27:23,470
如果您搜索阿瓦，我們不
要能夠直接跳到她的

571
00:27:23,470 --> 00:27:24,140
很快。

572
00:27:24,140 --> 00:27:26,556
我們要開始頂
一路走到底，

573
00:27:26,556 --> 00:27:28,600
不是不像我們原來的
邁克·史密斯的例子。

574
00:27:28,600 --> 00:27:33,470
>> 但是，如果我說，哎，數據庫，
索引的第一個名字領域，

575
00:27:33,470 --> 00:27:37,000
那麼它要做些什麼
票友和支持的東西

576
00:27:37,000 --> 00:27:38,130
像二進制搜索。

577
00:27:38,130 --> 00:27:39,820
它可能不是本身二進制搜索。

578
00:27:39,820 --> 00:27:42,810
數據庫傾向於使用另一
數據結構稱為B-樹，

579
00:27:42,810 --> 00:27:46,540
不要與二叉樹混淆，
只是使它更快地搜索

580
00:27:46,540 --> 00:27:48,500
東西自然對數。

581
00:27:48,500 --> 00:27:53,510
但價格你付出建立了
特徵，在存儲器中的數據結構，

582
00:27:53,510 --> 00:27:54,570
是多個字節。

583
00:27:54,570 --> 00:27:57,170
因此，它可能需要一些兆，
一些千兆字節，誰知道？

584
00:27:57,170 --> 00:27:58,410
這取決於數據。

585
00:27:58,410 --> 00:28:02,640
>> 所以，在某些時候，你必須決定，
這可能不是一個常見的情況。

586
00:28:02,640 --> 00:28:06,000
那麼，什麼是實際通用
情況下，如果你真的不得不選擇，

587
00:28:06,000 --> 00:28:10,080
什麼也許你喜歡的領域是什麼？

588
00:28:10,080 --> 00:28:10,580
電子郵件。

589
00:28:10,580 --> 00:28:14,400
我喜歡電子郵件，因為電子郵件，
在理論上應該是唯一的。

590
00:28:14,400 --> 00:28:17,650
所以通常情況下，當你知道
事先，你的領域之一

591
00:28:17,650 --> 00:28:20,277
是或將是獨一無二的，這
往往是一個很好的領域

592
00:28:20,277 --> 00:28:22,860
要搜索的，因為這樣一來，
當你搜索的東西，

593
00:28:22,860 --> 00:28:26,194
你要拿回一個或
零響應，然後就大功告成了。

594
00:28:26,194 --> 00:28:28,110
你不必繼續
尋找還有一些。

595
00:28:28,110 --> 00:28:31,992
>> 因此在這種情況下，在這裡，電子郵件，
只要你不能兩次註冊

596
00:28:31,992 --> 00:28:33,450
用相同的電子郵件，是一個很好的一個。

597
00:28:33,450 --> 00:28:36,710
通過定義ID，在
計算機科學世界裡，

598
00:28:36,710 --> 00:28:39,610
如果你在談論一個
ID，那最好是唯一的。

599
00:28:39,610 --> 00:28:42,970
這是排序的內涵
的ID或標識。

600
00:28:42,970 --> 00:28:46,440
及的這些其餘的可能是，
讓我們打電話給他們很好的富人，

601
00:28:46,440 --> 00:28:47,860
但並不真正需要。

602
00:28:47,860 --> 00:28:49,976
>> 因此在一個數據庫中，
您指定索引，

603
00:28:49,976 --> 00:28:51,350
但你可以更加精確。

604
00:28:51,350 --> 00:28:56,060
你可以說，哎，數據庫，確保
在這個表中的每個ID都是唯一的。

605
00:28:56,060 --> 00:28:59,330
甚至不要讓一個程序員
不小心把一個重複的電子郵件

606
00:28:59,330 --> 00:29:00,740
或重複的ID號。

607
00:29:00,740 --> 00:29:03,140
那麼像枚舉
保護我們同樣的，你

608
00:29:03,140 --> 00:29:04,881
可以有那些低級別的防禦。

609
00:29:04,881 --> 00:29:07,130
因此數據庫的設計，
從某種意義上說，是一種樂趣，

610
00:29:07,130 --> 00:29:08,380
因為你這樣做防守。

611
00:29:08,380 --> 00:29:11,460
你那種假設你的工作
與可怕，可怕的程序員

612
00:29:11,460 --> 00:29:15,550
你希望把盡可能多的防禦
你可以保護您的數據，

613
00:29:15,550 --> 00:29:18,940
但同時你要
以幫助他們更好的表現

614
00:29:18,940 --> 00:29:21,386
通過選擇
字段以優化。

615
00:29:21,386 --> 00:29:24,260
但是你不一定能做到這一點的
就像我們的真空樣的都在這裡。

616
00:29:24,260 --> 00:29:26,480
你得知道什麼是
這些常見的情況之中。

617
00:29:26,480 --> 00:29:29,397
如果開發者
實現一個地址簿，

618
00:29:29,397 --> 00:29:32,230
你很可能會希望能夠
在幾乎每一個領域搜索，

619
00:29:32,230 --> 00:29:33,830
只是應用程序的性質。

620
00:29:33,830 --> 00:29:37,910
因此，也許你花
該額外的空間。

621
00:29:37,910 --> 00:29:39,090
>> 對了，什麼問題嗎？

622
00:29:39,090 --> 00:29:41,820

623
00:29:41,820 --> 00:29:42,486
是啊。

624
00:29:42,486 --> 00:29:43,470
>> 聽眾：[聽不清]

625
00:29:43,470 --> 00:29:44,404
>> DAVID MALAN：否

626
00:29:44,404 --> 00:29:45,279
>> 聽眾：[聽不清]

627
00:29:45,279 --> 00:29:47,840

628
00:29:47,840 --> 00:29:48,826
>> DAVID MALAN：OK。

629
00:29:48,826 --> 00:29:49,701
>> 聽眾：[聽不清]

630
00:29:49,701 --> 00:29:52,420

631
00:29:52,420 --> 00:29:54,850
>> DAVID MALAN：哦，所以我們
在某種程度上說的

632
00:29:54,850 --> 00:29:57,940
現在是完全與語言無關。

633
00:29:57,940 --> 00:30:02,370
因此，我們現在談論的
關係數據庫更一般地，

634
00:30:02,370 --> 00:30:04,760
或SQL數據庫更普遍。

635
00:30:04,760 --> 00:30:06,870
>> 聽眾：[聽不清]

636
00:30:06,870 --> 00:30:10,030
>> DAVID MALAN：一個更好的詞來使用
是，可以用任何語言來使用。

637
00:30:10,030 --> 00:30:15,280
所以，我可以寫JavaScript代碼，C
代碼，C ++代碼，Java代碼，Ruby代碼，

638
00:30:15,280 --> 00:30:19,010
所有這一切跟一個
數據庫和執行查詢。

639
00:30:19,010 --> 00:30:22,310
事實上，這不是一個壞
Segue公司一個例子查詢。

640
00:30:22,310 --> 00:30:25,720
再次，我們不會進入
Java或C ++或任何這樣了，

641
00:30:25,720 --> 00:30:29,420
但在SQL中，語言我保持
指，結構化查詢語言，

642
00:30:29,420 --> 00:30:32,790
這本身是一種編程語言，
但它的意思用於，沒有

643
00:30:32,790 --> 00:30:37,330
驚訝的是，結構化查詢的查詢。

644
00:30:37,330 --> 00:30:38,660
>> 我的意思是這一點。

645
00:30:38,660 --> 00:30:41,190
你選擇數據的方法
從MySQL數據庫

646
00:30:41,190 --> 00:30:49,330
是你從字面上鍵入程序
像從用戶選擇的明星。

647
00:30:49,330 --> 00:30:52,200
我假設這個表，
從此被稱為用戶。

648
00:30:52,200 --> 00:30:54,860
我可以把它稱為我們想要的東西，
但那種有道理。

649
00:30:54,860 --> 00:30:57,240
所以選擇是一個非常
常見的動詞，如果你

650
00:30:57,240 --> 00:30:59,290
將在SQL中，硬是做到這一點。

651
00:30:59,290 --> 00:31:02,730
您如何看待明星
裝置在這方面？

652
00:31:02,730 --> 00:31:04,410
>> 聽眾：[聽不清]

653
00:31:04,410 --> 00:31:05,380
>> DAVID MALAN：對不起？

654
00:31:05,380 --> 00:31:06,300
>> 聽眾：[聽不清]

655
00:31:06,300 --> 00:31:09,580
>> DAVID MALAN：不需要，它是
比這更包容，其實。

656
00:31:09,580 --> 00:31:11,700
這是通配符。

657
00:31:11,700 --> 00:31:14,740
星幾乎總是意味著什麼，
因此，這意味著，在這種情況下，

658
00:31:14,740 --> 00:31:16,510
選擇一切從數據庫。

659
00:31:16,510 --> 00:31:20,730
所以，當我這樣說，我的意思是
給我回的每列

660
00:31:20,730 --> 00:31:22,440
從我的表叫用戶。

661
00:31:22,440 --> 00:31:24,730
所以給我一個結果集，因為它被稱為。

662
00:31:24,730 --> 00:31:28,210
換句話說，給我的一份
電子表格，就是我在獲得。

663
00:31:28,210 --> 00:31:34,890
>> 但如果我說，從用戶選擇星級
其中ID等於1，有多大應該

664
00:31:34,890 --> 00:31:36,640
我的結果集中呢？

665
00:31:36,640 --> 00:31:41,680
或者相當於多少行應
我從數據庫中遞回？

666
00:31:41,680 --> 00:31:45,860
也許只有一個，如果我真的有
處理ID作為唯一標識符

667
00:31:45,860 --> 00:31:50,710
如果大衛有一個唯一的ID，我
應當得到一個且只有一個行

668
00:31:50,710 --> 00:31:53,220
包含所有的大衛的信息。

669
00:31:53,220 --> 00:31:56,390
如果我說，這其中的ID
等於99，我應該回去，

670
00:31:56,390 --> 00:32:00,320
在這種情況下，零行，
至少在時刻。

671
00:32:00,320 --> 00:32:03,620
>> 但是，如果我真的不關心
所有這些信息，

672
00:32:03,620 --> 00:32:06,970
我只是說，哪裡大衛住在哪裡？

673
00:32:06,970 --> 00:32:10,860
從選擇郵政編碼
用戶ID為1。

674
00:32:10,860 --> 00:32:15,820
這將選擇對我來說只有大衛的拉鍊
代碼和該行不是全部。

675
00:32:15,820 --> 00:32:19,541
我為什麼會這樣做而不是
明星查詢，外卡？

676
00:32:19,541 --> 00:32:21,950
>> 聽眾：[聽不清]

677
00:32:21,950 --> 00:32:24,590
>> DAVID MALAN：是的，我可能只需要它。

678
00:32:24,590 --> 00:32:26,350
因此性能又是這裡的答案。

679
00:32:26,350 --> 00:32:28,540
為什麼要求更多
信息比你需要的，

680
00:32:28,540 --> 00:32:32,020
因為即使它的所有權利在一起，
你還是要複製的數據，

681
00:32:32,020 --> 00:32:35,560
這似乎從數據庫
到你的程序不知何故，

682
00:32:35,560 --> 00:32:38,490
而這，如果你只是傻
只需要這些數字五，

683
00:32:38,490 --> 00:32:40,340
該行的不全部。

684
00:32:40,340 --> 00:32:42,180
>> 那麼，如何插入一個用戶？

685
00:32:42,180 --> 00:32:44,780
假設用戶剛
登記為第一次。

686
00:32:44,780 --> 00:32:46,560
語法通常是這樣的。

687
00:32:46,560 --> 00:32:52,700
插入到用戶，
那麼我們會說值，

688
00:32:52,700 --> 00:33:00,150
然後我們會說值
像，讓我們說，勞倫斯庫利，

689
00:33:00,150 --> 00:33:02,380
我們這裡的攝影師。

690
00:33:02,380 --> 00:33:04,390
和下一個字段是性別。

691
00:33:04,390 --> 00:33:08,020
所以我們會說報價，引文結束
“F”，那麼我們有一個ID

692
00:33:08,020 --> 00:33:12,250
而我要say--讓我們
假裝她實際上不是在這裡，

693
00:33:12,250 --> 00:33:14,380
所以我們會在故事中後退。

694
00:33:14,380 --> 00:33:16,530
SO 2將是她的ID。

695
00:33:16,530 --> 00:33:19,130
然後下一個字段
這裡是她的電子郵件。

696
00:33:19,130 --> 00:33:22,140
因此，它要像
勞倫斯卡利等等，

697
00:33:22,140 --> 00:33:24,360
而我們只是點點
從這裡點上它了。

698
00:33:24,360 --> 00:33:26,890
現在它將會得到一點點
乏味，但插入查詢

699
00:33:26,890 --> 00:33:28,310
最終將像她那樣。

700
00:33:28,310 --> 00:33:30,970
>> 如果我想擺脫
斯庫利，嗯，哦，讓我們註銷

701
00:33:30,970 --> 00:33:37,420
她，她會刪除她的賬戶，
從那裡ID等於2的用戶刪除，

702
00:33:37,420 --> 00:33:38,500
將擺脫斯卡利的。

703
00:33:38,500 --> 00:33:48,050
或者，我可以說，更新用戶設置，
比方說，我們有什麼可以改變？

704
00:33:48,050 --> 00:33:49,430
假設她的動作。

705
00:33:49,430 --> 00:33:53,730
集拉鍊等於021--不，
這是她目前的拉鍊。

706
00:33:53,730 --> 00:33:54,487
90210。

707
00:33:54,487 --> 00:33:56,320
唯一的其他郵政編碼
我知道世界。

708
00:33:56,320 --> 00:33:59,002
因此，將改變
她居然ZIP代碼 - ，

709
00:33:59,002 --> 00:34:00,460
這不會改變她的郵政編碼。

710
00:34:00,460 --> 00:34:02,170
>> 什麼我只是做？

711
00:34:02,170 --> 00:34:04,292
即使語法可能是新的。

712
00:34:04,292 --> 00:34:05,302
>> 聽眾：[聽不清]

713
00:34:05,302 --> 00:34:08,010
DAVID MALAN：是的，我感動眾人
以加利福尼亞州貝弗利山莊。

714
00:34:08,010 --> 00:34:11,920
所以我實際上應該
說得清ID等於2。

715
00:34:11,920 --> 00:34:12,820
等等。

716
00:34:12,820 --> 00:34:15,290
因此，SQL是所有關於這些
種指令。

717
00:34:15,290 --> 00:34:20,260
選擇，插入，刪除，更新​​，
這些謂詞末

718
00:34:20,260 --> 00:34:22,139
這些where子句，可以這麼說。

719
00:34:22,139 --> 00:34:25,170
而且還有很多更可以
這樣做，但它實際上只是歸結

720
00:34:25,170 --> 00:34:29,750
簡單，如果arcanely，表達
你想要什麼數據庫做的。

721
00:34:29,750 --> 00:34:31,580
>> 然後將數據庫
何時會弄清楚，

722
00:34:31,580 --> 00:34:35,630
您將勞倫斯卡利到
數據庫中，把她的記憶

723
00:34:35,630 --> 00:34:38,230
這樣我們就可以很快得到
她以她的電子郵件地址

724
00:34:38,230 --> 00:34:42,610
或基於她的ID號碼等。

725
00:34:42,610 --> 00:34:43,391
是啊，丹。

726
00:34:43,391 --> 00:34:44,266
聽眾：[聽不清]

727
00:34:44,266 --> 00:34:46,364

728
00:34:46,364 --> 00:34:47,780
DAVID MALAN：非常好的問題。

729
00:34:47,780 --> 00:34:50,370
將這些腳本從改變
微軟訪問Oracle

730
00:34:50,370 --> 00:34:52,290
到MySQL到PostgreSQL？

731
00:34:52,290 --> 00:34:53,790
簡短的答案是它依賴。

732
00:34:53,790 --> 00:34:58,697
在理論上，有一個很
SQL的顯著公共子集

733
00:34:58,697 --> 00:35:00,780
這是在所有共享
的這些實施方式。

734
00:35:00,780 --> 00:35:03,340
但是，不同的製造商
有附加功能

735
00:35:03,340 --> 00:35:07,120
它們的數據庫做某些事情
超出這些特徵的範圍，

736
00:35:07,120 --> 00:35:08,720
可能，事實上，斷裂。

737
00:35:08,720 --> 00:35:11,210
>> 因此，開發商的方式
規避這一點，

738
00:35:11,210 --> 00:35:14,350
是，而不是寫生
SQL代碼就像我寫在這裡，

739
00:35:14,350 --> 00:35:19,460
他們改用庫，
公用庫本身

740
00:35:19,460 --> 00:35:23,650
是有點高層次和摘要
遠離你正在使用的產品。

741
00:35:23,650 --> 00:35:25,710
和它給你
函數和過程

742
00:35:25,710 --> 00:35:28,810
打電話，讓你永遠不會
其實寫原始SQL。

743
00:35:28,810 --> 00:35:32,609
>> 從理論上講，那麼，你可以改變
產品從Oracle到微軟

744
00:35:32,609 --> 00:35:34,650
反之亦然或任何
否則，你從字面上

745
00:35:34,650 --> 00:35:36,920
改變一無所知你的代碼。

746
00:35:36,920 --> 00:35:40,180
事實上，雖然，你有時
放棄功能作為一個結果。

747
00:35:40,180 --> 00:35:43,860
你可能已經選擇了一個產品，因為
它有這些增值功能，

748
00:35:43,860 --> 00:35:46,610
而你現在只是不
使用它們自覺。

749
00:35:46,610 --> 00:35:51,630
>> 據傳與大多數公司傾向於
從來沒有擺脫他們的數據庫了。

750
00:35:51,630 --> 00:35:54,002
因此，儘管這是一個不錯的
有特色，現實

751
00:35:54,002 --> 00:35:55,960
是，如果你正在檢修
你的數據庫，你

752
00:35:55,960 --> 00:35:59,890
可能使得其他變化束
反正，你不一定

753
00:35:59,890 --> 00:36:01,360
需要預期。

754
00:36:01,360 --> 00:36:03,720
因此，它可以說是
超過了實際工程問題，

755
00:36:03,720 --> 00:36:05,670
但它確實取決於上下文。

756
00:36:05,670 --> 00:36:09,960
但在理論上，SQL共享
在這些不同的產品。

757
00:36:09,960 --> 00:36:11,560
真是好問題。

758
00:36:11,560 --> 00:36:12,272
是啊。

759
00:36:12,272 --> 00:36:13,147
>> 聽眾：[聽不清]

760
00:36:13,147 --> 00:36:17,820

761
00:36:17,820 --> 00:36:21,480
>> DAVID MALAN：是啊，所以
你能想到一個數據庫

762
00:36:21,480 --> 00:36:25,020
僅僅是一個服務器，在結束時
一天，以及該服務器的內部

763
00:36:25,020 --> 00:36:28,670
是一大堆
表，行和列。

764
00:36:28,670 --> 00:36:33,410
而當你發送一個這樣的查詢
從您的程序，你的網站，

765
00:36:33,410 --> 00:36:39,340
用Java編寫的，紅寶石，巨蟒，什麼的，
服務器接收到這個指令

766
00:36:39,340 --> 00:36:41,660
和解釋它
從字面上以同樣的方式

767
00:36:41,660 --> 00:36:43,660
我們前面討論過用
解釋型語言，

768
00:36:43,660 --> 00:36:47,333
然後進行零一些動作
或更多行中的零個或多個表。

769
00:36:47,333 --> 00:36:48,208
聽眾：[聽不清]

770
00:36:48,208 --> 00:36:53,540

771
00:36:53,540 --> 00:36:55,070
>> DAVID MALAN：沒錯，沒錯。

772
00:36:55,070 --> 00:36:58,450
因此，偽的東西
像這可能是這一點。

773
00:36:58,450 --> 00:37:02,450
在你的PHP文件或
Python的文件或您的Java文件，

774
00:37:02,450 --> 00:37:09,210
你將有偽代碼，或
刮樣塊作為，如果用戶訪問

775
00:37:09,210 --> 00:37:19,870
acme.com/register~~V的第一次，
然後插入到用戶，等等。

776
00:37:19,870 --> 00:37:22,619
我們將轉化這
到底更具體的代碼。

777
00:37:22,619 --> 00:37:24,660
不過說真的，我們都
積木在這裡，

778
00:37:24,660 --> 00:37:27,680
即使我們跳過一些
的實施步驟。

779
00:37:27,680 --> 00:37:31,560
>> 因此，讓我找到什麼缺點，我們
奇妙確實剛才。

780
00:37:31,560 --> 00:37:36,470
你已經創建了一個漂亮的
為用戶完整表格。

781
00:37:36,470 --> 00:37:38,920
誠然，我們可以實現
它的幾個不同的方式，

782
00:37:38,920 --> 00:37:43,030
但你實際上已經帶領我們
下path--和我說你，

783
00:37:43,030 --> 00:37:48,080
但它可能是我的一個相當fault--
低效的數據庫實現。

784
00:37:48,080 --> 00:37:49,950
它不歸。

785
00:37:49,950 --> 00:37:52,320
>> 並通過規範化我的意思
那裡將是，

786
00:37:52,320 --> 00:37:57,380
隨著時間的推移，一個顯著冗餘，
因此效率低下，

787
00:37:57,380 --> 00:38:00,210
即浪費空間。

788
00:38:00,210 --> 00:38:05,650
僅基於你在這裡看到，可以
你想像的空間，這種浪費

789
00:38:05,650 --> 00:38:08,710
是從哪兒來，隨著時間的推移，
隨著越來越多的用戶註冊

790
00:38:08,710 --> 00:38:10,860
為您的網站？

791
00:38:10,860 --> 00:38:13,047
哪些數據可能會變得多餘？

792
00:38:13,047 --> 00:38:19,084

793
00:38:19,084 --> 00:38:20,940
>> 聽眾：[聽不清]

794
00:38:20,940 --> 00:38:22,686
>> DAVID MALAN：為什麼你的意思是？

795
00:38:22,686 --> 00:38:23,561
聽眾：[聽不清]

796
00:38:23,561 --> 00:38:32,180

797
00:38:32,180 --> 00:38:32,930
DAVID MALAN：是的。

798
00:38:32,930 --> 00:38:35,622
讓我們承擔起施行
今天這是真的。

799
00:38:35,622 --> 00:38:38,330
事實證明，我們已經學會了這
硬盤的方式，這是不正確的。

800
00:38:38,330 --> 00:38:41,670
不知怎的，多個城市都有，
不知何故，相同的郵政編碼，

801
00:38:41,670 --> 00:38:43,390
打破這個奇妙的直覺。

802
00:38:43,390 --> 00:38:46,180
但是讓我們假設這是真的，
因為它幾乎總是如此。

803
00:38:46,180 --> 00:38:51,390
因此，假設一個郵政編碼是
始終與同一個城市關聯

804
00:38:51,390 --> 00:38:53,600
和狀態，這是一種
合理的假設，

805
00:38:53,600 --> 00:38:54,840
但不正確的，事實證明。

806
00:38:54,840 --> 00:38:57,310
但是，一個合理的假設
今天的目的。

807
00:38:57,310 --> 00:39:01,650
>> 然後，假設我住在劍橋，
馬，根據該用戶的表，

808
00:39:01,650 --> 00:39:04,100
並假設勞倫
斯庫利住在馬薩諸塞州劍橋市，

809
00:39:04,100 --> 00:39:06,120
並假設賈巴爾
住在馬薩諸塞州劍橋市，

810
00:39:06,120 --> 00:39:10,400
阿瓦和住在劍橋，
MA，我們都在02138。

811
00:39:10,400 --> 00:39:15,890
為什麼我們要記住劍橋，
MA，02138為我們四個？

812
00:39:15,890 --> 00:39:18,903
我應該足以記得嗎？

813
00:39:18,903 --> 00:39:20,249
>> 聽眾：[聽不清]

814
00:39:20,249 --> 00:39:21,540
DAVID MALAN：只要郵政編碼。

815
00:39:21,540 --> 00:39:25,080
只是，02138存在，因為
你知道我們能做什麼？

816
00:39:25,080 --> 00:39:32,650
我們可以在這裡得到一點花哨
而在這裡，定義另一個表

817
00:39:32,650 --> 00:39:35,850
這是怎麼回事是
的名字，這將是該類型，

818
00:39:35,850 --> 00:39:38,840
這將是該
長度，從今以後，我

819
00:39:38,840 --> 00:39:42,900
去這個叫我的城市表。

820
00:39:42,900 --> 00:39:47,011
這就是所謂的
當然，我的用戶表。

821
00:39:47,011 --> 00:39:49,885
所以我應該把在這裡
我的城市表，你覺得呢？

822
00:39:49,885 --> 00:39:53,605

823
00:39:53,605 --> 00:39:54,535
>> 聽眾：[聽不清]

824
00:39:54,535 --> 00:39:55,930
>> DAVID MALAN：是的。

825
00:39:55,930 --> 00:40:01,440
所以，拉鍊以及州和城市。

826
00:40:01,440 --> 00:40:05,350
所以，這裡的類型，我們會說
這將是一個char 5再次，

827
00:40:05,350 --> 00:40:06,750
受先前的辯論。

828
00:40:06,750 --> 00:40:14,810
這將是一個枚舉，也許像
之前，市將是一個VARCHAR 50。

829
00:40:14,810 --> 00:40:17,960
所以現在我能得到什麼
從該表中刪除

830
00:40:17,960 --> 00:40:21,995
以消除低效率？

831
00:40:21,995 --> 00:40:23,100
>> 聽眾：[聽不清]

832
00:40:23,100 --> 00:40:23,850
DAVID MALAN：好的。

833
00:40:23,850 --> 00:40:30,239
國家和城市走，所以我現在已經
消除潛在的低效率

834
00:40:30,239 --> 00:40:33,280
對於冗餘記住，劍橋，
MA，劍橋，麻省，劍橋，麻省，

835
00:40:33,280 --> 00:40:35,712
馬薩諸塞州劍橋市，對此，希望
是永遠不會改變。

836
00:40:35,712 --> 00:40:37,670
即使是這樣，它的
minorly煩人，現在

837
00:40:37,670 --> 00:40:39,750
我不得不改變
它在多行，

838
00:40:39,750 --> 00:40:43,770
而在這裡，我可以只
改變它在一個地方。

839
00:40:43,770 --> 00:40:46,890
>> 現在有什麼取捨，也許？

840
00:40:46,890 --> 00:40:48,020
這是超級方便。

841
00:40:48,020 --> 00:40:50,730
我所有的數據必須很好地在一起。

842
00:40:50,730 --> 00:40:53,644
但顯然現在的情況？

843
00:40:53,644 --> 00:40:55,684
>> 聽眾：[聽不清]

844
00:40:55,684 --> 00:40:58,100
DAVID MALAN：沒錯，我
很高興你用這個詞加入，

845
00:40:58,100 --> 00:41:01,320
因為這實際上是關鍵字，
在關係數據庫中的世界

846
00:41:01,320 --> 00:41:05,270
在SQL中，這是一個實際的詞你
可以鍵入或至少傳達。

847
00:41:05,270 --> 00:41:09,280
而事實上，我們現在要做的
選擇大衛的完整信息

848
00:41:09,280 --> 00:41:19,700
像從選擇星級
用戶，加入城市，on--現在

849
00:41:19,700 --> 00:41:24,010
我將只是移動到第二行
為了使本fits-- users.zip等於

850
00:41:24,010 --> 00:41:34,570
cities.zip，其中users.ID等於1。

851
00:41:34,570 --> 00:41:35,550
>> 發生什麼了？

852
00:41:35,550 --> 00:41:38,970
這是難看，但你可以種
讀它從左到右，從上到下。

853
00:41:38,970 --> 00:41:41,030
從用戶選擇星級
是像以前一樣，

854
00:41:41,030 --> 00:41:42,930
但它不是從用戶本身。

855
00:41:42,930 --> 00:41:45,910
這是一個從用戶加入的城市。

856
00:41:45,910 --> 00:41:48,520
那我就加入這兩個表嗎？

857
00:41:48,520 --> 00:41:51,820
那麼，顯然，
用戶表拉鍊領域，

858
00:41:51,820 --> 00:41:54,810
而這期間僅僅是特殊
語法來表達想法，

859
00:41:54,810 --> 00:41:58,130
這就是城市的表壓縮領域。

860
00:41:58,130 --> 00:42:01,580
我想這兩個相等，
但我想最終選擇

861
00:42:01,580 --> 00:42:06,280
只有那些的行
在用戶表ID

862
00:42:06,280 --> 00:42:08,730
等於1，這正好是我的。

863
00:42:08,730 --> 00:42:11,781
>> 而僅僅是明確的，一個
程序員，通常在

864
00:42:11,781 --> 00:42:14,780
硬編碼像數
1，否則只有網站

865
00:42:14,780 --> 00:42:17,630
支持大衛或
第一個用戶，你

866
00:42:17,630 --> 00:42:20,720
將改為做
像ID，其中

867
00:42:20,720 --> 00:42:22,510
這代表了一​​個
變量，這東西

868
00:42:22,510 --> 00:42:26,210
可以隨時間改變，類似
在精神上我剛才所說

869
00:42:26,210 --> 00:42:28,080
這些類型的佔位符。

870
00:42:28,080 --> 00:42:30,396
但現在我們只是硬編碼為1。

871
00:42:30,396 --> 00:42:31,520
所以這是什麼意思？

872
00:42:31,520 --> 00:42:35,100
好了，這個可視化的好方法是
如果這手是用戶表，

873
00:42:35,100 --> 00:42:38,090
這手是拉鍊
表中，我們都有點finding--

874
00:42:38,090 --> 00:42:41,330
我的手指的技巧是ZIP
在這裡，我的手指的技巧

875
00:42:41,330 --> 00:42:43,740
這裡有拉鍊，你
一種是環環相扣

876
00:42:43,740 --> 00:42:47,950
讓你回來的結果
原始表，由真正加盟

877
00:42:47,950 --> 00:42:49,590
這兩個表的公共字段。

878
00:42:49,590 --> 00:42:50,840
它不必須是拉鍊。

879
00:42:50,840 --> 00:42:54,460
它可以是任何其它的事，但
拉鍊是好的，因為一個，因為它很短，

880
00:42:54,460 --> 00:42:56,470
二，它總是
相同的長度，所以有

881
00:42:56,470 --> 00:43:02,270
一個真正的效益是什麼
奧利維爾這裡提出

882
00:43:02,270 --> 00:43:05,200
與分解出ZIP和
[聽不清]提議我們擺脫

883
00:43:05,200 --> 00:43:07,110
城市和狀態。

884
00:43:07,110 --> 00:43:11,370
>> 因此，這是一個過程
被稱為正常化。

885
00:43:11,370 --> 00:43:14,171
上有問題嗎？

886
00:43:14,171 --> 00:43:16,170
那麼，讓我指出
這是什麼樣的東西，

887
00:43:16,170 --> 00:43:19,202
即使它是相當級別低，
這次討論中，你會覺得

888
00:43:19,202 --> 00:43:20,910
你那種得到
失去了雜草，

889
00:43:20,910 --> 00:43:26,690
這是充分體現
對於開發商的機會是壞的。

890
00:43:26,690 --> 00:43:29,600
而事實上，我們即使在
課程我教過，當我們已經有，

891
00:43:29,600 --> 00:43:32,290
例如，缺乏經驗
本科程序員

892
00:43:32,290 --> 00:43:35,920
建立網站，乍一看，
網站看起來棒極了。

893
00:43:35,920 --> 00:43:38,280
他們擁有所有的
功能我們的要求，

894
00:43:38,280 --> 00:43:40,650
開發商的工作做得很好。

895
00:43:40,650 --> 00:43:43,370
>> 但他們並不一定知道
足夠的了解數據庫設計

896
00:43:43,370 --> 00:43:46,680
或者他們沒有想到辛苦
足夠的了解的數據類型

897
00:43:46,680 --> 00:43:49,220
和類型的用戶的的
網站將不得不，

898
00:43:49,220 --> 00:43:53,240
我們發現，那麼，半年之後，
之後，他們已經畢業或移動時，

899
00:43:53,240 --> 00:43:56,016
那該死的，我們的網站
真的，真的很慢。

900
00:43:56,016 --> 00:43:58,890
而且我還沒有談到有
數百萬或幾千個用戶。

901
00:43:58,890 --> 00:44:02,580
我的意思是在校園裡幾百個用戶，
所有的人都喜歡，比如，

902
00:44:02,580 --> 00:44:04,870
店在課程
同時，他們

903
00:44:04,870 --> 00:44:07,010
使用課程目錄
應用我所提到的

904
00:44:07,010 --> 00:44:10,410
而事情是變得非常
慢，因為沒有索引。

905
00:44:10,410 --> 00:44:13,740
目前還沒有紅色恆星，所以
說話，或者我們不得不不一定

906
00:44:13,740 --> 00:44:17,690
分解出來通用數據
得到的空間節省一些。

907
00:44:17,690 --> 00:44:21,880
>> 所以審查開發商的時候
或數據庫的人或類似物

908
00:44:21,880 --> 00:44:25,864
題型想通過
甚至，審查別人的代碼時，

909
00:44:25,864 --> 00:44:28,530
也就是說，不一定看
通過他們所有的代碼，但是說，

910
00:44:28,530 --> 00:44:30,154
讓我們來看看通過數據庫表。

911
00:44:30,154 --> 00:44:31,150
你在存儲？

912
00:44:31,150 --> 00:44:33,941
然後說，好吧，等
分鐘，你為什麼要使用一個整數？

913
00:44:33,941 --> 00:44:36,224
如果我們有4個十億
和這些行的1？

914
00:44:36,224 --> 00:44:38,140
與這些類型的
問題是一個機會

915
00:44:38,140 --> 00:44:40,170
來樣推回並
得到的，其中檢測

916
00:44:40,170 --> 00:44:42,300
如果你不舒服做
它有更多的人技術

917
00:44:42,300 --> 00:44:45,425
問這些問題的，不論是否
人真正知道他們的東西。

918
00:44:45,425 --> 00:44:47,890
這是什麼樣的
的東西，那就是，人

919
00:44:47,890 --> 00:44:50,540
在互聯網上誰
是自學成才的，也許

920
00:44:50,540 --> 00:44:53,920
學習較少，因為你
並不一定碰到過它

921
00:44:53,920 --> 00:44:56,630
為多，因為你可以得到
數據庫啟動並運行，

922
00:44:56,630 --> 00:44:58,880
但除非你讀過
在高達教程或過

923
00:44:58,880 --> 00:45:01,880
講述數據庫規範化
和索引和性能，

924
00:45:01,880 --> 00:45:04,255
這些是各​​種事情
這會傷害你。

925
00:45:04,255 --> 00:45:07,480
你可能會想，還是壞工程師
可能會說，哦，好，我們更好的待遇

926
00:45:07,480 --> 00:45:09,600
一個更大的數據庫
或更快的數據庫

927
00:45:09,600 --> 00:45:13,360
或只是錢扔在這，
垂直的規模，未必如此。

928
00:45:13,360 --> 00:45:16,920
如果你去in--，你可以進去
在fact--和添加索引後，

929
00:45:16,920 --> 00:45:20,320
並可能需要對幾個小時
數據庫建立新數據

930
00:45:20,320 --> 00:45:24,100
結構我前面提到，
你仍然可以解決這個事實後，

931
00:45:24,100 --> 00:45:26,180
這是你在哪裡
開始區分

932
00:45:26,180 --> 00:45:28,830
好壞設計師
設計師，不僅僅是美觀，

933
00:45:28,830 --> 00:45:32,972
但性能方面也是如此。

934
00:45:32,972 --> 00:45:33,555
任何問題？

935
00:45:33,555 --> 00:45:36,420

936
00:45:36,420 --> 00:45:37,480
沒有？

937
00:45:37,480 --> 00:45:41,980
因此對於NoSQL的，這是另一種類型的
數據庫我前面提到，

938
00:45:41,980 --> 00:45:43,490
你不必行和列。

939
00:45:43,490 --> 00:45:47,000
相反，你有什麼
這看起來更像這一點。

940
00:45:47,000 --> 00:45:48,630
我將使用通用的語法。

941
00:45:48,630 --> 00:45:51,270
大括號發生
在這裡使用了不少。

942
00:45:51,270 --> 00:45:55,400
你可能有一些
像第一個名字是大衛，

943
00:45:55,400 --> 00:46:00,180
你可能有最後
名字是馬蘭，報價，

944
00:46:00,180 --> 00:46:07,530
你可能有ID is--
對不起，whoops-- ID為1，

945
00:46:07,530 --> 00:46:13,410
電子郵件是malan@harvard.edu，我不會
懶得打字了休息，然後

946
00:46:13,410 --> 00:46:14,380
一些其他的事情。

947
00:46:14,380 --> 00:46:17,380
>> 換言之，這是
文本表示

948
00:46:17,380 --> 00:46:20,720
什麼，我們一般會打電話
在計算機程序中的對象。

949
00:46:20,720 --> 00:46:26,079
和對象通常僅有
鍵值對的集合。

950
00:46:26,079 --> 00:46:27,370
如此反复，這種反复出現的主題。

951
00:46:27,370 --> 00:46:30,440
我們看到鍵值對在HTML中，
我們現在看到的鍵值對

952
00:46:30,440 --> 00:46:34,020
在數據庫的背景下，我們
看到鍵值對的背景下，

953
00:46:34,020 --> 00:46:35,970
，我認為，語言今天早些時候。

954
00:46:35,970 --> 00:46:36,890
一直來了。

955
00:46:36,890 --> 00:46:39,620
事實上，這是真的
什麼樣的數據可以歸結為，

956
00:46:39,620 --> 00:46:44,240
數據和元數據，或值
和鍵，分別。

957
00:46:44,240 --> 00:46:47,430
>> 這樣一個非關係
數據庫，基於東西

958
00:46:47,430 --> 00:46:50,680
在對象上，在那裡你只需聚集
一切融合在一起，並把它

959
00:46:50,680 --> 00:46:55,640
到內存中，一般會被
描繪為，或者想到，因為這。

960
00:46:55,640 --> 00:47:00,500
我會馬上離開，作為一個
諸如此類的另一種方式。

961
00:47:00,500 --> 00:47:03,750
一個是不一定
優於其他。

962
00:47:03,750 --> 00:47:07,310
事實上，很流行
這些天的數據庫系統

963
00:47:07,310 --> 00:47:11,942
像MongoDB的和Redis的和幾個
其它這種工具，可以免費獲得，

964
00:47:11,942 --> 00:47:13,400
但他們越來越成為時尚。

965
00:47:13,400 --> 00:47:18,850
部分原因是他們提供額外的
在這些表格的方法的特點，

966
00:47:18,850 --> 00:47:20,850
而且還因為他們是
一個小更易於使用，

967
00:47:20,850 --> 00:47:24,099
因為你不必硬思考
對很多設計決策。

968
00:47:24,099 --> 00:47:25,970
所以利弊。

969
00:47:25,970 --> 00:47:29,740
因此，實現有選擇
超出我們只是花時間。

970
00:47:29,740 --> 00:47:32,310
>> 因此，讓我們做到這一點。

971
00:47:32,310 --> 00:47:37,870
讓我們轉變了一點
回到現在的網絡編程，

972
00:47:37,870 --> 00:47:40,470
讓我們種的結論
今天的東西

973
00:47:40,470 --> 00:47:43,930
這有點動手，盡顯
在昨天一定的差距。

974
00:47:43,930 --> 00:47:45,340
讓我去這個第一。

975
00:47:45,340 --> 00:47:49,310
所以，昨天召回
我們有一些典型的HTML

976
00:47:49,310 --> 00:47:55,110
這最初曾頁，只
HTML，然後二次過的CSS，

977
00:47:55,110 --> 00:47:56,620
級聯樣式表。

978
00:47:56,620 --> 00:47:59,830
這是我們沒有一個新的標籤
昨天看到，或糾纏，

979
00:47:59,830 --> 00:48:01,490
所謂的腳本。

980
00:48:01,490 --> 00:48:05,830
>> 原來你其實可以嵌入
語言JavaScript調用在你的網頁

981
00:48:05,830 --> 00:48:08,310
頁面，讓您的網站
頁面做一些事情。

982
00:48:08,310 --> 00:48:09,710
所以，我是什麼意思呢？

983
00:48:09,710 --> 00:48:12,630
好吧，讓我繼續前進，只是
藉此代碼片刻。

984
00:48:12,630 --> 00:48:15,860
我要進入Cloud9，沒有必要
去那裡自己只是還沒有，

985
00:48:15,860 --> 00:48:21,350
我要去打電話給這個alert.HTML。

986
00:48:21,350 --> 00:48:23,650
我要在我的文件粘貼在這裡。

987
00:48:23,650 --> 00:48:32,070
而只是為了澄清我做了什麼，讓
我去這個地址去提醒，

988
00:48:32,070 --> 00:48:33,870
你看到的Hello World。

989
00:48:33,870 --> 00:48:35,440
>> 但是，這是一種給人留下深刻印象的。

990
00:48:35,440 --> 00:48:37,410
我想要做的事
有一點不同。

991
00:48:37,410 --> 00:48:40,610
所以，我要真正做到這一點。

992
00:48:40,610 --> 00:48:43,820
我打算在此處，去，
在我的腳本標記之間，

993
00:48:43,820 --> 00:48:53,460
說警報（'你好，世界'）;這樣的通知
這是一個有點草率，但我有HTML，

994
00:48:53,460 --> 00:48:56,180
在其內部的是一個
語言JavaScript調用，

995
00:48:56,180 --> 00:48:59,420
這就是什麼叫做
函數調用或過程調用。

996
00:48:59,420 --> 00:49:04,500
這是一個動詞，從字面上看，在這種情況下，
而我調用代碼的功能

997
00:49:04,500 --> 00:49:06,310
別人寫的。

998
00:49:06,310 --> 00:49:09,630
>> 這樣的功能是
警惕，讓我們到這個網頁

999
00:49:09,630 --> 00:49:14,046
現在，點擊重裝，現在你
看到互動的一點點。

1000
00:49:14,046 --> 00:49:15,420
這是一種老派的和醜陋的。

1001
00:49:15,420 --> 00:49:18,580
這種提醒您的
彈出窗口，或許，昔日的

1002
00:49:18,580 --> 00:49:22,030
但它確實做的東西
多一點計劃。

1003
00:49:22,030 --> 00:49:26,940
>> 所以不止這些，讓我們做
更有趣的東西。

1004
00:49:26,940 --> 00:49:30,980
讓我在這裡進去幹掉了這一點。

1005
00:49:30,980 --> 00:49:33,840
而且我要繼續前進，
創建窗體就像我們昨天做。

1006
00:49:33,840 --> 00:49:34,840
其實，你知道嗎？

1007
00:49:34,840 --> 00:49:37,350
我要進入
google.html您，這是我們

1008
00:49:37,350 --> 00:49:43,027
開始在昨天，它看起來像
這一點，通過我們搜索貓

1009
00:49:43,027 --> 00:49:45,360
但是請注意，有一種一
臭蟲在當前版本中。

1010
00:49:45,360 --> 00:49:49,770
它適用於貓，但假設
我不配合，我什麼類型，

1011
00:49:49,770 --> 00:49:53,290
我只需點擊提交。

1012
00:49:53,290 --> 00:49:54,540
這是一種怪異的行為。

1013
00:49:54,540 --> 00:49:57,300
帶我去了谷歌實，
沒有給我一個錯誤消息。

1014
00:49:57,300 --> 00:50:00,590
我想告訴用戶
你需要給我們一個值。

1015
00:50:00,590 --> 00:50:01,780
>> 那麼我們如何做到這一點？

1016
00:50:01,780 --> 00:50:06,790
好讓我回去到Cloud9和
讓我進入我的頁面頂部

1017
00:50:06,790 --> 00:50:11,980
並添加腳本標記這個樣子，哪裡
我要鍵入一些JavaScript代碼。

1018
00:50:11,980 --> 00:50:15,420
而且我要做到以下幾點。

1019
00:50:15,420 --> 00:50:22,910
如果（document.getelementByID--和召回
我們先前談過這個問題，

1020
00:50:22,910 --> 00:50:23,960
該功能。

1021
00:50:23,960 --> 00:50:25,310
做我想做的ID來獲得？

1022
00:50:25,310 --> 00:50:33,050
我希望得到q和我要去
比方說等於沒事人一樣this--

1023
00:50:33,050 --> 00:50:38,220
居然讓我用雙引號
只是consistency--等於一無所有，

1024
00:50:38,220 --> 00:50:46,650
然後警報（“請輸入查詢”）在這裡。

1025
00:50:46,650 --> 00:50:49,200
>> 所以，我有什麼似乎是
類似的條件。

1026
00:50:49,200 --> 00:50:51,410
我們看到在這個划痕總體思路。

1027
00:50:51,410 --> 00:50:54,240
這就像那些謎題之一
件看起來是這樣的。

1028
00:50:54,240 --> 00:50:55,780
和我說什麼？

1029
00:50:55,780 --> 00:50:59,520
好了，到這裡，看到我
要做到以下幾點。

1030
00:50:59,520 --> 00:51:02,790
我要給這種形式
現場不僅q的名字，

1031
00:51:02,790 --> 00:51:06,630
是獲取傳遞給谷歌，但我
打算給它一個本地標識符，

1032
00:51:06,630 --> 00:51:07,630
也叫Q值。

1033
00:51:07,630 --> 00:51:11,780
但我可以把這個事情我
想，我只是要保持簡單

1034
00:51:11,780 --> 00:51:14,570
也稱之為Q，只是為了簡單起見。

1035
00:51:14,570 --> 00:51:17,650
>> 現在我該怎麼辦
東西多一點。

1036
00:51:17,650 --> 00:51:22,600
在這裡的表單字段，我要去
添加所謂的一個事件處理程序。

1037
00:51:22,600 --> 00:51:32,260
在提交，我想打電話給
一個名為驗證功能。

1038
00:51:32,260 --> 00:51:35,520
這還不存在，這
字或該動詞驗證，

1039
00:51:35,520 --> 00:51:38,560
因為什麼，我該怎麼辦
這裡現在添加一些代碼。

1040
00:51:38,560 --> 00:51:42,200
>> 我要說的功能驗證。

1041
00:51:42,200 --> 00:51:48,280
我要縮進，這並添加另一個
在這裡花括號並在這裡另外一個。

1042
00:51:48,280 --> 00:51:50,110
考慮一下這個現在正在做。

1043
00:51:50,110 --> 00:51:54,210
我為創建now--想到這我
自己的一塊拼圖以前不

1044
00:51:54,210 --> 00:51:57,440
存在的，我已經叫這個謎
一塊驗證拼圖。

1045
00:51:57,440 --> 00:52:01,620
它的生命的目的是執行
它裡面的四行代碼。

1046
00:52:01,620 --> 00:52:04,940
>> 如果的document.getElementById
所以概念上，

1047
00:52:04,940 --> 00:52:09,380
即是要進入元件，
在HTML元素，其獨特的

1048
00:52:09,380 --> 00:52:12,930
想法只是q，然後即使
語法看起來有點怪異，

1049
00:52:12,930 --> 00:52:16,430
這等於等於只是意味著平等。

1050
00:52:16,430 --> 00:52:20,950
因此，這意味著如果與元素
問唯一標識符，得到的時候，

1051
00:52:20,950 --> 00:52:25,700
沒有價值，只是等於
報價引文結束，沒有在那裡，

1052
00:52:25,700 --> 00:52:27,170
然後做我想做什麼？

1053
00:52:27,170 --> 00:52:29,360
我想在用戶嚷嚷。

1054
00:52:29,360 --> 00:52:31,710
>> 我們不會何去何從很詳細。

1055
00:52:31,710 --> 00:52:32,960
我將返​​回false。

1056
00:52:32,960 --> 00:52:34,380
這是一個錯誤。

1057
00:52:34,380 --> 00:52:38,746
否則，我將返回true。

1058
00:52:38,746 --> 00:52:40,120
所以無論是它的工作或沒有。

1059
00:52:40,120 --> 00:52:41,800
或真或假。

1060
00:52:41,800 --> 00:52:47,820
現在，如果我沒有犯任何錯誤，
讓我保存這個並重新加載此。

1061
00:52:47,820 --> 00:52:50,940
而讓我仔細檢查
我沒有，其實做任何錯別字，

1062
00:52:50,940 --> 00:52:52,690
所以我不為難自己。

1063
00:52:52,690 --> 00:52:54,240
讓我們來看看這是否正常工作。

1064
00:52:54,240 --> 00:52:56,930
>> 所以現在我要鍵入貓。

1065
00:52:56,930 --> 00:52:59,421
它仍然有效，或一半的作品，至少。

1066
00:52:59,421 --> 00:53:02,170
現在讓我重新加載它，現在讓
我來試試無需鍵入提交

1067
00:53:02,170 --> 00:53:05,860
anything--該死的，它打破了。

1068
00:53:05,860 --> 00:53:06,430
一個瞬間。

1069
00:53:06,430 --> 00:53:09,380

1070
00:53:09,380 --> 00:53:12,660
讓我打開控制台，
[聽不清]日誌，重新加載頁面。

1071
00:53:12,660 --> 00:53:13,576
讓我再試試這個。

1072
00:53:13,576 --> 00:53:17,000

1073
00:53:17,000 --> 00:53:17,501
噢，該死。

1074
00:53:17,501 --> 00:53:18,000
我忘了。

1075
00:53:18,000 --> 00:53:18,630
我做了一個錯字。

1076
00:53:18,630 --> 00:53:20,760
我記得那是什麼。

1077
00:53:20,760 --> 00:53:21,350
。值。

1078
00:53:21,350 --> 00:53:27,060
我的意思是說，如果該值
該元件的其ID為q

1079
00:53:27,060 --> 00:53:29,800
等於說，然後大聲喝斥用戶。

1080
00:53:29,800 --> 00:53:31,870
>> 所以，現在讓我再次屏住呼吸。

1081
00:53:31,870 --> 00:53:33,480
開始了。

1082
00:53:33,480 --> 00:53:34,130
在那裡，我們走了。

1083
00:53:34,130 --> 00:53:35,010
請鍵入查詢。

1084
00:53:35,010 --> 00:53:36,840
因此，這不是讓我通過。

1085
00:53:36,840 --> 00:53:40,210
我可以那種俏皮與此，
而不是檢查沒有價值，

1086
00:53:40,210 --> 00:53:46,720
我可以這樣說，
沒有更多的尋找貓，

1087
00:53:46,720 --> 00:53:51,150
現在我們可以只是更調皮地讓
用戶搜索犬，如果他或她

1088
00:53:51,150 --> 00:53:57,490
想，還是我去這裡
搜索貓，現在我不能。

1089
00:53:57,490 --> 00:53:58,690
>> 那麼，這裡的外賣？

1090
00:53:58,690 --> 00:54:03,010
所以之一，我們已經引入
我們的HTML和CSS的世界裡，

1091
00:54:03,010 --> 00:54:04,320
編程功能。

1092
00:54:04,320 --> 00:54:06,300
我現在其實可以
使代碼的決定。

1093
00:54:06,300 --> 00:54:10,570
以前，所有我能做的就是標記
文本內容或圖形內容

1094
00:54:10,570 --> 00:54:13,080
並告訴它要尋找什麼
像和在哪裡顯示。

1095
00:54:13,080 --> 00:54:16,650
現在，我實際上可以問
網頁的問題

1096
00:54:16,650 --> 00:54:20,010
並根據決策
其上，並提示用戶

1097
00:54:20,010 --> 00:54:22,780
如果我需要在他或她的叫喊。

1098
00:54:22,780 --> 00:54:28,740
>> 所以讓我們嘗試一些
對我們自己與此有關。

1099
00:54:28,740 --> 00:54:33,350
來吧，讓我打開下一張幻燈片
在這裡，只是指出了一件事。

1100
00:54:33,350 --> 00:54:37,250
剛剛與CSS一樣，我們可以分解出
我們的JavaScript代碼到一個單獨的文件，

1101
00:54:37,250 --> 00:54:40,660
你可以做同樣的事情
用JavaScript與CSS。

1102
00:54:40,660 --> 00:54:44,520
並使用，使用一個源
屬性的腳本標記。

1103
00:54:44,520 --> 00:54:46,540
但我們不會現在複雜的事情。

1104
00:54:46,540 --> 00:54:50,440
相反，如果你能
去不是這個頁面，

1105
00:54:50,440 --> 00:55:02,690
可是 - 讓我在order--移動圍繞此
這裡去，如果可以的話，這個頁面。

1106
00:55:02,690 --> 00:55:03,592
這裡該URL。

1107
00:55:03,592 --> 00:55:04,550
這是在今天的幻燈片。

1108
00:55:04,550 --> 00:55:07,133
您可能必須重新加載，因為
我已經添加了一對夫婦的事情。

1109
00:55:07,133 --> 00:55:09,970

1110
00:55:09,970 --> 00:55:13,890
>> 但是去那裡有一些謎題等待。

1111
00:55:13,890 --> 00:55:16,670
而這將會給我們一個機會，
在稍微更有趣的背景下，

1112
00:55:16,670 --> 00:55:20,610
有一些JavaScript涉足。

1113
00:55:20,610 --> 00:55:25,505
當你到達那裡，
我將解釋什麼在等著。

1114
00:55:25,505 --> 00:55:47,350

1115
00:55:47,350 --> 00:55:47,850
獲得綠色。

1116
00:55:47,850 --> 00:56:03,063

1117
00:56:03,063 --> 00:56:03,562
設置藍色。

1118
00:56:03,562 --> 00:56:11,030

1119
00:56:11,030 --> 00:56:13,930
集綠色，紅色設置。

1120
00:56:13,930 --> 00:56:19,220

1121
00:56:19,220 --> 00:56:20,220
哎呀。

1122
00:56:20,220 --> 00:56:22,330
抱歉。

1123
00:56:22,330 --> 00:56:27,630
>> 這是的程度提供了
文檔這一挑戰。

1124
00:56:27,630 --> 00:56:29,920
而這是去工作如下。

1125
00:56:29,920 --> 00:56:33,340
所以，你對這個有什麼
網頁是一大堆

1126
00:56:33,340 --> 00:56:38,024
一個哥們形象拼圖
在斯坦福大學。

1127
00:56:38,024 --> 00:56:41,190
所以，你在這裡看到的是幾乎
那種那些眼的難題之一，

1128
00:56:41,190 --> 00:56:43,815
但如果你只盯著它，
什麼也沒有打算在你彈出。

1129
00:56:43,815 --> 00:56:46,000
更確切地說，是東西
隱藏這個形象。

1130
00:56:46,000 --> 00:56:47,790
和它隱藏在以下方式。

1131
00:56:47,790 --> 00:56:51,740
圖片，你可能知道，可
僅僅三色組成。

1132
00:56:51,740 --> 00:56:53,346
有些紅，有藍色和一些綠色。

1133
00:56:53,346 --> 00:56:55,220
我們可以讓所有的
顏色彩虹

1134
00:56:55,220 --> 00:56:57,570
由這三種顏色以某種方式混合。

1135
00:56:57,570 --> 00:57:01,940
>> 因此，這看起來主要是綠色和
藍色的，但尼克說，在這裡，

1136
00:57:01,940 --> 00:57:04,060
這個鐵拼圖形象是一個謎。

1137
00:57:04,060 --> 00:57:06,780
它包含的圖像
著名的東西，但是，

1138
00:57:06,780 --> 00:57:08,310
圖像已被扭曲。

1139
00:57:08,310 --> 00:57:11,500
著名的目的是在紅色值。

1140
00:57:11,500 --> 00:57:13,810
然而，紅色值
有10個都被劃分。

1141
00:57:13,810 --> 00:57:16,230
所以，它們太小了10倍。

1142
00:57:16,230 --> 00:57:18,280
因此，換句話說，尼克
把原始圖像，

1143
00:57:18,280 --> 00:57:21,500
他所有的去飽和
從它的紅色，

1144
00:57:21,500 --> 00:57:23,850
降低紅色的量
墨水，如果你願意，在裡面。

1145
00:57:23,850 --> 00:57:26,060
>> 藍色和綠色價值觀
都只是毫無意義的，

1146
00:57:26,060 --> 00:57:30,000
隨機值，又名噪音設計
模糊實像。

1147
00:57:30,000 --> 00:57:32,250
那麼什麼尼克所做的就是他
淡化了紅色，然後

1148
00:57:32,250 --> 00:57:34,380
他只是隨便扔
藍色和綠色的金額

1149
00:57:34,380 --> 00:57:37,590
在圖像那種晦澀
究竟是什麼仍然存在。

1150
00:57:37,590 --> 00:57:41,089
您必須撤消這些扭曲
以顯示圖像。

1151
00:57:41,089 --> 00:57:44,255
首先，將所有的藍色和綠色價值觀
到零，讓他們閃開，

1152
00:57:44,255 --> 00:57:48,700
看看結果。然後
乘以10的每個紅色值，

1153
00:57:48,700 --> 00:57:51,720
縮減到
大約其最終值。

1154
00:57:51,720 --> 00:57:53,035
什麼是著名的對象呢？

1155
00:57:53,035 --> 00:57:57,920
>> 所以大家有這個矩形
在您的瀏覽器現在。

1156
00:57:57,920 --> 00:58:00,830
並注意有一些
啟動代碼，可以這麼說。

1157
00:58:00,830 --> 00:58:04,370
這是JavaScript代碼
尼克寫了你。

1158
00:58:04,370 --> 00:58:07,250
並注意有
在中間行

1159
00:58:07,250 --> 00:58:10,380
以斜杠斜杠開始，這是
什麼是通常被稱為註釋。

1160
00:58:10,380 --> 00:58:14,660
這意味著它是一個短語程序員
不具有功能意義。

1161
00:58:14,660 --> 00:58:16,520
這只是一個視覺提示對人類。

1162
00:58:16,520 --> 00:58:18,670
>> 所以，你可以繼續前進，
刪除剛才那行，

1163
00:58:18,670 --> 00:58:22,214
並且是超級小心，不要
刪除或更改任何東西。

1164
00:58:22,214 --> 00:58:25,130
而讓我帶你通過
這是什麼代碼所做的，我會離開它

1165
00:58:25,130 --> 00:58:28,580
你找出秘密圖像。

1166
00:58:28,580 --> 00:58:32,226
這裡這第一行，我已經只是
突出顯示為您提供了以下內容。

1167
00:58:32,226 --> 00:58:34,100
在左手側，
你有什麼所謂

1168
00:58:34,100 --> 00:58:39,140
一個變量，尼克隨意，
但合理的呼籲像IM。

1169
00:58:39,140 --> 00:58:41,660
在右手側
那個等號，

1170
00:58:41,660 --> 00:58:45,240
他說，給我一個新的
報價，引文結束“簡單的圖像”。

1171
00:58:45,240 --> 00:58:49,680
>> 簡單的圖像，在這種情況下
是所謂的一類，那麼，

1172
00:58:49,680 --> 00:58:53,910
這有點像一個分類 - 
技術上prototype--但實際上，

1173
00:58:53,910 --> 00:58:58,000
這是給我一個新的對象，
其內容是文件，

1174
00:58:58,000 --> 00:58:59,610
鐵puzzle.png。

1175
00:58:59,610 --> 00:59:03,190
換句話說，尼克已經創造
這個概念的簡單圖像

1176
00:59:03,190 --> 00:59:05,920
這樣我們就可以，對於教學
的宗旨，發揮與圖像

1177
00:59:05,920 --> 00:59:09,790
並改變它的紅色，
綠色和藍色的值。

1178
00:59:09,790 --> 00:59:11,750
>> 而我們如何做呢？

1179
00:59:11,750 --> 00:59:15,360
這裡這個晦澀的語法
是一種像重複塊

1180
00:59:15,360 --> 00:59:19,140
你們有些人在看到划痕早先
今天，在這裡你可以重複10次。

1181
00:59:19,140 --> 00:59:22,220
在這種情況下，尼克也沒有
硬編碼了一些像10。

1182
00:59:22,220 --> 00:59:28,020
相反，他是在說，初始化
一個名為x為0變量，

1183
00:59:28,020 --> 00:59:33,180
檢查，如果x小於
圖像的寬度。

1184
00:59:33,180 --> 00:59:38,160
>> 所以要更恰當，形象是
可變的，點的意思走在它的內部

1185
00:59:38,160 --> 00:59:40,900
並獲得它的寬度，
然後打開括號，封閉

1186
00:59:40,900 --> 00:59:43,687
括號只是一個程序員的方式
的話說，這是一個功能。

1187
00:59:43,687 --> 00:59:44,520
這是一個過程。

1188
00:59:44,520 --> 00:59:46,430
這是功能
別人寫的。

1189
00:59:46,430 --> 00:59:48,570
使用它，並給我一個答案。

1190
00:59:48,570 --> 00:59:53,610
然後X ++是一個奇特的方式
他說，你做了這個曾經之後，

1191
00:59:53,610 --> 00:59:55,850
1增加x。

1192
00:59:55,850 --> 00:59:58,760
換句話說，這
是一個程序員的方式

1193
00:59:58,760 --> 01:00:05,760
的誘導環那
要遍歷

1194
01:00:05,760 --> 01:00:10,410
所有圖像中的列。

1195
01:00:10,410 --> 01:00:14,790
>> 圖像只是一個網格
點，行和點列。

1196
01:00:14,790 --> 01:00:18,270
這是迭代的方式
在所有這些列。

1197
01:00:18,270 --> 01:00:20,770
而在裡面，
同時，我們迭代

1198
01:00:20,770 --> 01:00:24,030
在高度，在這裡
和這裡和這裡。

1199
01:00:24,030 --> 01:00:29,442
所以，這僅僅是一個疲憊地走的路，
幾乎像一個老同學的打字機，

1200
01:00:29,442 --> 01:00:32,230
只看一遍
整幅圖像迭代。

1201
01:00:32,230 --> 01:00:36,370
即使這不是很全
清晰的，只是依靠信念，現在，

1202
01:00:36,370 --> 01:00:38,880
那些三線
代碼一起是

1203
01:00:38,880 --> 01:00:43,090
要允許你反复看
在每一個像素，每一個點的形象。

1204
01:00:43,090 --> 01:00:43,790
>> 什麼是像素？

1205
01:00:43,790 --> 01:00:46,250
好了，要清楚，如果我們看一下
在原來的和放大，

1206
01:00:46,250 --> 01:00:49,060
如果你真的把你的眼睛
電腦屏幕，這是

1207
01:00:49,060 --> 01:00:53,510
只是一大堆點，幾個
千點擠在一起那裡。

1208
01:00:53,510 --> 01:00:56,180
所以你有什麼有關呢？

1209
01:00:56,180 --> 01:00:59,240
這些點中的每一個，
最終的定義，

1210
01:00:59,240 --> 01:01:06,350
是一個什麼樣的一般結果
所謂的RGB，紅，綠，藍，這

1211
01:01:06,350 --> 01:01:09,940
再次，可以被組合以
給你任何數量的顏色。

1212
01:01:09,940 --> 01:01:13,200
>> 事實上，如果你還記得
從很多很多年前，

1213
01:01:13,200 --> 01:01:17,320
投影儀屏幕喜歡這些東西
曾經擁有而不是一個鏡頭，但三種。

1214
01:01:17,320 --> 01:01:20,700
其中一人吐出紅燈，一
他們吐出的綠光，其中之一

1215
01:01:20,700 --> 01:01:21,600
吐出藍色的光。

1216
01:01:21,600 --> 01:01:24,391
如果你在一所中學
就像我在那裡他們從來沒有

1217
01:01:24,391 --> 01:01:27,000
正確對齊，你是
總是看電影史

1218
01:01:27,000 --> 01:01:29,770
那名稍扭曲，
因為三種顏色不

1219
01:01:29,770 --> 01:01:30,970
結合正常。

1220
01:01:30,970 --> 01:01:36,330
>> 但事實證明，每
這些值的紅，綠，藍，

1221
01:01:36,330 --> 01:01:37,980
可以具有與它們相關聯的數字。

1222
01:01:37,980 --> 01:01:42,500
例如，0用於紅色意味著沒有
紅，0綠色表示沒有綠色，

1223
01:01:42,500 --> 01:01:45,120
0藍色表示沒有藍色。

1224
01:01:45,120 --> 01:01:49,403
所以，如果你有沒有紅，沒有綠色，
沒有藍色的，你有什麼顏色？

1225
01:01:49,403 --> 01:01:51,009
>> 聽眾：[聽不清]

1226
01:01:51,009 --> 01:01:52,800
DAVID MALAN：你會
希望如此，它是白色的。

1227
01:01:52,800 --> 01:01:55,333
不幸的是，這operates--遺憾？

1228
01:01:55,333 --> 01:01:56,380
>> 聽眾：[聽不清]

1229
01:01:56,380 --> 01:01:58,630
DAVID MALAN：所以你其實
有黑色，在這種情況下。

1230
01:01:58,630 --> 01:02:01,530
所以，如果你沒有這些
顏色打開，你有黑色的。

1231
01:02:01,530 --> 01:02:06,510
但是，如果你有，我們說了很多
其中，想了很多的紅色，它的255，

1232
01:02:06,510 --> 01:02:10,340
很多綠色的，很多
藍色的，這是白色的。

1233
01:02:10,340 --> 01:02:12,230
所以這是兩個極端。

1234
01:02:12,230 --> 01:02:17,460
因此，通過這樣的邏輯，如果我有很多
紅色和綠色無，沒有藍，

1235
01:02:17,460 --> 01:02:18,485
什麼顏色是什麼？

1236
01:02:18,485 --> 01:02:19,360
聽眾：[聽不清]

1237
01:02:19,360 --> 01:02:20,610
DAVID MALAN：是的，很明顯。

1238
01:02:20,610 --> 01:02:25,940
然後沒有紅色，很多
綠色，沒有藍，然後

1239
01:02:25,940 --> 01:02:29,590
如果你have--很好，我們只是完成
它，只因為，但是這當然

1240
01:02:29,590 --> 01:02:31,350
現在，是藍色的。

1241
01:02:31,350 --> 01:02:33,030
現在你可以將這些顏色。

1242
01:02:33,030 --> 01:02:36,430
現在，順便說一句，如果您有任何的
曾經做過一些實際的網站設計，

1243
01:02:36,430 --> 01:02:38,360
你實際上可能
看到這樣的符號。

1244
01:02:38,360 --> 01:02:42,030
FFF--實際上，它是
甚至可能不是。

1245
01:02:42,030 --> 01:02:44,380
這是FFFFFF。

1246
01:02:44,380 --> 01:02:48,970
>> 沒有人見過F公司和E的
和A through--所以事實證明，

1247
01:02:48,970 --> 01:02:52,970
昨天我們談到了小數，
今天，那種關於十進制。

1248
01:02:52,970 --> 01:02:54,570
今天我們談到的二進制文件。

1249
01:02:54,570 --> 01:02:59,010
事實證明，十六進制是一個非常
公共基礎的系統在計算使用。

1250
01:02:59,010 --> 01:03:04,960
二是二，小數為10進制為16。

1251
01:03:04,960 --> 01:03:08,640
而事實證明，怎麼辦
你在十六進制數？

1252
01:03:08,640 --> 01:03:11,620
零，一，二，三，四，
五，六，七，八，

1253
01:03:11,620 --> 01:03:14,730
九，你九點以後用什麼？

1254
01:03:14,730 --> 01:03:16,600
什麼是下一個數字？

1255
01:03:16,600 --> 01:03:19,180
我們已經用零。

1256
01:03:19,180 --> 01:03:20,570
我需要這16個。

1257
01:03:20,570 --> 01:03:25,770
零，一，二，三，四，
五，六，七，八，九，

1258
01:03:25,770 --> 01:03:27,520
你需要一些任意約定。

1259
01:03:27,520 --> 01:03:30,810
>> 什麼決定人類的一段時間
以前，經過九年來的信

1260
01:03:30,810 --> 01:03:34,450
A，然後B，然後C.於是
這樣你在十六進制計數

1261
01:03:34,450 --> 01:03:37,040
是零，一，二，三，四，
五，六，七，八，九，

1262
01:03:37,040 --> 01:03:42,880
A，B，C，D，E，F，這將算
你一路走好，它的出現，為15。

1263
01:03:42,880 --> 01:03:47,850
所以零至15是零通過
F.現在為什麼是顯著？

1264
01:03:47,850 --> 01:03:51,570
那麼，當你有兩個F公司，
這就是你如何表達255。

1265
01:03:51,570 --> 01:03:54,350
>> 所以長話短說，在
Photoshop的世界，

1266
01:03:54,350 --> 01:03:57,299
該圖形設計軟件，
在web開發的世界裡，

1267
01:03:57,299 --> 01:03:59,590
在這裡你有很多顏色，
當然，一起玩，

1268
01:03:59,590 --> 01:04:02,350
通常程序員會
表達這些十六進制，

1269
01:04:02,350 --> 01:04:05,260
只是因為它往往
是有點簡單。

1270
01:04:05,260 --> 01:04:07,850
儘管乍一看
它的要複雜得多。

1271
01:04:07,850 --> 01:04:11,590
>> 因此在任何情況下，這是非常重要的
因為尼克·斯坦福

1272
01:04:11,590 --> 01:04:15,100
給了我們六件功能
你，含苞待放的程序員，

1273
01:04:15,100 --> 01:04:17,060
現在將不得不使用的能力。

1274
01:04:17,060 --> 01:04:19,960
內置於本網站
頁面六大功能，

1275
01:04:19,960 --> 01:04:21,820
六手續尼克寫道。

1276
01:04:21,820 --> 01:04:26,800
他們三人將讓你一個數字，
紅色，綠色，或藍色值。

1277
01:04:26,800 --> 01:04:28,787
他們三人將設置該值。

1278
01:04:28,787 --> 01:04:30,620
而這些下劃線
只是佔位符，

1279
01:04:30,620 --> 01:04:32,600
所以你需要知道那些是什麼。

1280
01:04:32,600 --> 01:04:36,240
>> 因此，與這三個功能，
第一這些東西

1281
01:04:36,240 --> 01:04:39,190
將是x坐標，
而這些東西的第二

1282
01:04:39,190 --> 01:04:40,700
將是一個y坐標。

1283
01:04:40,700 --> 01:04:44,650
換句話說，這點，這
像素你想要得到的綠色，

1284
01:04:44,650 --> 01:04:46,480
得到的藍色，得到的紅色。

1285
01:04:46,480 --> 01:04:51,440
然後這裡，這將是
X，這將是一個y值，

1286
01:04:51,440 --> 01:04:55,379
並且這將是一個數字。

1287
01:04:55,379 --> 01:04:57,170
因此，讓我們做的第一件
這一起行

1288
01:04:57,170 --> 01:05:00,220
然後我會把它留給你
嘗試演繹休息。

1289
01:05:00,220 --> 01:05:03,100
所以每個指令
此頁面上，我們需要

1290
01:05:03,100 --> 01:05:08,960
通過的一個因子來增加紅色
10，我們需要刪除綠色

1291
01:05:08,960 --> 01:05:09,930
並取出藍色。

1292
01:05:09,930 --> 01:05:12,410
讓我們先從後者場景。

1293
01:05:12,410 --> 01:05:17,760
所以，如果我想，我要去
通過使用一些縮進空格，

1294
01:05:17,760 --> 01:05:22,291
如果我要設置紅，
綠色或藍色值，

1295
01:05:22,291 --> 01:05:23,540
我要做到以下幾點。

1296
01:05:23,540 --> 01:05:31,280
>> 圖片，im.setBlue，然後
根據我在這裡的指令，

1297
01:05:31,280 --> 01:05:36,700
哪三件事情我應該
現在鍵入括號內的？

1298
01:05:36,700 --> 01:05:41,960
我需要的x值時，
y值，什麼號碼

1299
01:05:41,960 --> 01:05:48,770
我應該把在這裡，如果我想擺脫
藍色的基礎上，這樣的故事在這裡？

1300
01:05:48,770 --> 01:05:49,630
只需調零。

1301
01:05:49,630 --> 01:05:52,420
如果我要沒藍了，我只是
將其更改為為零。

1302
01:05:52,420 --> 01:05:54,465
>> 現在，就讓我們回顧一下這是什麼做的。

1303
01:05:54,465 --> 01:05:56,970

1304
01:05:56,970 --> 01:06:01,170
我這裡有對這些頂級
第二和第三行，

1305
01:06:01,170 --> 01:06:04,080
我要求兩個迴路，
嵌套循環，如果你

1306
01:06:04,080 --> 01:06:08,360
將，這將會有效果
左進展到右的，

1307
01:06:08,360 --> 01:06:11,590
從上到下對所有的x
值和全部的Y值。

1308
01:06:11,590 --> 01:06:15,167
因為再次，一張圖片
只是一個行和列的網格。

1309
01:06:15,167 --> 01:06:17,000
因此，這是會得到
擺脫所有的藍色。

1310
01:06:17,000 --> 01:06:18,627
讓我在接下來的行你離開。

1311
01:06:18,627 --> 01:06:20,043
我該如何擺脫所有的綠色？

1312
01:06:20,043 --> 01:06:23,747

1313
01:06:23,747 --> 01:06:25,140
>> 聽眾：[聽不清]

1314
01:06:25,140 --> 01:06:26,151
>> DAVID MALAN：好的。

1315
01:06:26,151 --> 01:06:28,260
>> 聽眾：[聽不清]

1316
01:06:28,260 --> 01:06:30,850
>> DAVID MALAN：好的。

1317
01:06:30,850 --> 01:06:36,120
而且我要放大，只取
在乎的是你沒有做任何錯別字。

1318
01:06:36,120 --> 01:06:39,390
如果你是舒服
你做了什麼，

1319
01:06:39,390 --> 01:06:42,936
繼續前進，點擊按鈕
運行/保存，看看你會得到什麼。

1320
01:06:42,936 --> 01:06:46,982

1321
01:06:46,982 --> 01:06:48,690
再次，我們已經取得了
短短三年的變化。

1322
01:06:48,690 --> 01:06:52,130
我們刪除了第一
發表評論，並取代了它

1323
01:06:52,130 --> 01:06:53,575
與這兩行代碼。

1324
01:06:53,575 --> 01:06:55,742

1325
01:06:55,742 --> 01:06:58,450
而且它的確定，如果你需要打
運行/保存按鈕幾次

1326
01:06:58,450 --> 01:07:01,190
修復某些東西。

1327
01:07:01,190 --> 01:07:03,610
>> 讓我也放大我
代碼，這樣您可以錄製。

1328
01:07:03,610 --> 01:07:04,110
好。

1329
01:07:04,110 --> 01:07:08,720
所以我看到安德魯有什麼
似乎是一個錯誤。

1330
01:07:08,720 --> 01:07:11,110
他只是有一個大的黑色
矩形他的屏幕上。

1331
01:07:11,110 --> 01:07:13,120
沒有任何人有
一個大的黑色矩形？

1332
01:07:13,120 --> 01:07:13,390
>> 聽眾：是的。

1333
01:07:13,390 --> 01:07:14,360
>> DAVID MALAN：大黑色矩形？

1334
01:07:14,360 --> 01:07:16,068
好了，讓我們想想
這意味著什麼。

1335
01:07:16,068 --> 01:07:20,560
我們說，零，零，零，
所以沒有綠色，沒有紅，沒有藍，

1336
01:07:20,560 --> 01:07:21,980
是要給你黑。

1337
01:07:21,980 --> 01:07:24,467
而事實證明，
我們的大多數筆記本電腦

1338
01:07:24,467 --> 01:07:25,800
只是沒有足夠的保真度。

1339
01:07:25,800 --> 01:07:27,750
你不能完全說有
實際上是東西在那裡。

1340
01:07:27,750 --> 01:07:30,340
如果你有種，也許瘦
屏幕前進和後退，

1341
01:07:30,340 --> 01:07:32,850
也許你看到一個
小東西呢？

1342
01:07:32,850 --> 01:07:34,820
也許，那種類型的，？

1343
01:07:34,820 --> 01:07:36,640
這不是完美的黑色。

1344
01:07:36,640 --> 01:07:38,050
>> 聽眾：[聽不清]

1345
01:07:38,050 --> 01:07:39,510
>> DAVID MALAN：劇透！

1346
01:07:39,510 --> 01:07:42,610
有一些紅色的存在，但
從規格記

1347
01:07:42,610 --> 01:07:44,940
這個問題，尼克緩和下來。

1348
01:07:44,940 --> 01:07:47,860
他有些去飽和了，
但不是所有的方式為零。

1349
01:07:47,860 --> 01:07:51,670
因此，如果我們要放大的量
紅，讓我提出這一招。

1350
01:07:51,670 --> 01:07:53,750
讓我放大我的屏幕上。

1351
01:07:53,750 --> 01:07:58,678
讓我繼續說
量等於im.getRed（X，Y）。

1352
01:07:58,678 --> 01:08:02,440

1353
01:08:02,440 --> 01:08:05,790
>> 這行代碼是給我
所謂的變量。

1354
01:08:05,790 --> 01:08:09,643
我隨意，但，可以說，
合理地叫我的變量是什麼，

1355
01:08:09,643 --> 01:08:10,143
顯然？

1356
01:08:10,143 --> 01:08:13,530

1357
01:08:13,530 --> 01:08:14,340
量。

1358
01:08:14,340 --> 01:08:14,980
只是量。

1359
01:08:14,980 --> 01:08:16,960
我可以叫它
任何我想要的，但我

1360
01:08:16,960 --> 01:08:19,490
使用此功能的其他
我前面描述

1361
01:08:19,490 --> 01:08:25,359
獲得紅量在x逗號年。

1362
01:08:25,359 --> 01:08:27,520
我為什麼這樣做呢？

1363
01:08:27,520 --> 01:08:30,004
你有什麼想在這裡做什麼？

1364
01:08:30,004 --> 01:08:32,910

1365
01:08:32,910 --> 01:08:33,619
您需要add--

1366
01:08:33,619 --> 01:08:34,493
聽眾：[聽不清]

1367
01:08:34,493 --> 01:08:36,279
DAVID MALAN：是的，也許
乘以10的。

1368
01:08:36,279 --> 01:08:38,862
如果你不知道這一點，我
要繼續前進，並做到這一點。

1369
01:08:38,862 --> 01:08:42,060
我要繼續前進，
比方說，我要紅色的量

1370
01:08:42,060 --> 01:08:46,550
我想成為什麼
是在紅，次10，

1371
01:08:46,550 --> 01:08:50,330
和明星，在你的星號
鍵盤是曲風不要用x。

1372
01:08:50,330 --> 01:08:51,569
使用明星。

1373
01:08:51,569 --> 01:08:55,350
這就是你的事情乘以
大多數編程語言。

1374
01:08:55,350 --> 01:08:59,790
>> 所以根據賈巴爾的直覺，
存儲在這個變量，名為量，

1375
01:08:59,790 --> 01:09:03,649
我是多麼想衝在位置XY。

1376
01:09:03,649 --> 01:09:11,500
怎麼樣，現在，我做這做
像素有多少？

1377
01:09:11,500 --> 01:09:12,859
你已經這樣做過。

1378
01:09:12,859 --> 01:09:17,666
您可以設置綠色，
藍沒有價值，到零。

1379
01:09:17,666 --> 01:09:18,540
聽眾：[聽不清]

1380
01:09:18,540 --> 01:09:20,040
DAVID MALAN：是的，很好
你不希望它10。

1381
01:09:20,040 --> 01:09:21,460
你已經在這裡做了數學。

1382
01:09:21,460 --> 01:09:24,779
所以，我們得到的紅色值，
這是一種低一些，大概。

1383
01:09:24,779 --> 01:09:26,180
我們乘以10了。

1384
01:09:26,180 --> 01:09:29,139
你想要做什麼
現在變量？

1385
01:09:29,139 --> 01:09:30,130
>> 聽眾：[聽不清]

1386
01:09:30,130 --> 01:09:30,880
>> DAVID MALAN：好的。

1387
01:09:30,880 --> 01:09:34,616
所以im.set--什麼？

1388
01:09:34,616 --> 01:09:35,640
>> 聽眾：setRed。

1389
01:09:35,640 --> 01:09:39,760
>> DAVID MALAN：setRed，在位置XY。

1390
01:09:39,760 --> 01:09:40,260
是啊。

1391
01:09:40,260 --> 01:09:41,200
而剛剛金額。

1392
01:09:41,200 --> 01:09:44,257
換言之，可變
是一個臨時佔位符

1393
01:09:44,257 --> 01:09:45,840
你可以把你想要的任何東西。

1394
01:09:45,840 --> 01:09:48,680
我們碰巧把一個
在這數的時刻。

1395
01:09:48,680 --> 01:09:51,569
我們已經通過倍增
10使它更大。

1396
01:09:51,569 --> 01:09:56,480
現在我代變量
作為第三個參數，或者輸入

1397
01:09:56,480 --> 01:09:57,810
設置紅色。

1398
01:09:57,810 --> 01:10:00,440
所以，一旦你
完成那，並注意

1399
01:10:00,440 --> 01:10:02,330
的分號和括號。

1400
01:10:02,330 --> 01:10:06,290
>> 繼續並點擊
運行/再次保存，而你

1401
01:10:06,290 --> 01:10:10,690
應該看到，神奇，什麼竟是
那裡。 [？阿瓦，？]是什麼呢？

1402
01:10:10,690 --> 01:10:16,412
埃菲爾鐵塔在羽翼豐滿
紅，不是很暗。

1403
01:10:16,412 --> 01:10:17,870
現在應該是比較明顯的，是嗎？

1404
01:10:17,870 --> 01:10:18,840
好。

1405
01:10:18,840 --> 01:10:20,215
和安德魯，沒有更多的黑盒子？

1406
01:10:20,215 --> 01:10:21,090
聽眾：[聽不清]

1407
01:10:21,090 --> 01:10:22,180
DAVID MALAN：好的。

1408
01:10:22,180 --> 01:10:23,610
所以，我會記住這在屏幕上。

1409
01:10:23,610 --> 01:10:27,010
如果你想要玩這個
後來，我就重新創建你的。

1410
01:10:27,010 --> 01:10:29,140
但是這個代碼在這裡確實做到了。

1411
01:10:29,140 --> 01:10:31,460
為什麼我們不能做一個其他。

1412
01:10:31,460 --> 01:10:33,880
讓我略微向下滾動。

1413
01:10:33,880 --> 01:10:36,760
>> 因此，在這種情況下，將投影機
並沒有真正做到公正。

1414
01:10:36,760 --> 01:10:40,486
但在你的屏幕上，你可能
有一個很紅，很黑盒子。

1415
01:10:40,486 --> 01:10:42,610
這也是一個難題，
顯示的東西出名。

1416
01:10:42,610 --> 01:10:44,193
但是，圖像已被扭曲。

1417
01:10:44,193 --> 01:10:47,740
真正的形象，這一次，是
在藍色和綠色價值觀。

1418
01:10:47,740 --> 01:10:51,820
但是，他們都被劃分
20如此的值是非常小的。

1419
01:10:51,820 --> 01:10:54,660
紅色值只是
隨機數，噪音小。

1420
01:10:54,660 --> 01:10:57,190
撤消這些扭曲
揭示真實形象。

1421
01:10:57,190 --> 01:10:59,200
>> 於是尼克然後告訴你該怎麼做。

1422
01:10:59,200 --> 01:11:04,290
設置紅色值為零，並
那麼就不要糟蹋它是什麼。

1423
01:11:04,290 --> 01:11:07,110
然後乘以藍色
和20綠色價值觀。

1424
01:11:07,110 --> 01:11:09,820
因此，它幾乎是
相同的程序和以前一樣，

1425
01:11:09,820 --> 01:11:11,380
但你在倒車過程中。

1426
01:11:11,380 --> 01:11:13,780
我將把我的代碼
前的情況下，在屏幕上

1427
01:11:13,780 --> 01:11:16,650
要引用回吧
或者一個進一步發揮。

1428
01:11:16,650 --> 01:11:18,100
讓我放大了。

1429
01:11:18,100 --> 01:11:21,450
但是，解決銅形象
拼圖，排名第二。

1430
01:11:21,450 --> 01:11:37,623

1431
01:11:37,623 --> 01:11:40,580
>> 聽眾：[聽不清]

1432
01:11:40,580 --> 01:11:44,010
>> DAVID MALAN：OK，所以這一塊我
不會給盡可能多的提示。

1433
01:11:44,010 --> 01:11:47,220
所以我would--哦，讓我們
看，你有一個錯字在這裡。

1434
01:11:47,220 --> 01:11:49,621
所以請記住，這在這裡
實際上需要去那裡。

1435
01:11:49,621 --> 01:11:52,870
那麼，我建議，如果你想
專注於這一個，還有的答案。

1436
01:11:52,870 --> 01:11:57,060
如果你想錄製的，那
應該得到的第一個工作。

1437
01:11:57,060 --> 01:11:59,910
然後你就可以使用它作為
靈感第二個。

1438
01:11:59,910 --> 01:12:02,230
尼斯。

1439
01:12:02,230 --> 01:12:02,730
好。

1440
01:12:02,730 --> 01:12:05,430

1441
01:12:05,430 --> 01:12:08,180
>> 而對於好奇，
這是一個簡單的例子

1442
01:12:08,180 --> 01:12:11,080
一門科學或藝術
所謂的隱寫術，

1443
01:12:11,080 --> 01:12:14,100
在現有技術中隱藏圖像信息。

1444
01:12:14,100 --> 01:12:16,890
通常情況下，圖像可能
水印很招搖

1445
01:12:16,890 --> 01:12:19,500
在底部的一個標誌
角落裡，但很明顯，你

1446
01:12:19,500 --> 01:12:22,070
可以是更複雜
它實際上

1447
01:12:22,070 --> 01:12:25,050
隱藏在圖像其他圖像
以某種方式與這種技術。

1448
01:12:25,050 --> 01:12:59,890

1449
01:12:59,890 --> 01:13:05,770
>> 再舉一個30秒，然後我們會
至少宣布你應該看到的。

1450
01:13:05,770 --> 01:13:08,330
我會離開第三
一個作為一個在家鍛煉，

1451
01:13:08,330 --> 01:13:11,353
如果您想了解更多的
挑戰這個週末。

1452
01:13:11,353 --> 01:13:18,240

1453
01:13:18,240 --> 01:13:20,390
而且我認為安德魯可能
已先得到它。

1454
01:13:20,390 --> 01:13:22,645
什麼是第二圖像，安德魯？

1455
01:13:22,645 --> 01:13:23,920
>> 聽眾：自由女神像。

1456
01:13:23,920 --> 01:13:28,500
>> DAVID MALAN：自由女神像
將這次的答案。

1457
01:13:28,500 --> 01:13:31,140
如此反复，只是一些簡單的
實施例中，目標，其中

1458
01:13:31,140 --> 01:13:35,040
就是給你怎樣的感覺
我們已經翻譯刮寫真

1459
01:13:35,040 --> 01:13:40,410
塊更惱人的多
複雜的代碼，但所有的思想

1460
01:13:40,410 --> 01:13:42,980
仍完全一樣，
儘管在引入

1461
01:13:42,980 --> 01:13:48,380
現在一個變量的概念，是
能夠臨時存儲東西。

1462
01:13:48,380 --> 01:13:51,750
>> 讓我們做一個更多動手，
只是到現在連點

1463
01:13:51,750 --> 01:13:53,880
到一些更真實的世界。

1464
01:13:53,880 --> 01:13:56,610
當你準備好，如果你能
到屏幕上的這個URL。

1465
01:13:56,610 --> 01:14:00,610
這也是在你的副本
幻燈片，developers.google.com/maps~~V。

1466
01:14:00,610 --> 01:14:03,660
讓我們確實做了什麼
真正的，可以這麼說，在網絡上

1467
01:14:03,660 --> 01:14:07,600
使用谷歌地圖API或
應用程序接口，

1468
01:14:07,600 --> 01:14:08,940
以下面的方式。

1469
01:14:08,940 --> 01:14:12,341
>> 谷歌，許多公司一樣，
提供了大量的免費功能

1470
01:14:12,341 --> 01:14:14,840
你可以用它來建立你
自己的有趣的應用。

1471
01:14:14,840 --> 01:14:18,890
事實上，如果你曾經使用過
尤伯杯得到出租車或汽車，

1472
01:14:18,890 --> 01:14:21,640
你可能知道有尤伯杯
一張地圖，它顯示了它的汽車。

1473
01:14:21,640 --> 01:14:24,870
也就是說，作為最好的，我可以
告訴，谷歌地圖API。

1474
01:14:24,870 --> 01:14:28,884
他們實際上是使用谷歌的地圖，
但尤伯杯不是一個映射的公司，

1475
01:14:28,884 --> 01:14:31,050
也不會是這樣一個
特別有趣的問題

1476
01:14:31,050 --> 01:14:33,510
解決之上其
汽車服務問題。

1477
01:14:33,510 --> 01:14:35,510
因此，他們是站在，
再次，在肩膀上

1478
01:14:35,510 --> 01:14:37,520
其他的，谷歌在這種情況下。

1479
01:14:37,520 --> 01:14:42,850
因此，他們使用谷歌的地圖，但自己
汽車服務等這樣的特性。

1480
01:14:42,850 --> 01:14:47,770
>> 因此，我們要充分利用
這個做到以下幾點。

1481
01:14:47,770 --> 01:14:50,230
如果我已經走的太快，
就給我打電話了一會兒。

1482
01:14:50,230 --> 01:14:53,500
快樂重溫一些形象的東西。

1483
01:14:53,500 --> 01:14:56,290
你應該看到自己
在這樣的頁面。

1484
01:14:56,290 --> 01:14:58,230
因此，谷歌的不錯，和
他們是名列前茅

1485
01:14:58,230 --> 01:15:01,364
不僅提供的API，
但免費的API，你

1486
01:15:01,364 --> 01:15:02,780
可以玩或商業使用。

1487
01:15:02,780 --> 01:15:06,450
他們開始，如果您的使用情況向您收費
高，但我事先說乾就幹

1488
01:15:06,450 --> 01:15:10,490
並簽署了我們一個免費帳戶
即，希望10台電腦

1489
01:15:10,490 --> 01:15:12,480
不會資格我們豁然開朗。

1490
01:15:12,480 --> 01:15:14,320
所以希望這
論證會工作。

1491
01:15:14,320 --> 01:15:18,840
>> 並注意他們有原料藥
Android版，iOS版，Web和Web服務，

1492
01:15:18,840 --> 01:15:19,620
不管它是什麼。

1493
01:15:19,620 --> 01:15:20,700
讓我們專注於網絡。

1494
01:15:20,700 --> 01:15:26,560
因此，單擊粉紅色的盒子，網絡，以及
將引領你，希望到一個頁面

1495
01:15:26,560 --> 01:15:27,630
這裡。

1496
01:15:27,630 --> 01:15:29,335
他們已經有了一大堆的API。

1497
01:15:29,335 --> 01:15:31,210
而且它可以是一個小
壓倒在第一，

1498
01:15:31,210 --> 01:15:33,000
但我會通過我們想要的東西指導我們。

1499
01:15:33,000 --> 01:15:38,500
>> 左上角是谷歌地圖
JavaScript的API，JavaScript API的。

1500
01:15:38,500 --> 01:15:40,380
因此，繼續前進，然後點擊一個。

1501
01:15:40,380 --> 01:15:49,360
而這將導致現在你的
下頁，演示和示例代碼。

1502
01:15:49,360 --> 01:15:51,190
讓我縮小在這裡。

1503
01:15:51,190 --> 01:15:56,300
讓我把我們中場休息向下滾動
到那裡說快速啟動步驟。

1504
01:15:56,300 --> 01:15:57,970
您的屏幕看起來應該像我的。

1505
01:15:57,970 --> 01:16:01,130
>> 並有兩個步驟，得到
一鍵啟動和發展。

1506
01:16:01,130 --> 01:16:04,190
我已經做了第一步的
我們得到一個所謂的關鍵。

1507
01:16:04,190 --> 01:16:05,320
而且這是一種常見的想法。

1508
01:16:05,320 --> 01:16:09,210
API密鑰通常只是
一個大的隨機數字或字符串

1509
01:16:09,210 --> 01:16:11,130
你應該
粘貼到你的代碼，

1510
01:16:11,130 --> 01:16:15,280
因此，谷歌知道你是誰，當
你使用他們的服務，他們的API。

1511
01:16:15,280 --> 01:16:17,370
但這並不意味著我們
被收取任何費用。

1512
01:16:17,370 --> 01:16:21,030
而現在，點擊，而不是
之一，單擊開始發展。

1513
01:16:21,030 --> 01:16:25,990
如果你能波箱
如果以上不知道我們在哪裡。

1514
01:16:25,990 --> 01:16:28,040
>> 所以，我們只是刮傷
面，在這裡，但什麼

1515
01:16:28,040 --> 01:16:31,000
我以為會是引人注目
是真正擁有我們所有人，

1516
01:16:31,000 --> 01:16:34,240
在一個窗口中使用Cloud9和
本教程在另一個窗口，

1517
01:16:34,240 --> 01:16:37,120
讓真正得到我們自己
並運行應用程序

1518
01:16:37,120 --> 01:16:40,920
嵌入自定義谷歌
映射在我們自己的網頁，

1519
01:16:40,920 --> 01:16:43,010
然後將一個或兩個功能。

1520
01:16:43,010 --> 01:16:45,520
但是，我們只是刮傷
什麼我們能做的表面。

1521
01:16:45,520 --> 01:16:47,020
>> 所以只是一個快速的健全性檢查。

1522
01:16:47,020 --> 01:16:49,740
是每個人在這個頁面中，
谷歌地圖API的JavaScript？

1523
01:16:49,740 --> 01:16:50,872
應該說起步。

1524
01:16:50,872 --> 01:16:53,330
我們不會去通過
以任何方式整個事情。

1525
01:16:53,330 --> 01:16:58,090
OK，在另一個選項卡，如果你不
打開它，就進入Cloud9

1526
01:16:58,090 --> 01:17:03,500
並獲得自己只是
一個新的標籤，最終。

1527
01:17:03,500 --> 01:17:11,070
如此反复，從昨天c9.io，
c9.io，只是創建一個新文件。

1528
01:17:11,070 --> 01:17:13,500
並繼續和呼叫
它不管你想。

1529
01:17:13,500 --> 01:17:16,495
我打電話給我map.html。

1530
01:17:16,495 --> 01:17:17,870
說它是什麼在.html結尾。

1531
01:17:17,870 --> 01:17:23,930

1532
01:17:23,930 --> 01:17:26,580
你應該大致
在那裡，我在這個過程中

1533
01:17:26,580 --> 01:17:31,470
在一個空的只是一個閃爍提示
標籤被稱為像map.html。

1534
01:17:31,470 --> 01:17:35,808

1535
01:17:35,808 --> 01:17:38,148
或文件，新文件這一次。

1536
01:17:38,148 --> 01:17:41,960

1537
01:17:41,960 --> 01:17:48,000
>> 而現在，在上
谷歌地圖API的JavaScript，

1538
01:17:48,000 --> 01:17:50,010
我們將跳過閱讀
通過這一切的文字。

1539
01:17:50,010 --> 01:17:53,760
但是請注意，你好世界
確實無處不在，你現在看到了。

1540
01:17:53,760 --> 01:17:58,020
你好世界上有這麼大豐富多彩
例如一大堆HTML的。

1541
01:17:58,020 --> 01:18:03,590
來吧，複製和只粘貼
HTML，所以從在頂部的文檔類型

1542
01:18:03,590 --> 01:18:08,810
一路的密切HTML標記，去
繼續並重新複製所有的that--，

1543
01:18:08,810 --> 01:18:14,430
這就是世界你好下example--
並粘貼到您的Cloud9標籤，

1544
01:18:14,430 --> 01:18:17,996
所以說現在你的屏幕
應該大致像我這樣。

1545
01:18:17,996 --> 01:18:22,280

1546
01:18:22,280 --> 01:18:24,520
>> 而且你可以將它保存，但
不加載它只是還沒有。

1547
01:18:24,520 --> 01:18:26,290
讓我們先來看看
代碼，看看我們是否

1548
01:18:26,290 --> 01:18:29,110
不能推斷或學習
從它是什麼谷歌

1549
01:18:29,110 --> 01:18:30,860
已經有美國的盲目複製和粘貼。

1550
01:18:30,860 --> 01:18:33,334
他們只是想幫助，
從字面上看，讓我們開始，

1551
01:18:33,334 --> 01:18:35,500
但有沒有那麼多
複雜居然有。

1552
01:18:35,500 --> 01:18:40,100

1553
01:18:40,100 --> 01:18:42,210
如有任何問題，只是還沒有？

1554
01:18:42,210 --> 01:18:43,790
我們很安全，銳意進取？

1555
01:18:43,790 --> 01:18:44,330
好。

1556
01:18:44,330 --> 01:18:46,800
>> 如此迅速，我們只是做
一些快速完整性檢查。

1557
01:18:46,800 --> 01:18:48,800
一條線的我
見，希望你

1558
01:18:48,800 --> 01:18:51,710
你看，這是什麼意思，DOCTYPE HTML？

1559
01:18:51,710 --> 01:18:52,385
賈巴爾，還記得？

1560
01:18:52,385 --> 01:18:53,260
聽眾：[聽不清]

1561
01:18:53,260 --> 01:18:53,968
DAVID MALAN：是的。

1562
01:18:53,968 --> 01:18:54,870
這裡談到HTML 5。

1563
01:18:54,870 --> 01:18:57,950
同時，兩線的上
這裡的屏幕意味著哎瀏覽器，

1564
01:18:57,950 --> 01:18:59,482
這裡是實際的HTML。

1565
01:18:59,482 --> 01:19:01,440
線路三是哎瀏覽器，
來這裡的頭。

1566
01:19:01,440 --> 01:19:04,260
四號線，當然，嘿嘿
瀏覽器，來這裡的冠軍。

1567
01:19:04,260 --> 01:19:07,780
什麼是五號線嗎？

1568
01:19:07,780 --> 01:19:09,930
實際上，這並不
真正做到了我們什麼。

1569
01:19:09,930 --> 01:19:13,340
在這種情況下，它只是調整大小
該頁面為默認。第六行，

1570
01:19:13,340 --> 01:19:16,140
我們還沒有談到，但是它
指定字符編碼。

1571
01:19:16,140 --> 01:19:19,181
有不同的方式來編碼文件，
尤其是對外國語言。

1572
01:19:19,181 --> 01:19:21,100
UTF-8只是往往是默認的。

1573
01:19:21,100 --> 01:19:26,580
>> 所以，現在我們將看到一行
七個通16，一些CSS。

1574
01:19:26,580 --> 01:19:29,260
儘管我們還沒有看到
所有這些事情之前，

1575
01:19:29,260 --> 01:19:30,810
我們可以種推斷。

1576
01:19:30,810 --> 01:19:37,075
因此，八號線的手段，嘿嘿的瀏覽器，適用
以下所有以兩個標籤，

1577
01:19:37,075 --> 01:19:37,575
顯然？

1578
01:19:37,575 --> 01:19:40,650

1579
01:19:40,650 --> 01:19:41,701
HTML和正文。

1580
01:19:41,701 --> 01:19:43,200
所以，逗號是有新的東西。

1581
01:19:43,200 --> 01:19:46,140
而這只是一個方式
一次指定多個標籤。

1582
01:19:46,140 --> 01:19:47,640
>> 然後，我們已經得到了大括號內。

1583
01:19:47,640 --> 01:19:51,170
因此很明顯，這告訴瀏覽器，
使頁面100％的高度。

1584
01:19:51,170 --> 01:19:54,170
所以，即使有很少
內容，使整個頁面，

1585
01:19:54,170 --> 01:19:55,530
使事情填充頁面。

1586
01:19:55,530 --> 01:19:57,524
使地圖最終填充頁面。

1587
01:19:57,524 --> 01:19:58,690
保證金，這是什麼意思？

1588
01:19:58,690 --> 01:20:01,559
這通常喜歡隨心所欲
白色空間周圍的邊緣

1589
01:20:01,559 --> 01:20:04,350
有些瀏覽器只是設計師
決定應該有，因為它

1590
01:20:04,350 --> 01:20:05,540
那種讓事情看起來更乾淨。

1591
01:20:05,540 --> 01:20:06,498
但是，我們不希望這樣。

1592
01:20:06,498 --> 01:20:08,710
我們希望地圖去
一路的邊緣。

1593
01:20:08,710 --> 01:20:10,930
填充，在精神上的利潤率相近。

1594
01:20:10,930 --> 01:20:14,980
平均利潤率外，填補裝置
在裡面，但它的同類交易。

1595
01:20:14,980 --> 01:20:17,520
這是一個緩衝的一點點
你和邊緣之間。

1596
01:20:17,520 --> 01:20:21,170
>> 然後13號線是一個很好的
機會快速回顧。

1597
01:20:21,170 --> 01:20:26,440
什麼尖銳的跡象地圖
意思是，或包括hashtag圖是什麼意思？

1598
01:20:26,440 --> 01:20:29,650
這是什麼參考，原則？

1599
01:20:29,650 --> 01:20:31,485
>> 聽眾：[聽不清]

1600
01:20:31,485 --> 01:20:32,360
DAVID MALAN：沒錯。

1601
01:20:32,360 --> 01:20:36,900
此屬性，此CSS屬性
適用於一件事，HTML標記

1602
01:20:36,900 --> 01:20:41,180
具有引用的ID，引文結束“地圖”。

1603
01:20:41,180 --> 01:20:44,460
現在，讓我們快進，滾動
下到文件的底部，其

1604
01:20:44,460 --> 01:20:49,860
是不是太遙遠，和在線通知
19，如果您將其粘貼正是像我一樣，

1605
01:20:49,860 --> 01:20:53,405
線19具有只是一個div，這是一個
頁面，昨天我司

1606
01:20:53,405 --> 01:20:54,820
所謂的矩形區域。

1607
01:20:54,820 --> 01:20:55,820
它有什麼也沒有。

1608
01:20:55,820 --> 01:20:57,550
這是一個開放的標籤，結束標記。

1609
01:20:57,550 --> 01:20:59,490
但它確實有一個唯一的ID。

1610
01:20:59,490 --> 01:21:02,090
>> 那麼什麼似乎是
這裡發生的事情是谷歌

1611
01:21:02,090 --> 01:21:05,880
正在準備我們的網頁
擁有完整的100％的高度，

1612
01:21:05,880 --> 01:21:09,680
和沒有填充，無利潤，因為
我們打算把裡面

1613
01:21:09,680 --> 01:21:13,647
此格，其唯一的ID是
地圖，是一個實際的嵌入式地圖。

1614
01:21:13,647 --> 01:21:15,480
我們希望它來填充
的頁面，而不是僅僅

1615
01:21:15,480 --> 01:21:17,560
在中間的一些小矩形。

1616
01:21:17,560 --> 01:21:24,220
因此，14號線同樣強調，在
地圖本身應具有100％的高度。

1617
01:21:24,220 --> 01:21:29,220
>> 所以，現在線20之間的通知
和28，這是JavaScript代碼。

1618
01:21:29,220 --> 01:21:33,020
這是，即使它是
語法有點怪，

1619
01:21:33,020 --> 01:21:34,730
那裡不是所有的東西會在這裡。

1620
01:21:34,730 --> 01:21:39,310
在第21行，這是聲明
所謂的變量。

1621
01:21:39,310 --> 01:21:42,030
與其說這是的
量，像我們以前那樣，

1622
01:21:42,030 --> 01:21:44,500
我們更精確地說，
VAR，這只是意味著變量。

1623
01:21:44,500 --> 01:21:46,520
我們可以用在
尼克的代碼，但他沒有，所以我

1624
01:21:46,520 --> 01:21:48,190
沒有理會任何這樣做。

1625
01:21:48,190 --> 01:21:50,240
這是一個被稱為變量
地圖，然後有

1626
01:21:50,240 --> 01:21:53,360
一個函數，它是
顯然稱initMap。

1627
01:21:53,360 --> 01:21:55,780
>> 所以，這就像我們自己的自定義
拼圖的划痕。

1628
01:21:55,780 --> 01:21:58,830
我們創建了一塊
功能稱​​為initMap，

1629
01:21:58,830 --> 01:22:00,980
你可以種推斷
這裡發生了什麼。

1630
01:22:00,980 --> 01:22:02,930
在左手側，
我們已經有了一個變量，

1631
01:22:02,930 --> 01:22:06,000
所以我們打算把以下
該變量內在的東西，

1632
01:22:06,000 --> 01:22:07,362
從右到左。

1633
01:22:07,362 --> 01:22:11,940
右手邊說，哎
瀏覽器，給我一個新的谷歌地圖。

1634
01:22:11,940 --> 01:22:16,490
而google.maps.map僅僅是一個時髦的方式
指定此功能的

1635
01:22:16,490 --> 01:22:19,790
屬於谷歌地圖。

1636
01:22:19,790 --> 01:22:23,010
>> 括號後，我們已經看到了
在此之前，嘿嘿瀏覽器，得到

1637
01:22:23,010 --> 01:22:29,210
我的網頁中的元素，該
在標籤的唯一ID的頁面is--

1638
01:22:29,210 --> 01:22:30,710
>> 聽眾：[聽不清]

1639
01:22:30,710 --> 01:22:31,790
>> DAVID MALAN：--map。

1640
01:22:31,790 --> 01:22:35,770
而到底是怎麼回事，好了，
這條線一起，23行，

1641
01:22:35,770 --> 01:22:38,630
基本上說，
哎瀏覽器，去給我拿

1642
01:22:38,630 --> 01:22:42,800
頁面上的空div
其獨有的ID是地圖，

1643
01:22:42,800 --> 01:22:45,600
因為我想插入
到它 - 注入進去，

1644
01:22:45,600 --> 01:22:49,520
如果你will--一大堆內容
這種情況也可以從網絡到來，

1645
01:22:49,520 --> 01:22:50,427
後來。

1646
01:22:50,427 --> 01:22:52,010
和谷歌的拼盡全力的為我們。

1647
01:22:52,010 --> 01:22:55,350
>> 如此反复，在一天的最末端，
我們有抽象這個例子。

1648
01:22:55,350 --> 01:22:58,610
我不知道地圖是什麼
或如何實現的地圖API。

1649
01:22:58,610 --> 01:22:59,460
我們並不需要。

1650
01:22:59,460 --> 01:23:02,740
我們只需要告訴地圖
在那裡把自己，並留下

1651
01:23:02,740 --> 01:23:04,880
那些底層的實現
細節谷歌。

1652
01:23:04,880 --> 01:23:08,190
現在，顯然有
數據的兩件

1653
01:23:08,190 --> 01:23:11,940
本例是
提供谷歌的API。

1654
01:23:11,940 --> 01:23:16,450
顯然在地圖的中心，
和縮放級別，可以這麼說。

1655
01:23:16,450 --> 01:23:21,390
>> 而且沒有人承認這些
坐標，緯度和經度？

1656
01:23:21,390 --> 01:23:24,364
或許不會，但我們可以回去
到教程，從字面上看。

1657
01:23:24,364 --> 01:23:25,780
但是，我們會看到它在短短的時刻。

1658
01:23:25,780 --> 01:23:29,880
縮放級別之間的值，我不知道
知道，一個在13或類似的東西。

1659
01:23:29,880 --> 01:23:32,880
它只是與你多遠辦
放大或縮小，僅此而已。

1660
01:23:32,880 --> 01:23:35,690
而現在的盡頭
頁面，通知行29--

1661
01:23:35,690 --> 01:23:39,960
這是一個有點難看，因為
它wraps--這行代碼

1662
01:23:39,960 --> 01:23:44,570
是下載到
谷歌瀏覽器的實際API。

1663
01:23:44,570 --> 01:23:47,500
所有的代碼，谷歌的
工程師們編寫實現

1664
01:23:47,500 --> 01:23:50,000
嵌入地圖這整個功能。

1665
01:23:50,000 --> 01:23:51,470
>> 現在，讓我們沒有改變任何東西。

1666
01:23:51,470 --> 01:23:54,761
如果你沿著之後，繼續前進，
只保存該文件，如果你確實有

1667
01:23:54,761 --> 01:23:55,760
我擁有的。

1668
01:23:55,760 --> 01:23:57,370
去其URL。

1669
01:23:57,370 --> 01:23:59,820
您可以點擊運行按鈕
往上頂，這將告訴

1670
01:23:59,820 --> 01:24:03,050
您的Web服務器的URL一次。

1671
01:24:03,050 --> 01:24:06,010
它會引領你到一個新的標籤。

1672
01:24:06,010 --> 01:24:11,910
如果您單擊打開的
map.html，賠率是你

1673
01:24:11,910 --> 01:24:15,520
要得到一個警告，
錯誤消息，是嗎？

1674
01:24:15,520 --> 01:24:18,570
錯誤信息，錯誤信息？

1675
01:24:18,570 --> 01:24:21,170
>> 所以很遺憾，錯誤
消息是不是啟發

1676
01:24:21,170 --> 01:24:23,890
除非你真正打開
控制台，特殊標籤，我們

1677
01:24:23,890 --> 01:24:27,110
保持開放和昨天
一點點的當天。

1678
01:24:27,110 --> 01:24:29,445
但是，我偶然發現
這個較早，所以我已經

1679
01:24:29,445 --> 01:24:30,820
想出解決的辦法是什麼。

1680
01:24:30,820 --> 01:24:34,440
在今天的幻燈片，或
相反，在Cloud9，通知

1681
01:24:34,440 --> 01:24:36,430
我們沒有做
一些故意的。

1682
01:24:36,430 --> 01:24:40,690
注意，這個腳本標籤中
第29行，如果你讀通過它，

1683
01:24:40,690 --> 01:24:44,440
它就像maps.googleapis.com/
什麼，什麼，什麼，

1684
01:24:44,440 --> 01:24:46,430
然後注意到有人，
開發商之一，

1685
01:24:46,430 --> 01:24:50,040
在所有的資本寫道：
字母，你的API密鑰。

1686
01:24:50,040 --> 01:24:51,700
>> 我們必須粘貼有什麼。

1687
01:24:51,700 --> 01:24:53,450
這是一步
我做了我們面前，

1688
01:24:53,450 --> 01:24:57,190
他們再次可能黑名單
我們彷彿突然，12個或更多的我們

1689
01:24:57,190 --> 01:24:59,470
開始使用相同的密鑰，
但讓​​我們看看會發生什麼。

1690
01:24:59,470 --> 01:25:03,030
所以，如果你進入今天的
幻燈片，一張幻燈片後，有

1691
01:25:03,030 --> 01:25:07,070
這個非常時髦的前瞻性文本字符串。

1692
01:25:07,070 --> 01:25:12,230
繼續前進，只是複製和
它說：你的API密鑰粘貼。

1693
01:25:12,230 --> 01:25:15,120
這是我簽署了一個。

1694
01:25:15,120 --> 01:25:17,700
>> 絕對不要嘗試
手動輸入了，

1695
01:25:17,700 --> 01:25:21,210
因為感覺充滿
有錯別字，有可能。

1696
01:25:21,210 --> 01:25:23,260
因此，只要複製和粘貼。

1697
01:25:23,260 --> 01:25:26,090
而這將使得該行
更長的時間，但現在，僅僅是明確的，

1698
01:25:26,090 --> 01:25:29,540
它看起來應該多一點
這樣，這裡的關鍵不等於

1699
01:25:29,540 --> 01:25:32,200
資本在你大喊大叫。

1700
01:25:32,200 --> 01:25:34,810
保存頁面，回去
其他選項卡，重裝，

1701
01:25:34,810 --> 01:25:36,770
並希望看到地圖上哪裡？

1702
01:25:36,770 --> 01:25:37,790
>> 聽眾：澳大利亞。

1703
01:25:37,790 --> 01:25:38,748
>> DAVID MALAN：澳大利亞。

1704
01:25:38,748 --> 01:25:41,200
因此很明顯，這些都是
GPS坐標澳大利亞。

1705
01:25:41,200 --> 01:25:44,491
讓我逛完只是一瞬間
並幫助任何人誰是不能令人信服，

1706
01:25:44,491 --> 01:25:47,729
但讓​​我提出，通過谷歌，找到
你自己家鄉的GPS坐標

1707
01:25:47,729 --> 01:25:48,770
還是自己的祖國。

1708
01:25:48,770 --> 01:25:51,436
大概谷歌可以關閉此
，或者維基百科可以告訴你。

1709
01:25:51,436 --> 01:25:54,410
但是，選擇兩種不同的價值觀
對於經度和緯度，

1710
01:25:54,410 --> 01:25:57,530
回去和粘貼他們，
然後保存後重新加載頁面

1711
01:25:57,530 --> 01:26:00,718
看看你是否能有
地圖為自己的家鄉。

1712
01:26:00,718 --> 01:26:04,500

1713
01:26:04,500 --> 01:26:08,042
>> 而當你與完成
即，後續challenge--

1714
01:26:08,042 --> 01:26:11,250
我給少一點的方向，
故意讓你故意

1715
01:26:11,250 --> 01:26:13,791
有一對夫婦的鬥爭
與文檔分鐘，

1716
01:26:13,791 --> 01:26:18,740
改變地圖為不這
卡通默認，但衛星地圖。

1717
01:26:18,740 --> 01:26:24,600
所以你實際看到的衛星
圖像，而不是漂亮的顏色。

1718
01:26:24,600 --> 01:26:29,710
>> 而暗示我給你
是更改地圖的類型。

1719
01:26:29,710 --> 01:26:33,084
回到那個讓
開始頁尋找靈感。

1720
01:26:33,084 --> 01:26:40,599

1721
01:26:40,599 --> 01:26:42,390
正如你可能已經收集到，
如果你正在尋找，

1722
01:26:42,390 --> 01:26:44,250
有那麼多的
事情可以做。

1723
01:26:44,250 --> 01:26:46,380
你們當中有些人已經
改變了地圖類型。

1724
01:26:46,380 --> 01:26:49,890
但是你可以do--例如，讓我
去的東西我們做的課程

1725
01:26:49,890 --> 01:26:52,050
我teach-- maps.cs50.net。

1726
01:26:52,050 --> 01:26:53,470
我們的一位本科生這樣做。

1727
01:26:53,470 --> 01:26:58,890
我們集中我們的地圖上哈佛和
覆蓋所有這些建築的名字，

1728
01:26:58,890 --> 01:27:01,070
我們讓他添加此。

1729
01:27:01,070 --> 01:27:04,270
所以，如果我想搜索，
例如，馬修斯廳，

1730
01:27:04,270 --> 01:27:05,730
我們有一個小的下拉菜單。

1731
01:27:05,730 --> 01:27:09,080
而且我認為他的使用引導時，
圖書館前面這個討論。

1732
01:27:09,080 --> 01:27:12,190
如果你點擊馬修斯
大廳，立刻

1733
01:27:12,190 --> 01:27:14,790
跳躍地圖以一定
位置，它表明

1734
01:27:14,790 --> 01:27:16,440
你在這個小彈出一個畫面。

1735
01:27:16,440 --> 01:27:18,670
>> 但即使是這個小
彈出，我們沒有實現。

1736
01:27:18,670 --> 01:27:27,521
如果我向下滾動，我們得到
開始頁面，並查找信息窗口，

1737
01:27:27,521 --> 01:27:29,770
你會看到一些的
功能你自己

1738
01:27:29,770 --> 01:27:31,561
可以添加，儘管有
更複雜一點，

1739
01:27:31,561 --> 01:27:33,970
一些所謂的信息窗口。

1740
01:27:33,970 --> 01:27:37,190
如果我點擊一個例子
在這裡，這是何等的樂趣，

1741
01:27:37,190 --> 01:27:40,530
你可以做這樣的事情，
點擊一個標記，然後瞧，

1742
01:27:40,530 --> 01:27:42,400
信息彈出。

1743
01:27:42,400 --> 01:27:45,874
>> 因此，我們還沒有完全出台
的JavaScript的功能不夠

1744
01:27:45,874 --> 01:27:49,040
畫的圖畫究竟如何
可以連接所有的這些東西在一起，

1745
01:27:49,040 --> 01:27:50,706
但我們那種觸及表面。

1746
01:27:50,706 --> 01:27:53,140
其實，我只是做的時候
我點擊該標記，

1747
01:27:53,140 --> 01:27:55,819
被觸發的事件，一個
所謂的單擊事件。

1748
01:27:55,819 --> 01:27:57,610
而我們居然看到了
事件今天早些時候，

1749
01:27:57,610 --> 01:28:00,670
所謂提交事件，
當我們被阻止

1750
01:28:00,670 --> 01:28:02,490
從尋找貓的用戶。

1751
01:28:02,490 --> 01:28:06,560
因此，我們那種千挑萬選用
從所有這些各種功能中，

1752
01:28:06,560 --> 01:28:08,990
給你的感覺，希望
什麼，你其實可以

1753
01:28:08,990 --> 01:28:11,000
做多一點
舒適的編程，

1754
01:28:11,000 --> 01:28:12,587
而完全免費的資源。

1755
01:28:12,587 --> 01:28:15,856

1756
01:28:15,856 --> 01:28:18,770
>> 任何問題？

1757
01:28:18,770 --> 01:28:19,790
沒有？

1758
01:28:19,790 --> 01:28:22,542
這是你最後的機會，
今天至少，在週五，

1759
01:28:22,542 --> 01:28:25,000
得到任何關你的胸部
讓你走出這裡

1760
01:28:25,000 --> 01:28:27,067
感覺自信和舒適。

1761
01:28:27,067 --> 01:28:27,566
是。

1762
01:28:27,566 --> 01:28:29,740
>> 聽眾：為什麼不
你添加更多的東西嗎？

1763
01:28:29,740 --> 01:28:32,720
>> DAVID MALAN：我的天哪。

1764
01:28:32,720 --> 01:28:35,260
我需要休息這個週末，我想。

1765
01:28:35,260 --> 01:28:36,180
其他問題？

1766
01:28:36,180 --> 01:28:37,055
>> 聽眾：[聽不清]

1767
01:28:37,055 --> 01:28:44,130

1768
01:28:44,130 --> 01:28:46,810
>> DAVID MALAN：你can--在
Internet Explorer中，安息吧，

1769
01:28:46,810 --> 01:28:49,310
你曾經是能夠把VB
腳本，虛擬基本的腳本，

1770
01:28:49,310 --> 01:28:50,643
但真的從來沒有流行起來。

1771
01:28:50,643 --> 01:28:52,490
所以，簡單的答案是剛剛的JavaScript。

1772
01:28:52,490 --> 01:28:55,144

1773
01:28:55,144 --> 01:28:55,810
其他問題？

1774
01:28:55,810 --> 01:28:58,427

1775
01:28:58,427 --> 01:28:59,760
好吧，好吧，讓我這樣做。

1776
01:28:59,760 --> 01:29:02,070
讓我搶外面的同事。

1777
01:29:02,070 --> 01:29:04,500
他們有一些評測
他們希望每個人都表格

1778
01:29:04,500 --> 01:29:06,310
花幾分鐘時間填寫。

1779
01:29:06,310 --> 01:29:08,775
他們想收集的形式和任何
你可能有減免之外。

1780
01:29:08,775 --> 01:29:10,240
他們還將有證書。

1781
01:29:10,240 --> 01:29:12,380
我猜有
外面仍然有一些小吃。

1782
01:29:12,380 --> 01:29:14,360
讓我通過這些了，如果你
在此期間有任何問題，

1783
01:29:14,360 --> 01:29:17,120
我會走動更多的獨立
我們可以讓你開始。

1784
01:29:17,120 --> 01:29:17,879
當然是。

1785
01:29:17,879 --> 01:29:18,754
聽眾：[聽不清]

1786
01:29:18,754 --> 01:29:26,737

1787
01:29:26,737 --> 01:29:28,570
DAVID MALAN：這是
通常真正的這些日子。

1788
01:29:28,570 --> 01:29:30,730
當然，與網絡
軟件時，靠在

1789
01:29:30,730 --> 01:29:32,901
別人你要么
美觀使用的東西

1790
01:29:32,901 --> 01:29:35,400
像引導，讓你不
必須實現低水平

1791
01:29:35,400 --> 01:29:37,169
菜單的細節和
按鈕和所有。

1792
01:29:37,169 --> 01:29:39,210
你扶著別人
像谷歌這樣你

1793
01:29:39,210 --> 01:29:42,050
沒有建立一個尤伯杯
業務和映射業務，

1794
01:29:42,050 --> 01:29:44,850
和任何數量的類似
應用程序也是如此。

1795
01:29:44,850 --> 01:29:46,350
>> 事實上，登錄都受歡迎。

1796
01:29:46,350 --> 01:29:48,500
如果你已經使用Spotify的或
任何數量的網站，

1797
01:29:48,500 --> 01:29:51,210
你會登錄一些
使用Facebook的網站。

1798
01:29:51,210 --> 01:29:53,350
那麼，什麼是好的，有
對於登錄的API

1799
01:29:53,350 --> 01:29:56,570
如今，讓您不必
擁有自己的用戶表

1800
01:29:56,570 --> 01:29:59,440
和你自己的數據庫
不一定以相同的程度。

1801
01:29:59,440 --> 01:30:01,795
你可以讓Facebook的做
那複雜性為您服務。

1802
01:30:01,795 --> 01:30:03,920
所以這是一個激動人心的時刻，
說實話，在規劃，

1803
01:30:03,920 --> 01:30:07,200
因為有這麼多的第三方
服務，你可以建立在上面。

1804
01:30:07,200 --> 01:30:10,890
>> 再次，你付出的代價是
無論是財政或停機。

1805
01:30:10,890 --> 01:30:13,750
如果谷歌下降，
所以呢尤伯杯，可以說，

1806
01:30:13,750 --> 01:30:15,690
但也許這是一個
合理的取捨。

1807
01:30:15,690 --> 01:30:18,040
再次，這是主題之一，
我們希望，在過去的幾天，

1808
01:30:18,040 --> 01:30:18,780
是這些權衡。

1809
01:30:18,780 --> 01:30:20,738
而很少有去
是一個正確的答案。

1810
01:30:20,738 --> 01:30:25,700
這真的是更好
的兩個或兩個以上的答案。

1811
01:30:25,700 --> 01:30:26,682
>> 各地通過這些。

1812
01:30:26,682 --> 01:30:36,830

1813
01:30:36,830 --> 01:30:41,110
>> 而這些Cloud9帳戶將繼續
工作，在理論上，在永久。

1814
01:30:41,110 --> 01:30:45,000
您可能會發現，如果你再等幾天
或一個星期或更長時間重新登錄到他們，

1815
01:30:45,000 --> 01:30:49,170
這可能需要像一個或
五分鐘開回來了，

1816
01:30:49,170 --> 01:30:54,090
但是這只是因為他們把
它睡覺，以節省資源。

1817
01:30:54,090 --> 01:31:10,527