1
00:00:00,000 --> 00:00:02,570
[Powered by Google Translate] [第9周]

2
00:00:02,570 --> 00:00:04,740
[戴维·J·马兰 - 哈佛大学]

3
00:00:04,740 --> 00:00:07,170
[这是CS50。 -  CS50.TV]

4
00:00:07,170 --> 00:00:12,350
好的。欢迎回来。这是CS50，这是第9周开始。

5
00:00:12,350 --> 00:00:16,600
今天，我们特别侧重于设计，不再在C的背景下，

6
00:00:16,600 --> 00:00:20,010
但在的背景下，PHP和SQL位和一些JavaScript，

7
00:00:20,010 --> 00:00:23,730
特别是朝双方的pset 7月底，最终的项目。

8
00:00:23,730 --> 00:00:26,310
事实上，在这一点上，如果你是在最终的项目

9
00:00:26,310 --> 00:00:30,100
大概一个小时前，你至少开始给一些思考

10
00:00:30,100 --> 00:00:33,730
最终的项目，你在想你想与1或2个同学，

11
00:00:33,730 --> 00:00:36,150
如果你无法连接同学，

12
00:00:36,150 --> 00:00:40,570
随意填写在cs50.net/partners/form。

13
00:00:40,570 --> 00:00:42,880
它会问你你是谁，你在想的是什么样的项目，

14
00:00:42,880 --> 00:00:44,870
你住的地方只是后勤方面的原因。

15
00:00:44,870 --> 00:00:49,510
然后，如果你要留意在未来一周左右的电子表格URL，

16
00:00:49,510 --> 00:00:53,520
然后，你可以看到一个只读版本的谷歌文档

17
00:00:53,520 --> 00:00:56,010
我们正在收集这方面的信息。

18
00:00:56,010 --> 00:00:58,930
所以，如果你想与别人，通过各种手段随时接触到人

19
00:00:58,930 --> 00:01:00,480
通过这种机制。

20
00:01:00,480 --> 00:01:02,690
但大多数人做的工作独奏。这是完全正常的。

21
00:01:02,690 --> 00:01:06,120
所以，不要觉得这是不以任何方式强制性的。

22
00:01:06,120 --> 00:01:09,680
上周五，这只是我和几个在这里的球队，

23
00:01:09,680 --> 00:01:11,100
最空的影院。

24
00:01:11,100 --> 00:01:14,600
有3个游客坐在上面，所以这是一个有点尴尬的。

25
00:01:14,600 --> 00:01:18,970
我们谈的是数据库和我们谈到的pset一点点。

26
00:01:18,970 --> 00:01:22,200
如果你没有碰巧赶上上的视频只是还没有，这是罚款。

27
00:01:22,200 --> 00:01:26,770
我会尽力定义的任何条款，否则，我们会想当然地

28
00:01:26,770 --> 00:01:28,840
根据上周五的演讲。

29
00:01:28,840 --> 00:01:32,550
>> 但今天我们要尝试让大家给点意见

30
00:01:32,550 --> 00:01:34,990
不只是能够做这样的事情的pset 7

31
00:01:34,990 --> 00:01:37,360
但真正了解发生了什么事情引擎盖下的，

32
00:01:37,360 --> 00:01:41,910
特别是一些抽象的functions.php文件中，我们将在

33
00:01:41,910 --> 00:01:45,780
让你的生活更容易一点，但让你最终明白

34
00:01:45,780 --> 00:01:48,760
所以，当训练车轮脱落，在几个星期后，你仍然可以生存

35
00:01:48,760 --> 00:01:53,750
在现实世界中，没有任何的CS50的框架下你做这个东西。

36
00:01:53,750 --> 00:01:57,500
这$ _SESSION，对于那些你熟悉的人

37
00:01:57,500 --> 00:02:01,960
已经赶上了上周五的视频，是什么会议，让我们做

38
00:02:01,960 --> 00:02:04,330
在一个基于PHP的Web应用程序？

39
00:02:04,330 --> 00:02:09,650
这是一个超全局变量，这意味着它类似的精神GET和POST

40
00:02:09,650 --> 00:02:13,970
和其他几个人，但是这是什么东西有用吗？

41
00:02:13,970 --> 00:02:18,320
>> 什么是会议？是啊。 [学生]登录。

42
00:02:18,320 --> 00:02:21,040
你说什么？ [学生]登录记录。的确，。

43
00:02:21,040 --> 00:02:25,100
在pset中7，我们正在使用的这届超全局，以方便登录。

44
00:02:25,100 --> 00:02:28,600
这个超全局的好处是，它是一个关联数组。

45
00:02:28,600 --> 00:02:33,190
一个关联数组，召回，仅仅是一个数组，但其索引不再是数字

46
00:02:33,190 --> 00:02:37,670
像012。它们可以是数字或它们甚至可以是字符串。

47
00:02:37,670 --> 00:02:44,890
因此，如果你的pset 7跳入，你可能还记得，我们存储的关键ID

48
00:02:44,890 --> 00:02:50,330
里面的这个关联数组的值是123  - 

49
00:02:50,330 --> 00:02:53,780
无论当前登录用户的ID。

50
00:02:53,780 --> 00:02:59,470
这样做的动机是，即使用户访问了本地

51
00:02:59,470 --> 00:03:02,720
或我的网站更一般的，然后他们记录中，

52
00:03:02,720 --> 00:03:07,320
即使他们不点击一个链接或返回到我的网站，5分钟

53
00:03:07,320 --> 00:03:10,730
或者甚至一个小时，甚至一天，但他们离开他们的浏览器窗口打开，

54
00:03:10,730 --> 00:03:14,370
通过超全局，我记得他们登录。

55
00:03:14,370 --> 00:03:21,140
>> 换句话说，它可以让我稍微长期什么我想知道的关于用户存储。

56
00:03:21,140 --> 00:03:24,390
你也可以想起来真是一个购物车的化身。

57
00:03:24,390 --> 00:03:27,740
像亚马逊这样的地方显然是让你把东西放进了购物车，

58
00:03:27,740 --> 00:03:32,230
但HTTP，权力网络的协议是无状态的

59
00:03:32,230 --> 00:03:34,230
在这个意义上，当你访问一个网站，

60
00:03:34,230 --> 00:03:37,290
在大多数情况下，你也别有一番不间断的网络连接

61
00:03:37,290 --> 00:03:39,270
您的浏览器和服务器之间。

62
00:03:39,270 --> 00:03:42,190
只要你下载了HTML，JPEG和GIF文件和所有这一切，

63
00:03:42,190 --> 00:03:48,200
连接消失，你只是有一个从服务器复制的HTML和诸如此类的东西。

64
00:03:48,200 --> 00:03:53,000
但是，如果服务器要记住关于你的东西，

65
00:03:53,000 --> 00:03:57,580
在服务器上记录这些信息的负担。

66
00:03:57,580 --> 00:04:00,130
所以你的程序员谁控制服务器

67
00:04:00,130 --> 00:04:04,400
可以把任何你最想在这个超全局关联数组

68
00:04:04,400 --> 00:04:06,850
，这将是有下一次用户回来，

69
00:04:06,850 --> 00:04:12,070
无论是分钟，甚至几天后，除非关闭浏览器窗口，

70
00:04:12,070 --> 00:04:14,360
在这一点SESSION消失。

71
00:04:14,360 --> 00:04:17,779
因此，它是短暂的存储，它的非持久的，它的意思走

72
00:04:17,779 --> 00:04:22,360
只要用户关闭浏览器 - 不只是选项卡中，往往是整个的浏览器，

73
00:04:22,360 --> 00:04:24,930
从而有效地注销用户。

74
00:04:24,930 --> 00:04:28,000
所以，事情其实这是怎么实现的呢？

75
00:04:28,000 --> 00:04:31,360
让我们快速浏览一下我们看一个简单的例子，在上周五。

76
00:04:31,360 --> 00:04:33,340
对于那些不熟悉，它是像这样简单。

77
00:04:33,340 --> 00:04:35,910
这是一个网页，其唯一目的就是要告诉我

78
00:04:35,910 --> 00:04:38,000
多少次我曾参观过这个页面。

79
00:04:38,000 --> 00:04:41,670
这是第一次来这里上周一，我曾经访问过这个网站，所以说0次。

80
00:04:41,670 --> 00:04:46,940
>> 但是，如果我开始重新加载这个页面，它说1次，2，3，4，5，

81
00:04:46,940 --> 00:04:49,800
，这最终将只是继续向上计数，起来，起​​来，起​​来，起​​来

82
00:04:49,800 --> 00:04:53,130
其实我每次单击刷新就可以了。

83
00:04:53,130 --> 00:04:58,830
所以，这是怎么工作的呢？让我进去，这个文件称为counter.php。

84
00:04:58,830 --> 00:05:02,490
它的上半部分是蓝色的意见，但有趣的是在这里。

85
00:05:02,490 --> 00:05:06,670
第13行，我们调用这个函数session_start的，

86
00:05:06,670 --> 00:05:09,600
，这简直是所有你需要做的，如果你想要访问

87
00:05:09,600 --> 00:05:13,610
这个特殊的超全局变量名为$ _SESSION。

88
00:05:13,610 --> 00:05:17,430
这使得这一切成为可能，我们可以看到在某一时刻怎么说都是可能的。

89
00:05:17,430 --> 00:05:20,350
在第16行通知，我在做什么。

90
00:05:20,350 --> 00:05:25,960
如果“计数器”的键，调用计数器 - 换句话说，索引值 - 

91
00:05:25,960 --> 00:05:32,310
存在这个数组里面的所谓的会话，然后我在做什么与它下面的行吗？

92
00:05:32,310 --> 00:05:36,650
第18行做什么？

