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

2
00:00:11,330 --> 00:00:12,360
>> DAVID马兰：好吧。

3
00:00:12,360 --> 00:00:15,970
这是CS50，这是
9周的结束。

4
00:00:15,970 --> 00:00:18,560
它在被旋风
这几天。

5
00:00:18,560 --> 00:00:21,580
与问题设置7，如果你的膝盖
深入到它，实现有相当多

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

7
00:00:23,340 --> 00:00:26,660
但是让我们看看如果我们不能拼凑
一切都聚集在这里简要地

8
00:00:26,660 --> 00:00:29,230
在此之前尚未在关闭于水火之中
另一个方向，看到

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

10
00:00:30,510 --> 00:00:32,630
>> 所以到目前为止，我们已经讨论过的HTML。

11
00:00:32,630 --> 00:00:33,740
我们已经谈到的CSS。

12
00:00:33,740 --> 00:00:34,705
我们已经谈了PHP的。

13
00:00:34,705 --> 00:00:36,520
你开始体验到的SQL。

14
00:00:36,520 --> 00:00:38,360
今天，我们就商量了一下
关于JavaScript。

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

16
00:00:41,230 --> 00:00:44,970
>> 所以，我们上周谈到了
概念有一个服务器。

17
00:00:44,970 --> 00:00:48,470
所以我们只绘制这个矩形
这里作为一个Web服务器。

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

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

20
00:00:54,640 --> 00:00:58,270
这样的事情之一是一个Web服务器
可以吐出可能是一个文件，该文件

21
00:00:58,270 --> 00:01:01,290
我们就得出这样的
包含一些HTML。

22
00:01:01,290 --> 00:01:04,786
所以，通俗地说，是什么
没有HTML让你做？

23
00:01:04,786 --> 00:01:06,036
>> 观众：页面看起来不错。

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

25
00:01:09,670 --> 00:01:12,310
>> DAVID MALAN：好，使一个页面看起来不错，
虽然我觉得我已经证明

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

27
00:01:13,370 --> 00:01:18,250
因此，HTML的确让你铺陈页
结构上，它可以让你

28
00:01:18,250 --> 00:01:22,410
排序的美学标记的页面，
标记静态内容，让你

29
00:01:22,410 --> 00:01:23,640
然后，可以使用Web浏览器查看它。

30
00:01:23,640 --> 00:01:24,690
>> 但是，这是关键。

31
00:01:24,690 --> 00:01:26,130
这是静态内容。

32
00:01:26,130 --> 00:01:28,590
你写它，你保存它，
然后你发货。

33
00:01:28,590 --> 00:01:31,130
和Web服务器，然后提供
它给您的访客。

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

35
00:01:35,700 --> 00:01:40,150
我们开始使用一个style属性
对某些标签。

36
00:01:40,150 --> 00:01:43,400
和style属性让我们设置
事情，比如字体大小和颜色。

37
00:01:43,400 --> 00:01:46,460
而且你可能已经开始发现，
或者你很快就会进行最后的

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

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

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

41
00:01:57,810 --> 00:02:00,730
是什么让你这样做的HTML
似乎没有从什么

42
00:02:00,730 --> 00:02:02,606
我们已经看到了这样多远？

43
00:02:02,606 --> 00:02:04,850
>> 观众：你自己定义的样式。

44
00:02:04,850 --> 00:02:06,700
>> DAVID马兰：定义样式
由你自己。

45
00:02:06,700 --> 00:02:10,280
所以定义类的东西类作为你
可能都遇到过，还是唯一

46
00:02:10,280 --> 00:02:13,800
识别文档中的节点，以便
你可以样式化它们。

47
00:02:13,800 --> 00:02:16,890
但更确切地说，我想说的是CSS
真的可以让你把东西

48
00:02:16,890 --> 00:02:20,790
最后一公里，并允许您指定多
更精确的美观性，

49
00:02:20,790 --> 00:02:24,340
而HTML在大多数情况下可以
你组织你的页面。

50
00:02:24,340 --> 00:02:27,310
>> 而且即使有一些默认值，
就像我们看到的标签

51
00:02:27,310 --> 00:02:30,690
一个标题标签，它粗略地讲
做事情的大和大胆。

52
00:02:30,690 --> 00:02:34,250
这是一个非常通用的定义
标签的 - 大和大胆。

53
00:02:34,250 --> 00:02:35,260
什么字号是什么？

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

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

56
00:02:36,890 --> 00:02:39,830
和CSS使您可以更精细地
调类的东西。

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

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

59
00:02:45,180 --> 00:02:48,370
这是非常强大的，你可以做
从字面上，你已经任何网站

60
00:02:48,370 --> 00:02:51,880
今天看到在网络上与它，但
它是一种在颈部疼痛。

61
00:02:51,880 --> 00:02:54,440
和你们有些人撞你的头
对墙壁已经只是做

62
00:02:54,440 --> 00:02:58,560
一些愚蠢的中心像一个菜单
问题设置7，如果你已经得到了

63
00:02:58,560 --> 00:02:59,470
这一点了。

64
00:02:59,470 --> 00:03:01,530
>> 但要意识到，那些事
得到随着时间的推移更加容易。

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

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

67
00:03:06,020 --> 00:03:07,220
解决这类问题。

68
00:03:07,220 --> 00:03:11,520
>> 我敢说使用CSS和HTML更
通常，你可以解决的问题

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

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

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

72
00:03:21,080 --> 00:03:22,570
>> 但是，这开始变得
凌乱的，我们说。

73
00:03:22,570 --> 00:03:26,480
只是那种混入你的HTML和
你的CSS的样式属性是

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

75
00:03:27,590 --> 00:03:31,460
所以我们不是说那种，
抽象地说，那你应该

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

77
00:03:34,050 --> 00:03:37,430
不是你的风格属性，但至少
使用样式标签里面有什么

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

79
00:03:38,840 --> 00:03:39,560
>> 观众：头。

80
00:03:39,560 --> 00:03:40,120
>> DAVID马兰：在头部。

81
00:03:40,120 --> 00:03:43,270
到现在为止，我们只有标题了
在那里，但你也可以添加一个样式

82
00:03:43,270 --> 00:03:47,230
标记，而且你可以把你的CSS大致
发言朝向页面的顶部。

83
00:03:47,230 --> 00:03:52,550
但后来我们把事情一步
我们分解了更多

84
00:03:52,550 --> 00:03:54,130
到一个单独的文件中。

85
00:03:54,130 --> 00:03:57,240
>> 所以这两个文件分别为
不知何故现在联系在一起。

86
00:03:57,240 --> 00:03:59,550
而事实上它是
标签，这样做。

87
00:03:59,550 --> 00:04:02,920
什么是总体的一个
动机分解出我们的CSS

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

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

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

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

92
00:04:06,150 --> 00:04:09,470
你可能已经看到在对设置7已经
，很多的网页时，

93
00:04:09,470 --> 00:04:12,260
购买页面，销售页面，该
投资组合页面，可能是

94
00:04:12,260 --> 00:04:13,550
结构有些类似。

95
00:04:13,550 --> 00:04:17,579
有一个CS50金融徽标上方
除非你已经决定去改变它。

96
00:04:17,579 --> 00:04:19,839
有一个页脚在
页面底部。

97
00:04:19,839 --> 00:04:24,315
和CSS允许，那么你在要素吧
成一个单独的文件，这样，如果

98
00:04:24,315 --> 00:04:27,780
你想在全球范围内改变一些东西
在您的整个网站，你可真

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

100
00:04:29,390 --> 00:04:32,750
>> 但你可能会付出代价
由已分解出来的

101
00:04:32,750 --> 00:04:38,380
CSS的从我的HTML文件到一个单独的
文件与引用它

102
00:04:38,380 --> 00:04:40,650
标签，我们看到在周一。

103
00:04:40,650 --> 00:04:43,850
什么可能的缺点是这个？

104
00:04:43,850 --> 00:04:48,830
回想一周前，当我们
谈论HTTP和TCP / IP和如何

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

106
00:04:52,070 --> 00:04:53,530
这里有什么事？

107
00:04:53,530 --> 00:04:54,730
>> 观众：它需要更多的时间。

108
00:04:54,730 --> 00:04:55,470
>> DAVID马兰：这需要更多的时间。

109
00:04:55,470 --> 00:04:56,750
为什么呢？

110
00:04:56,750 --> 00:04:59,450
>> 观众：[听不清]。

111
00:04:59,450 --> 00:04:59,750
>> 马兰大卫：是的。

112
00:04:59,750 --> 00:05:01,240
因此，它可以说是需要多一点的时间。

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

114
00:05:04,290 --> 00:05:06,920
所以，现在你必须做出不
一个，而是两个请求。

115
00:05:06,920 --> 00:05:11,230
并且其中的每个请求，因为我们所看到的
铬在所谓的督察，

116
00:05:11,230 --> 00:05:15,740
我们期待在网络选项卡，每个
这些文件都需要一个HTTP

117
00:05:15,740 --> 00:05:18,360
的要求，我们需要看到
一定量的时间。

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

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

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

121
00:05:22,260 --> 00:05:25,530
>> 但仔细想想，如Facebook的页面，
或CNN，还是谷歌，这是多少

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

123
00:05:28,060 --> 00:05:32,070
这些网页可能有几十个文件，
其中每一个可能需要一个

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

125
00:05:33,550 --> 00:05:35,800
这样的事情，都可能导致
开始放缓。

126
00:05:35,800 --> 00:05:39,280
>> 尤其是这些天，当大家都
拥有移动电话在我们的口袋和

127
00:05:39,280 --> 00:05:43,010
较慢的互联网连接，不必
等待几毫秒的时间，几

128
00:05:43,010 --> 00:05:46,110
额外多毫秒
文件实际上可能会很慢。

129
00:05:46,110 --> 00:05:50,430
延迟是描述字
这种等待，你有你

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

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

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

133
00:05:56,600 --> 00:05:58,170
它实际上是一个位在这里一个跷跷板。

134
00:05:58,170 --> 00:06:02,970
现在下行，但什么浏览器都可以做
如果他们是聪明的，以避免

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

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

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

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

139
00:06:11,690 --> 00:06:15,810
一般是指这里只是为了保存
提交您所要求的第一时间，

140
00:06:15,810 --> 00:06:17,440
然后检查你的缓存它。

141
00:06:17,440 --> 00:06:20,400
检查你的排序存储容器，
如果你已经有了一个

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

143
00:06:24,520 --> 00:06:28,560
再次请求它，只是为了给
用户相同的缓存副本。

144
00:06:28,560 --> 00:06:30,140
不要打扰请​​求它。

145
00:06:30,140 --> 00:06:32,560
>> 下行那里，虽然，因为你们中的一些
已在p组绊倒。

146
00:06:32,560 --> 00:06:35,870
如果你做出改变的服务器上，
你回去的浏览器，你

147
00:06:35,870 --> 00:06:39,250
重新加载时，有时浏览器
你帮一个忙，不打扰

148
00:06:39,250 --> 00:06:43,660
重新下载您的styles.css的文件
因为，来吧，什么是赔率

149
00:06:43,660 --> 00:06:47,620
这些样式Facebook的使用
打算小时变更为小时或

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

151
00:06:48,140 --> 00:06:48,800
这是相当低的。

152
00:06:48,800 --> 00:06:52,260
他们可能会随时间而改变，但不
按分钟或一小时。

153
00:06:52,260 --> 00:06:55,810
>> 所以一招，只是FYI在做网页的时候
发展，往往是按住

154
00:06:55,810 --> 00:06:59,500
比如Shift键，然后单击
重新加载在浏览器中，这将

155
00:06:59,500 --> 00:07:03,280
通常是告诉浏览器重装
一切，即使你已经有

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

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

158
00:07:06,630 --> 00:07:08,260
最终设计决策。

159
00:07:08,260 --> 00:07:11,520
>> 所以，现在，我们并不只是
在这里结束的故事。

160
00:07:11,520 --> 00:07:15,790
如果我现在回去，回去和背部
回来了，我们开始引进不只是

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

162
00:07:18,060 --> 00:07:20,786
所以，通俗地说，是什么
PHP确实让我们做什么？

163
00:07:20,786 --> 00:07:22,770
>> 观众：[听不清]。

164
00:07:22,770 --> 00:07:24,258
>> 马兰大卫：那是什么？

165
00:07:24,258 --> 00:07:25,250
>> 观众：介绍逻辑
入代码。

166
00:07:25,250 --> 00:07:26,620
>> DAVID MALAN：是啊，介绍
逻辑到你的代码。

167
00:07:26,620 --> 00:07:29,570
所以这是一个真正的编程语言
与循环，变量，和

168
00:07:29,570 --> 00:07:32,620
功能，以及所有条件，并
我们一直在使用的方式回来的东西

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

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

171
00:07:36,780 --> 00:07:39,190
不必有什么关系
与Web，即使那是

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

173
00:07:43,150 --> 00:07:47,130
但你可以使用PHP仅仅通过自然
的，它有一个印刷（这一事实）

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

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

176
00:07:52,440 --> 00:07:56,540
>> 因此，您可以使用这个编程
语言准确地输出

177
00:07:56,540 --> 00:07:58,460
什么我们之前谈论。

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

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

180
00:08:02,300 --> 00:08:06,460
也许你硬编码的东西，像
头和尾，并且标识，

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

182
00:08:07,950 --> 00:08:11,190
但对于像对设置7，
您要去哪里操纵股票和

183
00:08:11,190 --> 00:08:14,690
显示用户的投资组合，这是
要动态地改变，你可以

184
00:08:14,690 --> 00:08:18,960
当然使用PHP和它给人的逻辑
你作为一个编程语言

185
00:08:18,960 --> 00:08:22,320
输出子集动态
页面。

186
00:08:22,320 --> 00:08:25,900
>> 所以，当你谈论动态网站，
或web编程，这是

187
00:08:25,900 --> 00:08:27,200
你真正谈论。

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

189
00:08:31,450 --> 00:08:35,900
但其他语言，来查询数据库
通常，或另一台服务器，

190
00:08:35,900 --> 00:08:38,580
然后动态吐出的HTML。

191
00:08:38,580 --> 00:08:42,470
>> 现在，最终的结果，顺便说一句，是
大多数网站的HTML，

192
00:08:42,470 --> 00:08:45,970
包括你对设置7，可能是
将是一个巨大的烂摊子，如果

193
00:08:45,970 --> 00:08:48,060
你看看源
在浏览器中的代码。

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

195
00:08:49,010 --> 00:08:51,550
此时，当我们关心
式，我们关心的

196
00:08:51,550 --> 00:08:52,740
你写的东西。

197
00:08:52,740 --> 00:08:56,240
本公司不会在乎的东西
那你的代码输出。

198
00:08:56,240 --> 00:08:59,520
所以不用担心缩进
在这里，如果是PHP的这

199
00:08:59,520 --> 00:09:01,190
实际输出的东西。

200
00:09:01,190 --> 00:09:04,430
毕竟，浏览器不会在意，
和人将不会被期待

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

202
00:09:05,400 --> 00:09:09,000
我们的工作人员，例如，将
在看你的PHP。

203
00:09:09,000 --> 00:09:13,440
>> 所以让我给一个简单的例子现在
为什么其他人，这可能是有用的。

204
00:09:13,440 --> 00:09:18,620
所以坦率地说，我不记得过去
一次我用C来解决问题

205
00:09:18,620 --> 00:09:19,620
现实世界。

206
00:09:19,620 --> 00:09:22,330
这可能是在读研究生的时候
我需要使用一种语言，

207
00:09:22,330 --> 00:09:26,710
是相当低的水平，给我的
机会做一些事情非常高

208
00:09:26,710 --> 00:09:30,720
执行真正挽救尽可能多的CPU
周期，尽我所能，在很大程度上

209
00:09:30,720 --> 00:09:33,990
因为我是用庞大的数据集，
而每个CPU周期计数。

210
00:09:33,990 --> 00:09:37,750
坦率地说，即使是在事情，比如手机
这些天，其他设备

211
00:09:37,750 --> 00:09:39,910
在那里你不太有尽可能多的
内存和你不太有作为

212
00:09:39,910 --> 00:09:44,160
大量的CPU，使用更快的语言
仍然有吸引力。

213
00:09:44,160 --> 00:09:47,290
>> 但在现实世界中，当你只是
想一起抛出一些程序

214
00:09:47,290 --> 00:09:50,340
分析一些数据，或者你收集
对于一大堆的注册

215
00:09:50,340 --> 00:09:53,330
并且要很有​​些学生组
快速自动发送电子邮件

216
00:09:53,330 --> 00:09:56,240
逐一对每个其中的一个
注册者，你要达到的

217
00:09:56,240 --> 00:09:59,240
一个更高层次的语言
比C可以这么说。

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

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

220
00:10:04,550 --> 00:10:07,200
但是这3个可能
最时尚的现在。

221
00:10:07,200 --> 00:10:10,840
>> 而这是什么意思是，你可以打开
一个文本编辑器，例如gedit或

222
00:10:10,840 --> 00:10:14,030
大多数别的，然后就开始
编写代码，而不必担心

223
00:10:14,030 --> 00:10:17,800
有关编译，而无需
真担心内存管理，

224
00:10:17,800 --> 00:10:20,820
牢记尽管这一点
草率最终会回来

225
00:10:20,820 --> 00:10:24,790
咬你，如果数据集变
规模较大或问题变得大了。

226
00:10:24,790 --> 00:10:27,230
但是，这是什么意思的
我们如下。

227
00:10:27,230 --> 00:10:29,860
>> 让我继续运行拼写检查
从问题设置6。

228
00:10:29,860 --> 00:10:33,480
所以这是我的特里为基础实现
我用的大

229
00:10:33,480 --> 00:10:35,500
板在那里我表现不太好。

230
00:10:35,500 --> 00:10:38,720
我们会回来在一个星期的时间，
重温那些谁也结束了头顶上的

231
00:10:38,720 --> 00:10:40,430
大板在我们的最后一次演讲。

232
00:10:40,430 --> 00:10:44,520
但现在，让我继续前进，只是
运行我的解决方案文本，我们会做

233
00:10:44,520 --> 00:10:48,460
国王詹姆斯圣经，在这里，我们走。

234
00:10:48,460 --> 00:10:51,080
>> 因此，这些都是所有的假想
拼写错误的单词的出

