1
00:00:00,000 --> 00:00:00,890

2
00:00:00,890 --> 00:00:03,835
>> [音乐播放]

3
00:00:03,835 --> 00:00:10,597

4
00:00:10,597 --> 00:00:12,030
>> 扬声器1：好吧，大家好。

5
00:00:12,030 --> 00:00:14,330
欢迎您与我最后一节。

6
00:00:14,330 --> 00:00:16,160
它已经相当的学期。

7
00:00:16,160 --> 00:00:21,290
我不能相信这是一样，
第12周或11，类似的东西。

8
00:00:21,290 --> 00:00:24,520
但是，因为它是我们最后的
节中，我们有很多的糖果。

9
00:00:24,520 --> 00:00:27,090
我要去尝试和
预习，你我都一样，

10
00:00:27,090 --> 00:00:30,270
可以为您的测验上周三。

11
00:00:30,270 --> 00:00:34,060
所以可能不是最好的办法，
象，端部与测验审查。

12
00:00:34,060 --> 00:00:35,630
但我们会尽力使之有趣。

13
00:00:35,630 --> 00:00:36,720
而且总是有糖果。

14
00:00:36,720 --> 00:00:39,070
所以希望，这将使它更好。

15
00:00:39,070 --> 00:00:43,800
>> 您的测验将是非常
同样的事情作为测验零。

16
00:00:43,800 --> 00:00:46,840
这将是
格式相同，长度相同。

17
00:00:46,840 --> 00:00:50,065
你会在房间散落
在校园，因为那里

18
00:00:50,065 --> 00:00:54,660
接近你900，我们不能
在房间像这一切抱着你。

19
00:00:54,660 --> 00:00:58,610
所以一定要看看所有的
测验一个文档

20
00:00:58,610 --> 00:01:02,410
网上cs50.harvard.edu
今晚或明天晚上。

21
00:01:02,410 --> 00:01:06,070
确保你知道你
去，你需要带上。

22
00:01:06,070 --> 00:01:10,052
真的，你只需要带上自己
和一支铅笔，你应该罚款。

23
00:01:10,052 --> 00:01:11,760
这些问题将是
大同小异。

24
00:01:11,760 --> 00:01:15,250
很可能会发生一对夫妇
选择题，一对夫妇简短的回答，

25
00:01:15,250 --> 00:01:22,610
一些编码，也许有些真/假，
匹配各种各样的事情。

26
00:01:22,610 --> 00:01:27,790
所以，你不应该太
由格式惊讶。

27
00:01:27,790 --> 00:01:31,380
>> 又有什么可奇怪的是
长度，这在往年，

28
00:01:31,380 --> 00:01:32,970
一直要长得多。

29
00:01:32,970 --> 00:01:38,060
在我的本命年，我没有一个朋友
我记得在完成考试。

30
00:01:38,060 --> 00:01:41,100
有多个像
页留空。

31
00:01:41,100 --> 00:01:43,710
这样的长度可
那种迷失方向的

32
00:01:43,710 --> 00:01:47,554
只是因为在某些年份，它有
已经比测验一个长得多。

33
00:01:47,554 --> 00:01:49,720
我不知道那是什么
要像今年，

34
00:01:49,720 --> 00:01:51,640
但它的东西要注意的。

35
00:01:51,640 --> 00:01:53,390
>> 此外，该
difficulty--人们往往

36
00:01:53,390 --> 00:01:56,660
找到一个测验更
难度比测验零。

37
00:01:56,660 --> 00:01:58,590
再次，你知道，如果
那种你走

38
00:01:58,590 --> 00:02:01,590
出来感觉有点不安，因为
你没有这样做，以及你想

39
00:02:01,590 --> 00:02:04,430
你或者你觉得你没
这样做，以及你做了一个测验，

40
00:02:04,430 --> 00:02:07,429
记住，有可能是一个
其他很多人感觉这样的。

41
00:02:07,429 --> 00:02:09,800
我肯定是那些人之一。

42
00:02:09,800 --> 00:02:11,770
测验1一样，把我一个循环。

43
00:02:11,770 --> 00:02:14,540
和我的朋友有这个伟大的
他们在JP舔图片

44
00:02:14,540 --> 00:02:17,834
这些庞大的种
圣代，是喜欢，测验一，

45
00:02:17,834 --> 00:02:19,250
并期待像他们在流泪。

46
00:02:19,250 --> 00:02:21,860
>> 所以这是一个一般的感觉。

47
00:02:21,860 --> 00:02:25,257
这是一个严峻的考验，这是一个艰难的测验。

48
00:02:25,257 --> 00:02:28,340
很显然，如果你来了，你
感觉你震撼吧，为你的伟大。

49
00:02:28,340 --> 00:02:32,050
但是要知道，你可能不是 - 
你几乎绝对不是

50
00:02:32,050 --> 00:02:36,020
孤独，如果你走了样的感觉，
嗯，也许可以变得更好。

51
00:02:36,020 --> 00:02:37,003
它太硬。

52
00:02:37,003 --> 00:02:37,503
嗯。

53
00:02:37,503 --> 00:02:39,120
>> 听众：有多少是值得
相对于[听不清]？

54
00:02:39,120 --> 00:02:40,411
>> 扬声器1：这是值得的一样。

55
00:02:40,411 --> 00:02:41,730
是啊。

56
00:02:41,730 --> 00:02:45,150
但同样，它也将是
受类如何其余

57
00:02:45,150 --> 00:02:48,766
确实，你怎么不节，
你是如何随着时间的推移改善。

58
00:02:48,766 --> 00:02:50,390
分级是一个黑盒子一点点。

59
00:02:50,390 --> 00:02:54,310
那么什么实际数量
或百分比你

60
00:02:54,310 --> 00:02:56,790
不一定直接喜欢
与分级呈正相关

61
00:02:56,790 --> 00:02:57,790
你会得到的。

62
00:02:57,790 --> 00:03:00,210
有很多的
即进入它的因素。

63
00:03:00,210 --> 00:03:04,090
>> 所以这样，我们要去
通过一些测验审查。

64
00:03:04,090 --> 00:03:07,600
我只是要运行这个
就像最后一次你们。

65
00:03:07,600 --> 00:03:10,960
我有所有的答案
考考最后一个年度。

66
00:03:10,960 --> 00:03:14,260
所以，如果你们想拉
那在您自己的电脑，

67
00:03:14,260 --> 00:03:18,100
如果你已经采取了这一考试
之前，你有问题，

68
00:03:18,100 --> 00:03:20,090
我在想我们能
只是通过一些

69
00:03:20,090 --> 00:03:22,380
的更困难的问题上。

70
00:03:22,380 --> 00:03:25,810
所以我们可以谈论它，也许
得到多一点见识

71
00:03:25,810 --> 00:03:29,260
到后面的一些直觉
这些问题，如何处理它们。

72
00:03:29,260 --> 00:03:34,420
>> 还有，像上次一样，
我有一个100张幻灯片甲板

73
00:03:34,420 --> 00:03:37,760
有基本上都
幻灯片，我

74
00:03:37,760 --> 00:03:40,360
已经准备好以前
自上次quiz--我路段

75
00:03:40,360 --> 00:03:41,540
在这甲板上。

76
00:03:41,540 --> 00:03:43,960
所以我们可以通过
几乎任何东西

77
00:03:43,960 --> 00:03:46,450
我们已经谈过
事先，也许你

78
00:03:46,450 --> 00:03:49,130
希望在多一点澄清。

79
00:03:49,130 --> 00:03:50,320
我们能做到这一点首先。

80
00:03:50,320 --> 00:03:52,567
>> 但除此之外，我超级
幸福只是一种工作，

81
00:03:52,567 --> 00:03:53,900
通过这些问题与您联系。

82
00:03:53,900 --> 00:03:58,700
而且我真的在这里
专注于你们的想法

83
00:03:58,700 --> 00:04:01,466
将是最重要的关注。

84
00:04:01,466 --> 00:04:03,466
喜欢，很明显，所有的
这东西是很重要的。

85
00:04:03,466 --> 00:04:07,444

86
00:04:07,444 --> 00:04:10,610
特别是我们通过测验一，
我一定会指出之类的东西，

87
00:04:10,610 --> 00:04:13,380
哦，这可能是什么
你真的想知道

88
00:04:13,380 --> 00:04:15,170
或者你想对你的备忘单。

89
00:04:15,170 --> 00:04:18,100
我会告诉你的事情
因为我们种经历。

90
00:04:18,100 --> 00:04:22,079
>> 所以，关于这一点，还有什么东西
那你们想去过？

91
00:04:22,079 --> 00:04:26,050
另外，如果我没有在我的甲板上，
我们可以拉起来的东西在网络上，

92
00:04:26,050 --> 00:04:28,340
或者我们可以尝试做
向上对飞的一个例子。

93
00:04:28,340 --> 00:04:32,756
但任何概念，你
人是一个有点模糊。

94
00:04:32,756 --> 00:04:33,880
[？布莱恩？]你have--

95
00:04:33,880 --> 00:04:36,134
>> 听众：哦，是吗累计？

96
00:04:36,134 --> 00:04:38,300
喜欢，是对测验的东西
零点将要放在这里？

97
00:04:38,300 --> 00:04:41,100
>> 扬声器1：这是累积的，
但它更

98
00:04:41,100 --> 00:04:44,330
强调的东西
自上次测验。

99
00:04:44,330 --> 00:04:48,410
所以，很显然，你们有
了解变量和循环，

100
00:04:48,410 --> 00:04:49,380
和条件。

101
00:04:49,380 --> 00:04:52,030
它不像那些刚
走开，因为他们是

102
00:04:52,030 --> 00:04:55,210
显然固有的一切
否则，我们现在所学到的。

103
00:04:55,210 --> 00:04:58,560

104
00:04:58,560 --> 00:05:01,260
>> 有可能是一个问题
上的排序，或有

105
00:05:01,260 --> 00:05:03,710
可能是一个问题
在不同的搜索。

106
00:05:03,710 --> 00:05:07,000
或有可能是一对夫妇
上或许真的问题，你

107
00:05:07,000 --> 00:05:09,230
不得不与编译
或不同的错误。

108
00:05:09,230 --> 00:05:12,360
但是，如果你已经看了
测验一个从去年开始，

109
00:05:12,360 --> 00:05:15,870
你会发现，这是
非常专注的事情

110
00:05:15,870 --> 00:05:18,710
已经发生了自上次测验了。

111
00:05:18,710 --> 00:05:20,270
>> 为什么那个门总是上锁？

112
00:05:20,270 --> 00:05:21,555
这真的令我烦恼。

113
00:05:21,555 --> 00:05:25,310
因为我总是试图去通过它。

114
00:05:25,310 --> 00:05:28,450
>> 所以这是非常
如何测验会。

115
00:05:28,450 --> 00:05:32,360
那么，有没有什么概念，
你们想去了？

116
00:05:32,360 --> 00:05:35,210
或者我们可以直接进入
只看一个测验

117
00:05:35,210 --> 00:05:39,570
从去年种去
通过实践的问题在那里。

118
00:05:39,570 --> 00:05:41,220
我们还可以来回切换。

119
00:05:41,220 --> 00:05:43,130
这不是事情一次性的排序。

120
00:05:43,130 --> 00:05:46,367

121
00:05:46,367 --> 00:05:46,950
有问题吗？

122
00:05:46,950 --> 00:05:49,688

123
00:05:49,688 --> 00:05:50,188
是。

124
00:05:50,188 --> 00:05:51,950
>> 听众：请问一个
关于another--问题

125
00:05:51,950 --> 00:05:52,950
>> SPEAKER 1：另外一个？

126
00:05:52,950 --> 00:05:54,500
>> 听众：这是又一年。

127
00:05:54,500 --> 00:05:54,756
>> 扬声器1：是啊。

128
00:05:54,756 --> 00:05:56,068
我们还可以做一年。

129
00:05:56,068 --> 00:05:57,820
>> 听众：OK。

130
00:05:57,820 --> 00:05:58,710
因此，2011年。

131
00:05:58,710 --> 00:06:00,135
>> SPEAKER 1：2011。

132
00:06:00,135 --> 00:06:02,880
哦，这是今年我面前。

133
00:06:02,880 --> 00:06:04,032
让我拉这件事。

134
00:06:04,032 --> 00:06:04,934
>> 观众：我觉得。

135
00:06:04,934 --> 00:06:07,920

136
00:06:07,920 --> 00:06:12,842
>> SPEAKER 1：此方面
比扔我。

137
00:06:12,842 --> 00:06:14,435
>> 听众：11和12。

138
00:06:14,435 --> 00:06:16,637
>> 扬声器1：11和12。

139
00:06:16,637 --> 00:06:17,415
好不好。

140
00:06:17,415 --> 00:06:18,790
那么，在这里，我们为什么不这样做呢？

141
00:06:18,790 --> 00:06:22,390
你guys--大家只取一对夫妇
分钟翻阅测验。

142
00:06:22,390 --> 00:06:23,759
我们会造册。

143
00:06:23,759 --> 00:06:25,050
然后我们会去通过他们。

144
00:06:25,050 --> 00:06:25,990
行？

145
00:06:25,990 --> 00:06:28,530
虽然我得到了一堆
这个东西建立起来。

146
00:06:28,530 --> 00:06:29,440
好不好。

147
00:06:29,440 --> 00:06:31,850
我只是会写
东西写在纸上。

148
00:06:31,850 --> 00:06:47,460

149
00:06:47,460 --> 00:07:36,009
>> 2011年，11和12？

150
00:07:36,009 --> 00:07:38,880
我只是要改变此显示。

151
00:07:38,880 --> 00:07:39,380
好不好。

152
00:07:39,380 --> 00:07:40,320
这是更好的。

153
00:07:40,320 --> 00:07:45,490

154
00:07:45,490 --> 00:07:47,700
这种过度。

155
00:07:47,700 --> 00:08:04,632

156
00:08:04,632 --> 00:08:06,130
行。

157
00:08:06,130 --> 00:08:08,590
>> 任何人有任何的
他们想入手？

158
00:08:08,590 --> 00:08:11,270

159
00:08:11,270 --> 00:08:20,360
此外，忘了说了，如果你想要更多
的一群人谈论你

160
00:08:20,360 --> 00:08:23,182
，只是给你一个裂缝
当然，在过去的六个星期，

161
00:08:23,182 --> 00:08:24,890
我们运行的是检讨
会议从上午7:00

162
00:08:24,890 --> 00:08:29,580
到今晚8时30分在西北
B103，这也正好

163
00:08:29,580 --> 00:08:34,219
最后一次，在那里它会
是我，汉娜，Daven，用加布

164
00:08:34,219 --> 00:08:38,799
种和Rob从帮助
只是那种扔场边所有

165
00:08:38,799 --> 00:08:41,630
信息，你可能
希望对你的备忘单，

