1
00:00:00,000 --> 00:00:02,862
>> [音乐播放]

2
00:00:02,862 --> 00:00:10,030

3
00:00:10,030 --> 00:00:11,580
>> DAVID马兰：这是CS50。

4
00:00:11,580 --> 00:00:12,880
这是9周的开始。

5
00:00:12,880 --> 00:00:15,797
这是什么将有
是布尔先生诞辰200周年。

6
00:00:15,797 --> 00:00:17,630
因此，这是研究员
对他们，我们已经提到

7
00:00:17,630 --> 00:00:21,800
相当长的一段时间关于使用
布尔变量真与假，

8
00:00:21,800 --> 00:00:22,910
1和0这样。

9
00:00:22,910 --> 00:00:25,270
这是谷歌的
今天向他表示敬意。

10
00:00:25,270 --> 00:00:26,489
他会变成200。

11
00:00:26,489 --> 00:00:28,280
所以，如果你想
我们一起CS50午餐

12
00:00:28,280 --> 00:00:30,279
看看链接
在球场上的网站。

13
00:00:30,279 --> 00:00:33,580
而这样的面孔和朋友
这里在剑桥这些等待着你。

14
00:00:33,580 --> 00:00:35,360
像这些面孔等待着你在纽黑文。

15
00:00:35,360 --> 00:00:37,800
而且，事实上，肯在
纽黑文热情地让

16
00:00:37,800 --> 00:00:41,594
什么叫礼的GIF动画
这里在最近lunch--一个GIF尚未

17
00:00:41,594 --> 00:00:44,260
另一图形文件格式，
与你familiar--的

18
00:00:44,260 --> 00:00:46,300
看起来有点像这样。

19
00:00:46,300 --> 00:00:48,179
因此，只要序列of--确定。

20
00:00:48,179 --> 00:00:49,720
这里没有人在剑桥的笑。

21
00:00:49,720 --> 00:00:51,720
但在纽黑文，这
真可笑，对不对？

22
00:00:51,720 --> 00:00:52,350
好吧。

23
00:00:52,350 --> 00:00:53,940
>> 所以不要我们一起在那里。

24
00:00:53,940 --> 00:00:55,900
在这里，在哈佛，
具体而言，本周三，

25
00:00:55,900 --> 00:00:59,480
如果你是一个大二或大一even--
甚至junior--制作思路

26
00:00:59,480 --> 00:01:01,563
交换机到计算机
科学，知道有会

27
00:01:01,563 --> 00:01:04,440
被一个CS建议交易会
周三，下课后不久，

28
00:01:04,440 --> 00:01:08,040
在下午4点，在计算机
科学楼马克斯韦尔德沃金。

29
00:01:08,040 --> 00:01:11,890
我们会把这个在球场上的
网站的明天，也是如此。

30
00:01:11,890 --> 00:01:14,430
甜甜圈，我被告知，将送达。

31
00:01:14,430 --> 00:01:15,180
>> 好吧。

32
00:01:15,180 --> 00:01:18,790
太好笑了story--我被戳
围绕在互联网上，

33
00:01:18,790 --> 00:01:23,575
我发现一些旧档案
我以前的网站。

34
00:01:23,575 --> 00:01:25,950
而事实证明out--解决此
时间，似乎很及时

35
00:01:25,950 --> 00:01:28,910
因为据我了解，在UC选举
即将装备起来。

36
00:01:28,910 --> 00:01:32,230
所以，我跑了UC，凄惨地丢失。

37
00:01:32,230 --> 00:01:34,770
也许这是部分原因。

38
00:01:34,770 --> 00:01:37,600
因此，这是我的网站的时候。

39
00:01:37,600 --> 00:01:40,477
出于某种原因，我认为这是
一个好主意，告诉人们面前

40
00:01:40,477 --> 00:01:43,310
什么我的平台是，为什么他们
应该投我一票，他们有

41
00:01:43,310 --> 00:01:47,770
点击进入地发现，
信息，现在回想起来是

42
00:01:47,770 --> 00:01:48,660
那种让人毛骨悚然。

43
00:01:48,660 --> 00:01:50,910
我真的不知道那是什么东西。

44
00:01:50,910 --> 00:01:53,140
>> 但它肯定没有
帮助我的竞选活动。

45
00:01:53,140 --> 00:01:56,874
我还发现，高层
year--我有这个布偶日历。

46
00:01:56,874 --> 00:01:58,540
提线木偶是一种流行当时的情况。

47
00:01:58,540 --> 00:01:59,456
或者，也许他们不是。

48
00:01:59,456 --> 00:02:01,790
我有一个布偶日历当时的情况。

49
00:02:01,790 --> 00:02:04,860
而且我认为这会是很酷的名字
我的电脑哈佛的网络

50
00:02:04,860 --> 00:02:07,460
frogman.student.harvard.edu。

51
00:02:07,460 --> 00:02:10,370
当时，我们都独一无二
识别主机名。

52
00:02:10,370 --> 00:02:13,150
你可以选择一些虚荣
名称，而不是你自己的名字。

53
00:02:13,150 --> 00:02:15,580
而我就跟着蛙人出于某种原因。

54
00:02:15,580 --> 00:02:19,040
>> 然后我started--我花了很多
时间通过点击这些链接

55
00:02:19,040 --> 00:02:20,280
今天早上。

56
00:02:20,280 --> 00:02:24,690
这是我对网页，
现在似乎有种可爱。

57
00:02:24,690 --> 00:02:28,210
但是，这也证明了刚
技术多远已经到来。

58
00:02:28,210 --> 00:02:30,310
我的意思是，早在一天，
486是什么东西。

59
00:02:30,310 --> 00:02:34,090
这些天来，它的超级，超级，
超慢，好少

60
00:02:34,090 --> 00:02:36,216
比你可能在你的
自己的腰包，这些天。

61
00:02:36,216 --> 00:02:38,465
还有更多在那里，
更是尴尬。

62
00:02:38,465 --> 00:02:39,770
所以我会离开它。

63
00:02:39,770 --> 00:02:42,640
但是，这是我的第一次
进军web--哦，不。

64
00:02:42,640 --> 00:02:43,180
这是不是。

65
00:02:43,180 --> 00:02:47,000
我第一次真正涉足网页编程
是这样的网站，我只是忘了。

66
00:02:47,000 --> 00:02:50,620
在某些时候，我学会了如何
做重复的背​​景图像。

67
00:02:50,620 --> 00:02:55,260
所以我发现这个平铺有效，
像冰球运动员，足球和高尔夫球

68
00:02:55,260 --> 00:02:58,040
球，或不管它是什么
为Frosh IM的网站。

69
00:02:58,040 --> 00:03:01,390
这实际上，真正的
第一个基于网络的项目，我花了on--

70
00:03:01,390 --> 00:03:03,880
我想，也许大二
今年，初中year--

71
00:03:03,880 --> 00:03:07,622
服用CS50和CS51，一前一后
的共同后续类。

72
00:03:07,622 --> 00:03:09,330
我注意到，在寻找
通过档案

73
00:03:09,330 --> 00:03:12,150
这对我的继任者之一，
样的朋友，李改

74
00:03:12,150 --> 00:03:13,480
版权自言自语。

75
00:03:13,480 --> 00:03:17,520
但是，这确实是东西
我应该对自己的尴尬。

76
00:03:17,520 --> 00:03:19,370
但在当时，这
是第一个网站，

77
00:03:19,370 --> 00:03:22,220
正如我所说的几个星期前，
由新生能

78
00:03:22,220 --> 00:03:24,350
从这里注册校内体育活动。

79
00:03:24,350 --> 00:03:27,950
所以，事实证明，
该背景图片

80
00:03:27,950 --> 00:03:29,530
这样是不是个好主意。

81
00:03:29,530 --> 00:03:31,840
但在网络是新的，并
我们都尝试。

82
00:03:31,840 --> 00:03:34,310
这就是我
显然没有当时。

83
00:03:34,310 --> 00:03:34,810
好吧。

84
00:03:34,810 --> 00:03:38,020
因此，事不宜迟，我们切换
齿轮今天给你的，真的，

85
00:03:38,020 --> 00:03:42,250
你可能会发现的最后一块
对于最终的项目特别有用

86
00:03:42,250 --> 00:03:44,780
而且，将开始到
使整个万维网

87
00:03:44,780 --> 00:03:46,680
感觉有点更容易理解。

88
00:03:46,680 --> 00:03:49,460
事实上，我们将引进
多了一个编程语言

89
00:03:49,460 --> 00:03:52,474
JavaScript调用，它类似于
并以不同的方式不同

90
00:03:52,474 --> 00:03:54,140
从语言，我们已经看到了迄今。

91
00:03:54,140 --> 00:03:55,807
>> 所以C，召回，是这样的编译语言。

92
00:03:55,807 --> 00:03:57,473
你必须通过一个编译器运行它。

93
00:03:57,473 --> 00:03:59,810
你得到的源代码，对象
代码，或零和一。

94
00:03:59,810 --> 00:04:03,000
而这些都是零和一的
你的CPU，中央处理单元，

95
00:04:03,000 --> 00:04:04,360
真正理解。

96
00:04:04,360 --> 00:04:06,610
PHP，相比之下，不
编译型语言。

97
00:04:06,610 --> 00:04:08,772
这是什么？

98
00:04:08,772 --> 00:04:09,980
这是一种解释型语言。

99
00:04:09,980 --> 00:04:11,750
因此，有一些程序
所谓的解释器，

100
00:04:11,750 --> 00:04:13,708
具有读取它 - 顶到
底部，左到right--

101
00:04:13,708 --> 00:04:16,519
并找出所有的东西
你的语法确实和手段，

102
00:04:16,519 --> 00:04:20,200
不管它是一个循环或条件
或编程的任何其他数量

103
00:04:20,200 --> 00:04:20,740
结构体。

104
00:04:20,740 --> 00:04:22,210
所以这是一种解释型语言。

105
00:04:22,210 --> 00:04:23,910
>> 然后，我们介绍了HTML。

106
00:04:23,910 --> 00:04:26,440
和HTML甚至不是一个
编程语言。

107
00:04:26,440 --> 00:04:28,110
我们会叫什么？

108
00:04:28,110 --> 00:04:31,650
一种标记语言，这就是
几分说它奇特的方式

109
00:04:31,650 --> 00:04:35,820
没有像编程构造
我们看到即使回到划痕的一天。

110
00:04:35,820 --> 00:04:36,720
有没有循环。

111
00:04:36,720 --> 00:04:37,920
有没有条件。

112
00:04:37,920 --> 00:04:40,820
这真的是一门语言
有关标记您的数据

113
00:04:40,820 --> 00:04:43,620
和格式化或
构建以某种方式。

114
00:04:43,620 --> 00:04:46,147
>> 的CSS，同时，类似地
不是一种编程语言。

115
00:04:46,147 --> 00:04:47,730
它甚至更美观为主。

116
00:04:47,730 --> 00:04:50,470
它可以让你排序的微调
像字体大小和颜色

117
00:04:50,470 --> 00:04:51,850
和安置了这一切。

118
00:04:51,850 --> 00:04:52,370
然后，我们有

119
00:04:52,370 --> 00:04:53,160
>> SQL。

120
00:04:53,160 --> 00:04:56,010
因此，SQL确实是一个编程
在一定意义上的语言，

121
00:04:56,010 --> 00:04:59,330
虽然定制
具体到数据库。

122
00:04:59,330 --> 00:05:03,347
但是，即使我们只为您介绍
选择和插入和删除和更新

123
00:05:03,347 --> 00:05:05,430
和其他几个，
原来你其实可以

124
00:05:05,430 --> 00:05:07,380
写函数或者
程序，因为它们是

125
00:05:07,380 --> 00:05:11,270
所谓的，在SQL的外观和行为
很喜欢PHP和C函数。

126
00:05:11,270 --> 00:05:12,390
所以知道这些存在。

127
00:05:12,390 --> 00:05:15,348
但是，我们甚至不与他们不屑
因为我们只是划伤表面在这里。

128
00:05:15,348 --> 00:05:18,600
然后JavaScript中，最后的
我们的语言正式出台。

129
00:05:18,600 --> 00:05:21,029
因此，JavaScript的，也就是
一种解释型语言。

130
00:05:21,029 --> 00:05:23,070
而那些熟悉的，做的
要区分它

131
00:05:23,070 --> 00:05:26,960
一些特征
从C和PHP？

132
00:05:26,960 --> 00:05:28,300
是什么使得它有什么不同？

133
00:05:28,300 --> 00:05:29,650
>> 听众：这不是编译。

134
00:05:29,650 --> 00:05:29,930
>> DAVID马兰：再说一遍吗？

135
00:05:29,930 --> 00:05:31,200
>> 听众：这不是编译。

136
00:05:31,200 --> 00:05:31,930
>> DAVID马兰：这不是编译。

137
00:05:31,930 --> 00:05:33,450
因此它也被解释。

138
00:05:33,450 --> 00:05:34,760
所以它不是编译。

139
00:05:34,760 --> 00:05:37,210
但是，这使得它像PHP一点。

140
00:05:37,210 --> 00:05:39,545
但它仍然从不同的
PHP在一些醒目的方式，

141
00:05:39,545 --> 00:05:40,920
至少在方式，我们将使用它。

142
00:05:40,920 --> 00:05:41,205
是吗？

143
00:05:41,205 --> 00:05:41,940
>> 听众：它运行的客户端。

144
00:05:41,940 --> 00:05:44,000
>> DAVID马兰：它运行
客户端，通常。

145
00:05:44,000 --> 00:05:47,190
这确实是显着
特点对于我们现在。

146
00:05:47,190 --> 00:05:51,170
C组服务器端的意义
我们所做的一切都是在CS50的IDE。

147
00:05:51,170 --> 00:05:53,630
PHP迄今已
服务器端，只要

148
00:05:53,630 --> 00:05:56,550
因为它也一样，得到interpreted--
没有编制，但interpreted--