235
00:10:51,080 --> 00:10:52,240
国王詹姆斯圣经。

236
00:10:52,240 --> 00:10:55,560
和我的实现了
半秒钟的总和。

237
00:10:55,560 --> 00:10:58,270
所以不会在这个太糟糕了
特定的计算机。

238
00:10:58,270 --> 00:11:01,540
但想到多少
代码我不得不写。

239
00:11:01,540 --> 00:11:02,880
想想你有多少代码编写。

240
00:11:02,880 --> 00:11:06,170
想想你在多少小时内用完
D-大厅或你的宿舍或其它地方

241
00:11:06,170 --> 00:11:07,890
实际上编码了该解决方案。

242
00:11:07,890 --> 00:11:11,850
>> 好吧，如果我真的有一个更高的水平
像PHP语言，请注意

243
00:11:11,850 --> 00:11:13,350
我可以在这里做。

244
00:11:13,350 --> 00:11:16,410
首先，假设这是代替
您的分发代码。

245
00:11:16,410 --> 00:11:17,790
这是一个叫的拼写文件。

246
00:11:17,790 --> 00:11:20,220
它可作为当今的一部分
分配的代码。

247
00:11:20,220 --> 00:11:22,670
而且我要挥挥手最多
的细节，但是这实际上是

248
00:11:22,670 --> 00:11:25,500
如何一个有趣的例子
你可能端口的语言

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

250
00:11:28,870 --> 00:11:33,420
我硬是开了两个文本窗口，
之一，speller.c我的C版本，

251
00:11:33,420 --> 00:11:36,960
我刚开始翻译它在我
前往采用PHP和打字出来

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

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

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

255
00:11:43,730 --> 00:11:47,050
它使用典型地需要，但
包括确实存在。

256
00:11:47,050 --> 00:11:50,330
定义是有一点不同
＃在C中定义，但是这

257
00:11:50,330 --> 00:11:51,890
我们如何做一个常数。

258
00:11:51,890 --> 00:11:55,860
$ ARGC原来存在于PHP，
所以我们在前面提到过。

259
00:11:55,860 --> 00:11:58,650
这些仅仅是变量，所有的
它开始与美元的迹象。

260
00:11:58,650 --> 00:12:00,590
回想这些都只是一堆
浮动点。

261
00:12:00,590 --> 00:12:03,970
>> 所以长话短说，欢迎您
翻阅这一点，如果好奇，这是

262
00:12:03,970 --> 00:12:10,010
几乎是行换行转换
C版speller.c的到PHP。

263
00:12:10,010 --> 00:12:12,630
，你可以再次做到这一点
半打其他语言。

264
00:12:12,630 --> 00:12:14,910
>> 但有趣的是这个。

265
00:12:14,910 --> 00:12:16,910
或什么是令人沮丧的坦然
是这样的。

266
00:12:16,910 --> 00:12:20,790
让我继续前进，键入有关
dictionary.php，并声称我

267
00:12:20,790 --> 00:12:23,670
要继续前进，并重新实现
问题组六在这里。

268
00:12:23,670 --> 00:12:27,530
>> 因此，让我们首先提出，在这
文件，这将在实施

269
00:12:27,530 --> 00:12:30,550
PHP的，所以让我打开我的标签这样的。

270
00:12:30,550 --> 00:12:34,780
让我给自己一个全球性的
变量$尺寸变零。

271
00:12:34,780 --> 00:12:36,710
我想给
我是一个哈希表。

272
00:12:36,710 --> 00:12:38,110
我将使用一个哈希表这个东西。

273
00:12:38,110 --> 00:12:42,070
在PHP中我如何声明一个哈希表？

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

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

276
00:12:43,980 --> 00:12:48,870
>> 所以，开括号右括号代表
怎样在PHP中，我们已经看到？

277
00:12:48,870 --> 00:12:51,850
一个数组，而是一个数组，可以
是一个关联数组。

278
00:12:51,850 --> 00:12:54,320
关联数组是
一个数据结构，它

279
00:12:54,320 --> 00:12:55,860
与关联值的键。

280
00:12:55,860 --> 00:12:59,430
>> 现在，在数字索引的最简单
数组，这些键是什么？

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

282
00:13:02,250 --> 00:13:03,960
零，一，二，三，对不对？

283
00:13:03,960 --> 00:13:08,780
老派的东西从C回来，但它可以
也像foo，并且巴串，

284
00:13:08,780 --> 00:13:12,210
或麦克斯韦，或任何该等字符串。

285
00:13:12,210 --> 00:13:14,240
这样我就可以利用这
在短短的一瞬间。

286
00:13:14,240 --> 00:13:17,550
>> 让我继续前进，宣
就像一个功能 - 

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

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

289
00:13:20,690 --> 00:13:23,440
和PHP是一个有点不同
你从字面上输入功能，但你

290
00:13:23,440 --> 00:13:24,930
不要键入一个返回类型。

291
00:13:24,930 --> 00:13:28,760
我要继续前进，说，
load（）函数应在

292
00:13:28,760 --> 00:13:31,000
参数$词典，刚
像C版本一样。

293
00:13:31,000 --> 00:13:32,510
我这样做，从内存中。

294
00:13:32,510 --> 00:13:34,910
>> 我建议，我
要做到这一点。

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

296
00:13:37,080 --> 00:13:40,710
我要调用一个调用的函数
文件（），传入的这个名字

297
00:13:40,710 --> 00:13:44,990
文件，该文件是变量
$词典为$字。

298
00:13:44,990 --> 00:13:49,410
然后在里面我的for循环在这里，我
要继续前进，并存储在我的

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

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

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

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

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

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

305
00:14:04,970 --> 00:14:05,865
现在，为什么这项工作？

306
00:14:05,865 --> 00:14:07,010
样的，我欺骗在这里。

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

308
00:14:09,980 --> 00:14:13,680
它只是意味着你可以遍历
没有与我打扰数组

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

310
00:14:16,150 --> 00:14:21,350
词典当然是文件名，
像大或小，这两个

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

312
00:14:22,830 --> 00:14:26,715
文件是打开了文本的函数
文件，按行读取它的路线，

313
00:14:26,715 --> 00:14:29,840
你的双手背一个巨大的数组，
每个其元素是一个

314
00:14:29,840 --> 00:14:31,340
线从该文件。

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

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

317
00:14:37,080 --> 00:14:40,150
最后，词只是意味着这就是
可变我要去访问

318
00:14:40,150 --> 00:14:41,890
在这个循环中每次迭代。

319
00:14:41,890 --> 00:14:46,910
>> 因此，在短期，在这里单行指
开拓其名称是在文件

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

321
00:14:50,750 --> 00:14:54,290
一条线，存储在一个变量叫做字，
然后做一些事情的话。

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

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

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

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

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

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

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

329
00:15:08,920 --> 00:15:11,990
支架报价引文的东西，
不管这个词是。

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

331
00:15:15,200 --> 00:15:17,650
实际上是一个布尔值，隐式
或明确。

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

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

334
00:15:20,000 --> 00:15:23,150
>> 现在有几件事情
我就割这里的角落。

335
00:15:23,150 --> 00:15:27,720
从技术上讲，有将是一个
恼人的新生产线，/ n在年底

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

337
00:15:28,820 --> 00:15:31,770
所以我也许应该调用PHP函数
所谓的印章（），这将

338
00:15:31,770 --> 00:15:33,460
毫不夸张地砍了断。

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

340
00:15:35,020 --> 00:15:38,380
我也许应该增加尺寸上的每个
迭代，所以我跟踪

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

342
00:15:39,560 --> 00:15:43,180
坦率地说，这是一
PHP的愚蠢问题，如果你是

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

344
00:15:46,950 --> 00:15:51,670
所以，我要实际键入全球
$规模，全球$表，现在

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

346
00:15:52,690 --> 00:15:57,475
>> 所以不是那么简单过，但
大概花了比C时间少

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

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

349
00:15:58,730 --> 00:16:00,390
>> 所以，现在让我们做的检查（）函数。

350
00:16:00,390 --> 00:16:04,300
让我们来看看这至少拿了
几个小时就结束，它把我们的C。所以

351
00:16:04,300 --> 00:16:06,500
让我继续前进，并宣布
检查的功能。

352
00:16:06,500 --> 00:16:09,070
发生在说法的话，这是
从哪儿来的拼写。

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

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

355
00:16:18,400 --> 00:16:20,590
让我们来平衡我所有​​的括号 - 

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

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

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

359
00:16:28,460 --> 00:16:30,330
这是真正的硬
这项计划的一部分。

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

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

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

363
00:16:33,460 --> 00:16:34,520
>> 现在，为什么这工作？

364
00:16:34,520 --> 00:16:37,040
那么，一个我通过一个字，
它是一个字符串。

365
00:16:37,040 --> 00:16:41,400
二，我检查的哈希里面
表，谁就是所谓的$表。

366
00:16:41,400 --> 00:16:45,470
我迫使它通过调用为小写
一个函数的tolower（）的非常相似

367
00:16:45,470 --> 00:16:48,580
C，但这样做的整个单词，
不是一个单一的字符。

368
00:16:48,580 --> 00:16:52,680
如果它被设置，也就是说有
是一个值设置，换言之，

369
00:16:52,680 --> 00:16:54,880
如果这是真的，那么，
这是一个字。

370
00:16:54,880 --> 00:16:56,530
因为我把它放在那里与负载（）。

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

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

373
00:17:00,090 --> 00:17:03,570
功能尺寸（），我该怎么办呢？

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

375
00:17:05,230 --> 00:17:07,770
但我在技术上需要
这样做讨厌的事。

376
00:17:07,770 --> 00:17:10,640
而实际上听到了，我被切割
一个角落里太多了。

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

378
00:17:12,920 --> 00:17:16,260
>> 但话虽如此，卸载）。

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

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

381
00:17:20,500 --> 00:17:23,990
我想得到怎样实现卸载（）？

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

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

384
00:17:25,450 --> 00:17:28,900
>> 所以卸载（），内存管理是
完全采取为你照顾

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

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

387
00:17:32,600 --> 00:17:36,080
像你到底为什么我们花了过去
八加周的C写的

388
00:17:36,080 --> 00:17:41,030
显然很慢，真的时间
消费问题与数十小时

389
00:17:41,030 --> 00:17:42,530
根据我们的皮带工作？

390
00:17:42,530 --> 00:17:46,110
>> 那么，对于一件事，这可能工作
精致的小程序。

391
00:17:46,110 --> 00:17:47,840
这当然加速了我
开发时间。

392
00:17:47,840 --> 00:17:49,790
但是，让我们看看会发生什么
在现实世界中。

393
00:17:49,790 --> 00:17:52,370
>> 让我进入这个目录
在终端窗口。

394
00:17:52,370 --> 00:17:53,370
还有的拼写。

395
00:17:53,370 --> 00:17:56,570
并注意顺便说一句，你可能会
已遇到问题该设置

396
00:17:56,570 --> 00:17:58,190
六，问题设置7。

397
00:17:58,190 --> 00:18:01,610
你不必严格到
结束的PHP文件与书籍。php。

398
00:18:01,610 --> 00:18:05,250
如果把一条线一样，第一次以
极顶，这是一个特殊的行

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

400
00:18:10,980 --> 00:18:12,270
解释这个文件。

401
00:18:12,270 --> 00:18:15,410
所以现在没有人真正知道，
我运行一个PHP程序。

402
00:18:15,410 --> 00:18:19,860
我可以运行它，就好像它
被编译的东西在C

403
00:18:19,860 --> 00:18:20,650
>> 但这里的东西。

404
00:18:20,650 --> 00:18:21,600
其实，让我们再次做到这一点。

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

406
00:18:23,530 --> 00:18:25,390
还有的拼写。

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

408
00:18:26,720 --> 00:18:28,080
它得到了更快的这段时间。

409
00:18:28,080 --> 00:18:29,745
>> 现在，让我们进入PHP版本。

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

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

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

413
00:18:50,830 --> 00:18:53,285
但只是觉得多少时间
我保存于办公时间。

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

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

416
00:18:57,790 --> 00:19:01,020
>> 所以3.59秒，这实际上
听起来并不准确要么。

417
00:19:01,020 --> 00:19:03,710
那是因为长话短说，
当你打印出一个巨大的数额

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

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

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

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

422
00:19:17,620 --> 00:19:20,280
>> 那么，是这个价格来自哪里？

423
00:19:20,280 --> 00:19:21,790
为什么这么慢得多？

424
00:19:21,790 --> 00:19:24,220
PHP为什么表现如此糟糕？

425
00:19:24,220 --> 00:19:25,242
达尼埃尔？

426
00:19:25,242 --> 00:19:26,550
>> 观众：你不会是真的
使用一个哈希表。

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

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

429
00:19:28,760 --> 00:19:29,870
所以这是一个关联数组。

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

431
00:19:33,650 --> 00:19:39,520
引擎盖实现一个实际的哈希表
在像C或C + +。

432
00:19:39,520 --> 00:19:41,290
但是。

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

434
00:19:42,760 --> 00:19:44,010
>> 观众：[听不清]。

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

436
00:19:46,690 --> 00:19:47,080
>> 马兰大卫：是的。

437
00:19:47,080 --> 00:19:50,780
所以，每一个我现在写的功能 - 
实际上，你可以说，一旦更多的是

438
00:19:50,780 --> 00:19:51,480
大声一点好吗？

439
00:19:51,480 --> 00:19:54,509
>> 观众：每个函数
您收录了很多更全面

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

441
00:19:56,610 --> 00:19:57,550
>> 马兰大卫：所以这是非常真实的。

442
00:19:57,550 --> 00:20:01,490
还有很多更多的开销，我们是
不是真的由只注重看

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

444
00:20:03,730 --> 00:20:08,020
与此相反，有一个整体解释器
将在后台进行。

445
00:20:08,020 --> 00:20:12,040
事实上，当我运行这个程序时，它
没有运行编译零和壹

446
00:20:12,040 --> 00:20:14,290
专为我的英特尔CPU。

447
00:20:14,290 --> 00:20:19,270
相反，它是由线运行线路
PHP代码看起来完全

448
00:20:19,270 --> 00:20:20,350
像我们键入它。

449
00:20:20,350 --> 00:20:22,475
所以每当你使用
解释型语言，你

450
00:20:22,475 --> 00:20:23,850
其实也付出这个代价。

451
00:20:23,850 --> 00:20:27,010
这将需要一些时间来阅读
您的文件从上到下，从左

452
00:20:27,010 --> 00:20:30,740
右，然后执行各
线连连。

453
00:20:30,740 --> 00:20:34,250
>> 现在在现实中，尤其是在网络上，
实际上你可以加速这一进程

454
00:20:34,250 --> 00:20:38,660
通过缓存的结果
PHP代码被解释。

455
00:20:38,660 --> 00:20:41,640
而这是有道理的在网络上，因为
如果你还没有一个用户喜欢

456
00:20:41,640 --> 00:20:46,300
我在这里，但1,000或10,000个用户，然后
也许是第一次该文件是

457
00:20:46,300 --> 00:20:49,050
访问它的缓慢，但此后
它的速度更快。

458
00:20:49,050 --> 00:20:51,000
>> 然而，这也再一次是一个权衡。

459
00:20:51,000 --> 00:20:53,870
而对于一个类似的研究数据
设置，甚至一些大的像

460
00:20:53,870 --> 00:20:58,330
这一点，你的用户将最终
开始觉得放缓。

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

462
00:21:02,670 --> 00:21:06,710
坦率地说可能是你的语言
要达到解决问题的时

463
00:21:06,710 --> 00:21:08,200
到CS50后续。

464
00:21:08,200 --> 00:21:12,720
但要意识到你是多么真的
理所当然的引擎盖下

465
00:21:12,720 --> 00:21:15,910
真的那些过去的​​几个星期中的散列
表和树，并尝试，

466
00:21:15,910 --> 00:21:20,770
这是用来实际上最终
实现类的东西打开支架，

467
00:21:20,770 --> 00:21:24,200
方括号，这是我们现在可以
感激地想当然。

468
00:21:24,200 --> 00:21:26,360
>> 因此，让我们来看看现在
在本网站范围内。

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

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

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

472
00:21:36,210 --> 00:21:41,220
因此，为了在Web服务器上运行PHP
生成的东西，如HTML。

473
00:21:41,220 --> 00:21:44,540
>> 我们看了一眼$ _GET和$ _POST和
这就是自动用户

474
00:21:44,540 --> 00:21:49,100
输入端起来简单，如果你提交
形成在结尾的文件。关于php的网页

475
00:21:49,100 --> 00:21:50,460
服务器类的设备。

476
00:21:50,460 --> 00:21:53,310
但是，让我们简要地看
$ _COOKIE和$ _SESSION。

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

478
00:21:56,670 --> 00:21:58,220
使用网络？

479
00:21:58,220 --> 00:21:59,450
>> 观众：文件的计算机上。

480
00:21:59,450 --> 00:21:59,920
>> 马兰大卫：是的。

481
00:21:59,920 --> 00:22:03,500
它是在用户的计算机上的文件
用任何网站栽

482
00:22:03,500 --> 00:22:04,410
你碰巧访问。

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

484
00:22:07,334 --> 00:22:10,330
到google.com，当你去到几乎任何
网站在世界上的这些天，

485
00:22:10,330 --> 00:22:14,850
包括cs50.net，一个cookie种植
您的计算机上，这是

486
00:22:14,850 --> 00:22:19,800
无论是存储在RAM中的值的
计算机在您的浏览器的内存，或

487
00:22:19,800 --> 00:22:22,800
有时确实是一个文件存储
在您的硬盘驱动器。

488
00:22:22,800 --> 00:22:26,960
>> ，什么是通常存储在该文件中
是不是你的用户名，而不是你的

489
00:22:26,960 --> 00:22:31,060
密码，通常不是
敏感，除非该网站是不是这样

490
00:22:31,060 --> 00:22:35,040
用好他们的安全，而是
它是其中一个很大的唯一标识符

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

492
00:22:35,680 --> 00:22:38,920
这是一个大的随机数栽在您的
计算机，但你能想到的作为

493
00:22:38,920 --> 00:22:42,740
有点像从虚拟邮戳
一个俱乐部或者一些游乐园的

494
00:22:42,740 --> 00:22:47,160
使工作人员介绍，业主
服务，要记住你是谁。

495
00:22:47,160 --> 00:22:51,030
因此，如果大的随机数是一样
12345678，尽管这显然