166
00:08:41,630 --> 00:08:43,101
斜线，知道一般有。

167
00:08:43,101 --> 00:08:44,600
听众：这也是在网上，对吧？

168
00:08:44,600 --> 00:08:45,766
扬声器1：这也是在网上。

169
00:08:45,766 --> 00:08:48,500
所以你也可以留这一点
恶心的天气，去你宿舍，

170
00:08:48,500 --> 00:08:50,620
和实时数据流，如果你愿意的话。

171
00:08:50,620 --> 00:08:52,420
我敢肯定，很多的
people--我知道我会

172
00:08:52,420 --> 00:08:55,541
可以这样做，如果我是你的鞋子。

173
00:08:55,541 --> 00:08:56,040
好不好。

174
00:08:56,040 --> 00:08:59,152
那么，为什么我们不开始with--
而你guys--希望，

175
00:08:59,152 --> 00:09:00,110
你翻翻。

176
00:09:00,110 --> 00:09:03,068
如果不是这样，我可能刚开始工作
通过测验一个不同的事情

177
00:09:03,068 --> 00:09:05,490
从去年开始，除非你
有具体的问题。

178
00:09:05,490 --> 00:09:09,740
>> 我们将开始与这
问题在这里对堆栈。

179
00:09:09,740 --> 00:09:17,940
所以，每个人都记得
什么样的一个堆栈？

180
00:09:17,940 --> 00:09:21,760
我们如何往往to--任何人都可以随便给
箱堆叠的一般描述？

181
00:09:21,760 --> 00:09:23,300
A型的数据结构。

182
00:09:23,300 --> 00:09:23,900
好不好。

183
00:09:23,900 --> 00:09:25,650
所以，它是一个
数据结构，我们

184
00:09:25,650 --> 00:09:30,620
希望你能熟悉with--像
栈，数组，队列，等等。

185
00:09:30,620 --> 00:09:31,120
是。

186
00:09:31,120 --> 00:09:33,005
>> 观众：像第一
在先进后出的东西。

187
00:09:33,005 --> 00:09:34,810
>> SPEAKER 1：它是先入后出。

188
00:09:34,810 --> 00:09:35,310
没错。

189
00:09:35,310 --> 00:09:37,830
所以堆栈是完全
我们倾向于认为

190
00:09:37,830 --> 00:09:39,720
什么时候我们认为
一叠东西。

191
00:09:39,720 --> 00:09:41,024
这样的堆叠板。

192
00:09:41,024 --> 00:09:43,440
你放下第一板
将是在底部，

193
00:09:43,440 --> 00:09:45,981
而这将是最后一次
一个，你去掉底。

194
00:09:45,981 --> 00:09:47,180
因为它们叠加起来。

195
00:09:47,180 --> 00:09:50,390
>> 你把一走出底部，
通常情况下，东西崩溃，并打破。

196
00:09:50,390 --> 00:09:53,150
所以栈你能想到的
就像一叠板。

197
00:09:53,150 --> 00:09:57,707
或例子中，我们总是喜欢用
是在D厅，你有托盘，

198
00:09:57,707 --> 00:09:59,790
他们都堆积起来，
你需要从顶部。

199
00:09:59,790 --> 00:10:02,880
所以中的最后一个是第一个出。

200
00:10:02,880 --> 00:10:03,580
好不好。

201
00:10:03,580 --> 00:10:08,850
>> 所以在这里的情况，我们
看看我们have--我不知道

202
00:10:08,850 --> 00:10:14,050
如果我能真正放大一点点。

203
00:10:14,050 --> 00:10:15,730
因此，我们有这个结构在​​这里。

204
00:10:15,730 --> 00:10:16,520
对不对？

205
00:10:16,520 --> 00:10:20,160
所以，你有一些结构有
一些诠释能力的数字。

206
00:10:20,160 --> 00:10:22,960
那我们认为它代表？

207
00:10:22,960 --> 00:10:26,190
这是与尺寸的容纳阵列。

208
00:10:26,190 --> 00:10:31,750
>> 所以这真的代表
我们一般堆栈。

209
00:10:31,750 --> 00:10:35,980
我们的堆栈是真的只是一个
阵列与一些集数

210
00:10:35,980 --> 00:10:39,040
这是它的最大值，也就是说，它的容量。

211
00:10:39,040 --> 00:10:43,050
然后我们有一些整数大小，这
会跟踪我们的堆栈的大小

212
00:10:43,050 --> 00:10:44,990
在整个过程中
当我们使用它。

213
00:10:44,990 --> 00:10:45,490
好不好？

214
00:10:45,490 --> 00:10:50,620

215
00:10:50,620 --> 00:10:55,850
>> 在这种情况下，就在这里，我们说，我们的
堆栈大小已被初始化为0。

216
00:10:55,850 --> 00:10:58,190
因此，我们有一个空栈现在。

217
00:10:58,190 --> 00:11:01,760
然后我们要完成
流行的执行

218
00:11:01,760 --> 00:11:05,520
使得它返回整型在顶部。

219
00:11:05,520 --> 00:11:08,150
然后，如果它是空的，
它返回负1。

220
00:11:08,150 --> 00:11:09,320
好不好？

221
00:11:09,320 --> 00:11:12,646
所以我想你们只是想
什么，我们会在那里做。

222
00:11:12,646 --> 00:11:15,020
什么可能是第一个
事情我们会想检查？

223
00:11:15,020 --> 00:11:17,986

224
00:11:17,986 --> 00:11:19,110
这里有一个伟大的事情。

225
00:11:19,110 --> 00:11:24,700
每当says--如果有过一些
if语句，如“如果堆栈是空的，”

226
00:11:24,700 --> 00:11:29,330
或者“如果这个返回null”，或者
“如果这是什么” - 对不起。

227
00:11:29,330 --> 00:11:30,710
>> 听众：写一个If语句。

228
00:11:30,710 --> 00:11:31,000
>> 扬声器1：没错。

229
00:11:31,000 --> 00:11:31,500
你可以写一个If语句。

230
00:11:31,500 --> 00:11:34,100
而这可能是一个
你想第一件事情检查。

231
00:11:34,100 --> 00:11:34,599
好不好。

232
00:11:34,599 --> 00:11:36,940
当他们给你
有点像一个角落的情况下

233
00:11:36,940 --> 00:11:39,150
就是这样，这就是典型的
的第一件事情之一

234
00:11:39,150 --> 00:11:41,200
你要检查你的代码。

235
00:11:41,200 --> 00:11:44,220
>> 此外，东西
认识到测验

236
00:11:44,220 --> 00:11:48,870
是，如果你有一个低效的方式
做一些事情，把它写下来。

237
00:11:48,870 --> 00:11:52,220
因为我们没有分级
你设计，我们

238
00:11:52,220 --> 00:11:54,840
分级您的正确性测验。

239
00:11:54,840 --> 00:11:59,970
所以，即使你知道，这是一个超级
糟糕的方式做一些事情，但它的工作原理，

240
00:11:59,970 --> 00:12:03,290
把它写下来，好不好？

241
00:12:03,290 --> 00:12:06,520
>> 从字面上看，我已经看到了孩子们最后year--
如果你看看去年的之一，

242
00:12:06,520 --> 00:12:08,180
他们喜欢，做马里奥金字塔。

243
00:12:08,180 --> 00:12:12,482
他们从字面上只是做了“打印，
哈希，打印，哈希，哈希，打印，哈希，

244
00:12:12,482 --> 00:12:13,242
哈希散列。“

245
00:12:13,242 --> 00:12:14,040
但它是正确的。

246
00:12:14,040 --> 00:12:18,490
它是我们告诉它，
所以你不能拿分了。

247
00:12:18,490 --> 00:12:20,487
如果你到了
电线，很明显，你

248
00:12:20,487 --> 00:12:23,820
想要得到一个更好的解决方案，并
更优雅的解决方案可能会

249
00:12:23,820 --> 00:12:27,292
更少的代码，这意味着你可能
有被正确的机会较高。

250
00:12:27,292 --> 00:12:29,750
但是，如果你喜欢，你就知道
什么，不，我没有时间，我

251
00:12:29,750 --> 00:12:32,640
知道这是一个解决方案，
这是不是最好的，写吧。

252
00:12:32,640 --> 00:12:36,130
你甚至可以写上
身边，我知道这是可怕的，

253
00:12:36,130 --> 00:12:38,135
但我知道它的工作原理。

254
00:12:38,135 --> 00:12:39,320
因此，只要抬头。

255
00:12:39,320 --> 00:12:39,820
好不好。

256
00:12:39,820 --> 00:12:42,690
>> 所以，很显然，第一件事
是这样的if语句。

257
00:12:42,690 --> 00:12:45,320
那我们认为这如果
声明将是？

258
00:12:45,320 --> 00:12:50,860
而实际上，让我开
我的伟大崇高的编辑。

259
00:12:50,860 --> 00:12:55,480
我要这个代码，然后
展示你们的时候，它的完成。

260
00:12:55,480 --> 00:12:57,370
所以，诠释流行。

261
00:12:57,370 --> 00:13:02,260

262
00:13:02,260 --> 00:13:03,240
好不好。

263
00:13:03,240 --> 00:13:07,330
因此，如果我们有这样的整数
流行void--如此明显，

264
00:13:07,330 --> 00:13:13,270
这是一些函数，它在
什么，返回一个整数，对不对？

265
00:13:13,270 --> 00:13:18,930
所以它只是要说说
该堆栈，我们已经创建。

266
00:13:18,930 --> 00:13:23,360
>> 所以只是翻译最后
一句话，“如果堆栈是空的，

267
00:13:23,360 --> 00:13:28,380
流行音乐应该返回负
1，“怎么可能，我们做到这一点？

268
00:13:28,380 --> 00:13:30,250
所以，如果有什么？

269
00:13:30,250 --> 00:13:35,080
我们怎么知道堆栈是空的？

270
00:13:35,080 --> 00:13:36,800
这只是大小等于0。

271
00:13:36,800 --> 00:13:40,300
Stack.size等于0。

272
00:13:40,300 --> 00:13:42,840
另外，我也有种盲目的写在这里。

273
00:13:42,840 --> 00:13:49,550
所以，如果我做任何typos--哦，
还忘了提到这一点。

274
00:13:49,550 --> 00:13:54,310
>> 上周，我完全想通了
正是我们的问题是使用JavaScript。

275
00:13:54,310 --> 00:13:57,270
不要利用我
和D.你应该只

276
00:13:57,270 --> 00:14:00,070
利用我和id来获取元素。

277
00:14:00,070 --> 00:14:02,170
而这是整个错误。

278
00:14:02,170 --> 00:14:05,700
所以，如果你们回去
实际上去翻我的代码，

279
00:14:05,700 --> 00:14:09,590
如果你只是让一切一
小写字母D，“凭身份证忘元素”

280
00:14:09,590 --> 00:14:10,410
它会奏效。

281
00:14:10,410 --> 00:14:12,823
所以，我答应了，我非常接近。

282
00:14:12,823 --> 00:14:15,570
我只是资本的东西
我是不应该，这

283
00:14:15,570 --> 00:14:19,231
我敢肯定，你们必须在你的最后PSET。

284
00:14:19,231 --> 00:14:22,750
>> 所以，如果我们的大小等于0，
那么，我们应该怎么办？

285
00:14:22,750 --> 00:14:25,100
>> 听众：返回负1。

286
00:14:25,100 --> 00:14:28,644
>> SPEAKER 1：返回负1。

287
00:14:28,644 --> 00:14:29,450
酷。

288
00:14:29,450 --> 00:14:33,050
所以，现在我们该怎么办？

289
00:14:33,050 --> 00:14:39,420

290
00:14:39,420 --> 00:14:41,730
我们要弹出的东西了。

291
00:14:41,730 --> 00:14:45,090
现在，这种情况
我们有一些东西。

292
00:14:45,090 --> 00:14:48,686
我们的大小大于1
或大于0，对不对？

293
00:14:48,686 --> 00:14:50,060
实际上，我们有东西在那里。

294
00:14:50,060 --> 00:14:54,390
所以，我们想要做的是，我们
想在这里回归。

295
00:14:54,390 --> 00:14:58,860
我们会说我们要
返回堆栈的顶部。

296
00:14:58,860 --> 00:15:00,940
好不好？

297
00:15:00,940 --> 00:15:03,840
>> 那么我们怎样才能做到这一点？

298
00:15:03,840 --> 00:15:06,410
我们如何返回堆栈顶部？

299
00:15:06,410 --> 00:15:09,700
请记住，我们的堆栈
只是一个数组，对不对？

300
00:15:09,700 --> 00:15:12,690
它具有一定的能力
我们已经给了它。

301
00:15:12,690 --> 00:15:17,840
正如我们已经把事情on--或实际，
我们要在此之后写上“推”。

302
00:15:17,840 --> 00:15:21,563
如果东西都在那里 - 
也许画面会有所帮助。

303
00:15:21,563 --> 00:15:30,845

304
00:15:30,845 --> 00:15:32,120
嗯，我喜欢大粉笔更好。

305
00:15:32,120 --> 00:15:35,920

306
00:15:35,920 --> 00:15:41,000
>> 所以if--，你可以只
认为这是我们的堆栈。

307
00:15:41,000 --> 00:15:48,510
因此，这是0，1，2。

308
00:15:48,510 --> 00:15:51,175
我不知道为什么我的箱子
越来越小。

309
00:15:51,175 --> 00:15:52,540
但也有。

310
00:15:52,540 --> 00:15:53,180
好不好。

311
00:15:53,180 --> 00:15:59,960
>> 因此，这是一些堆栈
容量为5。

312
00:15:59,960 --> 00:16:04,470
让我们说我们有什么
在这里，我们有一些东西在这里。

313
00:16:04,470 --> 00:16:10,840
所以在这一点上，我们的
大小等于什么？

314
00:16:10,840 --> 00:16:12,720
2。

315
00:16:12,720 --> 00:16:15,370
如果我们想弹出
事关它，

316
00:16:15,370 --> 00:16:18,720
这意味着我们想要得到
摆脱这一权利在这里。

317
00:16:18,720 --> 00:16:21,300
好不好？

318
00:16:21,300 --> 00:16:25,633
因此，如何将我们回到这个价值？

319
00:16:25,633 --> 00:16:27,397
>> 听众：大小减去1。

320
00:16:27,397 --> 00:16:28,230
>> 扬声器1：没错。

321
00:16:28,230 --> 00:16:35,010
因此，大小减去1，或者你
可以做大小减去减。

322
00:16:35,010 --> 00:16:36,740
但是，我们不能只是做大小。

323
00:16:36,740 --> 00:16:38,560
这是一个结构里面，对吧？

324
00:16:38,560 --> 00:16:42,690
所以stack.struct。

325
00:16:42,690 --> 00:16:44,510
或stack.size。

326
00:16:44,510 --> 00:16:47,100
这是我们的指数在那里。

