1
00:00:00,000 --> 00:00:08,090

2
00:00:08,090 --> 00:00:09,810
>> JASON HIRSCHHORN：欢迎光临，
每个人，至10周。

3
00:00:09,810 --> 00:00:15,130
这是一个令人兴奋的一周，因为
明天是测验1，我们将得到

4
00:00:15,130 --> 00:00:16,400
在第二个。

5
00:00:16,400 --> 00:00:21,770
今天在节中，我们将去
对一些资源进行测验，并

6
00:00:21,770 --> 00:00:24,890
然后，我会回答任何和所有
问题你们有。

7
00:00:24,890 --> 00:00:27,880
我们将最终结束于
一些实际问题。

8
00:00:27,880 --> 00:00:30,940
>> 我们可以花整款
回答问题。

9
00:00:30,940 --> 00:00:33,240
我们可以花整款
去在实践中的问题。

10
00:00:33,240 --> 00:00:36,890
我们只会扩大，以填补
空间和时间，我们有。

11
00:00:36,890 --> 00:00:40,590
>> 所以我每星期把这个名单了，但
这个星期是特别重要的。

12
00:00:40,590 --> 00:00:44,980
对于学习，如果你还没有
已经开始了，男孩哦。

13
00:00:44,980 --> 00:00:46,400
但希望你已经开始。

14
00:00:46,400 --> 00:00:50,710
和你正在经历的材料
这里列出的资源。

15
00:00:50,710 --> 00:00:54,300
我会极力推荐
许多这些。

16
00:00:54,300 --> 00:00:58,780
>> 特别是，课堂笔记是
非常重要和有益的。

17
00:00:58,780 --> 00:01:02,880
该study.cs50.net提供
在很多大底

18
00:01:02,880 --> 00:01:04,250
我们讨论的主题。

19
00:01:04,250 --> 00:01:07,810
它也有一些伟大的
实践问题。

20
00:01:07,810 --> 00:01:11,260
然后，谷歌是伟大的，太。

21
00:01:11,260 --> 00:01:12,360
我不知道你会用它来干什​​么。

22
00:01:12,360 --> 00:01:14,090
但使用谷歌，以及。

23
00:01:14,090 --> 00:01:16,680
>> 伸手给我，如果您有任何
问题，意见或疑虑。

24
00:01:16,680 --> 00:01:19,420
期待在审查会议
幻灯片从昨晚。

25
00:01:19,420 --> 00:01:21,540
或者，如果你有一段时间了，
观看视频。

26
00:01:21,540 --> 00:01:24,930
它们提供了很多有帮助的
材料和信息。

27
00:01:24,930 --> 00:01:29,730
并设法弥补，如果不是全部，很多的
我们已经讨论了，而且你的主题

28
00:01:29,730 --> 00:01:32,610
在测验可能会看到。

29
00:01:32,610 --> 00:01:35,590
>> 说到测验，即
将是明天。

30
00:01:35,590 --> 00:01:37,260
它拥有75分钟之久。

31
00:01:37,260 --> 00:01:40,740
你们中许多人正在服用它在1
点多了，有些人相当

32
00:01:40,740 --> 00:01:42,740
把它在5:30。

33
00:01:42,740 --> 00:01:45,300
当时你正在服用它和
你正在做它的位置，确保

34
00:01:45,300 --> 00:01:49,400
您签出该文档
在CS50.net主页。

35
00:01:49,400 --> 00:01:54,340
>> 请记住，你可以得到一个8 1/2
由11片随身携带。

36
00:01:54,340 --> 00:01:57,310
通常情况下，人们不使用此
表在所有的考试中。

37
00:01:57,310 --> 00:01:59,740
不过说真的，这是一个令人难以置信
有用的学习工具。

38
00:01:59,740 --> 00:02:04,370
所以这片放在一起是什么
我花了大概三四个小时

39
00:02:04,370 --> 00:02:07,110
当我攻读CS50做什么，
这是很容易的最有帮助

40
00:02:07,110 --> 00:02:08,740
这样我可以学习的测验。

41
00:02:08,740 --> 00:02:10,949
所以，即使你有一些其他人的
学习指南来看待和

42
00:02:10,949 --> 00:02:14,740
作为参考使用，我强烈推荐
使自己的学习指南，把

43
00:02:14,740 --> 00:02:15,490
这些东西在一起。

44
00:02:15,490 --> 00:02:17,335
这确实能帮助你学习
所有的材料。

45
00:02:17,335 --> 00:02:20,270

46
00:02:20,270 --> 00:02:24,810
>> 最后但并非最不重要在本节中，
有一个明天的测验后，

47
00:02:24,810 --> 00:02:25,940
更多讲座 - 

48
00:02:25,940 --> 00:02:26,960
下周一。

49
00:02:26,960 --> 00:02:30,430
还有一节，没有未来
周二感恩节前，但

50
00:02:30,430 --> 00:02:31,630
周二之后。

51
00:02:31,630 --> 00:02:36,600
我们将一起开会作最后
再见了党和也做了一些很酷

52
00:02:36,600 --> 00:02:41,530
事情让你们感到兴奋
进一步研究在计算机科学。

53
00:02:41,530 --> 00:02:45,040
>> 还有一个多项目，多了一个
公平的，多一个hackathon。

54
00:02:45,040 --> 00:02:47,900
我们正在接近CS50年底，
这是令人兴奋的 - 

55
00:02:47,900 --> 00:02:50,950
而且，如果你像
我，有点难过。

56
00:02:50,950 --> 00:02:53,950
在我继续前进，没有任何人有
大约有任何疑问什么

57
00:02:53,950 --> 00:02:55,200
我们已经讨论了这么远吗？

58
00:02:55,200 --> 00:03:02,760

59
00:03:02,760 --> 00:03:08,730
>> 好了，好让我们在一些问题
您有测验和主题

60
00:03:08,730 --> 00:03:09,960
我们可能涵盖。

61
00:03:09,960 --> 00:03:11,540
所以这是一个列表，我放在一起。

62
00:03:11,540 --> 00:03:15,500
它绝不是详尽，但
希望能唤起你的记忆，如果你

63
00:03:15,500 --> 00:03:20,310
有任何关于这些问题的一些
主题，或者如果您有关于问题

64
00:03:20,310 --> 00:03:23,260
从测验练习题
在过去的几年。

65
00:03:23,260 --> 00:03:27,470
>> 我有几个问题，是
通过电子邮件发送给我，但我想暂缓

66
00:03:27,470 --> 00:03:29,490
那些一秒钟。

67
00:03:29,490 --> 00:03:34,570
没有任何人有任何疑问，
他们不明白的问题，

68
00:03:34,570 --> 00:03:38,100
答案他们不明白
让我们开始？

69
00:03:38,100 --> 00:03:39,520
阿维。

70
00:03:39,520 --> 00:03:41,585
>> 观众：你能随便去了
DOM和Ajax的真快？

71
00:03:41,585 --> 00:03:46,540
就像，我们需要知道或应该
了解他们的？

72
00:03:46,540 --> 00:03:49,750
>> JASON HIRSCHHORN：我要回答
通常这个问题，有什么事我

73
00:03:49,750 --> 00:03:52,100
需要了解特定主题X'

74
00:03:52,100 --> 00:03:55,280
因为我有一种感觉，你们中许多人
要问我，或者是

75
00:03:55,280 --> 00:03:56,570
好奇的。

76
00:03:56,570 --> 00:04:02,920
所以，在某种程度上，这一专题
涵盖演讲，或部分，或

77
00:04:02,920 --> 00:04:06,460
study.cs50.net，问题集，你
应该熟悉它。

78
00:04:06,460 --> 00:04:10,580
>> 所以，你不需要知道每一种类型
标签，是HTML中可用或

79
00:04:10,580 --> 00:04:15,950
每一种类型的属性或属性的
你可以给一些在CSS中。

80
00:04:15,950 --> 00:04:20,204
但是，如果你看到它在一个演讲的例子，
如果你看到它在一个问题

81
00:04:20,204 --> 00:04:23,290
集，你应该很熟悉
有了它，你看到特别的东西

82
00:04:23,290 --> 00:04:24,260
在演讲。

83
00:04:24,260 --> 00:04:28,510
所以我们讨论的文件
在对象模型中的位

84
00:04:28,510 --> 00:04:30,530
部分，更多的是在演讲。

85
00:04:30,530 --> 00:04:32,990
你应该很熟悉
有这么大的它。

86
00:04:32,990 --> 00:04:34,750
>> 而且你应该熟悉
AJAX到相同的程度。

87
00:04:34,750 --> 00:04:38,105
我们从来没有见过难以置信的先进或
阿贾克斯的复杂的例子，所以

88
00:04:38,105 --> 00:04:40,920
你不会被要求做
一些令人难以置信的复杂。

89
00:04:40,920 --> 00:04:45,180
但你可能会问，我怎么
使用jQuery做一个Ajax调用？

90
00:04:45,180 --> 00:04:47,350
这是你已经看到了一些东西
之前的时间，无论是在

91
00:04:47,350 --> 00:04:51,370
审查会议，并在讲座中，和
它的代码只有两个十岁上下行。

92
00:04:51,370 --> 00:04:53,190
>> 所以这是你应该
熟悉。

93
00:04:53,190 --> 00:04:55,550
但同样，对于所有这些主题，
如果你已经看到了

94
00:04:55,550 --> 00:04:59,220
之前，它是公平的游戏。

95
00:04:59,220 --> 00:05:01,540
我们可能会问你 - 很明显，我们是
要问你的事情你

96
00:05:01,540 --> 00:05:02,340
以前没有见过的。

97
00:05:02,340 --> 00:05:04,240
编码的东西你有没有
以前见过。

98
00:05:04,240 --> 00:05:06,570
这并不是说你有没有
看到解决工具

99
00:05:06,570 --> 00:05:08,120
这个问题之前。

100
00:05:08,120 --> 00:05:09,200
你已经看到了这些工具。

101
00:05:09,200 --> 00:05:11,160
>> 例如，在测试1，如果
你需要编写strlen的。

102
00:05:11,160 --> 00:05:12,790
我们以前没有编码的strlen。

103
00:05:12,790 --> 00:05:14,980
但你知道如何使用for循环，
你知道如何，如果条件下使用。

104
00:05:14,980 --> 00:05:18,570
你知道如何用C编写的变量
这将是在这里同样的事情。

105
00:05:18,570 --> 00:05:22,350
你不会被要求做
你有没有看到过，但什么

106
00:05:22,350 --> 00:05:25,150
你可能会问到，像，放
东西一起以一种新颖的方式，或

107
00:05:25,150 --> 00:05:27,650
解决不同类型的问题。

108
00:05:27,650 --> 00:05:30,830
>> 对不起，这不是特定于您
的问题，但我不能回答有关

109
00:05:30,830 --> 00:05:34,390
每一个话题你
做或不需要知道。

110
00:05:34,390 --> 00:05:36,830
但同时，对不起，这最后的事情。

111
00:05:36,830 --> 00:05:42,900
我们花了显著更多的时间
在链接列表比我们对阿贾克斯。

112
00:05:42,900 --> 00:05:46,160
你没有在问题集中使用Ajax。

113
00:05:46,160 --> 00:05:48,510
其中所述中心功能
问题设置了链接列表。

114
00:05:48,510 --> 00:05:50,370
我们花了很多时间在讲座
和使用它部分。

115
00:05:50,370 --> 00:05:57,080
>> 所以，赔率是链接列表将拿出更多
经常在测验比阿贾克斯的意志。

116
00:05:57,080 --> 00:06:00,390
或问题不得不与链接
名单将是值得更多的积分。

117
00:06:00,390 --> 00:06:03,520
所以，你可以肯定聚焦和窄
在东西比较多

118
00:06:03,520 --> 00:06:06,720
可能是因为我们要拿出
花更多的时间在他们身上。

119
00:06:06,720 --> 00:06:08,700
>> 确定没有别的问题？

120
00:06:08,700 --> 00:06:09,890
是啊。

121
00:06:09,890 --> 00:06:13,660
>> 观众：我们可以走了过来使用
在JavaScript中的匿名函数？

122
00:06:13,660 --> 00:06:17,140
我是有一点困惑了。

123
00:06:17,140 --> 00:06:20,180
>> JASON HIRSCHHORN：那么在JavaScript  - 

124
00:06:20,180 --> 00:06:24,400
我试图想我怎么样
可以写这样的 - 

125
00:06:24,400 --> 00:06:27,590
让我们实际打开了这个代码。

126
00:06:27,590 --> 00:06:31,830

127
00:06:31,830 --> 00:06:36,030
所以这是代码的最后一周，我们做到了。

128
00:06:36,030 --> 00:06:41,400
和你以前，如果你看到了这
曾在这里一节的最后一周。

129
00:06:41,400 --> 00:06:43,180
或者你已经看到的东西
之前与此类似。

130
00:06:43,180 --> 00:06:44,800
>> 但你可以看看这个第一道防线。

131
00:06:44,800 --> 00:06:46,950
这是你如何开始 - 

132
00:06:46,950 --> 00:06:48,010
大家以前也见过这个。

133
00:06:48,010 --> 00:06:51,930
如果你想要把一些JavaScript代码，
你把它放在这里面，假设

134
00:06:51,930 --> 00:06:53,520
您正在使用JQuery。

135
00:06:53,520 --> 00:06:56,940
这是说，什么也不做
直到文件的加载。

136
00:06:56,940 --> 00:06:59,940
>> 然后，简略的，你看这里
我们正在做这样的事情 - 

137
00:06:59,940 --> 00:07:02,560
功能开括号，括号封闭。

138
00:07:02,560 --> 00:07:05,250
因此，我们没有给这个
函数的名称。

139
00:07:05,250 --> 00:07:09,160
我们不会定义这个函数
应该运行，然后

140
00:07:09,160 --> 00:07:10,830
说它是一堆倍。

141
00:07:10,830 --> 00:07:15,140
我们只是说这个文件
已经接受一个函数。

142
00:07:15,140 --> 00:07:16,690
一对夫妇的事情要做。

143
00:07:16,690 --> 00:07:20,670
>> 我们不想花时间
给它一个名称，或将其保存为

144
00:07:20,670 --> 00:07:21,650
永久。

145
00:07:21,650 --> 00:07:24,150
我们只是想运行一些事情。

146
00:07:24,150 --> 00:07:27,500
因此，一个匿名函数排序
的服务的目的。

147
00:07:27,500 --> 00:07:30,280
如果你不打算使用的东西
一遍又一遍，所以你不需要

148
00:07:30,280 --> 00:07:32,420
给它一个名字 - 你只是
想一次使用它 - 

149
00:07:32,420 --> 00:07:36,720
你只说功能，
例如，在这种情况下，你只是

150
00:07:36,720 --> 00:07:38,280
定义的东西，
你可以给一个名称。

151
00:07:38,280 --> 00:07:40,920
>> 喜欢，我们可以拉这个功能了
并给它一个名称，然后调用

152
00:07:40,920 --> 00:07:41,760
在这里发挥作用。

153
00:07:41,760 --> 00:07:44,270
但是，我们并不需要，因为我们不
不想浪费时间给它一个名称或

154
00:07:44,270 --> 00:07:46,240
浪费的东西在我们的名称空间。

155
00:07:46,240 --> 00:07:47,530
而且你会看到很多。

156
00:07:47,530 --> 00:07:52,810
例如，我们看到了很多在这
代码，但是你以前见过这个时

157
00:07:52,810 --> 00:07:54,010
你点击的东西 - 

158
00:07:54,010 --> 00:07:55,980
运行此类型的代码。

159
00:07:55,980 --> 00:07:59,850
>> 我们可以定义我们想要的代码
运行时点击的，在这种情况下，

160
00:07:59,850 --> 00:08:03,450
这个ID，作为一个单独的函数
然后运行该功能。

161
00:08:03,450 --> 00:08:07,940
但在这种情况下，我们只是跳绳
该步骤和在这里将它移入和

162
00:08:07,940 --> 00:08:10,340
只是一切定义
我们希望发生的，并

163
00:08:10,340 --> 00:08:12,450
不给它一个名字。

164
00:08:12,450 --> 00:08:15,550
这仍然可能没有
回答你的问题。

165
00:08:15,550 --> 00:08:15,960
>> 观众：不是，它的作用。

166
00:08:15,960 --> 00:08:18,290
我的意思是，我想我只是真的不
知道为什么它会是一个

167
00:08:18,290 --> 00:08:20,800
功能可言，虽然。

168
00:08:20,800 --> 00:08:21,590
因为它没有真正被调用。

169
00:08:21,590 --> 00:08:23,170
它并没有真正有一个名字。

170
00:08:23,170 --> 00:08:25,510
>> JASON HIRSCHHORN：这是在一个函数
感，它的一系列步骤，

171
00:08:25,510 --> 00:08:28,460
就像你把一个函数。

172
00:08:28,460 --> 00:08:29,970
然后这就是为什么我们称之为
它的匿名函数。

173
00:08:29,970 --> 00:08:30,815
我们不打算给它一个名字。

174
00:08:30,815 --> 00:08:33,159
我们不会浪费尝试
以它命名的，但我们可以。

175
00:08:33,159 --> 00:08:34,890
>> 匿名函数，你
总是可以给一个名称。

176
00:08:34,890 --> 00:08:37,620
因此，举例来说，这段代码就在这里，
我们可以把这段代码里面

177
00:08:37,620 --> 00:08:39,929
函数，然后调用
此功能在这里。

178
00:08:39,929 --> 00:08:41,600
相反，我们说，我们不打算
打扰了。

179
00:08:41,600 --> 00:08:44,390
我们只是去写
这一切就在这里。

180
00:08:44,390 --> 00:08:49,840
>> 这就像有时当你正在写
四回路用C  - 你们

181
00:08:49,840 --> 00:08:51,630
之前已经看到这一点 - 也许你
通过forloop迭代

182
00:08:51,630 --> 00:08:53,090
进入i等于0。

183
00:08:53,090 --> 00:08:54,830
I小于strlen的。

184
00:08:54,830 --> 00:08:59,520
否则你会通过一些
数组，你可以保存数组

185
00:08:59,520 --> 00:09:01,580
索引i中的一些变量。

186
00:09:01,580 --> 00:09:02,830
并使用该变量。

187
00:09:02,830 --> 00:09:06,550
所以，你不需要重写数组
支架我一遍又一遍又一遍。

188
00:09:06,550 --> 00:09:08,160
>> 而这有点像
一个虚拟变量。

189
00:09:08,160 --> 00:09:10,790
这不是服务于很多其他用途，
使你的代码有点清洁

190
00:09:10,790 --> 00:09:12,120
并且更容易阅读。

191
00:09:12,120 --> 00:09:13,290
类似的功能在这里。

192
00:09:13,290 --> 00:09:15,665
只是使它更容易一点，但
在功能上没有区别。

193
00:09:15,665 --> 00:09:18,620

194
00:09:18,620 --> 00:09:19,330
这是否回答你的问题？

195
00:09:19,330 --> 00:09:19,970
>> 观众：是的。

196
00:09:19,970 --> 00:09:20,720
>> JASON HIRSCHHORN：OK。

197
00:09:20,720 --> 00:09:21,880
马里奥？

198
00:09:21,880 --> 00:09:25,380
>> 观众：昨天他们往往把
函数括号事件。

199
00:09:25,380 --> 00:09:26,420
这是否意味着什么？

200
00:09:26,420 --> 00:09:30,500
或者是它的事情，比如
他们会做

201
00:09:30,500 --> 00:09:35,100
的document.ready功能的事件。

202
00:09:35,100 --> 00:09:37,130
>> JASON HIRSCHHORN：我们已经看到了这一点，
再次，这些都是小事情，

203
00:09:37,130 --> 00:09:39,590
也许我不想
花太多时间。

204
00:09:39,590 --> 00:09:43,200
因为有时候我不希望人们
得到吓坏了，他们有没有