496
00:22:51,030 --> 00:22:54,180
不要太随意，认为那是的
邮戳，当您访问

497
00:22:54,180 --> 00:22:57,930
facebook.com首次，它们
邮票上的手数。

498
00:22:57,930 --> 00:23:01,510
然后，因为你讲的HTTP，您
是一个浏览器，并因为Facebook

499
00:23:01,510 --> 00:23:06,440
显然可以使用相同的网络
服务器，该协议的HTTP说，

500
00:23:06,440 --> 00:23:09,930
任何时候你随后参观
facebook.com，无论是第二

501
00:23:09,930 --> 00:23:13,560
以后，一个小时后，甚至在第二天，
所以只要你有没有明确

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

503
00:23:17,050 --> 00:23:20,280
HTTP说，你应该出示您的
用手戳你每次

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

505
00:23:22,020 --> 00:23:24,390
>> Facebook上有什么不那么它们是
看那个邮戳及

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

507
00:23:26,850 --> 00:23:30,260
我不知道第一眼就这
是大卫·马兰在剑桥，

508
00:23:30,260 --> 00:23:34,690
马萨诸塞州，但他们可以检查自己
数据库和说，哦，这个人

509
00:23:34,690 --> 00:23:39,930
在其计算机上，我们种植123456789
是大卫·马兰剑桥，

510
00:23:39,930 --> 00:23:40,440
马萨诸塞州。

511
00:23:40,440 --> 00:23:46,000
让我们显示，用户随后他的个人资料
页面或他的新闻联播。

512
00:23:46,000 --> 00:23:49,660
>> 但是有一个问题就在这里，如果这
是如何在网上确实有效。

513
00:23:49,660 --> 00:23:51,390
让我们来看看一个简单的例子。

514
00:23:51,390 --> 00:23:55,190
让我们真正去说facebook.com。

515
00:23:55,190 --> 00:23:58,130
但在此之前，我们可以去那里，让
我去进取，不断开拓Chrome的

516
00:23:58,130 --> 00:23:59,790
检查到这里。

517
00:23:59,790 --> 00:24:01,140
让我看看网络选项卡。

518
00:24:01,140 --> 00:24:06,020
现在，让我们继续前进，键入
在https://facebook.com。

519
00:24:06,020 --> 00:24:09,410
而且我这样做，让我们看不到
所有这些重定向和浪费

520
00:24:09,410 --> 00:24:10,660
时间翻翻那些。

521
00:24:10,660 --> 00:24:12,690
让我回车。

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

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

524
00:24:14,580 --> 00:24:15,640
有来自Facebook的。

525
00:24:15,640 --> 00:24:16,930
还有一大堆的文件。

526
00:24:16,930 --> 00:24:19,290
在这里，我每提
等待最后一次，这是

527
00:24:19,290 --> 00:24:21,240
大量的HTTP请求。

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

529
00:24:23,700 --> 00:24:26,420
>> 因此，让我们在这里向下滚动，并
我会放大，在第二。

530
00:24:26,420 --> 00:24:29,090
这将是一种
一个烂摊子，但让我们来看看。

531
00:24:29,090 --> 00:24:31,660
Facebook正在向我们发送
一大堆的东西。

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

533
00:24:33,490 --> 00:24:37,880
他们种植不是一个，而是四个
手邮票到这里我的手。

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

535
00:24:40,400 --> 00:24:44,030
而且有一些功能在这里。

536
00:24:44,030 --> 00:24:46,170
所有的人提一些
那种过期的。

537
00:24:46,170 --> 00:24:50,090
它看起来像Facebook希望
记住我，直到2015年。

538
00:24:50,090 --> 00:24:53,670
所以这是大概的时间由
我必须或注销他们就会

539
00:24:53,670 --> 00:24:55,710
自动假设我
不回来了。

540
00:24:55,710 --> 00:24:57,840
所以这实际上是一个体面的
量的时间。

541
00:24:57,840 --> 00:24:59,170
>> 另外还有一些其他的
事情怎么回事。

542
00:24:59,170 --> 00:25:03,036
此cookie似乎是强行
说是在1970年到期删除

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

544
00:25:04,460 --> 00:25:06,510
因此，浏览器只是将
假设好了，这就像

545
00:25:06,510 --> 00:25:07,910
洗完手的邮票。

546
00:25:07,910 --> 00:25:11,240
>> 但现在，当我的浏览器，使
后续请求 - 

547
00:25:11,240 --> 00:25:14,340
让我继续前进，这样做
再次重装。

548
00:25:14,340 --> 00:25:18,170
现在，让我向后滚动到
顶请求和下井

549
00:25:18,170 --> 00:25:20,760
在这里，请求头。

550
00:25:20,760 --> 00:25:21,390
注意到这一点。

551
00:25:21,390 --> 00:25:25,280
所以，现在我下不响应头是，
但发现它说请求头。

552
00:25:25,280 --> 00:25:29,220
并且发现我的浏览器的一部分
打重装后其请求有

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

554
00:25:32,780 --> 00:25:34,670
没有设置cookie的，但是饼干。

555
00:25:34,670 --> 00:25:38,750
因此，这是该行，HTTP标头等等
可以说，在我的浏览器排序

556
00:25:38,750 --> 00:25:43,340
无我知道它呈现
我的手对Facebook的检查。

557
00:25:43,340 --> 00:25:46,020
>> 所以，这些cookie可以
然后，用什么？

558
00:25:46,020 --> 00:25:49,420
要记住你是谁，或记得如何
你去过很多次出现，或

559
00:25:49,420 --> 00:25:50,280
真的什么。

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

561
00:25:52,742 --> 00:25:53,780
让我放大字体。

562
00:25:53,780 --> 00:25:58,380
而我每次重新加载该页面，通知时间
它的回忆多少次

563
00:25:58,380 --> 00:25:59,250
我去过那儿。

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

565
00:26:00,570 --> 00:26:03,140
让我们只需关闭该选项卡，
现在让我们回到

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

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

568
00:26:08,970 --> 00:26:10,960
它仍然记得，即使
虽然我关闭的选项卡。

569
00:26:10,960 --> 00:26:14,010
坦率地说，如果我关闭浏览器，
如果实施正确的方式，我

570
00:26:14,010 --> 00:26:18,950
还记得，这是用户
他或她是谁是第一次，并且

571
00:26:18,950 --> 00:26:22,840
只有一次我进入Chrome的菜单，
在这里在这里，去

572
00:26:22,840 --> 00:26:25,990
历史，并点击清除浏览数据，
因为一些你可能在

573
00:26:25,990 --> 00:26:33,050
过去，只有这样，你的cookies
实际上网络中被删除

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

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

576
00:26:35,340 --> 00:26:37,080
让我们在这里收起来的gedit。

577
00:26:37,080 --> 00:26:38,910
如果我们现在去这个文件。

578
00:26:38,910 --> 00:26:44,210
让我进入我们
虚拟主机/本地主机/大众，让我做

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

580
00:26:46,340 --> 00:26:48,350
请注意，这是一个相当
简单的程序。

581
00:26:48,350 --> 00:26:50,250
这是一个相当简单的网站。

582
00:26:50,250 --> 00:26:51,770
>> 这样的文件的顶部
只是意见。

583
00:26:51,770 --> 00:26:54,930
但这里有一个新的行，你可以
已对设置7已经看到，

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

585
00:26:56,000 --> 00:27:00,380
这是一行PHP代码
主要用来告诉网络服务器，使

586
00:27:00,380 --> 00:27:03,400
一定要杜绝的双手，使
一定要检查手的邮票。

587
00:27:03,400 --> 00:27:06,810
这是所有行的作用，以及它
完成所有的过程我们。

588
00:27:06,810 --> 00:27:09,510
然后注意到我刚刚拿到了
两个分支在这里。

589
00:27:09,510 --> 00:27:14,150
如果这里面的关键计数器
所谓特殊的全局变量

590
00:27:14,150 --> 00:27:18,010
$ _SESSION设置 - 换句话说，
如果有一定的价值存在 - 

591
00:27:18,010 --> 00:27:22,440
让我们得到它，并将其存储在本地
变量$计数器。

592
00:27:22,440 --> 00:27:27,000
否则，让我们分配$计数器
的默认值0。

593
00:27:27,000 --> 00:27:30,320
>> 现在，这里是PHP的一个方面，这是
既是祝福，也是诅咒。

594
00:27:30,320 --> 00:27:32,080
PHP是有点草率。

595
00:27:32,080 --> 00:27:35,160
因此而在C中，会是什么
计数器的范围已经

596
00:27:35,160 --> 00:27:36,725
无论是在这里还是在这里？

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

598
00:27:39,270 --> 00:27:41,690
>> 它会被限制
那些大括号。

599
00:27:41,690 --> 00:27:42,090
你猜怎么着？

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

601
00:27:46,920 --> 00:27:49,120
这里，这里，和
甚至楼下。

602
00:27:49,120 --> 00:27:52,400
所以我说，这是在这个意义上的祝福
你不必想的那么

603
00:27:52,400 --> 00:27:54,070
很难，因为我们做星期前。

604
00:27:54,070 --> 00:27:56,880
但它也有点在诅咒
无论您在使用变量

605
00:27:56,880 --> 00:28:00,020
PHP中，至少在这样的程序中，
它的全局访问

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

607
00:28:01,170 --> 00:28:06,130
所以，你必须记住，现在
您的变量不能是不确定的。

608
00:28:06,130 --> 00:28:07,640
你可能已经在其他地方定义它们。

609
00:28:07,640 --> 00:28:09,460
>> 但我怎么做最终？

610
00:28:09,460 --> 00:28:13,160
我要存储的全球内部
变量的值

611
00:28:13,160 --> 00:28:17,060
计数器键的结果
做计数器加1。

612
00:28:17,060 --> 00:28:18,910
所以这只是算术
该做

613
00:28:18,910 --> 00:28:20,590
递增的计数器。

614
00:28:20,590 --> 00:28:24,850
而事实上，我存储了
价值早在这里是指

615
00:28:24,850 --> 00:28:29,970
数据库基本更新到
记住用户123456789已

616
00:28:29,970 --> 00:28:31,010
这里两次。

617
00:28:31,010 --> 00:28:33,780
当我下一次再这样做我
重新加载页面，它会检查

618
00:28:33,780 --> 00:28:36,710
我的手印章，说，哦，
用户123456789已现

619
00:28:36,710 --> 00:28:38,410
来过这里三次。

620
00:28:38,410 --> 00:28:43,390
>> 还等什么PHP和类似的语言
这样做对我们来说是他们盘算

621
00:28:43,390 --> 00:28:47,720
如何以及在何处以及多长时间
存储在这个特殊值

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

623
00:28:48,830 --> 00:28:52,750
而这个超级全局下一次我
访问的页面是有点神奇

624
00:28:52,750 --> 00:28:57,440
预填充，填充值
在那里你访问的最后时间，

625
00:28:57,440 --> 00:29:02,310
这是否是在一秒钟前，一个星期
前，或在2013年，我们现在谈

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

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

628
00:29:07,600 --> 00:29:08,850
>> 观众：[听不清]。

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

630
00:29:11,900 --> 00:29:15,760
>> DAVID马兰：PHP中的变量是
本质上始终是全局的，除非你

631
00:29:15,760 --> 00:29:18,400
在函数中声明它们，
然后他们是本地的

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

633
00:29:19,420 --> 00:29:22,300
但是因为我没有写任何
功能，他们现在有效

634
00:29:22,300 --> 00:29:25,090
全球在我这里整个文件。

635
00:29:25,090 --> 00:29:26,040
>> 观众：是否有办法
让他们本地的？

636
00:29:26,040 --> 00:29:28,470
>> 马兰国宝：有没有
方法，使他们本地的？

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

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

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

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

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

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

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

644
00:29:42,380 --> 00:29:43,380
良好的测验问题。

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

646
00:29:43,930 --> 00:29:47,760
>> 所以最后，页面本身是
其实很简单。

647
00:29:47,760 --> 00:29:51,470
请注意，一旦我退出PHP模式，召回
所有的这些东西下来

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

649
00:29:53,700 --> 00:29:57,050
这是很好的，因为我也想送
一些HTML，但我确实希望用户

650
00:29:57,050 --> 00:29:59,140
动态更新HTML。

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

652
00:30:03,930 --> 00:30:07,730
模式，采用开放式支架问号
等号，然后输出值

653
00:30:07,730 --> 00:30:08,650
的计数器。

654
00:30:08,650 --> 00:30:12,360
>> 或者，如果这看起来有点神秘，这
等号，其实只是一些

655
00:30:12,360 --> 00:30:16,190
语法糖这
的printf（$计数器）。

656
00:30:16,190 --> 00:30:19,160
但坦率地说，这只是一点点丑
和一点点讨厌的类型。

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

658
00:30:23,660 --> 00:30:25,450
简洁地以同样的方式。

659
00:30:25,450 --> 00:30:26,940
>> 那么什么是底下怎么回事
油烟机？

660
00:30:26,940 --> 00:30:31,210
让我们来快速浏览一下网络
选项​​卡这里counter.php。

661
00:30:31,210 --> 00:30:35,090
让我继续前进，第一
让我们来清理cookies。

662
00:30:35,090 --> 00:30:38,670
因为让我们清除浏览数据
刚开始的时候。

663
00:30:38,670 --> 00:30:39,680
现在，让我们回到了这里。

664
00:30:39,680 --> 00:30:41,340
现在让我们来重新加载页面。

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

666
00:30:42,170 --> 00:30:44,810
因为我的手的邮票已经洗净，
我现在得到一个新的cookie。

667
00:30:44,810 --> 00:30:48,780
>> 事实上，如果我看网络选项卡，
看响应头，另行通知

668
00:30:48,780 --> 00:30:51,960
该设备是给我
他的名字是有点一个cookie

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

670
00:30:55,820 --> 00:30:58,440
并且它送我这真的
大随机数。

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

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

673
00:31:00,390 --> 00:31:03,600
这是某种字母数字字符串，
但据推测这是随机的。

674
00:31:03,600 --> 00:31:06,830
那就是邮戳所以
说话那我指的是。

675
00:31:06,830 --> 00:31:11,960
>> 同时，如果我重装一下，然后
看看这个第二行第二个我

676
00:31:11,960 --> 00:31:17,600
要求，现在通知我的要求
头文件包含PHPSESSID等于这一点，

677
00:31:17,600 --> 00:31:19,390
没有设置cookie的，但只是饼干。

678
00:31:19,390 --> 00:31:22,950
这是我的浏览器的演示文稿
我手里的邮票。

679
00:31:22,950 --> 00:31:28,820
>> 所以，现在作为传情，我们将讨论更多
这在一个星期左右，但

680
00:31:28,820 --> 00:31:31,590
以什么方式这使你
脆弱的，你的Facebook帐户

681
00:31:31,590 --> 00:31:34,137
脆弱的，和其他类似
账户脆弱？

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

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

684
00:31:36,750 --> 00:31:39,920
我是说真的，就像你们中的一些
可能试图在像一个俱乐部或

685
00:31:39,920 --> 00:31:44,030
游乐园，如果你尝试的东西
这样的复制邮票，虽然

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

687
00:31:47,560 --> 00:31:53,250
自己的，如果它实际上看起来确实
同样，123456789，那么网络

688
00:31:53,250 --> 00:31:57,980
服务器显然只是要
相信，该用户就是你。

689
00:31:57,980 --> 00:32:01,450
>> 这确实是一个根本性的
威胁你使用cookies的任何时间

690
00:32:01,450 --> 00:32:05,420
因为如果有人只是欺骗所以
说出你的cookie，计算出它是什么

691
00:32:05,420 --> 00:32:08,660
是，无论是真正的将其复制
通过看你的电脑

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

693
00:32:09,890 --> 00:32:14,520
大卫的cookie是JJ3JIK等等，
然后他们够聪明，知道

694
00:32:14,520 --> 00:32:18,080
怎么样的手动发送
从浏览器或一个cookie

695
00:32:18,080 --> 00:32:22,350
计划他们写，他们可以完全
登录到一个网站，你。

696
00:32:22,350 --> 00:32:28,560
它是不是很难假装
别人，除非我们重新对集

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

698
00:32:30,790 --> 00:32:32,065
>> 观众：密码学。

699
00:32:32,065 --> 00:32:33,860
>> DAVID马兰：有点
密码学位。

700
00:32:33,860 --> 00:32:36,550
简单的密码系统，至少在
标准版，但加密

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

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

703
00:32:37,410 --> 00:32:41,440
所以，事实证明，如果你加密所有的
这些头文件使用的东西，你

704
00:32:41,440 --> 00:32:48,770
现在可能知道作为SSL的详细亲切，
安全套接字层，或https://开头的URL，

705
00:32:48,770 --> 00:32:51,890
那么所有的这些事情，我们一直
瞥了一眼实际上是加密的，

706
00:32:51,890 --> 00:32:54,800
这意味着它就像你
无法读取邮戳。

707
00:32:54,800 --> 00:32:59,350
只有facebook.com可以，或者google.com，
或者在这种情况下，该设备可以

708
00:32:59,350 --> 00:33:00,550
阅读邮戳。

709
00:33:00,550 --> 00:33:04,020
>> 可悲的是，虽然，并再次，这是
太合适了NSA的东西

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

711
00:33:06,410 --> 00:33:09,850
它实际上并不难
即使破解了加密。

712
00:33:09,850 --> 00:33:12,040
没那么通过破解加密了，
但通过欺骗的

713
00:33:12,040 --> 00:33:15,720
浏览器到解密
数据过早。

714
00:33:15,720 --> 00:33:17,880
但同样，我们会挑逗你
与之前长。

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

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

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

718
00:33:23,760 --> 00:33:27,910
因此，如果没有这个现在离开我们呢？

719
00:33:27,910 --> 00:33:29,010
那么，让我们做到这一点。

720
00:33:29,010 --> 00:33:31,790
让我们继续前进，并采取快速
传情之前，我们休息一下。

721
00:33:31,790 --> 00:33:33,790
我想我们会一直这样时间长一点
今天，但我们要潜入

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

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

724
00:33:38,950 --> 00:33:41,520
>> 因此SQL，我们开始谈论
曾经如此短暂最后一次。

725
00:33:41,520 --> 00:33:44,670
你会真正得到你的手脏
有一些它在对设置7。