327
00:16:47,100 --> 00:16:48,070
好不好？

328
00:16:48,070 --> 00:16:56,240
>> 然后如果我们看一下
回到这里，在我们的结构，

329
00:16:56,240 --> 00:16:59,770
我们注意到，以
实际上访问阵列，

330
00:16:59,770 --> 00:17:04,920
我们需要做的stack.numbers
实际访问该数组。

331
00:17:04,920 --> 00:17:09,859

332
00:17:09,859 --> 00:17:13,700
使返回堆栈的顶部。

333
00:17:13,700 --> 00:17:18,950
>> 但一些that--如果你们看看
在接听键，这是他们所

334
00:17:18,950 --> 00:17:21,470
给你。

335
00:17:21,470 --> 00:17:22,640
所以这是它。

336
00:17:22,640 --> 00:17:27,450
不过，我可能会说，他们是
miss--哦，不是我想要的。

337
00:17:27,450 --> 00:17:30,864
我可能会争辩说，他们是
失去了一些东西，因为 - 是的。

338
00:17:30,864 --> 00:17:32,030
听众：减小尺寸。

339
00:17:32,030 --> 00:17:32,738
扬声器1：没错。

340
00:17:32,738 --> 00:17:34,634
我们现在需要减少我们的规模。

341
00:17:34,634 --> 00:17:36,550
那么，有什么猫腻约
这是一次返回

342
00:17:36,550 --> 00:17:38,780
什么，你的函数的
要退出，对不对？

343
00:17:38,780 --> 00:17:44,050
因此，我们可以做什么是真正
首先降低我们的规模。

344
00:17:44,050 --> 00:17:47,110
然后我们就可以根本stack.size。

345
00:17:47,110 --> 00:17:52,110
>> 我们可以只使用stack.size
因为我们的索引，不能我们？

346
00:17:52,110 --> 00:17:55,650
因为如果stack.size
2，我们减小了。

347
00:17:55,650 --> 00:17:58,520
所以它是1，这
是我们的实际指数之。

348
00:17:58,520 --> 00:18:03,320
一旦我们摆脱这一点，我们实际上
只有在我们的数组的一件事。

349
00:18:03,320 --> 00:18:04,204
所以它确实两者兼而有之。

350
00:18:04,204 --> 00:18:05,120
观众：[听不清]？

351
00:18:05,120 --> 00:18:09,186

352
00:18:09,186 --> 00:18:14,750
>> 扬声器1：那么，在这种情况下，
我们刚刚返回的元素

353
00:18:14,750 --> 00:18:19,500
在该位于顶部我们
大小是在顶部。

354
00:18:19,500 --> 00:18:25,530
但是，我们没有做任何事情来的
规模后，我们删除的元素。

355
00:18:25,530 --> 00:18:29,970
这并没有改变我们的规模还没有。

356
00:18:29,970 --> 00:18:32,410
这实际上不
本质上改变我们的规模。

357
00:18:32,410 --> 00:18:39,840
>> 但要使它成为一个更清晰一点，
你可以做stack.size减减。

358
00:18:39,840 --> 00:18:46,960
对于我来说，这使得它，我不知道，
一个小that--啊更清晰，

359
00:18:46,960 --> 00:18:51,080
那你实际上改变
的大小和返回它。

360
00:18:51,080 --> 00:18:54,050
另一种方法是很好的，因为
你改变并返回

361
00:18:54,050 --> 00:18:55,700
同时。

362
00:18:55,700 --> 00:19:00,792
但是，这只是另一种方式来写
这是我想向你展示的家伙。

363
00:19:00,792 --> 00:19:02,190
这是否有意义？

364
00:19:02,190 --> 00:19:04,940

365
00:19:04,940 --> 00:19:06,847
栈，我想，是
比队列容易得多。

366
00:19:06,847 --> 00:19:08,188
（笑）

367
00:19:08,188 --> 00:19:09,481

368
00:19:09,481 --> 00:19:09,980
好不好。

369
00:19:09,980 --> 00:19:12,000
你有什么具体问题
约11和12，或just--

370
00:19:12,000 --> 00:19:13,736
>> 观众：我认为这是堆栈。

371
00:19:13,736 --> 00:19:14,910
>> SPEAKER 1：堆栈大小？

372
00:19:14,910 --> 00:19:15,430
>> 听众：是的。

373
00:19:15,430 --> 00:19:15,980
>> SPEAKER 1：疑难杂症。

374
00:19:15,980 --> 00:19:16,490
好不好。

375
00:19:16,490 --> 00:19:19,630
是的，你可以做到这一点的
1这两种方式。

376
00:19:19,630 --> 00:19:20,320
好不好。

377
00:19:20,320 --> 00:19:22,790
>> 所以，现在我们有另外一个。

378
00:19:22,790 --> 00:19:30,250

379
00:19:30,250 --> 00:19:34,220
这是很奇怪的，像
不是我的屏幕上有这个。

380
00:19:34,220 --> 00:19:46,480

381
00:19:46,480 --> 00:19:51,030
因此，如果我们看这里，我们现在要
完成推的实施，

382
00:19:51,030 --> 00:19:57,030
这其实是把一些东西，去
并插入一些到我们的队列中，

383
00:19:57,030 --> 00:19:59,390
或者到我们的堆栈。

384
00:19:59,390 --> 00:20:00,140
好不好？

385
00:20:00,140 --> 00:20:03,560
>> 因此，如果我们注意到，我们
有几件事情。

386
00:20:03,560 --> 00:20:07,730
我们有我们的great--如果一切，
只要我们有其中之一，

387
00:20:07,730 --> 00:20:10,610
你们至少应该拿到一半
一个点，因为所有你需要做的

388
00:20:10,610 --> 00:20:15,760
被转换到这一点并且C.
他们给你一半。

389
00:20:15,760 --> 00:20:18,560
因此，“如果一个堆栈已满
或者是负的，

390
00:20:18,560 --> 00:20:20,940
然后按应返回false。“

391
00:20:20,940 --> 00:20:21,890
好不好？

392
00:20:21,890 --> 00:20:27,900
>> 所以我们只希望积极
整数是我们的堆栈。

393
00:20:27,900 --> 00:20:28,430
行？

394
00:20:28,430 --> 00:20:31,135
而这将任
返回true或false。

395
00:20:31,135 --> 00:20:36,410

396
00:20:36,410 --> 00:20:37,765
因此，我们应当[听不清]布尔。

397
00:20:37,765 --> 00:20:43,000

398
00:20:43,000 --> 00:20:43,660
好不好。

399
00:20:43,660 --> 00:20:45,725
所以翻译。

400
00:20:45,725 --> 00:20:47,146
>> 观众：[听不清]。

401
00:20:47,146 --> 00:20:48,318
>> 扬声器1：哦，谢谢。

402
00:20:48,318 --> 00:20:49,572
是啊。

403
00:20:49,572 --> 00:20:52,834
这就是为什么我有你们。

404
00:20:52,834 --> 00:20:53,810
诠释ñ。

405
00:20:53,810 --> 00:20:54,310
完美。

406
00:20:54,310 --> 00:20:56,590
因为我们正在把
东西到我们的堆栈。

407
00:20:56,590 --> 00:20:58,750
实际上，我们需要一些数字。

408
00:20:58,750 --> 00:20:59,250
好不好。

409
00:20:59,250 --> 00:21:05,669
>> 因此，只要采取这一最后行
他们给了我们，我们种的角落的情况下，

410
00:21:05,669 --> 00:21:06,960
你觉得我们在这里？

411
00:21:06,960 --> 00:21:08,730
很显然，我们将有一些如果。

412
00:21:08,730 --> 00:21:09,520
好不好。

413
00:21:09,520 --> 00:21:14,380
所以我们说，如果我们的堆栈
满，或者如果n是负的。

414
00:21:14,380 --> 00:21:18,850
所以大概最简单的开始
同，所以，如果n小于0

415
00:21:18,850 --> 00:21:23,960
or--记得你好看
AND和OR运算符那里。

416
00:21:23,960 --> 00:21:27,340
>> 如何将我们检查
看看我们的堆栈满了吗？

417
00:21:27,340 --> 00:21:28,368
会发生什么？

418
00:21:28,368 --> 00:21:30,080
>> 听众：大小相等的容量。

419
00:21:30,080 --> 00:21:30,871
>> 扬声器1：没错。

420
00:21:30,871 --> 00:21:35,430

421
00:21:35,430 --> 00:21:36,817
完美。

422
00:21:36,817 --> 00:21:37,316
好不好。

423
00:21:37,316 --> 00:21:40,672
什么做我们想做的事情呢？

424
00:21:40,672 --> 00:21:41,740
>> 观众：返回false。

425
00:21:41,740 --> 00:21:43,990
>> SPEAKER 1：返回false。

426
00:21:43,990 --> 00:21:44,960
完美。

427
00:21:44,960 --> 00:21:47,000
所以中途出现，对不对？

428
00:21:47,000 --> 00:21:50,370
最起码，你们
将有一半的。

429
00:21:50,370 --> 00:21:53,280
因此，让我们想一想。

430
00:21:53,280 --> 00:21:57,100

431
00:21:57,100 --> 00:21:59,030
>> 所以这是我们先从堆栈。

432
00:21:59,030 --> 00:22:02,340
我们正在努力把
在这里的一些元素。

433
00:22:02,340 --> 00:22:05,580
>> 我们有一个大小，
等于2现在。

434
00:22:05,580 --> 00:22:09,060
我们有一个容量等于5。

435
00:22:09,060 --> 00:22:13,470
让我们说我们有
一些n表示是等于3。

436
00:22:13,470 --> 00:22:18,170
因此，我们需要输入3到这个空间。

437
00:22:18,170 --> 00:22:22,320
我们需要输入成指数2。

438
00:22:22,320 --> 00:22:22,820
对不对？

439
00:22:22,820 --> 00:22:31,730

440
00:22:31,730 --> 00:22:35,130
>> 那么我们怎样才能做到这一点？

441
00:22:35,130 --> 00:22:46,580
试图assign--我们
要访问我们的数组。

442
00:22:46,580 --> 00:22:49,300
所以stack.numbers。

443
00:22:49,300 --> 00:22:52,932
但在什么指数之会
我们希望这是？

444
00:22:52,932 --> 00:22:54,408
>> 观众：[听不清]。

445
00:22:54,408 --> 00:22:56,806
>> 扬声器1：是啊。

446
00:22:56,806 --> 00:22:57,305
Stack.size。

447
00:22:57,305 --> 00:23:02,720

448
00:23:02,720 --> 00:23:04,830
我们希望这等于N，对不对？

449
00:23:04,830 --> 00:23:05,752
>> 观众：[听不清]。

450
00:23:05,752 --> 00:23:07,710
SPEAKER 1：我其实
只看这一点。

451
00:23:07,710 --> 00:23:09,865
我认为这是错误的。

452
00:23:09,865 --> 00:23:14,564
>> 听众：你不想要的
过去的电流大小的空间？

453
00:23:14,564 --> 00:23:18,842
>> 扬声器1：好吧，如果我们看这里，
我们的规模在这一点上是2。

454
00:23:18,842 --> 00:23:25,600
我们希望它进入指数2，
因为这是我们的堆栈的顶部。

455
00:23:25,600 --> 00:23:29,480
所以，我要说，这
应该stack.size，

456
00:23:29,480 --> 00:23:32,380
然后，你会增加stack.size。

457
00:23:32,380 --> 00:23:33,820
每个人都同意吗？

458
00:23:33,820 --> 00:23:35,780
我想，我同意这一点。

459
00:23:35,780 --> 00:23:38,180
你们可以说
和我一起，如果你愿意的话。

460
00:23:38,180 --> 00:23:40,078
或者不争论，但我们可以讨论这个问题。

461
00:23:40,078 --> 00:23:42,518
>> 观众：[听不清]。

462
00:23:42,518 --> 00:23:47,650
>> SPEAKER 1：嗯，就是它的
因为零索引打开。

463
00:23:47,650 --> 00:23:50,027
如此，而在第一部分中，
我以为他们是错的，

464
00:23:50,027 --> 00:23:53,910
他们实际上是正确的，这
一部分，我倒认为他们错了。

465
00:23:53,910 --> 00:23:55,990
我会说，你应该
绝对输入在这里。

466
00:23:55,990 --> 00:23:58,540
我想我们都同意
我们有2的尺寸。

467
00:23:58,540 --> 00:24:01,480
这正是我们在哪里
希望我们的新号码去。

468
00:24:01,480 --> 00:24:05,120
所以stack.numbers在
stack.size应等于ñ。

469
00:24:05,120 --> 00:24:09,510
然后我们会
递增stack.size。

470
00:24:09,510 --> 00:24:11,099
++。

471
00:24:11,099 --> 00:24:12,390
然后我们怎么想干什么？

472
00:24:12,390 --> 00:24:17,400
还有，我们必须最后一件事
做，如果我们成功地插入呢？

473
00:24:17,400 --> 00:24:19,190
返回true。

474
00:24:19,190 --> 00:24:20,071
现在你就大功告成了。

475
00:24:20,071 --> 00:24:23,440

476
00:24:23,440 --> 00:24:27,765
所以，我觉得这是整个负
零下stack.size和stack.size ++的

477
00:24:27,765 --> 00:24:29,440
乱七八糟的事情了。

478
00:24:29,440 --> 00:24:29,940
唉。

479
00:24:29,940 --> 00:24:34,400
我keep--我有这个本能
倾向，总是打

480
00:24:34,400 --> 00:24:38,060
控制，S，因为我从来没有
不想失去我的任何工作。

481
00:24:38,060 --> 00:24:39,670
不过，我并不需要现在这样做。

482
00:24:39,670 --> 00:24:40,170
好不好。

483
00:24:40,170 --> 00:24:41,650
所以这是堆栈。

484
00:24:41,650 --> 00:24:44,460

485
00:24:44,460 --> 00:24:46,300
酷。

486
00:24:46,300 --> 00:24:48,970
>> 还有什么？

487
00:24:48,970 --> 00:24:51,220
难道你们找到任何
其他的问题，你会

488
00:24:51,220 --> 00:24:52,810
想从以前的测验去了？

489
00:24:52,810 --> 00:24:57,660
如果没有，我们可以种开始说话
通过测验一个来自去年。

490
00:24:57,660 --> 00:24:58,160
是。

491
00:24:58,160 --> 00:25:00,035
>> 听众：对于第
一部分，我真的不

492
00:25:00,035 --> 00:25:02,438
了解您如何删除的号码。

493
00:25:02,438 --> 00:25:03,600
是不是还在吗？

494
00:25:03,600 --> 00:25:05,100
>> SPEAKER 1：该号码仍然存在。

495
00:25:05,100 --> 00:25:11,350
但是，什么情况是，因为你
告诉它，你的堆栈的顶部