205
00:09:43,200 --> 00:09:44,220
听到这些事情那么多。

206
00:09:44,220 --> 00:09:46,200
但是，我们讨论了一些
事件处理程序。

207
00:09:46,200 --> 00:09:50,360
所以有事，然后
这个功能被执行。

208
00:09:50,360 --> 00:09:53,210
然后，我们也想知道
关于一些细节是什么

209
00:09:53,210 --> 00:09:54,450
在发生此事件。

210
00:09:54,450 --> 00:09:55,730
>> 所以想回习题集4。

211
00:09:55,730 --> 00:09:58,390
这可能是最简单的方式
明白打出来。

212
00:09:58,390 --> 00:09:59,740
有一些代码 - 

213
00:09:59,740 --> 00:10:01,980
就像一个事件会发生，但
事件可能意味着很多东西。

214
00:10:01,980 --> 00:10:06,240
如果可能意味着鼠标被点击时，它
可能意味着你打箭头键，等。

215
00:10:06,240 --> 00:10:07,190
等等，等等。

216
00:10:07,190 --> 00:10:09,800
>> 但是，这一切都保存在这个通用
东西叫做事件。

217
00:10:09,800 --> 00:10:12,340
然后我们就可以说，是
本次活动这件事情？

218
00:10:12,340 --> 00:10:13,640
或者这是事件这件事情？

219
00:10:13,640 --> 00:10:15,500
或者，什么样的事
与该事件？

220
00:10:15,500 --> 00:10:18,660
所以这就是为什么您创建的变量
那里保存额外的信息

221
00:10:18,660 --> 00:10:21,420
关于究竟发生了什么的
你会想

222
00:10:21,420 --> 00:10:24,840
利用在该功能。

223
00:10:24,840 --> 00:10:28,200
但同样，这可能是一个
是超级不那么重要的东西

224
00:10:28,200 --> 00:10:29,450
熟悉。

225
00:10:29,450 --> 00:10:31,470

226
00:10:31,470 --> 00:10:36,110
>> 好了，有什么其他问题才有人
已经或者绊脚石，他们已经

227
00:10:36,110 --> 00:10:37,360
在审查遇到过吗？

228
00:10:37,360 --> 00:10:41,260

229
00:10:41,260 --> 00:10:42,510
我们将回到那个列表。

230
00:10:42,510 --> 00:10:52,550

231
00:10:52,550 --> 00:10:56,080
在练习测验怎么样，如果
人们已经采取了那些已经？

232
00:10:56,080 --> 00:10:59,110
什么是一些问题
绊倒你们了？

233
00:10:59,110 --> 00:11:08,970

234
00:11:08,970 --> 00:11:12,720
我知道一个事实，去年的
测验真的很难。

235
00:11:12,720 --> 00:11:15,670
>> 观众：你能解释一下
SQL注入攻击是什么？

236
00:11:15,670 --> 00:11:18,970
>> JASON HIRSCHHORN：好，太好了。

237
00:11:18,970 --> 00:11:20,440
所以我们谈到这一点。

238
00:11:20,440 --> 00:11:22,050
有关于安全的讲座。

239
00:11:22,050 --> 00:11:25,670
再次，正如我刚才所说，
这是一个在一边。

240
00:11:25,670 --> 00:11:30,010
但你会在测验受挫
当你读了一些小二点

241
00:11:30,010 --> 00:11:33,040
的问题，你像，当
我曾经学来的？

242
00:11:33,040 --> 00:11:35,560
>> 所有这些东西在那些讲座
你你需要的没想到

243
00:11:35,560 --> 00:11:38,290
知道，或者你可以粉饰，因为
他们没有做的

244
00:11:38,290 --> 00:11:41,860
习题集，这些将有可能
再上来的测验。

245
00:11:41,860 --> 00:11:45,030
所以，酷，有趣的东西，你只是
以为大卫告诉你来

246
00:11:45,030 --> 00:11:49,070
享受，他告诉你你来
享受，并让你仅仅是超级

247
00:11:49,070 --> 00:11:50,550
对学习充满兴趣的一切
有学习

248
00:11:50,550 --> 00:11:51,670
关于计算机科学。

249
00:11:51,670 --> 00:11:53,680
那些东西也拿出了上测验。

250
00:11:53,680 --> 00:11:56,440
所以，即使是没有这些小东西
直接关系到您的问题

251
00:11:56,440 --> 00:11:59,630
设置，如你们所熟悉的
测验0，可能会冒出来。

252
00:11:59,630 --> 00:12:01,530
这是一个很好的例子
的东西。

253
00:12:01,530 --> 00:12:10,140
>> 因此，一个SQL注入攻击是当你
从用户获得一些信息和

254
00:12:10,140 --> 00:12:15,090
你想用它插入到一个表
SQL INSERT语句，但你

255
00:12:15,090 --> 00:12:17,680
没有净化输入
提前。

256
00:12:17,680 --> 00:12:21,560
所以，很明显，我们已经看到了
SQL语句。

257
00:12:21,560 --> 00:12:22,810
我就打开了 - 

258
00:12:22,810 --> 00:12:25,590

259
00:12:25,590 --> 00:12:26,840
让我们去 - 

260
00:12:26,840 --> 00:12:31,290

261
00:12:31,290 --> 00:12:31,960
我们会去检讨 - 

262
00:12:31,960 --> 00:12:35,180
我认为，谁支付呢？

263
00:12:35,180 --> 00:12:36,350
我觉得Samala做到了。

264
00:12:36,350 --> 00:12:39,292
所以我们可以得到 - 

265
00:12:39,292 --> 00:12:41,270
>> 观众：你在哪里找到呢？

266
00:12:41,270 --> 00:12:44,990
>> JASON HIRSCHHORN：所以，如果你去
CS50.net，测验，然后你就可以

267
00:12:44,990 --> 00:12:47,170
翻阅过，并得到滑梯
从审查会议。

268
00:12:47,170 --> 00:12:49,860
但你可以看到这是一个很好的例子
的SQL注入攻击。

269
00:12:49,860 --> 00:12:53,690
我们从用户处获得的一些信息
他们给我们一个字符串，然后我们

270
00:12:53,690 --> 00:12:55,780
要插入的字符串
到数据库中。

271
00:12:55,780 --> 00:12:59,780
一般来说，我们要消毒的
输入，表示有一些

272
00:12:59,780 --> 00:13:01,050
字符是危险的。

273
00:13:01,050 --> 00:13:04,000
>> 例如，在SQL字符串，
这些报价 - 

274
00:13:04,000 --> 00:13:05,000
单引号或双引号 - 

275
00:13:05,000 --> 00:13:05,620
意味着什么。

276
00:13:05,620 --> 00:13:08,380
他们的意思是在这里结束这个字符串。

277
00:13:08,380 --> 00:13:13,090
所以，如果用户给你一个
或双引号，他们可能是

278
00:13:13,090 --> 00:13:18,970
试图绊倒你的SQL查询，
插入一些不好的东西进去。

279
00:13:18,970 --> 00:13:23,130
如果他们这样做，他们可以得到
你的数据库的控制权，或做一些

280
00:13:23,130 --> 00:13:24,760
东西，你不希望他们做的。

281
00:13:24,760 --> 00:13:28,300
>> 所以这就是为什么每当我们需要的SQL
查询，我们净化输入之前

282
00:13:28,300 --> 00:13:31,090
将其放入数据库中，这
意味着我们逃避这些字符。

283
00:13:31,090 --> 00:13:32,590
我们将讨论，在第二。

284
00:13:32,590 --> 00:13:35,820
不过长话短说，SQL注入
攻击是，如果你不这样做 - 

285
00:13:35,820 --> 00:13:39,760
如果你不把输入的护理
他们给了你把你的前

286
00:13:39,760 --> 00:13:46,830
数据库，他们可以，你下来看看
在这里，运行查询，其实 - 

287
00:13:46,830 --> 00:13:52,470
他们把他们的代码到这里，并
这个选择线下这里将选择

288
00:13:52,470 --> 00:13:56,360
一切从表姑
什么是给定的密码。

289
00:13:56,360 --> 00:13:58,960
因为你有1或等于1。

290
00:13:58,960 --> 00:14:02,750
>> 所以基本上，长话短说，
一种方法来接管数据库。

291
00:14:02,750 --> 00:14:07,570
的问题，那么，对于你们，是
凡在p设置7你消毒所有

292
00:14:07,570 --> 00:14:10,010
输入您的SQL查询？

293
00:14:10,010 --> 00:14:11,230
在哪里这一步发生的呢？

294
00:14:11,230 --> 00:14:14,150
你在哪里防止SQL注入
发生用p袭击设置7？

295
00:14:14,150 --> 00:14:20,100

296
00:14:20,100 --> 00:14:20,490
是啊。

297
00:14:20,490 --> 00:14:21,870
>> 观众：地穴？

298
00:14:21,870 --> 00:14:23,120
>> JASON HIRSCHHORN：所以它不是隐窝。

299
00:14:23,120 --> 00:14:52,360

300
00:14:52,360 --> 00:14:55,380
我们没有让你这样做的这个
特别是设置的问题，但它发生

301
00:14:55,380 --> 00:14:58,190
在查询功能。

302
00:14:58,190 --> 00:15:00,930
实际上，我们写了你，
我们花了照顾

303
00:15:00,930 --> 00:15:03,040
消毒的投入为您服务。

304
00:15:03,040 --> 00:15:07,790
但在过去的几年中，学生有
上键入他们自己的输入。

305
00:15:07,790 --> 00:15:10,020
IN P组7，很多你 - 

306
00:15:10,020 --> 00:15:11,270
让我打开另外一个文件。

307
00:15:11,270 --> 00:15:18,530

308
00:15:18,530 --> 00:15:22,590
>> 所以，你会发现在这里有很多
人，在问题设置7，没叫

309
00:15:22,590 --> 00:15:25,240
此功能对字符串。

310
00:15:25,240 --> 00:15:27,880
这个函数，用htmlspecialchars，
再次 - 

311
00:15:27,880 --> 00:15:31,410
该字符串可能有一些东西
在HTML中是指别的。

312
00:15:31,410 --> 00:15:36,160
像一个大括号，方，或者角度
支架意味着什么在HTML中。

313
00:15:36,160 --> 00:15:38,980
>> 所以，如果你打印出来的
屏幕或者如果你只是采取和

314
00:15:38,980 --> 00:15:42,260
打印出你的HTML，这可能
做一些你不希望。

315
00:15:42,260 --> 00:15:45,180
所以用htmlspecialchars越过所有那些
有特殊字符

316
00:15:45,180 --> 00:15:47,030
会议和逃脱他们。

317
00:15:47,030 --> 00:15:51,450
因此，它被打印出来的文字
你想看到的，而不是

318
00:15:51,450 --> 00:15:53,280
搞砸了你的HTML。

319
00:15:53,280 --> 00:15:55,040
我们在标题中所谓的功能。

320
00:15:55,040 --> 00:15:57,390
和很多人忘了
在程序中调用该函数

321
00:15:57,390 --> 00:15:58,700
你在写代码。

322
00:15:58,700 --> 00:16:03,970
>> 因此，举例来说，如果一只股票名称有一个
在它的角括号，你忘了

323
00:16:03,970 --> 00:16:06,675
调用这个函数，这个角度
支架可能已经揭去什么

324
00:16:06,675 --> 00:16:08,250
你的HTML的样子。

325
00:16:08,250 --> 00:16:11,810
但调用这个函数将难逃
该所以实际打印出来作为一个

326
00:16:11,810 --> 00:16:15,870
尖括号并不会抛出
关闭你的HTML代码。

327
00:16:15,870 --> 00:16:18,760
>> 我们已经看到了同样的原因，有时，
在双引号前斜线

328
00:16:18,760 --> 00:16:22,310
printf的线路，因为我们不希望
双引号下来的字符串。

329
00:16:22,310 --> 00:16:24,050
我们想打印出来
输出到屏幕上。

330
00:16:24,050 --> 00:16:26,920
所以，这一切是同样的想法。

331
00:16:26,920 --> 00:16:28,260
这是否回答你的问题？

332
00:16:28,260 --> 00:16:31,529

333
00:16:31,529 --> 00:16:33,870
>> 种类：受众。

334
00:16:33,870 --> 00:16:35,300
>> JASON HIRSCHHORN：你
有一个跟进？

335
00:16:35,300 --> 00:16:43,252
>> 观众：我猜的SQL注入
攻击都有做呢？

336
00:16:43,252 --> 00:16:45,720
我不知道如何
这两者是相关的。

337
00:16:45,720 --> 00:16:47,610
为什么你会做specialChars中？

338
00:16:47,610 --> 00:16:51,200
>> JASON HIRSCHHORN：好的，那么在SQL
当你注入注入攻击

339
00:16:51,200 --> 00:16:59,180
一些恶意的字符串到别人的
程序，他们只是把它和运行

340
00:16:59,180 --> 00:17:01,230
用字符串的SQL查询
你给了他们。

341
00:17:01,230 --> 00:17:04,220
正如你所看到这儿，那
可能是有问题的。

342
00:17:04,220 --> 00:17:07,480
所以你防止对的方法是
你把自己的字符串，他们给

343
00:17:07,480 --> 00:17:09,220
你 - 那么这个字符串就在这里 - 

344
00:17:09,220 --> 00:17:11,240
你消毒了。

345
00:17:11,240 --> 00:17:14,305
你逃避所有的事情，
是潜在的问题。

346
00:17:14,305 --> 00:17:18,626
所以，你不理解他们的东西
这意味着什么。

347
00:17:18,626 --> 00:17:23,390
>> 以及与一个例子
HTML是这个功能。

348
00:17:23,390 --> 00:17:26,060
所以它在这里同样的想法。

349
00:17:26,060 --> 00:17:27,579
而我只是向您展示其他
当你已经实例

350
00:17:27,579 --> 00:17:29,030
以前见过这样的想法。

351
00:17:29,030 --> 00:17:33,913
付印前逃逸用户输入
它的屏幕还是把它

352
00:17:33,913 --> 00:17:36,782
里面的SQL语句。

353
00:17:36,782 --> 00:17:40,790
>> 因此，在这种情况下，用户：观众
是搞乱与编程。

354
00:17:40,790 --> 00:17:41,240
>> JASON HIRSCHHORN：是的。

355
00:17:41,240 --> 00:17:44,800
与所有这些安全攻击，
这总是一般的用户，或

356
00:17:44,800 --> 00:17:47,470
一个人，正试图一塌糊涂
与你的程序员。

357
00:17:47,470 --> 00:17:51,038
而这些办法可以
防止对他们。

358
00:17:51,038 --> 00:17:54,280
>> 观众：所以，我有一个问题
关于杂凑函数。

359
00:17:54,280 --> 00:17:59,340
在测验1自2011年，有两个
关于片面哈希值的问题。

360
00:17:59,340 --> 00:18:02,540
我只是想知道
这是什么意思。

361
00:18:02,540 --> 00:18:03,660
>> JASON HIRSCHHORN：OK，这测验？

362
00:18:03,660 --> 00:18:03,770
2011？

363
00:18:03,770 --> 00:18:04,705
>> 观众：是啊。

364
00:18:04,705 --> 00:18:06,720
>> 观众：测验1？

365
00:18:06,720 --> 00:18:08,620
>> 观众：[听不清]。

366
00:18:08,620 --> 00:18:09,940
这就像一个散列密码。

367
00:18:09,940 --> 00:18:12,220
这不是把事情 - 

368
00:18:12,220 --> 00:18:13,440
>> JASON HIRSCHHORN：什么页面呢？

369
00:18:13,440 --> 00:18:15,720
>> 观众：我认为这是
9或10，或两者。

370
00:18:15,720 --> 00:18:16,720
>> JASON HIRSCHHORN：好吧，
继续前进，柯特。

371
00:18:16,720 --> 00:18:17,780
你可以回答，而我们期待。

372
00:18:17,780 --> 00:18:19,540
>> 观众：我认为这是在说
关于散列密码。

373
00:18:19,540 --> 00:18:24,430
象，当有人输入密码，
你把它变成一个加密的东西。

374
00:18:24,430 --> 00:18:27,395
这是密码散列，这是
从散列函数不同的是

375
00:18:27,395 --> 00:18:30,900
把东西放到一个哈希表。

376
00:18:30,900 --> 00:18:31,610
>> JASON HIRSCHHORN：让我们来看看。

377
00:18:31,610 --> 00:18:33,930
让我拉他们
给出的答案。

378
00:18:33,930 --> 00:18:35,440
然后我们将通过它走。

379
00:18:35,440 --> 00:18:42,430

380
00:18:42,430 --> 00:18:45,400
>> 所以简略的给了一个很好的例子
一个单向散列。

381
00:18:45,400 --> 00:18:48,800
当我们以前看到这一点，我们
取密码并开启 - 

382
00:18:48,800 --> 00:18:53,040
请记住，在p将7，有人可能
有一个密码，这只是密码，

383
00:18:53,040 --> 00:18:55,300
但后来它被加密成
一些很长的事情。

384
00:18:55,300 --> 00:18:59,830
单向散列意味着它是非常容易
从一条路可以走其他的，但

385
00:18:59,830 --> 00:19:02,800
它很难从去
另一种方式回来。

386
00:19:02,800 --> 00:19:05,230
>> 所以你知道，当你检查
人的密码的问题

387
00:19:05,230 --> 00:19:08,820
设置7，你会拿自己 - 

388
00:19:08,820 --> 00:19:11,953
因此，举例来说，说他们想
更改他们的密码，你问他们

389
00:19:11,953 --> 00:19:13,130
他们的旧密码。

390
00:19:13,130 --> 00:19:13,910
你把自己的旧密码。

391
00:19:13,910 --> 00:19:15,150
你加密了。

392
00:19:15,150 --> 00:19:19,240
然后比较了两种加密
而不是unencrypting原

393
00:19:19,240 --> 00:19:20,780
之一，因为它是真正
难走那条路。

394
00:19:20,780 --> 00:19:27,070

395
00:19:27,070 --> 00:19:28,035
是啊。

396
00:19:28,035 --> 00:19:31,430
>> 观众：如何深入我们不
的telnet理解必须是？

397
00:19:31,430 --> 00:19:34,870

398
00:19:34,870 --> 00:19:41,360
>> JASON HIRSCHHORN：如果有人提到
在简短的演讲，只是一个短暂的

399
00:19:41,360 --> 00:19:43,260
理解。

400
00:19:43,260 --> 00:19:45,585
再次，回到答案
为AVI的问题 - 

401
00:19:45,585 --> 00:19:48,260

402
00:19:48,260 --> 00:19:50,430
在更多的事情上来，就越有可能
它是你必须要超

403
00:19:50,430 --> 00:19:51,530
熟悉他们。

404
00:19:51,530 --> 00:19:54,730
如果他们来了才在演讲中，
这只是一个地方。

405
00:19:54,730 --> 00:19:57,180
但是，如果他们拿出在讲座中，段，
和问题设置，那么你

406
00:19:57,180 --> 00:19:58,710
大概得超
熟悉他们。

407
00:19:58,710 --> 00:20:01,320

408
00:20:01,320 --> 00:20:03,960
>> 所以，我有一个问题，从
早期有关 - 

409
00:20:03,960 --> 00:20:06,950
IS是2010年秋季 - 

410
00:20:06,950 --> 00:20:08,520
测验1，让我们拉起 - 

411
00:20:08,520 --> 00:20:17,390

412
00:20:17,390 --> 00:20:21,790
这个问题在栈和队列，
我们确实花了时间的公平一点点

413
00:20:21,790 --> 00:20:23,720
讲座中谈到，即使
虽然我们并没有真正

414
00:20:23,720 --> 00:20:26,020
曾经击中了它的部分。

415
00:20:26,020 --> 00:20:33,190
所以这个问题是给你一个系列
的命令，并要求你什么