726
00:33:44,670 --> 00:33:46,480
和通俗地说，这是什么SQL  - 

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

728
00:33:47,110 --> 00:33:49,850
为你做点什么？

729
00:33:49,850 --> 00:33:50,310
这是什么？

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

731
00:33:51,546 --> 00:33:53,240
>> 观众：让您存取数据。

732
00:33:53,240 --> 00:33:53,360
>> 马兰大卫：是的。

733
00:33:53,360 --> 00:33:55,120
它让你的数据访问
在数据库中。

734
00:33:55,120 --> 00:33:56,710
结构化查询语言。

735
00:33:56,710 --> 00:33:59,890
这实质上是一个
编程语言。

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

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

738
00:34:04,710 --> 00:34:06,870
他们被称为存储
在SQL过程。

739
00:34:06,870 --> 00:34:09,860
但我们会保持它相当简单，只是
使用它的一些基本操作

740
00:34:09,860 --> 00:34:14,320
如选择数据，插入数据，
更新数据和删除数据。

741
00:34:14,320 --> 00:34:17,400
>> 而你真的可以想到一个数据库，
就像一个SQL数据库，只需

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

743
00:34:18,800 --> 00:34:21,989
因为SQL是指一个关系
数据库，其中

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

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

746
00:34:24,739 --> 00:34:27,929
所以，只要你可以把电子表格
这样或谷歌文档，

747
00:34:27,929 --> 00:34:32,460
你可以放入一个SQL数据库
通过声明一个表。

748
00:34:32,460 --> 00:34:34,800
>> 现在，你如何实际访问
这些信息？

749
00:34:34,800 --> 00:34:38,239
那么，与命令或
查询是这样的。

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

751
00:34:40,199 --> 00:34:44,489
并且在大多数情况下，这些都是
你需要到四只成份

752
00:34:44,489 --> 00:34:47,370
做的东西很有力
在问题设置7。

753
00:34:47,370 --> 00:34:49,940
>> 现在又回到了一天，你居然会
在一个数据库交互

754
00:34:49,940 --> 00:34:52,730
黑色和白色终端窗口
闪烁的提示是这样的。

755
00:34:52,730 --> 00:34:56,370
而我们在运行数据库
器具被称为MySQL的，这是

756
00:34:56,370 --> 00:34:58,560
自由和开放源码的数据库引擎。

757
00:34:58,560 --> 00:35:02,240
如果谷歌和阅读维基百科
的文章，你就会知道这个名字是

758
00:35:02,240 --> 00:35:05,060
对于一些有点过渡
Linux版本。

759
00:35:05,060 --> 00:35:10,460
玛丽亚数据库实际上是一个
叉这么说的MySQL。

760
00:35:10,460 --> 00:35:12,740
>> 长话短说，甲骨文收购了MySQL。

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

762
00:35:13,870 --> 00:35:17,010
人们一直担心，它会
不再停留相当开源，

763
00:35:17,010 --> 00:35:20,930
所以这是MySQL的只是一个副本，这是
还是免费的，还是开源的，

764
00:35:20,930 --> 00:35:23,550
默认安装在Fedora Linux系统。

765
00:35:23,550 --> 00:35:26,130
>> 但是，这是一种在痛
脖子上结识一

766
00:35:26,130 --> 00:35:27,310
数据库这种方式。

767
00:35:27,310 --> 00:35:30,560
所以我们在CS50包括家电
一个免费的开源工具，称为

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

769
00:35:31,700 --> 00:35:33,940
仅仅是巧合
它是用PHP编写的。

770
00:35:33,940 --> 00:35:36,450
有没有根本
需要为PHP在这里。

771
00:35:36,450 --> 00:35:40,090
但是这仅仅是一个基于Web的工具，
我们免费下载，安装在

772
00:35:40,090 --> 00:35:43,850
家电，这使我们能够有一个
与该图形用户界面

773
00:35:43,850 --> 00:35:48,610
探索对集合7个数据库
要创建新的数据库，

774
00:35:48,610 --> 00:35:51,980
说为自己最后的项目，如果你愿意
像，并最终创造

775
00:35:51,980 --> 00:35:55,900
动态网站像CS50财经
使您可以查询数据和

776
00:35:55,900 --> 00:35:58,140
动态更新数据。

777
00:35:58,140 --> 00:36:01,420
>> 你不会有只使用
一个简单的文本文件或CSV。

778
00:36:01,420 --> 00:36:05,950
实际上，你可以使用智能资料库
程序使您可以执行更多

779
00:36:05,950 --> 00:36:10,240
不仅仅是阅读复杂的查询
通过线性的一切。

780
00:36:10,240 --> 00:36:14,150
>> 因此，例如，这就是我们给
你对P-集合7个盒子。

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

782
00:36:18,280 --> 00:36:21,450
用户名，其中一个是散，
而另一个是识别码。

783
00:36:21,450 --> 00:36:26,200
>> 但有趣的东西，只是为了
这里梳理出一个念头，用户名

784
00:36:26,200 --> 00:36:29,270
大概是已经独一无二的，对不对？

785
00:36:29,270 --> 00:36:31,190
我的意思是，几乎所有的网站，如果
你有一个用户名，有

786
00:36:31,190 --> 00:36:32,370
不能由两个凯撒。

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

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

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

790
00:36:35,600 --> 00:36:38,610
否则，他们不知道哪个
jharvard它实际上是。

791
00:36:38,610 --> 00:36:42,710
所以，可能是什么动机也
具有在左边的第三列

792
00:36:42,710 --> 00:36:46,970
还有所谓的ID，它看起来像一个
数字是同样独特之处？

793
00:36:46,970 --> 00:36:51,300
感觉有点多余
我第一眼。

794
00:36:51,300 --> 00:36:54,910
为什么它可能引人注目的有
不仅是唯一的用户名，

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

796
00:36:56,837 --> 00:36:59,460
>> 观众：他们可以有
相同的密码。

797
00:36:59,460 --> 00:37:01,720
>> DAVID马兰：人们可能有
相同的密码，确保万无一失。

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

799
00:37:03,900 --> 00:37:08,270
但是，如果他们有这样的唯一的用户名，我
会说，其实并不

800
00:37:08,270 --> 00:37:11,630
事，因为如果他们在键入他们的
用户名，我只需要检查他们的

801
00:37:11,630 --> 00:37:15,060
密码，其自己的哈希值。

802
00:37:15,060 --> 00:37:15,970
否则为什么？

803
00:37:15,970 --> 00:37:17,950
>> 观众：更快速的搜寻。

804
00:37:17,950 --> 00:37:18,680
>> DAVID马兰：更快速的搜寻。

805
00:37:18,680 --> 00:37:19,548
为什么呢？

806
00:37:19,548 --> 00:37:21,460
>> 观众：ID是只有一个。

807
00:37:21,460 --> 00:37:24,040
>> DAVID马兰：ID是一个字符，
或者更确切地说，它是一个数字，

808
00:37:24,040 --> 00:37:26,910
因此它可能是32位
或者类似的东西。

809
00:37:26,910 --> 00:37:30,270
而用户名，显然杰森
赫塞豪恩的上升有几分

810
00:37:30,270 --> 00:37:33,900
可笑的长，而且它要
带我去了很多时间转换为字符串

811
00:37:33,900 --> 00:37:40,910
比较H-I-R-S-C-H-H-O-R-N，也许
一/ 0或类似的东西，为了

812
00:37:40,910 --> 00:37:45,100
查找杰森，而不是仅仅
说给我的用户排名第二。

813
00:37:45,100 --> 00:37:46,510
这是32位。

814
00:37:46,510 --> 00:37:48,550
它是一个单一的诠释
你要比较。

815
00:37:48,550 --> 00:37:52,150
事实上，这也正是为什么数据库
倾向于分配唯一的ID来

816
00:37:52,150 --> 00:37:53,710
列在其中。

817
00:37:53,710 --> 00:37:56,280
>> 现在，还有什么其他的数据类型是有
除了INT和明显

818
00:37:56,280 --> 00:37:57,160
像这样的字符串？

819
00:37:57,160 --> 00:37:59,700
嗯，更正确，
SQL数据库，如

820
00:37:59,700 --> 00:38:02,060
MySQL中，有煤焦领域。

821
00:38:02,060 --> 00:38:05,320
和char有点误导
不是单一的CHAR。

822
00:38:05,320 --> 00:38:10,290
在MySQL数据库中的CHAR字段是
一个或多个字符，但它是一个

823
00:38:10,290 --> 00:38:11,780
个字符的固定数目。

824
00:38:11,780 --> 00:38:15,710
>> 因此，举例来说，如果我去到
phpMyAdmin的，你可能已经或

825
00:38:15,710 --> 00:38:21,340
很快将问题设置7，和我一起去
我的数据库，只是为了好玩，

826
00:38:21,340 --> 00:38:25,700
让我们创建一个新的表称为
测试只有两列。

827
00:38:25,700 --> 00:38:27,160
然后我就单击Go。

828
00:38:27,160 --> 00:38:30,070
而这将成为相当熟悉，
尤其是当你鼓捣

829
00:38:30,070 --> 00:38:31,130
围绕在你自己的。

830
00:38:31,130 --> 00:38:34,140
在这里，我可以键入ID来创建
INT类型的新表。

831
00:38:34,140 --> 00:38:37,770
但在这里我可以键入用户名
重新创建表的前面。

832
00:38:37,770 --> 00:38:40,700
并注意我有一大堆
的类型可供选择。

833
00:38:40,700 --> 00:38:43,610
>> 而这也是为什么phpMyAdmin的
是种不错的。

834
00:38:43,610 --> 00:38:46,770
这是一种自我的教学中，你
能正中下怀点，并单击，

835
00:38:46,770 --> 00:38:50,730
看下拉菜单，并从推断
什么权力的SQL给你。

836
00:38:50,730 --> 00:38:54,090
>> 事实上，如果让我选择CHAR，然后我
必须指定长度，或如何

837
00:38:54,090 --> 00:38:55,940
许多值，有多少个字符。

838
00:38:55,940 --> 00:39:00,090
所以，很常见的值是一样的东西
255，但是这是一个有点长。

839
00:39:00,090 --> 00:39:02,250
通常是八输入用户名。

840
00:39:02,250 --> 00:39:03,590
但是，这是一个有点小的这些天。

841
00:39:03,590 --> 00:39:05,430
因此，这是一个设计决策。

842
00:39:05,430 --> 00:39:08,630
它是最多8个字符，
32，255，1,000？

843
00:39:08,630 --> 00:39:09,830
这真的取决于你。

844
00:39:09,830 --> 00:39:12,350
但一个CHAR字段是一个定数。

845
00:39:12,350 --> 00:39:16,420
因此，选择太少，你是那种
如果你想有一个较长的用户名搞砸。

846
00:39:16,420 --> 00:39:19,132
选择太多，什么是
坏处？

847
00:39:19,132 --> 00:39:20,820
>> 观众：[听不清]。

848
00:39:20,820 --> 00:39:21,620
>> DAVID马兰：这是一种浪费。

849
00:39:21,620 --> 00:39:24,835
就像在C，如果你有一个更大的
的内存块比你需要的，你

850
00:39:24,835 --> 00:39:27,190
只是在浪费时间和浪费的空间。

851
00:39:27,190 --> 00:39:31,430
因此，作为一种替代，存在着
VARCHAR，其通过解决了这个问题

852
00:39:31,430 --> 00:39:36,390
治疗长度不为固定长度，
但作为一个最大长度，并使用

853
00:39:36,390 --> 00:39:40,990
可变数目的char，然后
往往只使用尽可能多的在字符作为你

854
00:39:40,990 --> 00:39:42,710
实际需要。

855
00:39:42,710 --> 00:39:43,670
这听起来很完美。

856
00:39:43,670 --> 00:39:45,640
>> 我们为什么不摆脱
CHAR数据类型呢？

857
00:39:45,640 --> 00:39:48,500
可能是什么的缺点
使用VARCHAR处理，这听起来

858
00:39:48,500 --> 00:39:51,644
就像是一个不错的双赢？

859
00:39:51,644 --> 00:39:52,596
是吗？

860
00:39:52,596 --> 00:39:53,846
>> 观众：[听不清]。

861
00:39:53,846 --> 00:39:57,360

862
00:39:57,360 --> 00:39:57,790
>> DAVID MALAN：好，好。

863
00:39:57,790 --> 00:40:01,101
所以，如果所有的数据都是一样的
长，有什么顾虑？

864
00:40:01,101 --> 00:40:05,250
>> 观众：因为你在浪费
告诉他们所有数据。

865
00:40:05,250 --> 00:40:09,060
>> 马兰大卫：所以，如果您的所有数据是
相同的长度，不过，我认为

866
00:40:09,060 --> 00:40:12,300
该指定的最大长度
在VARCHAR是没有不同

867
00:40:12,300 --> 00:40:16,070
在指定的CHAR固定长度的，如果
你知道这个数字在前进。

868
00:40:16,070 --> 00:40:19,500
但现在却是，我会有点
从答案中提取的现实

869
00:40:19,500 --> 00:40:22,610
这还是有一个最大，这可能
是恼人的，特别是如果你

870
00:40:22,610 --> 00:40:25,920
遇到一个人的名字那
特别长，你没

871
00:40:25,920 --> 00:40:26,860
预期。

872
00:40:26,860 --> 00:40:31,420
而且这也有点低效率
实际上在VARCHAR的搜索为

873
00:40:31,420 --> 00:40:35,620
相对于搜索在字符，尤其是
对于有大量和长期的表

874
00:40:35,620 --> 00:40:36,510
大量数据。

875
00:40:36,510 --> 00:40:40,060
所以在这里也一样，主题又是
没有明显的选择。

876
00:40:40,060 --> 00:40:42,870
>> 所以才给你其他的感觉
可能会感兴趣的数据类型

877
00:40:42,870 --> 00:40:45,400
无论是对设置7或
未来，还有诠释。

878
00:40:45,400 --> 00:40:47,270
有BIGINT，这
就像很久很久。

879
00:40:47,270 --> 00:40:48,880
它往往是64位。

880
00:40:48,880 --> 00:40:51,640
有小数，你会看到在
问题集，这是一个非常

881
00:40:51,640 --> 00:40:55,300
到清洁的问题，我们的答案
与浮动和浮动遇到

882
00:40:55,300 --> 00:40:55,980
点不精确。

883
00:40:55,980 --> 00:40:57,390
然后还有DATETIME。

884
00:40:57,390 --> 00:41:01,530
有字面上，有一个数据类型
看起来就像是一年，一个月，一天，

885
00:41:01,530 --> 00:41:03,730
和一个小时，分钟和秒。

886
00:41:03,730 --> 00:41:07,470
>> 但是，SQL数据库也有
东西我们称之为索引。

887
00:41:07,470 --> 00:41:11,630
和索引的东西，你
指定创建表时

888
00:41:11,630 --> 00:41:15,720
让搜索和其他操作
更有效。

889
00:41:15,720 --> 00:41:18,550
具体来说，有一种叫
主索引，你可以

890
00:41:18,550 --> 00:41:19,440
声明如下。

891
00:41:19,440 --> 00:41:22,330
>> 我们用这样做对你
用户表，我们给你。

892
00:41:22,330 --> 00:41:26,160
但是请注意，如果我手动重新创建
用户表这里给

893
00:41:26,160 --> 00:41:27,110
它的用户的名称。

894
00:41:27,110 --> 00:41:28,125
我已经指定ID。

895
00:41:28,125 --> 00:41:29,330
我指定的诠释。

896
00:41:29,330 --> 00:41:32,000
我指定的用户名与
最多32个字符。

897
00:41:32,000 --> 00:41:36,140
但是，如果我们继续滚动在这个相当
宽的窗口，通知有一个

898
00:41:36,140 --> 00:41:38,260
一堆其他的东西，我可以指定。

899
00:41:38,260 --> 00:41:40,950
>> 一，我可以指定属性
就像，你知道吗，这

900
00:41:40,950 --> 00:41:42,190
诠释应该是无符号的。

901
00:41:42,190 --> 00:41:45,510
我不想负数，
所以我们让它无符号。

902
00:41:45,510 --> 00:41:48,660
null是不是与此有关，因为
我也希望每个用户

903
00:41:48,660 --> 00:41:49,640
有一个唯一的号码。

904
00:41:49,640 --> 00:41:50,830
我不希望它为null。

905
00:41:50,830 --> 00:41:52,330
>> 但是，这是有趣的。

906
00:41:52,330 --> 00:41:57,780
我可以指定ID是要么
该数据库的主键，或者它

907
00:41:57,780 --> 00:42:00,620
独特的，或者它的索引或全文。

908
00:42:00,620 --> 00:42:05,630
因此，对于今天的目的，很长的故事
总之，主要手段，这应

909
00:42:05,630 --> 00:42:10,570
是从概念上和技术上
我们用来唯一领域

910
00:42:10,570 --> 00:42:12,140
识别用户。

911
00:42:12,140 --> 00:42:16,140
>> 因此，当我们仰望的用户，这是排序
的承诺，主要是通过找一找

912
00:42:16,140 --> 00:42:17,370
那唯一的标识符。

913
00:42:17,370 --> 00:42:21,930
并且数据库将确保，如果你
有一个用户号码3，你不能

914
00:42:21,930 --> 00:42:25,400
物理插入另一个用户
与相同数目3。

915
00:42:25,400 --> 00:42:28,380
该数据库将刚刚拒绝
保存更改。

916
00:42:28,380 --> 00:42:32,310
这是一件好事，因为你可以
保护自己免受自己。自我

917
00:42:32,310 --> 00:42:34,270
>> 另外，对于用户名。

918
00:42:34,270 --> 00:42:37,670
因此，在第二排，召回，
是用户名字段。

919
00:42:37,670 --> 00:42:41,860
所以在这里，第二行是用户名，
因为我们没有在最左边那里。

920
00:42:41,860 --> 00:42:43,940
>> 那么还有什么我可能要指定？

921
00:42:43,940 --> 00:42:47,840
我不能，根据SQL语句，
指定两个主键。

922
00:42:47,840 --> 00:42:50,750
您可以指定一个联合密钥，你
看着这两个领域，但他们不能

923
00:42:50,750 --> 00:42:52,260
分别是主键。

924
00:42:52,260 --> 00:42:54,750
所以这是不可能的。