149
00:05:56,550 --> 00:06:00,690
里面的CS50 IDE，这当然是
在云中仅有一个或多个服务器。

150
00:06:00,690 --> 00:06:03,070
>> 但JavaScript中，甚至
虽然你你会

151
00:06:03,070 --> 00:06:07,000
开始写它，比方说，PSET
八，也许最终projects--你

152
00:06:07,000 --> 00:06:09,620
要纠正它
CS50 IDE和保存

153
00:06:09,620 --> 00:06:14,760
在内部CS50 IDE，IDE CS50文件
和，反过来，云服务器

154
00:06:14,760 --> 00:06:19,160
其所托管的，都不会
解释或执行代码。

155
00:06:19,160 --> 00:06:23,880
相反，它会在要发送
未改变形式向下到浏览器。

156
00:06:23,880 --> 00:06:26,990
而且它然后将是IE浏览器
或者Chrome或Firefox或Safari

157
00:06:26,990 --> 00:06:30,697
或任何实际解释
它，从上到下，从左到右。

158
00:06:30,697 --> 00:06:32,780
因此，关键的区别
特征为今天

159
00:06:32,780 --> 00:06:36,110
是，JavaScript是客户端
和PHP，例如，

160
00:06:36,110 --> 00:06:37,690
已被服务器端。

161
00:06:37,690 --> 00:06:40,920
现在，这种具有有趣的含义
为一样，知识产权

162
00:06:40,920 --> 00:06:42,660
谁又能真正看到你的代码。

163
00:06:42,660 --> 00:06:44,860
事实上，你可以去
在网络上看到最

164
00:06:44,860 --> 00:06:47,530
有人有任何代码
用JavaScript编写的。

165
00:06:47,530 --> 00:06:50,230
有时是可读的，
有时它的模糊处理。

166
00:06:50,230 --> 00:06:52,550
但更多的是对在适当的时候。

167
00:06:52,550 --> 00:06:57,530
>> 所以JavaScript中，很好地不够，是
超级相似，语法，为C.

168
00:06:57,530 --> 00:06:59,364
和很多像PHP，
没有主要功能。

169
00:06:59,364 --> 00:07:02,113
如果你想开始写
JavaScript代码，你会看到今天，

170
00:07:02,113 --> 00:07:03,270
你刚开始写它。

171
00:07:03,270 --> 00:07:06,910
但它，你会看到，特别是
有用在Web浏览器的上下文中。

172
00:07:06,910 --> 00:07:09,820
然而，我的小
disclaimer--通常先前已经

173
00:07:09,820 --> 00:07:13,790
是说，你可以不断
今天使用JavaScript的服务器端

174
00:07:13,790 --> 00:07:17,655
使用名为Node.js的花式框架
的一些CS50自己的应用程序

175
00:07:17,655 --> 00:07:18,280
被写入。

176
00:07:18,280 --> 00:07:20,640
50检查实际使用node.js中

177
00:07:20,640 --> 00:07:24,140
但是，我们要重点关注
JavaScript客户端现在开始。

178
00:07:24,140 --> 00:07:26,750
>> 因此，这里是一组在PHP中的条件。

179
00:07:26,750 --> 00:07:29,350
对不起，in--事实上，这
声明中，也就是正确的。

180
00:07:29,350 --> 00:07:32,200
这里也是一组
条件在JavaScript中。

181
00:07:32,200 --> 00:07:35,560
在语法上，它是
与C和PHP。

182
00:07:35,560 --> 00:07:39,040
布尔先生的表达式，
同样，语法

183
00:07:39,040 --> 00:07:41,190
等同于C和PHP。

184
00:07:41,190 --> 00:07:44,100
我们也有在开关
JavaScript代码看起来完全相同。

185
00:07:44,100 --> 00:07:46,350
我们有一个循环是
结构相同，

186
00:07:46,350 --> 00:07:48,140
while循环，做while循环。

187
00:07:48,140 --> 00:07:49,980
>> 这其中有一点不同。

188
00:07:49,980 --> 00:07:53,120
PHP有每个结构
你可能会使用

189
00:07:53,120 --> 00:07:55,320
还是会在PSET七种用途，也许吧。

190
00:07:55,320 --> 00:07:59,460
JavaScript有此特殊版本
对，你从字面上说些什么

191
00:07:59,460 --> 00:08:03,864
像可变密钥中的对象，这
是说一个非常简洁的方式，

192
00:08:03,864 --> 00:08:06,780
如果我有一个object--，我们将
在moment--再谈论这些

193
00:08:06,780 --> 00:08:10,370
我想遍历所有
内的关键值对的，

194
00:08:10,370 --> 00:08:13,620
我没有搞清楚如何
数值索引它们与零个，一个

195
00:08:13,620 --> 00:08:14,580
二三。

196
00:08:14,580 --> 00:08:15,900
>> 我可以从字面上讲。

197
00:08:15,900 --> 00:08:20,740
并在每个迭代中，JavaScript的
我将更新可变密钥

198
00:08:20,740 --> 00:08:24,810
成为第一密钥，那么下一个键，
然后下键，则下一个键，

199
00:08:24,810 --> 00:08:25,510
等等。

200
00:08:25,510 --> 00:08:30,000
我可以通过治疗得到其价值
在JavaScript对象，因为我们将看到，

201
00:08:30,000 --> 00:08:32,584
就好像它是一个
关联数组在PHP。

202
00:08:32,584 --> 00:08:35,750
事实上，如果你终于缠你
介意身边有什么关联数组

203
00:08:35,750 --> 00:08:40,140
在PHP中，你可以把它现在的
相同在JavaScript的对象。

204
00:08:40,140 --> 00:08:42,030
但是，这一点
过于简单化。

205
00:08:42,030 --> 00:08:47,230
>> 阵列看，够漂亮，相同的
到PHP除了一个字符。

206
00:08:47,230 --> 00:08:51,425
有一件事在这里失踪
我们确实看到上周与PHP。

207
00:08:51,425 --> 00:08:52,050
什么是不加吗？

208
00:08:52,050 --> 00:08:53,310
是吗？

209
00:08:53,310 --> 00:08:54,090
没有美元符号。

210
00:08:54,090 --> 00:08:56,240
所以，我们又回到了一
比较正常的世界里，

211
00:08:56,240 --> 00:08:58,050
变量没有美元符号。

212
00:08:58,050 --> 00:09:00,810
但是你做前缀他们
使用var，通常。

213
00:09:00,810 --> 00:09:02,230
和VAR是指变量。

214
00:09:02,230 --> 00:09:06,440
而像PHP是松散
typed--其中有型，

215
00:09:06,440 --> 00:09:10,120
有数字和字符串
和花车等forth--

216
00:09:10,120 --> 00:09:11,570
JavaScript的同样有型。

217
00:09:11,570 --> 00:09:15,470
但它弱类型，因为我们的
程序员不必指定它们。

218
00:09:15,470 --> 00:09:18,980
我们只需要知道
不同类型的存在。

219
00:09:18,980 --> 00:09:21,690
>> 变量，meanwhile--这里是如何
我们可能会宣布“你好，世界”

220
00:09:21,690 --> 00:09:22,230
作为字符串。

221
00:09:22,230 --> 00:09:24,890
请注意，这是相同的
PHP，但没有美元符号。

222
00:09:24,890 --> 00:09:27,120
这是值得我们
开始看到更多的今天，

223
00:09:27,120 --> 00:09:30,990
因此，你有一个对象
与键和值。

224
00:09:30,990 --> 00:09:32,990
如果你想尝试
从去年week--推断

225
00:09:32,990 --> 00:09:34,730
语法是有点不同。

226
00:09:34,730 --> 00:09:39,740
不过有点神智check--多少
按键也该对象似乎有？

227
00:09:39,740 --> 00:09:40,850
所以，我看到四个。

228
00:09:40,850 --> 00:09:43,560
我看到两个。

229
00:09:43,560 --> 00:09:44,680
>> 因此，它实际上是两个。

230
00:09:44,680 --> 00:09:47,260
因此，这是一个集
两个键 - 值对。

231
00:09:47,260 --> 00:09:49,820
最关键的是符号，它的值是FB。

232
00:09:49,820 --> 00:09:52,620
最关键的是价格，其值为101.53。

233
00:09:52,620 --> 00:09:54,230
所以这是两个键 - 值对。

234
00:09:54,230 --> 00:09:58,120
请记住，PHP--而这又是
只是那种语法的差异。

235
00:09:58,120 --> 00:10:00,170
这还不是所有的
智力有趣。

236
00:10:00,170 --> 00:10:04,610
PHP可能已经写了这个相同的
作为follows--报价的事情，等于。

237
00:10:04,610 --> 00:10:06,730
而我，这些改变方括号。

238
00:10:06,730 --> 00:10:11,240
然后，我改变这
带引号的字，“价格”。

239
00:10:11,240 --> 00:10:12,500
然后，我不使用冒号。

240
00:10:12,500 --> 00:10:15,060
我才用什么上周？

241
00:10:15,060 --> 00:10:18,290
是啊，等号
箭头时髦的符号。

242
00:10:18,290 --> 00:10:21,470
>> 然后，我在这里做同样的事情。

243
00:10:21,470 --> 00:10:23,580
这里同样的事情。

244
00:10:23,580 --> 00:10:24,240
而这一切。

245
00:10:24,240 --> 00:10:27,752
所以这是很好，如果这还没有
真正沉没在内存只

246
00:10:27,752 --> 00:10:29,960
但因为它是真的
智力无趣。

247
00:10:29,960 --> 00:10:31,660
这只是语法上的不同。

248
00:10:31,660 --> 00:10:33,230
但思路是完全一样的。

249
00:10:33,230 --> 00:10:35,910
内该变量的
在JavaScript报价

250
00:10:35,910 --> 00:10:39,020
是键值对的集合，
其中之一是符号，其中一个

251
00:10:39,020 --> 00:10:39,690
是价格。

252
00:10:39,690 --> 00:10:42,340
我可以在这些值获得
以下语法。

253
00:10:42,340 --> 00:10:46,280
就像在PHP中，我可以
做一些like--让

254
00:10:46,280 --> 00:10:48,590
我做这个框大一点。

255
00:10:48,590 --> 00:10:52,750
就像在PHP中，我可以
使this--哦，该死。

256
00:10:52,750 --> 00:10:53,250
加油。

257
00:10:53,250 --> 00:10:56,350

258
00:10:56,350 --> 00:11:00,800
>> 就像在PHP-- OK，我们将
只要使用演示说明。

259
00:11:00,800 --> 00:11:06,010
就像在PHP中，我可以
做$报价$报价[“符号”]，

260
00:11:06,010 --> 00:11:08,860
这将让我
值“的象征。”

261
00:11:08,860 --> 00:11:12,800
在JavaScript中，这将是
相同的，因此我可以做到这一点。

262
00:11:12,800 --> 00:11:14,850
唯一那
缺少的是美元符号。

263
00:11:14,850 --> 00:11:17,470
>> 这么好听够的话，有
没有多少新的语法。

264
00:11:17,470 --> 00:11:21,025
因此，我们关注什么今天，真的，
一些想法和应用。

265
00:11:21,025 --> 00:11:22,900
和第一个这样的
应用程序，你可能

266
00:11:22,900 --> 00:11:26,090
已经看到，如果你潜入的pset
7已经是这样的语法。

267
00:11:26,090 --> 00:11:28,980
因此，在PSET七，如果你
见过或没见过它，

268
00:11:28,980 --> 00:11:33,570
知道，有一个文件就是我们给
你叫config.json--的JavaScript

269
00:11:33,570 --> 00:11:34,661
对象符号。

270
00:11:34,661 --> 00:11:35,160
为什么呢？

271
00:11:35,160 --> 00:11:39,540
我们希望能够为您提供
一些键值对的模板。

272
00:11:39,540 --> 00:11:44,290
我们希望能够给你一个列表
主机，服务器的名称。

273
00:11:44,290 --> 00:11:46,710
我们想给你一个
占位符，您的用户名

274
00:11:46,710 --> 00:11:48,210
和占位符，您的密码。

275
00:11:48,210 --> 00:11:49,410
如果你没有看到
这还没有，不用担心。

276
00:11:49,410 --> 00:11:51,340
更多关于这方面的pset 7
[？规范。 ？] 接着，

277
00:11:51,340 --> 00:11:53,173
很明显，我们希望你
填写待办事项

278
00:11:53,173 --> 00:11:55,310
因为当你登录
CS50 IDE，你们每个人

279
00:11:55,310 --> 00:11:57,630
有你自己的用户名和密码。

280
00:11:57,630 --> 00:12:00,910
>> 因此，我们可能已经使用了半打
或多个不同的文件格式。

281
00:12:00,910 --> 00:12:02,940
我们可以使用一个.txt文件。

282
00:12:02,940 --> 00:12:04,570
我们可以用一个CSV文件。

283
00:12:04,570 --> 00:12:06,745
我们可以使用过的
INI文件，XML文件，

284
00:12:06,745 --> 00:12:09,370
一大堆更多的缩写词
你可能没有听说过。

285
00:12:09,370 --> 00:12:11,244
这是一种武断
在一天结束。

286
00:12:11,244 --> 00:12:16,030
但超受追捧是一个文本
格式，称为JSON-- JavaScript对象

287
00:12:16,030 --> 00:12:18,460
Notation--，看起来像这样。

288
00:12:18,460 --> 00:12:20,890
这是一个有点神秘，
但要注意的模式。

289
00:12:20,890 --> 00:12:24,180
你开始以开放的花
撑，你最终以相同。

290
00:12:24,180 --> 00:12:26,550
里面的那是后话。

291
00:12:26,550 --> 00:12:27,920
这是一个键值对。

292
00:12:27,920 --> 00:12:30,580
所以这是我的对象
在屏幕上看着这里

293
00:12:30,580 --> 00:12:33,690
具有一个键，它具有一个值。