416
00:20:33,190 --> 00:20:35,560
被印刷在这种情况下。

417
00:20:35,560 --> 00:20:40,180
所以这是一个完全合理的问题
可能被问的你

418
00:20:40,180 --> 00:20:43,090
家伙，然后你们应该
能够回答它。

419
00:20:43,090 --> 00:20:50,020
>> 那么，为什么你不看它30
秒，然后如果有人想

420
00:20:50,020 --> 00:20:52,140
建议答案给我，
然后我们将通过它走。

421
00:20:52,140 --> 00:21:22,590

422
00:21:22,590 --> 00:21:24,235
好吧，谁拥有一个答案
问题27？

423
00:21:24,235 --> 00:21:31,740

424
00:21:31,740 --> 00:21:33,860
是啊。

425
00:21:33,860 --> 00:21:40,250
>> 观众：它是1，2，3，3？

426
00:21:40,250 --> 00:21:40,780
>> JASON HIRSCHHORN：这是正确的。

427
00:21:40,780 --> 00:21:42,570
图27是1，2，3，3。

428
00:21:42,570 --> 00:21:44,510
所以，让我们来看看我们是如何走到这一点。

429
00:21:44,510 --> 00:21:48,930
>> 首先，我们要说，如果s
队列中的，得到印？

430
00:21:48,930 --> 00:21:53,360
所以q是先入先出。

431
00:21:53,360 --> 00:21:54,680
之前我们已经看到了。

432
00:21:54,680 --> 00:21:56,820
我们看到的人的图片
在苹果等待

433
00:21:56,820 --> 00:21:58,400
商店买一些产品。

434
00:21:58,400 --> 00:22:00,900
在是第一人
第一批人出来。

435
00:22:00,900 --> 00:22:02,940
在队列中的第一件事情
是第一个出来的东西。

436
00:22:02,940 --> 00:22:08,320
>> 所以，如果我们把东西放到一个队列中，
你推了1，那么我们弹出1。

437
00:22:08,320 --> 00:22:09,630
流行只是意味着冒了出来。

438
00:22:09,630 --> 00:22:11,080
在这种情况下，只取出来的东西。

439
00:22:11,080 --> 00:22:12,910
我们拿出第一
的事情，这是一个1。

440
00:22:12,910 --> 00:22:15,200
所以我们把我们的事情
打印下来在这里。

441
00:22:15,200 --> 00:22:18,110
这不再是我们的队列中。

442
00:22:18,110 --> 00:22:23,500
>> 然后我们推a 2和a 3，和
我们流行过的第一件事。

443
00:22:23,500 --> 00:22:25,030
再次，因为它是一个队列。

444
00:22:25,030 --> 00:22:33,320
所以，我们得到了一个2，那么我们就把另一
3，再次调用pop。

445
00:22:33,320 --> 00:22:34,980
我们的3是第一。

446
00:22:34,980 --> 00:22:40,940
>> 然后我们有一大堆的
其他的东西，调用pop。

447
00:22:40,940 --> 00:22:43,740
但同样，因为这是一个队列，
先入先出。

448
00:22:43,740 --> 00:22:45,980
我们拿出的第一件事情
这是以往任何时候都放进去。

449
00:22:45,980 --> 00:22:47,100
这是我们的3。

450
00:22:47,100 --> 00:22:50,060
并且，在这种情况下，我们也不用担心
所有其他的事情。

451
00:22:50,060 --> 00:22:51,310
所以这是，如果这是一个队列。

452
00:22:51,310 --> 00:22:58,917

453
00:22:58,917 --> 00:23:00,167
关于队列的任何问题吗？

454
00:23:00,167 --> 00:23:03,290

455
00:23:03,290 --> 00:23:04,040
>> 堆栈的不同。

456
00:23:04,040 --> 00:23:07,782
什么是我们拥有的缩写
对于理解一叠？

457
00:23:07,782 --> 00:23:08,750
>> 观众：后进先出。

458
00:23:08,750 --> 00:23:10,130
>> JASON HIRSCHHORN：后进先出法，我想。

459
00:23:10,130 --> 00:23:11,830
后进先出。

460
00:23:11,830 --> 00:23:15,630
因此，我们看到一个栈的实例
在一个食堂托盘。

461
00:23:15,630 --> 00:23:17,590
无论是托盘顶部
捡起。

462
00:23:17,590 --> 00:23:19,550
然后，如果新来的托盘
中，他们得到放在上面。

463
00:23:19,550 --> 00:23:21,070
然后无论是在
顶部捡起。

464
00:23:21,070 --> 00:23:24,010
因此，那些在底部托盘威力
在那里呆上一段时间。

465
00:23:24,010 --> 00:23:28,480
>> 在这种情况下，同样，我们将
得出了这一点。

466
00:23:28,480 --> 00:23:31,770
我们推进的，所以一
是排在第一位。

467
00:23:31,770 --> 00:23:32,790
而我们弹出的东西了。

468
00:23:32,790 --> 00:23:37,280
还有的只有一件事在那里，
所以我们移动1到这里。

469
00:23:37,280 --> 00:23:41,940
然后，我们把2和3
我们流行的东西了。

470
00:23:41,940 --> 00:23:43,650
>> 但同样，因为这是一个队列 - 

471
00:23:43,650 --> 00:23:45,010
或者这是一个堆栈，而 - 

472
00:23:45,010 --> 00:23:47,480
我们采取一切是最后一次。

473
00:23:47,480 --> 00:23:49,300
不管是在最后出来先。

474
00:23:49,300 --> 00:23:50,890
和3是最后一次。

475
00:23:50,890 --> 00:23:56,110
所以我们把3出现了下滑，那么
我们把另外3我们

476
00:23:56,110 --> 00:23:57,360
再弹出的东西。

477
00:23:57,360 --> 00:23:59,990

478
00:23:59,990 --> 00:24:05,710
最后，我们将在4，5，
6，和7，在这里我们弹出。

479
00:24:05,710 --> 00:24:09,060
并且因为它是一个栈，我们采取
无论是放在最后的，写

480
00:24:09,060 --> 00:24:10,240
下来这里。

481
00:24:10,240 --> 00:24:14,256
因此，我们最终以1，3，3，7。

482
00:24:14,256 --> 00:24:17,380

483
00:24:17,380 --> 00:24:21,380
没有任何人有任何的问题
堆栈或队列，或这个例子吗？

484
00:24:21,380 --> 00:24:27,540

485
00:24:27,540 --> 00:24:29,030
>> 确定。

486
00:24:29,030 --> 00:24:30,440
让我们回到主题列表中。

487
00:24:30,440 --> 00:24:32,510
不是这样的，这样一来。

488
00:24:32,510 --> 00:24:34,280
还有什么其他的问题人们有哪些？

489
00:24:34,280 --> 00:24:37,550

490
00:24:37,550 --> 00:24:39,480
>> 观众：我不知道有多么重要
这是，但我感到困惑的

491
00:24:39,480 --> 00:24:43,550
不同类型之间的差别
语言，如标记，编译，

492
00:24:43,550 --> 00:24:45,980
解释。

493
00:24:45,980 --> 00:24:46,750
>> JASON HIRSCHHORN：这是
一个很好的问题。

494
00:24:46,750 --> 00:24:50,500
我觉得这是比较重要，
让我们赶紧去了吧。

495
00:24:50,500 --> 00:24:56,850
我们已经看到了很大的语言至今都
C，PHP和JavaScript，在条款

496
00:24:56,850 --> 00:24:58,330
的编程语言。

497
00:24:58,330 --> 00:25:01,060
HTML，正如你所说，是不是
一种编程语言。

498
00:25:01,060 --> 00:25:02,260
这是一种标记语言。

499
00:25:02,260 --> 00:25:05,700
然后我们有CSS，这也是
不是一种编程语言。

500
00:25:05,700 --> 00:25:10,330
>> 我们也看到SQL中，这是不
一种编程语言要么。

501
00:25:10,330 --> 00:25:15,695
所以SQL允许你写
查询一个数据库。

502
00:25:15,695 --> 00:25:18,370

503
00:25:18,370 --> 00:25:20,140
HTML是一种标记语言。

504
00:25:20,140 --> 00:25:22,570
它定义了事物是如何构成的。

505
00:25:22,570 --> 00:25:26,250
和CSS可以让你的风格的东西。

506
00:25:26,250 --> 00:25:28,520
这可能是在多大程度上为你
需要了解这三个。

507
00:25:28,520 --> 00:25:32,920
但更有趣的数字
输出C，PHP之间的差异，

508
00:25:32,920 --> 00:25:34,320
和JavaScript。

509
00:25:34,320 --> 00:25:37,900
>> 因此，一个最大的不同，
正如你所说，是他们如何是

510
00:25:37,900 --> 00:25:40,550
编译，或任何
相当于是。

511
00:25:40,550 --> 00:25:42,580
所以C编译。

512
00:25:42,580 --> 00:25:43,950
我们将始终运行一个编译器。

513
00:25:43,950 --> 00:25:51,100
然后在那里是你的错误
当您运行C编译器？

514
00:25:51,100 --> 00:25:55,740
它在哪里告诉你
代码中的错误？

515
00:25:55,740 --> 00:25:57,860
你怎么知道有一个
在C语言代码中的错误？

516
00:25:57,860 --> 00:25:58,770
>> 观众：这表明你
在终端中。

517
00:25:58,770 --> 00:26:00,410
>> JASON HIRSCHHORN：这表明你在
终端为你编译。

518
00:26:00,410 --> 00:26:02,620
如果有错误，它
实际上不会编译它。

519
00:26:02,620 --> 00:26:04,830
所以，你知道，有右的错误
走，时间提前，然后再

520
00:26:04,830 --> 00:26:06,050
即使运行代码。

521
00:26:06,050 --> 00:26:10,010
>> 当然，您可能会遇到你的代码，
得到一个段错误，但那是

522
00:26:10,010 --> 00:26:12,350
可能是因为你没有
一些愚蠢的逻辑的事情。

523
00:26:12,350 --> 00:26:15,770
但随着技术的代码
所有正确的，可以运行。

524
00:26:15,770 --> 00:26:18,210
所以C代码被编译的时间提前。

525
00:26:18,210 --> 00:26:19,760
怎么样的PHP代码？

526
00:26:19,760 --> 00:26:21,430
在哪里在你的PHP代码中的错误？

527
00:26:21,430 --> 00:26:23,170
你怎么知道你有错误
在你的PHP代码？

528
00:26:23,170 --> 00:26:26,038

529
00:26:26,038 --> 00:26:28,430
>> 观众：运行时间？

530
00:26:28,430 --> 00:26:31,230
>> JASON HIRSCHHORN：是啊，当你
将运行它，您将运行

531
00:26:31,230 --> 00:26:32,180
在后面的PHP代码。

532
00:26:32,180 --> 00:26:33,300
然后你会显示一个画面。

533
00:26:33,300 --> 00:26:35,260
你可能会看到一些东西在上面，
但随后你会看到，像一些

534
00:26:35,260 --> 00:26:36,710
橙色，丑表。

535
00:26:36,710 --> 00:26:41,420
它会给你一个行号和
比方说，胡说，胡说，胡说，这东西

536
00:26:41,420 --> 00:26:42,400
没有工作。

537
00:26:42,400 --> 00:26:48,730
>> 所以PHP是一行一行
并在服务器上运行。

538
00:26:48,730 --> 00:26:52,380
然后，结果是
发送给您。

539
00:26:52,380 --> 00:26:53,340
大。

540
00:26:53,340 --> 00:26:56,410
在执行逐行服务器产品线
然后发送给你。

541
00:26:56,410 --> 00:26:59,010
如果有错误，它会发送
你的错误，但你可能有

542
00:26:59,010 --> 00:27:00,400
得到的时间提前一些东西。

543
00:27:00,400 --> 00:27:02,730
所以它的一些可能有工作，但
后来，一些东西可能没有

544
00:27:02,730 --> 00:27:03,890
没有奏效。

545
00:27:03,890 --> 00:27:04,600
>> 怎么样的JavaScript？

546
00:27:04,600 --> 00:27:06,065
你在哪里看到JavaScript错误？

547
00:27:06,065 --> 00:27:10,860

548
00:27:10,860 --> 00:27:12,870
P中设置8，当你得到一个
错误，你是怎么知道的？

549
00:27:12,870 --> 00:27:13,710
会在哪里出现呢？

550
00:27:13,710 --> 00:27:15,900
>> 观众：在控制台中，
在底部。

551
00:27:15,900 --> 00:27:17,650
>> JASON HIRSCHHORN：在
控制台上的底部。

552
00:27:17,650 --> 00:27:20,160
它还会给你
行号，它会

553
00:27:20,160 --> 00:27:21,330
显示在底部。

554
00:27:21,330 --> 00:27:24,320
与未执行的JavaScript
在服务器上。

555
00:27:24,320 --> 00:27:27,800
JavaScript最初被发送到你的电脑，
然后当它是时间来运行

556
00:27:27,800 --> 00:27:31,670
JavaScript中，JavaScript的是
由行上线运行

557
00:27:31,670 --> 00:27:33,410
客户端，就在你身边。

558
00:27:33,410 --> 00:27:35,570
没有服务器，客户端。

559
00:27:35,570 --> 00:27:37,690
>> 同样地，它是
通过线运行线路。

560
00:27:37,690 --> 00:27:40,630
然后当你将得到一个错误，
它会显示在底部。

561
00:27:40,630 --> 00:27:44,580
类似于PHP的，它的一些可能
执行，那么你可能会得到一个

562
00:27:44,580 --> 00:27:46,310
错误以后。

563
00:27:46,310 --> 00:27:49,910
>> 此外，有一点不像PHP的，如果
你得到了一个JavaScript错误 - 

564
00:27:49,910 --> 00:27:52,780
说你没有做正确的
对于一个警告框代码 - 

565
00:27:52,780 --> 00:27:55,800
你可以继续运行你的程序。

566
00:27:55,800 --> 00:27:58,180
该警告框是行不通的，但
你的程序将被罚款。

567
00:27:58,180 --> 00:28:00,490
只是也许该函数将失败。

568
00:28:00,490 --> 00:28:02,610
>> 因此，有一些最大
在如何将这些术语的区别

569
00:28:02,610 --> 00:28:09,230
语言，或如何编程代码
你写的是实际评估。

570
00:28:09,230 --> 00:28:11,970
也有在其他方面的差异
最大的区别 - 条款

571
00:28:11,970 --> 00:28:15,590
我们已经看到在变量方面
在不同的语言。

572
00:28:15,590 --> 00:28:19,660
所以，有谁能够给我一个差
变量之间

573
00:28:19,660 --> 00:28:20,910
在这三种语言？

574
00:28:20,910 --> 00:28:24,802

575
00:28:24,802 --> 00:28:25,770
是。

576
00:28:25,770 --> 00:28:27,130
>> 观众：在C中，他们
严格的类型。

577
00:28:27,130 --> 00:28:28,550
在另外两个，它们是
松散类型。

578
00:28:28,550 --> 00:28:30,040
>> JASON HIRSCHHORN：与
这是什么意思？

579
00:28:30,040 --> 00:28:31,775
>> 观众：那在C中，你必须声明
该变量的类型时，

580
00:28:31,775 --> 00:28:36,140
你声明的变量，
像interbool或char。

581
00:28:36,140 --> 00:28:36,990
>> JASON HIRSCHHORN：优秀。

582
00:28:36,990 --> 00:28:39,780
在C语言中，我们总是不得不把
一个类型的变量。

583
00:28:39,780 --> 00:28:41,360
我们不能真正混合类型。

584
00:28:41,360 --> 00:28:45,750
你不能做一个整数
加的字符串。

585
00:28:45,750 --> 00:28:48,760
但是，正如我们已经看到的这些其他
语言，你其实可以混合类型，

586
00:28:48,760 --> 00:28:51,230
你从来没有真正得给
什么类型，直到永远。

587
00:28:51,230 --> 00:28:53,905
>> 那么，我们如何知道的事情是变量
在PHP和JavaScript？

588
00:28:53,905 --> 00:28:57,120

589
00:28:57,120 --> 00:28:58,685
>> 观众：在PHP中，他们开始
用一个美元符号。

590
00:28:58,685 --> 00:29:00,810
在JavaScript中，当你声明
他们，你必须有一个酒吧。

591
00:29:00,810 --> 00:29:01,760
>> JASON HIRSCHHORN：对。

592
00:29:01,760 --> 00:29:03,535
所以在PHP中，他们开始
用一个美元符号。

593
00:29:03,535 --> 00:29:06,300
在JavaScript中，他们必须有吧，
虽然有时候他们实际上并不

594
00:29:06,300 --> 00:29:07,520
得有吧。

595
00:29:07,520 --> 00:29:09,240
但是，这是正确的。

596
00:29:09,240 --> 00:29:13,300
>> 所以这是一个很大的区别
之间的变量。

597
00:29:13,300 --> 00:29:16,140
我认为这些都是可能，关闭
顶我的头，两个最大

598
00:29:16,140 --> 00:29:19,250
这之间的差异
三种语言。

599
00:29:19,250 --> 00:29:20,594
但是，是的。

600
00:29:20,594 --> 00:29:24,720
>> 观众：和C变量的作用域
被限制在花括号

601
00:29:24,720 --> 00:29:27,760
当其他的，它只是喜欢，
它死了，如果是在只有一个功能，

602
00:29:27,760 --> 00:29:29,650
但除此之外，it's  - 

603
00:29:29,650 --> 00:29:30,240
>> JASON HIRSCHHORN：对。

604
00:29:30,240 --> 00:29:36,780
所以范围略有不同。作为
你还记得，大括号定义

605
00:29:36,780 --> 00:29:37,710
变量的范围。

606
00:29:37,710 --> 00:29:41,680
所以，如果有人在里面，如果定义
条件，这是一个内部循环，

607
00:29:41,680 --> 00:29:44,290
该变量只存在在那里。

608
00:29:44,290 --> 00:29:47,760
>> 在JavaScript中，如果一个变量被定义
内部的if条件 - 

609
00:29:47,760 --> 00:29:50,750
里面的for循环 - 它会存在
该函数，但它不会存在

610
00:29:50,750 --> 00:29:52,330
以外的功能。

611
00:29:52,330 --> 00:29:59,250
所以范围是一点点更灵活
在JavaScript和PHP。

612
00:29:59,250 --> 00:30:00,500
这回答这个问题？

613
00:30:00,500 --> 00:30:03,110

614
00:30:03,110 --> 00:30:04,635
好了，没有别的问题？

615
00:30:04,635 --> 00:30:07,260

616
00:30:07,260 --> 00:30:08,865
我们可以做四个多分钟
的问题，那么

617
00:30:08,865 --> 00:30:10,740
我们会跳进编码。

618
00:30:10,740 --> 00:30:12,645
>> 观众：我们可以进入阿贾克斯
并说说是什么吗？

619
00:30:12,645 --> 00:30:15,670

620
00:30:15,670 --> 00:30:17,800
>> JASON HIRSCHHORN：交谈后为AVI。

621
00:30:17,800 --> 00:30:19,170
他问这个问题前面。

622
00:30:19,170 --> 00:30:19,630
>> 观众：我的坏。

623
00:30:19,630 --> 00:30:20,880
>> JASON HIRSCHHORN：不用担心。

624
00:30:20,880 --> 00:30:22,740

625
00:30:22,740 --> 00:30:24,290
>> 观众：究竟什么是JSON？

626
00:30:24,290 --> 00:30:28,360

627
00:30:28,360 --> 00:30:28,900
>> JASON HIRSCHHORN：JSON是什么？

628
00:30:28,900 --> 00:30:29,930
什么是你的问题？

629
00:30:29,930 --> 00:30:31,350
>> 观众：刚才真的很快，
之间的差

630
00:30:31,350 --> 00:30:32,870
在PHP打印和回声。

631
00:30:32,870 --> 00:30:36,200