925
00:42:54,750 --> 00:42:56,040
所以，这可能我想选择？

926
00:42:56,040 --> 00:42:59,710
>> 好吧，独特的是在精神上有类似
在那里你指定这个主键

927
00:42:59,710 --> 00:43:03,570
域应是唯一的，但它的
不会是一

928
00:43:03,570 --> 00:43:04,410
我用所有的时间。

929
00:43:04,410 --> 00:43:08,450
而且我们不打算使用这一个所有
时间为的是什么了吗？

930
00:43:08,450 --> 00:43:10,490
它的速度较慢，如果可能
这是一个漫长的用户名。

931
00:43:10,490 --> 00:43:11,740
这只是在浪费时间。

932
00:43:11,740 --> 00:43:16,140
>> 指数，同时，指定它的
不会是唯一的，但我想

933
00:43:16,140 --> 00:43:19,470
你的工作你的魔法下的
油烟机，使其更快地为我

934
00:43:19,470 --> 00:43:21,420
搜索这个领域。

935
00:43:21,420 --> 00:43:23,320
因此，这可能不是与此有关。

936
00:43:23,320 --> 00:43:26,500
对于用户名，我要说的却是
独特之处是一个很好的答案。

937
00:43:26,500 --> 00:43:31,200
但是假设我们做了更多用户
不仅仅是用户名有意思，

938
00:43:31,200 --> 00:43:32,430
哈希，和身份证号码。

939
00:43:32,430 --> 00:43:33,860
如果我们给了人们充分的名字呢？

940
00:43:33,860 --> 00:43:37,700
如果我们给他们的地址
以及关于它们的其他数据？

941
00:43:37,700 --> 00:43:43,360
>> 好吧，如果你指定了一个列
数据库建立索引，这意味着

942
00:43:43,360 --> 00:43:47,730
的MySQL或Oracle，或者任何数据库
你使用，应该工作它的魔力

943
00:43:47,730 --> 00:43:51,300
并使用某种奇特的数据
就像一棵树，或一个线索，或结构

944
00:43:51,300 --> 00:43:55,940
哈希表，什么保证
当你使用搜索数据

945
00:43:55,940 --> 00:43:58,150
选择在那个特定的领域 - 

946
00:43:58,150 --> 00:44:01,310
就像告诉我大家，
住在牛津街。

947
00:44:01,310 --> 00:44:02,540
查询这样的。

948
00:44:02,540 --> 00:44:06,250
如果事先已指定
你想在该领域中的指数，

949
00:44:06,250 --> 00:44:09,050
搜索将是非常非常快。

950
00:44:09,050 --> 00:44:12,090
>> 如果不指定索引，最好
你可以做的是，如果一个线性搜索

951
00:44:12,090 --> 00:44:13,030
它没有排序。

952
00:44:13,030 --> 00:44:16,220
但如果指定索引，智能
人谁做的资料库 - 

953
00:44:16,220 --> 00:44:19,340
你这样的人谁知道现在树
并试图和哈希表 - 

954
00:44:19,340 --> 00:44:23,220
会自动建立这样一个数据
结构在RAM中，以确保

955
00:44:23,220 --> 00:44:26,050
这些搜索速度更快。

956
00:44:26,050 --> 00:44:29,660
>> FULLTEXT同时也是世界上精神相似，
但可以让你做通配符

957
00:44:29,660 --> 00:44:35,480
搜索，就像告诉我大家，
住在开头的街道

958
00:44:35,480 --> 00:44:36,960
字母O无论出于何种原因。

959
00:44:36,960 --> 00:44:38,850
你可以做通配符搜索
这样的。

960
00:44:38,850 --> 00:44:45,880
或者，像表演更引人注目的东西
我大家谁都有这个词 - 

961
00:44:45,880 --> 00:44:49,400
告诉我每个人都为名称开头
与一个特定的字母。

962
00:44:49,400 --> 00:44:51,880
您可以搜索关键字
在这种方式。

963
00:44:51,880 --> 00:44:52,630
好的。

964
00:44:52,630 --> 00:44:55,760
>> 因此，设计机会
可能有。

965
00:44:55,760 --> 00:44:57,740
另外有一些人，我会
我挥动双手。

966
00:44:57,740 --> 00:45:00,530
事实证明，你可以有
不同的存储引擎。

967
00:45:00,530 --> 00:45:04,390
这是更神秘的比我们需要的
肯定是问题设置7。

968
00:45:04,390 --> 00:45:06,920
默认情况下，你们正在使用
一些所谓的InnoDB。

969
00:45:06,920 --> 00:45:10,910
你会看到提到这个地方在
phpMyAdmin的界面最有可能的。

970
00:45:10,910 --> 00:45:14,130
但是要知道，还有其他的设计
这是潜在的决定

971
00:45:14,130 --> 00:45:18,030
兴趣来最终项目是否
你做一些基于Web的。

972
00:45:18,030 --> 00:45:19,330
>> 但是，让我们做到这一点。

973
00:45:19,330 --> 00:45:23,130
让我们继续前进，把这点
屏幕作为传情的故事

974
00:45:23,130 --> 00:45:26,330
包括你，一个室友，
和一杯牛奶。

975
00:45:26,330 --> 00:45:28,240
让我们在两分钟
左右突破这里。

976
00:45:28,240 --> 00:45:31,060
如果你能留下来，让我们来
回来了，看起来有点多在SQL和

977
00:45:31,060 --> 00:45:35,160
然后有点用的JavaScript
对设置在脑海8。

978
00:45:35,160 --> 00:45:36,120
>> 好的。

979
00:45:36,120 --> 00:45:40,420
所以，让我们给你思考一个
可以非常容易出现极端状况

980
00:45:40,420 --> 00:45:44,240
在使用数据库，或上下文
坦率地说，即使使用真实世界的事情

981
00:45:44,240 --> 00:45:46,280
像自动取款机取钱。

982
00:45:46,280 --> 00:45:47,640
所以这里有一个冰箱。

983
00:45:47,640 --> 00:45:50,040
假设你已经有一个了
你的宿舍或者你的房子。

984
00:45:50,040 --> 00:45:54,990
你已经得到了一个室友的都有，和
你真的喜欢牛奶的实例。

985
00:45:54,990 --> 00:45:57,210
>> 所以，你回家从类一天。

986
00:45:57,210 --> 00:45:58,490
他或她还没有回来。

987
00:45:58,490 --> 00:45:59,180
你打开冰箱。

988
00:45:59,180 --> 00:46:00,870
你真的想要的一大杯牛奶。

989
00:46:00,870 --> 00:46:01,820
有没有牛奶。

990
00:46:01,820 --> 00:46:02,920
所以，你会怎么做？

991
00:46:02,920 --> 00:46:03,840
你关闭了冰箱。

992
00:46:03,840 --> 00:46:04,670
你抢你的钥匙。

993
00:46:04,670 --> 00:46:05,930
你出去到广场。

994
00:46:05,930 --> 00:46:09,240
而你在得到线在CVS的那些
自助结帐的东西，它总是

995
00:46:09,240 --> 00:46:11,180
需要更长的时间比实际
有收银员。

996
00:46:11,180 --> 00:46:11,820
总之。

997
00:46:11,820 --> 00:46:15,490
>> 那么，与此同时，小点小点小点，你的
室友回家，他或她

998
00:46:15,490 --> 00:46:17,440
类似地具有一个渴望
对于一些牛奶。

999
00:46:17,440 --> 00:46:20,380
于是，他或她打开冰箱，
看起来里面，哦，该死的。

1000
00:46:20,380 --> 00:46:21,160
没有牛奶。

1001
00:46:21,160 --> 00:46:24,750
于是，他或她领导了，偏偏去
到其它的CVS，只有这是一个

1002
00:46:24,750 --> 00:46:27,900
方框相差出于某种原因，他或
她会在网上买一些牛奶。

1003
00:46:27,900 --> 00:46:30,480
>> 同时，你回家的时候，他或
她回家，和做什么

1004
00:46:30,480 --> 00:46:31,980
你最终有吗？

1005
00:46:31,980 --> 00:46:33,080
两倍的牛奶。

1006
00:46:33,080 --> 00:46:34,620
但你真的不喜欢
牛奶那么多。

1007
00:46:34,620 --> 00:46:37,300
所以，现在你有这么多的牛奶，现在
其中之一是刚准备去酸

1008
00:46:37,300 --> 00:46:37,820
最终。

1009
00:46:37,820 --> 00:46:39,370
所以这是一个非常糟糕的问题。

1010
00:46:39,370 --> 00:46:39,900
对吗？

1011
00:46:39,900 --> 00:46:41,990
>> 所以，发生了什么事？

1012
00:46:41,990 --> 00:46:44,810
所以从根本上，这是一种
荒谬的例子。

1013
00:46:44,810 --> 00:46:48,580
但引擎盖下，我们已经有
在这里发生的是你们两个检查

1014
00:46:48,580 --> 00:46:52,390
某一段的状态
存储器，该冰箱。

1015
00:46:52,390 --> 00:46:54,420
你们俩检查状态
一些变量。

1016
00:46:54,420 --> 00:46:57,360
你们都画了一个结论，
那你再采取行动。

1017
00:46:57,360 --> 00:47:01,420
但不幸的是，当你的室友
是在商店，那状态

1018
00:47:01,420 --> 00:47:05,670
变变了，他或她回来
现在想改变状态，但

1019
00:47:05,670 --> 00:47:07,480
它已经被改变
他或她。

1020
00:47:07,480 --> 00:47:11,120
当然，他或她会不会有
去商店，如果他们知道

1021
00:47:11,120 --> 00:47:13,010
您已经在途中。

1022
00:47:13,010 --> 00:47:16,430
>> 所以，在现实世界中，你怎么能这样
避免这个问题，假设你有

1023
00:47:16,430 --> 00:47:18,940
冰箱，你有一个室友，
而你居然喜欢牛奶？

1024
00:47:18,940 --> 00:47:19,760
>> 观众：沟通。

1025
00:47:19,760 --> 00:47:20,580
>> DAVID马兰：沟通。

1026
00:47:20,580 --> 00:47:21,160
确定。

1027
00:47:21,160 --> 00:47:22,500
但如何可能你沟通？

1028
00:47:22,500 --> 00:47:23,990
>> 观众：留一个便条。

1029
00:47:23,990 --> 00:47:25,480
>> DAVID马兰：留一个便条，对不对？

1030
00:47:25,480 --> 00:47:28,025
总是留下一张纸条，为
该节目的球迷。

1031
00:47:28,025 --> 00:47:31,580
好吧，所以总是留下一张纸条，或
把真正喜欢一个挂锁或某事

1032
00:47:31,580 --> 00:47:35,440
上，让您的冰箱
从检查的状态室友

1033
00:47:35,440 --> 00:47:36,540
该变量。

1034
00:47:36,540 --> 00:47:40,800
>> 现在，为什么会这样有密切关系
问题设置7，或到自动取款机。

1035
00:47:40,800 --> 00:47:46,780
那么，想象在一个ATM的世界里
你也许可以去到一个ATM

1036
00:47:46,780 --> 00:47:48,920
机器在这里，并在这里另一个自动取款机。

1037
00:47:48,920 --> 00:47:50,680
而这经常​​发生。

1038
00:47:50,680 --> 00:47:54,150
并假设您有两个ATM卡，
这有可能获得。

1039
00:47:54,150 --> 00:47:57,420
和您登录到两台机器
同时有效，希望

1040
00:47:57,420 --> 00:47:58,660
虽然没有人在找。

1041
00:47:58,660 --> 00:48:01,260
然后你在你的PIN码输入
大致同时。

1042
00:48:01,260 --> 00:48:06,280
然后，你做一个查询余额
就看你有多少现金。

1043
00:48:06,280 --> 00:48:08,920
让我们说你有100元，
留在您的帐户。

1044
00:48:08,920 --> 00:48:13,310
所以基本上同时，你
说一，零，零，输入。

1045
00:48:13,310 --> 00:48:16,000
而你希望拿回一些钱。

1046
00:48:16,000 --> 00:48:18,440
>> 但多少钱可能你回来？

1047
00:48:18,440 --> 00:48:21,710
现在在一天结束电脑，
特别是如果他们在跟谁说话

1048
00:48:21,710 --> 00:48:27,360
服务器，不一定做的事情
在该命令中的预期。

1049
00:48:27,360 --> 00:48:30,860
>> 因此，假设会发生什么，因为，
无论网络速度问题有

1050
00:48:30,860 --> 00:48:34,530
是，或CPU的问题有，或
这样的事情，假设

1051
00:48:34,530 --> 00:48:38,530
第一台ATM检查您的平衡和
看，哦，这个人有100元。

1052
00:48:38,530 --> 00:48:41,840
但随后被分心，因为也许
备份正在发生，所以它的

1053
00:48:41,840 --> 00:48:42,500
放缓。

1054
00:48:42,500 --> 00:48:45,080
或者，也许在检查中，网络
连接有一点点慢，因为

1055
00:48:45,080 --> 00:48:45,910
这只是发生。

1056
00:48:45,910 --> 00:48:47,100
他们是物理设备。

1057
00:48:47,100 --> 00:48:49,330
如此同时，第二ATM是
问同样的问题。

1058
00:48:49,330 --> 00:48:53,030
多少钱，大卫有哪些？
100元的答案。

1059
00:48:53,030 --> 00:48:58,930
但是，因为第一个ATM尚未
发送的消息减去100元，两者

1060
00:48:58,930 --> 00:49:03,000
自动取款机已视察该银行的金库，
看到有100美元那里，而现在

1061
00:49:03,000 --> 00:49:07,160
两台机器都可能
要吐出一个答案。

1062
00:49:07,160 --> 00:49:12,240
>> 现在，这是伟大的，你在某种意义上
如果银行做什么，最终

1063
00:49:12,240 --> 00:49:17,200
由量改变至负100
设置变量等于你

1064
00:49:17,200 --> 00:49:21,570
银行账户等于0，而不是
干嘛减去100。

1065
00:49:21,570 --> 00:49:24,410
现在，在最坏的情况下为银行 - 

1066
00:49:24,410 --> 00:49:27,470
或者在最好的银行，同时，
他们给你200美元，

1067
00:49:27,470 --> 00:49:31,690
您的银行帐户现在显示负
100元，这确实不

1068
00:49:31,690 --> 00:49:32,950
有利于你的。

1069
00:49:32,950 --> 00:49:36,500
但问题是，这个比赛
条件两个室友越来越

1070
00:49:36,500 --> 00:49:40,660
牛奶，或两个自动取款机试图获得现金
和更改保管库的状态

1071
00:49:40,660 --> 00:49:44,510
在同一时间存在任何
时间，你有一个数据库。

1072
00:49:44,510 --> 00:49:48,290
>> 现在，在问题设置7，本次发行
出现在这个意义上，如果你买了

1073
00:49:48,290 --> 00:49:52,110
股Facebook股票，然后对
比如你买的第二份额

1074
00:49:52,110 --> 00:49:55,160
Facebook股票，你需要做
决定作为编程器。

1075
00:49:55,160 --> 00:49:58,710
为了决定如何更新
数据库，赔率是你要

1076
00:49:58,710 --> 00:50:02,250
有一个行的股票，而这
是实现它的方法之一。

1077
00:50:02,250 --> 00:50:06,640
而你将有一股
FB，这是他们的股票代码

1078
00:50:06,640 --> 00:50:10,120
这个用户名，或该用户
ID，该唯一标识符。

1079
00:50:10,120 --> 00:50:12,340
>> 但是，同样的故事可以发生在这里。

1080
00:50:12,340 --> 00:50:15,800
如果你做一个选择在SQL中，你会看到
在问题设置7，当你看到，

1081
00:50:15,800 --> 00:50:18,460
哦，大卫有一股
Facebook股票。

1082
00:50:18,460 --> 00:50:23,240
现在让我改变这是两股，
因为他想买一个

1083
00:50:23,240 --> 00:50:24,120
第二份额。

1084
00:50:24,120 --> 00:50:27,860
但是，假设大卫实际上有两个
浏览器窗口打开，或假设

1085
00:50:27,860 --> 00:50:32,150
它与夫妻双方联名账户，
和他们两人都试图执行

1086
00:50:32,150 --> 00:50:36,770
相同的操作，有，同样，
可能存在的决定是

1087
00:50:36,770 --> 00:50:39,670
基于以前提出
世界上的国家 - 

1088
00:50:39,670 --> 00:50:41,290
该帐户拥有一股股份 - 

1089
00:50:41,290 --> 00:50:45,630
并且两个人，或者两个服务器，现在
试试再说吧递增到两股。

1090
00:50:45,630 --> 00:50:49,020
但在这种情况下，您可能已落案起诉
我的钱为股份，但

1091
00:50:49,020 --> 00:50:50,830
增加只是一次。

1092
00:50:50,830 --> 00:50:54,730
>> 所以，总之，最根本的问题
在这里，与笑话留下

1093
00:50:54,730 --> 00:50:58,750
注意，或把挂锁就可以了，是
如果两个人，或者两个线程 - 

1094
00:50:58,750 --> 00:50:59,930
回想起刮 - 

1095
00:50:59,930 --> 00:51:03,220
可以检查一些变量的状态
然后试图更改变量，

1096
00:51:03,220 --> 00:51:07,950
但这两件事情不要发生在
同一时间，但可以被打断

1097
00:51:07,950 --> 00:51:11,500
其他的事情发生，数据可
进入一个非常奇怪的状态。

1098
00:51:11,500 --> 00:51:15,450
而且你可以受益，也可以承受
在金钱例的意义。

1099
00:51:15,450 --> 00:51:18,110
>> 因此，在问题设置7，我们给你
这一行代码，其中长

1100
00:51:18,110 --> 00:51:21,000
总而言之，解决了这个
问题在MySQL。

1101
00:51:21,000 --> 00:51:24,950
这个很长的指令不
甚至适合到上一行

1102
00:51:24,950 --> 00:51:30,370
屏幕在这里可以确保您的操作
是所谓的原子。

1103
00:51:30,370 --> 00:51:33,720
这一切都发生在一次，或者
它不会发生的。

1104
00:51:33,720 --> 00:51:37,530
这个很长的短语不能
得到部分中断。

1105
00:51:37,530 --> 00:51:39,840
>> 和它做什么简直是
它说什么。

1106
00:51:39,840 --> 00:51:44,200
插入一些表如下
三场的那些特定的值，