294
00:12:33,690 --> 00:12:37,610
而就推断基础上，
以前的模式，什么是这里的关键？

295
00:12:37,610 --> 00:12:39,790
数据库的事
结肠的左侧。

296
00:12:39,790 --> 00:12:43,500
>> 现在，该值正好是
一个多行这个时候。

297
00:12:43,500 --> 00:12:46,760
但值以卷曲
振奋并用大括号结束。

298
00:12:46,760 --> 00:12:49,480
所以，你会提出什么
数据库的值的类型？

299
00:12:49,480 --> 00:12:52,160

300
00:12:52,160 --> 00:12:54,670
字典或者，只是更多
简洁地说，一个对象。

301
00:12:54,670 --> 00:12:55,170
对？

302
00:12:55,170 --> 00:13:00,010
这是怎样的一个数据结构的
可以使用其他结构内本身。

303
00:13:00,010 --> 00:13:02,750
因此，如果这件事我们
调用一个object--和对象

304
00:13:02,750 --> 00:13:07,101
只是一堆的键值pairs--的
数据库本身的值是一个目的。

305
00:13:07,101 --> 00:13:10,350
数据库的价值有一大堆
关键值对，其中第一个

306
00:13:10,350 --> 00:13:13,130
为主机，然后将其命名，然后
用户名，然后密码，

307
00:13:13,130 --> 00:13:17,550
其每个的值，同时，它的
只是一个无聊的双引号括起来。

308
00:13:17,550 --> 00:13:19,770
>> 因此，即使这不是
超清晰，只是还没有，

309
00:13:19,770 --> 00:13:22,740
知道，这仅仅是一个
标准，相当无聊的方式

310
00:13:22,740 --> 00:13:25,190
的存储在一个标准的格式的数据。

311
00:13:25,190 --> 00:13:27,700
但常见的错误，你
可能使，即使在PSET七，

312
00:13:27,700 --> 00:13:32,120
是有点愚蠢的事情，就像你
一不小心忽略逗号那里。

313
00:13:32,120 --> 00:13:34,900
这将导致文件
不一定具有可读性。

314
00:13:34,900 --> 00:13:38,191
如果你不小心忽略的东西，如
报价，它不会是可读的。

315
00:13:38,191 --> 00:13:41,654
所以这是一个非常挑剔的文件格式，
但它是一个是超级常见。

316
00:13:41,654 --> 00:13:44,820
而我们碰巧使用它，即使
你不使用任何JavaScript，否则，

317
00:13:44,820 --> 00:13:46,330
在PSET七人。

318
00:13:46,330 --> 00:13:46,860
>> 好吧。

319
00:13:46,860 --> 00:13:48,110
所以请记住这张图片。

320
00:13:48,110 --> 00:13:51,657
我们谈到，在HTML中，这
代码可能会是这样。

321
00:13:51,657 --> 00:13:54,740
这是超文本标记语言
只是[听不清]“你好，世界”。

322
00:13:54,740 --> 00:13:57,570
但是，我们提出了一个
前阵子，如果有帮助，

323
00:13:57,570 --> 00:14:00,210
你可能要开始思考
这个已经是一棵树。

324
00:14:00,210 --> 00:14:03,730
事实上，压痕，我们
使用只是为了提高可读性的缘故

325
00:14:03,730 --> 00:14:05,610
或风格的缘故上
左侧可以种

326
00:14:05,610 --> 00:14:10,040
被翻译成这棵树，在那里你
有一些特殊的根节点，我们将

327
00:14:10,040 --> 00:14:16,860
一般称为文件，低于该
是根HTML元素或标记，HTML，

328
00:14:16,860 --> 00:14:19,980
然后具有两个
儿童，头部和身体。

329
00:14:19,980 --> 00:14:21,750
>> 然后反过来，头部有一个标题。

330
00:14:21,750 --> 00:14:23,440
和标题有一个文本值。

331
00:14:23,440 --> 00:14:26,130
而机身同样具有文本值。

332
00:14:26,130 --> 00:14:29,220
所以，如果你是舒服的说法
这是的，你可以利用这个HTML

333
00:14:29,220 --> 00:14:32,080
并得出类似的图片
此，右手侧

334
00:14:32,080 --> 00:14:35,910
是一个很好的心理模型，因为现在
我们有JavaScript的，编程

335
00:14:35,910 --> 00:14:39,960
语言，浏览器可以
执行和解释给你，

336
00:14:39,960 --> 00:14:42,690
事实证明，什么
我们即将做的代码

337
00:14:42,690 --> 00:14:45,320
在开始操作这个
树结构在存储器中。

338
00:14:45,320 --> 00:14:47,070
我们没有建
树在内存中。

339
00:14:47,070 --> 00:14:49,880
我们没有那种做
PSET十五风格的数据结构

340
00:14:49,880 --> 00:14:50,650
复杂性。

341
00:14:50,650 --> 00:14:54,610
浏览器，很好地不够，在
解释的HTML从上到下，

342
00:14:54,610 --> 00:14:58,600
左或右，是从字面上去
手我们指针的等效

343
00:14:58,600 --> 00:15:00,840
以免费的整个树。

344
00:15:00,840 --> 00:15:02,150
它做了所有的辛勤工作。

345
00:15:02,150 --> 00:15:05,520
这就是Mozilla和苹果
和其他人已经为我们所做的。

346
00:15:05,520 --> 00:15:09,400
>> 使用JavaScript我们要
能够控制和改变，做

347
00:15:09,400 --> 00:15:12,910
有趣的东西
那棵树，否则称为

348
00:15:12,910 --> 00:15:15,880
作为DOM或文档对象模型。

349
00:15:15,880 --> 00:15:17,110
什么样的事情呢？

350
00:15:17,110 --> 00:15:19,030
嗯，事实证明，
在JavaScript中，有

351
00:15:19,030 --> 00:15:22,800
这个洗衣清单
事件可以发生。

352
00:15:22,800 --> 00:15:26,330
而且，我们还没有真正使用的
一句话，因为周零和PSET

353
00:15:26,330 --> 00:15:28,240
零，当我们谈到划痕。

354
00:15:28,240 --> 00:15:31,390
大多数人可能没有用
事件在划痕的项目。

355
00:15:31,390 --> 00:15:33,850
但是，你可能还记得
简单马可波罗

356
00:15:33,850 --> 00:15:36,760
例如，如果我们有两个
其中一人的精灵，说，马可。

357
00:15:36,760 --> 00:15:40,180
其他的人，然后，在收听
和讯这种情况下，说，马球。

358
00:15:40,180 --> 00:15:42,080
如果没有，请随时
回头看那么远了。

359
00:15:42,080 --> 00:15:44,450
>> 但是，这仅仅是
再说了，你可以种

360
00:15:44,450 --> 00:15:47,730
从这些名称推断
事情，JavaScript的，事实证明，

361
00:15:47,730 --> 00:15:53,200
是想给大家一个办法，听
鼠标下降或鼠标往上走

362
00:15:53,200 --> 00:15:57,920
或键下降或密钥
上升或onsubmit的ONSELECT

363
00:15:57,920 --> 00:15:59,740
或onresizing东西。

364
00:15:59,740 --> 00:16:03,060
换句话说，任何物理动作
一个人可以使用浏览器

365
00:16:03,060 --> 00:16:08,210
你做的每一天，你可以写
该代码侦听这些事件

366
00:16:08,210 --> 00:16:10,220
然后做适当的事情。

367
00:16:10,220 --> 00:16:14,130
>> 举例来说，如果你使用谷歌地图，
如果你点击和移动会发生什么

368
00:16:14,130 --> 00:16:16,250
鼠标，典型地？

369
00:16:16,250 --> 00:16:17,758
如果您单击并拖动？

370
00:16:17,758 --> 00:16:18,258
是吗？

371
00:16:18,258 --> 00:16:21,701

372
00:16:21,701 --> 00:16:22,200
没错。

373
00:16:22,200 --> 00:16:23,159
地图开始移动。

374
00:16:23,159 --> 00:16:25,616
所以，你可以排序看看有什么
在这里，有什么在那里。

375
00:16:25,616 --> 00:16:27,130
以及如何做谷歌实现了吗？

376
00:16:27,130 --> 00:16:29,421
嗯，据推测，他们是
使用一对夫妇的这些事件

377
00:16:29,421 --> 00:16:31,720
听众，一个
说，监听鼠标

378
00:16:31,720 --> 00:16:35,410
down--因此当用户物理地
推他的触控板或他或她的鼠标

379
00:16:35,410 --> 00:16:36,010
下来。

380
00:16:36,010 --> 00:16:38,350
然后，我们正在寻找
像运动

381
00:16:38,350 --> 00:16:41,145
或一些其它事件
让我们捕捉拖累。

382
00:16:41,145 --> 00:16:45,910
而事实上，是拖拉同样在此
点点可能的选项点名单。

383
00:16:45,910 --> 00:16:49,140
>> 因此，这将是一个强大的
的方式开始响应用户

384
00:16:49,140 --> 00:16:52,824
甚至在他或她实际点击
明确的东西像提交。

385
00:16:52,824 --> 00:16:55,240
但是，我们要引进
一对夫妇主题到那里。

386
00:16:55,240 --> 00:16:58,570
但首先，让我们来过渡
一些实际代码。

387
00:16:58,570 --> 00:17:01,450
所以我要去
进取，不断开拓DOM-0，

388
00:17:01,450 --> 00:17:05,869
这是一个非常简单的例子
在这里，如果我放大只是

389
00:17:05,869 --> 00:17:08,500
有此输入来到我身边。

390
00:17:08,500 --> 00:17:12,410
而且我要继续前进，并输入
“大卫”为我的名，然后点击提交。

391
00:17:12,410 --> 00:17:17,940
>> 排序，然后，虽然便宜，我
有这样的提示弹出，上面写着：

392
00:17:17,940 --> 00:17:19,244
“你好，大卫！”

393
00:17:19,244 --> 00:17:21,740
因此，这是一种
像我们的“你好，世界”

394
00:17:21,740 --> 00:17:25,150
我们做了一段时间回来在C和
即使是在PHP，因为我已经动态

395
00:17:25,150 --> 00:17:26,310
输出我的名字。

396
00:17:26,310 --> 00:17:28,230
我可以在这里做别人的名字。

397
00:17:28,230 --> 00:17:31,240
我可以简单地更改为，
像汉娜，点击提交。

398
00:17:31,240 --> 00:17:33,780
事实上，小弹出的变化。

399
00:17:33,780 --> 00:17:36,650
>> 现在，弹出窗口中的一个
网络中最被滥用的特点。

400
00:17:36,650 --> 00:17:38,520
而事实上，早在
当天弹出窗口拦截器

401
00:17:38,520 --> 00:17:40,820
开始流行，因为你
会去一些website--

402
00:17:40,820 --> 00:17:43,604
也许是有问题的place--
那会突然

403
00:17:43,604 --> 00:17:46,020
启动胡椒屏幕
有一大堆的弹出窗口。

404
00:17:46,020 --> 00:17:49,700
因此这种能力弹出
在用户的前窗

405
00:17:49,700 --> 00:17:52,372
一直没有特别
广受人类。

406
00:17:52,372 --> 00:17:54,080
所以这就是为什么你看到的
这阻止的事情，

407
00:17:54,080 --> 00:17:55,706
这只是让这件事难看。

408
00:17:55,706 --> 00:17:57,996
因此，我们将需要一个
更好的方式来提示用户。

409
00:17:57,996 --> 00:17:59,350
但现在，似乎工作。

410
00:17:59,350 --> 00:18:03,320
所以只是凭直觉，什么
似乎是发生在这里？

411
00:18:03,320 --> 00:18:07,870
我继续前进，点击提交，
然后事情发生了，显然。

412
00:18:07,870 --> 00:18:12,870
但是，什么是不能发生的事情是发生过的事
上周任我点击提交？

413
00:18:12,870 --> 00:18:15,940
什么都没有发生在屏幕上？

414
00:18:15,940 --> 00:18:17,170
对不起？

415
00:18:17,170 --> 00:18:18,010
刷新。

416
00:18:18,010 --> 00:18:19,720
该网址没有改变的。

417
00:18:19,720 --> 00:18:22,250
我说，这是DOM-0，
我依然在DOM-0。

418
00:18:22,250 --> 00:18:26,890
通常情况下，我们会得到改变一些其他的
的URL，就像register.php或类似物。

419
00:18:26,890 --> 00:18:29,560
>> 但是，即使当我辞退
这件事情通过单击确定，

420
00:18:29,560 --> 00:18:32,310
注意到网址
保持完全投入。

421
00:18:32,310 --> 00:18:35,350
而且，事实上，如果我有一点
持怀疑态度，让我打开Chrome浏览器。

422
00:18:35,350 --> 00:18:36,860
让我打开网络选项卡。

423
00:18:36,860 --> 00:18:38,360
并且注意到它的空白的时刻。

424
00:18:38,360 --> 00:18:40,700
让我继续前进，重新提交玛丽亚。

425
00:18:40,700 --> 00:18:42,810
有没有网络流量任何责任。

426
00:18:42,810 --> 00:18:44,320
因此，有没有HTTP。

427
00:18:44,320 --> 00:18:47,620
>> 因此，我们确实，如果我看源代码
对于this--让我关闭这个窗口

428
00:18:47,620 --> 00:18:49,480
去查看源代码。

429
00:18:49,480 --> 00:18:50,400
有趣的。

430
00:18:50,400 --> 00:18:53,520
它看起来像有一些
新的标签，其中包括脚本。

431
00:18:53,520 --> 00:18:57,490
因此，让我们在CS50看看
IDE正是我发送给用户。

432
00:18:57,490 --> 00:19:00,690
>> 所以在这里is--我们
只关注HTML。

433
00:19:00,690 --> 00:19:03,500
这里的底部DOM-0.html的一半。

