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
缩放级别之间的值，我不知道
知道，一个在1​​3或类似的东西。

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