1107
00:51:44,200 --> 00:51:47,280
但重复键，
不要做一个插入。

1108
00:51:47,280 --> 00:51:48,280
做一个更新。

1109
00:51:48,280 --> 00:51:52,450
因此，这就像做一个SELECT和
INSERT可以这么说在同一时间。

1110
00:51:52,450 --> 00:51:55,150
什么是关键这可能是
被引用到这里？

1111
00:51:55,150 --> 00:51:58,300

1112
00:51:58,300 --> 00:52:01,380
>> 事实证明，你会看到在这个
问题设置7的规格，因为

1113
00:52:01,380 --> 00:52:06,040
我们已经宣布那里是一个唯一的密钥
这个特定的表上，使得

1114
00:52:06,040 --> 00:52:08,480
你不能有多个行
用于与相同的用户

1115
00:52:08,480 --> 00:52:10,150
同样一分钱的股票代码 - 

1116
00:52:10,150 --> 00:52:13,780
在这里这个例子中，DVN.V是
一个愚蠢的仙股，我们

1117
00:52:13,780 --> 00:52:14,980
是指在规范中。

1118
00:52:14,980 --> 00:52:17,860
因为我们已经宣布它是唯一的，
这是什么意思是，如果你

1119
00:52:17,860 --> 00:52:23,580
尝试插入重复行，你
而不是去而不更新它

1120
00:52:23,580 --> 00:52:27,020
任何人有机会改变
世界上的任何国家。

1121
00:52:27,020 --> 00:52:29,400
因此，在短期，这确保
事情是原子的。

1122
00:52:29,400 --> 00:52:32,530
>> 更一般地，虽然，数据库
如MySQL  - 

1123
00:52:32,530 --> 00:52:35,460
而你不需要这个功能的
对设置7，但请记住它的

1124
00:52:35,460 --> 00:52:36,200
未来 - 

1125
00:52:36,200 --> 00:52:38,870
支持所谓的交易，
在那里你可以说

1126
00:52:38,870 --> 00:52:40,990
从字面上START TRANSACTION。

1127
00:52:40,990 --> 00:52:43,270
然后，您可以执行
两个SQL语句。

1128
00:52:43,270 --> 00:52:45,710
和一个SQL语句，你会看到
在对设置7，显得有些

1129
00:52:45,710 --> 00:52:46,750
这样的事情。

1130
00:52:46,750 --> 00:52:48,820
更新的表中调用帐户。

1131
00:52:48,820 --> 00:52:52,550
设置余额列等于什么
目前余额栏

1132
00:52:52,550 --> 00:52:57,280
是减去1,000，其中的数量，
帐户号码，如用户ID，

1133
00:52:57,280 --> 00:53:00,830
等于2，然后更新
账户点缀点点。

1134
00:53:00,830 --> 00:53:04,350
>> 因此，在外行人的术语，什么这两个
查询似乎在做的

1135
00:53:04,350 --> 00:53:05,840
银行业的现实世界有意义吗？

1136
00:53:05,840 --> 00:53:07,440
>> 观众：转移到储蓄。

1137
00:53:07,440 --> 00:53:08,020
>> DAVID马兰：没错。

1138
00:53:08,020 --> 00:53:10,470
从一个转移资金
向另一方。

1139
00:53:10,470 --> 00:53:14,400
这是另一个例子，你
真的想这两件事情发生

1140
00:53:14,400 --> 00:53:15,570
或不会发生。

1141
00:53:15,570 --> 00:53:18,880
你不想要的东西，得到的
他们中间，有可能陷入困境

1142
00:53:18,880 --> 00:53:22,220
算算，还是搞砸了多少
钱，你有，或有多少

1143
00:53:22,220 --> 00:53:23,170
钱的银行都有。

1144
00:53:23,170 --> 00:53:26,890
那么什么是真正好的关于交易
在MySQL的是，和

1145
00:53:26,890 --> 00:53:30,160
数据库更一般地，是它们
以及谁已经实现的聪明人

1146
00:53:30,160 --> 00:53:33,670
这些特性弄清楚如何使
确保两个的事情发生

1147
00:53:33,670 --> 00:53:35,120
或根本没有。

1148
00:53:35,120 --> 00:53:38,580
>> 如果你是真正有志于做
这是由人使用的网站上

1149
00:53:38,580 --> 00:53:41,490
校园里，人们在现实世界中，做
东西在启动意义上说，

1150
00:53:41,490 --> 00:53:43,300
这些都是种
设计决策

1151
00:53:43,300 --> 00:53:45,020
变得比以往那么重要。

1152
00:53:45,020 --> 00:53:48,240
否则，你就开始失去数据，输
用户，或者在最坏的情况下为

1153
00:53:48,240 --> 00:53:51,800
我们在这里看到的，潜在的
赔钱。

1154
00:53:51,800 --> 00:53:56,180
如此反复，更多，在问题设置
7，还有可能对某些

1155
00:53:56,180 --> 00:53:57,530
你在最后的项目。

1156
00:53:57,530 --> 00:54:01,870
>> 因此，让我们改变图片中我们有
刚才只是一种方式。

1157
00:54:01,870 --> 00:54:04,070
因此，让我能不能我居然看到 - 

1158
00:54:04,070 --> 00:54:06,030
不，那已经走了。

1159
00:54:06,030 --> 00:54:06,690
在那里，它是。

1160
00:54:06,690 --> 00:54:09,020
>> 所以这是我们离开最后一次。

1161
00:54:09,020 --> 00:54:12,390
而事实证明，我们要去折腾
一件事情到这里混 - 

1162
00:54:12,390 --> 00:54:14,510
一个名为JavaScript语言。

1163
00:54:14,510 --> 00:54:18,060
所以，JavaScript实际上适合
进入这片 - 

1164
00:54:18,060 --> 00:54:22,086
而且我也不太留有足够的空间，
所以这不是现在的规模。

1165
00:54:22,086 --> 00:54:23,900
OK，这是值得同情的。

1166
00:54:23,900 --> 00:54:27,075
好了，这就是JavaScript的。

1167
00:54:27,075 --> 00:54:27,340
好的。

1168
00:54:27,340 --> 00:54:28,760
我真的这样做了倒忙。

1169
00:54:28,760 --> 00:54:29,390
好的。

1170
00:54:29,390 --> 00:54:34,790
>> 因此，JavaScript是另一种编程
语言和我们的最后，有没有什么帮助

1171
00:54:34,790 --> 00:54:37,770
放心，有没有什么更
的消防栓在这里。

1172
00:54:37,770 --> 00:54:41,100
这样的JavaScript也是一种解释
语言，这意味着你不

1173
00:54:41,100 --> 00:54:42,670
它编译成零和一。

1174
00:54:42,670 --> 00:54:43,690
你只要运行它。

1175
00:54:43,690 --> 00:54:47,680
但是，什么是有根本不同的
JavaScript的通常是你

1176
00:54:47,680 --> 00:54:49,815
不要在Web服务器上运行它。

1177
00:54:49,815 --> 00:54:52,570
它不会在运行
家电本身。

1178
00:54:52,570 --> 00:54:57,490
相反，它就会被用户下载
通过HTTP到他们的浏览器 - 

1179
00:54:57,490 --> 00:55:00,260
Chrome浏览器，Safari浏览器，IE浏览器，
Firefox的，不管是谁 - 

1180
00:55:00,260 --> 00:55:03,860
并且它是执行这个浏览器
特定的编程语言。

1181
00:55:03,860 --> 00:55:08,000
>> 所以要清楚，PHP迄今已
无论是执行在命令行

1182
00:55:08,000 --> 00:55:11,290
我们的黑与白的窗口，在服务器上
像设备，计算机

1183
00:55:11,290 --> 00:55:14,490
喜欢该设备，或者它已经
由Web服务器执行

1184
00:55:14,490 --> 00:55:15,860
在计算机上运行。

1185
00:55:15,860 --> 00:55:20,490
但这里的主题是，PHP迄今
已被执行的服务器端，所以

1186
00:55:20,490 --> 00:55:24,820
用户和用户的浏览器
永远看不到一行PHP代码。

1187
00:55:24,820 --> 00:55:28,530
>> 事实上，如果你曾经打开一个浏览器
您的网站或其他和你

1188
00:55:28,530 --> 00:55:32,400
实际看到的PHP代码在你的窗口，
有人搞砸了。

1189
00:55:32,400 --> 00:55:34,950
因为它并不意味着是
直接发送到一个浏览器。

1190
00:55:34,950 --> 00:55:38,150
它应该被执行转身
成类似HTML。

1191
00:55:38,150 --> 00:55:40,120
>> 但JavaScript的本质
相反。

1192
00:55:40,120 --> 00:55:44,350
它的意思是典型的内部运行
的用户的浏览器窗口。

1193
00:55:44,350 --> 00:55:46,840
和使用什么类型的网站
然后，JavaScript的这些日子？

1194
00:55:46,840 --> 00:55:49,640

1195
00:55:49,640 --> 00:55:52,180
>> 如同字面上每个受欢迎的网站。

1196
00:55:52,180 --> 00:55:55,430
每一个网站，你们大概
每天使用使用JavaScript的

1197
00:55:55,430 --> 00:55:57,330
最简单的，甚至
最性感的特点。

1198
00:55:57,330 --> 00:55:59,800
>> 因此，像Fac​​ebook的
聊天，如果您使用。

1199
00:55:59,800 --> 00:56:01,040
如何实际工作？

1200
00:56:01,040 --> 00:56:05,090
以及迄今，所有的东西，我们已经
完成了HTML和PHP假定

1201
00:56:05,090 --> 00:56:08,750
你拉了一个网址，你敲回车，
和你看到一些HTML内容。

1202
00:56:08,750 --> 00:56:11,970
而你点击链接，即改变
网址，改变了页面，并重新加载

1203
00:56:11,970 --> 00:56:12,740
一些新的内容。

1204
00:56:12,740 --> 00:56:16,340
点击另一个URL或者提交一个表单，你
获得护送到另一个页面，

1205
00:56:16,340 --> 00:56:17,420
你看到了一些新的内容。

1206
00:56:17,420 --> 00:56:22,710
>> 但使用类似Facebook的聊天，
或Gchat，或谷歌地图，很少

1207
00:56:22,710 --> 00:56:27,350
没有整个页面刷新，使得
你看到一个白色屏幕片刻，

1208
00:56:27,350 --> 00:56:28,470
然后新的内容。

1209
00:56:28,470 --> 00:56:32,610
更确切地说，网页今天是动态
再次得到更新

1210
00:56:32,610 --> 00:56:35,570
一次又一次的所有排序
幕后。

1211
00:56:35,570 --> 00:56:38,560
而事实证明，当你去
像Facebook或Gchat，

1212
00:56:38,560 --> 00:56:43,050
或Gmail和页面更新
无自动重装

1213
00:56:43,050 --> 00:56:47,630
整个屏幕上，发生的是，
您的浏览器已排序的秘密

1214
00:56:47,630 --> 00:56:49,410
额外的HTTP请求 - 

1215
00:56:49,410 --> 00:56:52,740
不是整个网页，但只为
数据的小的块，如

1216
00:56:52,740 --> 00:56:55,740
即时消息，你的朋友刚刚
送你，或状态的更新，

1217
00:56:55,740 --> 00:56:58,210
刚刚有人送你，或鸣叫
有人刚刚发。

1218
00:56:58,210 --> 00:57:02,120
它只是让小请求
数据，然后使用JavaScript，这

1219
00:57:02,120 --> 00:57:06,370
编程语言，要改变什么
网页看起来像没有

1220
00:57:06,370 --> 00:57:09,860
服务器的帮助，无需服务器
生成的HTML。

1221
00:57:09,860 --> 00:57:13,820
>> 所以，总之，可以使用JavaScript的再
不仅从获取新数据

1222
00:57:13,820 --> 00:57:16,750
无需重新加载整个服务器
页面或提交表单。

1223
00:57:16,750 --> 00:57:20,060
它也可以用来改变
所谓的DOM  - 

1224
00:57:20,060 --> 00:57:21,520
文档对象模型 - 

1225
00:57:21,520 --> 00:57:24,620
这仅仅是看中方式
说的HTML的树

1226
00:57:24,620 --> 00:57:26,220
我们看到最后一次。

1227
00:57:26,220 --> 00:57:31,640
>> 所以安抚，JavaScript是
所以语法类似于C为好。

1228
00:57:31,640 --> 00:57:32,820
有没有主函数。

1229
00:57:32,820 --> 00:57:35,430
你刚开始写代码
它会得到执行，或

1230
00:57:35,430 --> 00:57:36,900
更恰当的解释。

1231
00:57:36,900 --> 00:57:38,660
条件如下所示。

1232
00:57:38,660 --> 00:57:41,230
无异于C或
PHP为此事。

1233
00:57:41,230 --> 00:57:43,890
布尔表达式或 - 编在一起
看起来就像这样。

1234
00:57:43,890 --> 00:57:45,590
相与在一起看起来像这样。

1235
00:57:45,590 --> 00:57:47,750
>> 交换机将看起来像这样。

1236
00:57:47,750 --> 00:57:49,440
for循环看起来会像这样。

1237
00:57:49,440 --> 00:57:51,060
while循环看起来会像这样。

1238
00:57:51,060 --> 00:57:53,316
做while循环看起来会像这样。

1239
00:57:53,316 --> 00:57:54,780
>> 这是新的。

1240
00:57:54,780 --> 00:57:58,753
所以，JavaScript有没有一个foreach
构造本身，而是该构建

1241
00:57:58,753 --> 00:58:03,870
对于变量i的数组，和我在这
情况变成一个索引值。

1242
00:58:03,870 --> 00:58:06,880
因此，它是从一点点不同
的foreach，虽然新版本

1243
00:58:06,880 --> 00:58:10,280
JavaScript的是走出来的时候，
因此，即使这些语言特性

1244
00:58:10,280 --> 00:58:10,880
正在不断发展。

1245
00:58:10,880 --> 00:58:16,920
>> 并顺便说一句，JavaScript的这些日子
也可以用一台服务器上一样

1246
00:58:16,920 --> 00:58:19,920
使用PHP名为Node.js的框架

1247
00:58:19,920 --> 00:58:24,670
一个CS50的转录因子，凯文，导致一
研讨会上的Node.js这是可在

1248
00:58:24,670 --> 00:58:26,440
cs50.net/seminars。

1249
00:58:26,440 --> 00:58:28,830
所以，如果你很好奇，知道你
可以在服务器端作为使用本

1250
00:58:28,830 --> 00:58:33,870
好了，但是这是一个相当新的趋势，
但一个强大的一个。

1251
00:58:33,870 --> 00:58:35,270
>> 这是一个有点不同。

1252
00:58:35,270 --> 00:58:37,910
这是在JavaScript的数组。

1253
00:58:37,910 --> 00:58:40,115
什么打你不同
与C或PHP？

1254
00:58:40,115 --> 00:58:43,890

1255
00:58:43,890 --> 00:58:47,420
这里有几个简单的故事
我们可以在这里告诉。

1256
00:58:47,420 --> 00:58:49,367
现在缺少对PHP的？

1257
00:58:49,367 --> 00:58:51,652
>> 观众：[听不清]。

1258
00:58:51,652 --> 00:58:52,110
>> DAVID马兰：怎么了？

1259
00:58:52,110 --> 00:58:53,322
对不起，再说一遍吗？

1260
00:58:53,322 --> 00:58:54,740
>> 观众：不声明
变量的类型。

1261
00:58:54,740 --> 00:58:56,390
>> DAVID马兰：我们不会宣布
变量的类型。

1262
00:58:56,390 --> 00:58:59,630
所以，其实蛮喜欢PHP的，我们不是
指定该变量的类型。

1263
00:58:59,630 --> 00:59:02,670
相反，我们更一般
话说变种变量。

1264
00:59:02,670 --> 00:59:06,690
我们没有的PHP的滋扰
美元符号，这虽然繁琐

1265
00:59:06,690 --> 00:59:09,160
类型，并让更多的清楚，
什么是一个变量。

1266
00:59:09,160 --> 00:59:11,830
而在这里，我们是有点回
C'S方法只是通过调用

1267
00:59:11,830 --> 00:59:14,500
按我们想要的变量名称
给它，像数字。

1268
00:59:14,500 --> 00:59:17,170
也像PHP，我们有
方括号内为

1269
00:59:17,170 --> 00:59:19,170
该数组内的值。

1270
00:59:19,170 --> 00:59:22,490
>> 在JavaScript中这样的变量也
可能是这样的。

1271
00:59:22,490 --> 00:59:26,900
注意这里，这是一个称为S字符串，
但同样有我们没有指定

1272
00:59:26,900 --> 00:59:28,750
这是一个字符串。

1273
00:59:28,750 --> 00:59:33,160
这里虽然是一种功能，不
存在于恰好在PHP中相同的方式，

1274
00:59:33,160 --> 00:59:34,460
但有点类似。

1275
00:59:34,460 --> 00:59:36,530
这是在JavaScript中的对象。

1276
00:59:36,530 --> 00:59:42,110
而对象是类的瑞士军刀
的数据结构中，你刀

1277
00:59:42,110 --> 00:59:43,900
可以将它们用于任何数量的东西。

1278
00:59:43,900 --> 00:59:46,860
>> 在这里，例如，我们正在声明
一个变量名为报价。

1279
00:59:46,860 --> 00:59:49,110
该变量的类型
是一个对象。

1280
00:59:49,110 --> 00:59:53,550
你可以认为这是一个C结构
有键和值。

1281
00:59:53,550 --> 00:59:55,250
符号是一个关键。

1282
00:59:55,250 --> 00:59:57,350
FB是一个值，显然
股票代码。

1283
00:59:57,350 --> 00:59:57,930
逗号。

1284
00:59:57,930 --> 01:00:02,180
价格是另一个关键，它的值是
显然是浮点，或一个

1285
01:00:02,180 --> 01:00:06,510
更一般地在数字
的JavaScript49.26美元。

1286
01:00:06,510 --> 01:00:09,030
>> 所以，PHP不具备 - 

1287
01:00:09,030 --> 01:00:12,980
我们还没有看到PHP对象相当
像这样，但我们也看到一个模拟，

1288
01:00:12,980 --> 01:00:14,093
这是什么？

1289
01:00:14,093 --> 01:00:14,980
>> 观众：[听不清]。