434
00:19:03,500 --> 00:19:07,830
并注意它有一个标题，
头标签，body标签，表单标签。

435
00:19:07,830 --> 00:19:11,257
但是，跳出你的
不同的，特别是如果你从来没有

436
00:19:11,257 --> 00:19:12,590
写任何JavaScript自己。

437
00:19:12,590 --> 00:19:14,920
让我滚动一点
这里的权利。

438
00:19:14,920 --> 00:19:18,330
我有一个输入，
另一个输入提交。

439
00:19:18,330 --> 00:19:21,410
我有一个ID，这是一种新的。

440
00:19:21,410 --> 00:19:22,790
但是，我们也看到这一点CSS。

441
00:19:22,790 --> 00:19:24,480
还有什么是绝对新的？

442
00:19:24,480 --> 00:19:24,980
是吗？

443
00:19:24,980 --> 00:19:30,580

444
00:19:30,580 --> 00:19:32,140
美观大方。

445
00:19:32,140 --> 00:19:32,760
>> 好吧。

446
00:19:32,760 --> 00:19:35,630
那么，它说的onsubmit，
注意到有东西似乎遵循。

447
00:19:35,630 --> 00:19:38,740
这是一个属性
在HTML命名。

448
00:19:38,740 --> 00:19:40,944
它的价值就在这里这个带引号的字符串。

449
00:19:40,944 --> 00:19:42,860
这看起来有点
怪异的第一眼。

450
00:19:42,860 --> 00:19:44,050
这不是HTML。

451
00:19:44,050 --> 00:19:45,240
这不是CSS。

452
00:19:45,240 --> 00:19:47,580
这是，您可能已经猜到，JavaScript的。

453
00:19:47,580 --> 00:19:51,850
如此看来，内置于该
网页是一个名为greet函数。

454
00:19:51,850 --> 00:19:54,250
而我推断，只是
因为它是一个词，打招呼。

455
00:19:54,250 --> 00:19:55,880
它有一个开放的括号，
接近括号，分号。

456
00:19:55,880 --> 00:19:58,095
看起来像一个C函数，
看起来像一个PHP函数。

457
00:19:58,095 --> 00:20:00,370
>> 事实上，这将
是一个JavaScript函数。

458
00:20:00,370 --> 00:20:01,440
然后我返回false。

459
00:20:01,440 --> 00:20:03,440
我们会回来
在短短的时刻。

460
00:20:03,440 --> 00:20:05,320
但如果是这个函数定义？

461
00:20:05,320 --> 00:20:07,950
那么，让我向上滚动
到该文件的顶部。

462
00:20:07,950 --> 00:20:11,710
而且，即使它是一个漫长的线路，
它是相对简单的。

463
00:20:11,710 --> 00:20:15,000
让我缩小这里
围绕这四条线。

464
00:20:15,000 --> 00:20:17,137
>> 因此，在JavaScript中，只
PHP之类的，你只要

465
00:20:17,137 --> 00:20:19,720
比方说，从字面上看，这个词“功能，”
的函数的名称，

466
00:20:19,720 --> 00:20:22,700
然后用任何括号
arguments--没有参数在这种情况下。

467
00:20:22,700 --> 00:20:25,290
而且也没有返回类型
在JavaScript中，就像PHP。

468
00:20:25,290 --> 00:20:29,470
因此，这不是C.宽松一点
打开大括号，靠近大括号。

469
00:20:29,470 --> 00:20:33,270
内置到JavaScript是一种function--
不推荐function--

470
00:20:33,270 --> 00:20:35,730
但一个函数调用警报
在生活中，其唯一目的

471
00:20:35,730 --> 00:20:38,620
就是拉了那个漂亮的丑陋
提示我们看到刚才。

472
00:20:38,620 --> 00:20:40,950
>> 现在，这是怎样的一个拗口的。

473
00:20:40,950 --> 00:20:42,560
发生了什么？

474
00:20:42,560 --> 00:20:45,840
因此，让我们开始
这里强调的一切。

475
00:20:45,840 --> 00:20:48,540
这是同样的理由来提醒。

476
00:20:48,540 --> 00:20:49,530
而这是怎么回事？

477
00:20:49,530 --> 00:20:51,200
这看起来就像一个字符串。

478
00:20:51,200 --> 00:20:59,180
而事实证明，不象PHP和不同
C，它不会在JavaScript无所谓

479
00:20:59,180 --> 00:21:01,090
如果单引号或双引号。

480
00:21:01,090 --> 00:21:02,060
他们会是相同的。

481
00:21:02,060 --> 00:21:03,769
坦率地说，这只是
受追捧

482
00:21:03,769 --> 00:21:06,726
对于JavaScript程序员总是
使用单引号的某些原因。

483
00:21:06,726 --> 00:21:07,840
这只是我们该做的。

484
00:21:07,840 --> 00:21:09,710
但是，我们可以使用双引号，也是如此。

485
00:21:09,710 --> 00:21:11,540
>> 因此，加上是一个新的角色。

486
00:21:11,540 --> 00:21:14,512
但是，那些你们谁做了
这之前，是什么加什么意思？

487
00:21:14,512 --> 00:21:16,440
是啊。

488
00:21:16,440 --> 00:21:17,120
串联。

489
00:21:17,120 --> 00:21:18,570
因此，我们在PHP中看到这一点。

490
00:21:18,570 --> 00:21:20,315
这里还有点
运营商在PHP中

491
00:21:20,315 --> 00:21:22,000
将连接两个字符串在一起。

492
00:21:22,000 --> 00:21:24,000
C组在颈部疼痛做到这一点。

493
00:21:24,000 --> 00:21:27,310
从PSET六，这是召回
在颈部一种特殊的疼痛，

494
00:21:27,310 --> 00:21:29,470
你将不得不使用
类似的strcat

495
00:21:29,470 --> 00:21:31,660
分配内存后
在堆栈或堆。

496
00:21:31,660 --> 00:21:34,243
你必须赴汤蹈火
只是连接两个字符串。

497
00:21:34,243 --> 00:21:36,040
在JavaScript中，这是超级简单。

498
00:21:36,040 --> 00:21:38,030
只需使用它们之间的加法运算。

499
00:21:38,030 --> 00:21:41,420
>> 这样复杂的外观的
事情似乎是这样的

500
00:21:41,420 --> 00:21:43,490
因为在结束时
这整个字符串，我只是

501
00:21:43,490 --> 00:21:45,797
串联上一个惊叹号。

502
00:21:45,797 --> 00:21:48,380
因此，如果发生了什么雨后春笋般冒出来了
“你好，戴维。”“你好，汉娜，”

503
00:21:48,380 --> 00:21:52,740
“你好，玛丽亚，”等字样，很明显
在这两个之间的中间事

504
00:21:52,740 --> 00:21:55,215
加号必须给我提供什么教育？

505
00:21:55,215 --> 00:21:58,855

506
00:21:58,855 --> 00:22:01,991
是什么在那里吗？

507
00:22:01,991 --> 00:22:02,490
是啊。

508
00:22:02,490 --> 00:22:05,090
所以我就假装在这里
回答他们的名字吧？

509
00:22:05,090 --> 00:22:10,380
因此，他们的名字突然出现在最后
结果。所以，这是什么意思？

510
00:22:10,380 --> 00:22:15,080
好吧，我在前面的提议
图像的所谓的DOM

511
00:22:15,080 --> 00:22:18,580
有这种特殊的根元素
一路前称为文档。

512
00:22:18,580 --> 00:22:21,660
而现在，事实证明，这是怎么回事
是一个特殊的全局变量

513
00:22:21,660 --> 00:22:25,250
在JavaScript，内置到这是一个
一大堆有用的功能。

514
00:22:25,250 --> 00:22:31,770
其中有用的功能是
能力得到任何后代节点。

515
00:22:31,770 --> 00:22:37,760
这些正方形或长方形或椭圆形
只是在树中的节点，可以这么说。

516
00:22:37,760 --> 00:22:41,850
>> 所以，事实证明，内置
JavaScript的文档对象

517
00:22:41,850 --> 00:22:47,300
是一个功能，或者被称为
方法，这就是所谓的getElementById。

518
00:22:47,300 --> 00:22:50,410
的语法主叫
在JavaScript函数

519
00:22:50,410 --> 00:22:55,220
这是一个对象或一个的内部
变量只是用点符号。

520
00:22:55,220 --> 00:22:57,950
我们看到在C
什么结构的语法。

521
00:22:57,950 --> 00:23:03,530
你看样这PSET七，
排序，当你看到CS50 ::查询。

522
00:23:03,530 --> 00:23:08,070
PHP中的结肠结肠是另一种
调用函数的方式

523
00:23:08,070 --> 00:23:09,260
里面的一些对象。

524
00:23:09,260 --> 00:23:11,960
>> 但现在在JavaScript中，
它只是一个点。

525
00:23:11,960 --> 00:23:14,170
因此该功能，
很好地够种，

526
00:23:14,170 --> 00:23:16,810
说什么does--得到元素通过ID。

527
00:23:16,810 --> 00:23:20,280
一个元素是另一个名字
对于在DOM标签或节点。

528
00:23:20,280 --> 00:23:26,900
因此得到元素通过ID“名”
意味着this--这里是我的HTML。

529
00:23:26,900 --> 00:23:31,910
在此基础上的HTML，什么
节点或者是HTML标记是我

530
00:23:31,910 --> 00:23:35,097
要以编程方式交由
通过调用的document.getElementById？

531
00:23:35,097 --> 00:23:37,650

532
00:23:37,650 --> 00:23:38,500
>> 是的，没错。

533
00:23:38,500 --> 00:23:42,670
我要获得输入
元有ID为“名”。

534
00:23:42,670 --> 00:23:45,140
那么具体而言，可以
觉得这个功能，

535
00:23:45,140 --> 00:23:49,560
的getElementById，作为给人一种方式
回一个指向特定节点

536
00:23:49,560 --> 00:23:50,060
在树中。

537
00:23:50,060 --> 00:23:51,980
我们还没有绘制这
树，但它是一个办法

538
00:23:51,980 --> 00:23:54,900
对获得访问该
矩形或矩形

539
00:23:54,900 --> 00:23:58,090
经由其ID唯一标识它。

540
00:23:58,090 --> 00:23:59,760
>> 现在，这是为什么有用吗？

541
00:23:59,760 --> 00:24:01,510
那么，事实证明
一旦你已经得到

542
00:24:01,510 --> 00:24:07,220
该节点，表示从矩形
画面，在它的内部节点，

543
00:24:07,220 --> 00:24:10,660
反过来，有一大堆的
properties--键值对

544
00:24:10,660 --> 00:24:13,480
或数据，其中之一是所谓的值。

545
00:24:13,480 --> 00:24:16,500
因此，从字面上看，它是一种一
满口解释整件事。

546
00:24:16,500 --> 00:24:19,370
但在一天结束时，
这一切确实是给你

547
00:24:19,370 --> 00:24:23,070
用户键入字符串中的
在这种分层方式。

548
00:24:23,070 --> 00:24:24,820
但我不喜欢
这些夫妇的事情。

549
00:24:24,820 --> 00:24:27,590
或者说，有一些好奇依然。

550
00:24:27,590 --> 00:24:28,870
所有这一切似乎工作。

551
00:24:28,870 --> 00:24:33,420
为什么你会认为我回来
呼叫招呼后假的？

552
00:24:33,420 --> 00:24:35,910
这看起来有点丑，那
我有两个语句有

553
00:24:35,910 --> 00:24:38,730
用分号隔开。

554
00:24:38,730 --> 00:24:39,310
猜一下。

555
00:24:39,310 --> 00:24:44,390
如果我删除返回false，什么
可能发生的事情，只是本能？

556
00:24:44,390 --> 00:24:46,990

557
00:24:46,990 --> 00:24:49,460
对不起，再说一遍吗？

558
00:24:49,460 --> 00:24:50,530
>> 打开一堆的Windows。

559
00:24:50,530 --> 00:24:52,780
因此，潜在的或许真的
这样会发生。

560
00:24:52,780 --> 00:24:54,422
还有什么？

561
00:24:54,422 --> 00:24:55,630
可能提交申请在哪里？

562
00:24:55,630 --> 00:24:59,109

563
00:24:59,109 --> 00:25:00,510
要在同一个页面。

564
00:25:00,510 --> 00:25:03,110
因此，事实上，就是这样
越接近答案在这里，

565
00:25:03,110 --> 00:25:05,890
即使不像
在过去，我已经不

566
00:25:05,890 --> 00:25:09,300
指定action属性，
通常我们要做的。

567
00:25:09,300 --> 00:25:11,780
原来有一个默认的。
如果没有指定动作，

568
00:25:11,780 --> 00:25:15,370
这就像说报价，引文结束
或文件本身的名称，

569
00:25:15,370 --> 00:25:17,850
在这种情况下将
像DOM-0.html。

570
00:25:17,850 --> 00:25:20,420
那种只是它的推断，
或者说暗示的保证。

571
00:25:20,420 --> 00:25:22,420
>> 所以，如果我不这样做，让我们注意。

572
00:25:22,420 --> 00:25:23,230
让我保存这个。

573
00:25:23,230 --> 00:25:25,270
我已经删除返回FALSE。

574
00:25:25,270 --> 00:25:27,759
让我回到这
例如，迫使其重新装入。

575
00:25:27,759 --> 00:25:30,800
你可能已经看到了我建议
这在CS50讨论一堆倍。

576
00:25:30,800 --> 00:25:34,560
如果有什么是有史以来作用时髦和
浏览器的行为不作为您的​​期望，

577
00:25:34,560 --> 00:25:37,410
通常情况下，你会想举行
按住Shift键，然后单击刷新。

578
00:25:37,410 --> 00:25:41,480
这将迫使所有的文件重新加载
而不是使用浏览器的本地缓存

579
00:25:41,480 --> 00:25:47,032
或副本，现在，让我继续前进，
打开我的督察，网络选项卡。