93
00:05:36,650 --> 00:05:40,360
>> [听不见的学生响应那是什么？ [学生]保存的价值。好。

94
00:05:40,360 --> 00:05:45,800
它的值存储在会议现在在一个新的本地临时变量，

95
00:05:45,800 --> 00:05:48,250
$计数器全部用小写。

96
00:05:48,250 --> 00:05:50,770
请注意，PHP已经有点懒。

97
00:05:50,770 --> 00:05:55,550
请注意，我们没有任何提及的整数或浮点数或字符串，或类似的东西，

98
00:05:55,550 --> 00:06:00,480
因为PHP是弱类型，你没有指定类型的变量，

99
00:06:00,480 --> 00:06:03,310
在这种情况下，在这里我还没有甚至宣称它。

100
00:06:03,310 --> 00:06:08,980
我声明这些花括号内的，不像C，这其实是没关系的。

101
00:06:08,980 --> 00:06:13,800
无论怎样深层嵌套的变量的声明是在PHP  - 

102
00:06:13,800 --> 00:06:16,650
内部的，里面的大括号和大括号 - 

103
00:06:16,650 --> 00:06:21,230
在那一刻，它会在时间存在的程序的其余部分，

104
00:06:21,230 --> 00:06:22,680
为更好或更坏。

105
00:06:22,680 --> 00:06:26,930
因此，它立即成为全球性的，只要你定义它，因为我们在这里做的。

106
00:06:26,930 --> 00:06:31,620
>> 否则，如果我没有发现有什么事，在SESSION超全局，

107
00:06:31,620 --> 00:06:34,680
我似乎初始化这个变量的计数器为0，

108
00:06:34,680 --> 00:06:37,580
只是假设该用户从未来过这里。

109
00:06:37,580 --> 00:06:40,030
然后，这当然是递增计数器如何？

110
00:06:40,030 --> 00:06:44,480
我里面的这个关联数组的值更新

111
00:06:44,480 --> 00:06:49,530
通过设置它等于任何逆流+ 1。

112
00:06:49,530 --> 00:06:53,520
如果我向下滚动的HTML页面，它其实很简单。

113
00:06:53,520 --> 00:06:58,920
我在本页面身体，“你已经访问此网站和太次。”

114
00:06:58,920 --> 00:07:00,350
这是一个PHP构造。

115
00:07:00,350 --> 00:07:06,080
如果你这样做<=，有效地相当于什么功能？

116
00:07:07,920 --> 00:07:12,600
这真是像printf的东西，我们已经见过很多次在C，

117
00:07:12,600 --> 00:07:15,940
虽然你可能已经知道，从规范的pset 7，

118
00:07:15,940 --> 00:07:20,160
打印也是一个函数，只是打印出一些东西，但它并没有实际使用的格式代码，

119
00:07:20,160 --> 00:07:23,270
实际上，你可以说回声。

120
00:07:23,270 --> 00:07:27,460
他们都是非常轻微的净影响是不同的，即使最终。

121
00:07:27,460 --> 00:07:31,270
因此，使用等号只是一个优雅的方式做它

122
00:07:31,270 --> 00:07:34,910
更简洁，否则你可能可以。

123
00:07:34,910 --> 00:07:38,370
所以这是此网站。它打印出计数器的值。

124
00:07:38,370 --> 00:07:40,550
这是怎么实际发生的事情吗？

125
00:07:40,550 --> 00:07:43,250
您可能还记得一个星期前，我们开始寻找下面的罩

126
00:07:43,250 --> 00:07:47,910
在网页如何使用该Inspector选项卡。

127
00:07:47,910 --> 00:07:51,900
>> Chrome有Mac版本，Windows版本，甚至Linux版本，这两者

128
00:07:51,900 --> 00:07:59,510
Firefox和IE浏览器也有类似的机制，让你有这样的内置调试器

129
00:07:59,510 --> 00:08:01,400
的浏览器的内部。

130
00:08:01,400 --> 00:08:03,040
让我们来看看下面的。

131
00:08:03,040 --> 00:08:06,960
在这里，我们有一大堆的标签记得，最左边的一个元素，

132
00:08:06,960 --> 00:08:10,700
不管如何godawful，HTML和JavaScript是在一个页面，

133
00:08:10,700 --> 00:08:15,710
记得，与“元素”选项卡中，您实际上可以浏览HTML层次

134
00:08:15,710 --> 00:08:17,050
漂亮和整齐。

135
00:08:17,050 --> 00:08:19,370
所以，如果你想学习谷歌或Facebook这样的网站

136
00:08:19,370 --> 00:08:22,370
还是真的任何网站，你可能会更好过

137
00:08:22,370 --> 00:08:26,360
这样的源代码，而不是观看原始源，

138
00:08:26,360 --> 00:08:29,580
它可以是一个烂摊子，我们已经看到了，特别是在谷歌的网站。

139
00:08:29,580 --> 00:08:32,220
所以，如果我不是在这里点击“网络”选项卡，

140
00:08:32,220 --> 00:08:34,830
让我们来看看发生了什么事情，就当我访问这个页面。

141
00:08:34,830 --> 00:08:38,669
首先，让我清楚我的缓存。

142
00:08:38,669 --> 00:08:43,570
我要进入​​Chrome浏览器中的设置，然后去历史

143
00:08:43,570 --> 00:08:46,420
然后清除所有浏览数据。

144
00:08:46,420 --> 00:08:48,170
你可能会用于其他目的，[笑声]

145
00:08:48,170 --> 00:08:51,990
但是当它涉及到开发的网站，它实际上是有用的 - 

146
00:08:51,990 --> 00:08:55,980
如果你笑，你知道的。 [笑声]

147
00:08:55,980 --> 00:08:59,310
它实际上是非常有用的网站开发时，因为现实的情况是

148
00:08:59,310 --> 00:09:04,100
缓存缓存的HTML文件，JavaScript文件的事情，比如饼干之类的东西

149
00:09:04,100 --> 00:09:06,390
实际上可以成为一个很头痛，因为如果无论出于何种原因

150
00:09:06,390 --> 00:09:11,500
浏览器决定缓存一些文件，但你已经切换到文件服务器上的

151
00:09:11,500 --> 00:09:14,670
但浏览器还没有真正认识到该文件已经修改

152
00:09:14,670 --> 00:09:19,060
，因此不实际重新下载它，甚至当您单击Reload按钮，

153
00:09:19,060 --> 00:09:23,210
最万无一失的方法之一，只是确保故障是不是与您的代码，

154
00:09:23,210 --> 00:09:26,480
这是浏览器的行为，是要在您的浏览器

155
00:09:26,480 --> 00:09:29,950
清除全部历史记录，以便有没有混淆。

156
00:09:29,950 --> 00:09:33,210
>> 然后，如果你真的想成为偏执狂，退出浏览器，重新启动它，

157
00:09:33,210 --> 00:09:35,660
然后确保所有工作。

158
00:09:35,660 --> 00:09:38,820
因此，在短，清除缓存是做开发的时候。

159
00:09:38,820 --> 00:09:40,690
所以，在这里，我们有“网络”选项卡。

160
00:09:40,690 --> 00:09:46,020
我以前曾访问过的网站的9倍，但让我继续，并单击“重新加载”。

161
00:09:46,020 --> 00:09:47,500
我是回落到0。

162
00:09:47,500 --> 00:09:52,100
实际，让我们看看它是如何，这届超全局正在实施。

163
00:09:52,100 --> 00:09:55,990
1 HTTP请求，我要点击，

164
00:09:55,990 --> 00:09:58,810
这个调试窗口，让我看，里面的。

165
00:09:58,810 --> 00:10:01,970
在这里，我看到的只是来自服务器的响应，这是不感兴趣的。

166
00:10:01,970 --> 00:10:04,030
我已经看到了这在任何数量的方式。

167
00:10:04,030 --> 00:10:06,350
但在技术上是有趣的标头。

168
00:10:06,350 --> 00:10:11,770
如果我向下滚动，并专注于请求标头，然后单击“查看源文件”，

169
00:10:11,770 --> 00:10:14,400
我要看到的是字面上的HTTP请求

170
00:10:14,400 --> 00:10:17,250
刚去从我的浏览器到服务器，

171
00:10:17,250 --> 00:10:21,400
GET是最重要的词和/ counter.php的文件名，

172
00:10:21,400 --> 00:10:25,670
HTTP/1.1只是我的浏览器使用的HTTP版本。

173
00:10:25,670 --> 00:10:31,070
这里是一个小小的提醒，从浏览器到服务器的服务器的名称是什么

174
00:10:31,070 --> 00:10:33,020
它想聊得来。

175
00:10:33,020 --> 00:10:38,200
那么剩下的这有时是有趣的，但现在不相关权利。

176
00:10:38,200 --> 00:10:40,090
>> 这仅仅是种的好奇心。

177
00:10:40,090 --> 00:10:43,530
隐秘，虽然这个字符串是在任何时候，您的浏览器访问一个网站

178
00:10:43,530 --> 00:10:47,110
通知服务器你使用什么样的浏览器

179
00:10:47,110 --> 00:10:50,040
你使用的是什么操作系统和什么版本上。

180
00:10:50,040 --> 00:10:52,650
所以，如果你曾经想知道如何像CNN网站和诸如此类的东西

181
00:10:52,650 --> 00:10:56,860
知道的百分比是在网络上，PC用户的Mac用户，

182
00:10:56,860 --> 00:11:00,820
IE用户，Chrome用户之类的，这是因为我们所有的浏览器

183
00:11:00,820 --> 00:11:04,300
告诉每一个单​​一的网站，在那里我们是什么。

184
00:11:04,300 --> 00:11:07,410
这并不一定包含个人身份信息，

185
00:11:07,410 --> 00:11:13,060
但它告诉服务器你的IP地址是与您使用的是什么浏览器和操作系统。

186
00:11:13,060 --> 00:11:14,720
所以，在这个信息。

187
00:11:14,720 --> 00:11:19,960
但是，什么是更有趣的，当涉及到这些会议是响应头。

188
00:11:19,960 --> 00:11:22,530
让我单击“查看源文件”下的响应。

189
00:11:22,530 --> 00:11:24,590
有趣的是几件事情。

190
00:11:24,590 --> 00:11:27,580
1，我们回来的状态码为200。

191
00:11:27,580 --> 00:11:29,840
我们从来没有看到此状态码，因为这意味着一切都很好。

192
00:11:29,840 --> 00:11:32,920
它的字面意思是别的东西还好。

193
00:11:32,920 --> 00:11:36,380
什么是数字，我们有时会看到这是不好的？ [学生] 404。

194
00:11:36,380 --> 00:11:39,860
404，未找到文件，403你可能被绊在了，

195
00:11:39,860 --> 00:11:43,660
这是被禁止的，这意味着你忘了属性的东西，最有可能的。

196
00:11:43,660 --> 00:11:45,190
有一堆的人。

197
00:11:45,190 --> 00:11:47,760
>> 在这里，这是一个有点疯狂。

198
00:11:47,760 --> 00:11:52,340
我真的写了这个文件，几分钟前，将其粘贴到gedit的。

199
00:11:52,340 --> 00:11:57,100
为什么这页在1981年之前到期，真的是一个网络？

200
00:11:58,010 --> 00:12:00,730
这是怎么回事呢？

201
00:12:00,730 --> 00:12:04,390
>> 听不见的学生响应时间戳记。但是，为什么呢？

202
00:12:06,110 --> 00:12:09,120
这是有点武断，但实际上它是有用的。

203
00:12:09,120 --> 00:12:15,500
这是在说我的浏览器，这是PHP文件，你只是要求已经过期。

204
00:12:15,500 --> 00:12:18,580
事实上，30年前到期。

205
00:12:18,580 --> 00:12:20,260
但到底是什么，究竟意味着什么？

206
00:12:20,260 --> 00:12:22,500
这只是意味着，当用户下一次访问这个页面，

207
00:12:22,500 --> 00:12:25,540
无论是重装或在地址栏输入URL，

208
00:12:25,540 --> 00:12:28,010
确保您去获取新的副本。

209
00:12:28,010 --> 00:12:30,840
这是清除缓存的一个例子，

210
00:12:30,840 --> 00:12:33,790
一个愚蠢的字，仅仅表示试图阻止浏览器

211
00:12:33,790 --> 00:12:37,260
从实际缓存HTML，从服务器发送

212
00:12:37,260 --> 00:12:41,490
，这样你就没有不小心碰到重装，然后看到相同版本的文件。

213
00:12:41,490 --> 00:12:43,730
事实上，你想向服务器发送一个新的副本。

214
00:12:43,730 --> 00:12:47,440
因此，事实上，它的1981年只是意味着该设备的选择

215
00:12:47,440 --> 00:12:50,280
任意一个过去的日期。

216
00:12:50,280 --> 00:12:53,380
但是，真正的的多汁线是现在这一个。

217
00:12:53,380 --> 00:12:57,550
即使在50与Cookie，你可能很熟悉。

218
00:12:57,550 --> 00:13:01,820
截至目前，尤其是在那些不太舒服或在两者之间，

219
00:13:01,820 --> 00:13:04,120
什么是Cookie在你的理解

220
00:13:04,120 --> 00:13:06,980
即使我们即将让您了解更多的技术？

221
00:13:08,150 --> 00:13:10,070
一个cookie是什么？是啊。

222
00:13:10,070 --> 00:13:13,890
[学生]关于用户的信息，想，如果他们写自己的用户名或东西。

223
00:13:13,890 --> 00:13:17,370
>> 好。这是关于用户的信息，是否已经输入自己的用户名。

224
00:13:17,370 --> 00:13:21,190
Cookies是一种方式，使服务器可以记住用户的东西。

225
00:13:21,190 --> 00:13:25,810
真的是一个cookie是一个文本文件或部分的字节序列

226
00:13:25,810 --> 00:13:28,340
您的浏览器内的服务器的种植，

227
00:13:28,340 --> 00:13:31,960
和内部的该文件或那些字节之间是一些标识符种。

228
00:13:31,960 --> 00:13:35,640
也许这是从字面上您的用户名，但更多的时候，它的东西，看起来更神秘的

229
00:13:35,640 --> 00:13:43,700
这样的事情在这里 -  bo8dal3ct等等 - 这非常大的字母数字字符串

230
00:13:43,700 --> 00:13:47,050
这真的只是意味着你是一个独特的标识符。

231
00:13:47,050 --> 00:13:49,790
或者，你可以认为它排序的虚拟邮戳。

232
00:13:49,790 --> 00:13:53,020
如果你去一些俱乐部或游乐园，要记住，你实际上已经支付

233
00:13:53,020 --> 00:13:55,850
了，他们把你的手的某种红色的小标签上，

234
00:13:55,850 --> 00:13:59,270
并提醒人们，在你已经支付的计数器

235
00:13:59,270 --> 00:14:01,340
你可以来来去去，请你。

236
00:14:01,340 --> 00:14:04,250
Cookies是精神，有点类似。

237
00:14:04,250 --> 00:14:08,070
我第一次访问这个网站，我只是做了我的缓存清空后，

238
00:14:08,070 --> 00:14:11,620
Web服务器，在的家电在这种情况下，把我的手一戳就

239
00:14:11,620 --> 00:14:15,030
他的名字是PHPSESSID，会话ID，

240
00:14:15,030 --> 00:14:18,260
它的值是这个很长的字母数字字符串。

241
00:14:18,260 --> 00:14:22,470
>> 所以，现在排序的字样，下一次我打我的手，重新加载

242
00:14:22,470 --> 00:14:25,230
或手动访问这个URL在浏览器中，

243
00:14:25,230 --> 00:14:29,230
我的浏览器定义HTTP将展示邮戳

244
00:14:29,230 --> 00:14:31,940
再次，一遍又一遍。

245
00:14:31,940 --> 00:14:34,550
因此，即使服务器没有必要知道我是谁，

246
00:14:34,550 --> 00:14:39,610
他们至少知道，我的相同的用户或者至少，更具体地，在同一个浏览器。

247
00:14:39,610 --> 00:14:45,660
所以这是最终SESSION的超全局变量是如何实现的。

248
00:14:45,660 --> 00:14:51,200
服务器不知道你是谁，当你重新审视一个网站，第二次或第三次

249
00:14:51,200 --> 00:14:53,410
除非你提出这个邮戳。

250
00:14:53,410 --> 00:14:55,530
只要你提出，邮戳，

251
00:14:55,530 --> 00:14:59,370
基本上进入它自己的一个小数据库的Web服务器

252
00:14:59,370 --> 00:15:06,040
和检查，还好，我刚才看到了邮戳的用户bo8dal3ct等等。

253
00:15:06,040 --> 00:15:09,850
让我看看什么样的信息存储程序员

254
00:15:09,850 --> 00:15:12,380
内关于该用户的超全局，

255
00:15:12,380 --> 00:15:17,000
然后让我确保数据是再次里面的SESSION超全局

256
00:15:17,000 --> 00:15:19,830
因此，程序员可以重新访问这些数据

257
00:15:19,830 --> 00:15:23,360
即使它被设置一些前的几分钟或几小时。

258
00:15:23,360 --> 00:15:26,150
所以，换句话说，饼干，得到了一个坏名声了一段时间

259
00:15:26,150 --> 00:15:29,990
因为在浏览器中的不安全感，他们真的可以侵犯我们的隐私而所有这一切，

260
00:15:29,990 --> 00:15:31,900
实际上，他们有很大的效用，因为没有他们

261
00:15:31,900 --> 00:15:36,110
你将不停地登录到您所访问的每一个Facebook页面

262
00:15:36,110 --> 00:15:40,680
或阅读，如果浏览器没有一些方法，记住每一个Gmail电子邮件

263
00:15:40,680 --> 00:15:43,320
你已经通过认证。

264
00:15:43,320 --> 00:15:46,640
>> 因此，以这种方式Cookie的跨线来回发送。

265
00:15:46,640 --> 00:15:52,470
有关cookies的另一种好奇心，尤其是在这里，这是完全明文。

266
00:15:52,470 --> 00:15:54,930
有没有加密，在这里任何，

267
00:15:54,930 --> 00:15:57,240
事实上，我使用HTTP的时刻。

268
00:15:57,240 --> 00:16:00,890
我们最喜欢的时刻之一，这是2年前，在CS50

269
00:16:00,890 --> 00:16:04,750
是一个工具叫做Firesheep左右的时间就出来了。

270
00:16:04,750 --> 00:16:08,320
这是一个免费的软件，是由一名安全研究人员

271
00:16:08,320 --> 00:16:13,250
作为一个为社会敲响了警钟，说是多么残暴实施

272
00:16:13,250 --> 00:16:17,900
在网络上的一些认证机制。

273
00:16:17,900 --> 00:16:22,880
因此，一段时间后，Facebook是几乎完全通过HTTP，没有HTTPS。

274
00:16:22,880 --> 00:16:25,640
而且，即使你不知道加密的工作原理，S是安全的

275
00:16:25,640 --> 00:16:27,950
所以这意味着有至少涉及一些加密。

276
00:16:27,950 --> 00:16:30,610
没有使用Facebook的用户名和密码进行加密，

277
00:16:30,610 --> 00:16:33,560
但只要你看着你戳或您的邮件或新​​闻源，

278
00:16:33,560 --> 00:16:35,360
所有这一切是未加密的。

279
00:16:35,360 --> 00:16:37,870
所以，是的Gmail，直到一年或2年前。

280
00:16:37,870 --> 00:16:41,100
您登录的任何时间，是的，他们使用安全的加密，

281
00:16:41,100 --> 00:16:44,300
但此后他们没有。原因可能是什么？

282
00:16:44,300 --> 00:16:49,210
为什么不直接使用加密算法的所有的时间，在这样的情况下使用呢？

283
00:16:49,210 --> 00:16:53,700
那是什么？我觉得我听到的东西。 [学生]速度。

284
00:16:53,700 --> 00:16:56,250
速度，对不对？有办法解决这个问题。

285
00:16:56,250 --> 00:16:59,610
但是，如果你只是一种认为它在逻辑上，如果你加密的东西，

286
00:16:59,610 --> 00:17:01,820
你有至少做一些更多的工作。

287
00:17:01,820 --> 00:17:05,460
在pset中，当你实现凯撒或维琼内尔，甚至破解，

288
00:17:05,460 --> 00:17:07,760
只是打印一个字符串是比较容易的。

289
00:17:07,760 --> 00:17:12,040
加密，然后打印一个字符串至少需要多一点的工作。

290
00:17:12,040 --> 00:17:14,520
>>  对于超受欢迎的网站，如谷歌和Facebook，

291
00:17:14,520 --> 00:17:18,839
如果你必须为每个用户做更多的工作，为他们访问的每一个网页，

292
00:17:18,839 --> 00:17:20,520
这只是需要更多的CPU时间。

293
00:17:20,520 --> 00:17:22,920
如果您需要更多的CPU时间，你可能需要更多的服务器，

294
00:17:22,920 --> 00:17:24,270
这意味着你可能需要更多的钱。

295
00:17:24,270 --> 00:17:27,579
这么多年，这真的不是最好的做法。

296
00:17:27,579 --> 00:17:31,440
人们会时，才需要使用SSL加密。

297
00:17:31,440 --> 00:17:34,960
但事实证明，Firesheep这家伙超清晰，

298
00:17:34,960 --> 00:17:37,920
当你们谁是目前在Facebook上 - 

299
00:17:37,920 --> 00:17:39,880
出于好奇，让我们来看看如果你能坦白。

300
00:17:39,880 --> 00:17:42,620
如果你在Facebook上现在在一些标签，即使它的前景化，

301
00:17:42,620 --> 00:17:46,610
您的网址是HTTP或HTTPS？

302
00:17:46,610 --> 00:17:50,560
多个学生] S。S？ [笑声]

303
00:17:50,560 --> 00:17:55,510
好吧。任何HTTP？仅有1？好吧。

304
00:17:55,510 --> 00:17:58,940
所以，我们所有的人都可以破解，现在那家伙的Facebook帐户。

305
00:17:58,940 --> 00:18:04,100
在大多数情况下，这已经成为默认打开的，至少在一些网站。

306
00:18:04,100 --> 00:18:08,120
长话短说，如果你的网络流量是不加密的，

307
00:18:08,120 --> 00:18:12,960
不仅HTML回去，来回的WiFis未加密的，

308
00:18:12,960 --> 00:18:16,760
所以不要像饼干的东西晃来晃去，整个空气

309
00:18:16,760 --> 00:18:18,940
没有任何形式的加密。

310
00:18:18,940 --> 00:18:23,540
所以，如果你只是有点编程精明还是有点谷歌搜索技巧

311
00:18:23,540 --> 00:18:27,410
找到免费的软件，这样做，所有你必须​​做的就是坐在星巴克

312
00:18:27,410 --> 00:18:30,680
或坐在那里的机场一般未加密的WiFi

313
00:18:30,680 --> 00:18:36,070
只是看等关键字的Set-Cookie：PHPSESSID

314
00:18:36,070 --> 00:18:39,300
因为如果你的技术知识，只是看的WiFi

315
00:18:39,300 --> 00:18:43,010
可用于所有这种模式的整个空气的比特流中，

316
00:18:43,010 --> 00:18:50,840
然后，你可以说那家伙的的PHPSESSID发生是bo8dal等等。

317
00:18:50,840 --> 00:18:53,890
然后，如果你是足够精通技术的或合适的工具，