496
00:25:11,350 --> 00:25:16,180
在这里，当你去购买的东西
压入堆栈，它会刚刚取代它。

497
00:25:16,180 --> 00:25:17,084
>> 听众：哦，OK。

498
00:25:17,084 --> 00:25:17,750
扬声器1：是啊。

499
00:25:17,750 --> 00:25:21,334
所以，这就像他忘记它的存在
类型的东西，即使它的存在。

500
00:25:21,334 --> 00:25:22,750
观众：[听不清]或什么吗？

501
00:25:22,750 --> 00:25:23,333
SPEAKER 1：第

502
00:25:23,333 --> 00:25:25,090
因为我们是在一个
数组，你没有

503
00:25:25,090 --> 00:25:28,850
担心about--你只
覆盖它，当你需要它。

504
00:25:28,850 --> 00:25:30,560
行。

505
00:25:30,560 --> 00:25:31,560
还有没有其他问题？

506
00:25:31,560 --> 00:25:34,843
如果没有，我们只是去
开始工作通过。

507
00:25:34,843 --> 00:25:35,343
是啊。

508
00:25:35,343 --> 00:25:40,905
>> 听众：嗯，这个人是在2013年，
只是经历了SQL的东西。

509
00:25:40,905 --> 00:25:41,530
SPEAKER 1：SQL？

510
00:25:41,530 --> 00:25:42,030
好不好。

511
00:25:42,030 --> 00:25:45,290

512
00:25:45,290 --> 00:25:46,925
因此，这是26至29。

513
00:25:46,925 --> 00:25:47,550
听众：是的。

514
00:25:47,550 --> 00:25:48,120
扬声器1：OK。

515
00:25:48,120 --> 00:25:48,620
可爱。

516
00:25:48,620 --> 00:25:50,230
让我们这些拉起来。

517
00:25:50,230 --> 00:25:57,560

518
00:25:57,560 --> 00:25:59,506
哦，看看。

519
00:25:59,506 --> 00:26:02,180
难道你们喜欢史蒂夫·
鲍尔默谈，顺便说一下？

520
00:26:02,180 --> 00:26:06,350
这是相当热闹，在我看来。

521
00:26:06,350 --> 00:26:09,930
我爱我每次打开CS50的
部分网站的过程中，它就像，哦，

522
00:26:09,930 --> 00:26:10,730
观看部分。

523
00:26:10,730 --> 00:26:11,575
我很喜欢，毫米。

524
00:26:11,575 --> 00:26:13,100
>> 听众：我们能做到吗？

525
00:26:13,100 --> 00:26:15,060
>> SPEAKER 1：我们将在年底做。

526
00:26:15,060 --> 00:26:15,560
怎么样？

527
00:26:15,560 --> 00:26:17,476
因为我知道你们
一直想。

528
00:26:17,476 --> 00:26:18,573
因此，我们将在年底做。

529
00:26:18,573 --> 00:26:21,884

530
00:26:21,884 --> 00:26:22,800
一个问题。

531
00:26:22,800 --> 00:26:24,502
>> 观众：[听不清]。

532
00:26:24,502 --> 00:26:25,960
扬声器1：这将是一个荟萃部分。

533
00:26:25,960 --> 00:26:27,332
听众：这就像5秒。

534
00:26:27,332 --> 00:26:28,805
听众：真的吗？

535
00:26:28,805 --> 00:26:30,567
听众：这就像20秒。

536
00:26:30,567 --> 00:26:33,260
[插入VOICES]

537
00:26:33,260 --> 00:26:35,756
[笑]

538
00:26:35,756 --> 00:26:35,931

539
00:26:35,931 --> 00:26:37,680
SPEAKER 1：我喜欢这样
你已经做了

540
00:26:37,680 --> 00:26:40,130
这，这是什么使我快乐。

541
00:26:40,130 --> 00:26:42,340
好不好。

542
00:26:42,340 --> 00:26:42,840
26。

543
00:26:42,840 --> 00:26:43,340
好不好。

544
00:26:43,340 --> 00:26:46,050

545
00:26:46,050 --> 00:26:48,930
其实，我们只是要
现在反映这一点，因为我不能。

546
00:26:48,930 --> 00:26:49,640
这是恼人。

547
00:26:49,640 --> 00:26:56,200

548
00:26:56,200 --> 00:26:56,700
好不好。

549
00:26:56,700 --> 00:27:00,254
现在，我所看到的一切。

550
00:27:00,254 --> 00:27:01,230
可爱。

551
00:27:01,230 --> 00:27:02,500
好不好。

552
00:27:02,500 --> 00:27:07,300
>> 所以，很显然，这应该带回
从[美好的回忆？ CSG？]财政部。

553
00:27:07,300 --> 00:27:09,090
你约一半有你现在等级。

554
00:27:09,090 --> 00:27:13,370
另一半我会去
非常非常快的，我保证。

555
00:27:13,370 --> 00:27:17,110
>> 所以，我们有一些SQL表
这是帐户在这里。

556
00:27:17,110 --> 00:27:19,830
也许类似
您的家伙'用户表。

557
00:27:19,830 --> 00:27:22,350
我们有一些数量
这是一个主键

558
00:27:22,350 --> 00:27:24,750
并且表示
12位数的帐号。

559
00:27:24,750 --> 00:27:27,140
和平衡是他们有多少钱。

560
00:27:27,140 --> 00:27:30,530
并且缺省值是100。

561
00:27:30,530 --> 00:27:33,470
他们给他们百美元任何
一次，他们开户。

562
00:27:33,470 --> 00:27:36,132
我希望我的银行这样做。

563
00:27:36,132 --> 00:27:37,710
好不好。

564
00:27:37,710 --> 00:27:41,110
>> 因此，我们希望通过完成架构
指定旁边数量平衡

565
00:27:41,110 --> 00:27:43,900
相应的SQL类型。

566
00:27:43,900 --> 00:27:50,240
那么，什么你们觉得会
有点像你的下意识的反应

567
00:27:50,240 --> 00:27:51,380
对于类型为这两个？

568
00:27:51,380 --> 00:27:52,180
>> 听众：诠释。

569
00:27:52,180 --> 00:27:53,450
>> SPEAKER 1：int类型。

570
00:27:53,450 --> 00:27:54,230
好不好。

571
00:27:54,230 --> 00:27:57,490
然后换一个平衡点？

572
00:27:57,490 --> 00:27:57,990
小数。

573
00:27:57,990 --> 00:27:58,490
好不好。

574
00:27:58,490 --> 00:27:59,830
所以十进制的权利。

575
00:27:59,830 --> 00:28:01,450
INT接近。

576
00:28:01,450 --> 00:28:08,610
样的大事情是这样的
强调12位数的帐号。

577
00:28:08,610 --> 00:28:11,460
每当我们有东西
这比8位数大，

578
00:28:11,460 --> 00:28:15,522
他们希望你使用大
INT，我认为is--

579
00:28:15,522 --> 00:28:18,370

580
00:28:18,370 --> 00:28:21,605
>> 听众：是，仅仅SQL？

581
00:28:21,605 --> 00:28:27,290
>> 扬声器1：这是唯一一次我听说
它是SQL--就像使用一个大的整数。

582
00:28:27,290 --> 00:28:29,330
这只是给你一个
小更精确，

583
00:28:29,330 --> 00:28:33,070
确保你不
爆棚式的东西。

584
00:28:33,070 --> 00:28:35,910
说实话，我觉得这
绝对是那些1

585
00:28:35,910 --> 00:28:38,480
它的样子，呵呵，
它的意思的人

586
00:28:38,480 --> 00:28:41,090
谁拥有SQL多一点知识。

587
00:28:41,090 --> 00:28:44,710
我们从来没有说过
大整数你PSET。

588
00:28:44,710 --> 00:28:48,210
因此，这有点像我敢肯定
如果你把INT，这是一半的功劳。

589
00:28:48,210 --> 00:28:51,450
>> 正如我之前说的，也有去
出现一些问题，这只是

590
00:28:51,450 --> 00:28:55,550
意味着你绊倒，所以
不是每个人都得到100。

591
00:28:55,550 --> 00:28:58,326
因为，当然，还有
一些人CS50

592
00:28:58,326 --> 00:29:00,950
谁一直在做这个像
八年来，和你一样，

593
00:29:00,950 --> 00:29:01,741
你在干什么？

594
00:29:01,741 --> 00:29:03,290
但是，是的。

595
00:29:03,290 --> 00:29:05,650
>> 十进制平衡是明显的。

596
00:29:05,650 --> 00:29:10,910
再大的整型数仅仅是因为
的，像，强调12位。

597
00:29:10,910 --> 00:29:16,760
一旦有事情是大胆的，或者它
强调一样，关注它。

598
00:29:16,760 --> 00:29:18,940
我们不这样做，只是因为。

599
00:29:18,940 --> 00:29:20,290
好不好。

600
00:29:20,290 --> 00:29:24,400
>> 因此，“假设银行规定
20美元的月租费上的所有账户。

601
00:29:24,400 --> 00:29:27,850
用什么可以查询银行
从每一个账户中扣除20美元

602
00:29:27,850 --> 00:29:31,490
即使从结果
一些消极的平衡？“

603
00:29:31,490 --> 00:29:35,220
因此，让我们从简单的开始。

604
00:29:35,220 --> 00:29:39,240
我们有四个主要命令
对于SQL，这是什么？

605
00:29:39,240 --> 00:29:42,620
难道你们还记得四
大的，我告诉你？

606
00:29:42,620 --> 00:29:45,710
>> UPDATE，DELETE，SELECT和INSERT。

607
00:29:45,710 --> 00:29:46,430
完美。

608
00:29:46,430 --> 00:29:46,930
得到它了。

609
00:29:46,930 --> 00:29:52,910
还等什么，我们认为可能
对于这个最有用？

610
00:29:52,910 --> 00:29:54,231
我们are-- UPDATE。

611
00:29:54,231 --> 00:29:54,730
没错。

612
00:29:54,730 --> 00:29:59,330
所以UPDATE，因为我们正在寻找
在已经存在的账户。

613
00:29:59,330 --> 00:30:03,570
>> 所以请记住我们的一般
诸如此类的事情就是更新。

614
00:30:03,570 --> 00:30:06,300
然后会发生什么更新呢？

615
00:30:06,300 --> 00:30:09,780
我们有一些表
我们正在参考。

616
00:30:09,780 --> 00:30:17,130
所以，如果我拉了崇高again-- UPDATE。

617
00:30:17,130 --> 00:30:18,820
因此，这是一个普遍的格式。

618
00:30:18,820 --> 00:30:20,800
因此，我们必须更新表。

619
00:30:20,800 --> 00:30:23,203
然后什么是未来的事情，我们有吗？

620
00:30:23,203 --> 00:30:26,230
>> 你可以做WHERE。

621
00:30:26,230 --> 00:30:30,530
然后，我们在这里有一定的限定。

622
00:30:30,530 --> 00:30:32,300
然后我们有什么下一个？

623
00:30:32,300 --> 00:30:38,020
我们有一些东西SET--
等于什么。

624
00:30:38,020 --> 00:30:38,870
等等等等等于。

625
00:30:38,870 --> 00:30:41,859

626
00:30:41,859 --> 00:30:42,400
更新等等。

627
00:30:42,400 --> 00:30:45,655

628
00:30:45,655 --> 00:30:47,050
对不对？

629
00:30:47,050 --> 00:30:52,280
所以这是一般般
主意一定更新。

630
00:30:52,280 --> 00:30:53,060
好不好？

631
00:30:53,060 --> 00:30:56,890
>> 因此，让我们开始填补这一
与它应该是什么。

632
00:30:56,890 --> 00:30:59,640
那么，什么表中，我们在谈论什么？

633
00:30:59,640 --> 00:31:02,190
账户。

634
00:31:02,190 --> 00:31:05,360
然后在这种情况下，
什么是真的很酷

635
00:31:05,360 --> 00:31:08,620
是的，我们在谈论具体
我们的帐户内的用户，

636
00:31:08,620 --> 00:31:11,240
还是我们谈论的所有用户？

637
00:31:11,240 --> 00:31:12,490
我们正在谈论的所有用户。

638
00:31:12,490 --> 00:31:16,870
因此，在这种情况下，我们可以只
删除此WHERE预选赛。

639
00:31:16,870 --> 00:31:20,500
在WHERE只有当你想
限制你改变什么。

640
00:31:20,500 --> 00:31:23,500
如果你想改变整个
表中，你可以丢弃。

641
00:31:23,500 --> 00:31:27,390

642
00:31:27,390 --> 00:31:27,960
好不好。

643
00:31:27,960 --> 00:31:29,430
>> 所以，现在我们正处于我们设定的部分。

644
00:31:29,430 --> 00:31:31,514
我们需要什么改变？

645
00:31:31,514 --> 00:31:33,502
>> 听众：平衡。

646
00:31:33,502 --> 00:31:34,747
>> SPEAKER 1：平衡。

647
00:31:34,747 --> 00:31:37,080
我们要去to--如何
我们要改变的平衡？

648
00:31:37,080 --> 00:31:40,230

649
00:31:40,230 --> 00:31:43,370
我们有20美元的费用，对不对？

650
00:31:43,370 --> 00:31:45,210
零下20。

651
00:31:45,210 --> 00:31:48,130
他们说，这是如果确定
我们有负余额。

652
00:31:48,130 --> 00:31:51,630
所以在这种情况下，你不需要
做任何进一步的错误检查。

653
00:31:51,630 --> 00:31:53,040
好不好？

654
00:31:53,040 --> 00:31:56,130
这简直是​​所有你需要做的。

655
00:31:56,130 --> 00:31:57,990
很酷吧？

656
00:31:57,990 --> 00:31:59,260
好不好。

657
00:31:59,260 --> 00:32:01,460
>> 所以，让我们通过下一个。

658
00:32:01,460 --> 00:32:04,510
“用什么SQL查询可以在
银行取回帐号

659
00:32:04,510 --> 00:32:08,300
其最富有的客户提供
平衡超过一千美元吗？“

660
00:32:08,300 --> 00:32:11,820
如果您的银行和你最富有的客户
只是那些拥有超过1000美元，

661
00:32:11,820 --> 00:32:14,130
我觉得你
做错了什么。

662
00:32:14,130 --> 00:32:16,080
象，如何在一家银行生存？

663
00:32:16,080 --> 00:32:18,930
喜欢，是兴趣，不太够。

664
00:32:18,930 --> 00:32:20,911
好不好。

665
00:32:20,911 --> 00:32:23,660
有了这样的事情，做什么
您觉得我们的四大功能，

666
00:32:23,660 --> 00:32:25,970
你认为我们会使用？

667
00:32:25,970 --> 00:32:27,048
SELECT。

668
00:32:27,048 --> 00:32:27,548
完美。

669
00:32:27,548 --> 00:32:31,300