632
00:30:36,200 --> 00:30:38,490
>> JASON HIRSCHHORN：你为什么不谷歌
打印和回声之间的区别？

633
00:30:38,490 --> 00:30:40,670
细微的差别。

634
00:30:40,670 --> 00:30:42,020
不是什么大不了的事的。

635
00:30:42,020 --> 00:30:44,960
但你一定要google一下，
而且会给你一个很好的答案。

636
00:30:44,960 --> 00:30:46,910
>> JSON，可能更大的一笔交易。

637
00:30:46,910 --> 00:30:49,300
代表JavaScript对象表示法。

638
00:30:49,300 --> 00:30:51,865
而当我们已经看到的JSON被使用？

639
00:30:51,865 --> 00:30:55,110

640
00:30:55,110 --> 00:30:55,900
当你看到 - 

641
00:30:55,900 --> 00:30:57,400
为什么你甚至不知道这个词的JSON？

642
00:30:57,400 --> 00:30:59,140
当你看过了吗？

643
00:30:59,140 --> 00:31:02,200
>> 观众：当我们得到
股票行情融资。

644
00:31:02,200 --> 00:31:02,690
>> JASON HIRSCHHORN：所以你看到
当你获得了

645
00:31:02,690 --> 00:31:04,830
股票行情融资。

646
00:31:04,830 --> 00:31:07,340
又为什么你看到了吗？

647
00:31:07,340 --> 00:31:09,000
>> 观众：当我们检索
的所有信息，

648
00:31:09,000 --> 00:31:10,400
排在该格式。

649
00:31:10,400 --> 00:31:11,700
>> JASON HIRSCHHORN：所以你会得到 - 

650
00:31:11,700 --> 00:31:12,540
是的。

651
00:31:12,540 --> 00:31:13,020
来吧。

652
00:31:13,020 --> 00:31:15,210
>> 观众：[听不清]的信息
出的对象的？

653
00:31:15,210 --> 00:31:17,170
>> JASON HIRSCHHORN：无论那些
放在一起就是答案

654
00:31:17,170 --> 00:31:18,100
我们正在寻找。

655
00:31:18,100 --> 00:31:21,240
你想要的信息
这另一个网页。

656
00:31:21,240 --> 00:31:23,790
而你希望，当你
获取这些信息，这将是

657
00:31:23,790 --> 00:31:26,720
在某些类型的呈现给大家
标准化的格式。

658
00:31:26,720 --> 00:31:29,530
>> 每个人都可能是熟悉
用逗号分隔的值。

659
00:31:29,530 --> 00:31:32,970
您可以导出为Excel电子表格或
任何类型的电子表格作为一个列表

660
00:31:32,970 --> 00:31:34,540
逗号分隔值。

661
00:31:34,540 --> 00:31:37,370
和逗号分隔的所有
在不同的领域。

662
00:31:37,370 --> 00:31:38,780
JavaScript对象符号 - 

663
00:31:38,780 --> 00:31:39,440
JSON  - 

664
00:31:39,440 --> 00:31:43,540
是另一种类型的标准化的
物联网布局。

665
00:31:43,540 --> 00:31:49,010
这就是通常我们如何检索
从我们的Ajax查询的信息。

666
00:31:49,010 --> 00:31:51,770
>> 因此，在这种情况下，我们得到了它
从雅虎网站。

667
00:31:51,770 --> 00:31:53,600
他们返回的东西
我们在一个JSON对象。

668
00:31:53,600 --> 00:31:56,790
然后，我们知道，因为它是
一个标准，它是什么

669
00:31:56,790 --> 00:31:57,250
将会是什么样。

670
00:31:57,250 --> 00:32:00,760
因此，我们可以通过遍历数组
这是退还给我们，数组

671
00:32:00,760 --> 00:32:03,180
返回到我们的对象。

672
00:32:03,180 --> 00:32:07,770
>> 我们可能需要知道密钥，
但他们通常给你

673
00:32:07,770 --> 00:32:11,370
在该网站的文件时，
你想拿几个JSON

674
00:32:11,370 --> 00:32:12,170
标记他们。

675
00:32:12,170 --> 00:32:16,940
同样，你可以JSON
编码的对象。

676
00:32:16,940 --> 00:32:19,900
所以这是一个函数的JSON
强调编码。

677
00:32:19,900 --> 00:32:22,970
所以你可以采取一个对象，
你已经创建，JSON编码它，

678
00:32:22,970 --> 00:32:26,390
它传递的东西
否则，如果你想。

679
00:32:26,390 --> 00:32:30,770
和JSON解码也存在
类似的目的，或用于

680
00:32:30,770 --> 00:32:31,780
相反的目的。

681
00:32:31,780 --> 00:32:36,570
>> 观众：我们是否需要知道编码
哈希表和尝试？

682
00:32:36,570 --> 00:32:40,300
还是我们只是需要理解
他们是如何使用的，概念上？

683
00:32:40,300 --> 00:32:44,570
>> JASON HIRSCHHORN：那么，举起你的手
如果你没有对p哈希表中设置4

684
00:32:44,570 --> 00:32:46,920
带有链接列表。

685
00:32:46,920 --> 00:32:47,960
或p设置5。

686
00:32:47,960 --> 00:32:49,060
所以这是绝大多数人。

687
00:32:49,060 --> 00:32:50,390
p将5，6，谁知道。

688
00:32:50,390 --> 00:32:51,240
很久很久以前。

689
00:32:51,240 --> 00:32:54,140
>> 所以，你绝大多数做
哈希表与链接列表。

690
00:32:54,140 --> 00:32:56,525
而且因为这可能是更
常用的方法，因为我们花了

691
00:32:56,525 --> 00:32:59,460
大量的时间做链接列表和哈希
表，你也许应该

692
00:32:59,460 --> 00:33:02,600
非常熟悉如何编写代码
哈希表和链接列表。

693
00:33:02,600 --> 00:33:05,060
>> 如果你觉得回到了这个问题
设置，它是不是真的

694
00:33:05,060 --> 00:33:06,410
硬如您预期。

695
00:33:06,410 --> 00:33:08,120
并有少了很多
比你预期的代码。

696
00:33:08,120 --> 00:33:11,150

697
00:33:11,150 --> 00:33:14,650
我会说你应该知道如何
编写一个哈希表或链接列表。

698
00:33:14,650 --> 00:33:17,010
这并不是说你会问，
不一定，但你应该

699
00:33:17,010 --> 00:33:19,730
当然知道。

700
00:33:19,730 --> 00:33:21,860
>> 另外，如果你去翻过去的测验，
已经有很多

701
00:33:21,860 --> 00:33:26,450
关于编写功能上的问题
链接列表或双向链表。

702
00:33:26,450 --> 00:33:28,370
这似乎想出
每一年。

703
00:33:28,370 --> 00:33:31,940
右侧插入一个链接列表，右边
从链表中删除，用鼠标右键插入

704
00:33:31,940 --> 00:33:33,610
对于一个双向链表，等等。

705
00:33:33,610 --> 00:33:36,170
所以，我觉得挺舒服的
说你应该知道这一点。

706
00:33:36,170 --> 00:33:40,600
>> 对于尝试，我会说你应该
当然知道它是如何工作的，也许

707
00:33:40,600 --> 00:33:43,570
给一些伪代码如何
它的代码，并设置它。

708
00:33:43,570 --> 00:33:45,600
但它不会是最糟糕的事情
世界上，如果你不知道如何

709
00:33:45,600 --> 00:33:48,870
它在C代码这将是巨大的，如果你
知道如何编写代码在C，但我认为

710
00:33:48,870 --> 00:33:52,516
可能是伪代码试试看会
是你最需要的

711
00:33:52,516 --> 00:33:53,270
要知道一试。

712
00:33:53,270 --> 00:33:53,930
>> 观众：附加题？

713
00:33:53,930 --> 00:33:58,290
>> JASON HIRSCHHORN：而且用相同的，如果我们
进入二叉搜索树，你可能

714
00:33:58,290 --> 00:34:02,320
需要 - 你已经看到在过去，
我们已经做了很多 - 你知道如何

715
00:34:02,320 --> 00:34:03,380
二叉搜索树的作品。

716
00:34:03,380 --> 00:34:07,150
你或许应该能够
设置一个伪代码。

717
00:34:07,150 --> 00:34:10,510
但由于绝大多数人
没有这样做的问题

718
00:34:10,510 --> 00:34:13,880
集，我会说这是不太可能
重要的是你知道如何编写代码

719
00:34:13,880 --> 00:34:17,380
并成立了这样一棵树。

720
00:34:17,380 --> 00:34:19,679
>> 还有没有其他问题？

721
00:34:19,679 --> 00:34:23,234
另外，我们可以在整个问他们
因为我们经历了一些问题。

722
00:34:23,234 --> 00:34:27,170
好了，我们要继续前进。

723
00:34:27,170 --> 00:34:28,230
跳过该幻灯片现在。

724
00:34:28,230 --> 00:34:32,449
>> 发言的树，也就是第一
问题我已经为你们。

725
00:34:32,449 --> 00:34:34,270
因为这是一个问题。

726
00:34:34,270 --> 00:34:37,380
我会说这是极有可能你会
得到这样一个问题，在您的测验

727
00:34:37,380 --> 00:34:43,659
要求您编写一些类型的插入，
删除，查找，一类

728
00:34:43,659 --> 00:34:45,270
数据结构我们已经看到了。

729
00:34:45,270 --> 00:34:47,719
>> 需要达到的每一年，我们花了
这种大量的时间下半年

730
00:34:47,719 --> 00:34:50,270
学期要对这些数据类型。

731
00:34:50,270 --> 00:34:54,170
所以现在，我已经定义了一个节点
在二叉搜索树。

732
00:34:54,170 --> 00:34:58,490
而我希望你做的是给定的
启动一个二叉搜索树

733
00:34:58,490 --> 00:35:05,450
在这个节点星级根，完成
执行下面的功能，

734
00:35:05,450 --> 00:35:07,430
这恰好是一个查找功能。

735
00:35:07,430 --> 00:35:09,260
并有和没有递归做到这一点。

736
00:35:09,260 --> 00:35:10,860
>> 所以，我希望你写两个函数。

737
00:35:10,860 --> 00:35:14,310
一个用递归，一个人​​在做这个
这样做并没有递归。

738
00:35:14,310 --> 00:35:18,050
也不要假设
根将成为非null。

739
00:35:18,050 --> 00:35:21,790
因此，我们正在寻找我的整数
树开始在根，我们需要

740
00:35:21,790 --> 00:35:25,280
递归写这
和迭代。

741
00:35:25,280 --> 00:35:26,300
是啊。

742
00:35:26,300 --> 00:35:29,730
>> 观众：所以，你要我们返回true
如果我们发现，假如果我们

743
00:35:29,730 --> 00:35:30,480
并不觉得。

744
00:35:30,480 --> 00:35:32,160
>> JASON HIRSCHHORN：你怎么知道的？

745
00:35:32,160 --> 00:35:33,100
你是怎么知道的？

746
00:35:33,100 --> 00:35:36,500
>> 观众：我是问第一次，但我
假设，因为它说，在布尔

747
00:35:36,500 --> 00:35:37,490
该函数的开头。

748
00:35:37,490 --> 00:35:37,880
>> JASON HIRSCHHORN：对。

749
00:35:37,880 --> 00:35:41,020
它说BOOL，所以我什至都不需要
告诉你，我希望你能返回

750
00:35:41,020 --> 00:35:41,350
因为它说在那里。

751
00:35:41,350 --> 00:35:42,280
但是，这是正确的。

752
00:35:42,280 --> 00:35:43,510
返回，真或假。

753
00:35:43,510 --> 00:35:47,630
>> 在开始之前，我会建议，
如果您不熟悉

754
00:35:47,630 --> 00:35:51,300
二叉搜索树，快速绘制
它的照片，让您的

755
00:35:51,300 --> 00:35:51,750
的理解，正确的。

756
00:35:51,750 --> 00:35:54,720
写作时，也将帮助您
您的代码并检查它。

757
00:35:54,720 --> 00:35:57,830
同样，你也没有那么多
时间上的测验，做所有的事情

758
00:35:57,830 --> 00:35:59,030
我们要求你这样做。

759
00:35:59,030 --> 00:36:02,350
所以写的伪代码
是非常有帮助的。

760
00:36:02,350 --> 00:36:05,310
>> 而我们一般提供有关 - 

761
00:36:05,310 --> 00:36:06,820
如果伪代码是完全
正确的，这是

762
00:36:06,820 --> 00:36:08,910
通常50％的问题。

763
00:36:08,910 --> 00:36:11,410
所以它不是一个硬性规定，但如果
你只写伪代码，它的

764
00:36:11,410 --> 00:36:13,460
正确的，它通​​常50％。

765
00:36:13,460 --> 00:36:14,970
所以我总是建议 - 

766
00:36:14,970 --> 00:36:16,870
如果你时间紧迫，或者即使
你只是想弄明白 - 

767
00:36:16,870 --> 00:36:18,290
开始的伪代码。

768
00:36:18,290 --> 00:36:24,840
最后，如​​果你能写这
所有在C中，这将是非常美妙的。

769
00:36:24,840 --> 00:36:29,010
>> 因此，让我们3分钟
在这方面努力的程序。

770
00:36:29,010 --> 00:36:33,120
然后我们将要编写
伪代码，它只是一次，然后

771
00:36:33,120 --> 00:36:35,455
我们要递归编写它
然后反复。

772
00:36:35,455 --> 00:37:28,720

773
00:37:28,720 --> 00:37:30,760
>> 如果您有任何疑问，请随时
免费举起你的手。

774
00:37:30,760 --> 00:37:34,270
快乐的四处走动，并回答他们
在我们开始之前为一组。

775
00:37:34,270 --> 00:39:22,600

776
00:39:22,600 --> 00:39:27,200
>> 让我们重新开始，而且我们要
伪代码的递归版本

777
00:39:27,200 --> 00:39:29,830
这一点，那么我们将对其进行编码。

778
00:39:29,830 --> 00:39:33,380
因此，一个递归函数
需要两件事情。

779
00:39:33,380 --> 00:39:35,960
这可能是一个问题，
你可能会问。

780
00:39:35,960 --> 00:39:37,950
需要两件事情。

781
00:39:37,950 --> 00:39:40,610
谁可以提高他们的手，告诉我
什么两样东西递归

782
00:39:40,610 --> 00:39:43,680
函数需要？

783
00:39:43,680 --> 00:39:45,030
根据定义它有两件事情。

784
00:39:45,030 --> 00:39:46,280
什么是这两件事情？

785
00:39:46,280 --> 00:39:48,580

786
00:39:48,580 --> 00:39:49,830
新的手。

787
00:39:49,830 --> 00:39:55,050

788
00:39:55,050 --> 00:39:56,390
是的，奥尔登。

789
00:39:56,390 --> 00:39:57,980
>> 观众：所以我不能完全肯定，如果
这是术语，但是 - 

790
00:39:57,980 --> 00:39:59,715
>> JASON HIRSCHHORN：我很高兴
你养你的手。

791
00:39:59,715 --> 00:40:03,380
>> 观众：它需要一个基础的情况下，
并且它需要一个递归步骤。

792
00:40:03,380 --> 00:40:03,960
>> JASON HIRSCHHORN：完美。

793
00:40:03,960 --> 00:40:06,340
它需要一个基本情况和
一个递归步骤。

794
00:40:06,340 --> 00:40:10,430
那么什么是我们的基本情况吗？

795
00:40:10,430 --> 00:40:12,950
>> 观众：F盘根等于等于null。

796
00:40:12,950 --> 00:40:15,110
对不起，只是伪代码，
如果它为空。

797
00:40:15,110 --> 00:40:16,360
如果root为null。

798
00:40:16,360 --> 00:40:21,900

799
00:40:21,900 --> 00:40:23,540
>> JASON HIRSCHHORN：如果root为null。

800
00:40:23,540 --> 00:40:23,850
这是极好的。

801
00:40:23,850 --> 00:40:24,610
这是我们的基本情况。

802
00:40:24,610 --> 00:40:25,910
这就是我们要去
检查每一个时间。

803
00:40:25,910 --> 00:40:28,000
和基本情况是
你首先要做的。

804
00:40:28,000 --> 00:40:29,720
如果你打的基本情况，你就大功告成了。

805
00:40:29,720 --> 00:40:34,140
>> 现在，我们需要我们的递归调用，而且我
愿意打赌，我们需要一对夫妇

806
00:40:34,140 --> 00:40:35,440
这里的递归调用。

807
00:40:35,440 --> 00:40:39,630
因为它是一棵树，而我们
可以去多种方式。

808
00:40:39,630 --> 00:40:43,190
所以，如果根是空，我们是很好的。

809
00:40:43,190 --> 00:40:44,970
>> 你有什么建议？

810
00:40:44,970 --> 00:40:49,640
而现在我要开始呼叫
对你们，因为我知道你们

811
00:40:49,640 --> 00:40:50,540
都知道这一点。

812
00:40:50,540 --> 00:40:52,610
但安妮，又该
下一行是什么？

813
00:40:52,610 --> 00:40:53,570
如果我们找到了吗？

814
00:40:53,570 --> 00:40:55,526
我们该怎么办？

815
00:40:55,526 --> 00:40:57,300
>> 观众：如果我们找到了吗？

816
00:40:57,300 --> 00:40:59,160
>> JASON HIRSCHHORN：还是什么
应该是 - 

817
00:40:59,160 --> 00:41:02,124
给我的伪代码
行，我们发现了它。

818
00:41:02,124 --> 00:41:04,700
>> 观众：如果我等于根我？

819
00:41:04,700 --> 00:41:06,650
>> JASON HIRSCHHORN：与
那么我们该怎么做？

820
00:41:06,650 --> 00:41:07,590
>> 观众：返回true。

821
00:41:07,590 --> 00:41:08,530
>> JASON HIRSCHHORN：太好了。

822
00:41:08,530 --> 00:41:16,890
所以，如果我是我 - 

823
00:41:16,890 --> 00:41:17,400
哦，他们两个叫我。

824
00:41:17,400 --> 00:41:18,470
这得到混乱。

825
00:41:18,470 --> 00:41:23,830
但如果我是我返回true。

826
00:41:23,830 --> 00:41:25,620
这可能是下一个
我们应该做的事情。

827
00:41:25,620 --> 00:41:27,300
有道理。

828
00:41:27,300 --> 00:41:30,610
>> OK，现在我们还没有做我们的递归
调用的是，虽然，因为一个递归

829
00:41:30,610 --> 00:41:32,300
呼叫会再次调用该函数。

830
00:41:32,300 --> 00:41:41,460
那么又该下一
伪代码的行会？

831
00:41:41,460 --> 00:41:42,730
安娜。

832
00:41:42,730 --> 00:41:43,980
>> 观众：左边。

833
00:41:43,980 --> 00:41:47,040

834
00:41:47,040 --> 00:41:47,590
>> JASON HIRSCHHORN：要具体，虽然。

835
00:41:47,590 --> 00:41:50,600
这是一个二叉搜索树，还等什么
并检查左侧意味着什么？

836
00:41:50,600 --> 00:41:51,890
>> 观众：那么节点 - 

837
00:41:51,890 --> 00:41:53,342
对不起，根。

838
00:41:53,342 --> 00:41:55,306
然后向左箭头。

839
00:41:55,306 --> 00:41:59,234

840
00:41:59,234 --> 00:42:00,720
节点，节点，对不起。

841
00:42:00,720 --> 00:42:01,978
我不会读它正确。

842
00:42:01,978 --> 00:42:05,700
这就是所谓的节点，对不对？

843
00:42:05,700 --> 00:42:09,270
>> JASON HIRSCHHORN：它会被称为根
在该功能，但无论哪种方式。

844
00:42:09,270 --> 00:42:10,925
左侧的 - 是吗？

845
00:42:10,925 --> 00:42:13,780
>> 观众：如果它不等于
我，然后我们将调用