318
00:18:53,890 --> 00:18:58,890
然后，你可以只是重新配置自己的浏览器开始呈现，邮戳

319
00:18:58,890 --> 00:19:05,030
Facebook.com，而Facebook只是要假设你是那家伙

320
00:19:05,030 --> 00:19:09,880
因为他们知道是不是你是谁，但你有这样的唯一标识符。

321
00:19:09,880 --> 00:19:14,650
所以，如果你偷，唯一的标识符，它作为自己的Web服务器，

322
00:19:14,650 --> 00:19:16,860
他们只是要告诉你，人的新闻源

323
00:19:16,860 --> 00:19:18,980
或该人的消息或戳。

324
00:19:18,980 --> 00:19:23,190
>> 我想谷歌现在如何激活HTTPS的Facebook或许。

325
00:19:23,190 --> 00:19:25,150
但它确实是那样简单。

326
00:19:25,150 --> 00:19:27,660
因此，Facebook和谷歌之类的已经变得非常好，在此，

327
00:19:27,660 --> 00:19:31,870
但随时留意您访问的网站不使用HTTP

328
00:19:31,870 --> 00:19:35,020
有某种敏感信息，

329
00:19:35,020 --> 00:19:37,490
无论是财政或个人等。

330
00:19:37,490 --> 00:19:43,180
如果他们不利用这一点，很可能是这样的cookies是很容易被窃取，

331
00:19:43,180 --> 00:19:46,270
然后伪造的，而这正是Firesheep做。

332
00:19:46,270 --> 00:19:48,250
你没有成为一个程序员。

333
00:19:48,250 --> 00:19:51,680
所有您需要做的是有一个互联网连接，下载这个免费的工具，

334
00:19:51,680 --> 00:19:56,490
会怎样做是你登录，然后它会显示你的Facebook名称

335
00:19:56,490 --> 00:20:00,170
每个人都在桑德斯，在这个特殊的示范，在你身边

336
00:20:00,170 --> 00:20:03,260
和所有你需要做的就是点击他们的名字和过程自动化软件

337
00:20:03,260 --> 00:20:05,970
嗅探到Facebook作为自己的，该cookie，

338
00:20:05,970 --> 00:20:07,990
瞧，你正在登录。

339
00:20:07,990 --> 00:20:11,190
因此，这是另外一个人“不这样做”，正式。

340
00:20:11,190 --> 00:20:14,660
如果你有你自己的家庭网络，你想修改，通过各种手段，

341
00:20:14,660 --> 00:20:17,530
但认识到这一点并在大学环境中交叉的行。

342
00:20:17,530 --> 00:20:20,030
>> 但这里的目标是真正强调的不是如何做到这一点

343
00:20:20,030 --> 00:20:22,320
但如何抵御这些事情的。

344
00:20:22,320 --> 00:20:26,180
琐碎的解决方案，即使它本身是有缺陷的，

345
00:20:26,180 --> 00:20:31,360
是真正降低使用任何网站，不使用HTTPS不断。

346
00:20:31,360 --> 00:20:34,520
所以越来越多的网站，如Facebook和谷歌有复选框

347
00:20:34,520 --> 00:20:36,200
在这里你可以选择这样的事情，

348
00:20:36,200 --> 00:20:40,000
和银行这几年有类似的原因。

349
00:20:40,000 --> 00:20:43,580
因此，只要一点点的恐惧因素，如果我们能。但就是这样的缩影。

350
00:20:43,580 --> 00:20:46,420
这是，服务器如何记得你是谁。

351
00:20:46,420 --> 00:20:50,760
只要他们能记住你是谁，他们可以记住任何关于你

352
00:20:50,760 --> 00:20:56,140
程序员已经存放在里面的这个特殊的超全局变量名为$ _SESSION。

353
00:20:56,140 --> 00:20:59,750
的pset 7，我们使用它的平凡，只需要记住一个int，

354
00:20:59,750 --> 00:21:02,260
即独特的ID的用户登录，

355
00:21:02,260 --> 00:21:05,880
所以我们知道他们曾经做过的那样。

356
00:21:05,880 --> 00:21:12,450
然后在会话或饼干或类似的任何问题？

357
00:21:12,450 --> 00:21:15,130
Firesheep并不能很好地工作了，

358
00:21:15,130 --> 00:21:18,310
你必须把你的电脑变成一个特殊的混杂模式

359
00:21:18,310 --> 00:21:20,700
所以其实你听，除了自己的流量。

360
00:21:20,700 --> 00:21:23,940
所以，如果你正在下载Firesheep，知道这是不是很容易

361
00:21:23,940 --> 00:21:26,850
因为它曾经是证明。

362
00:21:26,850 --> 00:21:29,070
好的。不这样做，在桑德斯。在家里做。

363
00:21:29,070 --> 00:21:30,890
数据库。

364
00:21:30,890 --> 00:21:33,580
我们在很刻意的pset 7的事情之一

365
00:21:33,580 --> 00:21:37,780
是我们给你一个示例数据库中的表，有一些用户ID的用户，

366
00:21:37,780 --> 00:21:41,020
一些用户名和其中的一些加密的密码。

367
00:21:41,020 --> 00:21:44,520
，你会看到，如果你还没有的话，你要一点点改变表。

368
00:21:44,520 --> 00:21:47,710
你要到每个用户在该表中添加一些高速缓存，

369
00:21:47,710 --> 00:21:51,130
你要添加另一个历史表中，一个投资组合表，

370
00:21:51,130 --> 00:21:53,310
或也许调用别的东西。

371
00:21:53,310 --> 00:21:56,740
但在思考如何做到这一点，让我们打开此工具

372
00:21:56,740 --> 00:22:00,570
我们上周五，但如果不熟悉，该设备自带的工具

373
00:22:00,570 --> 00:22:04,680
所谓的phpMyAdmin，这是巧合的是用PHP编写的，

374
00:22:04,680 --> 00:22:07,950
但其目的在生活中，我在这里登录的jharvard与深红色后，

375
00:22:07,950 --> 00:22:15,160
是给我一个用户友好的方式查看和更改我的数据库。

376
00:22:15,160 --> 00:22:18,040
>> 我在设备上运行的数据库是MySQL的。

377
00:22:18,040 --> 00:22:23,420
这是非常流行的，它是一个免费的开源的数据库，奇妙的易于使用的，

378
00:22:23,420 --> 00:22:25,620
尤其是前端是这样的。

379
00:22:25,620 --> 00:22:29,350
这个工具允许我做什么，例如，围坐在桌子旁打个招呼。

380
00:22:29,350 --> 00:22:30,890
让我继续这样做。

381
00:22:30,890 --> 00:22:36,580
上周五，我们创建了一个表叫学生是超级简单的。

382
00:22:36,580 --> 00:22:41,680
它有3列 -  ID，名称，与电子邮件 - 我手动插入一对夫妇的行

383
00:22:41,680 --> 00:22:44,420
像大卫和迈克在这个特殊的例子。

384
00:22:44,420 --> 00:22:47,290
让我们这一点，让我们假定我们要记住更多的

385
00:22:47,290 --> 00:22:49,660
不仅仅是用户的姓名和电子邮件有关。

386
00:22:49,660 --> 00:22:53,090
让我点击在顶部结构。

387
00:22:53,090 --> 00:22:55,440
再次，在pset引导您完成必要的步骤，在这里，

388
00:22:55,440 --> 00:22:58,150
所以不要担心，如果一些这方面是有点快。

389
00:22:58,150 --> 00:22:59,690
然后，我要点击这里。

390
00:22:59,690 --> 00:23:02,270
我要添加一些列后，电子邮件

391
00:23:02,270 --> 00:23:04,130
因为我想补充的类似房子。

392
00:23:04,130 --> 00:23:06,640
我忘了记录学生的家。

393
00:23:06,640 --> 00:23:11,400
让我单击“Go”，现在我们有这种形式，不幸的是，由左到右宽一点，

394
00:23:11,400 --> 00:23:13,710
但我现在就打电话给这个场子里的名称，

395
00:23:13,710 --> 00:23:16,050
的类型，我现在必须做出选择。

396
00:23:16,050 --> 00:23:18,870
因此，让我们有一个简短的不同类型在MySQL中聊天

397
00:23:18,870 --> 00:23:24,590
而PHP是弱类型的戏剧快速和宽松的类型，

398
00:23:24,590 --> 00:23:29,430
在一个数据库中，特别是它的超级重要的实际使用输入你的优势

399
00:23:29,430 --> 00:23:33,260
因为一个能为你做的事情，MySQL和其他数据库引擎

400
00:23:33,260 --> 00:23:37,910
是确保你不把假的数据插入到数据库。

401
00:23:37,910 --> 00:23:41,850
这是一种错误检查，为您提供的免费。

402
00:23:41,850 --> 00:23:46,250
>> 对于房子，我们显然不希望它是一个int，这是一个在MySQL中的32位值。

403
00:23:46,250 --> 00:23:49,810
我们也想谈一谈有关数据类型为varchar（星期五），它代表的可变长度的字符。

404
00:23:49,810 --> 00:23:54,720
这是什么？这允许你指定你想这是某种形式的字符串。

405
00:23:54,720 --> 00:23:56,840
你真的不事先知道它有多长，

406
00:23:56,840 --> 00:24:00,100
所以我们的房子的名字可以武断地说是255个字符，

407
00:24:00,100 --> 00:24:04,190
但你可以去32，64  - 任何数量真的。

408
00:24:04,190 --> 00:24:10,700
但使用的数据类型为varchar的一个​​字段名为字符的优势是什么？

409
00:24:10,700 --> 00:24:15,110
如果我只是直观地向下滚动，发现有字符的数据类型为varchar。

410
00:24:15,110 --> 00:24:19,520
varchar是可变长度的字符，字符是一个固定长度的字符。

411
00:24:19,520 --> 00:24:24,730
因此，仅根据这一定义，这些有什么优势或劣势？

412
00:24:24,730 --> 00:24:30,490
换句话说，谁在乎的区别，为什么要照顾你吗？

413
00:24:31,660 --> 00:24:35,750
>> 是啊。 [学生] VARCHAR具有更大的灵活性，但占用更多的内存。

414
00:24:35,750 --> 00:24:40,730
好。数据类型为varchar占用更多的 - 让我们来看看。我不知道，如果我听说过这一权利。

415
00:24:40,730 --> 00:24:42,360
你能再说一次好吗？

416
00:24:42,360 --> 00:24:45,850
[学生]我说的数据类型为varchar可能具有更大的灵活性，但它会占用更多的内存。

417
00:24:45,850 --> 00:24:51,170
有趣的。好吧。数据类型为varchar可能给你更多的灵活性，但占用更多的内存。

418
00:24:51,170 --> 00:24:53,220
后者不一定是正确的。

419
00:24:53,220 --> 00:24:56,290
它依赖于上下文，但让我们回来。