580
00:25:47,032 --> 00:25:48,740
我要去点击
保留日志，因为我

581
00:25:48,740 --> 00:25:51,660
不希望它删除的行
一旦我撵走其他地方。

582
00:25:51,660 --> 00:25:54,650
>> 让我在这里继续前进，
岸堤类型，点击提交。

583
00:25:54,650 --> 00:25:55,150
好吧。

584
00:25:55,150 --> 00:25:56,480
这似乎符合市场预期。

585
00:25:56,480 --> 00:25:57,440
它说：“你好，安迪。”

586
00:25:57,440 --> 00:25:59,420
让我点击确定。

587
00:25:59,420 --> 00:26:00,610
有趣的。

588
00:26:00,610 --> 00:26:05,100
请注意，页面改变，
虽然原来的页面。

589
00:26:05,100 --> 00:26:06,770
请注意，网址样的改变。

590
00:26:06,770 --> 00:26:09,430
它增加了一个问号，
这通常是一个指标

591
00:26:09,430 --> 00:26:11,260
我们试图向东西。

592
00:26:11,260 --> 00:26:13,570
然后在底部，
更明确地，

593
00:26:13,570 --> 00:26:17,570
这里是实际的HTTP请求，
这得到了200响应该

594
00:26:17,570 --> 00:26:18,490
带我回到这里。

595
00:26:18,490 --> 00:26:20,250
>> 因此，这不是什么
我们想要做的，对不对？

596
00:26:20,250 --> 00:26:22,166
因为我不希望
重新加载整个页面。

597
00:26:22,166 --> 00:26:24,970
我不是想回去
假以短路

598
00:26:24,970 --> 00:26:28,840
浏览器的默认行为，其中
是，当然，提交该页面。

599
00:26:28,840 --> 00:26:31,700
>> 因此，让我们来看看一个
略好例子。

600
00:26:31,700 --> 00:26:33,920
这是DOM的版本之一。

601
00:26:33,920 --> 00:26:36,680
并注意以下几点。

602
00:26:36,680 --> 00:26:39,150
这是确定的，如果你不神交
所有的代码行。

603
00:26:39,150 --> 00:26:41,750
但是，什么是本质上的区别
这个执行？

604
00:26:41,750 --> 00:26:44,690
我将规定它的行为
同样的，做同样的事情。

605
00:26:44,690 --> 00:26:49,320

606
00:26:49,320 --> 00:26:51,570
有我明明做了什么不同？

607
00:26:51,570 --> 00:26:52,266
是吗？

608
00:26:52,266 --> 00:26:53,182
>> 听众：[听不清]。

609
00:26:53,182 --> 00:27:03,421

610
00:27:03,421 --> 00:27:04,170
DAVID马兰：是的。

611
00:27:04,170 --> 00:27:08,620
因此函数被定义differently--
换言之，从形式存在，

612
00:27:08,620 --> 00:27:13,180
那里就行7--或
相反，线8-不再

613
00:27:13,180 --> 00:27:15,070
我必须onsubmit属性。

614
00:27:15,070 --> 00:27:16,750
在前面的例子，我有这个。

615
00:27:16,750 --> 00:27:18,530
然后，我简直写到这里我的代码。

616
00:27:18,530 --> 00:27:20,210
然后我说，返回false。

617
00:27:20,210 --> 00:27:22,180
而如果它没有擦
你又走错了路，

618
00:27:22,180 --> 00:27:26,140
它应该开始，只要
因为，就像在HTML中，

619
00:27:26,140 --> 00:27:29,530
当我们开始共同混合它
使用CSS的样式属性，

620
00:27:29,530 --> 00:27:32,890
它刚开始得到一点
凌乱还是觉得有点不对劲。

621
00:27:32,890 --> 00:27:35,020
>> 同样在这里，如果
你开始服用HTML，

622
00:27:35,020 --> 00:27:37,419
然后自动
扑通一些JavaScript代码

623
00:27:37,419 --> 00:27:40,460
在一个带引号的字符串的中间，它的
不会是非常维护。

624
00:27:40,460 --> 00:27:40,630
对？

625
00:27:40,630 --> 00:27:43,690
它也不是很明显，在第一
地方，JavaScript代码。

626
00:27:43,690 --> 00:27:46,590
因此，这将是非常好的为
更好的设计宗旨，

627
00:27:46,590 --> 00:27:50,500
让我们彻底让我们的HTML
从我们的JavaScript分开。

628
00:27:50,500 --> 00:27:53,150
>> 因此，要做到这一点，我们已经
在这里做的是following--

629
00:27:53,150 --> 00:27:56,790
我们简单地用HTML只标记。

630
00:27:56,790 --> 00:28:00,730
所以，在这个版本的一台，所有
我是一个唯一的ID的形式。

631
00:28:00,730 --> 00:28:04,630
然后到这里，我趁着
对JavaScript的一个特殊功能

632
00:28:04,630 --> 00:28:08,480
因此我能有什么
所谓的匿名函数。

633
00:28:08,480 --> 00:28:14,150
所以，事实证明，如果我叫
“演示”中的document.getElementById

634
00:28:14,150 --> 00:28:18,890
这等于是给了我一个指针
在我的系统中，这一节点，表单元素，

635
00:28:18,890 --> 00:28:20,100
可以这么说。

636
00:28:20,100 --> 00:28:22,220
>> 现在，我只知道，从
知道一点的HTML

637
00:28:22,220 --> 00:28:26,330
现在我们已经看了一些网上
引用，一个表格单元支持

638
00:28:26,330 --> 00:28:29,950
在一大堆事件listeners--的
换句话说，事件的洗衣清单

639
00:28:29,950 --> 00:28:31,700
听众，我们看到刚才。

640
00:28:31,700 --> 00:28:35,950
我从书上知道文档
即onsubmit的是一个有效的事件

641
00:28:35,950 --> 00:28:38,520
侦听器表单元素。

642
00:28:38,520 --> 00:28:41,480
>> 所以一旦我知道，
它是安全的，我做

643
00:28:41,480 --> 00:28:45,390
该following--得到那个节点
从树中，表单元素，

644
00:28:45,390 --> 00:28:48,070
并访问其所谓的
onsubmit的财产。

645
00:28:48,070 --> 00:28:49,880
所以点只是意味着
这是一个属性，

646
00:28:49,880 --> 00:28:52,180
喜欢它里面的特殊值。

647
00:28:52,180 --> 00:28:55,590
什么类型的数据我是
分配，显然，

648
00:28:55,590 --> 00:28:58,900
到的onSubmit，这是
实际上是一个变量中

649
00:28:58,900 --> 00:29:01,010
树中该节点的？

650
00:29:01,010 --> 00:29:04,100
这是该结构的内场。

651
00:29:04,100 --> 00:29:05,810
什么是数据类型？

652
00:29:05,810 --> 00:29:07,030
>> 一个功能，是的。

653
00:29:07,030 --> 00:29:08,607
所以，事实证明，PHP有这一点。

654
00:29:08,607 --> 00:29:10,440
而且即使我们
没有告诉你这件事，

655
00:29:10,440 --> 00:29:16,240
C也有函数指针，该
传递和分配功能的能力

656
00:29:16,240 --> 00:29:18,330
作为变量的值本身。

657
00:29:18,330 --> 00:29:20,280
而且我们不打算
倒退回C.

658
00:29:20,280 --> 00:29:23,250
但现在，事实证明，
上的右侧这里，

659
00:29:23,250 --> 00:29:26,260
即使它看起来有点
时髦的，这意味着，哎浏览器，

660
00:29:26,260 --> 00:29:27,550
给我一个功能。

661
00:29:27,550 --> 00:29:30,560
我不会甚至不屑给予
它的名字，因为我从字面上

662
00:29:30,560 --> 00:29:34,450
要指定让我们叫它
此函数的地址

663
00:29:34,450 --> 00:29:35,994
立即onsubmit的。

664
00:29:35,994 --> 00:29:39,160
换句话说，浏览器，你不需要
知道这个函数的调用。

665
00:29:39,160 --> 00:29:41,890
你只需要知道
它是在存储器中。

666
00:29:41,890 --> 00:29:44,210
因此，这足以只是
有一个等号有

667
00:29:44,210 --> 00:29:48,240
并没有打扰这一命名，如
FOO或打招呼，或任何其他文字。

668
00:29:48,240 --> 00:29:50,150
而现在这只是一个风格的东西。

669
00:29:50,150 --> 00:29:53,100
我可以移动这个大括号
到the-- sorry--下一行

670
00:29:53,100 --> 00:29:54,750
像我们平时做CS50。

671
00:29:54,750 --> 00:29:57,550
但在JavaScript中，它的
实际上文体常见

672
00:29:57,550 --> 00:30:00,450
只保留了大括号中，
第一个，在该第一行。

673
00:30:00,450 --> 00:30:02,620
>> 但此后，有
没什么有趣的。

674
00:30:02,620 --> 00:30:05,830
打开大括号只
标定我的函数的开始。

675
00:30:05,830 --> 00:30:09,320
该功能是现在
相同的，只是我已经

676
00:30:09,320 --> 00:30:11,452
包括返回假
这里面的功能。

677
00:30:11,452 --> 00:30:13,160
因为事实证明out--
你不仅会

678
00:30:13,160 --> 00:30:14,980
从阅读知道这
该documentation--

679
00:30:14,980 --> 00:30:19,740
如果函数您分配了
到onsubmit处理程序返回false，

680
00:30:19,740 --> 00:30:23,420
浏览器才知道并同意
不要表单提交到服务器。

681
00:30:23,420 --> 00:30:27,210
如果返回true，将提交
它以一台服务器的原因，我们会看到

682
00:30:27,210 --> 00:30:28,700
在短短的时刻非常有用。

683
00:30:28,700 --> 00:30:31,000
>> 再经过分号
大括号那里只是

684
00:30:31,000 --> 00:30:32,541
意味着我做的定义功能。

685
00:30:32,541 --> 00:30:36,600
你知道要尽快叫什么
当你听到提交。

686
00:30:36,600 --> 00:30:37,100
好吧。

687
00:30:37,100 --> 00:30:40,650
这是可以说是一种丑陋的还是。

688
00:30:40,650 --> 00:30:42,190
那么，我们还能做什么？

689
00:30:42,190 --> 00:30:45,000
>> 嗯，事实证明，然后在
2版，这是last--

690
00:30:45,000 --> 00:30:46,780
而我们只需看一眼这一点。

691
00:30:46,780 --> 00:30:49,850
在制作的风险
它难看，原来

692
00:30:49,850 --> 00:30:52,160
，有一个库
世界所谓的jQuery。

693
00:30:52,160 --> 00:30:54,900
和jQuery是一个超级
流行的JavaScript库

694
00:30:54,900 --> 00:30:57,930
这是非常受欢迎，最
任何JavaScript--这不是

695
00:30:57,930 --> 00:31:00,540
不凡的人混淆
jQuery的使用JavaScript。

696
00:31:00,540 --> 00:31:01,070
为什么呢？

697
00:31:01,070 --> 00:31:04,990
JavaScript的本身就具有很
做things--的详细方法

698
00:31:04,990 --> 00:31:07,820
的document.getElementById，dadadadadada。

699
00:31:07,820 --> 00:31:10,510
你最终不得不非常
长行的代码。

700
00:31:10,510 --> 00:31:15,550
>> 因此，一个名叫约翰·渣油老乡，
究竟是谁的作品为一个启动

701
00:31:15,550 --> 00:31:18,630
这几天，走了出来
与此库年

702
00:31:18,630 --> 00:31:22,070
以前，很多人都做出了贡献
名为jQuery的改变

703
00:31:22,070 --> 00:31:23,449
语法以下列方式。

704
00:31:23,449 --> 00:31:25,740
而且只要你已经看到了这个，
因为你总是

705
00:31:25,740 --> 00:31:28,140
看到这，如果做一个
基于网络的最终项目，

706
00:31:28,140 --> 00:31:33,270
这将相当于方式
实现使用同一功能

707
00:31:33,270 --> 00:31:34,630
这个特殊的图书馆。

708
00:31:34,630 --> 00:31:36,680
>> 现在，而不是挑逗
它除了在其全部，

709
00:31:36,680 --> 00:31:38,520
就让我们来看看一些模式。

710
00:31:38,520 --> 00:31:44,850
这个语法似乎有
多少匿名函数

711
00:31:44,850 --> 00:31:49,584
或匿名函数
或者AKA lambda函数？

712
00:31:49,584 --> 00:31:50,190
二，对不对？

713
00:31:50,190 --> 00:31:52,690
而你知道，即使
你不是超级舒适这一点，

714
00:31:52,690 --> 00:31:55,780
刚刚通过的事实，它
说函数（）的两倍。

715
00:31:55,780 --> 00:31:58,172
>> 而事实证明，
这段代码是doing--

716
00:31:58,172 --> 00:32:01,255
我们会参考网上的参考，
最终，一些帮助与此有关。

717
00:32:01,255 --> 00:32:04,480
这也就意味着，当
该文件已经准备好，

718
00:32:04,480 --> 00:32:07,490
继续并注册
下面的函数

719
00:32:07,490 --> 00:32:12,064
作为提交处理程序的HTML
元素，其独特的想法是演示。

720
00:32:12,064 --> 00:32:14,480
然后，当发生这种情况，
调用这两个行代码。

721
00:32:14,480 --> 00:32:18,677
这是可悲的，更
说法返回false冗长的方式。

722
00:32:18,677 --> 00:32:21,510
我们提到这一点，只是因为
你会看到这个代码在线等。

723
00:32:21,510 --> 00:32:23,140
而且它是没什么被吓倒。

724
00:32:23,140 --> 00:32:26,057
反倒是，请记住，什么是
要在JavaScript中很常见

725
00:32:26,057 --> 00:32:26,765
就是这种模式。

726
00:32:26,765 --> 00:32:29,510
所以这就是为什么我们展示它现在。