846
00:42:13,780 --> 00:42:15,130
该功能了吗？

847
00:42:15,130 --> 00:42:15,490
>> JASON HIRSCHHORN：这是正确的。

848
00:42:15,490 --> 00:42:17,870
如果它不等于我，我们要去
再次调用该函数。

849
00:42:17,870 --> 00:42:21,435
然而，我们要什么副作用的树
再次调用该函数？

850
00:42:21,435 --> 00:42:22,685
>> 观众：在左侧。

851
00:42:22,685 --> 00:42:25,932

852
00:42:25,932 --> 00:42:27,670
>> JASON HIRSCHHORN：我们并不总是
要调用它的左边，如果它

853
00:42:27,670 --> 00:42:29,190
不等于它。

854
00:42:29,190 --> 00:42:29,610
>> 观众：哦，对不起。

855
00:42:29,610 --> 00:42:31,200
呼吁的权利。

856
00:42:31,200 --> 00:42:33,680
>> JASON HIRSCHHORN：我们想知道
具体而言，虽然 - 还记得，在一个

857
00:42:33,680 --> 00:42:37,700
二叉搜索树，一切
左手侧越小。

858
00:42:37,700 --> 00:42:40,460
一切的权利
手侧更大。

859
00:42:40,460 --> 00:42:43,990
所以它只是不 - 是啊，去吧。

860
00:42:43,990 --> 00:42:46,805
>> 观众：如果它的不到我，然后 - 

861
00:42:46,805 --> 00:42:52,130

862
00:42:52,130 --> 00:42:53,380
如果它是在左边 - 

863
00:42:53,380 --> 00:42:56,160

864
00:42:56,160 --> 00:42:58,606
>> JASON HIRSCHHORN：所以，如果
ri为小于 - 

865
00:42:58,606 --> 00:43:01,854

866
00:43:01,854 --> 00:43:09,110
因此，如果我们数小于我，
我们想去什么副作用？

867
00:43:09,110 --> 00:43:15,120
>> 观众：我们想去
向右侧。

868
00:43:15,120 --> 00:43:16,250
>> JASON HIRSCHHORN：我们想要去 - 

869
00:43:16,250 --> 00:43:19,210
让我画一个快速的树。

870
00:43:19,210 --> 00:43:23,850
如果这是5，这将是3。

871
00:43:23,850 --> 00:43:29,410
因此，如果ri为小于5，什么
一边做我们想要去？

872
00:43:29,410 --> 00:43:30,390
>> 观众：对不起，什么？

873
00:43:30,390 --> 00:43:33,190
>> JASON HIRSCHHORN：我们的电话号码是
小于我们的数

874
00:43:33,190 --> 00:43:34,710
现在在看。

875
00:43:34,710 --> 00:43:35,890
>> 观众：哦，那我们要
去的左侧。

876
00:43:35,890 --> 00:43:36,240
是啊。

877
00:43:36,240 --> 00:43:36,920
抱歉。

878
00:43:36,920 --> 00:43:37,230
>> JASON HIRSCHHORN：没错。

879
00:43:37,230 --> 00:43:38,480
无后顾之忧。

880
00:43:38,480 --> 00:43:41,020
在二叉搜索树，一切
下是到左边，

881
00:43:41,020 --> 00:43:42,110
更大的是在右边。

882
00:43:42,110 --> 00:43:46,700
因此，如果我们的数目小于
我们正在检查我 - 

883
00:43:46,700 --> 00:43:48,790
因为你在看
节点，它有一个i  - 

884
00:43:48,790 --> 00:43:50,040
那么你想要去到左边。

885
00:43:50,040 --> 00:43:55,480

886
00:43:55,480 --> 00:43:56,720
>> 这是一个轻松的一年。

887
00:43:56,720 --> 00:44:01,700
这是它的伪代码的其他线
我们需要写？

888
00:44:01,700 --> 00:44:02,910
卡洛斯？

889
00:44:02,910 --> 00:44:05,970
>> 观众：同样的事情，你只需切换
它以一个大于号

890
00:44:05,970 --> 00:44:07,420
和去的权利。

891
00:44:07,420 --> 00:44:08,350
>> JASON HIRSCHHORN：你能
说这一次吗？

892
00:44:08,350 --> 00:44:11,640
>> 观众：如果我们的数大于
比我去的权利。

893
00:44:11,640 --> 00:44:24,900

894
00:44:24,900 --> 00:44:26,690
>> JASON HIRSCHHORN：优秀
就业上的伪代码。

895
00:44:26,690 --> 00:44:28,700
让我们在真正的代码做到这一点。

896
00:44:28,700 --> 00:44:33,280
再次，这将伪代码
可能会得到你的，因为它是

897
00:44:33,280 --> 00:44:35,480
正确的，50％在这个问题上。

898
00:44:35,480 --> 00:44:39,720
但这个伪也意味着1
一，从本质上讲，成代码。

899
00:44:39,720 --> 00:44:44,380
>> 因此，让我们在C谁能给做到这一点
我的第一行代码？

900
00:44:44,380 --> 00:44:48,390
其实，第一次，以前我做的
这一点，让我拉过来 - 

901
00:44:48,390 --> 00:44:49,260
>> 观众：我有一个问题。

902
00:44:49,260 --> 00:44:52,430
你为什么要缩进
行我给你？

903
00:44:52,430 --> 00:44:54,160
>> JASON HIRSCHHORN：因为
我不能写。

904
00:44:54,160 --> 00:44:55,240
我不知道。

905
00:44:55,240 --> 00:44:55,650
你说得对。

906
00:44:55,650 --> 00:44:57,780
该行应该在那里。

907
00:44:57,780 --> 00:45:11,600

908
00:45:11,600 --> 00:45:14,480
>> 好了，这里是我们的函数。

909
00:45:14,480 --> 00:45:18,090
让我拉过来，也，
我们定义一个节点。

910
00:45:18,090 --> 00:45:23,320

911
00:45:23,320 --> 00:45:27,180
如果我们没有发生什么
写的typedef？

912
00:45:27,180 --> 00:45:30,240
有谁知道？

913
00:45:30,240 --> 00:45:32,570
>> 观众：它不会编译。

914
00:45:32,570 --> 00:45:33,860
>> JASON HIRSCHHORN：它会
编译，是的。

915
00:45:33,860 --> 00:45:37,120
>> 观众：难道只是声明了一个
实例，而不是使之成为一个新的

916
00:45:37,120 --> 00:45:39,840
键入您可以声明多个
的实例？

917
00:45:39,840 --> 00:45:41,700
>> JASON HIRSCHHORN：所以它不会
知道 - 它不会

918
00:45:41,700 --> 00:45:43,120
只是声明了一个类型。

919
00:45:43,120 --> 00:45:46,150
你仍然可以做出很多节点。

920
00:45:46,150 --> 00:45:48,070
>> 观众：但是难道我们要
每次写结构节点？

921
00:45:48,070 --> 00:45:48,640
>> JASON HIRSCHHORN：这是正确的。

922
00:45:48,640 --> 00:45:50,960
你必须编写结构节点
每一次，而不是仅仅节点。

923
00:45:50,960 --> 00:45:55,270
但用typedef，你可以只
写节点每一次。

924
00:45:55,270 --> 00:45:58,240
好了，谁没有给出 - 是啊，Avica。

925
00:45:58,240 --> 00:46:01,520
>> 观众：如果root等于等于
空，返回false。

926
00:46:01,520 --> 00:46:07,130

927
00:46:07,130 --> 00:46:09,490
>> JASON HIRSCHHORN：大和
这是我们的基本情况。

928
00:46:09,490 --> 00:46:11,200
下一行代码。

929
00:46:11,200 --> 00:46:13,999
谁没有给别人
我的代码行了吗？

930
00:46:13,999 --> 00:46:14,945
是啊。

931
00:46:14,945 --> 00:46:23,360
>> 观众：根箭头我
等于等于i。

932
00:46:23,360 --> 00:46:27,260
然后返回true。

933
00:46:27,260 --> 00:46:29,162
>> JASON HIRSCHHORN：太好了。

934
00:46:29,162 --> 00:46:32,048
下一行？

935
00:46:32,048 --> 00:46:32,790
是啊。

936
00:46:32,790 --> 00:46:34,010
别人？

937
00:46:34,010 --> 00:46:36,774
然后你可以去下一个。

938
00:46:36,774 --> 00:46:44,820
>> 观众：否则，如果根箭头
i小于我返回

939
00:46:44,820 --> 00:46:47,737
函数调用查找根源 - 

940
00:46:47,737 --> 00:46:50,611
>> JASON HIRSCHHORN：对不起。

941
00:46:50,611 --> 00:46:56,272
>> 观众：返回找到根
指向左侧逗号我。

942
00:46:56,272 --> 00:47:01,760

943
00:47:01,760 --> 00:47:08,440
>> JASON HIRSCHHORN：所以，如果ri为更大
比树的东西，我们要

944
00:47:08,440 --> 00:47:09,573
去左边？

945
00:47:09,573 --> 00:47:11,790
>> 观众：不，我有这样的切换。

946
00:47:11,790 --> 00:47:13,040
>> JASON HIRSCHHORN：哪一个？

947
00:47:13,040 --> 00:47:16,310

948
00:47:16,310 --> 00:47:16,950
>> 观众：没有，是的。

949
00:47:16,950 --> 00:47:19,050
我有一个小于号那里。

950
00:47:19,050 --> 00:47:22,890
>> JASON HIRSCHHORN：对，如果ri为
不到什么是根 - 

951
00:47:22,890 --> 00:47:25,660
我们当前的根 - 那么我们
想要去到左边。

952
00:47:25,660 --> 00:47:26,960
什么是最后一行，你呢？

953
00:47:26,960 --> 00:47:30,930
>> 观众：基本上同样的事情，
除了切换大于或

954
00:47:30,930 --> 00:47:34,690
等于小于和左到右。

955
00:47:34,690 --> 00:47:43,590

956
00:47:43,590 --> 00:47:43,680
>> JASON HIRSCHHORN：优秀。

957
00:47:43,680 --> 00:47:48,430
没有任何人有任何疑问，
这件事？

958
00:47:48,430 --> 00:47:52,560
因此，一些其他的东西，会
已经正确的是

959
00:47:52,560 --> 00:47:53,810
可能是 -  ltiff。

960
00:47:53,810 --> 00:47:56,520

961
00:47:56,520 --> 00:47:59,520
猜测，在技术上，没有这些
真的还需要，ltiff。

962
00:47:59,520 --> 00:48:00,950
>> 此外，有可能只
一个案件​​到这里。

963
00:48:00,950 --> 00:48:02,380
所以这可能是你最后一种情况。

964
00:48:02,380 --> 00:48:04,000
你甚至不需要说 -  ltiff。

965
00:48:04,000 --> 00:48:06,160
但可能好写
它是明确的。

966
00:48:06,160 --> 00:48:06,660
是啊。

967
00:48:06,660 --> 00:48:09,200
>> 观众：所以你不认为测验 - 
如果我们的错误，例如，

968
00:48:09,200 --> 00:48:11,725
在语法 - 

969
00:48:11,725 --> 00:48:13,990
小语法错误 - 

970
00:48:13,990 --> 00:48:17,810
那怎么得到采取的测验？

971
00:48:17,810 --> 00:48:21,300
>> JASON HIRSCHHORN：一般的测验，
小的语法错误或小

972
00:48:21,300 --> 00:48:24,010
风格的错误不会失去你点。

973
00:48:24,010 --> 00:48:26,610
所以，如果你忘了一个分号
在这里，这将是确定。

974
00:48:26,610 --> 00:48:30,290
如果您忘记关闭这个括号，
这将是确定。

975
00:48:30,290 --> 00:48:34,880
>> 这改变了巨大的语法错误
你的代码的功能意义

976
00:48:34,880 --> 00:48:37,600
戏剧性的是，你可能会得到
起飞的点。

977
00:48:37,600 --> 00:48:40,330
或一般，只是你分级
是否不是你的

978
00:48:40,330 --> 00:48:42,150
代码的功能，甚至 - 

979
00:48:42,150 --> 00:48:44,830
不是它的设计这么多，
而不是它的风格。

980
00:48:44,830 --> 00:48:50,780

981
00:48:50,780 --> 00:48:55,480
>> 现在，让我们编写一个迭代
版本发现的。

982
00:48:55,480 --> 00:49:00,400

983
00:49:00,400 --> 00:49:03,450
因此，这将是相当类似的，但
当然，还有将要

984
00:49:03,450 --> 00:49:06,250
一些关键的差别。

985
00:49:06,250 --> 00:49:09,160
然而，我们的伪代码
大概可以走 - 

986
00:49:09,160 --> 00:49:11,610
我们仍然可以采取一系的
伪代码，弄清了

987
00:49:11,610 --> 00:49:14,160
线是在这种情况下。

988
00:49:14,160 --> 00:49:18,010
>> 因此，在一个迭代版本，什么
你认为，朱莉娅，应

989
00:49:18,010 --> 00:49:19,260
在第一线？

990
00:49:19,260 --> 00:49:23,100

991
00:49:23,100 --> 00:49:26,920
>> 观众：同样，在迭代布尔，
您需要建立一个for循环，对不对？

992
00:49:26,920 --> 00:49:27,660
>> JASON HIRSCHHORN：确定。

993
00:49:27,660 --> 00:49:38,480
>> 观众：那么像，K，对于x
等于0时，x是小于我。

994
00:49:38,480 --> 00:49:42,260
或无，x是小于
树的大小。

995
00:49:42,260 --> 00:49:42,760
>> JASON HIRSCHHORN：树。

996
00:49:42,760 --> 00:49:46,660
所以我们真的不知道的大小
树，我们真的不知道

997
00:49:46,660 --> 00:49:48,900
多少次，我们可以走了，有啥
不同类型的循环，它可能是

998
00:49:48,900 --> 00:49:50,150
在这种情况下更好？

999
00:49:50,150 --> 00:49:53,250

1000
00:49:53,250 --> 00:49:55,244
>> 观众：如果别的吗？

1001
00:49:55,244 --> 00:49:57,070
>> JASON HIRSCHHORN：如果其他人
不能为一个循环。

1002
00:49:57,070 --> 00:49:58,935
那么什么是循环类型，我们可以只
去，直到某些情况下得到满足？

1003
00:49:58,935 --> 00:50:07,250

1004
00:50:07,250 --> 00:50:11,560
什么是唯一的其他类型的循环
C语言除了for循环？

1005
00:50:11,560 --> 00:50:11,930
>> 观众：虽然。

1006
00:50:11,930 --> 00:50:13,380
>> JASON HIRSCHHORN：虽然，没错。

1007
00:50:13,380 --> 00:50:16,430
在while循环中，不
需要知道如何 - 

1008
00:50:16,430 --> 00:50:18,450
while循环和for循环可以做
同样的事情，但美好的东西

1009
00:50:18,450 --> 00:50:21,500
关于while循环是我们不需要
要知道有多大我们的树。

1010
00:50:21,500 --> 00:50:23,060
因此，我们打算去，直到什么？

1011
00:50:23,060 --> 00:50:25,880

1012
00:50:25,880 --> 00:50:28,032
>> 观众：直到它等于
的大小 - 

1013
00:50:28,032 --> 00:50:32,320
>> JASON HIRSCHHORN：嗯，这是非常
类似我们的递归情况。

1014
00:50:32,320 --> 00:50:33,360
所以 - 

1015
00:50:33,360 --> 00:50:36,470
>> 观众：虽然根
我不等于我。

1016
00:50:36,470 --> 00:50:37,620
>> JASON HIRSCHHORN：这是真的很近。

1017
00:50:37,620 --> 00:50:39,430
而根I  - 

1018
00:50:39,430 --> 00:50:40,610
让我们来试试吧。

1019
00:50:40,610 --> 00:50:41,180
我不认为[听不清]

1020
00:50:41,180 --> 00:50:43,026
其中root我不等于我。

1021
00:50:43,026 --> 00:50:47,380

1022
00:50:47,380 --> 00:50:49,460
我们可能需要在一点点改变它
位，但听起来就像是相当

1023
00:50:49,460 --> 00:50:50,160
好，现在。

1024
00:50:50,160 --> 00:50:51,710
因此，我们将做到这一点。

1025
00:50:51,710 --> 00:50:55,660
>> 此外，请记住，我们不能假设
每个问题。

1026
00:50:55,660 --> 00:50:57,880
你不假设
根将成为非null。

1027
00:50:57,880 --> 00:51:01,914
那么你觉得很
我们应该做的第一件事是什么？

1028
00:51:01,914 --> 00:51:02,770
>> 观众：刚刚做同样的
和以前一样的事情。

1029
00:51:02,770 --> 00:51:05,260
如果根等于等号
空，返回false。

1030
00:51:05,260 --> 00:51:11,030

1031
00:51:11,030 --> 00:51:12,130
>> JASON HIRSCHHORN：太好了。

1032
00:51:12,130 --> 00:51:13,820
因此它可以为null。

1033
00:51:13,820 --> 00:51:15,810
因此，我们要摆脱
它的时候了。

1034
00:51:15,810 --> 00:51:19,560
然后我们要去检查，如果
根我不等于我。

1035
00:51:19,560 --> 00:51:24,480
所以，说我们正在寻找在这棵树
3，根我不等于我，现在

1036
00:51:24,480 --> 00:51:25,950
我们在我们的while循环。

1037
00:51:25,950 --> 00:51:27,500
我们究竟想干什么？

1038
00:51:27,500 --> 00:51:32,320

1039
00:51:32,320 --> 00:51:35,430
再次，这将是相当
类似于我们的递归版本。

1040
00:51:35,430 --> 00:51:36,230
是啊。

1041
00:51:36,230 --> 00:51:40,470
>> 观众：所以你想要遍历，或
不断下降的树，只要

1042
00:51:40,470 --> 00:51:42,400
根不等于空。

1043
00:51:42,400 --> 00:51:45,120

1044
00:51:45,120 --> 00:51:46,640
>> JASON HIRSCHHORN：只要
根不等于空？

1045
00:51:46,640 --> 00:51:50,200
>> 观众：根破折号我
不等于空。

1046
00:51:50,200 --> 00:51:51,220
只是根，是啊。

1047
00:51:51,220 --> 00:51:52,920
作为一个长期的根源是
不等于空。

1048
00:51:52,920 --> 00:51:54,240
>> JASON HIRSCHHORN：所以，你想要
要改变这种成根

1049
00:51:54,240 --> 00:51:56,590
不等于空？

1050
00:51:56,590 --> 00:51:59,020
>> 观众：是啊。

1051
00:51:59,020 --> 00:52:00,800
>> 观众：我们可以结合
这些，对不对？

1052
00:52:00,800 --> 00:52:02,990
我们不需要的，如果，最初。

1053
00:52:02,990 --> 00:52:05,180
>> JASON HIRSCHHORN：OK，所以如果我们鸵鸟政策 - 

1054
00:52:05,180 --> 00:52:08,140
如果我们结合它们，所以我们要做的
而根不等于空，

1055
00:52:08,140 --> 00:52:10,800
如果根恰好是在空
开始，我们怎么办下来吗？

1056
00:52:10,800 --> 00:52:11,450
>> 观众：返回false。

1057
00:52:11,450 --> 00:52:12,730
>> JASON HIRSCHHORN：太好了。

1058
00:52:12,730 --> 00:52:14,110
因此，两种方式可能
会工作。

1059
00:52:14,110 --> 00:52:15,645
这是一种不同的方式，
而这个结合了。

1060
00:52:15,645 --> 00:52:18,950
但同样，如果你没有任何办法，我们
不打算脱下设计

1061
00:52:18,950 --> 00:52:19,800
点上的测验。

1062
00:52:19,800 --> 00:52:21,020
但这个看起来不错。

1063
00:52:21,020 --> 00:52:23,940
>> 因此，尽管根不等于
空，什么是第一