420
00:24:56,290 --> 00:25:03,230
>> [听不见学生的回答没错。

421
00:25:03,230 --> 00:25:06,900
它实际上是字符的情况下，通常会使用更多的内存

422
00:25:06,900 --> 00:25:10,950
因为一个字符，和C一样，就像是一个字符串，它是一个字符数组。

423
00:25:10,950 --> 00:25:13,690
所以，如果你说一个char字段的长度为255，

424
00:25:13,690 --> 00:25:16,910
数据库是从字面上去给你255个字符。

425
00:25:16,910 --> 00:25:22,290
而如果房子是妈妈和6个字符总，

426
00:25:22,290 --> 00:25:25,090
你这是在浪费超过200个字符。

427
00:25:25,090 --> 00:25:29,640
>> 因此，一个数据类型为varchar有效地使用尽可能多的字符是必要的

428
00:25:29,640 --> 00:25:31,590
至最大量。

429
00:25:31,590 --> 00:25:35,470
但其实你付出的代价是性能，具有潜在的。

430
00:25:35,470 --> 00:25:39,740
如果你事先知道所有的字符串都将是8个字符 - 

431
00:25:39,740 --> 00:25:43,090
举例来说，假设您所需要的密码长度为8  - 

432
00:25:43,090 --> 00:25:47,350
上攻使用一个char领域的场合，虽然不是经常，

433
00:25:47,350 --> 00:25:51,100
指定一个固定长度的东西，就像一个密码

434
00:25:51,100 --> 00:25:53,300
因为现在的数据库可以更聪明。

435
00:25:53,300 --> 00:25:58,160
如果知道，每个char领域，每一个列中的字符串的长度相同，

436
00:25:58,160 --> 00:26:00,780
你回来的随机存取功能。

437
00:26:00,780 --> 00:26:05,110
您可以跳来跳去之间的各种字符字段在数据库表中

438
00:26:05,110 --> 00:26:07,940
因为觉得一个数据库以行和列。

439
00:26:07,940 --> 00:26:11,670
因此，如果每一个的字符串之一是相同的长度，

440
00:26:11,670 --> 00:26:17,820
你知道，第一个字节是0，下一个字节8

441
00:26:17,820 --> 00:26:20,240
然后16和24等等。

442
00:26:20,240 --> 00:26:24,500
因此，如果所有的字符串均具有相同的长度，就可以跳来跳去更有效。

443
00:26:24,500 --> 00:26:26,710
这样就可以在性能方面的好处，

444
00:26:26,710 --> 00:26:29,420
但通常你没有提前知道的豪华，

445
00:26:29,420 --> 00:26:32,170
所以一个varchar是要走的路。

446
00:26:32,170 --> 00:26:36,030
下面是另外一个细节，甚至Facebook跑进最后。

447
00:26:36,030 --> 00:26:39,670
诠释是伟大的，我们排序默认情况下，使用任何时候，我们希望有一个数字，

448
00:26:39,670 --> 00:26:41,750
但它只有32位。

449
00:26:41,750 --> 00:26:46,210
>> 而且尽管Facebook并没有完全有4十亿用户现在，

450
00:26:46,210 --> 00:26:48,680
肯定有一些人在那里拥有多个帐户

451
00:26:48,680 --> 00:26:50,960
或帐户已被打开，然后关闭，

452
00:26:50,960 --> 00:26:55,130
因此Facebook本身，我相信几年前从int转换

453
00:26:55,130 --> 00:27:00,010
，被形象地称为的BIGINT，这是64位，而不是。

454
00:27:00,010 --> 00:27:02,230
因此，这是一个设计决策。

455
00:27:02,230 --> 00:27:06,570
你会是幸运的，如果你的项目最终变成令人惊讶的启动，

456
00:27:06,570 --> 00:27:10,010
有4亿美元和1个用户，给予或采取，

457
00:27:10,010 --> 00:27:13,200
在这种情况下，使用int类型可能会有点短视。

458
00:27:13,200 --> 00:27:16,230
但在现实中，你的用户表可能是罚款与int类型。

459
00:27:16,230 --> 00:27:19,340
但对于类似的pset 7，喜欢你的历史记录表，

460
00:27:19,340 --> 00:27:23,700
你可能有数以千计，数以百万计的用户如果演变成etrade.com。

461
00:27:23,700 --> 00:27:26,020
所以，尽管你可能不会有超过4亿的用户，

462
00:27:26,020 --> 00:27:30,070
随着时间的推移，你有可能这些用户有超过4亿的交易 - 

463
00:27:30,070 --> 00:27:33,200
购买和销售的东西在他们的历史。

464
00:27:33,200 --> 00:27:38,090
所以，如果你预期 - 再次，这些都是很好的，如果你有这么多的数据的问题 - 

465
00:27:38,090 --> 00:27:40,920
如果你这样做预测数据的大小超过一个int，

466
00:27:40,920 --> 00:27:47,740
类似BIGINT不够频繁通过设计师的方向

467
00:27:47,740 --> 00:27:49,710
因为人的数字，不会是一个问题，

468
00:27:49,710 --> 00:27:51,930
但这个简单的选择一些更大的比。

469
00:27:51,930 --> 00:27:55,380
我们正在使用的十进制pset中，它指定了固定的精度

470
00:27:55,380 --> 00:27:59,840
这样你才能避免浮点数和双精度实数和类似的问题。

471
00:27:59,840 --> 00:28:02,440
>> 然后还有一些其他领域的。我们将挥动我们的手在一定程度上。

472
00:28:02,440 --> 00:28:07,270
但是，日期，时间都在MySQL中规定的格式，

473
00:28:07,270 --> 00:28:10,830
的优点是存储日期的日期，而不是​​VARCHAR处理

474
00:28:10,830 --> 00:28:15,730
数据库可以格式化成不同的格式，

475
00:28:15,730 --> 00:28:18,800
无论是美国格式或欧洲格式或类似的 - 但是你想要的 - 

476
00:28:18,800 --> 00:28:22,700
更有效地比，如果它只是一些通用的数据类型为varchar。

477
00:28:22,700 --> 00:28:25,150
然后还有一些其他BINARY，VARBINARY，斑点。

478
00:28:25,150 --> 00:28:28,580
这些都是二进制大对象，你也可以存储二进制数据

479
00:28:28,580 --> 00:28:30,750
以及作为在一个数据库中的几何数据。

480
00:28:30,750 --> 00:28:34,350
但对我们来说，我们通常会关心int和VARCHAR处理之类的。

481
00:28:34,350 --> 00:28:36,230
让我们完成了这个例子的房子。

482
00:28:36,230 --> 00:28:40,030
房子我要武断地说是255个字符。

483
00:28:40,030 --> 00:28:42,850
默认值，我们可以做到这一点。

484
00:28:42,850 --> 00:28:47,440
默认情况下，我们可以把每个人都在奥美楼，例如。

485
00:28:47,440 --> 00:28:49,710
这就是我们如何可以指定该数据库

486
00:28:49,710 --> 00:28:52,460
应确保有人总是有一个值。但我会离开即可。

487
00:28:52,460 --> 00:28:55,270
事实上，住在校外，而不是在一个房子里的人，

488
00:28:55,270 --> 00:28:59,590
也许我真的要指定为房子的默认值是NULL，

489
00:28:59,590 --> 00:29:04,890
然后我需要选中此复选框，如果用户的房子是空的，也没关系，告诉数据库。

490
00:29:04,890 --> 00:29:07,270
>> 再次，这是另一种防御机制，你可以把

491
00:29:07,270 --> 00:29:10,590
所以你甚至不必一定把它放在你的PHP代码。

492
00:29:10,590 --> 00:29:14,630
该数据库将确保事情是或不是NULL。

493
00:29:14,630 --> 00:29:17,310
最后，属性。

494
00:29:17,310 --> 00:29:18,920
这些都不是真正相关的。

495
00:29:18,920 --> 00:29:22,880
这些二进制，无符号 - 没有为varchar有关。

496
00:29:22,880 --> 00:29:24,220
指数。

497
00:29:24,220 --> 00:29:27,320
有谁知道或记得有一个猜想指数是什么

498
00:29:27,320 --> 00:29:29,510
类似的房子吗？

499
00:29:29,510 --> 00:29:35,240
其实这也是一个重要的设计决策，也比较容易。

500
00:29:35,240 --> 00:29:39,200
对于那些尚未看到了，上周五我们短暂交谈，有关主键。

501
00:29:39,200 --> 00:29:43,240
在一个数据库表中，主键的字段或列

502
00:29:43,240 --> 00:29:46,270
唯一标识表中的行。

503
00:29:46,270 --> 00:29:49,150
因此，在当前表中，我们的ID，我们有姓名和电子邮件。

504
00:29:49,150 --> 00:29:52,050
这些是最​​佳人选是一个主键，

505
00:29:52,050 --> 00:29:55,810
其作用是唯一标识行吗？

506
00:29:55,810 --> 00:29:57,530
也许ID。

507
00:29:57,530 --> 00:29:59,930
可以说，我们也可以使用又有何干？

508
00:29:59,930 --> 00:30:02,860
也许你可以使用电子邮件，因为在理论上，它的独特之处

509
00:30:02,860 --> 00:30:05,380
除非人共享电子邮件帐户。

510
00:30:05,380 --> 00:30:09,980
但现实情况是，如果您使用的是数字ID：1234，

511
00:30:09,980 --> 00:30:14,170
只有32位，而一个电子邮件地址可能会是这样的的许多字节或指定的字节。

512
00:30:14,170 --> 00:30:16,610
因此，在效率方面的独特标识符，

513
00:30:16,610 --> 00:30:19,270
它往往是好的做法，只是使用int

514
00:30:19,270 --> 00:30:23,090
即使你有一些的字符串的候选人，你可以说是使用。

515
00:30:23,090 --> 00:30:26,760
>> 对于类似的房子，这不应该是一个主键

516
00:30:26,760 --> 00:30:30,770
因为只有1人可以住在奥美和Currier和1人。

517
00:30:30,770 --> 00:30:32,790
同样，这不应该是唯一的。

518
00:30:32,790 --> 00:30:37,830
主要的区别和独特的是，在我们目前的情况下，表，

519
00:30:37,830 --> 00:30:42,620
ID是主要的，但不是主要的原因，我们刚才提到的电子邮件是 - 

520
00:30:42,620 --> 00:30:44,740
性能 - 但它仍然应该是唯一的。

521
00:30:44,740 --> 00:30:47,200
所以，你仍然可以强制执行唯一性，没有提出索赔要求

522
00:30:47,200 --> 00:30:49,520
，这是一个超级重要的主要领域。

523
00:30:49,520 --> 00:30:52,610
但是，这是非常有帮助的指数。

524
00:30:52,610 --> 00:30:56,180
如果您知道您的最终项目提前，pset中7，一般，

525
00:30:56,180 --> 00:30:59,480
这个场子里将是你搜索了很多

526
00:30:59,480 --> 00:31:01,910
利用选择的关键字或别的东西，

527
00:31:01,910 --> 00:31:05,180
那么你就可以先发制人地告诉数据库工作它的魔力

528
00:31:05,180 --> 00:31:10,510
并确保在内存中，它创造了必要的任何花哨的数据结构

529
00:31:10,510 --> 00:31:13,770
房子的基础上，以加快搜索。

530
00:31:13,770 --> 00:31:17,860
也许它会使用一个哈希表，也许它会使用一个链表。

531
00:31:17,860 --> 00:31:21,260
在现实中，往往使用一棵树，往往是一个结构，称为B-树 - 

532
00:31:21,260 --> 00:31:24,090
不是二进制树，但B-树 - 这是一个非常广泛的树

533
00:31:24,090 --> 00:31:27,370
你可能会看到在一个类CS124，数据结构类。

534
00:31:27,370 --> 00:31:31,800
但是，总之，你不必须担心​​，当使用智能数据库软件。

535
00:31:31,800 --> 00:31:35,890
您只需告诉它，“索引字段，这样我就可以更有效地搜索就可以了。”

536
00:31:35,890 --> 00:31:40,250
>> 如果你将其关闭，并你尝试搜索数据库中的每个人都住在奥美，

537
00:31:40,250 --> 00:31:42,710
它会退化成线性搜索。

538
00:31:42,710 --> 00:31:45,360
而且，如果你有6000的本科生都住在一些房子，

539
00:31:45,360 --> 00:31:47,900
你要的全表搜索找到Matherites，

540
00:31:47,900 --> 00:31:52,190
而如果你说的指数，希望它会是接近于对数搜索

541
00:31:52,190 --> 00:31:54,510
找到这些类型的学生。

542
00:31:54,510 --> 00:31:56,750
这仅仅是一个免费的功能打开，

543
00:31:56,750 --> 00:31:59,530
即使它的价格是在一定的空间。

544
00:31:59,530 --> 00:32:02,690
最后，自动递增，这人工智能领域，

545
00:32:02,690 --> 00:32:05,830
这意味着，如果它是一个int，你不想负责递增它自己

546
00:32:05,830 --> 00:32:07,570
每次有一个新的用户，请检查，

547
00:32:07,570 --> 00:32:11,910
，被插入的每个用户将自动获得一个新的ID。

548
00:32:11,910 --> 00:32:15,620
让我们单击“保存”，现在让我们找出故障，这种设计。

549
00:32:15,620 --> 00:32:20,200
如果我进入浏览，通知，迈克和我的房子是NULL。

550
00:32:20,200 --> 00:32:22,420
我可以使用phpMyAdmin来手动修改。

551
00:32:22,420 --> 00:32:25,110
在这里我可以去和类型Mather中，然后按Enter键，

552
00:32:25,110 --> 00:32:27,740
现在发现表是不同的。

553
00:32:27,740 --> 00:32:29,270
但是请注意，我可以做别的事情。

554
00:32:29,270 --> 00:32:33,530
大卫的ID为1，所以phpMyAdmin的再仅仅是一个管理工具;

555
00:32:33,530 --> 00:32:35,970
这是不是您的用户会看到。

556
00:32:35,970 --> 00:32:38,810
所以，如果我不是单击SQL选项卡往上顶 - 

557
00:32:38,810 --> 00:32:41,450
再次，pset中7为您介绍这些查询 - 

558
00:32:41,450 --> 00:32:45,260
我可以手动执行的SQL结构化查询语言命令

559
00:32:45,260 --> 00:32:56,410
UPDATE房子='Pfoho'WHERE id = 1的用户设置。

560
00:32:56,410 --> 00:33:00,830
这些SQL查询，精美的就够了，非常可读的由左到右。

561
00:33:00,830 --> 00:33:04,350
更新用户表，设置字段称为房子Pfoho

562
00:33:04,350 --> 00:33:06,830
在用户的编号是1。

563
00:33:06,830 --> 00:33:11,480
或者，我什至可以做电子邮件='malan@harvard.edu'。

564
00:33:11,480 --> 00:33:14,860
所以，只要是我唯一标识，这将正常工作。

565
00:33:14,860 --> 00:33:18,810
但是，ID往往是更高的性能，让我们做到这一点。

566
00:33:18,810 --> 00:33:22,950
让我们单击“转到”。好了，lecture.users不存在。什么是我的错误吗？

567
00:33:22,950 --> 00:33:26,220
这里实际上是所谓的什么表？

568
00:33:26,220 --> 00:33:28,770
这就是所谓的学生，只是因为这就是我们所做的，在左上角。

569
00:33:28,770 --> 00:33:31,860
这就是所谓的学生，而不是用户。所以现在单击“Go”。

570
00:33:31,860 --> 00:33:34,330
1行受影响。查询用时0.01秒。

571
00:33:34,330 --> 00:33:38,010
如果现在我单击“浏览”，现在马兰生活在Pfoho。

572
00:33:38,010 --> 00:33:42,070
所以这是另一种味道的SQL，但在pset将引导您完成更多一点。

573
00:33:42,070 --> 00:33:44,710
>> 我已经在这里有一个愚蠢的决定。

574
00:33:44,710 --> 00:33:47,820
我认为，这个数据库设计是低效的

575
00:33:47,820 --> 00:33:51,650
因为更多的人，我想补充的学生表，

576
00:33:51,650 --> 00:33:54,730
我们更多的我开始增加，我开始添加的TFS，

577
00:33:54,730 --> 00:33:58,320
我们将开始看到此表中的冗余什么？

578
00:34:00,840 --> 00:34:06,020
>> 是啊。 [学生]看到它的学生，我们使用的是相同的[听不清]

579
00:34:06,020 --> 00:34:07,360
相同的 - 对，没错。

580
00:34:07,360 --> 00:34:10,400
所以，如果400人住在奥美，给予或采取，

581
00:34:10,400 --> 00:34:15,000
此表最终将有400行说：“奥美”，“奥美”

582
00:34:15,000 --> 00:34:16,590
“奥美”，“奥美”，“奥美”。

583
00:34:16,590 --> 00:34:19,820
我们浪费了所有的这些字节，那里有一对夫妇的外卖店。

584
00:34:19,820 --> 00:34:23,080
1，角落里有疯狂的情况：如果有人花了很多钱

585
00:34:23,080 --> 00:34:25,949
并重新命名奥美，现在我们要改变我们的整个数据库表。

586
00:34:25,949 --> 00:34:29,730
这不会经常发生，但Pfoho一度被称为北楼15年前，

587
00:34:29,730 --> 00:34:32,310
所以它发生。不过，这还不是全部，引人注目。

588
00:34:32,310 --> 00:34:36,000
更引人注目的莫过于一个角落的情况，如需要更新大量的数据

589
00:34:36,000 --> 00:34:41,150
的数据库就是为什么你存储MATHER一遍又一遍，一遍又一遍吗？

590
00:34:41,150 --> 00:34:43,020
这是一个很大的字符，6个字符。

591
00:34:43,020 --> 00:34:45,500
我们不能做，甚至比这更好，特别是对Pforzheimer？

592
00:34:45,500 --> 00:34:48,320
当然，我们可以做的更好比许多字符。

593
00:34:48,320 --> 00:34:51,790
为什么不直接关联一个唯一的标识符，每间房子

594
00:34:51,790 --> 00:34:55,020
并存储为每个用户？所以，让我们来试试这个。

595
00:34:55,020 --> 00:35:00,610
而不是只是学生使用表，让我去我的演讲数据库在左上角。

596
00:35:00,610 --> 00:35:02,600
请注意，这里说创建表。

597
00:35:02,600 --> 00:35:04,550
让我创建一​​个新的表称为房屋。

598
00:35:04,550 --> 00:35:08,880
的列数为2。输入。

599
00:35:08,880 --> 00:35:11,200
现在，我有2个字段。

600
00:35:11,200 --> 00:35:14,600
我要叫这名字，这将是一个varchar的长度为255，

601
00:35:14,600 --> 00:35:18,770
>> 但是，这是相当武断的。让我在这里公约。

602
00:35:18,770 --> 00:35:22,840
因此，把一个ID在这里。让我们给每一个房子的唯一标识符。

603
00:35:22,840 --> 00:35:25,360
让我们给每一个房子的名字。

604
00:35:25,360 --> 00:35:30,980
让我们指定的标识符将是无符号的，只是按照惯例，只使用正数。

605
00:35:30,980 --> 00:35:35,020
让我们先走，并把现在这是一个自动递增字段。

606
00:35:35,020 --> 00:35:38,160
我们还需要什么别的吗？

607
00:35:38,160 --> 00:35:41,010
让我们继续前进，并单击“保存”。

608
00:35:41,010 --> 00:35:42,480
现在我有第二个表。

609
00:35:42,480 --> 00:35:45,860
顺便说一句，这是稍微有点隐蔽的SQL命令

610
00:35:45,860 --> 00:35:50,280
你将不得不手动键入，如果不使用的管理工具，像phpMyAdmin。

611
00:35:50,280 --> 00:35:51,990
因此，另一个原因，我们使用它。

612
00:35:51,990 --> 00:35:55,480
这是奇妙的有用的教学法，因为你可以按一下周围的

613
00:35:55,480 --> 00:36:01,050
并找出是如何工作的，只是复制和粘贴的phpMyAdmin做什么。

614
00:36:01,050 --> 00:36:04,150
但在CREATE TABLE命令是刚刚执行了，这里是我的表。

615
00:36:04,150 --> 00:36:11,370
让我继续通过点击“插入”选项卡，并使用原始的SQL，而不是过于简单化。

616
00:36:11,370 --> 00:36:15,040
让我做INSERT INTO房屋，

617
00:36:15,040 --> 00:36:22,230
我说的房子是有一个价值的“奥美”的名称。

618
00:36:22,230 --> 00:36:24,790
就是这样。这个语法是多了几分神秘。

619
00:36:24,790 --> 00:36:26,660
这是我们要插入的字段的名称。

620
00:36:26,660 --> 00:36:30,390
这是我们想要的值插入到这些领域。让我单击“Go”。

621
00:36:30,390 --> 00:36:34,410
1插入的行花了0.02秒。让我现在单击“浏览”。

622
00:36:34,410 --> 00:36:42,020
>> 请注意，如果我单击“浏览”，奥美，其ID是通过自动化的数字1。

623
00:36:42,020 --> 00:36:45,000
让我做另一个。让我进入“SQL”选项卡上。

624
00:36:45,000 --> 00:36:52,950
INSERT INTO的房子。的房子的名称是将有一个的Pfoho值等等。

625
00:36:52,950 --> 00:36:56,350
去！我能保持这样了一次又一次。

626
00:36:56,350 --> 00:36:59,470
或使用phpMyAdmin如果你觉得无聊，你可以直接使用“插入”选项卡

627
00:36:59,470 --> 00:37:01,000
没有输入的原始的SQL。

628
00:37:01,000 --> 00:37:04,690
例如，您可以一鼓作气更快速地打字，宿舍楼里，回车，

629
00:37:04,690 --> 00:37:07,610
现在如果我们单击“浏览”，有宿舍楼里，一个ID为3。

630
00:37:07,610 --> 00:37:09,920
因此，这就是我们所说的自动递增。

631
00:37:09,920 --> 00:37:12,280
但现在我们必须解决学生的东西。

632
00:37:12,280 --> 00:37:16,240
在学生，现在的房子领域的数据类型是什么？

633
00:37:16,240 --> 00:37:19,450
它应该是一个int，对不对？

634
00:37:19,450 --> 00:37:23,950
因此，这里的目标是分解出，否则被称为正常化，表

635
00:37:23,950 --> 00:37:27,940
所以，我们不存储信息的冗余在我的表。

636
00:37:27,940 --> 00:37:31,130
再次，我们在这里的路径是怎么说的奥美，奥美，

637
00:37:31,130 --> 00:37:34,220
奥美，奥美，Pfoho，Pfoho，Pfoho，Pfoho，这是非常多余的

638
00:37:34,220 --> 00:37:36,240
的浪费的字符。

639
00:37:36,240 --> 00:37:40,820
所以，让我继续前进，点击结构改变这种情况，

640
00:37:40,820 --> 00:37:44,620
让我继续前进，检查了房子，请单击“更改”，

641
00:37:44,620 --> 00:37:46,990
现在，我要改变这是一个int。

642
00:37:46,990 --> 00:37:49,490
255不再是相关的。

643
00:37:49,490 --> 00:37:54,010
让我继续说，很好，如果它仍然是NULL。保存。

644
00:37:54,010 --> 00:37:55,870
表学生已成功地改变，

645
00:37:55,870 --> 00:37:59,090
再次注意到房子是一个int。

646
00:37:59,090 --> 00:38:02,220
顺便说一句，忽略括号中的数字，当它涉及到整数。

647
00:38:02,220 --> 00:38:03,770
>> 这是传统的原因。

648
00:38:03,770 --> 00:38:06,920
早在一天当你没有图形用户界面，而不是有一个命令行环境中，

649
00:38:06,920 --> 00:38:11,580
10和11分别指定多少个字符，你应该显示

650
00:38:11,580 --> 00:38:13,950
在终端窗口中显示的字段。

651
00:38:13,950 --> 00:38:19,150
它有没有做实际的字段的位长，所以，现在我们就忽略。

652
00:38:19,150 --> 00:38:20,990
现在，我必须去到这个表中。

653
00:38:20,990 --> 00:38:24,610
如果大卫住在奥美，房子不应该是0，

654
00:38:24,610 --> 00:38:27,350
这是一个默认的int值最接近NULL。

655
00:38:27,350 --> 00:38:29,810
他应该住在房子1。

656
00:38:29,810 --> 00:38:36,870
让我们武断地说，迈克的生活在Pfoho，所以门牌号码2。

657
00:38:36,870 --> 00:38:40,160
现在，我的表看起来多了几分神秘。

658
00:38:40,160 --> 00:38:41,960
但考虑到效率。

659
00:38:41,960 --> 00:38:44,860
我现在只用32位来标识的房子，

660
00:38:44,860 --> 00:38:49,530
这意味着有规范的定义，我的房子马瑟和Pfoho的只有1

661
00:38:49,530 --> 00:38:52,090
和的房子表中。

662
00:38:52,090 --> 00:38:55,880
所以，如果我现在要重新加入这些表，它认为这种方式。

663
00:38:55,880 --> 00:39:01,980
在这里，我有我的学生表，右手边有这些数字，1和2。

664
00:39:01,980 --> 00:39:04,180
1奥美，2是Pfoho的。

665
00:39:04,180 --> 00:39:08,580
我们有这个其他表中的那些相同的标号，这就是所谓的房屋，

666
00:39:08,580 --> 00:39:11,020
1和2和图3为那些3房子。

667
00:39:11,020 --> 00:39:14,990
我们现在想要做的是，PHP和SQL代码的能力，

668
00:39:14,990 --> 00:39:18,800
排序的重新加入这些表，如果这些是学生，这些都是房屋，

669
00:39:18,800 --> 00:39:22,050
我们希望以某种方式结合起来，使1行1，

670
00:39:22,050 --> 00:39:25,670
2号线与2个，这样我们就可以计算出在大卫

671
00:39:25,670 --> 00:39:28,000
迈克和其他人生活的地方。

672
00:39:28,000 --> 00:39:31,850
要做到这一点，我们就可以像下面这样执行一个SQL查询。

673
00:39:31,850 --> 00:39:40,470
SELECT * FROM学生参加房子 - 

674
00:39:40,470 --> 00:39:43,000
现在什么领域，我们想加入吗？

675
00:39:43,000 --> 00:39:49,520
因此，students.house = houses.id。

676
00:39:49,520 --> 00:39:54,150
>> 有点神秘，但是这部分是指从字面上创建一个新的临时表

677
00:39:54,150 --> 00:39:56,690
这是参加的学生和房屋的结果。

678
00:39:56,690 --> 00:40:00,340
你怎么想在这里结合我的手指的技巧吗？

679
00:40:00,340 --> 00:40:05,280
将学生的家域的值等于房屋的ID字段。

680
00:40:05,280 --> 00:40:10,220
如果我现在单击“Go”，我正是我希望的。

681
00:40:10,220 --> 00:40:15,890
大卫在奥美，迈克是在Pfoho，我也看到了唯一的标识符。

682
00:40:15,890 --> 00:40:18,640
但问题是，现在我有一个完整的表。

683
00:40:18,640 --> 00:40:23,020
因此，这里的pset 7外卖或真正为最终的项目：

684
00:40:23,020 --> 00:40:25,830
如果你发现你存储的任何信息冗余，

685
00:40:25,830 --> 00:40:28,850
无论是房子，也许这是一个城市，州和ZIP

686
00:40:28,850 --> 00:40:32,050
其中的ZIP可以通常但并不总是可以使用一个唯一的标识符，

687
00:40:32,050 --> 00:40:35,810
干什么去了，然后通过行使精神上的东西，像phpMyAdmin

688
00:40:35,810 --> 00:40:40,660
分解出来，常用的数据，因为尤其是当你的网站得到更多的使用

689
00:40:40,660 --> 00:40:45,440
越来越流行，这是你如何确保这一切是超级快，

690
00:40:45,440 --> 00:40:51,930
许多暗示的独特性可能给数据库。

691
00:40:51,930 --> 00:40:53,860
这是一个很大。

692
00:40:53,860 --> 00:40:59,010
有什么问题吗？好的。让我们有5分钟的休息时间和重组。

693
00:41:01,600 --> 00:41:03,540
好的。

694
00:41:03,540 --> 00:41:08,680
下面是一个例子，几年前，当我把CS161，

695
00:41:08,680 --> 00:41:10,960
这是在大学的操作系统类

696
00:41:10,960 --> 00:41:15,160
这被称为是惊人的，但一个疯狂的工作，

697
00:41:15,160 --> 00:41:19,810
它真的在关注一些低级别的操作系统中出现的问题

698
00:41:19,810 --> 00:41:22,700
甚至还可以在世界上的数据库。

699
00:41:22,700 --> 00:41:27,040
>> 马戈舒尔茨，我的教授，当年的故事，被告知如下。

700
00:41:27,040 --> 00:41:30,990
假设你有一个小宿舍里为你和你的室友冰箱

701
00:41:30,990 --> 00:41:34,030
你真的喜欢牛奶。

702
00:41:34,030 --> 00:41:36,360
所以，你回家一天的课堂上，你的室友尚未出现，

703
00:41:36,360 --> 00:41:39,650
你打开冰箱，你会意识到，“哦，该死的，我们的牛奶。”

704
00:41:39,650 --> 00:41:42,070
所以，你关闭的冰箱，你走马路对面的CVS

705
00:41:42,070 --> 00:41:45,830
并获得越来越长的线，在CVS买一些牛奶。

706
00:41:45,830 --> 00:41:48,470
同时，从他或她的课，你的室友回家

707
00:41:48,470 --> 00:41:51,690
进了房间，打开冰箱真的想要一些牛奶，

708
00:41:51,690 --> 00:41:54,130
打开冰箱，“妈的，没有牛奶。”

709
00:41:54,130 --> 00:41:57,890
于是他或她关闭了冰箱，走出了门，并进入到ABP

710
00:41:57,890 --> 00:42:00,910
或其他地方比CVS你不会互相碰撞

711
00:42:00,910 --> 00:42:02,790
去得到一些牛奶。

712
00:42:02,790 --> 00:42:04,820
当然，几分钟后，你回家

713
00:42:04,820 --> 00:42:07,740
现在你有两倍多的牛奶，因为你其实是想。

714
00:42:07,740 --> 00:42:10,670
牛奶，现在会走坏，因为你喜欢牛奶

715
00:42:10,670 --> 00:42:14,200
但你真的不喜欢牛奶，所以现在你有太多的牛奶，所以它会变味。

716
00:42:14,200 --> 00:42:16,830
这是一个可怕的，可怕的局面。

717
00:42:16,830 --> 00:42:22,920
什么可能已经解决了这个困境，如果你是第一个室友回家吗？是。

718
00:42:22,920 --> 00:42:25,970
[学生]您应该留了一张纸条。 [笑声]

719
00:42:25,970 --> 00:42:28,090
好。你应该留了一张纸条。

720
00:42:28,090 --> 00:42:32,320
您应该把后它说明或如说，“飘的牛奶”

721
00:42:32,320 --> 00:42:36,830
，然后你的室友概念将被锁定，其实这样做。

722
00:42:36,830 --> 00:42:38,010
或者，你可以去1步。

723
00:42:38,010 --> 00:42:41,060
你可以从字面上某种挂锁锁的冰箱，

724
00:42:41,060 --> 00:42:44,870
现在你的室友会从字面上锁定的冰箱。

725
00:42:44,870 --> 00:42:48,520
如果我们概括编程，

726
00:42:48,520 --> 00:42:51,610
你几乎可以认为冰箱某些类型的变量或结构，

727
00:42:51,610 --> 00:42:53,500
某种信息的容器。

728
00:42:53,500 --> 00:42:58,290
根本的问题是，你可以检查

729
00:42:58,290 --> 00:43:02,370
或读取这样的数据结构的状态下，

730
00:43:02,370 --> 00:43:08,050
但你看它在不同的时间，但你做了一个决定

731
00:43:08,050 --> 00:43:11,920
基于对世界的状态，在这些不同的时刻。

732
00:43:11,920 --> 00:43:15,570
所以，如果你锁定了冰箱，你会至少避免你的室友

733
00:43:15,570 --> 00:43:19,070
从能够检查状态的世界，

734
00:43:19,070 --> 00:43:22,530
这样他或她可能不会作出同样的决定。

735
00:43:22,530 --> 00:43:25,780
因此，数据库，事实证明，这个问题不断。

736
00:43:25,780 --> 00:43:31,050
>> 让我们来看看，如果我们可以构造一个场景。

737
00:43:31,050 --> 00:43:34,310
假设，你的坏家伙，你去美国银行（Bank of America）

738
00:43:34,310 --> 00:43:37,950
或在广场上，有一对夫妇的自动取款机并排的其他地方，

739
00:43:37,950 --> 00:43:41,200
不知为何，你如何复制一个ATM卡 - 不是所有的努力。

740
00:43:41,200 --> 00:43:42,730
这只是一个磁条。

741
00:43:42,730 --> 00:43:45,180
所以你想尝试做的是玩这个游戏

742
00:43:45,180 --> 00:43:49,060
一台机器，让你把卡，另一张卡到其他机器上，

743
00:43:49,060 --> 00:43:51,980
你基本上要尝试去取钱同时，

744
00:43:51,980 --> 00:43:54,930
因为想象这个故事如下。

745
00:43:54,930 --> 00:43:57,350
机器左侧，把你的卡和PIN，

746
00:43:57,350 --> 00:44:00,240
然后你说，“给我100美元。”

747
00:44:00,240 --> 00:44:04,790
ATM编程，首先做一个选择的数据库或等值 - 

748
00:44:04,790 --> 00:44:10,780
它使用任何数据库 - 看看该用户是否拥有至少100元，在他或她的帐户？

749
00:44:10,780 --> 00:44:16,180
如果是这样的话，然后吐出100美元，而其资产负债减去100元。

750
00:44:16,180 --> 00:44:20,470
但是，当然，如果是多台机器在这里或多种方式的检查

751
00:44:20,470 --> 00:44:23,560
这个世界的状态，银行金库，就看你有多少钱，

752
00:44:23,560 --> 00:44:26,780
假设只是偶然的机器上左侧和右侧

753
00:44:26,780 --> 00:44:30,140
问这个问题在大致相同的时刻。

754
00:44:30,140 --> 00:44:34,160
>> 而这肯定会发生。自动取款机电脑这些天。

755
00:44:34,160 --> 00:44:37,670
因此，如果机器左侧的说，“是的，你有至少100元。”

756
00:44:37,670 --> 00:44:42,150
同时在机器上正确的说，“是的，你必须在至少100元，”

757
00:44:42,150 --> 00:44:47,420
之后两人又继续完成他们的计划和实际吐出100美元

758
00:44:47,420 --> 00:44:50,820
并说，“在此之前，你有200元。”

759
00:44:50,820 --> 00:44:54,890
“让我更新的变量，现在是100元留在该帐户。”

760
00:44:54,890 --> 00:44:58,780
但是，如果他们都已经检查您的帐户余额，发现它的$ 200

761
00:44:58,780 --> 00:45:02,000
两个人都做数学题，说200  -  100，

762
00:45:02,000 --> 00:45:06,990
机器有潜在的吐出两个100元的钞票在每一台机器，

763
00:45:06,990 --> 00:45:11,360
但他们只更新和账户余额为100元。

764
00:45:11,360 --> 00:45:15,130
换句话说，你已经采取了200元，但由于他们考察了世界的状态

765
00:45:15,130 --> 00:45:18,840
同时，然后根据该值决定，

766
00:45:18,840 --> 00:45:21,930
他们最终可能不会做的数学正确。

767
00:45:21,930 --> 00:45:25,520
因此，在银行的情况，你真的希望有某种锁定

768
00:45:25,520 --> 00:45:28,450
所以，只要你已经检查了一些变量的状态

769
00:45:28,450 --> 00:45:31,220
这是非常重要的，像您的帐户余额，

770
00:45:31,220 --> 00:45:36,070
不要让任何人作出决定的基础上，做你的事，直到你完成，

771
00:45:36,070 --> 00:45:38,920
在这种情况下，你是在左边的ATM。

772
00:45:38,920 --> 00:45:41,160
其他人锁定。

773
00:45:41,160 --> 00:45:44,650
实际上，你可以在几种不同的方法来达到这样的效果。

774
00:45:44,650 --> 00:45:48,660
>> 在MySQL中是一个最简单的方法，我们给你行的SQL

775
00:45:48,660 --> 00:45:52,030
问题集规范长相酷似。

776
00:45:52,030 --> 00:45:57,420
INSERT INTO表 - 无论它被称为 - 一个ID，一个符号，一个份额，股份数目，

777
00:45:57,420 --> 00:45:59,660
下面的值，例如。

778
00:45:59,660 --> 00:46:03,370
如果你还没有读过的规范，这是一个例子，你怎么去

779
00:46:03,370 --> 00:46:07,340
购买了10股，这一分钱的股票总统Skroob，

780
00:46:07,340 --> 00:46:10,340
其用户ID恰好是7号呢？

781
00:46:10,340 --> 00:46:14,070
这表示插入到表下面的ID，符号及股数，

782
00:46:14,070 --> 00:46:18,200
7，'DVN.V'，和10。

783
00:46:18,200 --> 00:46:21,510
但是 - 但是，但是，但是 - 第二行是非常重要的一个。

784
00:46:21,510 --> 00:46:26,310
DUPLICATE KEY UPDATE股的股​​数+的VALUES（股）。

785
00:46:26,310 --> 00:46:28,350
因此，完全神秘的，乍看之下。

786
00:46:28,350 --> 00:46:31,990
但事实证明，这个SQL查询，即使它包装到2号线，

787
00:46:31,990 --> 00:46:35,920
是1个很长的查询，这意味着它的原子

788
00:46:35,920 --> 00:46:41,000
在这个意义上，这个查询将被执行在一起，或没有在所有。

789
00:46:41,000 --> 00:46:45,100
MySQL的定义，这就是他们实现这个查询。

790
00:46:45,100 --> 00:46:51,010
它是由执行一次或根本不保证本手册的定义。

791
00:46:51,010 --> 00:46:54,020
这样做的动机是如下。

792
00:46:54,020 --> 00:46:58,540
如果在这种情况下，你想购买10股股票，

793
00:46:58,540 --> 00:47:02,260
它是一种相同的故事牛奶，这是一种同样的故事，作为ATM。

794
00:47:02,260 --> 00:47:04,970
>> 如果您不使用此语法错误的

795
00:47:04,970 --> 00:47:09,610
而是选择从数据库中看到这一分钱的股票多少股

796
00:47:09,610 --> 00:47:13,750
总统Skroob，并假设他有10股，

797
00:47:13,750 --> 00:47:19,330
一些一瞬间后，你做一个UPDATE语句，

798
00:47:19,330 --> 00:47:24,810
这是在SQL另一份声明中说，继续前进，增加10个股份

799
00:47:24,810 --> 00:47:28,700
因此，在理想状态下，以他现在10的总数是20，

800
00:47:28,700 --> 00:47:33,490
的问题是，因为在数据库中的系统，因为在今天的计算机上

801
00:47:33,490 --> 00:47:35,990
你有多个处理器，多核心 - 

802
00:47:35,990 --> 00:47:38,920
换句话说，计算机可以从字面上可以做多件事情一次 - 

803
00:47:38,920 --> 00:47:44,270
有没有保证，在这种情况下，SELECT和UPDATE

804
00:47:44,270 --> 00:47:46,150
将要发生背靠背。

805
00:47:46,150 --> 00:47:49,140
因此，一个坏的情况是，你做的SELECT

806
00:47:49,140 --> 00:47:51,670
看到这一分钱股票多少股份Skroob，

807
00:47:51,670 --> 00:47:54,710
然后只是偶然另一个数据库中查询被执行 - 

808
00:47:54,710 --> 00:47:57,740
也许它Skroob试图在另一个浏览器窗口买10股

809
00:47:57,740 --> 00:48:00,700
完全在另一个窗口，很像ATM  - 

810
00:48:00,700 --> 00:48:05,410
想在SELECT和UPDATE之间的另一个查询得到。

811
00:48:05,410 --> 00:48:10,210
可能的情况下，Skroob现在失去了一些股份数目

812
00:48:10,210 --> 00:48:14,340
因为另一个进程正在检查他的世界的状态，

813
00:48:14,340 --> 00:48:17,800
他得到了比他应该有更多的股票。

814
00:48:17,800 --> 00:48:23,250
我们不会去的正是那些特别的故事线将进入详情

815
00:48:23,250 --> 00:48:28,380
但问题是，如果你要检查一个变量的值，然后作出决定，

816
00:48:28,380 --> 00:48:32,500
如果有别人做的东西，在这2条语​​句之间的风险，

817
00:48:32,500 --> 00:48:36,220
这可以发生在多处理器系统中，在多核系统中，

818
00:48:36,220 --> 00:48:41,220
做多件事情的能力，在一次与电脑，不好的事情都可能发生

819
00:48:41,220 --> 00:48:44,530
如银行账户被扣除不正确的，买牛奶的两倍多，

820
00:48:44,530 --> 00:48:46,730
在这种情况下，错误的股数。

821
00:48:46,730 --> 00:48:48,370
但有一个更简单的方法来思考这个。

822
00:48:48,370 --> 00:48:53,290
>> 事实证明，SQL也支持，如果你正确地配置你的表，

823
00:48:53,290 --> 00:48:56,920
一些所谓的交易，我认为这实际上是更容易理解

824
00:48:56,920 --> 00:49:00,650
比这个，但它不是一个班轮，所以它实际上是一个更复杂一点。

825
00:49:00,650 --> 00:49:04,960
从字面上有一个名为START TRANSACTION语句在SQL。

826
00:49:04,960 --> 00:49:08,300
就像有SELECT，UPDATE，INSERT，DELETE和JOIN和一帮的人，

827
00:49:08,300 --> 00:49:10,970
有关键字，如START TRANSACTION。

828
00:49:10,970 --> 00:49:13,560
你在pset中7的情况下做的 - 

829
00:49:13,560 --> 00:49:17,270
你没有做到这一点的pset 7，它是没有必要明确卸弃，

830
00:49:17,270 --> 00:49:18,830
但最终的项目，它可以是有用的 - 

831
00:49:18,830 --> 00:49:22,820
如果你调用一个查询的START TRANSACTION，然后再查询

832
00:49:22,820 --> 00:49:25,620
和然后另一个查询，然后另一个，另一个，和另一个

833
00:49:25,620 --> 00:49:31,860
这些查询将不会实际执行，直到你调用的SQL语句COMMIT，

834
00:49:31,860 --> 00:49:37,220
在这一点上，无论是陈述或20项，它们都将被执行一次，

835
00:49:37,220 --> 00:49:42,770
这意味着没有人可以不小心买太多牛奶或借记太多的钱

836
00:49:42,770 --> 00:49:46,340
或买太多的股票，因为所有的查询将执行

837
00:49:46,340 --> 00:49:48,410
背靠背背靠背。

838
00:49:48,410 --> 00:49:51,580
这是超级重要的，特别是当你做这样的事情。

839
00:49:51,580 --> 00:49:54,900
这是一个任意的例子，说让我们更新银行账户

840
00:49:54,900 --> 00:50:00,200
通过设置等于余额 -  $ 1000的账户数为2的平衡。

841
00:50:00,200 --> 00:50:04,260
然后第二个语句，现在让我们存入的$ 1000

842
00:50:04,260 --> 00:50:07,310
进入别人的银行帐户，其帐户数为1。

843
00:50:07,310 --> 00:50:10,400
>> 换句话说，这是一个很好的例子，在那里你要确保

844
00:50:10,400 --> 00:50:13,590
这些语句都发生或根本不

845
00:50:13,590 --> 00:50:15,450
因为否则的话客户会得到拧

846
00:50:15,450 --> 00:50:17,670
你会拿自己的钱，而不是存放在其他地方，

847
00:50:17,670 --> 00:50:20,470
或银行去你要去的地方，钱存得要命

848
00:50:20,470 --> 00:50:23,140
但实际上没有从用户的帐户中减去它。

849
00:50:23,140 --> 00:50:25,810
所以，你想他们两个一起执行。

850
00:50:25,810 --> 00:50:29,140
因此进入世界交易。

851
00:50:29,140 --> 00:50:31,360
所以，一定要记住，在你的脑海里，

852
00:50:31,360 --> 00:50:34,710
没有那么多的目的，只是最后的项目，

853
00:50:34,710 --> 00:50:36,700
但如果你想利用您的最终项目的地方，

854
00:50:36,700 --> 00:50:39,040
如果你要启动它周围的一些公司，

855
00:50:39,040 --> 00:50:41,270
如果你想在校园里一些学生的问题解决

856
00:50:41,270 --> 00:50:45,210
，实际上有一个活的，活跃的网站，这些都是可能出现的那种微妙的错误

857
00:50:45,210 --> 00:50:49,480
如果你不太想通过什么都有可能发生，如果2人

858
00:50:49,480 --> 00:50:54,190
正在试图访问你的网站，在字面上的同一时刻，

859
00:50:54,190 --> 00:50:56,890
据此，他们的查询，否则可能会交织在一起。

860
00:50:58,840 --> 00:51:01,420
>> 准备好一些JavaScript，其捉弄人吗？

861
00:51:01,420 --> 00:51:04,320
这是我们本学期的最后一种语言。好的。

862
00:51:04,320 --> 00:51:09,940
值得庆幸的是，JavaScript会非常，非常，非常相似的语言，C和PHP，

863
00:51:09,940 --> 00:51:11,140
到目前为止，我们已经做了的。

864
00:51:11,140 --> 00:51:14,340
有没有任何JavaScript在pset中7，但它是一个非常有用的工具

865
00:51:14,340 --> 00:51:18,840
当谈到做基于网络的最终项目还是真的只是网络编程更普遍的。

866
00:51:18,840 --> 00:51:20,950
所以，简要概述了一种叫DOM。

867
00:51:20,950 --> 00:51:23,600
这是一个超级简单的网页，其实只是说你好，世界

868
00:51:23,600 --> 00:51:25,970
在标题和在体​​内。

869
00:51:25,970 --> 00:51:29,270
由于缩进一段时间，一直建议

870
00:51:29,270 --> 00:51:31,380
确实是有层次结构的网页。

871
00:51:31,380 --> 00:51:34,220
我可以得出这样的HTML片段为一棵树，

872
00:51:34,220 --> 00:51:37,470
回想起我们的讨论在C的数据结构，如下所示。

873
00:51:37,470 --> 00:51:40,710
我有一些特殊的根称为文档节点的节点，

874
00:51:40,710 --> 00:51:43,650
在短短的时刻，在JavaScript中，我们将看到模拟的。

875
00:51:43,650 --> 00:51:48,330
第一个孩子，唯一的孩子，在这种情况下的HTML标签。

876
00:51:48,330 --> 00:51:49,880
有没有直接映射的doctype。

877
00:51:49,880 --> 00:51:53,170
这是一个特殊的事情，所以我们应该忽略它，当它涉及到这个DOM，

878
00:51:53,170 --> 00:51:55,810
本文档对象模型树。

879
00:51:55,810 --> 00:51:59,530
注意，我已经描绘为一个矩形任意的HTML标签，

880
00:51:59,530 --> 00:52:02,890
有2个孩子：头部和身体。

881
00:52:02,890 --> 00:52:04,840
>> 同样画成矩形。

882
00:52:04,840 --> 00:52:08,970
它是有意义的图示，头是身体的左侧。

883
00:52:08,970 --> 00:52:11,960
其含义是，在树头是第一位的。

884
00:52:11,960 --> 00:52:14,910
因此，实际上是一个订货树当你画它是这样的，

885
00:52:14,910 --> 00:52:17,460
即使是任意的形状和诸如此类的东西。

886
00:52:17,460 --> 00:52:20,360
头同时还有一个孩子叫标题，

887
00:52:20,360 --> 00:52:25,170
和标题其实有自己的孩子，这是“你好，世界”，

888
00:52:25,170 --> 00:52:32,210
这我故意作为这里一个椭圆形，以使其能够稍微不同于矩形提请。

889
00:52:32,210 --> 00:52:37,420
这些矩形元素，而您好，世界上真的有一个文本节点。

890
00:52:37,420 --> 00:52:39,850
所以这是一个树中的节点，但它是一个不同类型的节点

891
00:52:39,850 --> 00:52:41,730
所以我画了任意不同。

892
00:52:41,730 --> 00:52:45,000
同样身体有一个孩子叫你好，世界好，

893
00:52:45,000 --> 00:52:47,910
如此不同的节点，即使它们是巧合的是相同的文字，

894
00:52:47,910 --> 00:52:52,100
但我画它使用相同的形状。那么，谁在乎呢？

895
00:52:52,100 --> 00:52:56,820
那么，什么是好的关于HTML的是，它有这样的层次性。

896
00:52:56,820 --> 00:53:01,010
什么是好的关于JavaScript，特别是库，可免费获得

897
00:53:01,010 --> 00:53:07,120
和流行的如jQuery，您可以通过在树结构如此惊人的容易。

898
00:53:07,120 --> 00:53:11,790
任何的东西，我们在C的指针和遍历树和递归的节点上

899
00:53:11,790 --> 00:53:15,300
左子右孩子，突然之间，我们可以排序的授予

900
00:53:15,300 --> 00:53:19,450
令人惊讶的启发，如果不是有点沮丧

901
00:53:19,450 --> 00:53:22,470
但几乎没有一种有效的方式去编程。

902
00:53:22,470 --> 00:53:24,470
因此，这些较高层次的语言如JavaScript

903
00:53:24,470 --> 00:53:28,340
我们将能够更直观地浏览这个树。

904
00:53:28,340 --> 00:53:30,430
>> 事实上，将是相当熟悉的语法。

905
00:53:30,430 --> 00:53:32,950
如果你从来没有见过的Javascript之前，这是一个非常好的参考

906
00:53:32,950 --> 00:53:35,910
从Mozilla人，谁的人让Firefox，

907
00:53:35,910 --> 00:53:38,370
所以不要随意浏览，在您方便的。

908
00:53:38,370 --> 00:53:41,590
你会发现 - 这些幻灯片是相同的，我们使用的是其他 - 

909
00:53:41,590 --> 00:53:44,030
同样地，主已经一去不复返了。

910
00:53:44,030 --> 00:53:47,010
所以，当你写一个程序，在JavaScript中，没有任何主要功能。

911
00:53:47,010 --> 00:53:48,690
你刚开始写代码。

912
00:53:48,690 --> 00:53:51,660
但JavaScript和C和PHP之间的关键区别

913
00:53:51,660 --> 00:53:55,890
，而C和PHP迄今已执行服务器端

914
00:53:55,890 --> 00:53:59,180
在这种情况下，由器具，或更一般地由服务器

915
00:53:59,180 --> 00:54:04,270
通常是由设计中的JavaScript的浏览器中执行。

916
00:54:04,270 --> 00:54:08,440
换句话说，您可以编写JavaScript代码，我们，

917
00:54:08,440 --> 00:54:13,080
服务器上的设备，但你有你的HTML之间，在你的CSS，

918
00:54:13,080 --> 00:54:16,100
在您的GIF和PNG和JPEG文件

919
00:54:16,100 --> 00:54:19,170
这样，当用户访问你的网页，如果你使用JavaScript，

920
00:54:19,170 --> 00:54:21,770
JavaScript代码，从服务器到浏览器，

921
00:54:21,770 --> 00:54:24,540
和它的实际执行的浏览器。

922
00:54:24,540 --> 00:54:27,960
因此，这甚至是知识产权的有意义的影响。

923
00:54:27,960 --> 00:54:32,600
这是一种愚蠢的，当它涉及到JavaScript代码，甚至想保护您的IP

924
00:54:32,600 --> 00:54:37,560
因为性质的语言，它通常被执行浏览器端。

925
00:54:37,560 --> 00:54:40,360
>> 您可以混淆它，这意味着你可以把它看疯了，丑陋的

926
00:54:40,360 --> 00:54:45,400
没有空格，可怕的变量名，使人们更难窃取您的IP，

927
00:54:45,400 --> 00:54:48,120
更关键的是，它是浏览器端执行。

928
00:54:48,120 --> 00:54:51,790
即使顺便说一句，可使用JavaScript的服务器端，

929
00:54:51,790 --> 00:54:54,480
最常见的情况，现在仍然是在浏览器上。

930
00:54:54,480 --> 00:54:59,800
这里是什么样子。下面是一个if-else if-else结构就像C语言，就像PHP。

931
00:54:59,800 --> 00:55:02,420
这里是一个布尔表达式，当你“或”两件事情。

932
00:55:02,420 --> 00:55:04,330
是当你“和”两件事情。

933
00:55:04,330 --> 00:55:08,300
这里是一个switch语句，这是类似于PHP

934
00:55:08,300 --> 00:55:10,810
，你可以打开不同类型的值。

935
00:55:10,810 --> 00:55:15,180
循环同样在这里，for循环的结构完全相同，这是我们见过的。

936
00:55:15,180 --> 00:55:18,110
while循环，我们已经得到了while循环。

937
00:55:18,110 --> 00:55:20,290
变量，以往任何时候都略有不同。

938
00:55:20,290 --> 00:55:24,560
你声明的变量，比如你在PHP和C，

939
00:55:24,560 --> 00:55:27,860
但同样是JavaScript的弱类型。

940
00:55:27,860 --> 00:55:32,730
您不指定整数或浮点数或字符串或任何类似的通常。

941
00:55:32,730 --> 00:55:34,240
您可以指定变种。

942
00:55:34,240 --> 00:55:38,040
您不必指定变种，但它的意义，如果你不这样做。

943
00:55:38,040 --> 00:55:42,000
通常，如果你省略VAR，你不小心创建一个全局变量，而不是本地。

944
00:55:42,000 --> 00:55:46,420
因此，我建议，你几乎总是只说va​​r和当时的名称的变量。

945
00:55:46,420 --> 00:55:48,740
这是不是一种类型，它只是var为变量。

946
00:55:48,740 --> 00:55:52,930
这将是一个例子，无论是123或“你好，世界”。

947
00:55:52,930 --> 00:55:58,910
数组是当前和语法上类似于PHP。

948
00:55:58,910 --> 00:56:03,690
我会说VAR的数字，然后我再使用方括号来声明一个变量

949
00:56:03,690 --> 00:56:08,870
，它的类型是数组，这些特殊的数字，以逗号分隔。

950
00:56:08,870 --> 00:56:11,740
最后，这是唯一的一个真正看​​起来不同。

951
00:56:11,740 --> 00:56:16,700
回想一下，在PHP中，我们将实现一个关联数组的学生

952
00:56:16,700 --> 00:56:20,220
像Zamyla可能是这样的，其中的变量被称为学生。

953
00:56:20,220 --> 00:56:23,370
方括号的意思来了一个数组。

954
00:56:23,370 --> 00:56:28,500
>> 事实上，我没有使用数字指标，但字符串 -  ID，房子，和名称 - 

955
00:56:28,500 --> 00:56:30,990
意味着这是一个关联数组，

956
00:56:30,990 --> 00:56:34,490
这些箭头的等号和尖括号

957
00:56:34,490 --> 00:56:37,310
也就是说，关键是“id”，值为1;

958
00:56:37,310 --> 00:56:39,310
最关键的是“房子”，是温斯洛普楼;

959
00:56:39,310 --> 00:56:41,800
最关键的是“名”，值是Zamyla陈。

960
00:56:41,800 --> 00:56:47,110
因此，有3个按键，在这里面的关联数组，每一个都有其自身的价值。

961
00:56:47,110 --> 00:56:52,880
我们已经看到，pset的，或你很快会在JavaScript中同样的想法，

962
00:56:52,880 --> 00:56:55,220
但它会看起来像这样。

963
00:56:55,220 --> 00:57:00,070
因此，VAR学生 - 没有美元符号的类型，也没有提及，但是变种 - 

964
00:57:00,070 --> 00:57:05,860
平等相待，然后打开在JavaScript中的花括号，因为当你有键值对，

965
00:57:05,860 --> 00:57:08,900
你实际使用的一些所谓的对象。

966
00:57:08,900 --> 00:57:13,490
你可能还记得谁没有采取的APCS或类似对象从Java

967
00:57:13,490 --> 00:57:15,140
或类似的语言。

968
00:57:15,140 --> 00:57:17,880
JavaScript是不是Java，首先。

969
00:57:17,880 --> 00:57:21,600
这是一个经过深思熟虑的设计决策年前收工别的东西，很受欢迎，

970
00:57:21,600 --> 00:57:25,640
它的名称，即使它具有Java本身没有根本的关系。

971
00:57:25,640 --> 00:57:31,490
JavaScript中的对象，你创建它们的花括号符号。

972
00:57:31,490 --> 00:57:36,710
JavaScript中的对象是几乎等同于关联数组在PHP

973
00:57:36,710 --> 00:57:40,030
当涉及到他们的内部存储数据。

974
00:57:40,030 --> 00:57:44,100
>> 但更有力地在JavaScript中，你可以关联很容易的功能

975
00:57:44,100 --> 00:57:48,040
里面的对象，尽管你可以做到这一点在其他语言中，

976
00:57:48,040 --> 00:57:50,040
这是一个相当普遍的范例，正如我们将看到的。

977
00:57:50,040 --> 00:57:54,380
总之，这个对象代表一个学生，谁是特别Zamyla的，

978
00:57:54,380 --> 00:58:00,380
在概念上，它是类似，只是语法不同。

979
00:58:00,380 --> 00:58:03,840
让实际使用JavaScript在文件中。

980
00:58:03,840 --> 00:58:05,570
原来有一个脚本标记。

981
00:58:05,570 --> 00:58:08,180
我们已经看到了的风格标签和我们见过的其他HTML标签。

982
00:58:08,180 --> 00:58:11,510
实际上脚本标签将包含一些JavaScript代码。

983
00:58:11,510 --> 00:58:15,500
让我进入设备，我们有一些预先的源代码。

984
00:58:15,500 --> 00:58:18,700
我还没有发布在网站上，但下课后，我会做到这一点。

985
00:58:18,700 --> 00:58:21,770
让打开这个1，blink.html的。

986
00:58:21,770 --> 00:58:27,560
早在20世纪90年代，简直是眨眼标签的HTML标签，

987
00:58:27,560 --> 00:58:30,340
而这是一个在互联网上的最奇妙的过度使用的标签

988
00:58:30,340 --> 00:58:36,140
让你访问一些20世纪90年代风格的网页，并开始看到这样的文字闪烁，

989
00:58:36,140 --> 00:58:39,810
结果的侯爵标签，其中有这样的文字去。

990
00:58:39,810 --> 00:58:45,070
其中，世界实际上已同意在Web标准的几十倍，

991
00:58:45,070 --> 00:58:48,250
几年前，董事会每个人都杀了闪烁标签。

992
00:58:48,250 --> 00:58:52,860
但是，我们可以复活它使用JavaScript作为一个示范的权力，你有

993
00:58:52,860 --> 00:58:56,660
当你可以写一个程序内的网页。

994
00:58:56,660 --> 00:59:00,240
首先，让我们略过的新东西，只注重老。

995
00:59:00,240 --> 00:59:01,780
>> 在这个例子中是旧的东西。

996
00:59:01,780 --> 00:59:06,350
我有一个HTML标签，头标签，标题标签。

997
00:59:06,350 --> 00:59:11,210
然后我有一个body标签的div，召回只是一个矩形分割的页面

998
00:59:11,210 --> 00:59:14,720
我的“问候”，任意指定一个唯一的ID，

999
00:59:14,720 --> 00:59:18,320
只是让我有一个唯一提到它的方式，有一些非常简单的文本：

1000
00:59:18,320 --> 00:59:20,220
你好，世界。

1001
00:59:20,220 --> 00:59:23,940
现在让我向上滚动到顶部的这个文件，看看有什么新。

1002
00:59:23,940 --> 00:59:27,710
新往上顶的第一件事，是script标签，

1003
00:59:27,710 --> 00:59:31,280
和内部的脚本标记通知我声明一个函数。

1004
00:59:31,280 --> 00:59:34,610
声明一个函数在JavaScript中，很类似PHP，

1005
00:59:34,610 --> 00:59:37,930
您字面上写函数，则函数的名称，括号，

1006
00:59:37,930 --> 00:59:40,400
也许一些参数，如果需要。

1007
00:59:40,400 --> 00:59:43,510
然后，我得到了我的花括号像往常一样，现在我们有一些稍微新的代码，

1008
00:59:43,510 --> 00:59:45,230
但让我们来看看这是什么意思。

1009
00:59:45,230 --> 00:59:48,670
所以无功格，这也就意味着给我一个变量所谓息。

1010
00:59:48,670 --> 00:59:50,530
我可以把它叫做foo的，但我想它被称为股息

1011
00:59:50,530 --> 00:59:52,620
的原因，在第二，这将是清楚的。

1012
00:59:52,620 --> 00:59:57,480
事实证明，在JavaScript中 - 这是我的网页中嵌入的JavaScript代码 - 

1013
00:59:57,480 --> 01:00:01,760
称为文档的各种有一个特殊的全局变量。

1014
01:00:01,760 --> 01:00:04,780
事实上，JavaScript是一种面向对象的语言。

1015
01:00:04,780 --> 01:00:07,230
我们不会进入细节，这是什么意思，在50

1016
01:00:07,230 --> 01:00:11,180
但现在知道对象是一个结构很像。

1017
01:00:11,180 --> 01:00:14,740
就像我们看到的遥想当年最早的一个问题设置

1018
01:00:14,740 --> 01:00:17,150
在一个结构，我们投入了大量的信息，

1019
01:00:17,150 --> 01:00:21,330
同样是文件的特殊结构，自带的浏览器，

1020
01:00:21,330 --> 01:00:24,810
任何网页。这不是我创建了。

1021
01:00:24,810 --> 01:00:28,210
本文件的结构里面，但是，你不仅数据

1022
01:00:28,210 --> 01:00:30,010
但你也具备的功能。

1023
01:00:30,010 --> 01:00:34,090
>> 任何时候你有一个函数的内部结构，里面的一个对象，

1024
01:00:34,090 --> 01:00:36,490
这就是所谓的一个方法。但是，同样的事情。

1025
01:00:36,490 --> 01:00:40,110
一个方法是一个函数，刚好是里面别的东西。

1026
01:00:40,110 --> 01:00:42,990
因此，这意味着，这个特殊的全局变量文件

1027
01:00:42,990 --> 01:00:47,690
有一个函数调用，基本上getElementById。

1028
01:00:47,690 --> 01:00:52,460
这将让你的DOM元素，文档对象模型树，

1029
01:00:52,460 --> 01:00:55,520
其ID是在这种情况下问候语。

1030
01:00:55,520 --> 01:00:59,200
换句话说，我们所有的时间花在数据结构来这里发挥作用。

1031
01:00:59,200 --> 01:01:01,400
这张照片的DOM，我们过会儿前，

1032
01:01:01,400 --> 01:01:06,100
即使是有点不同的，如果我有一个div在这幅画中，

1033
01:01:06,100 --> 01:01:11,180
什么样的document.getElementById返回我是一个指针

1034
01:01:11,180 --> 01:01:15,440
到的矩形在树中，树中的矩形的参考。

1035
01:01:15,440 --> 01:01:18,410
所以，这意味着什么实际调用这些功能之一。

1036
01:01:18,410 --> 01:01:21,960
在这种情况下，这又是一个div。这不是一个机构或一个标题。

1037
01:01:21,960 --> 01:01:26,480
因此，让我们来看看什么我现在做的这个div，我有这个变量称为格内。

1038
01:01:26,480 --> 01:01:32,580
原来你有能力动态调整您的网页的CSS与JavaScript。

1039
01:01:32,580 --> 01:01:39,060
到现在为止，所有的CSS，尽管是有限的，我们所做的是在样式属性，

1040
01:01:39,060 --> 01:01:41,730
或有什么地方我们把CSS？

1041
01:01:42,730 --> 01:01:45,810
我有点被宠坏的那一个。在风格标签在文件的顶部。

1042
01:01:45,810 --> 01:01:49,180
或第三位一直在吗？

1043
01:01:50,710 --> 01:01:54,590
>> 一个外部文件中，一些CSS。

1044
01:01:54,590 --> 01:01:56,730
因此，这些都是CSS迄今为止，我们已经做了3个地方，

1045
01:01:56,730 --> 01:01:59,310
但美中不足的是，我们已经硬编码。

1046
01:01:59,310 --> 01:02:04,060
你决定你一头扎进pset中7，我们决定在课前将我们的CSS。

1047
01:02:04,060 --> 01:02:07,380
但是如果你想改变你的CSS，你可以真正做到这一点

1048
01:02:07,380 --> 01:02:09,370
一旦你有一个实际的编程语言。

1049
01:02:09,370 --> 01:02:13,910
CSS，HTML  - 不是编程语言。 JavaScript是。

1050
01:02:13,910 --> 01:02:18,200
因此，原来，一旦你有这些矩形树

1051
01:02:18,200 --> 01:02:23,050
所谓的DOM，它本身它里面的一些数据。

1052
01:02:23,050 --> 01:02:27,820
所以，我刚拿到的div从树上有什么，我们会打电话给它里面的一个属性

1053
01:02:27,820 --> 01:02:34,390
称为风格，样式属性本身也是一个属性叫的知名度。

1054
01:02:34,390 --> 01:02:37,330
我也知道这只是寻找一个CSS用户手册。

1055
01:02:37,330 --> 01:02:41,160
原来有一个可见性CSS属性，它做什么它说。

1056
01:02:41,160 --> 01:02:44,530
这使得一些可见的或不可见或不可见。

1057
01:02:44,530 --> 01:02:46,810
而如何做到这一点是这样的。

1058
01:02:46,810 --> 01:02:50,510
我问的编程方式，如果这个div隐藏的知名度，

1059
01:02:50,510 --> 01:02:53,390
我该怎么改变？可见。

1060
01:02:53,390 --> 01:02:58,840
否则，如果这个页面是不是隐藏的知名度，在逻辑上我隐藏它。

1061
01:02:58,840 --> 01:03:04,070
我不知道为什么它是可见的和隐藏的和不可见的和不可见的。

1062
01:03:04,070 --> 01:03:06,000
这是一个糟糕的设计决定的方式。

1063
01:03:06,000 --> 01:03:09,530
但是，这些是对立的CSS可见的和隐藏。

1064
01:03:09,530 --> 01:03:15,520
所有这一切都没有是不是就意味着改变我的CSS文件和关闭，开启和关闭

1065
01:03:15,520 --> 01:03:16,870
为特定的分区。

1066
01:03:16,870 --> 01:03:20,630
但是，这是一个函数调用的闪烁。当闪烁功能叫什么名字？

1067
01:03:20,630 --> 01:03:24,080
事实证明，有一个特殊的全局变量称为窗口，

1068
01:03:24,080 --> 01:03:28,220
类似的文件精神，而文件是指您的网页，

1069
01:03:28,220 --> 01:03:31,700
像你的HTML DOM树，从服务器发送，

1070
01:03:31,700 --> 01:03:35,250
窗口是指在它的周围，镀铬的地址栏，标题栏，

1071
01:03:35,250 --> 01:03:37,880
所有的东西在你的网页。

1072
01:03:37,880 --> 01:03:42,800
>> 而事实证明，在窗口对象有一个特殊的功能，它里面叫的setInterval

1073
01:03:42,800 --> 01:03:44,360
做什么它说。

1074
01:03:44,360 --> 01:03:48,600
将设置的时间间隔 - 在这种情况下，每500毫秒 - 

1075
01:03:48,600 --> 01:03:52,270
，可以猜，什么会做的每500毫秒？

1076
01:03:52,270 --> 01:03:55,240
这将执行该函数闪烁。

1077
01:03:55,240 --> 01:03:58,560
很高兴在这里，我们可以这样做，即使我们从来没有在C。

1078
01:03:58,560 --> 01:04:01,580
C也有被调用的函数指针的东西，在这里你可以通过功能左右

1079
01:04:01,580 --> 01:04:03,140
作为参数。

1080
01:04:03,140 --> 01:04:07,620
同样，在JavaScript中，你可以传递到另一个函数的函数的名称。

1081
01:04:07,620 --> 01:04:10,630
注意到我在做什么。我没有这样做。

1082
01:04:10,630 --> 01:04:14,380
如果我把括号后的闪烁，这意味着呼吁闪烁功能。

1083
01:04:14,380 --> 01:04:17,430
如果我忽略它们，在这里的意思是闪烁功能

1084
01:04:17,430 --> 01:04:21,330
这样的setInterval可以把它每隔500毫秒。

1085
01:04:21,330 --> 01:04:28,200
因此，最终的结果是残酷的，但是，如果我进入本地和blink.html去，

1086
01:04:28,200 --> 01:04:32,120
我现在有这种情况发生了一次又一次。

1087
01:04:32,120 --> 01:04:34,950
如果我真的检查的元素，让我们看看我们可以看到这一点。

1088
01:04:34,950 --> 01:04:38,550
让我检查元素，让我向下滚动，只需要一点点，

1089
01:04:38,550 --> 01:04:44,320
让我选择在这里的元素，并注意Chrome浏览器的DOM里面督察。

1090
01:04:44,320 --> 01:04:48,840
它的字面来回变化，每500毫秒。

1091
01:04:48,840 --> 01:04:55,660
如果我们去我们的朋友内特，

1092
01:04:55,660 --> 01:05:00,020
，如果你以往任何时候都想知道这是如何的工作的，类似的的的想法与一个时间间隔，

1093
01:05:00,020 --> 01:05:04,810
但内特 - 实际上是非常有效地利用颜色在这种特殊情况下在这里。

1094
01:05:04,810 --> 01:05:07,350
所以，我们还有什么可以做呢？

1095
01:05:07,350 --> 01:05:09,990
让我们打开另一个例子试试

1096
01:05:09,990 --> 01:05:12,940
这是通过编程更加有用的事情闪烁。

1097
01:05:12,940 --> 01:05:17,990
让我今天进入我们的表格目录，进入FORM0。

1098
01:05:17,990 --> 01:05:20,820
这是我能想出的最丑陋的形式，

1099
01:05:20,820 --> 01:05:23,290
让我告诉你什么是它看起来像在浏览器中。

1100
01:05:23,290 --> 01:05:28,960
>> 让我进入本地主机/形式，这是FORM0的。

1101
01:05:28,960 --> 01:05:33,400
这是一个超级难看的HTML表格，有几个字段，电子邮件，密码，

1102
01:05:33,400 --> 01:05:37,190
密码，然后一点点的复选框，同意某些条款和条件。

1103
01:05:37,190 --> 01:05:41,350
美中不足的是，如果我访问的形式，我不想给你我的电子邮件地址，

1104
01:05:41,350 --> 01:05:44,730
我不想同意的条款和条件也许，我可以单击“注册”

1105
01:05:44,730 --> 01:05:46,920
它让我通过了。

1106
01:05:46,920 --> 01:05:50,800
发生这种情况向一个愚蠢的PHP称为dump.php的文件。

1107
01:05:50,800 --> 01:05:58,420
它的作用是打印出来的内容只是用于诊断目的的$ _GET。

1108
01:05:58,420 --> 01:06:01,580
这是由用户提交的只是现在。

1109
01:06:01,580 --> 01:06:05,010
但是，假设我们要验证用户的表单提交。

1110
01:06:05,010 --> 01:06:06,530
让我进入第1版。

1111
01:06:06,530 --> 01:06:11,420
这是form1.html。它看起来美观一样糟糕，但要注意它是如何的花哨。

1112
01:06:11,420 --> 01:06:15,450
如果没有合作，我请单击“注册”我被骂。

1113
01:06:15,450 --> 01:06:17,320
“您必须提供您的电子邮件地址。”

1114
01:06:17,320 --> 01:06:21,670
好的。所以，让我来试试。所以malan@harvard.edu。我并不需要一个密码。

1115
01:06:21,670 --> 01:06:25,100
注册。 “你必须提供一个密码。”好的。

1116
01:06:25,100 --> 01:06:28,470
因此，我将提供深红色的密码。注册。

1117
01:06:28,470 --> 01:06:32,300
“密码不匹配”。我现在必须输入深红色这里。

1118
01:06:32,300 --> 01:06:35,710
我不小心检查。注册。

1119
01:06:35,710 --> 01:06:39,860
“您必须同意的条款和条件。”好的。同意。注册。

1120
01:06:39,860 --> 01:06:43,700
现在，它让我看到那边的诊断输出。

1121
01:06:43,700 --> 01:06:45,630
>> 所以，刚刚发生了什么？

1122
01:06:45,630 --> 01:06:48,330
我们有这个能力来验证表单提交。

1123
01:06:48,330 --> 01:06:51,420
事实上，如果你没有潜入的pset 7，有一个歉意的功能

1124
01:06:51,420 --> 01:06:54,620
这使得它很容易在用户屏幕上的一条消息，大喊大叫。

1125
01:06:54,620 --> 01:06:57,580
我使用了一个略微不同的机制，报警功能，

1126
01:06:57,580 --> 01:07:03,690
这是不是一个函数的笑了，因为它非常丑陋的用户信息。

1127
01:07:03,690 --> 01:07:05,710
但是让我们看看我在这里做什么。

1128
01:07:05,710 --> 01:07:09,620
这是form1.html的，请注意，我有一些非常熟悉的语法：

1129
01:07:09,620 --> 01:07:12,920
body标签，表单标签，action属性，属性的方法。

1130
01:07:12,920 --> 01:07:17,050
但是请注意，我已经给了我一个独特的ID为方便。

1131
01:07:17,050 --> 01:07:19,190
然后我收到一封电子邮件，其类型为文本字段，

1132
01:07:19,190 --> 01:07:23,780
一个密码字段，它的类型是密码，确认字段，它的类型是密码，

1133
01:07:23,780 --> 01:07:28,070
一个复选框，然后在这里他的名字是协议类型为复选框。

1134
01:07:28,070 --> 01:07:30,380
然后我有一个提交按钮。

1135
01:07:30,380 --> 01:07:33,050
但是请注意，在上面更何况我有。

1136
01:07:33,050 --> 01:07:35,810
首先，有一个使用的脚本标记。

1137
01:07:35,810 --> 01:07:40,520
如果你有一些JavaScript代码，在另一个文件中，就像CSS，你可以将其包含。

1138
01:07:40,520 --> 01:07:44,530
你用脚本源代码，然后通知我连接显然

1139
01:07:44,530 --> 01:07:50,349
很长的路径，但其文件名googleapis.com在jquery.min结束

1140
01:07:50,349 --> 01:07:52,420
最小的。js。

1141
01:07:52,420 --> 01:07:55,969
jQuery是一个超级流行的，只是使JavaScript的JavaScript库

1142
01:07:55,969 --> 01:07:58,230
更方便用户的使用。

1143
01:07:58,230 --> 01:08:00,610
它实际上成为了事实上的标准。

1144
01:08:00,610 --> 01:08:04,090
因此，即使你将要看到的是不是纯JavaScript本身，

1145
01:08:04,090 --> 01:08:09,340
它是很像CS50库之上的JavaScript库是一层

1146
01:08:09,340 --> 01:08:13,670
在顶部的低级别的C代码，现实的情况是，几乎每个人都在互联网上使用它。

1147
01:08:13,670 --> 01:08:18,030
因此，这些都是没有培训车轮。这是最好的练习，这些天。

1148
01:08:18,030 --> 01:08:22,830
现在注意下面的是我自己的脚本标签，并注意我在这里所做的。

1149
01:08:22,830 --> 01:08:27,450
事实证明，，jQuery也有点花哨的东西。

1150
01:08:27,450 --> 01:08:29,660
JavaScript有货币符号，但他们是没有意义的。

1151
01:08:29,660 --> 01:08:32,870
>> 他们就像字母A或B或C。

1152
01:08:32,870 --> 01:08:36,670
jQuery没有简单地采用公约或下岗的要求这样的事实：

1153
01:08:36,670 --> 01:08:40,280
，将是他们的特殊符号。

1154
01:08:40,280 --> 01:08:44,950
因此，只要你加载这个全球性的JavaScript文件的脚本标签，

1155
01:08:44,950 --> 01:08:49,080
您可以访问一个特殊的全局变量，这就是所谓的$。

1156
01:08:49,080 --> 01:08:53,009
它更恰当地称为jQuery的，但看上去不性感$。

1157
01:08:53,009 --> 01:08:56,250
但没有特殊的意义。在PHP中，它有特殊的意义。

1158
01:08:56,250 --> 01:08:58,440
你必须有它前面的变量。

1159
01:08:58,440 --> 01:09:01,670
这仅仅是一个性感的事情，他们就。

1160
01:09:01,670 --> 01:09:03,389
这到底是怎么回事呢？

1161
01:09:03,389 --> 01:09:08,830
请注意，我通过我的jQuery功能全局变量文件

1162
01:09:08,830 --> 01:09:10,860
然后我打电话。准备好了。

1163
01:09:10,860 --> 01:09:15,480
什么jQuery基本上的作用是它可以让你采取一些普通的JavaScript的东西

1164
01:09:15,480 --> 01:09:17,889
像文档对象，window对象，

1165
01:09:17,889 --> 01:09:20,790
而如果你把它传递到jQuery函数 - 

1166
01:09:20,790 --> 01:09:24,429
再次，要清楚，这是一个函数调用jQuery的 - 

1167
01:09:24,429 --> 01:09:28,240
它是什么，它​​会返回给你一个特殊版本的文件

1168
01:09:28,240 --> 01:09:30,700
具有更多的功能，与它相关联的。

1169
01:09:30,700 --> 01:09:34,760
因此，在原始JavaScript有没有现成的函数，

1170
01:09:34,760 --> 01:09:37,810
但如果你通过文件的jQuery功能，

1171
01:09:37,810 --> 01:09:40,960
它返回给你一个特殊版本的文档对象

1172
01:09:40,960 --> 01:09:43,030
有更多花哨的功能。

1173
01:09:43,030 --> 01:09:48,230
这就是为什么人们喜欢它的原因。它只是使事情变得更容易的事，因为我们将要看到的。

1174
01:09:48,230 --> 01:09:49,820
那么，是什么这行代码是什么意思？

1175
01:09:49,820 --> 01:09:52,690
这行代码在这里是指当文件准备 - 

1176
01:09:52,690 --> 01:09:56,830
换句话说，一旦浏览器完成读取此文件从上到下 - 

1177
01:09:56,830 --> 01:09:59,200
继续执行以下功能。

1178
01:09:59,200 --> 01:10:03,540
什么是真正有趣的JavaScript  -  PHP以及 - 

1179
01:10:03,540 --> 01:10:05,450
匿名函数。

1180
01:10:05,450 --> 01:10:10,560
在JavaScript中，你可以声明没有名字，但他们有一个身体的功能。

1181
01:10:10,560 --> 01:10:12,570
请注意，这里发生了什么。

1182
01:10:12,570 --> 01:10:16,220
>> 这是一个函数调用的准备，它只是意味着执行以下操作

1183
01:10:16,220 --> 01:10:20,220
当整个网页是准备好了，当这些都被读出在从服务器。

1184
01:10:20,220 --> 01:10:23,090
你想要做什么？我想执行的代码块。

1185
01:10:23,090 --> 01:10:27,120
请注意，我们不希望马上执行这些代码。

1186
01:10:27,120 --> 01:10:34,350
如果我忽略了这一点，这将意味着立即开始执行这些代码行。

1187
01:10:34,350 --> 01:10:39,040
但事实上，我说，不，不，不，包在一个匿名函数，这样

1188
01:10:39,040 --> 01:10:43,000
表示不执行它，把它最终。

1189
01:10:43,000 --> 01:10:45,430
我们看到刚才我们在以前的表格的例子。

1190
01:10:45,430 --> 01:10:49,990
什么样的功能，我们称之为最终，500毫秒后呢？闪烁。

1191
01:10:49,990 --> 01:10:51,480
所以同样的想法。

1192
01:10:51,480 --> 01:10:53,950
再次，即使这看起来有点怪异，只是现在信仰

1193
01:10:53,950 --> 01:10:57,060
，这就是所谓的最终声明一个匿名函数，

1194
01:10:57,060 --> 01:11:01,720
只要简单的写函数（）{

1195
01:11:01,720 --> 01:11:05,380
所以我们要什么样的代码最终执行吗？以下。

1196
01:11:05,380 --> 01:11:10,460
这也显得有些新的，但在这里的意思是jQuery的功能，

1197
01:11:10,460 --> 01:11:13,430
，这是一条捷径。

1198
01:11:13,430 --> 01:11:18,830
下面这段HTML在屏幕的底部，当然有一些树表示。

1199
01:11:18,830 --> 01:11:21,730
它不是这个。此页面是更有趣的比这个Hello World例子。

1200
01:11:21,730 --> 01:11:25,210
但还有一些树，对应于这个HTML。

1201
01:11:25,210 --> 01:11:28,910
这将是一个痛苦在脖子上不得不实行某种递归函数

1202
01:11:28,910 --> 01:11:34,380
开始的根节点，然后找到该节点的ID注册。

1203
01:11:34,380 --> 01:11:38,340
那么，什么jQuery，我们这简直是超级容易。

1204
01:11:38,340 --> 01:11:43,000
来吧，让我无论div或任何形式，任何HTML元素

1205
01:11:43,000 --> 01:11:45,820
有一个ID的登记。

1206
01:11:45,820 --> 01:11:52,440
这是相当于的document.getElementById（“注册”）。

1207
01:11:52,440 --> 01:11:54,170
>> 人们为什么喜欢jQuery？

1208
01:11:54,170 --> 01:12:00,110
因为它是更短的输入。但是，这一切是。这是同样的想法。

1209
01:12:00,110 --> 01:12:02,630
我的标签的ID注册。

1210
01:12:02,630 --> 01:12:06,300
而当该标签，这恰好是一个形式，提交，

1211
01:12:06,300 --> 01:12:08,300
继续执行该代码。

1212
01:12:08,300 --> 01:12:11,320
因此，让我们现在看我们如何做表单验证。

1213
01:12:11,320 --> 01:12:15,950
语法在第一，但无可否认，神秘的是怎么回事呢？

1214
01:12:15,950 --> 01:12:21,050
如果这行代码是真实的，我要骂的用户提供他或她的电子邮件地址。

1215
01:12:21,050 --> 01:12:22,970
那么，这行代码是什么？

1216
01:12:22,970 --> 01:12:25,560
$ jQuery的。我们注意到这一点。

1217
01:12:25,560 --> 01:12:27,920
这是一种像CSS。

1218
01:12:27,920 --> 01:12:33,370
如果你跳入CSS，你就会知道，这意味着该元素的ID注册。

1219
01:12:33,370 --> 01:12:39,840
空间意味着找到一个孩子或一个登记的后裔，他的名字是输入。

1220
01:12:39,840 --> 01:12:42,970
那么这件事情在方括号中是一个小的过滤器。

1221
01:12:42,970 --> 01:12:47,010
而且，即使这个看起来很神秘的，这也就意味着去的形式，其ID的注册，

1222
01:12:47,010 --> 01:12:51,230
到输入元素内，他的名字是电子邮件，

1223
01:12:51,230 --> 01:12:55,440
然后得到它的价值，无论它的值恰好是 - 

1224
01:12:55,440 --> 01:12:59,670
航空自卫队这是我类型或malan@harvard.edu的，如果这是我所输入的。

1225
01:12:59,670 --> 01:13:05,250
因此，如果窗体的电子邮件领域==没什么，骂的用户。

1226
01:13:05,250 --> 01:13:09,700
否则，如果密码字段中的值的==什么都没有，骂的用户。

1227
01:13:09,700 --> 01:13:19,520
>> 否则，如果的密码字段的值不等于确认字段的值，

1228
01:13:19,520 --> 01:13:22,850
这是另一种形式的元素，在用户嚷嚷。

1229
01:13:22,850 --> 01:13:25,680
最后 - 而这其中也有它自己的一些新的语法，

1230
01:13:25,680 --> 01:13:29,270
但一旦你看到它，它至少更合理一点 - 

1231
01:13:29,270 --> 01:13:34,060
否则，如果是注册ID的形式，其有一个输入元素，其名称是协议

1232
01:13:34,060 --> 01:13:39,720
和检查，继续前进，大声嚷嚷的用户。

1233
01:13:39,720 --> 01:13:42,520
所以，我承认，乍看之下，这完全是压倒性的。

1234
01:13:42,520 --> 01:13:46,530
这是一个很多新的语法。但是，所有的jQuery如下这些种模式。

1235
01:13:46,530 --> 01:13:49,880
说实话，我不知道这存在，直到几分钟前。

1236
01:13:49,880 --> 01:13:53,640
我用Google搜索，“你怎么检查，如果一个复选框被选中，在jQuery吗？”

1237
01:13:53,640 --> 01:13:55,680
这是语法，因为有不同的方法做这件事

1238
01:13:55,680 --> 01:13:58,010
与实际原始JavaScript代码。

1239
01:13:58,010 --> 01:14:01,030
因此，作为第一页习题集7所强调的，

1240
01:14:01,030 --> 01:14:04,500
pset中7是非常行使自己的引导

1241
01:14:04,500 --> 01:14:08,650
我们提供了希望，一个概念性的框架，以解决在pset。

1242
01:14:08,650 --> 01:14:12,280
>> 但往往是网页设计的情况下，这是给你真正闲逛，

1243
01:14:12,280 --> 01:14:16,680
只要你引用它们包含的代码片段和例子从Web

1244
01:14:16,680 --> 01:14:17,960
每上，第一页的条款，

1245
01:14:17,960 --> 01:14:21,460
并认识到，学习HTML，CSS，JavaScript和SQL

1246
01:14:21,460 --> 01:14:26,020
真正的意思是在家里工作，我们已开始采取这些训练车轮。

1247
01:14:26,020 --> 01:14:29,150
并实现也有那么多的事情可以做的浏览器。

1248
01:14:29,150 --> 01:14:33,790
这些元素里面还有其他的东西称为事件处理程序。

1249
01:14:33,790 --> 01:14:37,140
即使我们只是看着那些被称为的onsubmit和onready，

1250
01:14:37,140 --> 01:14:40,310
你可以做这样的事情的OnKeyDown，调用onKeyUp，

1251
01:14:40,310 --> 01:14:43,410
喜欢当用户触摸键时，你可以听，键向上。

1252
01:14:43,410 --> 01:14:45,940
Gmail有键盘快捷键。

1253
01:14:45,940 --> 01:14:49,490
如何实现快捷键，例如C组成？

1254
01:14:49,490 --> 01:14:54,120
侦听事件，因为他们是所谓的，喜欢的OnKeyPress或onKeyUp和聚焦的。

1255
01:14:54,120 --> 01:14:56,360
如果你曾经在一些菜单选项悬停你的鼠标

1256
01:14:56,360 --> 01:15:00,180
突然，瞧，出现一个菜单或图形的颜色会发生变化，

1257
01:15:00,180 --> 01:15:01,920
他们是如何做呢？

1258
01:15:01,920 --> 01:15:06,940
而不是听的onready或的onsubmit，你听的onmouseover或鑻。

1259
01:15:06,940 --> 01:15:10,920
>> 因此，在短，这些非常简单的基础知识，我们已经开始触及问题的表面今日

1260
01:15:10,920 --> 01:15:13,940
，我们将深入进一步周三，你有越来越多的

1261
01:15:13,940 --> 01:15:17,530
实施种的东西，你已经很熟悉了。

1262
01:15:17,530 --> 01:15:21,620
因此，让我们的结束，我们将继续在周三。

1263
01:15:22,690 --> 01:15:24,320
>> [CS50.TV]