727
00:32:29,510 --> 00:32:30,010
好吧。

728
00:32:30,010 --> 00:32:32,730
因此，没有居住过
很多在该语法，

729
00:32:32,730 --> 00:32:37,800
是有任何疑问
这些实例或想法迄今为止？

730
00:32:37,800 --> 00:32:38,300
好吧。

731
00:32:38,300 --> 00:32:40,220
因此，让我们用这个东西是有用的。

732
00:32:40,220 --> 00:32:47,070
制作一个网页，只是说你好，
某某是不是所有的有趣，

733
00:32:47,070 --> 00:32:47,830
不underwhelm。

734
00:32:47,830 --> 00:32:51,038
这一个不会是美丽的，
但它会做一些有用的东西。

735
00:32:51,038 --> 00:32:56,350
让我回到我的目录
在这里，开拓，说，外形0.html。

736
00:32:56,350 --> 00:32:59,320
>> 因此，假设这是新生
校内体育活动注册页面

737
00:32:59,320 --> 00:33:01,780
没有任何的CSS或设计的任何意义。

738
00:33:01,780 --> 00:33:05,404
而且我要继续前进，
这里使用密码注册。

739
00:33:05,404 --> 00:33:08,320
而且我会同意的条款
和条件，然后单击注册。

740
00:33:08,320 --> 00:33:11,700
而现在的网站上说，“你是
注册！ （嗯，不是真的。）“

741
00:33:11,700 --> 00:33:15,070
这似乎是它的工作，但
让我继续前进，迫使重装。

742
00:33:15,070 --> 00:33:18,720
>> 让我说，不，你不这样做
需要我的实际电子邮件地址。

743
00:33:18,720 --> 00:33:21,820
或者，也许我们只能说，邮件在那里。

744
00:33:21,820 --> 00:33:25,080
密码会一样，12345。

745
00:33:25,080 --> 00:33:28,810
然后，只是因为我
白痴，现在是123456789。

746
00:33:28,810 --> 00:33:31,150
我不是要检查你的盒子。

747
00:33:31,150 --> 00:33:31,850
>> 嗯。

748
00:33:31,850 --> 00:33:32,350
好吧。

749
00:33:32,350 --> 00:33:34,920
因此，有几次机会
为改善这里。

750
00:33:34,920 --> 00:33:39,070
你知道，还是会在PSET看到
七，您可以编写代码 - 

751
00:33:39,070 --> 00:33:41,890
你就会有写
在PHP--代码保卫

752
00:33:41,890 --> 00:33:45,780
针对这些种的用户
错误，因为明确的用户

753
00:33:45,780 --> 00:33:46,790
没有合作。

754
00:33:46,790 --> 00:33:49,680
他或她还没有给你一切
重视你想要的，甚至在格式

755
00:33:49,680 --> 00:33:50,630
你希望他们。

756
00:33:50,630 --> 00:33:53,250
所以，你会在PSET 7看出，
我们当然可以有一些

757
00:33:53,250 --> 00:33:55,680
如果说条件
如果电子邮件地址

758
00:33:55,680 --> 00:33:59,450
不是username@something.edu，
我们可以只

759
00:33:59,450 --> 00:34:02,575
说对不起，并表示歉意用户
多，就像你可能在PSET七人。

760
00:34:02,575 --> 00:34:05,700
或者，如果他们没有检查那个盒子，
原来在PHP中，则可以检测到，

761
00:34:05,700 --> 00:34:06,200
太。

762
00:34:06,200 --> 00:34:09,389
当然，如果密码
不匹配在register.php

763
00:34:09,389 --> 00:34:11,521
为PSET七，则可以检测到。

764
00:34:11,521 --> 00:34:13,770
但是，这是在一个痛苦
脖子上，现在他们要求

765
00:34:13,770 --> 00:34:15,510
我们对所有的方式转到服务器。

766
00:34:15,510 --> 00:34:17,053
用户被告知错误。

767
00:34:17,053 --> 00:34:19,219
至少，除非你使用
有些美妙的技术，

768
00:34:19,219 --> 00:34:20,929
现在他们必须单击后退箭头。

769
00:34:20,929 --> 00:34:23,300
那岂不是很好，像
很多网站今天，

770
00:34:23,300 --> 00:34:26,190
如果你有更直接的
反馈意见，瞬间？

771
00:34:26,190 --> 00:34:31,389
>> 换句话说，让我去版本
一个，这将是不漂亮。

772
00:34:31,389 --> 00:34:33,469
但它确实有这个功能。

773
00:34:33,469 --> 00:34:39,590
马兰，12345，123456789，不
要选中该复选框，注册。

774
00:34:39,590 --> 00:34:41,330
密码不匹配。

775
00:34:41,330 --> 00:34:44,459
因此，即使这个弹出窗口是ugly--
我们可以最终取代本

776
00:34:44,459 --> 00:34:47,000
喜欢的东西引导，
你会在PSET 7见

777
00:34:47,000 --> 00:34:50,239
是一个非常受欢迎的library--我做
检测到口令不匹配。

778
00:34:50,239 --> 00:34:50,739
好吧。

779
00:34:50,739 --> 00:34:52,530
好吧，让我来解决，作为用户。

780
00:34:52,530 --> 00:34:55,460
让我继续前进，说12345，12345。

781
00:34:55,460 --> 00:34:57,780
仍然没有检查的协议。

782
00:34:57,780 --> 00:35:00,210
您必须同意
条款和条件。

783
00:35:00,210 --> 00:35:01,760
所以为什么？

784
00:35:01,760 --> 00:35:04,100
>> 如果我们已经假定
还有一种方法，

785
00:35:04,100 --> 00:35:07,260
而我们需要你
PSET七，检测错误

786
00:35:07,260 --> 00:35:09,780
这样的条件
服务器端的，为什么要我

787
00:35:09,780 --> 00:35:13,940
麻烦也这样做在JavaScript？

788
00:35:13,940 --> 00:35:15,850
是什么在争论
赞成加入什么

789
00:35:15,850 --> 00:35:18,760
你即将看到的some--
有额外的复杂性。

790
00:35:18,760 --> 00:35:23,610

791
00:35:23,610 --> 00:35:25,930
>> 也许没有上涨空间。

792
00:35:25,930 --> 00:35:26,924
可能是什么？

793
00:35:26,924 --> 00:35:27,840
听众：[听不清]。

794
00:35:27,840 --> 00:35:31,132

795
00:35:31,132 --> 00:35:32,340
DAVID马兰：呵呵，有意思。

796
00:35:32,340 --> 00:35:33,530
潜在的漏洞。

797
00:35:33,530 --> 00:35:37,540
所以肯定的是，如果你不处理
错误的用户输入，伟大的，

798
00:35:37,540 --> 00:35:40,170
也许是，如果这一切的美好
甚至没有达到您的服务器。

799
00:35:40,170 --> 00:35:42,160
我推回那里，
比方说，你应该

800
00:35:42,160 --> 00:35:43,284
解决这两个的这些问题。

801
00:35:43,284 --> 00:35:44,140
但是，这是公平的。

802
00:35:44,140 --> 00:35:44,710
还有什么？

803
00:35:44,710 --> 00:35:45,626
>> 听众：[听不清]。

804
00:35:45,626 --> 00:35:47,970

805
00:35:47,970 --> 00:35:49,014
>> DAVID马兰：是的。

806
00:35:49,014 --> 00:35:51,680
这段代码，正如我们之前所说，是
解释在客户端。

807
00:35:51,680 --> 00:35:53,846
它不打扰服务器，
这意味着它不

808
00:35:53,846 --> 00:35:55,930
影响服务器的负荷或容量。

809
00:35:55,930 --> 00:35:59,840
而现在，对于有点老了我，
这没有任何意义的影响

810
00:35:59,840 --> 00:36:01,970
因为我有一个用户现在。

811
00:36:01,970 --> 00:36:04,010
>> 但是，如果你的任何
体面的大小网站，

812
00:36:04,010 --> 00:36:07,400
尤其是最大的，像Fac​​ebook，
更可以留人关闭

813
00:36:07,400 --> 00:36:09,927
你的服务器的更好
当然，因为一台服务器，

814
00:36:09,927 --> 00:36:12,510
只有拥有的RAM量有限，
有限数目吉赫的，

815
00:36:12,510 --> 00:36:16,340
事物有限数目
它可以每单位做的时间。

816
00:36:16,340 --> 00:36:19,170
因此，如果有更多的人在
世界打你的服务器，

817
00:36:19,170 --> 00:36:21,750
意外记录
如果您错误，一样好

818
00:36:21,750 --> 00:36:23,254
能保持这种负载关闭服务器。

819
00:36:23,254 --> 00:36:25,420
加，尤其是在一个移动
如果你曾经device--

820
00:36:25,420 --> 00:36:29,190
登录my.harvard或
耶鲁大学的网络标识符号或类似的，

821
00:36:29,190 --> 00:36:32,330
有这有很多的等待时间
网站一样，因此它需要，

822
00:36:32,330 --> 00:36:34,110
就像，一个该死的两秒钟的时候。

823
00:36:34,110 --> 00:36:37,979
然后，我的上帝，如果你输错，
那么你就要打回去重做。

824
00:36:37,979 --> 00:36:40,520
因此，有延迟，特别是
在速度较慢的网络连接。

825
00:36:40,520 --> 00:36:43,030
但JavaScript的，因为
它运行在客户机上

826
00:36:43,030 --> 00:36:46,720
而并不需要来回走
跨越一个潜在的慢速互联网

827
00:36:46,720 --> 00:36:49,780
连接，就可以得到
几乎在瞬间反馈。

828
00:36:49,780 --> 00:36:50,760
>> 所以，让我们来看看这个。

829
00:36:50,760 --> 00:36:54,280
让我打开了形式-0和
看看这里的HTML。

830
00:36:54,280 --> 00:36:56,040
而且，我们只看到发生了什么事情。

831
00:36:56,040 --> 00:36:59,460
这是他们的一种形式
行动register.php。

832
00:36:59,460 --> 00:37:01,530
我只是用得到这么
我能看到的网址。

833
00:37:01,530 --> 00:37:05,030
但是，对于密码，我们就一定要
要改变这种张贴在现实中。

834
00:37:05,030 --> 00:37:06,910
以下是类型的文本输入字段。

835
00:37:06,910 --> 00:37:09,050
这里的另一个输入
字段类型的密码。

836
00:37:09,050 --> 00:37:13,150
在这里，如果你从来没有见过，
型复选框的输入端。

837
00:37:13,150 --> 00:37:15,250
>> 但有没有JavaScript的
在这里任何责任。

838
00:37:15,250 --> 00:37:18,170
这仅仅是HTML的
去register.php。

839
00:37:18,170 --> 00:37:21,020
但是，在一个版本，其中，我
开始让那些弹出窗口，

840
00:37:21,020 --> 00:37:23,010
让我们看看究竟会发生在这里。

841
00:37:23,010 --> 00:37:26,757
在一个版本中，什么
我要see--我

842
00:37:26,757 --> 00:37:29,340
以为我可以拖延足够
有足够的话，但我跑了出去。

843
00:37:29,340 --> 00:37:35,180

844
00:37:35,180 --> 00:37:38,590
>> 在版本埃德蒙顿我们走吧。

845
00:37:38,590 --> 00:37:43,180
在一个版本中，注意到following--
而不是最好的实施中，

846
00:37:43,180 --> 00:37:44,420
但是这是我的第一次。

847
00:37:44,420 --> 00:37:47,680
请注意，以下
形式，我有一个脚本标记。

848
00:37:47,680 --> 00:37:49,430
而script标签意味着，
哎，浏览器，点击这里

849
00:37:49,430 --> 00:37:52,340
进来一些代码，
通常情况下，JavaScript的。

850
00:37:52,340 --> 00:37:54,420
现在，请注意我在做什么。

851
00:37:54,420 --> 00:37:59,070
在line--我可以勉强
读它 - 第32行，它说，

852
00:37:59,070 --> 00:38:01,420
VAR form--所以给我
一个名为表单变量。

853
00:38:01,420 --> 00:38:05,049
然后得到document.getElementId
“注册”的

854
00:38:05,049 --> 00:38:05,590
这是什么？

855
00:38:05,590 --> 00:38:07,290
好了，让我退了这里。

856
00:38:07,290 --> 00:38:11,510
并注意啊，我给表单元素
一个任意的描述性的想法

857
00:38:11,510 --> 00:38:13,050
登记。

858
00:38:13,050 --> 00:38:16,820
因此，这给了我一个变量
让我抢这​​个节点，

859
00:38:16,820 --> 00:38:19,580
在树的矩形称为形式。

860
00:38:19,580 --> 00:38:24,460
form.onsubmit手段，嘿嘿浏览器，
注册事件侦听器

861
00:38:24,460 --> 00:38:25,470
在这种形式。

862
00:38:25,470 --> 00:38:28,890
换言之，当这种形式是
提交后，执行下面的代码。

863
00:38:28,890 --> 00:38:30,810
它并不需要，因为一个名
为什么你需要知道叫什么名字？

864
00:38:30,810 --> 00:38:32,880
你只需要知道
要执行的，ERGO

865
00:38:32,880 --> 00:38:35,610
它是一个匿名或lambda功能。

866
00:38:35,610 --> 00:38:37,632
并且函数
在这里所有这些行。

867
00:38:37,632 --> 00:38:40,840
而现在，说实话，即使你
也许没有写过的JavaScript

868
00:38:40,840 --> 00:38:44,200
之前，它只是C和PHP逻辑。

869
00:38:44,200 --> 00:38:51,720
因此，如果form.email.value ==“” - 
因此，如果电子邮件字段为空，

870
00:38:51,720 --> 00:38:54,980
骂为“你必须将用户
提供您的电子邮件地址。“

871
00:38:54,980 --> 00:38:58,980
否则，如果form.password.value
是在用户的空白吆喝，