1064
00:52:23,940 --> 00:52:25,400
的事情，我们要检查？

1065
00:52:25,400 --> 00:52:26,330
别人？

1066
00:52:26,330 --> 00:52:29,720
空，什么是第一件事情？

1067
00:52:29,720 --> 00:52:32,850
>> 观众：如果RI小于 - 

1068
00:52:32,850 --> 00:52:36,140
哦，我想，如果我们已经
发现它的根。

1069
00:52:36,140 --> 00:52:40,830
因此，如果根箭头i是等于i  - 

1070
00:52:40,830 --> 00:52:40,990
>> JASON HIRSCHHORN：对不起？

1071
00:52:40,990 --> 00:52:45,840
>> 观众：如果根箭头
i等于等于I  - 

1072
00:52:45,840 --> 00:52:47,090
>> JASON HIRSCHHORN：我们该怎么办？

1073
00:52:47,090 --> 00:52:50,300

1074
00:52:50,300 --> 00:52:51,550
>> 观众：返回true。

1075
00:52:51,550 --> 00:52:58,850

1076
00:52:58,850 --> 00:52:59,280
>> JASON HIRSCHHORN：太好了。

1077
00:52:59,280 --> 00:53:00,530
而下一步是什么？

1078
00:53:00,530 --> 00:53:04,510

1079
00:53:04,510 --> 00:53:06,843
杰夫，什么是下一行代码？

1080
00:53:06,843 --> 00:53:16,190
>> 观众：如果i小于根箭头
i，则根等于根箭头左边。

1081
00:53:16,190 --> 00:53:21,550
>> JASON HIRSCHHORN：根等号
根箭离开了。

1082
00:53:21,550 --> 00:53:24,530
所以，这可能是最大的
区别就在这里在这个迭代

1083
00:53:24,530 --> 00:53:26,600
版本相对于
递归版本。

1084
00:53:26,600 --> 00:53:28,970
递归版本，我们
再次调用该函数。

1085
00:53:28,970 --> 00:53:32,640
我们将更新时，根
我们所说的新功能。

1086
00:53:32,640 --> 00:53:34,170
在这里，我们不调用一个新的函数。

1087
00:53:34,170 --> 00:53:37,610
我们只是简单地更新
根此功能。

1088
00:53:37,610 --> 00:53:38,880
这是极好的。

1089
00:53:38,880 --> 00:53:40,730
什么是代码的最后一行？

1090
00:53:40,730 --> 00:53:43,950

1091
00:53:43,950 --> 00:53:44,880
是啊，马里奥？

1092
00:53:44,880 --> 00:53:48,290
>> 观众：否则等于根
根右侧的箭头。

1093
00:53:48,290 --> 00:53:49,492
>> JASON HIRSCHHORN：对不起？

1094
00:53:49,492 --> 00:53:52,340
>> 观众：根等号
根右侧的箭头。

1095
00:53:52,340 --> 00:53:55,590

1096
00:53:55,590 --> 00:53:57,140
>> JASON HIRSCHHORN：你也可以
写这样的事情？

1097
00:53:57,140 --> 00:54:02,786

1098
00:54:02,786 --> 00:54:03,890
>> 观众：我不知道。

1099
00:54:03,890 --> 00:54:05,140
>> JASON HIRSCHHORN：不能。

1100
00:54:05,140 --> 00:54:07,302

1101
00:54:07,302 --> 00:54:08,270
你不能这样做，加上等号。

1102
00:54:08,270 --> 00:54:10,780
好了，这个不错。

1103
00:54:10,780 --> 00:54:13,620
为什么我们不这样做
把它清理干净。

1104
00:54:13,620 --> 00:54:15,220
这看起来不错，这是可行的。

1105
00:54:15,220 --> 00:54:16,920
而我们将要爆发。

1106
00:54:16,920 --> 00:54:21,460
>> 如果root左为null或向右根
为null，我们会来这儿。

1107
00:54:21,460 --> 00:54:22,470
根将等于空。

1108
00:54:22,470 --> 00:54:24,270
我们会打破我们的循环，
我们会返回false。

1109
00:54:24,270 --> 00:54:26,280
所以，当我们跳出的
循环中，我们返回false。

1110
00:54:26,280 --> 00:54:29,520

1111
00:54:29,520 --> 00:54:32,793
>> 再次，在一个while循环是完美的
在这里，因为我们不知道如何

1112
00:54:32,793 --> 00:54:33,850
大我们的树。

1113
00:54:33,850 --> 00:54:36,460
我们试着写for循环，但我们
意识到你必须弄清楚如何

1114
00:54:36,460 --> 00:54:37,410
大的是时间提前。

1115
00:54:37,410 --> 00:54:38,720
是啊。

1116
00:54:38,720 --> 00:54:41,790
>> 观众：如果这不是一个二进制
搜索树，这将是真正的数学-Y

1117
00:54:41,790 --> 00:54:44,220
要反复写，对不对？

1118
00:54:44,220 --> 00:54:47,170
一样，如果它是一棵树，
但不一定 - 

1119
00:54:47,170 --> 00:54:49,730
所以它不是在左边的所有越小，
而右边都较大。

1120
00:54:49,730 --> 00:54:52,540
这将是非常困难的
遍历它，对不对？

1121
00:54:52,540 --> 00:54:55,720
我们不得不拯救早期是什么
在树回去，

1122
00:54:55,720 --> 00:54:56,970
和类似的东西。

1123
00:54:56,970 --> 00:54:59,690

1124
00:54:59,690 --> 00:55:02,010
>> JASON HIRSCHHORN：如果它不是一个二进制
搜索树，如果它只是一个

1125
00:55:02,010 --> 00:55:04,740
树，事情没
整理这样的 - 

1126
00:55:04,740 --> 00:55:07,440
和我们之前意识到，当安娜
在帮助我们，使

1127
00:55:07,440 --> 00:55:08,800
排序的帮助了我们很多 - 

1128
00:55:08,800 --> 00:55:12,610
我们需要的，是的，永远保存
我们以前。

1129
00:55:12,610 --> 00:55:14,430
但有可能是一个很大的
我们在哪里previouslys。

1130
00:55:14,430 --> 00:55:17,730
可能有很多父节点的。

1131
00:55:17,730 --> 00:55:22,530
>> 可能做到这一点的最好办法就是
是要继续推动东西到一些

1132
00:55:22,530 --> 00:55:24,170
类型堆栈或队列。

1133
00:55:24,170 --> 00:55:26,030
你将永远不需要编写本
因为这是一个困难的问题。

1134
00:55:26,030 --> 00:55:30,820
但你把一些东西到堆栈
或队列，然后弹出他们关闭，

1135
00:55:30,820 --> 00:55:31,890
然后评估他们。

1136
00:55:31,890 --> 00:55:34,200
>> 然后有一些其他的东西在那里
你实际上是把节点，

1137
00:55:34,200 --> 00:55:36,090
然后创建一个，然后
通过搜索。

1138
00:55:36,090 --> 00:55:38,700
这可能是做的最好的方式。

1139
00:55:38,700 --> 00:55:42,410
好了，关于这个问题的任何问题吗？

1140
00:55:42,410 --> 00:55:44,670
>> 观众：这是一个相关的说明。

1141
00:55:44,670 --> 00:55:50,460
我们将要比较运行时间
对哈希表，二进制

1142
00:55:50,460 --> 00:55:52,160
搜索树，等等？

1143
00:55:52,160 --> 00:55:54,310
>> JASON HIRSCHHORN：可能吧。

1144
00:55:54,310 --> 00:55:56,150
因此，让我们做到这一点真的很快。

1145
00:55:56,150 --> 00:55:58,490
运行时间为哈希表 - 

1146
00:55:58,490 --> 00:55:59,090
什么样的人？

1147
00:55:59,090 --> 00:56:00,050
二叉树？

1148
00:56:00,050 --> 00:56:02,920
>> 观众：链接列表。

1149
00:56:02,920 --> 00:56:04,780
>> JASON HIRSCHHORN：好，让我们做插入。

1150
00:56:04,780 --> 00:56:09,980
什么是插件的大O
在一个哈希表？

1151
00:56:09,980 --> 00:56:13,080

1152
00:56:13,080 --> 00:56:15,285
什么是假设
你在做什么？

1153
00:56:15,285 --> 00:56:17,760
>> 观众：你要插入的
开头的链接列表。

1154
00:56:17,760 --> 00:56:19,860
>> JASON HIRSCHHORN：可能第一
假设是不存在冲突。

1155
00:56:19,860 --> 00:56:22,340
如果没有冲突，则
插入时间就是其中之一。

1156
00:56:22,340 --> 00:56:26,560
如果有冲突，你就
做单独的链接和插入

1157
00:56:26,560 --> 00:56:31,880
在链接列表的开头，
然后插入也是恒定的。

1158
00:56:31,880 --> 00:56:34,700
>> 如果你正在做一个哈希表，但你
有处理的方法不同

1159
00:56:34,700 --> 00:56:36,040
有碰撞，有什么
不同的方法？

1160
00:56:36,040 --> 00:56:41,580

1161
00:56:41,580 --> 00:56:42,960
什么是一个不同的方法
处理的

1162
00:56:42,960 --> 00:56:44,205
在哈希表中的碰撞？

1163
00:56:44,205 --> 00:56:44,915
>> 观众：线性规划。

1164
00:56:44,915 --> 00:56:45,540
>> JASON HIRSCHHORN：线性规划。

1165
00:56:45,540 --> 00:56:47,770
所以，我们要继续寻找
下一个空位。

1166
00:56:47,770 --> 00:56:50,390
这不是恒定的插入时间。

1167
00:56:50,390 --> 00:56:52,266
你可能不得不通过
整个表，使

1168
00:56:52,266 --> 00:56:53,936
可能的n大O。

1169
00:56:53,936 --> 00:56:54,740
是啊。

1170
00:56:54,740 --> 00:56:57,690
>> 观众：否则只是链接？

1171
00:56:57,690 --> 00:57:00,160
>> JASON HIRSCHHORN：我们做了
单独的链接。

1172
00:57:00,160 --> 00:57:00,720
这是第一个。

1173
00:57:00,720 --> 00:57:01,560
这就是链接列表。

1174
00:57:01,560 --> 00:57:03,720
花哨的名字是单独的链接。

1175
00:57:03,720 --> 00:57:06,880
它可以是任何类型的列表结构
我们正好在做链接列表。

1176
00:57:06,880 --> 00:57:10,490
>> 如此反复，插在一个哈希表
可能是恒定的时间。

1177
00:57:10,490 --> 00:57:13,160
关于插入什么
在堆垛机的队列？

1178
00:57:13,160 --> 00:57:19,260

1179
00:57:19,260 --> 00:57:20,640
>> 观众：是不是恒定的？

1180
00:57:20,640 --> 00:57:21,530
>> JASON HIRSCHHORN：这是不变的时间。

1181
00:57:21,530 --> 00:57:23,420
你只是推动它。

1182
00:57:23,420 --> 00:57:24,120
确定。

1183
00:57:24,120 --> 00:57:25,380
插入，请问是什么其他的？

1184
00:57:25,380 --> 00:57:27,100
上一试？

1185
00:57:27,100 --> 00:57:30,252
什么是插在一个try大O？

1186
00:57:30,252 --> 00:57:32,808
>> 观众：长度是恒定的。

1187
00:57:32,808 --> 00:57:34,560
最长长度 - 

1188
00:57:34,560 --> 00:57:36,998
字的长度
要插入。

1189
00:57:36,998 --> 00:57:38,210
>> JASON HIRSCHHORN：对不起？

1190
00:57:38,210 --> 00:57:39,120
等等，所以我怎么听见了吗？

1191
00:57:39,120 --> 00:57:40,260
你说 - 你说什么？

1192
00:57:40,260 --> 00:57:41,650
什么是你的答案，马库斯？

1193
00:57:41,650 --> 00:57:43,640
>> 观众：这个词的长度
你要插入的字符，

1194
00:57:43,640 --> 00:57:45,480
假设它是一个字符尝试。

1195
00:57:45,480 --> 00:57:46,840
>> JASON HIRSCHHORN：好了，
字的长度。

1196
00:57:46,840 --> 00:57:49,500
我们会做一个假设，即
它的字符的字符串。

1197
00:57:49,500 --> 00:57:51,930
你说不同的东西，虽然。

1198
00:57:51,930 --> 00:57:55,490
你说的最长的单词的长度。

1199
00:57:55,490 --> 00:57:57,600
>> 观众：这只是常数，对不对？

1200
00:57:57,600 --> 00:57:58,440
>> JASON HIRSCHHORN：为什么会
它是恒定的？

1201
00:57:58,440 --> 00:58:00,970
>> 观众：就像，如果你使用大O
符号，那么它不是基于变化

1202
00:58:00,970 --> 00:58:04,680
对事物的数
已经在尝试。

1203
00:58:04,680 --> 00:58:07,344
>> JASON HIRSCHHORN：所以我们
说它是常量时间。

1204
00:58:07,344 --> 00:58:11,840
它是恒定的插入，并
那是因为这样的想法 - 

1205
00:58:11,840 --> 00:58:14,820
说我们有一个字，就是45，
或一个词，就是60，那

1206
00:58:14,820 --> 00:58:16,800
有一个恒定的数量。

1207
00:58:16,800 --> 00:58:21,050
它只会被插入
在常数时间。

1208
00:58:21,050 --> 00:58:26,060
>> 但在实践中，它不会是，
显然，发生在一毫秒内

1209
00:58:26,060 --> 00:58:26,590
例如。

1210
00:58:26,590 --> 00:58:28,880
但我们会说大O是
不断的尝试。

1211
00:58:28,880 --> 00:58:31,330
这就是它的一个
最大的优点。

1212
00:58:31,330 --> 00:58:33,330
>> 怎么样插入一个链接列表？

1213
00:58:33,330 --> 00:58:37,220
只需一个通用的，排序的链接列表？

1214
00:58:37,220 --> 00:58:37,700
是啊。

1215
00:58:37,700 --> 00:58:38,530
>> 观众：我有一个问题。

1216
00:58:38,530 --> 00:58:42,670
在测试中，他们会不断问我们的
插入时间这四个步骤，

1217
00:58:42,670 --> 00:58:43,270
还是什么？

1218
00:58:43,270 --> 00:58:44,300
还是只是 - 

1219
00:58:44,300 --> 00:58:47,670
当你说的插入时间为一，
这只是意味着恒定的时间？

1220
00:58:47,670 --> 00:58:49,770
>> JASON HIRSCHHORN：是啊，他们会
总是问，是它的n大O？

1221
00:58:49,770 --> 00:58:51,440
日志的n大O？

1222
00:58:51,440 --> 00:58:53,960
Ñ​​平方不变。

1223
00:58:53,960 --> 00:58:56,520
这些都是真正的唯一
那些你需要知道的。

1224
00:58:56,520 --> 00:58:58,420
什么插入到
排序的链接列表？

1225
00:58:58,420 --> 00:58:59,440
>> 观众：我有一个问题 - 

1226
00:58:59,440 --> 00:58:59,980
一个问题 - 

1227
00:58:59,980 --> 00:59:01,060
>> JASON HIRSCHHORN：答案是什么
对这个问题有关系吗？

1228
00:59:01,060 --> 00:59:02,120
>> 观众：等等，你问什么？

1229
00:59:02,120 --> 00:59:06,750
>> JASON HIRSCHHORN：什么是大O
插入排序的链接列表？

1230
00:59:06,750 --> 00:59:07,070
>> 观众：一？

1231
00:59:07,070 --> 00:59:09,400
无等待，无等待，正。

1232
00:59:09,400 --> 00:59:11,420
>> JASON HIRSCHHORN：N.除了
链接列表。

1233
00:59:11,420 --> 00:59:12,706
什么是你的问题？

1234
00:59:12,706 --> 00:59:16,440
>> 观众：所以你会写
Øk或邻1对的 - 

1235
00:59:16,440 --> 00:59:18,150
>> JASON HIRSCHHORN：哦。

1236
00:59:18,150 --> 00:59:21,830
我会写邻1，大概。

1237
00:59:21,830 --> 00:59:24,160
还有另外一个数据结构
这将是良好的。

1238
00:59:24,160 --> 00:59:25,730
树，二叉搜索树。

1239
00:59:25,730 --> 00:59:27,510
什么是插入在
二叉查找树？

1240
00:59:27,510 --> 00:59:31,190

1241
00:59:31,190 --> 00:59:33,900
>> 观众：登录。

1242
00:59:33,900 --> 00:59:39,260
>> JASON HIRSCHHORN：那么，什么是最糟糕的
情况二叉搜索树？

1243
00:59:39,260 --> 00:59:45,350
因此，如果我们碰巧从5开始，每
数大于5，则

1244
00:59:45,350 --> 00:59:48,760
我们已经有了5，7，9，11，等等。

1245
00:59:48,760 --> 00:59:52,255
在这种情况下，它基本上只是一个链接
列表，我们需要插入所有

1246
00:59:52,255 --> 00:59:52,680
的方式在末端。

1247
00:59:52,680 --> 00:59:54,350
所以它的n个大O。

1248
00:59:54,350 --> 00:59:57,720
>> 这可能是我们最糟糕的情况
在二叉搜索树。

1249
00:59:57,720 --> 01:00:00,890
很明显，你永远不会建造
与5中的一个二分搜索树

1250
01:00:00,890 --> 01:00:04,270
中间，知道5将
是最低的数字。

1251
01:00:04,270 --> 01:00:08,030
但它可能是，如果你
从头开始。

1252
01:00:08,030 --> 01:00:10,980
这之前的任何问题，我
移动到另一个问题？

1253
01:00:10,980 --> 01:00:11,560
这是一个很好的问题。

1254
01:00:11,560 --> 01:00:15,100
我想知道大O  - 

1255
01:00:15,100 --> 01:00:18,620
>> 观众：关于搜索什么
这四个？

1256
01:00:18,620 --> 01:00:20,400
>> JASON HIRSCHHORN：当然我们
没有搜索和排序。

1257
01:00:20,400 --> 01:00:22,160
我们做了所有这些算法，对吧。

1258
01:00:22,160 --> 01:00:23,390
等待，是测验1？

1259
01:00:23,390 --> 01:00:23,980
是盖 - 

1260
01:00:23,980 --> 01:00:25,860
你已经有
问题在测验1？

1261
01:00:25,860 --> 01:00:29,650
二进制搜索的大O运行时，
插入排序，冒泡排序？

1262
01:00:29,650 --> 01:00:30,160
>> 观众：是啊。

1263
01:00:30,160 --> 01:00:32,790
>> JASON HIRSCHHORN：如果您有这样的
在测验0的问题，可能你不会

1264
01:00:32,790 --> 01:00:35,180
得到测验1完全相同的问题。

1265
01:00:35,180 --> 01:00:36,300
可能是还是不错的知道这些。

1266
01:00:36,300 --> 01:00:38,520
你应该希望知道的GH了。

1267
01:00:38,520 --> 01:00:40,740
>> 但其他数运行时间
可能是很好的了解。

1268
01:00:40,740 --> 01:00:42,890
未涉及的测验0的东西。

1269
01:00:42,890 --> 01:00:47,300
像所有的这些运算符的
这些抽象数据类型。

1270
01:00:47,300 --> 01:00:50,760
>> 好吧，让我们继续前进。

1271
01:00:50,760 --> 01:00:52,190
这应该是相当快的。

1272
01:00:52,190 --> 01:00:56,170
这是一种新的语言，我们没有
其实在编码之前。

1273
01:00:56,170 --> 01:00:59,300
这是一个问题，问
在PHP代码。

1274
01:00:59,300 --> 01:01:01,950
因此，考虑下面的PHP数组。

1275
01:01:01,950 --> 01:01:06,150
写PHP和/或HTML代码，使得它
输出与TFS一个两列的表格