670
00:32:31,300 --> 00:32:32,460
SELECT。

671
00:32:32,460 --> 00:32:33,300
好不好。

672
00:32:33,300 --> 00:32:40,150
因此，我们选择了一些
标识FROM表。

673
00:32:40,150 --> 00:32:44,070
然后WHERE条件。

674
00:32:44,070 --> 00:32:46,110
所以，当我们经历
这些，我只是去

675
00:32:46,110 --> 00:32:49,680
给你们一个普通进修
对所有这些的一般格式。

676
00:32:49,680 --> 00:32:54,600
>> 因此，我们选择某种
对[？的事情。 ？]在这种情况下，

677
00:32:54,600 --> 00:32:59,050
这将是
通常一些列。

678
00:32:59,050 --> 00:33:02,870
所以在我们的例子中，我们有一些，平衡。

679
00:33:02,870 --> 00:33:06,020
在您的家伙'的情况下，也许
它的ID，姓名，口令。

680
00:33:06,020 --> 00:33:10,760
任何该等列，这是
通常我们正在选择。

681
00:33:10,760 --> 00:33:14,785
>> 所以在这里这种情况下，这
一种柱，有什么标识

682
00:33:14,785 --> 00:33:17,700
是我们从表中拉？

683
00:33:17,700 --> 00:33:21,020
是什么让我们的？

684
00:33:21,020 --> 00:33:24,510
它要求我们为我们的数字，对不对？

685
00:33:24,510 --> 00:33:26,236
该账号。

686
00:33:26,236 --> 00:33:30,500
所以请记住，在这种情况下，仅仅数。

687
00:33:30,500 --> 00:33:33,910
如果你们曾经有过的错误，即
鲜艳的橙色框会出现。

688
00:33:33,910 --> 00:33:37,040
而且当时想，出乎意料
排在一样，等等。

689
00:33:37,040 --> 00:33:39,840
那是因为你叫
你的表错了，对不对？

690
00:33:39,840 --> 00:33:43,660
所以，要确保你
正确地调用列。

691
00:33:43,660 --> 00:33:48,670
>> 因此，从表中，我们的表
是所谓的帐户。

692
00:33:48,670 --> 00:33:51,460
再次，要确保你
正确引用您的餐桌。

693
00:33:51,460 --> 00:33:52,990
然后什么是我们的条件吗？

694
00:33:52,990 --> 00:33:55,672
我们寻找什么样的？

695
00:33:55,672 --> 00:33:56,680
我们希望有钱的人。

696
00:33:56,680 --> 00:33:57,180
是。

697
00:33:57,180 --> 00:34:00,580
所以，平衡大于1000。

698
00:34:00,580 --> 00:34:02,020
你去那里。

699
00:34:02,020 --> 00:34:03,760
这是您的查询。

700
00:34:03,760 --> 00:34:06,430
不是太糟糕了，对不对？

701
00:34:06,430 --> 00:34:07,160
好不好。

702
00:34:07,160 --> 00:34:09,350
>> 所以，现在我们的最后一个。

703
00:34:09,350 --> 00:34:11,370
有了这一点，我们通过微风。

704
00:34:11,370 --> 00:34:12,170
好不好。

705
00:34:12,170 --> 00:34:16,280
所以现在“有什么可以查询
银行接近，即删除“ - 

706
00:34:16,280 --> 00:34:19,760
你不爱他们如何
只是给了你DELETE--

707
00:34:19,760 --> 00:34:24,060
“有0平衡每一个账户？”

708
00:34:24,060 --> 00:34:26,899
我想我们都同意我们
可能会被使用DELETE。

709
00:34:26,899 --> 00:34:29,330
我欢迎采取任何
周围的讨论。

710
00:34:29,330 --> 00:34:33,560
但我认为这是相当安全的，
说我们可以使用DELETE。

711
00:34:33,560 --> 00:34:42,600
>> 所以我们要删除一些
用户表，WHERE条件。

712
00:34:42,600 --> 00:34:45,480
所以同一类的SELECT事情。

713
00:34:45,480 --> 00:34:48,389

714
00:34:48,389 --> 00:34:49,840
所以在这个case--哦，对不起。

715
00:34:49,840 --> 00:34:51,570
我应该DELETE FROM。

716
00:34:51,570 --> 00:34:54,320
由于删除将
删除整个行。

717
00:34:54,320 --> 00:34:58,300
所以我们不需要谈论哪些
关于我们的用户具体的事情

718
00:34:58,300 --> 00:34:59,280
删除。

719
00:34:59,280 --> 00:35:02,870
如果我们删除一个用户，我们
删除他们的一切。

720
00:35:02,870 --> 00:35:07,230
>> 所以在这种情况下，我们只需要
请跟随我们的WHERE和我们的条件。

721
00:35:07,230 --> 00:35:13,050
所以，我们的表只是我们的帐户
表中，我们一直在做。

722
00:35:13,050 --> 00:35:14,931
然后我们有什么条件吗？

723
00:35:14,931 --> 00:35:16,655
>> 听众：平衡。

724
00:35:16,655 --> 00:35:18,330
>> SPEAKER 1：余额等于0。

725
00:35:18,330 --> 00:35:19,401
正确的。

726
00:35:19,401 --> 00:35:19,900
所有的好。

727
00:35:19,900 --> 00:35:20,322
是。

728
00:35:20,322 --> 00:35:21,238
>> 观众：[听不清]。

729
00:35:21,238 --> 00:35:25,745

730
00:35:25,745 --> 00:35:30,530
>> 扬声器1：所以DELETE
本质上删除一切。

731
00:35:30,530 --> 00:35:42,380
因此而使用SELECT，SELECT需要在
您想返回特定的列。

732
00:35:42,380 --> 00:35:46,680
如果你想要的一切
用户返回，你用明星。

733
00:35:46,680 --> 00:35:49,040
星说，还给我
一切从该用户。

734
00:35:49,040 --> 00:35:54,430
或者，如果你把WHERE明星，那
意味着只要给我的一切。

735
00:35:54,430 --> 00:35:56,520
>> 但本质上删除了这一点。

736
00:35:56,520 --> 00:36:01,569
所以，如果你说，删除
户口所在余额等于0，

737
00:36:01,569 --> 00:36:02,610
它会通过。

738
00:36:02,610 --> 00:36:05,890
处处是平衡
等于0时，它固有地做到这一点。

739
00:36:05,890 --> 00:36:07,470
它会删除一切。

740
00:36:07,470 --> 00:36:15,120
明星更for--
用SELECT或UPDATE，

741
00:36:15,120 --> 00:36:20,320
它更多地谈论个人
对应于用户的字段。

742
00:36:20,320 --> 00:36:25,530
>> 所以，当你选择
从表WHERE ID明星

743
00:36:25,530 --> 00:36:31,130
等于1，返回给你
一切与ID 1的用户。

744
00:36:31,130 --> 00:36:38,980
如果你做的SELECT数量
或者从用户的ID名逗号

745
00:36:38,980 --> 00:36:43,110
WHERE ID等于1，即
只是返回它们的数量

746
00:36:43,110 --> 00:36:44,880
或者他们的ID和他们的名字。

747
00:36:44,880 --> 00:36:45,540
好不好？

748
00:36:45,540 --> 00:36:49,420
>> 所以我们使用明星在这种情况下，以
给我们的一切用户。

749
00:36:49,420 --> 00:36:51,940
并删除固有做到这一点。

750
00:36:51,940 --> 00:36:56,950
它不只是删除ID，
或只是名称，或什么的。

751
00:36:56,950 --> 00:36:57,550
是啊，没有。

752
00:36:57,550 --> 00:36:59,780
它只是删除整个用户。

753
00:36:59,780 --> 00:37:05,210
所以我们不必担心
关于明星那里。

754
00:37:05,210 --> 00:37:09,170
>> 如果你想删除
一切，你能做到这一点，

755
00:37:09,170 --> 00:37:11,970
这将只放下一切。

756
00:37:11,970 --> 00:37:14,290
但通常情况下，你
不想这样做。

757
00:37:14,290 --> 00:37:16,940
但是，如果你想删除
一切，你能做到这一点。

758
00:37:16,940 --> 00:37:18,890
好不好。

759
00:37:18,890 --> 00:37:22,120
>> 有你们发现其他问题吗？

760
00:37:22,120 --> 00:37:22,620
是。

761
00:37:22,620 --> 00:37:24,316
>> 听众：你能做到26？

762
00:37:24,316 --> 00:37:27,090
>> SPEAKER 1：26，我们只是做了。

763
00:37:27,090 --> 00:37:28,090
听众：哦，25，对不起。

764
00:37:28,090 --> 00:37:30,721
SPEAKER 1：25。

765
00:37:30,721 --> 00:37:31,220
好不好。

766
00:37:31,220 --> 00:37:31,870
25。

767
00:37:31,870 --> 00:37:32,650
呵呵。

768
00:37:32,650 --> 00:37:33,691
他们正在做的JavaScript。

769
00:37:33,691 --> 00:37:37,265
哦，我简直不敢相信。

770
00:37:37,265 --> 00:37:38,765
我要惹我们再次，伙计们。

771
00:37:38,765 --> 00:37:42,180

772
00:37:42,180 --> 00:37:43,330
好不好。

773
00:37:43,330 --> 00:37:44,440
我们得到了这一点。

774
00:37:44,440 --> 00:37:46,172
我们要完成这项工作。

775
00:37:46,172 --> 00:37:48,190
啊，jQuery的。

776
00:37:48,190 --> 00:37:49,380
乐趣。

777
00:37:49,380 --> 00:37:49,880
好不好。

778
00:37:49,880 --> 00:37:54,040
>> 所以，我们要完成
实施网页

779
00:37:54,040 --> 00:37:57,820
以这样的方式，如果他们参观，
输入自己的姓名，并提交表单，

780
00:37:57,820 --> 00:38:03,810
他们有这个伟大的警报
窗口将要出现。

781
00:38:03,810 --> 00:38:08,410
因此，与警报什么，我们知道，
我们将不得不使用JavaScript。

782
00:38:08,410 --> 00:38:11,190
耶，JavaScript的。

783
00:38:11,190 --> 00:38:14,070
如果他们无法输入
提交表单的名字，

784
00:38:14,070 --> 00:38:15,110
没有警报应该出现。

785
00:38:15,110 --> 00:38:17,900
所以，你可以使用jQuery，
但你不必。

786
00:38:17,900 --> 00:38:22,390
>> 所以我打算让你们工作
这个只是一两分钟。

787
00:38:22,390 --> 00:38:24,050
想想吧。

788
00:38:24,050 --> 00:38:26,050
然后我们将编写它。

789
00:38:26,050 --> 00:38:29,260

790
00:38:29,260 --> 00:38:33,610
斜线我要去尝试和思考的
要解释这个答案，你最好的办法。

791
00:38:33,610 --> 00:38:49,945

792
00:38:49,945 --> 00:38:50,470
行。

793
00:38:50,470 --> 00:38:53,150
我们会得到它成立。

794
00:38:53,150 --> 00:38:53,920
好不好。

795
00:38:53,920 --> 00:38:56,370
>> 所以，我们只是去
走过这一点，

796
00:38:56,370 --> 00:38:59,010
因为我知道的jQuery
是有点混乱。

797
00:38:59,010 --> 00:39:01,710
JavaScript的。

798
00:39:01,710 --> 00:39:03,542
这是一个有点在那里。

799
00:39:03,542 --> 00:39:05,875
所以，我们要做的是什么
[听不清]实际上解决

800
00:39:05,875 --> 00:39:07,250
这个问题与jQuery。

801
00:39:07,250 --> 00:39:09,490
所以，如果你还记得，
jQuery是只是一个库

802
00:39:09,490 --> 00:39:11,520
这只是基于JavaScript的顶部。

803
00:39:11,520 --> 00:39:14,750
它的意思是让你
生活稍微容易一些。

804
00:39:14,750 --> 00:39:17,660
>> 我肯定会，如果
你有时间，你看

805
00:39:17,660 --> 00:39:20,510
的一点点
文档jQuery的。

806
00:39:20,510 --> 00:39:23,230
但它是非常相似的JavaScript。

807
00:39:23,230 --> 00:39:27,830
它有类似的范例，在那里你
使用这个点运算符来调用函数

808
00:39:27,830 --> 00:39:31,720
对你有对象。

809
00:39:31,720 --> 00:39:36,970
>> 所以，我们在这里是jQuery的，
你应该总是有这种

810
00:39:36,970 --> 00:39:43,010
包装物，它是
$（文件）。就绪（功能）功能

811
00:39:43,010 --> 00:39:45,510
在括号这里。

812
00:39:45,510 --> 00:39:46,070
好不好。

813
00:39:46,070 --> 00:39:48,700
因此，这可能是一个
你想在你的备忘单。

814
00:39:48,700 --> 00:39:52,070
因为最起码，你可以
有包装的jQuery的。

815
00:39:52,070 --> 00:39:57,190
它会至少让
你分道扬镳那里。

816
00:39:57,190 --> 00:40:00,110
>> 所以在同样的方式，我们
谈了很多关于JavaScript的，

817
00:40:00,110 --> 00:40:04,560
我们会通过寻找启动
在我们试图修改什么

818
00:40:04,560 --> 00:40:06,150
或者我们正在试图改变。

819
00:40:06,150 --> 00:40:09,050
这将典型地是
我们会放在第一件事。

820
00:40:09,050 --> 00:40:18,270
因此，在这种情况下，如果我们回到这个
这里，我们来看看我们这里的形式，

821
00:40:18,270 --> 00:40:21,790
我们有这样的投入，
没错，这个ID的输入。

822
00:40:21,790 --> 00:40:24,780
我们知道，基于
我们的问题，我们

823
00:40:24,780 --> 00:40:27,970
要么要扔
一个错误，如果这是空的，

824
00:40:27,970 --> 00:40:31,720
或者我们打算把
这成为一个警告，对不对？

825
00:40:31,720 --> 00:40:36,670
所以可能安全地说，我们是
将要与输入此处理。

826
00:40:36,670 --> 00:40:41,770
>> jQuery是在很相似，如果我们
回想起CSS，任何一个ID

827
00:40:41,770 --> 00:40:44,760
我们来看一个哈希值。

828
00:40:44,760 --> 00:40:48,310
任何与类我们
看着同一个点，对不对？

829
00:40:48,310 --> 00:40:53,210
所以在这里以相同的方式，什么
我们谈论的是投入。

830
00:40:53,210 --> 00:40:56,920
我们看到，输入的是
在我们的形式的ID。

831
00:40:56,920 --> 00:41:00,850
所以，我们要提到它本身。

832
00:41:00,850 --> 00:41:01,653
输入。

833
00:41:01,653 --> 00:41:02,460
好不好？

834
00:41:02,460 --> 00:41:04,480
>> 所以，当有疑问，甚至
如果你无处，