872
00:38:58,980 --> 00:39:00,400
“你必须提供您的密码。”

873
00:39:00,400 --> 00:39:04,240
>> 更有趣的是逻辑，
如果form.password.value不

874
00:39:04,240 --> 00:39:08,630
等于form.confirmation.value--
并确认哪儿来的？

875
00:39:08,630 --> 00:39:09,470
让我快退。

876
00:39:09,470 --> 00:39:12,870
好吧，我叫这个输入
场在这里密码。

877
00:39:12,870 --> 00:39:15,180
我这里所说的这一个确认。

878
00:39:15,180 --> 00:39:17,850
我可以把它叫做
密码两个或其他任何东西。

879
00:39:17,850 --> 00:39:20,560
我只是逻辑检查
这两个是相同的。

880
00:39:20,560 --> 00:39:25,760
Else--事实证明这是布尔先生
again--一个布尔值，该复选框。

881
00:39:25,760 --> 00:39:29,810
所以，如果我说了，惊呼一声point--
如果不是form.agreement.checked，

882
00:39:29,810 --> 00:39:31,820
骂的用户也是如此。

883
00:39:31,820 --> 00:39:34,470
>> 所以这个语法，你会看到的是
在JavaScript中很常见，

884
00:39:34,470 --> 00:39:35,970
在这里，你有这样的点号。

885
00:39:35,970 --> 00:39:37,460
开始时你有一个对象在这里。

886
00:39:37,460 --> 00:39:41,430
您下潜较深到到
如密码属性。

887
00:39:41,430 --> 00:39:43,280
然后你在它的实际价值得到。

888
00:39:43,280 --> 00:39:45,830
再次，这里是输入。

889
00:39:45,830 --> 00:39:47,310
这里是名密码。

890
00:39:47,310 --> 00:39:50,860
而它的价值是什么的
人类实际上已经输入的研究。

891
00:39:50,860 --> 00:39:53,610
>> 因此，在所有的这些
的情况下，我返回false。

892
00:39:53,610 --> 00:39:55,800
但如果没有，我返回true。

893
00:39:55,800 --> 00:39:58,030
所以，现在我们看到了
引人注目的使用时，

894
00:39:58,030 --> 00:40:00,620
您将返回false来
停止哪些用户做

895
00:40:00,620 --> 00:40:03,200
并让他或她的选择
一次或再次输入。

896
00:40:03,200 --> 00:40:05,870
否则，我们返回true。

897
00:40:05,870 --> 00:40:08,585
>> 让我介绍一款
这等变异只

898
00:40:08,585 --> 00:40:13,140
其种子有一定的了解。

899
00:40:13,140 --> 00:40:16,850
那么，在这2版本，外形2--
我会用一挥手做到这一点。

900
00:40:16,850 --> 00:40:19,920
这一点，对于那些好奇，
jQuery的版本，

901
00:40:19,920 --> 00:40:23,330
你们谁可能要
涉足该特定库。

902
00:40:23,330 --> 00:40:25,145
但是让我们start--和什么问题吗？

903
00:40:25,145 --> 00:40:29,230
让我停顿了片刻，因为
这是快了许多。

904
00:40:29,230 --> 00:40:32,610
>> 但这里的好处是，所有的
代码几乎是相同的。

905
00:40:32,610 --> 00:40:33,985
新的东西是DOM是什么？

906
00:40:33,985 --> 00:40:35,115
什么是这些矩形？

907
00:40:35,115 --> 00:40:35,990
这些是什么节点？

908
00:40:35,990 --> 00:40:37,540
什么是匿名函数？

909
00:40:37,540 --> 00:40:38,830
什么是事件处理程序？

910
00:40:38,830 --> 00:40:43,480
但值得庆幸的是，大多数这只是
兜了一圈，比如说，从零一周。

911
00:40:43,480 --> 00:40:43,980
好吧。

912
00:40:43,980 --> 00:40:46,070
因此，一些稍微更有趣吗？

913
00:40:46,070 --> 00:40:49,340
好吧，首先，让我去
进取，不断开拓谷歌地图。

914
00:40:49,340 --> 00:40:53,360
而且你会发现，一
那一刻，在一瞬间，

915
00:40:53,360 --> 00:40:55,930
注意会发生什么时
我点击速度不够快。

916
00:40:55,930 --> 00:40:59,720
而在哈佛这方面是如此
快，你真的不注意到它。

917
00:40:59,720 --> 00:41:04,469
但是，你有什么样的一种见
如果我点击并拖动真快？

918
00:41:04,469 --> 00:41:07,010
这些你在网上看的，
如果你慢这0.5倍的速度，

919
00:41:07,010 --> 00:41:09,640
你可以看到这更好。

920
00:41:09,640 --> 00:41:13,550
>> 发生了什么事刚
之前，我点击和拖动？

921
00:41:13,550 --> 00:41:15,900
让我来这里 - 让我做
别的东西，比如90210。

922
00:41:15,900 --> 00:41:17,550
让我们远去。

923
00:41:17,550 --> 00:41:19,000
这是真快，太。

924
00:41:19,000 --> 00:41:22,460
如何迪斯尼世界？

925
00:41:22,460 --> 00:41:23,190
在那里，我们走了。

926
00:41:23,190 --> 00:41:23,690
好。

927
00:41:23,690 --> 00:41:26,030
你看见什么了一秒钟？

928
00:41:26,030 --> 00:41:27,200
只是，像，广场，对不对？

929
00:41:27,200 --> 00:41:28,930
占位符瓷砖？

930
00:41:28,930 --> 00:41:30,270
>> 那么，这是怎么回事吗？

931
00:41:30,270 --> 00:41:35,410
谷歌地图是一个很好的例子
这就是所谓AJAX这种技术。

932
00:41:35,410 --> 00:41:38,510
而这正是我们将开始
使用JavaScript的一个特别

933
00:41:38,510 --> 00:41:39,277
诱人的方法。

934
00:41:39,277 --> 00:41:41,610
早在一天，有
这个网站叫MapQuest的。

935
00:41:41,610 --> 00:41:44,120
我应该已经采取了
从20世纪90年代截图此，

936
00:41:44,120 --> 00:41:45,820
在这里，如果你想
看看在这里在地图上，

937
00:41:45,820 --> 00:41:48,590
你会从字面上点击箭头
在顶部的显示你

938
00:41:48,590 --> 00:41:49,870
不同的正方形的地图。

939
00:41:49,870 --> 00:41:51,790
如果你想向左移动，你
点击即表明您一个箭头

940
00:41:51,790 --> 00:41:53,210
不同的正方形的地图。

941
00:41:53,210 --> 00:41:54,840
而一些网站今日仍然这样做。

942
00:41:54,840 --> 00:41:57,820
但即使Mapquest服务已经得到
更好的，如谷歌地图。

943
00:41:57,820 --> 00:42:01,880
>> 相反，有什么更好的这些
天是使用AJAX网站。

944
00:42:01,880 --> 00:42:04,510
AJAX--另外称为
异步JavaScript和XML，

945
00:42:04,510 --> 00:42:08,370
这是说只是一种奇特的方式
一种技术或技术，

946
00:42:08,370 --> 00:42:14,200
允许使用JavaScript的浏览器
作出额外的HTTP请求

947
00:42:14,200 --> 00:42:16,390
后页被加载。

948
00:42:16,390 --> 00:42:17,479
所以，这是什么意思？

949
00:42:17,479 --> 00:42:19,270
那么，这将是一种
恼人的在Gmail

950
00:42:19,270 --> 00:42:21,103
如果每次你需要时间
检查你的邮件，

951
00:42:21,103 --> 00:42:24,940
你字面上按下Control-R或
命令-R或单击刷新按钮

952
00:42:24,940 --> 00:42:26,580
而整个该死的网页将重新加载。

953
00:42:26,580 --> 00:42:26,800
对？

954
00:42:26,800 --> 00:42:28,460
它会闪烁白色
可能是第二个。

955
00:42:28,460 --> 00:42:30,043
你会看到愚蠢的进度条。

956
00:42:30,043 --> 00:42:33,170
而只是为了看看是否有新的
邮件，整个网页和网址

957
00:42:33,170 --> 00:42:34,580
你在必须重新加载。

958
00:42:34,580 --> 00:42:35,960
>> 但是，这不是在Gmail中会发生什么。

959
00:42:35,960 --> 00:42:36,459
对？

960
00:42:36,459 --> 00:42:40,300
当你在一个新的电子邮件
Gmail的，是什么在屏幕上发生什么呢？

961
00:42:40,300 --> 00:42:41,480
它只是显示了，对不对？

962
00:42:41,480 --> 00:42:44,280
它只是奇迹般地出现
如在表中一个新行。

963
00:42:44,280 --> 00:42:47,030
这实际上涉及到
体面的复杂性。

964
00:42:47,030 --> 00:42:51,892
其实，如果你仔细想想这棵树，
这虽然是一个简单的在这里，

965
00:42:51,892 --> 00:42:54,100
Gmail--我不得不看
在代码是sure--

966
00:42:54,100 --> 00:42:58,710
可能有一个HTML表格或者
它呈现一个无序列表

967
00:42:58,710 --> 00:43:01,060
您的每一个收件箱中的邮件作为。

968
00:43:01,060 --> 00:43:04,050
>> 所以，如果你想象这有
是当你的内存树

969
00:43:04,050 --> 00:43:09,050
使用Gmail看起来那种类型的
这样，当谷歌意识到，哦，

970
00:43:09,050 --> 00:43:12,770
你有一个新的电子邮件，它不
要重建整个树。

971
00:43:12,770 --> 00:43:16,430
相反，它想找到该节点中
代表您的收件箱中的树

972
00:43:16,430 --> 00:43:18,580
并且只需插入一个新的节点。

973
00:43:18,580 --> 00:43:24,640
>> 所以非常相似PSET五，在那里你
不得不节点插入到一个哈希表，

974
00:43:24,640 --> 00:43:28,410
同样做谷歌，通过
它写的JavaScript代码，

975
00:43:28,410 --> 00:43:31,890
遍历这棵树，找出其中
是窗口的那部分的收件箱，

976
00:43:31,890 --> 00:43:33,440
然后插入新行。

977
00:43:33,440 --> 00:43:37,460
而一个新的行只是表示一个
或多个在一个树的新节点。

978
00:43:37,460 --> 00:43:41,340
>> 所以AJAX是这种技术
，允许这一点。

979
00:43:41,340 --> 00:43:44,440
一旦你访问过的URL，
然而，疯狂的长是，

980
00:43:44,440 --> 00:43:46,472
而一旦页面
被加载，你仍然可以

981
00:43:46,472 --> 00:43:48,430
抓住从多个数据
internet--无论是

982
00:43:48,430 --> 00:43:52,460
电子邮件或map--的瓦
抓住它幕后

983
00:43:52,460 --> 00:43:55,290
然后将其插入到页
从而使人体并不真正

984
00:43:55,290 --> 00:43:56,910
要等待它。

985
00:43:56,910 --> 00:43:58,980
>> Facebook的Messenger的工作方式相同。

986
00:43:58,980 --> 00:44:01,562
任何数量的其它websites--
呵呵，其实，即使是这样。

987
00:44:01,562 --> 00:44:04,270
我的意思是，这是坦率地种，
一个恼人的功能，这些天。

988
00:44:04,270 --> 00:44:07,500
如果我开始寻找这个cats--
是一种可怕的用户体验。

989
00:44:07,500 --> 00:44:08,990
这只是开始搜索我。

990
00:44:08,990 --> 00:44:10,050
那么它是什么做的？

991
00:44:10,050 --> 00:44:12,920
该网址还没有真正改变
自从我开始打字。

992
00:44:12,920 --> 00:44:17,330
但是，什么是整个会
wire-- OK，嗯有趣。

993
00:44:17,330 --> 00:44:20,470
什么是整个会
线在这里只是变得怪异。

994
00:44:20,470 --> 00:44:21,090
>> 好。

995
00:44:21,090 --> 00:44:24,670
因此，让我继续前进，并检查
元素，并进入网络选项卡

996
00:44:24,670 --> 00:44:27,040
并努力使这种
技术少约猫。

997
00:44:27,040 --> 00:44:32,595
作为I型，从字面上看，猫
还有 - 发生了什么

998
00:44:32,595 --> 00:44:37,710
per--我不会点击的。

999
00:44:37,710 --> 00:44:38,210
好吧。

1000
00:44:38,210 --> 00:44:44,280
所以到这里，发生了什么事每
一次，我输入一个字符，显然？

1001
00:44:44,280 --> 00:44:45,000
像，水平低？

1002
00:44:45,000 --> 00:44:47,860
发生了什么事，每个那些
字符我打字在我的键盘？

1003
00:44:47,860 --> 00:44:48,359
是吗？

1004
00:44:48,359 --> 00:44:50,950
听众：[听不清]。

1005
00:44:50,950 --> 00:44:52,340
>> DAVID马兰：没错。

1006
00:44:52,340 --> 00:44:55,600
每个这些字符是
去谷歌，一次一个。

1007
00:44:55,600 --> 00:44:58,490
他们正在建立一个字符串
他们的服务器上，表示

1008
00:44:58,490 --> 00:44:59,936
一切我已经输入了迄今。

1009
00:44:59,936 --> 00:45:01,810
每一次我型
另一种性格，他们

1010
00:45:01,810 --> 00:45:04,530
使用一个自己的秘密武器
搜索算法计算出，

1011
00:45:04,530 --> 00:45:07,370
他的意思是这种猫页
或者这种猫页面或之类的？

1012
00:45:07,370 --> 00:45:10,620
因此，在某种意义上说，它为我提供了一个
在更好的体验我甚至不

1013
00:45:10,620 --> 00:45:11,860
需要完成我的想法。

1014
00:45:11,860 --> 00:45:14,440
事实上，这是一个很有用
首先，自动完成一般。