1276
01:01:06,150 --> 01:01:08,810
名称和房屋。

1277
01:01:08,810 --> 01:01:11,600
>> 你从来没有这样做过，
此特定问题。

1278
01:01:11,600 --> 01:01:16,270
但是，这应该是非常熟悉的
你的问题确实设置7。

1279
01:01:16,270 --> 01:01:21,250
所以，我愿意打赌你会
问到代码的东西在PHP中

1280
01:01:21,250 --> 01:01:23,880
非常类似于您
在问题没有设定7。

1281
01:01:23,880 --> 01:01:26,300
>> 首先，数组是不是特定的。

1282
01:01:26,300 --> 01:01:28,140
什么数组类型是什么？

1283
01:01:28,140 --> 01:01:29,080
>> 观众：会意字。

1284
01:01:29,080 --> 01:01:31,250
>> JASON HIRSCHHORN：这是
一个关联数组。

1285
01:01:31,250 --> 01:01:33,750
和什么之间的区别
关联数组和对象？

1286
01:01:33,750 --> 01:01:41,780

1287
01:01:41,780 --> 01:01:44,857
>> 观众：一个对象数组的索引
整数和一个关联数组

1288
01:01:44,857 --> 01:01:47,814
是字符串的索引，
或者类似的东西。

1289
01:01:47,814 --> 01:01:50,570

1290
01:01:50,570 --> 01:01:54,880
>> JASON HIRSCHHORN：这么一个数组
对象将有指标

1291
01:01:54,880 --> 01:01:57,090
整数，但一个对象的字段。

1292
01:01:57,090 --> 01:02:01,590
它也有类似的那些字段名称
名称，门牌，学生。

1293
01:02:01,590 --> 01:02:03,720
你有一个想法？

1294
01:02:03,720 --> 01:02:06,630
>> 观众：嗯，联想
数组是PHP的，对不对？

1295
01:02:06,630 --> 01:02:07,880
和对象是在JavaScript？

1296
01:02:07,880 --> 01:02:12,330

1297
01:02:12,330 --> 01:02:14,820
>> JASON HIRSCHHORN：说实话，有没有
两者之间真正的区别。

1298
01:02:14,820 --> 01:02:19,540
两者都有字符串作为密钥，并能
基本上有什么作为值。

1299
01:02:19,540 --> 01:02:21,250
不同的语言呼叫一个
事情关联数组，

1300
01:02:21,250 --> 01:02:22,750
一件事情的对象。

1301
01:02:22,750 --> 01:02:25,960
所以说实话，有没有真正的
差异，但有一些肯定

1302
01:02:25,960 --> 01:02:27,730
语法差异
两者之间。

1303
01:02:27,730 --> 01:02:28,200
是啊。

1304
01:02:28,200 --> 01:02:33,580
>> 观众：那么，对象也根据编码
油烟机作为一个哈希表，然后呢？

1305
01:02:33,580 --> 01:02:35,796
>> JASON HIRSCHHORN：你这是什么
意思是，引擎盖下的编码？

1306
01:02:35,796 --> 01:02:38,017
>> 观众：我们被告知，联想
阵列在技术上是一个

1307
01:02:38,017 --> 01:02:39,960
哈希表。

1308
01:02:39,960 --> 01:02:44,510
那么，对象也从技术上
哈希表？

1309
01:02:44,510 --> 01:02:45,350
>> JASON HIRSCHHORN：我不会
要回答这个问题。

1310
01:02:45,350 --> 01:02:46,600
我会尽快给你这一点。

1311
01:02:46,600 --> 01:02:48,980
但我不认为任何一个
那些这样。

1312
01:02:48,980 --> 01:02:53,790
但是，以任何方式，关联数组和
对象，通常，人们用这些

1313
01:02:53,790 --> 01:02:54,910
术语可以互换。

1314
01:02:54,910 --> 01:02:57,630
在这种情况下，凉爽的一部分
是您可以使用键。

1315
01:02:57,630 --> 01:03:00,580
字符串作为键，而不是
只是简单的数字。

1316
01:03:00,580 --> 01:03:02,070
>> 所以我一直在谈论
这一段时间。

1317
01:03:02,070 --> 01:03:04,090
我们希望，有些人有
得到就这样开始了。

1318
01:03:04,090 --> 01:03:08,050
我们将编写一些PHP和HTML
代码，这样，我们得到一个两列

1319
01:03:08,050 --> 01:03:11,830
表与TFS名和房屋。

1320
01:03:11,830 --> 01:03:15,380
>> 好吧，我也想一个标题
排此表上。

1321
01:03:15,380 --> 01:03:18,410
所以我要得到直
到这一点。

1322
01:03:18,410 --> 01:03:20,770
我们要文件，新建，
而且我们要 - 

1323
01:03:20,770 --> 01:03:27,780

1324
01:03:27,780 --> 01:03:28,320
>> 确定。

1325
01:03:28,320 --> 01:03:29,970
我该如何开始一个表？

1326
01:03:29,970 --> 01:03:32,090
什么是标签，迈克尔，
启动一个表？

1327
01:03:32,090 --> 01:03:32,890
>> 对象：表。

1328
01:03:32,890 --> 01:03:34,020
>> JASON HIRSCHHORN：表。

1329
01:03:34,020 --> 01:03:37,870
如果我打开一个标签，是什么
还有什么我需要什么？

1330
01:03:37,870 --> 01:03:39,810
>> 观众：头部？

1331
01:03:39,810 --> 01:03:41,040
或者，我猜，类。

1332
01:03:41,040 --> 01:03:41,730
>> JASON HIRSCHHORN：那么，对不起。

1333
01:03:41,730 --> 01:03:45,430
假定我们已经写
doctab，HTML，所有的东西。

1334
01:03:45,430 --> 01:03:50,230
但是，如果我打开这个表标签，是什么
还有什么我需要写？

1335
01:03:50,230 --> 01:03:53,450
为验证HTML吗？

1336
01:03:53,450 --> 01:03:55,000
>> 观众：关闭它。

1337
01:03:55,000 --> 01:03:56,050
>> JASON HIRSCHHORN：关闭标签。

1338
01:03:56,050 --> 01:03:57,575
我怎样写一个特写table标签？

1339
01:03:57,575 --> 01:03:59,580
>> 观众：点斜线表。

1340
01:03:59,580 --> 01:04:00,960
>> JASON HIRSCHHORN：斜线表，太好了。

1341
01:04:00,960 --> 01:04:02,730
可能是有道理写两个
那些因为一起

1342
01:04:02,730 --> 01:04:03,870
你必须做到这一点。

1343
01:04:03,870 --> 01:04:08,575
好吧，如果我想要一个标题行，怎么办
我写的标题行的标题？

1344
01:04:08,575 --> 01:04:11,650

1345
01:04:11,650 --> 01:04:19,290
>> 观众：是不是少
超过10小时密切 - 

1346
01:04:19,290 --> 01:04:21,550
TR，是的。

1347
01:04:21,550 --> 01:04:22,100
>> JASON HIRSCHHORN：TR？

1348
01:04:22,100 --> 01:04:25,080
>> 观众：那么同样的事情，
斜线，是啊。

1349
01:04:25,080 --> 01:04:26,610
>> JASON HIRSCHHORN：确定，
给我两列。

1350
01:04:26,610 --> 01:04:30,100

1351
01:04:30,100 --> 01:04:33,210
>> 观众：T D？

1352
01:04:33,210 --> 01:04:34,460
>> JASON HIRSCHHORN：确定。

1353
01:04:34,460 --> 01:04:37,730

1354
01:04:37,730 --> 01:04:39,520
我想两列。

1355
01:04:39,520 --> 01:04:40,960
这是否能给我两列？

1356
01:04:40,960 --> 01:04:43,880
多少列，这是？

1357
01:04:43,880 --> 01:04:45,920
之一。

1358
01:04:45,920 --> 01:04:47,170
因此，让我们复制并粘贴此。

1359
01:04:47,170 --> 01:04:59,750

1360
01:04:59,750 --> 01:05:03,390
>> 因此，实际上，在测验，所有这些代码
我们已经写了这么远了

1361
01:05:03,390 --> 01:05:04,710
其实给你。

1362
01:05:04,710 --> 01:05:06,200
但你应该还
知道怎么写呢。

1363
01:05:06,200 --> 01:05:06,470
是啊。

1364
01:05:06,470 --> 01:05:10,636
>> 观众：你的房子
两者之间。

1365
01:05:10,636 --> 01:05:11,130
>> JASON HIRSCHHORN：繁荣。

1366
01:05:11,130 --> 01:05:12,720
它应该就在那里，对不对？

1367
01:05:12,720 --> 01:05:14,600
良好的通话。

1368
01:05:14,600 --> 01:05:17,760
所以，再一次，所有这些代码实际上是
给你实际的测验。

1369
01:05:17,760 --> 01:05:19,570
但它的乐趣，写它，你
应该知道怎么写呢。

1370
01:05:19,570 --> 01:05:23,640
因此，这就是你需要
开始你的代码。

1371
01:05:23,640 --> 01:05:25,150
什么是我们需要在这里写？

1372
01:05:25,150 --> 01:05:28,640

1373
01:05:28,640 --> 01:05:30,565
>> 对不起，我需要改变
该文件的名称。

1374
01:05:30,565 --> 01:05:41,180

1375
01:05:41,180 --> 01:05:44,270
因此，我们将其保存在一个。的HTML文件，
没有一个。PHP文件。

1376
01:05:44,270 --> 01:05:47,030
这些东西会是什么呢？
在一个。PHP文件。

1377
01:05:47,030 --> 01:05:48,500
所以我们在一个。的HTML文件。

1378
01:05:48,500 --> 01:05:50,090
什么是第一件事情
我需要写？

1379
01:05:50,090 --> 01:05:52,990
我想提出一些PHP
在HTML代码。

1380
01:05:52,990 --> 01:05:57,300
>> 观众：PHP的，像另一个胡萝卜
和问号PHP的，对不对？

1381
01:05:57,300 --> 01:05:58,310
>> JASON HIRSCHHORN：太好了。

1382
01:05:58,310 --> 01:05:59,360
如何才能结束呢？

1383
01:05:59,360 --> 01:06:02,510
>> 观众：用一个问号。

1384
01:06:02,510 --> 01:06:03,120
>> JASON HIRSCHHORN：那太好了。

1385
01:06:03,120 --> 01:06:07,090
这就是我需要的，如果我想的第一件事
把一些PHP代码在这里。

1386
01:06:07,090 --> 01:06:11,210
>> 观众：我想一个PHP
文件可以采取的HTML。

1387
01:06:11,210 --> 01:06:12,290
>> JASON HIRSCHHORN：是啊。

1388
01:06:12,290 --> 01:06:15,330
一，PHP文件可以采取一些
HTML和显示。

1389
01:06:15,330 --> 01:06:16,450
这是我的坏。

1390
01:06:16,450 --> 01:06:18,300
我只是试图模仿
这是什么的测验。

1391
01:06:18,300 --> 01:06:21,910

1392
01:06:21,910 --> 01:06:24,720
>> 好了，对不起你迷惑。

1393
01:06:24,720 --> 01:06:25,550
是的，practice.HTML。

1394
01:06:25,550 --> 01:06:27,340
现在，我们打算把
一些PHP代码英寸

1395
01:06:27,340 --> 01:06:30,530
这是第一行
PHP代码我应该怎么写？

1396
01:06:30,530 --> 01:06:33,360
我要通过这个数组
并使其成为一个表。

1397
01:06:33,360 --> 01:06:34,600
是啊。

1398
01:06:34,600 --> 01:06:37,160
>> 观众：您可以使用
一个的H循环或for循环。

1399
01:06:37,160 --> 01:06:38,415
>> JASON HIRSCHHORN：好的，有什么
你要使用？

1400
01:06:38,415 --> 01:06:40,720
>> 观众：我会用一个for循环。

1401
01:06:40,720 --> 01:06:48,700
对，然后你做的美元符号
i等于0分号美元

1402
01:06:48,700 --> 01:06:51,580
签署小于2我。

1403
01:06:51,580 --> 01:06:55,455
然后我分号美元
签署加我加。

1404
01:06:55,455 --> 01:07:01,890

1405
01:07:01,890 --> 01:07:03,880
>> JASON HIRSCHHORN：如何做
你知道使用一个2？

1406
01:07:03,880 --> 01:07:10,444
>> 观众：因为有两个
在较大的关联数组

1407
01:07:10,444 --> 01:07:11,960
关联数组。

1408
01:07:11,960 --> 01:07:13,610
>> JASON HIRSCHHORN：那么大的事情的
没有联系的数组。

1409
01:07:13,610 --> 01:07:15,500
最重要的事情只是一个正常的数组。

1410
01:07:15,500 --> 01:07:17,380
但你说得对，有
2关联数组

1411
01:07:17,380 --> 01:07:18,910
我们的内部更大的数组。

1412
01:07:18,910 --> 01:07:20,310
这就是为什么你使用两个。

1413
01:07:20,310 --> 01:07:24,270
我觉得不舒服假设
他们是2，有啥办法写

1414
01:07:24,270 --> 01:07:26,810
这个没有假设他们是2？

1415
01:07:26,810 --> 01:07:27,507
>> 观众：[听不清]？

1416
01:07:27,507 --> 01:07:29,165
>> JASON HIRSCHHORN：好的，怎么
你写的吗？

1417
01:07:29,165 --> 01:07:35,262
>> 观众：Foreach回美元符号
TFS或像美元符号TF。

1418
01:07:35,262 --> 01:07:38,360

1419
01:07:38,360 --> 01:07:41,960
>> JASON HIRSCHHORN：OK，所以对于每个
TFS作为TFS，我想，现在

1420
01:07:41,960 --> 01:07:43,650
再次，有我的表。

1421
01:07:43,650 --> 01:07:45,250
那么，谁可以给我
下一行代码？

1422
01:07:45,250 --> 01:07:52,870

1423
01:07:52,870 --> 01:07:59,810
>> 观众：打印，然后在
报价，支架TR结束

1424
01:07:59,810 --> 01:08:02,670
支架，最终报价。

1425
01:08:02,670 --> 01:08:05,300
结束括号，分号。

1426
01:08:05,300 --> 01:08:07,135
>> JASON HIRSCHHORN：确定，
什么该怎么办呢？

1427
01:08:07,135 --> 01:08:08,610
>> 观众：它会说，新行。

1428
01:08:08,610 --> 01:08:11,070
它会放
标记为新行。

1429
01:08:11,070 --> 01:08:13,000
>> JASON HIRSCHHORN：对，这个PHP一样
我们前面谈到的 - 这

1430
01:08:13,000 --> 01:08:22,160
PHP将被求值，然后
它会打印出该文件

1431
01:08:22,160 --> 01:08:26,350
表丝束，然后该
HTML将被评估。

1432
01:08:26,350 --> 01:08:27,810
我们只是复制本
HTML我们不得不在这里。

1433
01:08:27,810 --> 01:08:28,120
是啊。

1434
01:08:28,120 --> 01:08:29,470
>> 观众：[听不清]？

1435
01:08:29,470 --> 01:08:30,290
>> JASON HIRSCHHORN：对不起？

1436
01:08:30,290 --> 01:08:31,240
就是这里。

1437
01:08:31,240 --> 01:08:33,590
2012年秋季。

1438
01:08:33,590 --> 01:08:35,970
不要看答案，
让我们来解决它在一起。

1439
01:08:35,970 --> 01:08:37,330
所以，我们打印的表行。

1440
01:08:37,330 --> 01:08:38,550
所以你可能在
摆动的东西。

1441
01:08:38,550 --> 01:08:41,060
什么是下一行
代码，我们需要写？

1442
01:08:41,060 --> 01:08:42,926
阿萨姆，给我的下一行代码。

1443
01:08:42,926 --> 01:08:46,290
>> 观众：你需要的TF的名字。

1444
01:08:46,290 --> 01:08:54,319
TF开括号引号
名左右方括号。

1445
01:08:54,319 --> 01:08:57,310
>> JASON HIRSCHHORN：给我他们的名字。

1446
01:08:57,310 --> 01:08:58,540
>> 观众：你需要打印。

1447
01:08:58,540 --> 01:08:59,790
>> [插VOICES]

1448
01:08:59,790 --> 01:09:01,963

1449
01:09:01,963 --> 01:09:03,430
>> JASON HIRSCHHORN：OK，
我怎么打印呢？

1450
01:09:03,430 --> 01:09:04,680
>> [插VOICES]

1451
01:09:04,680 --> 01:09:08,609

1452
01:09:08,609 --> 01:09:10,350
>> JASON HIRSCHHORN：我失踪
现在的东西。

1453
01:09:10,350 --> 01:09:12,470
我在想什么？

1454
01:09:12,470 --> 01:09:13,720
>> 观众：你需要一个美元符号。

1455
01:09:13,720 --> 01:09:15,960

1456
01:09:15,960 --> 01:09:17,210
>> JASON HIRSCHHORN：什么
什么我失踪？

1457
01:09:17,210 --> 01:09:20,100

1458
01:09:20,100 --> 01:09:21,650
所有我们到目前为止印刷是TR。

1459
01:09:21,650 --> 01:09:25,589

1460
01:09:25,589 --> 01:09:27,470
>> 观众：后关闭TR。

1461
01:09:27,470 --> 01:09:28,720
>> JASON HIRSCHHORN：因此，我们需要
后关闭TR。

1462
01:09:28,720 --> 01:09:34,390

1463
01:09:34,390 --> 01:09:37,906
谁看见我们错过了什么
第16行？

1464
01:09:37,906 --> 01:09:39,340
是的，安娜。

1465
01:09:39,340 --> 01:09:47,050
>> 观众：你需要打开
一个TD和大括号。

1466
01:09:47,050 --> 01:09:49,380
>> JASON HIRSCHHORN：在哪里
我们把花括号？

1467
01:09:49,380 --> 01:09:51,790
>> 观众：围绕TF名字。

1468
01:09:51,790 --> 01:09:53,080
>> JASON HIRSCHHORN：喜欢这个？

1469
01:09:53,080 --> 01:09:55,420
>> 观众：是啊。

1470
01:09:55,420 --> 01:09:59,000
然后关闭TD。

1471
01:09:59,000 --> 01:10:00,250
>> JASON HIRSCHHORN：像这样？

1472
01:10:00,250 --> 01:10:03,370

1473
01:10:03,370 --> 01:10:06,950
>> 观众：你需要双引号
标记旁边的大括号？

1474
01:10:06,950 --> 01:10:07,460
>> JASON HIRSCHHORN：就在这里？

1475
01:10:07,460 --> 01:10:08,710
不，你不知道。

1476
01:10:08,710 --> 01:10:10,820

1477
01:10:10,820 --> 01:10:12,550
所以这是完全正确的。

1478
01:10:12,550 --> 01:10:12,940
是啊。

1479
01:10:12,940 --> 01:10:15,290
>> 观众：所以这之间的区别
和用点encatenating是，如果

1480
01:10:15,290 --> 01:10:18,420
你用点，你必须有
双引号，那么一个点，

1481
01:10:18,420 --> 01:10:20,370
然后点 - 

1482
01:10:20,370 --> 01:10:20,520
>> JASON HIRSCHHORN：正确。

1483
01:10:20,520 --> 01:10:23,800
所以你说有一个最终的
的方式写这这样的。

1484
01:10:23,800 --> 01:10:26,760

1485
01:10:26,760 --> 01:10:28,966
什么是连接运算符
在JavaScript中？

1486
01:10:28,966 --> 01:10:31,200
>> 观众：加号。

1487
01:10:31,200 --> 01:10:34,710
你忘了把
大括号后面。

1488
01:10:34,710 --> 01:10:35,760
>> JASON HIRSCHHORN：太好了。

1489
01:10:35,760 --> 01:10:38,850
并且还有一系
代码丢失。