1290
01:00:14,980 --> 01:00:16,110
>> DAVID马兰：关联数组。

1291
01:00:16,110 --> 01:00:19,990
因此而PHP有关联数组
其语法是有史以来略等

1292
01:00:19,990 --> 01:00:20,370
不同的 - 

1293
01:00:20,370 --> 01:00:21,780
我们看到了方括号。

1294
01:00:21,780 --> 01:00:23,860
我们看到了奇怪的箭头符号。

1295
01:00:23,860 --> 01:00:27,330
JavaScript有对象，但这是
大多是语义差异和

1296
01:00:27,330 --> 01:00:29,260
不同的同义词了。

1297
01:00:29,260 --> 01:00:35,060
不过，顺便说一句，PHP也有
在某种程度上对象的Java及其他

1298
01:00:35,060 --> 01:00:37,810
语言有对象
面向对象的编程。

1299
01:00:37,810 --> 01:00:40,440
但是我们将使用这些刚
数据类型现在。

1300
01:00:40,440 --> 01:00:42,170
对象和关联数组。

1301
01:00:42,170 --> 01:00:44,140
>> 这其中可能使
更加清楚一点。

1302
01:00:44,140 --> 01:00:45,890
这也是为什么一个对象是非常有用的。

1303
01:00:45,890 --> 01:00:48,760
当你想声明一个学生，
像Zamyla，我们实际上可以

1304
01:00:48,760 --> 01:00:52,630
封装可以这么说那里面
使用花括号，就像反对

1305
01:00:52,630 --> 01:00:55,060
一大堆钥匙的前
在这里值。

1306
01:00:55,060 --> 01:00:59,150
我们有一个ID，一个房子，一个名字
Zamyla，后跟一个分号作为

1307
01:00:59,150 --> 01:01:00,690
通常在最后。

1308
01:01:00,690 --> 01:01:04,840
>> 到这里也一样，这是稍微
不同，但也很强大

1309
01:01:04,840 --> 01:01:05,690
这些天。

1310
01:01:05,690 --> 01:01:08,780
下面是一个数组，我知道，因为
有一个方括号起来

1311
01:01:08,780 --> 01:01:11,090
顶部和方括号
在底部。

1312
01:01:11,090 --> 01:01:16,050
这就是数据的数组
在JavaScript显然键入？

1313
01:01:16,050 --> 01:01:21,260
这是它的外观的阵列
像三个物体。

1314
01:01:21,260 --> 01:01:24,580
我知道这只是一个对象
因为大括号。

1315
01:01:24,580 --> 01:01:28,760
并注意有大括号，
有些东西，右大括号，逗号，

1316
01:01:28,760 --> 01:01:31,180
然后一些，逗号，
然后一些。

1317
01:01:31,180 --> 01:01:33,800
所以，这三个参数
用两个逗号隔开。

1318
01:01:33,800 --> 01:01:36,810
>> 因此，这是三个对象的数组。

1319
01:01:36,810 --> 01:01:39,940
并且其中的每个对象似乎是
一些学生或工作人员

1320
01:01:39,940 --> 01:01:42,370
排序，每一个ID，
房子，和名称。

1321
01:01:42,370 --> 01:01:45,060
但我已经叫这东西
所谓的JSON  - 

1322
01:01:45,060 --> 01:01:47,450
JavaScript对象表示法。

1323
01:01:47,450 --> 01:01:52,060
这是一个数据格式，实际上
那么很受欢迎，在

1324
01:01:52,060 --> 01:01:55,100
时尚这些天，如果你写了一个
使用Facebook应用程序

1325
01:01:55,100 --> 01:01:59,150
API，Twitter的API，真的差点
任何API在那里这些天，

1326
01:01:59,150 --> 01:02:02,820
包括一些CS50自己的
你回来的数据是不是在

1327
01:02:02,820 --> 01:02:04,720
老同学CSV格式。

1328
01:02:04,720 --> 01:02:06,780
>> 因为回想一下，CSV
超简单。

1329
01:02:06,780 --> 01:02:10,230
这仅仅是分开列
用逗号。

1330
01:02:10,230 --> 01:02:13,190
JSON数据给你更多的元数据。

1331
01:02:13,190 --> 01:02:17,800
它有关联的每个值一个键，以便
他们不必只是假设

1332
01:02:17,800 --> 01:02:22,460
第零列是一个数值，列
一个是另外一个，第二列是另一回事。

1333
01:02:22,460 --> 01:02:26,790
在这里的JSON对象一切都是排序
自我描述的，因为每一个

1334
01:02:26,790 --> 01:02:30,940
名字在这个文件中的一个具有字面
在它前面的名称为

1335
01:02:30,940 --> 01:02:32,510
带引号的字符串。

1336
01:02:32,510 --> 01:02:34,950
>> 因此，让我们来看看一个
几个例子在这里。

1337
01:02:34,950 --> 01:02:36,800
让我去到设备。

1338
01:02:36,800 --> 01:02:41,000
让我进入我们的虚拟主机
目录进入公众。

1339
01:02:41,000 --> 01:02:45,590
让我进入
JavaScript的目录。

1340
01:02:45,590 --> 01:02:49,610
让我们去进取，不断开拓
DOM-0.html，其中的DOM只是意味着

1341
01:02:49,610 --> 01:02:51,010
文档对象模型。

1342
01:02:51,010 --> 01:02:53,490
这是树的东西到
我前面提到的。

1343
01:02:53,490 --> 01:02:54,950
>> 让我提出以下建议。

1344
01:02:54,950 --> 01:02:57,720
下面是它的一个网页
身体是非常简单的。

1345
01:02:57,720 --> 01:03:00,170
所以这儿的底部，
注意到我有一个表格。

1346
01:03:00,170 --> 01:03:01,500
我们以前见过的那些。

1347
01:03:01,500 --> 01:03:07,600
它有两个输入端，其中一个具有一个
其中一个名称标识，有一种类型的

1348
01:03:07,600 --> 01:03:09,830
提交，并且所述第一
一个人的类型是text。

1349
01:03:09,830 --> 01:03:11,900
因此，这实际上听起来很简单。

1350
01:03:11,900 --> 01:03:13,090
>> 让我们在这里。

1351
01:03:13,090 --> 01:03:15,390
让我们回到这个页面在这里。

1352
01:03:15,390 --> 01:03:21,030
让我们进入本地主机，并进入
我们的JavaScript目录，并转到

1353
01:03:21,030 --> 01:03:24,640
DOM-0，在这里，我们有这样的形式。

1354
01:03:24,640 --> 01:03:26,550
所以这是很明显
所有的页面一样。

1355
01:03:26,550 --> 01:03:28,740
它有一个名字字段
一个提交按钮。

1356
01:03:28,740 --> 01:03:30,340
但我不打算在这里使用PHP。

1357
01:03:30,340 --> 01:03:34,310
我将尽一切客户端
所以要如下在JavaScript中发言。

1358
01:03:34,310 --> 01:03:39,100
>> 请注意，我确实赋予的名称
这个输入领域的独特

1359
01:03:39,100 --> 01:03:42,350
标识符，这实际上
救我一些时间在一个时刻。

1360
01:03:42,350 --> 01:03:45,480
并注意我介绍另一个标签
在我的网页的头部，

1361
01:03:45,480 --> 01:03:46,565
 标记。

1362
01:03:46,565 --> 01:03:50,120
>> 因此，它是在这个意义上说，JavaScript是
一个客户端编程语言。

1363
01:03:50,120 --> 01:03:55,020
在这种情况下，就像CSS，我已经把
它直接在我的HTML。

1364
01:03:55,020 --> 01:03:58,810
但请注意，我已经声明的函数
看起来有点像PHP

1365
01:03:58,810 --> 01:04:01,530
语法，但其实这是
JavaScript的，因为再次，它是

1366
01:04:01,530 --> 01:04:03,920
客户端在浏览器中。

1367
01:04:03,920 --> 01:04:07,590
并以此来猜测这是什么打算
这样做，即使有些语法

1368
01:04:07,590 --> 01:04:09,338
这里是新的。

1369
01:04:09,338 --> 01:04:11,760
>> 观众：问好谁。

1370
01:04:11,760 --> 01:04:14,020
>> DAVID马兰：这是怎么回事打招呼
对谁访问这个页面。

1371
01:04:14,020 --> 01:04:15,120
那么，如何？

1372
01:04:15,120 --> 01:04:18,070
>> 因此注意到，原来在JavaScript
有一个alert（）函数。

1373
01:04:18,070 --> 01:04:22,840
这是一个非常可悲的排序功能，
真的只是往往惹恼用户。

1374
01:04:22,840 --> 01:04:25,440
这不是一个你真的应该使用
通常情况下，但它是一个快速和肮脏

1375
01:04:25,440 --> 01:04:27,710
这样的排序打印的东西
到的图形用户

1376
01:04:27,710 --> 01:04:29,180
接口，就像一个浏览器。

1377
01:04:29,180 --> 01:04:31,400
请注意，在这里，我已经有了一个
字符串中的单引号。

1378
01:04:31,400 --> 01:04:36,010
事实证明，与C，JavaScript的
其实可以有使用单

1379
01:04:36,010 --> 01:04:38,730
报价，坦白说这只是一种
当中的文体公约

1380
01:04:38,730 --> 01:04:41,180
JavaScript程序员
使用单引号。

1381
01:04:41,180 --> 01:04:43,750
PHP的，他们实际上有轻微
不同的意义。

1382
01:04:43,750 --> 01:04:45,810
但现在，只要知道
这是唯一的原因。

1383
01:04:45,810 --> 01:04:49,270
在JavaScript中的约定往往是
使用单引号，但我们可以用

1384
01:04:49,270 --> 01:04:50,950
两地双引号为好。

1385
01:04:50,950 --> 01:04:52,610
>> 因此，这是有趣的。

1386
01:04:52,610 --> 01:04:56,430
记得最后一次，我们有这样的
图片，吸引了一棵树在屏幕上

1387
01:04:56,430 --> 01:04:59,720
在那里你有HTML节点，
头节点，身体节点

1388
01:04:59,720 --> 01:05:00,800
然后一些文本。

1389
01:05:00,800 --> 01:05:04,700
但是有在一个特殊的节点
极顶，我称为文档。

1390
01:05:04,700 --> 01:05:08,260
嗯，事实证明在JavaScript中，任何
时间你写在JavaScript程序

1391
01:05:08,260 --> 01:05:11,040
在浏览器中，您可以访问
一个特殊的全局变量。

1392
01:05:11,040 --> 01:05:14,130
类似的精神，PHP的超全局变量，
这个就是所谓的

1393
01:05:14,130 --> 01:05:16,050
全部小写的文件。

1394
01:05:16,050 --> 01:05:21,480
>> 这就像一个结构，但这种结构
也有在其内部功能。

1395
01:05:21,480 --> 01:05:23,790
因此，一个C结构只是有数据通常。

1396
01:05:23,790 --> 01:05:29,060
但由于这是一个JavaScript对象
在技​​术上也有功能，

1397
01:05:29,060 --> 01:05:31,830
否则称为方法
里面的它。

1398
01:05:31,830 --> 01:05:35,750
而且你可以调用一个函数内
这个对象毫不夸张地做了

1399
01:05:35,750 --> 01:05:39,610
名，点，和然后的名称
的功能，或再次方法。

1400
01:05:39,610 --> 01:05:41,160
这只是一个代名词，真的。

1401
01:05:41,160 --> 01:05:42,450
>> 而这是什么功能呢？

1402
01:05:42,450 --> 01:05:43,840
那种你可以从它的名字猜测。

1403
01:05:43,840 --> 01:05:45,590
通过ID获取元素。

1404
01:05:45,590 --> 01:05:50,040
因此，这是要搜索的网页，
搜索那棵树，寻找

1405
01:05:50,040 --> 01:05:55,210
任何节点，AKA元件，具有
的报价引文名唯一的ID。

1406
01:05:55,210 --> 01:05:56,560
然后我该怎么办？

1407
01:05:56,560 --> 01:06:00,350
我要得到里面的值
在树中的节点，我要去

1408
01:06:00,350 --> 01:06:02,580
以某种方式打招呼该名称。

1409
01:06:02,580 --> 01:06:05,360
>> 所以采取了猜测，即使我们已经没有
看到了这一点，但什么加

1410
01:06:05,360 --> 01:06:07,396
符号的意思是在这里和这里可能呢？

1411
01:06:07,396 --> 01:06:08,230
>> 观众：串联。

1412
01:06:08,230 --> 01:06:09,220
>> 国宝马兰：串连。

1413
01:06:09,220 --> 01:06:11,290
没错，这些都只是
设计决定排序

1414
01:06:11,290 --> 01:06:12,280
人民年前。

1415
01:06:12,280 --> 01:06:15,190
在PHP中，串接
点的东西。

1416
01:06:15,190 --> 01:06:18,800
在C中，通过几个铁圈跳
像strcopy（）或调用函数

1417
01:06:18,800 --> 01:06:20,600
的strcat（）或其他类似的功能。

1418
01:06:20,600 --> 01:06:22,060
但在JavaScript中，您可以使用加号。

1419
01:06:22,060 --> 01:06:24,770
所以，这仅仅是串联
三根弦 - 

1420
01:06:24,770 --> 01:06:27,850
你好，名称，然后
一个惊叹号。

1421
01:06:27,850 --> 01:06:30,390
>> 所以，当这是为什么功能
虽然叫？

1422
01:06:30,390 --> 01:06:33,150
嗯，猜测
HTML的底部。

1423
01:06:33,150 --> 01:06:35,810
为什么迎接（）调用，或什么时候？

1424
01:06:35,810 --> 01:06:39,730

1425
01:06:39,730 --> 01:06:44,030
>> 显然，最好的，我可以告诉，
提交表单提交时，

1426
01:06:44,030 --> 01:06:47,200
我要为所欲为
这些引号内。

1427
01:06:47,200 --> 01:06:50,900
具体地说，我现在就打电话给
迎接（），则返回false。

1428
01:06:50,900 --> 01:06:53,090
>> 好吧，让我们来看看网
这里是效果第一。

1429
01:06:53,090 --> 01:06:58,290
所以，让我继续前进，并键入
，譬如说，罗兰，提交。

1430
01:06:58,290 --> 01:06:59,440
您好罗兰。

1431
01:06:59,440 --> 01:07:02,990
让我们来看看，也许这只是
一个幸运实施。

1432
01:07:02,990 --> 01:07:03,200
不。

1433
01:07:03,200 --> 01:07:05,990
因此，它的输入任何
命名其实我放在那里。

1434
01:07:05,990 --> 01:07:07,970
>> 但是请注意，有什么不改变。

1435
01:07:07,970 --> 01:07:10,360
该网址仍是DOM-0.html。

1436
01:07:10,360 --> 01:07:11,820
有没有注册页面register.php。

1437
01:07:11,820 --> 01:07:13,110
有没有第二个文件。

1438
01:07:13,110 --> 01:07:14,930
有没有action属性。

1439
01:07:14,930 --> 01:07:19,720
那么，什么是返回false
大概是在做什么？

1440
01:07:19,720 --> 01:07:23,660
为什么我调用迎接（），然后
可能返回false？

1441
01:07:23,660 --> 01:07:26,420
通常会发生什么，当你点击
提交表单，甚至我们有

1442
01:07:26,420 --> 01:07:27,854
在过去一周内看到吗？

1443
01:07:27,854 --> 01:07:29,900
>> 观众：[听不清]。

1444
01:07:29,900 --> 01:07:30,860
>> 国宝MALAN：去某处，对不对？

1445
01:07:30,860 --> 01:07:32,720
去一些目标URL。

1446
01:07:32,720 --> 01:07:34,120
但我不希望这样的事情发生在这里。

1447
01:07:34,120 --> 01:07:37,620
我想我的网页是完全
如Gmail，一旦你的动态

1448
01:07:37,620 --> 01:07:38,650
在那里，你呆在那里。

1449
01:07:38,650 --> 01:07:42,900
网址不会改变的方式，
表示重新加载整个页面。

1450
01:07:42,900 --> 01:07:46,680
相反，我只是想改变一些东西
像打印出来的东西

1451
01:07:46,680 --> 01:07:48,320
这里的屏幕上。

1452
01:07:48,320 --> 01:07:49,630
>> 那么，让我清洁
一点点。

1453
01:07:49,630 --> 01:07:55,370
让我开拓DOM-0，但
让我开了DOM-2。

1454
01:07:55,370 --> 01:07:57,350
只要你在这里看到一些语法。

1455
01:07:57,350 --> 01:08:02,080
>> 事实证明，我们刚才
没有使用原始的JavaScript。

1456
01:08:02,080 --> 01:08:04,420
因此，这是真正的语言
的JavaScript。

1457
01:08:04,420 --> 01:08:07,340
你们中的一些人可能知道
图书馆称为jQuery的。

1458
01:08:07,340 --> 01:08:09,980
>> 因此，jQuery是不一样的
如JavaScript的东西。

1459
01:08:09,980 --> 01:08:14,110
这只是一个图书馆，一个真正聪明
小伙写和推广等

1460
01:08:14,110 --> 01:08:18,100
几乎每个人都在世界上现在
使用jQuery使用JavaScript的时候。

1461
01:08:18,100 --> 01:08:20,890
乍一看，说实话，
看起来多了几分神秘。

1462
01:08:20,890 --> 01:08:24,990
但是你会发现，尤其是如果你去
有您的最终项目网站

1463
01:08:24,990 --> 01:08:29,029
发展，你会发现，这
做清理工作，并节省您相当

1464
01:08:29,029 --> 01:08:30,229
几行代码。

1465
01:08:30,229 --> 01:08:33,189
>> 所以，我们就如何一目了然
这种形式的工作。

1466
01:08:33,189 --> 01:08:35,664
请注意，我怎么删除显然
从我的HTML？

1467
01:08:35,664 --> 01:08:38,240

1468
01:08:38,240 --> 01:08:40,630
有没有提交处理
可以这么说。

1469
01:08:40,630 --> 01:08:41,470
有没有属性。

1470
01:08:41,470 --> 01:08:43,359
因为你知道，
我真的不喜欢吗？

1471
01:08:43,359 --> 01:08:45,640
我觉得像我们下降
到旧习惯。

1472
01:08:45,640 --> 01:08:49,340
就像它已开始感觉邋遢
以交融两个CSS