835
00:41:04,480 --> 00:41:09,100
如果你真的不确定如何
接近这个，A，有这样的包装。

836
00:41:09,100 --> 00:41:11,780
所以开始有与
包装的jQuery。

837
00:41:11,780 --> 00:41:16,330
B，请确保你知道
你正在改变。

838
00:41:16,330 --> 00:41:18,830
并在有疑问时，
把在东西，

839
00:41:18,830 --> 00:41:21,390
做点，不管你觉得
你应该做它。

840
00:41:21,390 --> 00:41:22,150
>> 听众：什么是包装？

841
00:41:22,150 --> 00:41:24,160
>> SPEAKER 1：包装
是此第一行。

842
00:41:24,160 --> 00:41:27,520
所以这是说，等到
我的文件已准备就绪。

843
00:41:27,520 --> 00:41:29,160
然后开始用的东西搞乱。

844
00:41:29,160 --> 00:41:30,890
好不好？

845
00:41:30,890 --> 00:41:32,780
所以我们知道我们正在玩弄输入。

846
00:41:32,780 --> 00:41:35,450
所以我们想，行，投入是我们的形式。

847
00:41:35,450 --> 00:41:37,220
这是我们的ID。

848
00:41:37,220 --> 00:41:39,800
所以，这就是我们
去寻找。

849
00:41:39,800 --> 00:41:45,220
我们要看看会发生什么
当这个表单提交，对不对？

850
00:41:45,220 --> 00:41:50,180
>> 因此，我们可能会认为，
我们有一些.submit。

851
00:41:50,180 --> 00:41:56,080
所以.submit只是说，OK，这种形式
我们已经与哈希输入参考，

852
00:41:56,080 --> 00:41:59,594
当它被提交，
执行别的东西。

853
00:41:59,594 --> 00:42:01,135
因此，我们将有一些功能。

854
00:42:01,135 --> 00:42:05,010

855
00:42:05,010 --> 00:42:07,270
请注意，我们这里有匿名函数。

856
00:42:07,270 --> 00:42:09,090
在这里，我们有一个匿名函数。

857
00:42:09,090 --> 00:42:09,590
是。

858
00:42:09,590 --> 00:42:14,880
>> 观众：它会始终.submit，
还是仅仅因为在HTML，

859
00:42:14,880 --> 00:42:18,260
我们做出了按钮式提交？

860
00:42:18,260 --> 00:42:23,680
>> 扬声器1：应当.submit，因为
这是某种形式的，我们正在提交。

861
00:42:23,680 --> 00:42:27,750
因为这个.submit不一定
对应于该按钮是什么样

862
00:42:27,750 --> 00:42:28,430
打电话。

863
00:42:28,430 --> 00:42:32,610
但事实证明，这是一个
形成我们提交。

864
00:42:32,610 --> 00:42:33,140
好不好。

865
00:42:33,140 --> 00:42:35,015
>> 所以，匿名通知
功能这里says--

866
00:42:35,015 --> 00:42:37,348
听众：我真的不
理解匿名函数。

867
00:42:37,348 --> 00:42:39,240
扬声器1：所以匿名
功能，它们是

868
00:42:39,240 --> 00:42:42,380
只是功能不具有一个名字。

869
00:42:42,380 --> 00:42:49,560
所以有，而不是一些主要功能
这calls--我们可以说，如果文件

870
00:42:49,560 --> 00:42:52,380
准备好了，那么我们就称之为输入。

871
00:42:52,380 --> 00:42:57,470
然后，当提交，call--
就像，如果某某等提交

872
00:42:57,470 --> 00:42:59,550
我们会打电话一些其他的功能。

873
00:42:59,550 --> 00:43:01,840
匿名函数
根本就没有名字，

874
00:43:01,840 --> 00:43:05,120
它只是执行
在这些各种各样的事情。

875
00:43:05,120 --> 00:43:10,970
>> 所以在这种情况下，这是什么说
是，当我们的文件准备好，

876
00:43:10,970 --> 00:43:12,880
执行此功能。

877
00:43:12,880 --> 00:43:17,110
这个功能是由
内这里的一切。

878
00:43:17,110 --> 00:43:24,410
再下一层就是，OK，
当输入被提交，执行此。

879
00:43:24,410 --> 00:43:28,329
它表示的只是一种方式
应该怎样执行时。

880
00:43:28,329 --> 00:43:30,120
这真的只是一个
功能不

881
00:43:30,120 --> 00:43:32,860
有一个名字，所以它们往往
嵌套成彼此

882
00:43:32,860 --> 00:43:35,132
因为你可以叫不上名字称呼他们。

883
00:43:35,132 --> 00:43:36,984
好不好？

884
00:43:36,984 --> 00:43:39,775
从字面上看，一个匿名函数
是没有名字只是一个函数。

885
00:43:39,775 --> 00:43:41,470
就是这样。

886
00:43:41,470 --> 00:43:47,370
只是一种方式来封装
不同的东西

887
00:43:47,370 --> 00:43:49,250
我们要在特定的时间执行。

888
00:43:49,250 --> 00:43:51,164
>> 观众：[听不清]。

889
00:43:51,164 --> 00:43:53,420
>> SPEAKER 1：发泄？

890
00:43:53,420 --> 00:43:54,360
在哪里？

891
00:43:54,360 --> 00:43:57,510
>> 听众：在
函数后面的括号？

892
00:43:57,510 --> 00:44:00,660
>> SPEAKER 1：后功能。

893
00:44:00,660 --> 00:44:01,290
哪一个？

894
00:44:01,290 --> 00:44:02,410
>> 听众：这两种。

895
00:44:02,410 --> 00:44:05,137
如果放像，事件，或者，如果
你把一个参数出现，

896
00:44:05,137 --> 00:44:07,372
会是错的？

897
00:44:07,372 --> 00:44:12,592
>> SPEAKER 1：在这种情况下，我想
你可以把一个参数在里面。

898
00:44:12,592 --> 00:44:15,619
但是因为我们并不需要一个
的说法，不应该有。

899
00:44:15,619 --> 00:44:17,410
喜欢，它的整体，
就像，你只应该

900
00:44:17,410 --> 00:44:19,810
有事情是
必要的事情。

901
00:44:19,810 --> 00:44:29,325
以同样的方式，如果我们有任何
功能有INT主要void--一样，

902
00:44:29,325 --> 00:44:35,687
与INT主要无效，你
可以做INT ARG V，等等。

903
00:44:35,687 --> 00:44:38,270
但是，如果你不需要这些，你
不应该让他们在那里。

904
00:44:38,270 --> 00:44:39,070
同样的事情。

905
00:44:39,070 --> 00:44:40,896
艾玛，你有问题吗？

906
00:44:40,896 --> 00:44:41,671
好不好。

907
00:44:41,671 --> 00:44:42,170
酷。

908
00:44:42,170 --> 00:44:42,670
好不好。

909
00:44:42,670 --> 00:44:45,862
所以，我们至今是当我们
文件的准备，执行此。

910
00:44:45,862 --> 00:44:47,570
现在，我们正在寻找
当它提交。

911
00:44:47,570 --> 00:44:51,530
所以，现在我们实际上有某种
对我们的事情肉。

912
00:44:51,530 --> 00:45:00,120
因此，我们需要得到的价值是，
用户提交的，不管是一个名字

913
00:45:00,120 --> 00:45:01,340
或空。

914
00:45:01,340 --> 00:45:07,270
然后，我们需要或者回报
此警报或抛出一个错误。

915
00:45:07,270 --> 00:45:08,560
无论哪种方式。

916
00:45:08,560 --> 00:45:13,690
>> 那么，我们如何声明
在JavaScript中的变量？

917
00:45:13,690 --> 00:45:14,670
变种。

918
00:45:14,670 --> 00:45:19,430
所以我们可以说，VAR名
equals--或实际中，我们将

919
00:45:19,430 --> 00:45:21,960
这样做的价值，因为我觉得它的名字。

920
00:45:21,960 --> 00:45:23,920
好不好。

921
00:45:23,920 --> 00:45:31,320
因此，我们有一定的价值在这里，我们
想从我们投入的形式来拉。

922
00:45:31,320 --> 00:45:34,100
所以在同样的方式，
那种我们做了投入，

923
00:45:34,100 --> 00:45:38,380
谁能告诉我什么，我们
可能会在这里呼吁

924
00:45:38,380 --> 00:45:41,230
如果我们想获得
从形式叫什么名字？

925
00:45:41,230 --> 00:45:46,929
如果我们回头看我们的形式在这里，
我们注意到，我们有名称的ID。

926
00:45:46,929 --> 00:45:47,845
观众：[听不清]。

927
00:45:47,845 --> 00:45:51,026

928
00:45:51,026 --> 00:45:54,675
>> SPEAKER 1：你不用
把它作为一个数组。

929
00:45:54,675 --> 00:45:57,650

930
00:45:57,650 --> 00:46:00,760
你并不需要担心。

931
00:46:00,760 --> 00:46:03,250
所以，我们只是有一些名字。

932
00:46:03,250 --> 00:46:09,022
然后，因为JavaScript和东西
奇怪的是，我们不能只是做“的名字。”

933
00:46:09,022 --> 00:46:11,230
实际上，我们必须调用
一些功能给我们，

934
00:46:11,230 --> 00:46:14,160
像，该识别符的值。

935
00:46:14,160 --> 00:46:15,160
好不好？

936
00:46:15,160 --> 00:46:16,780
所以，这只是.VAL。

937
00:46:16,780 --> 00:46:18,356
>> 观众：[听不清]。

938
00:46:18,356 --> 00:46:19,160
>> 扬声器1：OK。

939
00:46:19,160 --> 00:46:27,030
所以用JavaScript，这种
这里的事情刚刚经历。

940
00:46:27,030 --> 00:46:35,730
你可以认为这as--它的
像几乎一个的getElementById，其中

941
00:46:35,730 --> 00:46:40,630
的getElementById实际上
返回完整的东西给你。

942
00:46:40,630 --> 00:46:49,930
在$（“＃名称”）就像是，
OK，我有它，我可以访问它，

943
00:46:49,930 --> 00:46:52,265
但如果你真的想要它
返回的值以你 - 

944
00:46:52,265 --> 00:46:53,596
>> 听众：是不是像一个指针？

945
00:46:53,596 --> 00:46:55,070
>> 扬声器1：这有点像一个指针。

946
00:46:55,070 --> 00:46:57,069
你可以把它想成
有点像一个指针。

947
00:46:57,069 --> 00:46:59,060
像，它说，OK，我
知道如何到达那里，

948
00:46:59,060 --> 00:47:02,330
但实际获得的价值出来的
它，你必须明确地提出要求。

949
00:47:02,330 --> 00:47:07,800
不幸的是，很明显，我们不
做过多的使用JavaScript和jQuery。

950
00:47:07,800 --> 00:47:12,160
>> 因此，这将回落到多少
你guys--你发生什么就知道了，

951
00:47:12,160 --> 00:47:17,610
你发生什么事都见过，什么
种可以在逻辑猜测。

952
00:47:17,610 --> 00:47:21,639
由于其中的一些事情，你
大概可以拿到一半。

953
00:47:21,639 --> 00:47:24,180
但要得到它完全正确的，
我觉得这个问题可能

954
00:47:24,180 --> 00:47:25,624
具有最低分数之一。

955
00:47:25,624 --> 00:47:27,790
观众：像，比如，
为[听不清]输入，

956
00:47:27,790 --> 00:47:29,450
你为什么不必须把VAL呢？

957
00:47:29,450 --> 00:47:30,450
SPEAKER 1：对于这一个？

958
00:47:30,450 --> 00:47:31,124
听众：是的。

959
00:47:31,124 --> 00:47:31,790
扬声器1：是啊。

960
00:47:31,790 --> 00:47:33,498
因为这是一种
都喜欢，正如我们所说，

961
00:47:33,498 --> 00:47:37,180
一些指针，这是我的参考
它实际上就是把我们的价值。

962
00:47:37,180 --> 00:47:38,872
>> 听众：鉴于[听不清]？

963
00:47:38,872 --> 00:47:42,060
>> SPEAKER 1：对于输入，
投入只是some--

964
00:47:42,060 --> 00:47:44,450
这就像我们只是
看着它作为一个整体，

965
00:47:44,450 --> 00:47:48,859
这.submit告诉
我们什么，我们需要知道的。

966
00:47:48,859 --> 00:47:50,150
jQuery和JavaScript是怪异。

967
00:47:50,150 --> 00:47:50,800
我知道。

968
00:47:50,800 --> 00:47:51,690
我知道，伙计们。

969
00:47:51,690 --> 00:47:52,460
我知道。

970
00:47:52,460 --> 00:47:55,260
还有一个原因，我不
做网页编程。

971
00:47:55,260 --> 00:47:56,230
只是在开玩笑。

972
00:47:56,230 --> 00:47:57,780
我还没有足够的曝光吧。

973
00:47:57,780 --> 00:47:59,070
>> 观众：[听不清] CSS。

974
00:47:59,070 --> 00:48:00,206
>> [笑]

975
00:48:00,206 --> 00:48:00,590
>> 扬声器1：OK，这就是CSS。

976
00:48:00,590 --> 00:48:03,730
CSS只是一样，把事情漂亮，
它不像我们处理数据。

977
00:48:03,730 --> 00:48:05,710
有一个区别在那里。

978
00:48:05,710 --> 00:48:06,350
好不好。

979
00:48:06,350 --> 00:48:12,110
所以，现在我们希望，这也part--，对于
这样，出了问题，你可能不

980
00:48:12,110 --> 00:48:16,070
知道语法，你也能像，
OK，你可以有一些VAR值

981
00:48:16,070 --> 00:48:18,320
而像，假设我
得到正确的值。

982
00:48:18,320 --> 00:48:20,600
然后你很可能
写这篇文章下一部分。

983
00:48:20,600 --> 00:48:24,640
下一部分将可能
似乎更容易，

984
00:48:24,640 --> 00:48:26,610
或它将使逻辑
感你们。

985
00:48:26,610 --> 00:48:31,520
>> 虽然我们已经写了这么远，
我知道我会喜欢，嗯，是啊，

986
00:48:31,520 --> 00:48:34,340
我不知道，在测验。

987
00:48:34,340 --> 00:48:37,610
你完全可以写伪码
然后打入真正的代码

988
00:48:37,610 --> 00:48:40,460
你 - 当它有点像数学。

989
00:48:40,460 --> 00:48:42,904
如果你曾经有过的一些
多部分的问题，其中

990
00:48:42,904 --> 00:48:44,820
你不知道如何
闯过第一步骤中，

991
00:48:44,820 --> 00:48:46,736
但一切
依赖于第一步骤中，

992
00:48:46,736 --> 00:48:49,577
你刚才说的一样，假设x等于4。

993
00:48:49,577 --> 00:48:50,910
然后运行它，对吗？