1490
01:10:38,850 --> 01:10:40,130
谁可以给我的最后一行
的代码，我们就错过？

1491
01:10:40,130 --> 01:10:43,940

1492
01:10:43,940 --> 01:10:47,602
>> 观众：刚才完全一样的东西，
刚刚与房子，而不是名称。

1493
01:10:47,602 --> 01:10:52,960

1494
01:10:52,960 --> 01:10:53,450
大

1495
01:10:53,450 --> 01:10:54,390
>> JASON HIRSCHHORN：太好了。

1496
01:10:54,390 --> 01:10:59,320
和你的语法是完全正确的
在获得一个关联数组的东西。

1497
01:10:59,320 --> 01:11:04,450
因此，在实际测验，你是
实际上放弃了，直到这里。

1498
01:11:04,450 --> 01:11:05,710
所以这段代码是给你的。

1499
01:11:05,710 --> 01:11:07,750
你不得不写有这些
四行并记住

1500
01:11:07,750 --> 01:11:09,190
关闭表标签。

1501
01:11:09,190 --> 01:11:11,370
你这家伙居然没
一切和更多。

1502
01:11:11,370 --> 01:11:11,810
是啊。

1503
01:11:11,810 --> 01:11:14,850
>> 观众：所以这将是功能
如果你只是有相同的，所有的

1504
01:11:14,850 --> 01:11:17,250
一个大的打印通话，对吧？

1505
01:11:17,250 --> 01:11:19,630
然后就连接在一起
其上，等等？

1506
01:11:19,630 --> 01:11:20,730
>> JASON HIRSCHHORN：像这样？

1507
01:11:20,730 --> 01:11:21,980
>> 观众：是啊。

1508
01:11:21,980 --> 01:11:23,810

1509
01:11:23,810 --> 01:11:26,940
它只是不会好看，如果你是
看着它，当你检查

1510
01:11:26,940 --> 01:11:28,550
在您的网站元素，对不对？

1511
01:11:28,550 --> 01:11:29,800
>> JASON HIRSCHHORN：我同意。

1512
01:11:29,800 --> 01:11:35,410

1513
01:11:35,410 --> 01:11:38,710
如果我装了这个网页，我会成为
能够看到这个PHP代码，永远不会消失？

1514
01:11:38,710 --> 01:11:39,240
>> 观众：号

1515
01:11:39,240 --> 01:11:40,080
>> JASON HIRSCHHORN：号

1516
01:11:40,080 --> 01:11:42,240
而实际上，我不会。

1517
01:11:42,240 --> 01:11:43,920
>> 观众：这是不是HTML，对不对？

1518
01:11:43,920 --> 01:11:45,000
所以，你也许可以 - 

1519
01:11:45,000 --> 01:11:46,780
>> JASON HIRSCHHORN：所以这个PHP将
评估服务器端。

1520
01:11:46,780 --> 01:11:51,020
PHP总是被判断服务器端，所以
你永远能看到PHP代码。

1521
01:11:51,020 --> 01:11:52,980
>> 观众：但是你能够
看到打印的结果。

1522
01:11:52,980 --> 01:11:53,480
>> JASON HIRSCHHORN：对。

1523
01:11:53,480 --> 01:11:55,510
而且说实话可能不
把它全部上线。

1524
01:11:55,510 --> 01:11:59,740
它可能很好地格式化你，
或者它可能把它放在同一行。

1525
01:11:59,740 --> 01:12:01,521
不清楚。

1526
01:12:01,521 --> 01:12:03,596
但是，是的，好一点。

1527
01:12:03,596 --> 01:12:06,470
>> 观众：怎么会有的
没有文字的高亮

1528
01:12:06,470 --> 01:12:07,550
任何PHP的命令？

1529
01:12:07,550 --> 01:12:09,370
因为我记得看到这一点。

1530
01:12:09,370 --> 01:12:11,620
>> JASON HIRSCHHORN：因为它是一个
。html文件在这里在顶部。

1531
01:12:11,620 --> 01:12:20,390

1532
01:12:20,390 --> 01:12:21,650
你去那里。

1533
01:12:21,650 --> 01:12:25,752

1534
01:12:25,752 --> 01:12:28,800
>> 观众：如果我们做了初步的方法
用for循环，正确的，如果我们

1535
01:12:28,800 --> 01:12:33,500
要访问TFS，我们会
做TFS支架0支架，然后

1536
01:12:33,500 --> 01:12:35,180
[听不清]？

1537
01:12:35,180 --> 01:12:35,970
>> JASON HIRSCHHORN：你会 - 

1538
01:12:35,970 --> 01:12:40,560
所以你说的for循环，你
会做的美元符号TFS支架1

1539
01:12:40,560 --> 01:12:41,850
或者我，对吧。

1540
01:12:41,850 --> 01:12:46,780
或美元符号我关闭支架
然后括号

1541
01:12:46,780 --> 01:12:49,600
双引号，是的。

1542
01:12:49,600 --> 01:12:50,640
>> 好的，优秀的。

1543
01:12:50,640 --> 01:12:53,020
我们有一个更快的之一。

1544
01:12:53,020 --> 01:12:55,090
七分钟，所以我想
走在这一个。

1545
01:12:55,090 --> 01:12:56,160
这是另一个例子。

1546
01:12:56,160 --> 01:12:58,740
我们现在是一个完全另一种语言。

1547
01:12:58,740 --> 01:12:59,990
>> 我们有一些HTML代码。

1548
01:12:59,990 --> 01:13:02,480

1549
01:13:02,480 --> 01:13:07,460
这是在屏幕上种小，但
我希望你仔细看看它真的

1550
01:13:07,460 --> 01:13:11,140
很快，有人可以告诉我，
如果我要载入这个网页，

1551
01:13:11,140 --> 01:13:12,390
我会看到什么？

1552
01:13:12,390 --> 01:13:22,710

1553
01:13:22,710 --> 01:13:26,450
详细说明一切
此网页。

1554
01:13:26,450 --> 01:13:28,630
诺亚？

1555
01:13:28,630 --> 01:13:30,450
那么我看到了什么？

1556
01:13:30,450 --> 01:13:38,140
>> 观众：在代码的前端
谷歌有感觉的文字和

1557
01:13:38,140 --> 01:13:39,190
提交按钮。

1558
01:13:39,190 --> 01:13:41,180
>> JASON HIRSCHHORN：什么
将按钮说呢？

1559
01:13:41,180 --> 01:13:42,430
>> 观众：提交。

1560
01:13:42,430 --> 01:13:44,620

1561
01:13:44,620 --> 01:13:45,160
哦，搜索。

1562
01:13:45,160 --> 01:13:45,840
对不起。

1563
01:13:45,840 --> 01:13:46,830
>> JASON HIRSCHHORN：它会说搜索。

1564
01:13:46,830 --> 01:13:47,520
请记住，名称。

1565
01:13:47,520 --> 01:13:50,550
我们使用什么名称？

1566
01:13:50,550 --> 01:13:53,774
此名称属性，有什么
用的？

1567
01:13:53,774 --> 01:13:55,470
>> [插VOICES]

1568
01:13:55,470 --> 01:13:59,300
>> 观众：这就是它的名字
因为当它被点击？

1569
01:13:59,300 --> 01:14:00,160
>> JASON HIRSCHHORN：这可能是。

1570
01:14:00,160 --> 01:14:02,690
但是，我们通常看到的 - 为什么
是我们给这个名称的队列？

1571
01:14:02,690 --> 01:14:03,830
为什么我们看到了吗？

1572
01:14:03,830 --> 01:14:05,220
是啊。

1573
01:14:05,220 --> 01:14:08,600
>> 观众：那岂不是成了指数
超级全局变量？

1574
01:14:08,600 --> 01:14:12,740
>> JASON HIRSCHHORN：是啊，一般当
这种形式会提交，然后在那里

1575
01:14:12,740 --> 01:14:13,500
将这个提交给？

1576
01:14:13,500 --> 01:14:14,750
哪一页？

1577
01:14:14,750 --> 01:14:16,820

1578
01:14:16,820 --> 01:14:18,460
诺亚，哪一页将这个提交给？

1579
01:14:18,460 --> 01:14:25,710

1580
01:14:25,710 --> 01:14:27,700
>> 观众：我不知道。

1581
01:14:27,700 --> 01:14:28,920
>> JASON HIRSCHHORN：在哪里
可能我们能找到它吗？

1582
01:14:28,920 --> 01:14:31,025
你在哪里找到什么
页面提交给？

1583
01:14:31,025 --> 01:14:32,850
哪一行代码？

1584
01:14:32,850 --> 01:14:34,040
>> 观众：表单操作。

1585
01:14:34,040 --> 01:14:34,650
>> JASON HIRSCHHORN：没错。

1586
01:14:34,650 --> 01:14:35,130
行动。

1587
01:14:35,130 --> 01:14:37,100
所以它提交到搜索页面。

1588
01:14:37,100 --> 01:14:38,630
反斜杠搜索。

1589
01:14:38,630 --> 01:14:40,140
所以这是完全正确的。

1590
01:14:40,140 --> 01:14:40,680
用什么方法？

1591
01:14:40,680 --> 01:14:42,090
>> 观众：获取。

1592
01:14:42,090 --> 01:14:42,490
>> JASON HIRSCHHORN：获取。

1593
01:14:42,490 --> 01:14:43,420
没错。

1594
01:14:43,420 --> 01:14:44,490
所以我们阅读这一点。

1595
01:14:44,490 --> 01:14:45,180
这将是一种形式。

1596
01:14:45,180 --> 01:14:45,910
你说得对。

1597
01:14:45,910 --> 01:14:50,340
两件事情的形式，的标题
页面和顶部将是谷歌。

1598
01:14:50,340 --> 01:14:54,270
>> 因此，这里有两个问题，你应该
能回答这个页面。

1599
01:14:54,270 --> 01:15:01,760
如果此HTML住在这个网站，
用户输入错误到这个文本

1600
01:15:01,760 --> 01:15:06,900
场就在这里，什么URL将
用户发现自己因

1601
01:15:06,900 --> 01:15:08,150
提交表单？

1602
01:15:08,150 --> 01:15:10,980

1603
01:15:10,980 --> 01:15:12,510
>> 因此，我们有这个权利在这里。

1604
01:15:12,510 --> 01:15:13,720
我要回去
此页，虽然。

1605
01:15:13,720 --> 01:15:16,980
我会写了第一部分。

1606
01:15:16,980 --> 01:15:18,230
大家可以看到在这里？

1607
01:15:18,230 --> 01:15:30,620

1608
01:15:30,620 --> 01:15:32,906
好了，马里奥，你以为你知道吗？

1609
01:15:32,906 --> 01:15:34,700
哪一页？

1610
01:15:34,700 --> 01:15:37,630
>> 观众：反斜杠搜索。

1611
01:15:37,630 --> 01:15:38,880
>> JASON HIRSCHHORN：我要去
搬到这里了。

1612
01:15:38,880 --> 01:15:44,800

1613
01:15:44,800 --> 01:15:49,155
OK，反斜线搜索问题
马克Q等于错误。

1614
01:15:49,155 --> 01:15:53,560

1615
01:15:53,560 --> 01:15:55,165
任何人有不同的建议吗？

1616
01:15:55,165 --> 01:15:57,910

1617
01:15:57,910 --> 01:15:59,160
是啊。

1618
01:15:59,160 --> 01:16:01,700

1619
01:16:01,700 --> 01:16:03,740
>> 那么，如何才能得到这个？

1620
01:16:03,740 --> 01:16:05,520
好了，我们以前见过这个。

1621
01:16:05,520 --> 01:16:07,170
而你想出了这点。

1622
01:16:07,170 --> 01:16:08,870
你说的没错，诺亚，该
行动告诉我们什么

1623
01:16:08,870 --> 01:16:11,700
页面我们要。

1624
01:16:11,700 --> 01:16:12,820
>> 我们也知道用什么方法。

1625
01:16:12,820 --> 01:16:13,420
我们正在做的get。

1626
01:16:13,420 --> 01:16:17,040
和GET和POST的区别
是，获得显示在URL

1627
01:16:17,040 --> 01:16:18,490
及后则没有。

1628
01:16:18,490 --> 01:16:22,760
所以，如果我在写帖子就在那里
方法，会有什么不同？

1629
01:16:22,760 --> 01:16:24,250
>> 观众：它只是
是斜线搜索。

1630
01:16:24,250 --> 01:16:25,400
>> JASON HIRSCHHORN：它会
刚刚被削减搜索。

1631
01:16:25,400 --> 01:16:27,400
没有什么比在这里会发生什么。

1632
01:16:27,400 --> 01:16:30,030
但因为它是一个得到，网址
显示如下。

1633
01:16:30,030 --> 01:16:35,140
首先我们看到了一个问号和
我们看到的名称和值。

1634
01:16:35,140 --> 01:16:42,730
说有另外一个文本字段，并
我给它r的名字，我输入一个

1635
01:16:42,730 --> 01:16:45,220
值，毛虫。

1636
01:16:45,220 --> 01:16:48,560
什么现在这个样子？

1637
01:16:48,560 --> 01:16:52,040
我还有一个文本字段，我给一个
r和毛毛虫的值的名称。

1638
01:16:52,040 --> 01:16:56,990
>> 观众：酒吧后你就会有
＆符号毛虫。

1639
01:16:56,990 --> 01:16:58,380
>> JASON HIRSCHHORN：这是
没有连字符。

1640
01:16:58,380 --> 01:17:00,500
>> 观众：或者只是什么
在和符号。

1641
01:17:00,500 --> 01:17:01,330
>> JASON HIRSCHHORN：是啊，没有。

1642
01:17:01,330 --> 01:17:03,700
你是对的，我错了。

1643
01:17:03,700 --> 01:17:05,660
这就像一克。

1644
01:17:05,660 --> 01:17:06,910
>> 对象：卡特彼勒。

1645
01:17:06,910 --> 01:17:08,840

1646
01:17:08,840 --> 01:17:11,090
r等于毛毛虫，对不起。

1647
01:17:11,090 --> 01:17:13,970

1648
01:17:13,970 --> 01:17:14,700
>> JASON HIRSCHHORN：有
在那里没有R？

1649
01:17:14,700 --> 01:17:16,680
>> 观众：没有，没有。

1650
01:17:16,680 --> 01:17:18,030
>> JASON HIRSCHHORN：我们将讨论
关于下课。

1651
01:17:18,030 --> 01:17:18,930
这是完全正确的。

1652
01:17:18,930 --> 01:17:20,530
所以，是正确的。

1653
01:17:20,530 --> 01:17:23,430
然后你可以有很多这样的，
他们将全部串连

1654
01:17:23,430 --> 01:17:24,950
连同这一点，。

1655
01:17:24,950 --> 01:17:25,900
所以这是完全正确的。

1656
01:17:25,900 --> 01:17:27,700
>> 还有一个问题。

1657
01:17:27,700 --> 01:17:30,676
画出此HTML的DOM，开始
与文件。

1658
01:17:30,676 --> 01:17:33,330

1659
01:17:33,330 --> 01:17:34,570
我们可以这样做，在两分钟。

1660
01:17:34,570 --> 01:17:36,790
我们将在这里做了。

1661
01:17:36,790 --> 01:17:38,040
我将回到这个网页。

1662
01:17:38,040 --> 01:17:40,630

1663
01:17:40,630 --> 01:17:42,160
OK，我们开始文档。

1664
01:17:42,160 --> 01:17:49,698

1665
01:17:49,698 --> 01:17:52,090
>> 下一步是什么？

1666
01:17:52,090 --> 01:17:53,910
所以，当你通读 - 

1667
01:17:53,910 --> 01:17:54,540
>> 观众：HTML。

1668
01:17:54,540 --> 01:17:55,790
>> JASON HIRSCHHORN：HTML是下一个。

1669
01:17:55,790 --> 01:17:57,850
我们将通过标签去标记。

1670
01:17:57,850 --> 01:18:00,890
什么是HTML呢？

1671
01:18:00,890 --> 01:18:01,550
>> 观众：头。

1672
01:18:01,550 --> 01:18:02,800
>> JASON HIRSCHHORN：头。

1673
01:18:02,800 --> 01:18:05,090

1674
01:18:05,090 --> 01:18:08,520
头后有什么？

1675
01:18:08,520 --> 01:18:09,770
>> 观众：标题。

1676
01:18:09,770 --> 01:18:11,880

1677
01:18:11,880 --> 01:18:12,560
>> JASON HIRSCHHORN：标题。

1678
01:18:12,560 --> 01:18:14,740
和标题有谷歌的价值，
但我不会去

1679
01:18:14,740 --> 01:18:16,240
写在现在。

1680
01:18:16,240 --> 01:18:18,750
好了，哪里的身体去了？

1681
01:18:18,750 --> 01:18:20,890
>> 观众：还有脱落的HTML。

1682
01:18:20,890 --> 01:18:21,490
>> JASON HIRSCHHORN：没错。

1683
01:18:21,490 --> 01:18:22,820
机身自带了这里。

1684
01:18:22,820 --> 01:18:25,970

1685
01:18:25,970 --> 01:18:30,330
难道大家都明白为什么
是这样的话？

1686
01:18:30,330 --> 01:18:32,970
你应该能够计算
这一点，也一样，即使我没有

1687
01:18:32,970 --> 01:18:33,665
这个漂亮的缩进。

1688
01:18:33,665 --> 01:18:37,680
>> 排序的缩进给它拿走，
但你可以看到，头部标记有

1689
01:18:37,680 --> 01:18:41,240
被关闭，这意味着我们可能
不能下去在这里。

1690
01:18:41,240 --> 01:18:43,460
我们需要回到多达什么
是头向右前

1691
01:18:43,460 --> 01:18:44,730
标签，或未满。

1692
01:18:44,730 --> 01:18:46,720
我们甚至用头标记。

1693
01:18:46,720 --> 01:18:48,560
>> 并在进入身体的形式。

1694
01:18:48,560 --> 01:18:50,300
下形式，有两个输入端。

1695
01:18:50,300 --> 01:18:53,330

1696
01:18:53,330 --> 01:18:54,420
确定。

1697
01:18:54,420 --> 01:18:55,490
这就是我的一切。

1698
01:18:55,490 --> 01:18:56,980
测验1是明天。

1699
01:18:56,980 --> 01:18:58,350
我很高兴为你们。

1700
01:18:58,350 --> 01:18:59,690
这将是一个爆炸。

1701
01:18:59,690 --> 01:19:00,250
>> 如果你有 - 

1702
01:19:00,250 --> 01:19:00,600
>> 观众：[掌声]

1703
01:19:00,600 --> 01:19:02,460
>> JASON HIRSCHHORN：哦停下来，停下来。

1704
01:19:02,460 --> 01:19:04,520
不过没有关系，我在开玩笑。

1705
01:19:04,520 --> 01:19:07,220
如果您有任何疑问，右
节后，我在外面。

1706
01:19:07,220 --> 01:19:11,700
如果您有任何疑问，今晚，
随时来电，电子邮件，gchat，

1707
01:19:11,700 --> 01:19:12,740
信鸽我。

1708
01:19:12,740 --> 01:19:13,950
祝你好运明天。

1709
01:19:13,950 --> 01:19:16,220
有一个美好的感恩节假期，
如果我没有看到你在那之前。

1710
01:19:16,220 --> 01:19:19,320
我会在感恩节之后见到你
对我们的最终周二

1711
01:19:19,320 --> 01:19:20,295
部分党永远。

1712
01:19:20,295 --> 01:19:21,545
>> 观众：[听不清]。

1713
01:19:21,545 --> 01:19:25,270

1714
01:19:25,270 --> 01:19:25,790
>> JASON HIRSCHHORN：太好了。

1715
01:19:25,790 --> 01:19:28,900
好吧，我看下你们
一周或两周。

1716
01:19:28,900 --> 01:19:30,150
而明天好运。

1717
01:19:30,150 --> 01:19:32,203