1473
01:08:49,340 --> 01:08:52,149
HTML，因为你是一种投掷
各地不同的语言

1474
01:08:52,149 --> 01:08:56,180
的地方，同样也开始觉得
像一个坏的道路下去

1475
01:08:56,180 --> 01:09:01,069
里面有我，我把JavaScript代码
HTML，而不是保出来。

1476
01:09:01,069 --> 01:09:02,279
>> 因此，这里的教训。

1477
01:09:02,279 --> 01:09:05,080
在DOM-2.HTML，我保出来。

1478
01:09:05,080 --> 01:09:07,399
我做的事情略有
是不同的。

1479
01:09:07,399 --> 01:09:09,630
现在，我要挥挥手
这确实

1480
01:09:09,630 --> 01:09:10,590
引擎盖下。

1481
01:09:10,590 --> 01:09:14,210
但是，只是现在假设，首先
这个库中的代码线

1482
01:09:14,210 --> 01:09:18,170
所谓jQuery只是意味着，当
文件准备就绪，做到以下几点。

1483
01:09:18,170 --> 01:09:20,080
>> 因为网页可以采取的
一段时间来加载。

1484
01:09:20,080 --> 01:09:23,029
你可能会在一个缓慢的互联网
连接，并且它可能是纺

1485
01:09:23,029 --> 01:09:25,290
和纺纱，最后它的加载。

1486
01:09:25,290 --> 01:09:29,060
这行代码只是说，等到
整页都准备好了，文件

1487
01:09:29,060 --> 01:09:31,189
准备就绪后，才执行该代码。

1488
01:09:31,189 --> 01:09:34,390
>> 现在通知，这可能是
最有用的

1489
01:09:34,390 --> 01:09:36,189
从jQuery带走。

1490
01:09:36,189 --> 01:09:42,140
这里是此行的精神非常相似
这更长的行这里。

1491
01:09:42,140 --> 01:09:46,920
而在原料的JavaScript代码，
存在一个文件的全局对象

1492
01:09:46,920 --> 01:09:50,460
有getElementById（）调用的函数，
谁写的人

1493
01:09:50,460 --> 01:09:55,720
jQuery的简化，只是说
美元符号，然后将里面的

1494
01:09:55,720 --> 01:10:00,250
括号把两个引号，然后
其次，把一个hash符号

1495
01:10:00,250 --> 01:10:02,250
你想抓住唯一的ID。

1496
01:10:02,250 --> 01:10:06,170
因此，这是相当于
的document.getElementById。

1497
01:10:06,170 --> 01:10:11,090
>> 同时，提交只是意味着
提交你的任何形式

1498
01:10:11,090 --> 01:10:14,240
指的是在左边，去
提前执行。

1499
01:10:14,240 --> 01:10:16,600
但是，这是现在的好奇心。

1500
01:10:16,600 --> 01:10:19,560
什么有什么奇怪
我这里强调的吗？

1501
01:10:19,560 --> 01:10:23,840

1502
01:10:23,840 --> 01:10:28,594
它不仅是一种语法
新的，还缺少些什么。

1503
01:10:28,594 --> 01:10:29,558
>> 观众：这只是调用的函数？

1504
01:10:29,558 --> 01:10:31,970
这不叫警报？

1505
01:10:31,970 --> 01:10:32,440
>> DAVID马兰：是啊。

1506
01:10:32,440 --> 01:10:35,450
好了，所以提醒（）跌
在这里，是公平的。

1507
01:10:35,450 --> 01:10:39,520
但有没有提及
名称，就像你知道的，foo或

1508
01:10:39,520 --> 01:10:40,980
这里的东西了。

1509
01:10:40,980 --> 01:10:43,830
的确，这是一个特点
JavaScript代码，这是相当

1510
01:10:43,830 --> 01:10:45,370
功能强大，但也颇具新意。

1511
01:10:45,370 --> 01:10:47,460
和PHP实际上有这一点。

1512
01:10:47,460 --> 01:10:49,500
>> 让我继续做
一些真正的快速。

1513
01:10:49,500 --> 01:10:52,030
让我继续前进，在这里放了这一点。

1514
01:10:52,030 --> 01:10:52,600
让我这样做。

1515
01:10:52,600 --> 01:10:53,690
功能。

1516
01:10:53,690 --> 01:10:56,455
让我们把这个handler（）的。

1517
01:10:56,455 --> 01:10:58,290
一个处理函数可以这么说。

1518
01:10:58,290 --> 01:11:00,110
一些处理一些操作。

1519
01:11:00,110 --> 01:11:02,700
让我清理我的压痕。

1520
01:11:02,700 --> 01:11:04,380
并把这个在这里。

1521
01:11:04,380 --> 01:11:06,090
并把在这里。

1522
01:11:06,090 --> 01:11:06,470
没错。

1523
01:11:06,470 --> 01:11:07,060
确定。

1524
01:11:07,060 --> 01:11:10,300
>> 所以，现在我有一个调用的函数
处理程序（），我真的不知道

1525
01:11:10,300 --> 01:11:10,890
它做什么呢。

1526
01:11:10,890 --> 01:11:12,710
它只是仍然有这些东西。

1527
01:11:12,710 --> 01:11:13,900
哎呦。

1528
01:11:13,900 --> 01:11:15,820
花了太多。

1529
01:11:15,820 --> 01:11:18,490
让我们做到这一点。

1530
01:11:18,490 --> 01:11:18,990
好的。

1531
01:11:18,990 --> 01:11:20,240
抱歉。

1532
01:11:20,240 --> 01:11:23,140

1533
01:11:23,140 --> 01:11:23,690
好的。

1534
01:11:23,690 --> 01:11:24,720
让我这样做。

1535
01:11:24,720 --> 01:11:25,020
确定。

1536
01:11:25,020 --> 01:11:27,040
这看起来不错，直
现在转发。

1537
01:11:27,040 --> 01:11:29,090
让我这样做。

1538
01:11:29,090 --> 01:11:29,860
做到这一点。

1539
01:11:29,860 --> 01:11:30,950
和确定。

1540
01:11:30,950 --> 01:11:33,080
所以，现在，让我们把这个在这里。

1541
01:11:33,080 --> 01:11:35,840

1542
01:11:35,840 --> 01:11:37,270
在飞行中没有更多的规划。

1543
01:11:37,270 --> 01:11:37,900
确定。

1544
01:11:37,900 --> 01:11:40,000
>> 所以，现在，让我们回到
那里的故事开始了。

1545
01:11:40,000 --> 01:11:43,530
此前，我说，这条线在这里
意味着，当文档准备好，去

1546
01:11:43,530 --> 01:11:44,380
进取，做到这一点。

1547
01:11:44,380 --> 01:11:45,660
我想要什么做的？

1548
01:11:45,660 --> 01:11:49,070
好吧具体地说，我想去
进取，做到以下几点。

1549
01:11:49,070 --> 01:11:53,700
执行下面这行代码，然后
我要你做的是调用这个

1550
01:11:53,700 --> 01:11:56,370
功能当表单被提交。

1551
01:11:56,370 --> 01:11:57,730
>> 现在，这是很有趣。

1552
01:11:57,730 --> 01:11:59,170
这本身不是一个函数。

1553
01:11:59,170 --> 01:12:02,540
请注意，我不是把括号
这里以正常的方式。

1554
01:12:02,540 --> 01:12:06,800
我从字面上传递一个调用的函数
处理程序（）到另一个函数

1555
01:12:06,800 --> 01:12:10,800
所谓的提交（）作为参数的
虽然它就像一个变量。

1556
01:12:10,800 --> 01:12:14,290
这也是特征之一
JavaScript中，函数是自己

1557
01:12:14,290 --> 01:12:15,710
其实只是对象。

1558
01:12:15,710 --> 01:12:18,350
事实上，他们真的只是
某种类型的变量。

1559
01:12:18,350 --> 01:12:21,340
并且如果该函数的名称是
处理程序（），没有理由我不能

1560
01:12:21,340 --> 01:12:23,390
在把它作为这里的参数。

1561
01:12:23,390 --> 01:12:27,530
这意味着表单时
与演示的ID是

1562
01:12:27,530 --> 01:12:29,320
提交时，调用这个函数。

1563
01:12:29,320 --> 01:12:32,770
>> 但现在，如果我撤消了这一切，
那为什么我也许做

1564
01:12:32,770 --> 01:12:34,850
这个刚才？

1565
01:12:34,850 --> 01:12:36,840
那么，这是一个匿名函数。

1566
01:12:36,840 --> 01:12:41,080
因为坦率地说，我才意识到我为什么
懒得浪费时间宣告

1567
01:12:41,080 --> 01:12:45,540
调用的函数句柄（）只调用
它在一个且只有一个地方？

1568
01:12:45,540 --> 01:12:48,640
如果我不需要名字，我不
需要调用它不止一个地方，

1569
01:12:48,640 --> 01:12:51,200
我们只是执行函数
正确的，我需要它。

1570
01:12:51,200 --> 01:12:55,190
所以JavaScript和PHP的支持一下
被称为匿名函数，

1571
01:12:55,190 --> 01:12:57,900
让我做的正是这一点。

1572
01:12:57,900 --> 01:12:59,570
>> 但我们只是表面文章。

1573
01:12:59,570 --> 01:13:02,430
让我们用挑逗只是一对夫妇
这里最后的例子。

1574
01:13:02,430 --> 01:13:04,600
>> 如果我进入quote.php。

1575
01:13:04,600 --> 01:13:07,160

1576
01:13:07,160 --> 01:13:11,870
请注意，这实际上是一个PHP
函数，PHP程序，我写

1577
01:13:11,870 --> 01:13:15,270
该预计称为HTTP参数
符号，我可以通过在

1578
01:13:15,270 --> 01:13:16,730
喜欢FB的值。

1579
01:13:16,730 --> 01:13:20,010
如果我们真正看看源
代码，这个查询是一个免费网站

1580
01:13:20,010 --> 01:13:23,680
所谓雅虎财经，就像对集
7，和它返回给我

1581
01:13:23,680 --> 01:13:26,580
东西显然
已知的格式是JSON  - 

1582
01:13:26,580 --> 01:13:28,010
JavaScript对象表示法。

1583
01:13:28,010 --> 01:13:28,810
这只是一个对象。

1584
01:13:28,810 --> 01:13:32,500
注意花括号，引号，
冒号和逗号。

1585
01:13:32,500 --> 01:13:34,720
>> 现在，同时，这是很酷。

1586
01:13:34,720 --> 01:13:38,520
因为我也许可以使用编程
语言生成URL

1587
01:13:38,520 --> 01:13:40,370
看起来像这样动态的，
对不对？

1588
01:13:40,370 --> 01:13:43,340
我可以将其更改为谷歌
并取回谷歌的

1589
01:13:43,340 --> 01:13:47,930
股票价格为$ 1,017.55。

1590
01:13:47,930 --> 01:13:49,640
因此，让我们看看如果我们不能现在就用这个​​。

1591
01:13:49,640 --> 01:13:56,590
>> 让我去的ajax-0在这里，这
如下所示。

1592
01:13:56,590 --> 01:13:59,750
这只是一个网站，有
一个按钮的表单。

1593
01:13:59,750 --> 01:14:05,860
让我在这里继续前进，键入YHOO
雅虎的股票代码，点击获取

1594
01:14:05,860 --> 01:14:10,530
报价单，现在发现我已经得到了
一个警报，32.86。

1595
01:14:10,530 --> 01:14:14,050
>> 让我真正去票友版本
的这一页，第二版，并

1596
01:14:14,050 --> 01:14:17,530
输入比方说微软，MSFT。

1597
01:14:17,530 --> 01:14:18,410
获取报价。

1598
01:14:18,410 --> 01:14:19,850
现在发现，没有任何警报。

1599
01:14:19,850 --> 01:14:22,770
请注意，如果说价格
被确定的？

1600
01:14:22,770 --> 01:14:27,060
有最简单的例子
暗示了什么Gchat，和Facebook

1601
01:14:27,060 --> 01:14:30,070
聊天，和Gmail，以及其他类似
网站正在做通过实际

1602
01:14:30,070 --> 01:14:31,290
改变网页。

1603
01:14:31,290 --> 01:14:31,800
>> 注意到这一点。

1604
01:14:31,800 --> 01:14:33,120
让我重新加载页面。

1605
01:14:33,120 --> 01:14:35,080
让我打开Chrome的督察。

1606
01:14:35,080 --> 01:14:36,890
让我去的元素
标签这儿吧。

1607
01:14:36,890 --> 01:14:42,310
现在请注意，如果我放大到这里和
打开这个了，请注意，这是我的

1608
01:14:42,310 --> 01:14:44,500
HTML DOM  - 我的文档对象模型。

1609
01:14:44,500 --> 01:14:45,920
这是我的HTML。

1610
01:14:45,920 --> 01:14:48,750
但现在发现，即使它是怎么回事
是一个有点难以看到它在两个

1611
01:14:48,750 --> 01:14:52,080
在一次地方，如果我输入的FB
在这里，看底部

1612
01:14:52,080 --> 01:14:54,110
屏幕而已。

1613
01:14:54,110 --> 01:14:57,720
>> 它实际上改变
我的HTML的飞行。

1614
01:14:57,720 --> 01:15:01,670
并且它在做这个很简单
通过做这样的事情。

1615
01:15:01,670 --> 01:15:06,800
如果我打开了AJAX-2，实施通知
什么是性感

1616
01:15:06,800 --> 01:15:09,560
如此，即使它很丑陋，
但由于复杂的，因为这

1617
01:15:09,560 --> 01:15:11,910
在功能上，它有一些
HTML在底部。

1618
01:15:11,910 --> 01:15:13,810
但是请注意，我用来标记。

1619
01:15:13,810 --> 01:15:16,640
我们还没有使用过，但是，这是
像，但它不会强迫

1620
01:15:16,640 --> 01:15:17,840
一切都迈上了一个新行。

1621
01:15:17,840 --> 01:15:20,830
它只是使一个矩形区域
在同一行上实质上。

1622
01:15:20,830 --> 01:15:22,870
>> 请注意，我给了它价格的ID。

1623
01:15:22,870 --> 01:15:26,800
和原来通过使用相同的
JavaScript库，我有一个函数

1624
01:15:26,800 --> 01:15:30,440
所谓引号（）这就是所谓的时
表单被提交。

1625
01:15:30,440 --> 01:15:31,800
而我在做什么是这样的。

1626
01:15:31,800 --> 01:15:35,730
我在JavaScript中声明一个变量
所谓的url，保存价值

1627
01:15:35,730 --> 01:15:38,650
quote.php？符号=。

1628
01:15:38,650 --> 01:15:44,220
换句话说，我自己也开始
准备一个HTTP请求，然后

1629
01:15:44,220 --> 01:15:49,250
我串连到了一个加号
任何与该ID的元素

1630
01:15:49,250 --> 01:15:54,190
的符号是，该通知是
文字栏位就在这里。

1631
01:15:54,190 --> 01:15:56,630
所以就像我们在过去曾形式。

1632
01:15:56,630 --> 01:16:01,450
>> 然后事实证明在jQuery中，如果你
打电话。VAL（），调用一个val的

1633
01:16:01,450 --> 01:16:05,900
函数，数值函数，即得到
无论用户已输入的字词。

1634
01:16:05,900 --> 01:16:08,920
然后所有的网络流量
出现这种情况是这样的。

1635
01:16:08,920 --> 01:16:11,230
$。的getJSON。

1636
01:16:11,230 --> 01:16:13,720
>> 而作为一个不谈，美元符号
只是一个速记符号。

1637
01:16:13,720 --> 01:16:16,860
这真是jQuery.getJSON。

1638
01:16:16,860 --> 01:16:21,520
让我到JSON从这个URL，而当
请求回来，称此

1639
01:16:21,520 --> 01:16:26,550
函数并传入作为参数
无论来自服​​务器返回。

1640
01:16:26,550 --> 01:16:31,205
>> 所以，换句话说，如果我回去
浏览器了，我回去quote.php，

1641
01:16:31,205 --> 01:16:35,590
什么我的浏览器正在做的是越来越
这个块的数据。

1642
01:16:35,590 --> 01:16:38,930
当我去这个网页在这里，
注意，如果我们不是去网络

1643
01:16:38,930 --> 01:16:43,820
选项​​卡，然后清除它，然后键入
像歌谷歌和获取

1644
01:16:43,820 --> 01:16:46,340
引号，注意页没有改变。

1645
01:16:46,340 --> 01:16:50,990
但一个HTTP请求是，什么
回到这里，如果我们看一下

1646
01:16:50,990 --> 01:16:56,130
响应是一大堆的JSON
我们访问的最后用

1647
01:16:56,130 --> 01:16:58,070
这个简单的线条在这里。

1648
01:16:58,070 --> 01:17:00,150
>> 数据是得到了
从服务器。

1649
01:17:00,150 --> 01:17:02,120
价格的名义
关键我在乎。

1650
01:17:02,120 --> 01:17:05,230
所以data.price给我的。

1651
01:17:05,230 --> 01:17:07,540
>> 现在同时，与此
是最后一个例子。

1652
01:17:07,540 --> 01:17:09,280
你可以做了更多的页面。

1653
01:17:09,280 --> 01:17:12,440
实际上之一，还有两人。

1654
01:17:12,440 --> 01:17:14,780
我们可以带回
标记，如果你还记得这个。

1655
01:17:14,780 --> 01:17:15,850
这就是JavaScript的。

1656
01:17:15,850 --> 01:17:17,110
我们可以做到这一点。

1657
01:17:17,110 --> 01:17:17,690
非常令人兴奋的。

1658
01:17:17,690 --> 01:17:18,800
我们把这个作为一个悬念。

1659
01:17:18,800 --> 01:17:21,590
>> 但更令人兴奋的是，你可以
做这样的事情。

1660
01:17:21,590 --> 01:17:25,940
如果我去的地理定位-1，它的出现
认为Chrome知道我们是在

1661
01:17:25,940 --> 01:17:30,672
纬度经度42.37，-71.10。

1662
01:17:30,672 --> 01:17:32,940
因此，有更多的有
在您的处置。

1663
01:17:32,940 --> 01:17:34,290
但更多的是在下周。

1664
01:17:34,290 --> 01:17:35,540
星期一见。

1665
01:17:35,540 --> 01:17:37,558