994
00:48:50,910 --> 00:48:52,410
>> 你可以做同样的事情的代码。

995
00:48:52,410 --> 00:48:55,740
所以，你可以说，假设
我得到了价值的权利。

996
00:48:55,740 --> 00:48:58,290
那么在这里做下一​​部分。

997
00:48:58,290 --> 00:49:02,610
因为这部分实际上
应该是相当合理的。

998
00:49:02,610 --> 00:49:06,560
>> 因此，我们需要检查
如果我们的价值是空的。

999
00:49:06,560 --> 00:49:11,650
或者，如果它的一些名字，
实际上给一个警告。

1000
00:49:11,650 --> 00:49:15,085
那么，什么可能我们要检查？

1001
00:49:15,085 --> 00:49:17,800
我们希望有一些如果。

1002
00:49:17,800 --> 00:49:19,510
您如何看待我们的。如果将是？

1003
00:49:19,510 --> 00:49:24,141
我们需要检查是否值，看看
is--如果它不是一个空字符串。

1004
00:49:24,141 --> 00:49:30,740

1005
00:49:30,740 --> 00:49:31,730
>> 完美。

1006
00:49:31,730 --> 00:49:32,570
没错。

1007
00:49:32,570 --> 00:49:33,070
好不好。

1008
00:49:33,070 --> 00:49:36,320
所以，如果是这样的话，
我们怎么想干什么？

1009
00:49:36,320 --> 00:49:39,190
我们要抛出一些警惕，对不对？

1010
00:49:39,190 --> 00:49:41,090
所以它只是警告。

1011
00:49:41,090 --> 00:49:43,050
然后不管我们想进去。

1012
00:49:43,050 --> 00:49:45,430
那么，我们应该
让我们警觉里面？

1013
00:49:45,430 --> 00:49:48,916
>> 听众：“你好。”

1014
00:49:48,916 --> 00:49:50,421
>> SPEAKER 1：逗号。

1015
00:49:50,421 --> 00:49:52,462
然后做你们
记得如何连接？

1016
00:49:52,462 --> 00:49:53,400
>> 观众：加。

1017
00:49:53,400 --> 00:49:54,520
>> SPEAKER 1：加。

1018
00:49:54,520 --> 00:49:57,490
因此，我们希望有加。

1019
00:49:57,490 --> 00:50:03,480
然后我们需要另一个加
我们的感叹号。

1020
00:50:03,480 --> 00:50:05,620
酷。

1021
00:50:05,620 --> 00:50:06,540
好不好。

1022
00:50:06,540 --> 00:50:08,255
否则，什么可能我们想要做什么？

1023
00:50:08,255 --> 00:50:10,380
我们不想做任何事，对不对？

1024
00:50:10,380 --> 00:50:14,190
所以我们只是返回false。

1025
00:50:14,190 --> 00:50:17,200
不是我想做的事情。

1026
00:50:17,200 --> 00:50:18,520
好不好。

1027
00:50:18,520 --> 00:50:20,660
>> 然后将这些中，
course--什么是重要的

1028
00:50:20,660 --> 00:50:23,510
是要记住关闭
您的匿名函数。

1029
00:50:23,510 --> 00:50:27,230
所以，如果你发现，我们有一些
功能在这里，到此为止。

1030
00:50:27,230 --> 00:50:31,710
因此，我们需要关闭该
第一个，并添加一个分号。

1031
00:50:31,710 --> 00:50:35,195
然后这个人在这里有
做这个匿名函数，

1032
00:50:35,195 --> 00:50:38,650
所以我们关闭它。

1033
00:50:38,650 --> 00:50:40,190
节约是下意识的反应。

1034
00:50:40,190 --> 00:50:40,690
是。

1035
00:50:40,690 --> 00:50:45,650
听众：还有一个原因that--
只是在JavaScript中所有的例子

1036
00:50:45,650 --> 00:50:48,480
我已经看到了，我们有
第一个大括号

1037
00:50:48,480 --> 00:50:51,075
在同一行的功能？

1038
00:50:51,075 --> 00:50:53,040
>> 扬声器1：这是风格。

1039
00:50:53,040 --> 00:50:54,130
是啊。

1040
00:50:54,130 --> 00:51:00,650
而实际上，如果你把61，我们
做我们所有的花括号的方式。

1041
00:51:00,650 --> 00:51:01,830
咦？

1042
00:51:01,830 --> 00:51:05,030
>> 观众：如果我们这样做那样做的
在PSET，是坏的风格？

1043
00:51:05,030 --> 00:51:05,720
>> SPEAKER 1：第

1044
00:51:05,720 --> 00:51:09,710
我们已经明确告知
你们这样做。

1045
00:51:09,710 --> 00:51:14,540
但实际上，这是一种
占主导地位的公约

1046
00:51:14,540 --> 00:51:19,620
在大堆c类和
JavaScript和jQuery的。

1047
00:51:19,620 --> 00:51:23,074
所以很明显，我sure--
实际上，如果我

1048
00:51:23,074 --> 00:51:26,770
要完全做到这一点的问题
盲目而不必看着它，

1049
00:51:26,770 --> 00:51:30,080
有可能是极少数
如何我会得到这一点。

1050
00:51:30,080 --> 00:51:36,160
>> 我可能会一直喜欢，好吧，也许我
需要抓住的东西，是一个输入端。

1051
00:51:36,160 --> 00:51:38,020
而且我认为具有
知识一样，

1052
00:51:38,020 --> 00:51:43,240
OK，如果我想要得到的东西
从具有一个ID的形式，

1053
00:51:43,240 --> 00:51:46,990
我指的是它以这种方式，
我大概明白了。

1054
00:51:46,990 --> 00:51:49,940
我可能会这样。

1055
00:51:49,940 --> 00:51:53,400
不过说真的，唯一的事情，我觉得
我真的得到的是这一权利在这里。

1056
00:51:53,400 --> 00:51:59,230
>> 所以这是种很重要的
知道，与任何艰难的考验，

1057
00:51:59,230 --> 00:52:02,130
有种你选择你的战场，对不对？

1058
00:52:02,130 --> 00:52:06,780
如果你知道你不会得到
jQuery的是第一部分，正如我所说，

1059
00:52:06,780 --> 00:52:10,080
假设你有这样的价值
和做什么，你可以用它。

1060
00:52:10,080 --> 00:52:14,730
如果你有时间，回去
和尝试，并填写作品。

1061
00:52:14,730 --> 00:52:17,150
但是，不要让这样的问题
这真的陷入你失望。

1062
00:52:17,150 --> 00:52:18,080
原因是什么？

1063
00:52:18,080 --> 00:52:23,260
这是一个问题上
jQuery的出整个考试。

1064
00:52:23,260 --> 00:52:25,810
所以，是的，这将会是巨大的，如果你得到了它。

1065
00:52:25,810 --> 00:52:28,297
>> 观众：[听不清]你
欢迎使用jQuery。

1066
00:52:28,297 --> 00:52:30,005
SPEAKER 1：你是
欢迎使用jQuery。

1067
00:52:30,005 --> 00:52:31,088
听众：OK。 [听不清]。

1068
00:52:31,088 --> 00:52:33,060
SPEAKER 1：你如何不使用它呢？

1069
00:52:33,060 --> 00:52:35,850
我要看看
所有我的JavaScript。

1070
00:52:35,850 --> 00:52:38,810
它实际上是容易得多，
我认为，使用jQuery，

1071
00:52:38,810 --> 00:52:42,995
因为jQuery实际上降低了
你写JavaScript的量可能

1072
00:52:42,995 --> 00:52:43,620
受，想，有一半。

1073
00:52:43,620 --> 00:52:46,334
所以，我们的代码很可能是
只要不两倍的。

1074
00:52:46,334 --> 00:52:49,250
所以，如果你recognize--最大
事情从这个问题拿走

1075
00:52:49,250 --> 00:52:50,550
是图案。

1076
00:52:50,550 --> 00:52:52,890
如果您在访问
从形式的东西，

1077
00:52:52,890 --> 00:52:57,830
你要使用引号，哈希，
无论你想访问。

1078
00:52:57,830 --> 00:53:01,000
如果它被提交，你想
使用像一个.submit。

1079
00:53:01,000 --> 00:53:03,680
你可能会使用
匿名函数在那里。

1080
00:53:03,680 --> 00:53:08,030
如果你确实需要的值
什么，你要做的报价，

1081
00:53:08,030 --> 00:53:12,160
哈希，无论那场，.VAL。

1082
00:53:12,160 --> 00:53:14,690
并认识模式
这样会

1083
00:53:14,690 --> 00:53:19,586
要远远超过有用
真正了解的细节问题。

1084
00:53:19,586 --> 00:53:20,562
是。

1085
00:53:20,562 --> 00:53:23,164
>> 观众：所以，如果
用户提交他们的名字

1086
00:53:23,164 --> 00:53:27,394
它贯穿了声明，将
他走下来，在此之后返回false？

1087
00:53:27,394 --> 00:53:30,373
>> SPEAKER 1：没有，因为警报，
你可以认为它像一回。

1088
00:53:30,373 --> 00:53:30,873
是啊。

1089
00:53:30,873 --> 00:53:31,590
所以它会退出。

1090
00:53:31,590 --> 00:53:31,925
是啊。

1091
00:53:31,925 --> 00:53:33,883
>> 听众：莫非你
[？地方？]括号

1092
00:53:33,883 --> 00:53:37,105
的提交，括号什么？

1093
00:53:37,105 --> 00:53:38,870
>> 扬声器1：我做了，我相信。

1094
00:53:38,870 --> 00:53:42,300
这其中的关在这里。

1095
00:53:42,300 --> 00:53:45,800
然后这个人会倒闭这里。

1096
00:53:45,800 --> 00:53:47,135
>> 听众：哦，有。

1097
00:53:47,135 --> 00:53:48,470
行。

1098
00:53:48,470 --> 00:53:53,572
>> SPEAKER 1：很显然，小，
小句法的东西

1099
00:53:53,572 --> 00:53:55,780
这样，我们可能会
只是圈，并像，

1100
00:53:55,780 --> 00:53:58,385
不要忘记你的括号内。

1101
00:53:58,385 --> 00:53:59,810
但是，是的。

1102
00:53:59,810 --> 00:54:00,950
好不好。

1103
00:54:00,950 --> 00:54:04,190
我们有一个又一个
我们愿做？

1104
00:54:04,190 --> 00:54:07,700

1105
00:54:07,700 --> 00:54:11,599
难道你们得到二叉树呢？

1106
00:54:11,599 --> 00:54:12,890
难道我们要说明一下吗？

1107
00:54:12,890 --> 00:54:17,940
我觉得像二叉树
与DOM的应该是分

1108
00:54:17,940 --> 00:54:19,880
那你们变得相当容易。

1109
00:54:19,880 --> 00:54:21,978
我不想你
失去在该点。

1110
00:54:21,978 --> 00:54:28,335

1111
00:54:28,335 --> 00:54:30,370
好不好。

1112
00:54:30,370 --> 00:54:33,097
>> 让我们做到这一点DOM这里。

1113
00:54:33,097 --> 00:54:35,555
我希望我有我的面，所以我
可能只是在屏幕上绘制。

1114
00:54:35,555 --> 00:54:38,330

1115
00:54:38,330 --> 00:54:41,461
这就是我用来做最后一年。

1116
00:54:41,461 --> 00:54:41,960
好不好。

1117
00:54:41,960 --> 00:54:48,370
因此，正如我所说，我们谈
关于DOM，文档对象模型。

1118
00:54:48,370 --> 00:54:51,415
他们很可能要给你
片段中的一些点点这样的

1119
00:54:51,415 --> 00:54:54,250
并要求你创建一棵树吧。

1120
00:54:54,250 --> 00:54:58,050
而这恰恰都有做
通过标签运行。

1121
00:54:58,050 --> 00:55:00,685
所以让我们尝试做到这一点。

1122
00:55:00,685 --> 00:55:09,610

1123
00:55:09,610 --> 00:55:12,920
>> 此外，按照往常一样，如果你们
做这些测验，因为我强烈

1124
00:55:12,920 --> 00:55:16,450
建议你一样的做法，
其中任何一个，你是喜欢，

1125
00:55:16,450 --> 00:55:19,480
我真的不明白是什么
怎么回事，只是，当然，

1126
00:55:19,480 --> 00:55:23,334
有一个问题给我发电子邮件，
我将解释尽我所能。

1127
00:55:23,334 --> 00:55:25,298
好不好。

1128
00:55:25,298 --> 00:55:33,420
>> 我们有一些文件，我们有HTML。

1129
00:55:33,420 --> 00:55:33,970
好不好。

1130
00:55:33,970 --> 00:55:38,750
所以当时我们只是分析
这里的标签，对不对？

1131
00:55:38,750 --> 00:55:45,810
所以，我们看到了什么comes--是什么
HTML下的两个子目？

1132
00:55:45,810 --> 00:55:48,880
特别是因为
他们是正确缩进？

1133
00:55:48,880 --> 00:55:49,580
头部和身体。

1134
00:55:49,580 --> 00:56:00,298

1135
00:56:00,298 --> 00:56:00,800
啊。

1136
00:56:00,800 --> 00:56:03,730

1137
00:56:03,730 --> 00:56:04,960
头部和身体。

1138
00:56:04,960 --> 00:56:05,952
可爱。

1139
00:56:05,952 --> 00:56:07,410
那么接下来就让我们从这里开始头。

1140
00:56:07,410 --> 00:56:09,090
什么是下面的头上？

1141
00:56:09,090 --> 00:56:11,721
什么是我们的下一个标签？

1142
00:56:11,721 --> 00:56:12,220
称号。

1143
00:56:12,220 --> 00:56:16,450

1144
00:56:16,450 --> 00:56:19,605
然后在标题测验。

1145
00:56:19,605 --> 00:56:23,970

1146
00:56:23,970 --> 00:56:24,690
好不好。

1147
00:56:24,690 --> 00:56:27,940
>> 所以从字面上看，它只是
通过标签走，好不好？

1148
00:56:27,940 --> 00:56:31,610
这样的话，如果我们有
身体，因为我们经历，

1149
00:56:31,610 --> 00:56:35,460
机身内部有三件事情，对不对？

1150
00:56:35,460 --> 00:56:36,400
它有三个div的。

1151
00:56:36,400 --> 00:56:40,060

1152
00:56:40,060 --> 00:56:41,900
每格都有自己的小盒子。

1153
00:56:41,900 --> 00:56:45,260

1154
00:56:45,260 --> 00:56:48,106
什么是在第一个div？

1155
00:56:48,106 --> 00:56:48,606
[听不清]

1156
00:56:48,606 --> 00:56:52,070

1157
00:56:52,070 --> 00:56:57,292
再下一个是中间的，
我只是要缩写。