1015
00:45:14,440 --> 00:45:17,690
如果他们的算法是不够好
如果我的搜索都是显而易见的，

1016
00:45:17,690 --> 00:45:19,300
我不必键入整个单词。

1017
00:45:19,300 --> 00:45:22,110
他们会告诉我是什么
在实际上，我寻找。

1018
00:45:22,110 --> 00:45:25,940
那么，谷歌称之为即时
搜索只是使用AJAX，

1019
00:45:25,940 --> 00:45:30,820
使用代码，允许他们请求
通过网络浏览器的其他内容

1020
00:45:30,820 --> 00:45:34,026
背后使用这种场景
新的语言，JavaScript的。

1021
00:45:34,026 --> 00:45:35,400
因此，我们必须留下一两分钟。

1022
00:45:35,400 --> 00:45:37,710
而让我叫我的好友
科尔顿起来搬上舞台，

1023
00:45:37,710 --> 00:45:40,090
因为它似乎
特别有趣的最后一次

1024
00:45:40,090 --> 00:45:42,290
引进技术
你们有些人

1025
00:45:42,290 --> 00:45:44,769
已表示有兴趣
在最终的项目。

1026
00:45:44,769 --> 00:45:47,310
我们认为这会很有趣，使
一个志愿者，不过，今天

1027
00:45:47,310 --> 00:45:50,074
向您展示的除了
这可以让你 - 是啊，

1028
00:45:50,074 --> 00:45:50,990
只见这手第一次。

1029
00:45:50,990 --> 00:45:52,900
上来吧。

1030
00:45:52,900 --> 00:45:53,560
做得太好了。

1031
00:45:53,560 --> 00:45:55,035
做得好。

1032
00:45:55,035 --> 00:45:57,410
我将这个项目上
屏幕上一会儿就好了。

1033
00:45:57,410 --> 00:45:58,150
你叫什么名字给大家？

1034
00:45:58,150 --> 00:45:59,180
>> 全民教育：我是全民教育。

1035
00:45:59,180 --> 00:45:59,410
>> DAVID马兰：ETHA？

1036
00:45:59,410 --> 00:45:59,785
>> 全民教育：全民教育。

1037
00:45:59,785 --> 00:46:00,160
>> DAVID马兰：全民教育？

1038
00:46:00,160 --> 00:46:00,730
>> 全民教育：是的。

1039
00:46:00,730 --> 00:46:01,250
>> DAVID马兰：很高兴见到你。

1040
00:46:01,250 --> 00:46:01,600
好吧。

1041
00:46:01,600 --> 00:46:02,590
让我得到这个准备。

1042
00:46:02,590 --> 00:46:04,423
你过来给
中间用科尔顿在这里。

1043
00:46:04,423 --> 00:46:07,050
什么科尔顿在他手里
今天是一个遥控器。

1044
00:46:07,050 --> 00:46:10,440
因此，而不是只是站在那里一
三维世界中四处寻找

1045
00:46:10,440 --> 00:46:14,080
作为科尔顿那样，现在EFA可以
实际上走动通过往上走，

1046
00:46:14,080 --> 00:46:16,689
下，左，和右像
任天堂或Xbox控制器。

1047
00:46:16,689 --> 00:46:18,230
全民教育：我要掉下舞台。

1048
00:46:18,230 --> 00:46:20,500
DAVID马兰：我会的
站在大致在这里。

1049
00:46:20,500 --> 00:46:21,991
但是，这是一个危险。

1050
00:46:21,991 --> 00:46:22,490
好。

1051
00:46:22,490 --> 00:46:25,690
因此，继续前进，把那些。

1052
00:46:25,690 --> 00:46:29,315
让我继续前进，
切换到此处的屏幕。

1053
00:46:29,315 --> 00:46:30,670
让我把灯光调暗。

1054
00:46:30,670 --> 00:46:32,780
而科尔顿，让我
走到你旁边的立场。

1055
00:46:32,780 --> 00:46:35,520
>> 难道你想在这里解释一下
与MIC我们在做什么？

1056
00:46:35,520 --> 00:46:36,380
干得好。

1057
00:46:36,380 --> 00:46:37,280
>> COLTON：当然。

1058
00:46:37,280 --> 00:46:39,980
所以现在我们
加载了魔环，

1059
00:46:39,980 --> 00:46:43,070
我想operating--不工作
系统，但主要程序，其中

1060
00:46:43,070 --> 00:46:46,630
您可以访问所有的游戏
该应用程序存储库中。

1061
00:46:46,630 --> 00:46:50,060
所以现在，应该说
轻点触控板开始。

1062
00:46:50,060 --> 00:46:53,430
触摸板将是对
右侧的耳机。

1063
00:46:53,430 --> 00:46:54,569
所以，尽管tap--

1064
00:46:54,569 --> 00:46:55,110
全民教育：哦，伙计。

1065
00:46:55,110 --> 00:46:56,443
DAVID马兰：是啊，你去那里。

1066
00:46:56,443 --> 00:47:00,340

1067
00:47:00,340 --> 00:47:02,460
质量的全民教育是看到
高得多的品质。

1068
00:47:02,460 --> 00:47:03,831
这仅仅是在Wi-Fi在这里。

1069
00:47:03,831 --> 00:47:05,580
COLTON：你那么什么
要想做的事情

1070
00:47:05,580 --> 00:47:08,350
看起来是朝上方
右边的屏幕。

1071
00:47:08,350 --> 00:47:10,420
是的，在很右上角的那场比赛。

1072
00:47:10,420 --> 00:47:14,780
然后，当你选择
它，再次点击触摸板。

1073
00:47:14,780 --> 00:47:17,010
我认为它Dreadhalls。

1074
00:47:17,010 --> 00:47:20,820
然后这里A--这里，让
我握住你的眼镜给你。

1075
00:47:20,820 --> 00:47:24,420

1076
00:47:24,420 --> 00:47:25,790
>> 所以，我只是给了他一个控制器。

1077
00:47:25,790 --> 00:47:28,886
所以，现在他能控制比赛。

1078
00:47:28,886 --> 00:47:30,510
他可以左右移动之类的东西。

1079
00:47:30,510 --> 00:47:31,968
因此，继续前进，仰望上方。

1080
00:47:31,968 --> 00:47:33,640
您应该看到新游戏。

1081
00:47:33,640 --> 00:47:36,310
所以，尽管你可以做到这一点。

1082
00:47:36,310 --> 00:47:39,320
现在，你应该能够控制
自己与控制器，

1083
00:47:39,320 --> 00:47:43,860
还有，一旦
游戏加载了这里。

1084
00:47:43,860 --> 00:47:46,356
这可能是有点吓人。

1085
00:47:46,356 --> 00:47:47,300
>> 全民教育：现在你告诉我。

1086
00:47:47,300 --> 00:47:50,132
好。

1087
00:47:50,132 --> 00:47:51,080
>> COLTON：好吧。

1088
00:47:51,080 --> 00:47:52,650
所以，请确认您可以走动。

1089
00:47:52,650 --> 00:47:52,750
好。

1090
00:47:52,750 --> 00:47:53,583
你可以四处走动。

1091
00:47:53,583 --> 00:47:54,300
完善。

1092
00:47:54,300 --> 00:47:56,470
所以，如果你往下看，你有一张地图。

1093
00:47:56,470 --> 00:47:58,170
地图显示您身在何处。

1094
00:47:58,170 --> 00:47:59,720
你可以看看周围的房间。

1095
00:47:59,720 --> 00:48:01,440
您可以完全转身。

1096
00:48:01,440 --> 00:48:02,128
是的，没错。

1097
00:48:02,128 --> 00:48:02,627
回转。

1098
00:48:02,627 --> 00:48:05,370

1099
00:48:05,370 --> 00:48:07,125
>> 所以，看看你的左边。

1100
00:48:07,125 --> 00:48:09,875
我觉得有东西，你可以
拿起放在房间桶。

1101
00:48:09,875 --> 00:48:11,709
>> 全民教育：我如何获得
映射出的方法是什么？

1102
00:48:11,709 --> 00:48:12,375
COLTON：查一查。

1103
00:48:12,375 --> 00:48:12,980
只要看看了。

1104
00:48:12,980 --> 00:48:13,480
好吧。

1105
00:48:13,480 --> 00:48:13,765
你去那里。

1106
00:48:13,765 --> 00:48:15,181
现在，继续前进，只是转身。

1107
00:48:15,181 --> 00:48:21,460

1108
00:48:21,460 --> 00:48:24,620
所以看得更远一些，以你的左边。

1109
00:48:24,620 --> 00:48:25,530
继续前进离开。

1110
00:48:25,530 --> 00:48:26,960
继续找走了。

1111
00:48:26,960 --> 00:48:27,541
继续。

1112
00:48:27,541 --> 00:48:28,040
是啊。

1113
00:48:28,040 --> 00:48:28,720
>> 全民教育：哦，这样。

1114
00:48:28,720 --> 00:48:29,261
>> COLTON：是的。

1115
00:48:29,261 --> 00:48:30,999
走向它与控制器。

1116
00:48:30,999 --> 00:48:31,540
你去那里。

1117
00:48:31,540 --> 00:48:32,790
现在，应该说把它捡起来。

1118
00:48:32,790 --> 00:48:33,360
你去那里。

1119
00:48:33,360 --> 00:48:34,290
捡起来。

1120
00:48:34,290 --> 00:48:35,550
好吧。

1121
00:48:35,550 --> 00:48:38,286
现在，让我们走出这个房间。

1122
00:48:38,286 --> 00:48:42,209
继续前进，走到那扇门。

1123
00:48:42,209 --> 00:48:45,000
所以，你要hold--它说
按住按钮，迫使它开放。

1124
00:48:45,000 --> 00:48:46,333
所以，尽管并按住该按钮。

1125
00:48:46,333 --> 00:48:48,250
是的，迫使其打开。

1126
00:48:48,250 --> 00:48:48,750
好吧。

1127
00:48:48,750 --> 00:48:49,410
做得好。

1128
00:48:49,410 --> 00:48:50,826
现在，我们走出了房间。

1129
00:48:50,826 --> 00:48:56,970

1130
00:48:56,970 --> 00:49:01,366
所以我要离开休息了
给你，看看你了解一下。

1131
00:49:01,366 --> 00:49:02,865
全民教育：我不会在黑暗的房间。

1132
00:49:02,865 --> 00:49:07,315

1133
00:49:07,315 --> 00:49:07,815
等一下。

1134
00:49:07,815 --> 00:49:09,314
现在我必须去暗下来的大厅？

1135
00:49:09,314 --> 00:49:10,785
好了，我要回去[听不清]。

1136
00:49:10,785 --> 00:49:15,520

1137
00:49:15,520 --> 00:49:16,270
COLTON：好吧。

1138
00:49:16,270 --> 00:49:17,560
一些更多的项目回暖。

1139
00:49:17,560 --> 00:49:19,370
看起来像一些硬币。

1140
00:49:19,370 --> 00:49:22,242
这是一个锁定选秀权。

1141
00:49:22,242 --> 00:49:24,200
所以，如果你发现一个上锁
门，你可以使用。

1142
00:49:24,200 --> 00:49:27,755

1143
00:49:27,755 --> 00:49:28,380
你怕了吗？

1144
00:49:28,380 --> 00:49:29,371
>> 全民教育：还没有。

1145
00:49:29,371 --> 00:49:29,871
COLTON：OK。

1146
00:49:29,871 --> 00:49:34,850

1147
00:49:34,850 --> 00:49:35,497
>> Pretend--呀。

1148
00:49:35,497 --> 00:49:37,330
只是假装你
其实站在那里。

1149
00:49:37,330 --> 00:49:39,580
如果你把around--
你得习惯它。

1150
00:49:39,580 --> 00:49:40,752
但是，这是有道理的。

1151
00:49:40,752 --> 00:49:43,960
DAVID马兰：虽然全民教育继续
玩，因为我们可以做到这一切的一天，

1152
00:49:43,960 --> 00:49:45,381
我们都可以踮着脚尖在这里。

1153
00:49:45,381 --> 00:49:48,130
但是，我们确实有另外两对，
如果你想拿出和发挥。

1154
00:49:48,130 --> 00:49:49,980
否则，我们将看到
你接下来的周三。

1155
00:49:49,980 --> 00:49:51,354
感谢您对我们的志愿者今天。

1156
00:49:51,354 --> 00:49:52,101
[掌声]

1157
00:49:52,101 --> 00:49:54,506

1158
00:49:54,506 --> 00:49:57,392
>> [MUSIC  - “宋飞正传主题”]

1159
00:49:57,392 --> 00:49:58,222

1160
00:49:58,222 --> 00:50:00,180
扬声器1：好吧，我
把一个新的PL卡口上。

1161
00:50:00,180 --> 00:50:01,800
我只是改变了OLPF--

1162
00:50:01,800 --> 00:50:03,980
>> 扬声器2：那么是什么
到底在做什么？

1163
00:50:03,980 --> 00:50:07,063
>> 扬声器1：好吧，每个人these--
在这里，我会告诉你这一个在这里。

1164
00:50:07,063 --> 00:50:08,690
你可以看到它在这里。

1165
00:50:08,690 --> 00:50:09,510
>> 扬声器3：我觉得我好这些。

1166
00:50:09,510 --> 00:50:09,933
你要多一些？

1167
00:50:09,933 --> 00:50:11,325
>> 扬声器4：没有，我很好。 [听不清]。

1168
00:50:11,325 --> 00:50:12,200
>> 扬声器3：没有，[听不清]。

1169
00:50:12,200 --> 00:50:12,700
有一些。

1170
00:50:12,700 --> 00:50:21,165

1171
00:50:21,165 --> 00:50:22,290
扬声器1：不同的颜色。

1172
00:50:22,290 --> 00:50:22,890
扬声器2：确定。

1173
00:50:22,890 --> 00:50:26,690
扬声器1：所以最终什么
所做的就是调整颜色of--