1158
00:56:57,292 --> 00:56:59,410
然后最后一个是底部。

1159
00:56:59,410 --> 00:57:06,060

1160
00:57:06,060 --> 00:57:07,650
>> 因此，其实，它只是穿行。

1161
00:57:07,650 --> 00:57:11,140
因为我们打算给
你的HTML正确缩进，

1162
00:57:11,140 --> 00:57:16,800
你可以从字面上只是贯穿
而像，OK，这里是HTML。

1163
00:57:16,800 --> 00:57:19,460
因此，这是最外
角落里，或者最远离开，

1164
00:57:19,460 --> 00:57:22,410
所以必须是自己的事。

1165
00:57:22,410 --> 00:57:26,360
这些都在同一个缩进。

1166
00:57:26,360 --> 00:57:30,120
>> 所以我们知道，头部需要
是在相同的水平体，

1167
00:57:30,120 --> 00:57:32,040
但HTML下方。

1168
00:57:32,040 --> 00:57:33,100
这就是我们这里。

1169
00:57:33,100 --> 00:57:36,810
头部和身体是兄弟，
但他们在HTML。

1170
00:57:36,810 --> 00:57:39,130
然后我们只需要进入每一项。

1171
00:57:39,130 --> 00:57:44,370
所以头有称号，这
有测验，我们在这里看到。

1172
00:57:44,370 --> 00:57:48,210
然后在这种情况下，我们有
身体，有以下三条线。

1173
00:57:48,210 --> 00:57:51,470
所以这些都是
所有的兄弟姐妹身下。

1174
00:57:51,470 --> 00:57:53,732
好不好？

1175
00:57:53,732 --> 00:57:56,190
当你看到，所以希望
这样的事情，你喜欢，

1176
00:57:56,190 --> 00:57:57,900
是的，我只是去画一棵树。

1177
00:57:57,900 --> 00:58:00,430
这会是很大的。

1178
00:58:00,430 --> 00:58:01,130
好不好。

1179
00:58:01,130 --> 00:58:03,220
所以，希望确保
你们知道。

1180
00:58:03,220 --> 00:58:10,510
>> 那么，我们为什么不进入
32我们的二叉树？

1181
00:58:10,510 --> 00:58:17,905
因为一旦你理解了二进制
搜索树，它真的不是那么糟糕。

1182
00:58:17,905 --> 00:58:20,960
所以埃弗雷特，我可以erase--我
意思是说，这些都是在网上，太。

1183
00:58:20,960 --> 00:58:24,130
所以，如果你有任何问题。

1184
00:58:24,130 --> 00:58:44,410

1185
00:58:44,410 --> 00:58:46,370
>> 失去了一点点的空间存在，但它的确定。

1186
00:58:46,370 --> 00:58:50,190
因此，二叉搜索树是
只是一种方式来组织数据

1187
00:58:50,190 --> 00:58:57,000
不是在一个阵列，其中
根总是更大

1188
00:58:57,000 --> 00:59:03,500
比左子和根是
总是比右孩子少。

1189
00:59:03,500 --> 00:59:04,770
好不好。

1190
00:59:04,770 --> 00:59:08,160
>> 所以，我们在这里有这个伟大的搜索树。

1191
00:59:08,160 --> 00:59:13,360
我们有这些数字，34，
59，20，106，36，和52。

1192
00:59:13,360 --> 00:59:15,160
我们需要组织
它们以这样的方式

1193
00:59:15,160 --> 00:59:22,100
使得该根是更大
比一切在左侧

1194
00:59:22,100 --> 00:59:24,750
并且它小于
一切在右侧。

1195
00:59:24,750 --> 00:59:29,580
并且通常，你
想要做的是试图找到

1196
00:59:29,580 --> 00:59:31,720
一些关于在中间。

1197
00:59:31,720 --> 00:59:35,420
与二叉搜索树，你可能有
要玩一点点吧。

1198
00:59:35,420 --> 00:59:40,850
>> 但在这种情况下，我们只
假设我们知道这第一个。

1199
00:59:40,850 --> 00:59:44,870
所以36是我们这里的第一个。

1200
00:59:44,870 --> 00:59:46,790
通常情况下，我会尝试
并选择一些

1201
00:59:46,790 --> 00:59:50,160
大约在中间那会
大概产生最好的结果。

1202
00:59:50,160 --> 00:59:56,200
所以，现在我们知道这一切的
此方需要小于36。

1203
00:59:56,200 --> 00:59:59,520
但同时，你能看到的是
我们有两个点在这里。

1204
00:59:59,520 --> 01:00:04,350
因此，如果我们知道，我们需要两个
是小于根数，

1205
01:00:04,350 --> 01:00:08,670
那么你可以随便点，这些
并选择第三个数字。

1206
01:00:08,670 --> 01:00:09,390
好不好。

1207
01:00:09,390 --> 01:00:11,550
>> 所以我们为什么不与本方开始？

1208
01:00:11,550 --> 01:00:17,270
因此，如果我们知道这一切的
此方需要小于36--

1209
01:00:17,270 --> 01:00:21,290
但是，如果我们看看这个，
我们知道，这个数字

1210
01:00:21,290 --> 01:00:25,180
比这个数字要少，对不对？

1211
01:00:25,180 --> 01:00:30,810
因为这个数字在这里
是在右侧。

1212
01:00:30,810 --> 01:00:34,680
请记住，就像在我们的大
树，一切都在正确的

1213
01:00:34,680 --> 01:00:37,130
需要比根大。

1214
01:00:37,130 --> 01:00:40,540
通过这种方式，我们知道，
无论是在这种需求

1215
01:00:40,540 --> 01:00:43,090
比什么在这里大。

1216
01:00:43,090 --> 01:00:44,020
好不好？

1217
01:00:44,020 --> 01:00:46,340
>> 因此，我们有两个选择
对于这两种气泡。

1218
01:00:46,340 --> 01:00:49,830
我们有32和34--还是遗憾。

1219
01:00:49,830 --> 01:00:53,330
20和34。

1220
01:00:53,330 --> 01:00:56,500
所以，您怎么看
我们可能在把这些？

1221
01:00:56,500 --> 01:00:59,230
如果此人有成为
大于这个，

1222
01:00:59,230 --> 01:01:04,340
这意味着我们要
有20个在这里和这里34。

1223
01:01:04,340 --> 01:01:05,340
好不好。

1224
01:01:05,340 --> 01:01:09,380
>> 所以以相同的方式，我们期待
在这种子树。

1225
01:01:09,380 --> 01:01:14,994
和我们说，OK，我们没有36。

1226
01:01:14,994 --> 01:01:20,460
我们有106，52，和59。

1227
01:01:20,460 --> 01:01:21,590
对不对？

1228
01:01:21,590 --> 01:01:24,820
在这里这种情况下，我们
知道这一个需求

1229
01:01:24,820 --> 01:01:29,570
有一件事是大于
并有一件事是低于它。

1230
01:01:29,570 --> 01:01:30,100
对不对？

1231
01:01:30,100 --> 01:01:34,580
因此，如果我们把这些才能，它只是
大约又发现中间值。

1232
01:01:34,580 --> 01:01:35,766
因此，我们的中间值是59。

1233
01:01:35,766 --> 01:01:38,524

1234
01:01:38,524 --> 01:01:40,190
所以后来我们说，OK，什么是低于59？

1235
01:01:40,190 --> 01:01:41,826
嗯，这是52。

1236
01:01:41,826 --> 01:01:42,950
什么是大于59？

1237
01:01:42,950 --> 01:01:45,120
嗯，这是106。

1238
01:01:45,120 --> 01:01:45,930
好不好？

1239
01:01:45,930 --> 01:01:49,430
所以它只是一个有点像一个谜。

1240
01:01:49,430 --> 01:01:53,160
它通常会有所帮助，尤其是
在小树林这样，

1241
01:01:53,160 --> 01:01:56,617
如果你只是为了它，如果你
知道有多少是在左侧

1242
01:01:56,617 --> 01:01:58,450
又有多少是在
没错，这正好可以

1243
01:01:58,450 --> 01:02:01,050
让你选择什么
应该是你的根。

1244
01:02:01,050 --> 01:02:02,922
然后你就可以种
的工作，从那里。

1245
01:02:02,922 --> 01:02:05,080
嗯。

1246
01:02:05,080 --> 01:02:05,580
33？

1247
01:02:05,580 --> 01:02:07,570
当然。

1248
01:02:07,570 --> 01:02:10,120
好不好。

1249
01:02:10,120 --> 01:02:17,410
因此，我们要创建一个节点
或二进制搜索树。

1250
01:02:17,410 --> 01:02:20,416
让我们看一下可能是什么吧。

1251
01:02:20,416 --> 01:02:26,130

1252
01:02:26,130 --> 01:02:28,600
我认为，这将
实际上是我们的最后一个问题。

1253
01:02:28,600 --> 01:02:29,510
啊。

1254
01:02:29,510 --> 01:02:30,010
好不好。

1255
01:02:30,010 --> 01:02:48,190

1256
01:02:48,190 --> 01:02:48,690
好不好。

1257
01:02:48,690 --> 01:02:55,580

1258
01:02:55,580 --> 01:02:58,040
>> 这就好比我们所能
认为作为一个节点，对不对？

1259
01:02:58,040 --> 01:03:01,610
我们有一定的价值，而我们
知道，它要么

1260
01:03:01,610 --> 01:03:03,830
有左，右的孩子。

1261
01:03:03,830 --> 01:03:08,420
tree--这意味着二进制搜索
它有，顶多两个孩子。

1262
01:03:08,420 --> 01:03:08,920
好不好？

1263
01:03:08,920 --> 01:03:12,690

1264
01:03:12,690 --> 01:03:15,540
让我们想想办法，我们
定义一个链表，对吧？

1265
01:03:15,540 --> 01:03:17,740
>> 我们有一些int值
表示的值。

1266
01:03:17,740 --> 01:03:20,760
我们有这样的代表的一些指针
它打算明年。

1267
01:03:20,760 --> 01:03:23,350
二叉查找树非常相似。

1268
01:03:23,350 --> 01:03:27,980
我们还是有一定的价值，
N，我们给它，对吗？

1269
01:03:27,980 --> 01:03:31,750
然后我画了这些非常
明确箭头，

1270
01:03:31,750 --> 01:03:34,010
因为它们是有效的指针。

1271
01:03:34,010 --> 01:03:34,940
好不好？

1272
01:03:34,940 --> 01:03:38,500
>> 所以n通常是什么？

1273
01:03:38,500 --> 01:03:39,230
它的一些价值。

1274
01:03:39,230 --> 01:03:41,800
什么是我们通常将它指定为？

1275
01:03:41,800 --> 01:03:42,500
一个int。

1276
01:03:42,500 --> 01:03:49,980
因此，我们有一些整数n或int值，
或任何你想调用它。

1277
01:03:49,980 --> 01:03:53,230
然后我们有左
孩子和右孩子。

1278
01:03:53,230 --> 01:03:54,570
对不对？

1279
01:03:54,570 --> 01:03:58,060
而且我们知道他们是什么
point--它们是什么指向？

1280
01:03:58,060 --> 01:04:01,560
他们指着其他节点，对不对？

1281
01:04:01,560 --> 01:04:07,540
因此，如何将我们声明一个节点指针？

1282
01:04:07,540 --> 01:04:10,480

1283
01:04:10,480 --> 01:04:11,460
>> 观众：[听不清]。

1284
01:04:11,460 --> 01:04:12,472
>> SPEAKER 1：嗯。

1285
01:04:12,472 --> 01:04:14,305
并且我们将不得不
其中的两个，对不对？

1286
01:04:14,305 --> 01:04:18,070

1287
01:04:18,070 --> 01:04:26,710
然后我们可以从字面上
不要离开左子

1288
01:04:26,710 --> 01:04:30,950
右为右孩子。

1289
01:04:30,950 --> 01:04:31,820
Actually--遗憾。

1290
01:04:31,820 --> 01:04:33,155
因为我们需要的结构。

1291
01:04:33,155 --> 01:04:36,250

1292
01:04:36,250 --> 01:04:41,580
>> 所以结构是因为我们还没有
宣布完一个节点呢。

1293
01:04:41,580 --> 01:04:47,070
因此，节点内这里。

1294
01:04:47,070 --> 01:04:49,640
这有点像
递归定义，对不对？

1295
01:04:49,640 --> 01:04:53,140
所以，当我们都在
此定义，我们

1296
01:04:53,140 --> 01:04:57,310
还没有完成申报
节点作为结构，

1297
01:04:57,310 --> 01:04:59,380
所以我们要做的结构
节点只是说，是的，

1298
01:04:59,380 --> 01:05:03,930
我们实际上指
回到我们自己类型的事情。

1299
01:05:03,930 --> 01:05:07,410
像一旦它
创建时，它会没事的。

1300
01:05:07,410 --> 01:05:10,890
>> 所以有多大你们认为这是？

1301
01:05:10,890 --> 01:05:13,650
这是什么结构的大小？

1302
01:05:13,650 --> 01:05:14,370
12。

1303
01:05:14,370 --> 01:05:14,870
为什么呢？

1304
01:05:14,870 --> 01:05:18,990

1305
01:05:18,990 --> 01:05:19,664
精确。

1306
01:05:19,664 --> 01:05:21,830
而事实上，其中一个
第一个问题的一个测验

1307
01:05:21,830 --> 01:05:24,170
是关于大小，这就是为什么我问。

1308
01:05:24,170 --> 01:05:25,230
行。

1309
01:05:25,230 --> 01:05:29,350
>> 我们将结束，因为
DCE会骂我，如果我们不这样做。

1310
01:05:29,350 --> 01:05:33,790
但是，如果你们有任何问题，
当然，给我发电子邮件，让我知道。

1311
01:05:33,790 --> 01:05:35,190
你们要摇晃。

1312
01:05:35,190 --> 01:05:37,210
我超级兴奋。

1313
01:05:37,210 --> 01:05:39,380
你们会做的
星期三，然后

1314
01:05:39,380 --> 01:05:43,150
你会得到工作，最终
项目，这将是真棒。

1315
01:05:43,150 --> 01:05:48,784
>> 我会在这里下一个
本周从4:00到4:30

1316
01:05:48,784 --> 01:05:50,700
如果你们要来
拿起你的测验。

1317
01:05:50,700 --> 01:05:54,410
如果你想给我找一些其他的时间
或者只是协调不同的时间，

1318
01:05:54,410 --> 01:05:56,460
随时让我知道。

1319
01:05:56,460 --> 01:05:58,670
否则，这是我们的最后一节。

1320
01:05:58,670 --> 01:06:01,070
所以这是非常高兴看到你们。

1321
01:06:01,070 --> 01:06:02,450
请采取更多的糖果。

1322
01:06:02,450 --> 01:06:05,390
和好运气在你的测验。

1323
01:06:05,390 --> 01:06:06,687