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

2
00:00:08,070 --> 00:00:10,430
>> R.J.阿基诺：让刚上手。

3
00:00:10,430 --> 00:00:12,310
因此，这是测验1。

4
00:00:12,310 --> 00:00:14,890
下面是一些高层次的信息。

5
00:00:14,890 --> 00:00:19,915
在关于页面的测验是在这个
的URL，不再CS50.net，尽管这

6
00:00:19,915 --> 00:00:21,080
仍然可以工作。

7
00:00:21,080 --> 00:00:26,920
这是CS50.harvard.edu/quizzes/2013/1。

8
00:00:26,920 --> 00:00:31,070
这是很大的关于页面，告诉你
何时何地，也就是下周三

9
00:00:31,070 --> 00:00:32,100
在一堆室。

10
00:00:32,100 --> 00:00:36,120
并通过下周三，我
意味着从现在开始两天。

11
00:00:36,120 --> 00:00:37,890
所有这些信息是存在的。

12
00:00:37,890 --> 00:00:39,110
但它是累积的。

13
00:00:39,110 --> 00:00:43,790
>> 所以一切从第一的一半
今年是潜在的测验，

14
00:00:43,790 --> 00:00:50,780
因为你不能真正做到先进
事情在C无，如果条件和

15
00:00:50,780 --> 00:00:51,920
for循环等。

16
00:00:51,920 --> 00:00:55,580
但会有一重
材料，因为测验0覆盖，

17
00:00:55,580 --> 00:00:59,570
首先是结构和文件
I / O。这是典型的多

18
00:00:59,570 --> 00:01:01,620
比测验0有挑战性。

19
00:01:01,620 --> 00:01:03,870
平均得分通常较低。

20
00:01:03,870 --> 00:01:05,980
努力学习。

21
00:01:05,980 --> 00:01:09,340
>> 当你在学习时，一定要使用
CS50/discuss张贴您的问题

22
00:01:09,340 --> 00:01:10,830
和阅读其他人的问题。

23
00:01:10,830 --> 00:01:13,550
所以，如果你没有任何问题，
登录并阅读

24
00:01:13,550 --> 00:01:14,580
您的朋友的问题。

25
00:01:14,580 --> 00:01:16,560
他们很可能好问题。

26
00:01:16,560 --> 00:01:17,730
并采取实践测验。

27
00:01:17,730 --> 00:01:20,750
我们已经给测验的
七八年了。

28
00:01:20,750 --> 00:01:22,180
他们在网上的所有。

29
00:01:22,180 --> 00:01:25,540
未来的问题是相似的
老问题。

30
00:01:25,540 --> 00:01:26,550
这就是我们如何让他们。

31
00:01:26,550 --> 00:01:27,740
>> 测验还不存在。

32
00:01:27,740 --> 00:01:28,670
我们没有看到它。

33
00:01:28,670 --> 00:01:32,496
但它看起来像
以前的测验。

34
00:01:32,496 --> 00:01:36,500
对于这种审查会议，这是不
专题的详尽清单。

35
00:01:36,500 --> 00:01:40,740
你不能只是出席本，然后
是完全准备好测验。

36
00:01:40,740 --> 00:01:43,330
否则，它不会是
太大的测验。

37
00:01:43,330 --> 00:01:46,270
这也是不一定
你需要知道的任何一切

38
00:01:46,270 --> 00:01:46,970
给定的主题。

39
00:01:46,970 --> 00:01:50,520
它的意思是暴露你的东西
我们已经介绍了，提醒你我们

40
00:01:50,520 --> 00:01:53,070
覆盖，并在途中
我们覆盖它。

41
00:01:53,070 --> 00:01:57,030
但是你将不得不更进一步，
更深层次的，当你学习到仔细检查

42
00:01:57,030 --> 00:02:00,230
你知道一切关于任何给定的
主题，你已经填写

43
00:02:00,230 --> 00:02:03,320
一切是那样的角落
涵盖讲座。

44
00:02:03,320 --> 00:02:07,980
>> 测验笔记告诉你去
抄写笔记，观看讲座视频。

45
00:02:07,980 --> 00:02:10,155
这是一个很好的方式，以确保你已经
涵盖了所有你的基地。

46
00:02:10,155 --> 00:02:12,670

47
00:02:12,670 --> 00:02:17,340
所以起步，当我做这些
幻灯片中，我试图把在那里我发现

48
00:02:17,340 --> 00:02:18,350
信息。

49
00:02:18,350 --> 00:02:22,890
因此，对于文件I / O，例如，第7周，
周一的演讲和张贴

50
00:02:22,890 --> 00:02:27,960
第6条和习题集都有
有关文件信息的I / O。我已经做了

51
00:02:27,960 --> 00:02:28,840
这对每一个议题。

52
00:02:28,840 --> 00:02:33,010
因此，那些标题幻灯片可能
对你有所帮助。

53
00:02:33,010 --> 00:02:38,950
>> 所以在这里我们有文件I / O。请记住，在
习题集5，我们使用的fopen，fclose的，

54
00:02:38,950 --> 00:02:41,210
FWRITE，用fread和fseek的。

55
00:02:41,210 --> 00:02:48,090
经回收30ish JPEG和
经调整大小和混乱

56
00:02:48,090 --> 00:02:50,320
位图，你应该很熟悉
这些功能

57
00:02:50,320 --> 00:02:51,830
以及它们如何工作。

58
00:02:51,830 --> 00:02:54,420
如果你不再熟悉，
绝对检讨。

59
00:02:54,420 --> 00:02:56,860
并确保您了解什么
不同的论点是，

60
00:02:56,860 --> 00:02:58,260
当他们使用。

61
00:02:58,260 --> 00:03:03,620
>> 但共同文件相关的错误
你可能会问 - 

62
00:03:03,620 --> 00:03:07,270
好吧，如果你忘了检查
FOPEN实际工作之前，你去

63
00:03:07,270 --> 00:03:08,350
修改文件。

64
00:03:08,350 --> 00:03:09,760
这可能是坏的。

65
00:03:09,760 --> 00:03:13,560
如果你忘了FCLOSE文件
你已经fopened，这是类似于

66
00:03:13,560 --> 00:03:14,400
内存泄漏。

67
00:03:14,400 --> 00:03:15,980
这是非常糟糕的。

68
00:03:15,980 --> 00:03:18,670
而忘记检查，如果你已经
之前你到达了文件的末尾

69
00:03:18,670 --> 00:03:19,790
开始写吧。

70
00:03:19,790 --> 00:03:22,320
>> 所以，如果你说，嘿，我在
该文件的末尾。

71
00:03:22,320 --> 00:03:23,750
给我5个字节。

72
00:03:23,750 --> 00:03:27,370
嗯，这可能不会
计算出你所期望的方式。

73
00:03:27,370 --> 00:03:30,930
这真的是对文件I / O，
因为我们做了这么多了

74
00:03:30,930 --> 00:03:32,300
这个问题设定。

75
00:03:32,300 --> 00:03:36,000
因此，如果你明白发生了什么事情
在习题集5，记得bitmats

76
00:03:36,000 --> 00:03:40,090
和JPEG文件，那么你很可能所有
为文件设置I / O。如果这是一个有点

77
00:03:40,090 --> 00:03:44,770
模糊，进行检讨这个问题
置和相关材料。

78
00:03:44,770 --> 00:03:51,110
>> 结构都认为是对的话题
0测验测验和1之间的线。

79
00:03:51,110 --> 00:03:53,090
并没有引起太大的削减测验0。

80
00:03:53,090 --> 00:03:57,040
所以他们一定会放在
测验1，第7周，周一。

81
00:03:57,040 --> 00:03:58,150
什么是结构？

82
00:03:58,150 --> 00:04:00,250
这里我们给出一个结构。

83
00:04:00,250 --> 00:04:03,140
这就像一个新类型。

84
00:04:03,140 --> 00:04:07,940
这就像一个容器
为多个字段。

85
00:04:07,940 --> 00:04:12,970
>> 在这种情况下，我们声明一个struct
学生有两个字段 - 

86
00:04:12,970 --> 00:04:17,750
我们正在调用一个字符串名称和
我们正在调用的年龄为int。

87
00:04:17,750 --> 00:04:21,450
所以，当我通过各地的学生或I
修改学生，我就可以

88
00:04:21,450 --> 00:04:24,430
访问他们的名字和他们的年龄。

89
00:04:24,430 --> 00:04:26,670
让我们来看看一些代码的。

90
00:04:26,670 --> 00:04:29,090
在这里，我们可以看到，我已经声明
一个学生的，就像

91
00:04:29,090 --> 00:04:30,300
我声明任何变量 - 

92
00:04:30,300 --> 00:04:32,430
诠释十，诠释y，等等。

93
00:04:32,430 --> 00:04:34,180
>> 这里的学生的。

94
00:04:34,180 --> 00:04:37,370
他开始没有在他的领域。

95
00:04:37,370 --> 00:04:38,240
因此，让我们设置它们。

96
00:04:38,240 --> 00:04:40,681
你设置点一个struct的领域。

97
00:04:40,681 --> 00:04:43,780
所以，我在这里说s.name = RJ。

98
00:04:43,780 --> 00:04:46,470
和s.age = 21。

99
00:04:46,470 --> 00:04:48,500
您也可以更新字段
你会更新以同样的方式

100
00:04:48,500 --> 00:04:49,550
一个变量的值。

101
00:04:49,550 --> 00:04:53,270
所以我想从RJ改变我的名字与
无期限至R.J.拼写

102
00:04:53,270 --> 00:04:54,540
正确的做法。

103
00:04:54,540 --> 00:04:58,890
这将是s.name = RJ，同样
正如我们所说的它最初。

104
00:04:58,890 --> 00:05:00,030
然后你就可以访问它们。

105
00:05:00,030 --> 00:05:00,930
>> 因此，我们已经设置它们。

106
00:05:00,930 --> 00:05:01,840
我们已经更新了他们。

107
00:05:01,840 --> 00:05:03,890
您也可以访问它们
在非常相同的方式。

108
00:05:03,890 --> 00:05:09,330
所以在这里，我打印出
R.J.是21岁。

109
00:05:09,330 --> 00:05:14,700
而且我访问这些值
与s.name和s.age。

110
00:05:14,700 --> 00:05:17,040
所以这存取结构
用点符号。

111
00:05:17,040 --> 00:05:17,850
是的，问题吗？

112
00:05:17,850 --> 00:05:21,176
>> 观众：有没有对一个原因
前一张幻灯片，你没有把

113
00:05:21,176 --> 00:05:24,848
学生在顶行，像的typedef
结构的学生，然后

114
00:05:24,848 --> 00:05:25,840
学生在结束了吗？

115
00:05:25,840 --> 00:05:29,040
>> R.J.阿基诺：所以现在的问题是，在
这张幻灯片，我们通常看到的

116
00:05:29,040 --> 00:05:32,400
typedef结构节点，然后
该结构的字段和

117
00:05:32,400 --> 00:05:34,250
然后字节点。

118
00:05:34,250 --> 00:05:37,790
以及如何来到这里我就不说了，的typedef
结构的学生，然后

119
00:05:37,790 --> 00:05:39,820
的结构，然后学生的领域？

120
00:05:39,820 --> 00:05:44,310
原因是，我不需要
该结构的内部访问它。

121
00:05:44,310 --> 00:05:46,270
所以，它的确定要离开它没有名字。

122
00:05:46,270 --> 00:05:49,210
我只能把它作为
匿名结构。

123
00:05:49,210 --> 00:05:53,130
>> 我们这样做是对链表和原因
事情是因为你内心需要

124
00:05:53,130 --> 00:05:55,360
引用一个结构节点明星。

125
00:05:55,360 --> 00:05:58,220
因此，该结构必须有一个名字，
所以你以后可以访问它。

126
00:05:58,220 --> 00:05:59,540
这是一个小细节。

127
00:05:59,540 --> 00:06:04,750
但你通常会看到typedef结构
大括号，如果你不需要

128
00:06:04,750 --> 00:06:08,720
的名称和typedef结构部分名称
其次是大括号，如果你愿意

129
00:06:08,720 --> 00:06:09,520
所需要的名字。

130
00:06:09,520 --> 00:06:12,070
所以这是一个很好的问题。

131
00:06:12,070 --> 00:06:17,000
>> 而在这一点上，我们倾向于修改
结构，并通过周围结构由

132
00:06:17,000 --> 00:06:18,680
引用，而不是价值。

133
00:06:18,680 --> 00:06:21,940
所以我们只指针传递给周围
结构，而不是在绕过

134
00:06:21,940 --> 00:06:23,150
结构本身。

135
00:06:23,150 --> 00:06:28,050
所以你很频繁将是
使用，在这种情况下，学生*或

136
00:06:28,050 --> 00:06:34,150
结构*节点或节点，而不是*
培养出来的学生或节点。

137
00:06:34,150 --> 00:06:39,350
所以在这里，我已经说过了，OK，变量PTR
将是s的地址。

138
00:06:39,350 --> 00:06:45,570
这将是指针
向学生R.J.

139
00:06:45,570 --> 00:06:48,965
>> 因此，我们可以在这些领域得到
因为我们得到什么一样。

140
00:06:48,965 --> 00:06:51,460
首先，身份证引用指针
得到的结构。

141
00:06:51,460 --> 00:06:55,530
这就是* PTR，然后
一个点和年龄。

142
00:06:55,530 --> 00:06:58,790
因此，要访问字段，我已经更新
现在到22，因为，让我们

143
00:06:58,790 --> 00:07:00,860
说，这是我的生日。

144
00:07:00,860 --> 00:07:03,990
有一个快捷方式语法
这里使用的箭头。

145
00:07:03,990 --> 00:07:07,060
所以PTR箭头年龄只是
一样* ptr.age。

146
00:07:07,060 --> 00:07:10,150

147
00:07:10,150 --> 00:07:11,550
现在，这件事情你必须
背诵和记忆。

148
00:07:11,550 --> 00:07:15,010
>> 你用了很多的pset6，
在拼写检查pset中。

149
00:07:15,010 --> 00:07:18,350
但其实这是怎么回事
在发动机罩的下面。

150
00:07:18,350 --> 00:07:20,500
它取消引用指针
然后访问它。

151
00:07:20,500 --> 00:07:21,432
问题？

152
00:07:21,432 --> 00:07:22,682
>> 观众：[听不清]。

153
00:07:22,682 --> 00:07:25,860

154
00:07:25,860 --> 00:07:28,060
>> R.J.阿基诺：那么，为什么我们使用
指针作为结构代替

155
00:07:28,060 --> 00:07:29,500
结构本身？

156
00:07:29,500 --> 00:07:33,740
究其原因是，如果你传递
一个结构体给一个函数，你可能

157
00:07:33,740 --> 00:07:36,900
要绕过只是4左右
表示指针的字节，作为

158
00:07:36,900 --> 00:07:40,375
相对于潜在的30或
40字节属于结构。

159
00:07:40,375 --> 00:07:44,410
所以传递的东西给一个函数
是容易当的东西

160
00:07:44,410 --> 00:07:48,230
在短较小。

161
00:07:48,230 --> 00:07:49,074
问题？

162
00:07:49,074 --> 00:07:53,026
>> 观众：你可能会提到这
在开始的时候，但在那里

163
00:07:53,026 --> 00:07:56,000
其他幻灯片上[听不清]？

164
00:07:56,000 --> 00:07:58,960
>> R.J.阿基诺：这些幻灯片将
了审查会议之后。

165
00:07:58,960 --> 00:08:00,210
我们将张贴在网站上。

166
00:08:00,210 --> 00:08:02,450

167
00:08:02,450 --> 00:08:06,870
因此，在移动和移动上略有
快，我们要谈的数据

168
00:08:06,870 --> 00:08:07,350
结构。

169
00:08:07,350 --> 00:08:08,040
也有很多。

170
00:08:08,040 --> 00:08:10,080
我们覆盖的一群人。

171
00:08:10,080 --> 00:08:12,500
这里是你应该了解
关于数据结构。

172
00:08:12,500 --> 00:08:15,590
>> 你应该明白在一个较高的
每级结构是什么。

173
00:08:15,590 --> 00:08:21,190
你可以用英语解释给你
这并没有采取CS50朋友如何

174
00:08:21,190 --> 00:08:25,580
我们组织我们的数据，以及我们为什么会
可以使用的东西以这种方式？

175
00:08:25,580 --> 00:08:26,990
这就是事情之一。

176
00:08:26,990 --> 00:08:29,650
东西两，理解
的实施。

177
00:08:29,650 --> 00:08:34,270
因此，了解如何使用这些东西
在C中，我们会去在这。

178
00:08:34,270 --> 00:08:39,030
>> 然后三件事会被知道
运行时间和的局限性

179
00:08:39,030 --> 00:08:40,470
你使用各种结构。

180
00:08:40,470 --> 00:08:44,059
所以，理解你为什么会用
哈希表，而不是一个数组。

181
00:08:44,059 --> 00:08:49,570
了解如何快速，平均而言，
访问一个哈希表。

182
00:08:49,570 --> 00:08:54,010
了解操作速度快什么
链表但对数组慢，

183
00:08:54,010 --> 00:08:56,080
反之亦然。

184
00:08:56,080 --> 00:08:59,780
因此，要理解这一点，你就必须
了解大O符号只知道

185
00:08:59,780 --> 00:09:01,310
如何谈论这些
各种各样的东西。

186
00:09:01,310 --> 00:09:02,700
我们会谈论。

187
00:09:02,700 --> 00:09:06,040
>> 所以第一件事情，链表。

188
00:09:06,040 --> 00:09:07,770
这里是一个高层次的图像
的一个链表。

189
00:09:07,770 --> 00:09:08,830
我们发现这在课堂上。

190
00:09:08,830 --> 00:09:11,670
我们通常有10人
站在舞台上。

191
00:09:11,670 --> 00:09:16,790
但我们有一系列节点，其中每个
节点有一定的价值和指针

192
00:09:16,790 --> 00:09:18,610
它的下一个值。

193
00:09:18,610 --> 00:09:21,730
因此，为了从一个节点到下一个，你
只是说，给我的下一个节点。

194
00:09:21,730 --> 00:09:22,530
您有节点。

195
00:09:22,530 --> 00:09:23,770
给我的下一个节点。

196
00:09:23,770 --> 00:09:24,400
您有节点。

197
00:09:24,400 --> 00:09:28,790
给我的下一个节点等
直到没有节点的左边。

198
00:09:28,790 --> 00:09:31,850
>> 所以继续谈
它在一个较高的水平。

199
00:09:31,850 --> 00:09:34,100
这是很容易插入的东西
成一个链表。

200
00:09:34,100 --> 00:09:36,010
如果你不关心顺序，
你能把它

201
00:09:36,010 --> 00:09:36,840
权利开头。

202
00:09:36,840 --> 00:09:38,520
这是恒定的时间。

203
00:09:38,520 --> 00:09:39,900
但很难找到一个值。

204
00:09:39,900 --> 00:09:43,060
如果你要问，
是在我的名单7？

205
00:09:43,060 --> 00:09:44,740
你必须要经过
每一个值。

206
00:09:44,740 --> 00:09:45,680
这是7？

207
00:09:45,680 --> 00:09:46,610
这是7？

208
00:09:46,610 --> 00:09:47,770
这是7？

209
00:09:47,770 --> 00:09:48,690
这是7？

210
00:09:48,690 --> 00:09:49,830
一遍又一遍。

211
00:09:49,830 --> 00:09:51,520
这就是为O（n）。

212
00:09:51,520 --> 00:09:53,800
因此，研究在答题时，
使用数组进行比较。

213
00:09:53,800 --> 00:09:57,010

214
00:09:57,010 --> 00:09:58,220
>> 这样可以吗？

215
00:09:58,220 --> 00:09:59,220
灯灭暗淡。

216
00:09:59,220 --> 00:10:01,110
确定。

217
00:10:01,110 --> 00:10:02,400
当是一个链表更好？

218
00:10:02,400 --> 00:10:04,640
如果是一个数组更好？

219
00:10:04,640 --> 00:10:06,670
因此，让我们来看看一些代码。

220
00:10:06,670 --> 00:10:08,960
这里是一个可能的节点。

221
00:10:08,960 --> 00:10:09,770
这是一个结构。

222
00:10:09,770 --> 00:10:12,220
它有一个int n，它
将是我们的价值。

223
00:10:12,220 --> 00:10:17,780
它有一个结构节点*未来，这
是我们的指针到下一个节点。

224
00:10:17,780 --> 00:10:23,040
所以在这里，我们可以看到，我们发生了
已经把一个int在我们​​的节点。

225
00:10:23,040 --> 00:10:27,850
但如果这是字符的链表
星或漂浮的链表，我们

226
00:10:27,850 --> 00:10:28,820
完全可以做到这一点。

227
00:10:28,820 --> 00:10:33,110
>> 记得在pset6，你可能有一个
焦炭星或只是链表

228
00:10:33,110 --> 00:10:34,360
静态字符数组。

229
00:10:34,360 --> 00:10:37,370

230
00:10:37,370 --> 00:10:39,040
让我们来看看在这里的操作。

231
00:10:39,040 --> 00:10:43,570
因此，我们要插入一个新的
n为进我们的链表。

232
00:10:43,570 --> 00:10:48,940
我们有一个头指针是开始了
一个指向该节点具有

233
00:10:48,940 --> 00:10:53,460
的n值和一个下一个指针的那
指向这个节点是一个值

234
00:10:53,460 --> 00:10:57,760
n和下一个空的，因为
它的最后一个节点。

235
00:10:57,760 --> 00:11:00,440
因此，在时间的关系，我会
把所有的代码在屏幕上。

236
00:11:00,440 --> 00:11:03,130
我们将通过它走
几行的时间。

237
00:11:03,130 --> 00:11:05,790
>> 因此，这里的代码。

238
00:11:05,790 --> 00:11:07,560
我希望它是可读的。

239
00:11:07,560 --> 00:11:11,275
我们做的第一件事是
我们用malloc一个新的节点。

240
00:11:11,275 --> 00:11:15,105
因此，它使一个指针到一个新的节点
不太有什么设置

241
00:11:15,105 --> 00:11:16,450
在它。

242
00:11:16,450 --> 00:11:19,580
我们检查，以确保
新节点不为null。

243
00:11:19,580 --> 00:11:22,220
否则，我们不得不放弃。

244
00:11:22,220 --> 00:11:27,680
因此，检查了这一点，我们现在
在节点中设置的值。

245
00:11:27,680 --> 00:11:31,520
所以我们把新的N到我们的n场。

246
00:11:31,520 --> 00:11:36,050
我们设置下一个指针指向
原来的头，这样我们就可以

247
00:11:36,050 --> 00:11:38,900
现在已插入此
节点进入我们的名单。

248
00:11:38,900 --> 00:11:44,600
>> 最后，我们有全球主管点
我们的新节点，所以，如果我们要

249
00:11:44,600 --> 00:11:50,300
在开始的头，我们将在此
新的第一个节点，而不是

250
00:11:50,300 --> 00:11:51,560
旧的第一个节点。

251
00:11:51,560 --> 00:11:55,320
当这个函数退出时，
变量新的节点不再存在，

252
00:11:55,320 --> 00:11:57,130
因为它是本地的功能。

253
00:11:57,130 --> 00:11:59,770
因此，这是世界的状态。

254
00:11:59,770 --> 00:12:03,570
我们的全球头指向我们的新
第一结点，它指向了

255
00:12:03,570 --> 00:12:06,346
原来的第一个节点，这点
到后，该节点。

256
00:12:06,346 --> 00:12:09,790
>> 这是插入。

257
00:12:09,790 --> 00:12:12,150
我希望这是相对
简单的跟随。

258
00:12:12,150 --> 00:12:14,300
如有疑问，画一幅画。

259
00:12:14,300 --> 00:12:17,820
所以，我觉得谈论
链表和看

260
00:12:17,820 --> 00:12:19,870
代码是非常无益的。

261
00:12:19,870 --> 00:12:23,790
而在寻找的链接图片
列表可以让我觉得，哦，所以

262
00:12:23,790 --> 00:12:24,970
我有这个节点在这里。

263
00:12:24,970 --> 00:12:28,980
但是，如果我更新指针，
它结束了断开。

264
00:12:28,980 --> 00:12:34,340
我已经忘了在那里
节点去。

265
00:12:34,340 --> 00:12:35,390
和代码退出。

266
00:12:35,390 --> 00:12:37,830
和你有多个节点
被断开。

267
00:12:37,830 --> 00:12:39,970
而你不结了
你想要的名单。

268
00:12:39,970 --> 00:12:43,320
>> 所以，如果你画的图画和做
一步一步，希望，你会看到

269
00:12:43,320 --> 00:12:46,840
事情来讲的正确顺序
更新指针，以确保

270
00:12:46,840 --> 00:12:48,830
该列表走到一起。

271
00:12:48,830 --> 00:12:51,240
插入相对比较简单。

272
00:12:51,240 --> 00:12:55,210
更复杂的是
插入到排序的列表。

273
00:12:55,210 --> 00:12:59,980
一个更复杂的功能是删除
和发现，所以期待通过列表

274
00:12:59,980 --> 00:13:03,030
看看是否有出现。

275
00:13:03,030 --> 00:13:07,220
也许你在pset6这样做，当你
钻进你的哈希表和你说了，

276
00:13:07,220 --> 00:13:10,460
好，这个词的苹果
在我的链接列表？

277
00:13:10,460 --> 00:13:11,440
>> 所以，你可能已经做到了这一点。

278
00:13:11,440 --> 00:13:15,530
但可以肯定，刷新你的记忆
并尝试重新实现查找和

279
00:13:15,530 --> 00:13:19,150
重写删除一个链表。

280
00:13:19,150 --> 00:13:22,850
有趣的旁注，也有双重链接
列表，在那里你必须

281
00:13:22,850 --> 00:13:27,490
指向正向和指针
落后的，这样你可以去

282
00:13:27,490 --> 00:13:29,270
下一个节点，并以前面的节点。

283
00:13:29,270 --> 00:13:33,860
而且是在去年的一个问题
测验该类型的，会说话

284
00:13:33,860 --> 00:13:36,190
关于双链表。

285
00:13:36,190 --> 00:13:40,070
>> 现在，这是你的结构
比较熟悉的，因为大多数

286
00:13:40,070 --> 00:13:42,520
你可能使用它们pset6。

287
00:13:42,520 --> 00:13:45,680
这里有一个有点不太熟悉。

288
00:13:45,680 --> 00:13:51,020
作为一个方面说明，我认为测验1
主要测验比0更难，因为

289
00:13:51,020 --> 00:13:54,600
你在做什么，你的东西
没有做一样多。

290
00:13:54,600 --> 00:13:58,100
把那个另一种方式，对于测验0，
你已经写了很多C的我们

291
00:13:58,100 --> 00:13:58,880
问你下

292
00:13:58,880 --> 00:14:02,310
>> 对于测验1，我们要问你
PHP和JavaScript，您

293
00:14:02,310 --> 00:14:03,490
没有写一样的。

294
00:14:03,490 --> 00:14:07,590
我们要问你的C代码的
你还没有写成多少，

295
00:14:07,590 --> 00:14:09,130
这个先进的C的东西。

296
00:14:09,130 --> 00:14:11,520
所以肯定，实践的东西，我们
演讲中谈到，你

297
00:14:11,520 --> 00:14:15,260
并不一定做
关于这个问题集。

298
00:14:15,260 --> 00:14:17,870
>> 说到这，你有没有写
一个堆栈上的一个问题集。

299
00:14:17,870 --> 00:14:19,610
但它是在课堂上。

300
00:14:19,610 --> 00:14:22,530
这里有一个高层次的画面
栈，我们表明，每年。

301
00:14:22,530 --> 00:14:26,180
它的托盘堆叠中
在奥美食堂。

302
00:14:26,180 --> 00:14:30,570
在较高的水平，栈是最后的
入先出的数据结构。

303
00:14:30,570 --> 00:14:32,040
这意味着你要去
把东西 - 

304
00:14:32,040 --> 00:14:36,400
1，3，7，12，14，负0。

305
00:14:36,400 --> 00:14:39,180
有一件事我不能有
说 - 负3，0。

306
00:14:39,180 --> 00:14:40,250
你把所有这些东西英寸

307
00:14:40,250 --> 00:14:42,940
，最后一个你把是第一
一个的走出来。

308
00:14:42,940 --> 00:14:44,170
>> 所以，你有两个操作 - 

309
00:14:44,170 --> 00:14:45,260
压入和弹出。

310
00:14:45,260 --> 00:14:49,180
所有投入，我是
手势像这样的推动。

311
00:14:49,180 --> 00:14:52,020
然后当我在抢达到
东西或顶部到达抢

312
00:14:52,020 --> 00:14:53,940
什么东西，这就是流行。

313
00:14:53,940 --> 00:14:55,540
所以，我们要实现堆栈。

314
00:14:55,540 --> 00:14:57,870
而且我们发现他们在讲座
使用数组。

315
00:14:57,870 --> 00:14:59,550
但你可以做他们
使用链表。

316
00:14:59,550 --> 00:15:01,770
栈是一种概念上的数据
结构，不喜欢的

317
00:15:01,770 --> 00:15:03,760
特定实现的。

318
00:15:03,760 --> 00:15:06,420
>> 那么，什么将是什么样子？

319
00:15:06,420 --> 00:15:07,970
它看起来有点像这样。

320
00:15:07,970 --> 00:15:10,840
你必须为整数的大小。

321
00:15:10,840 --> 00:15:16,000
而且你已经有了值的数组
我们调用托盘，因为这是

322
00:15:16,000 --> 00:15:18,570
图片是什么
我们 -  INT托盘 - 

323
00:15:18,570 --> 00:15:21,740
然后一些最大容量。

324
00:15:21,740 --> 00:15:27,100
那么，什么将推动样子？

325
00:15:27,100 --> 00:15:33,250
那么，如果我们有一个堆栈s，则推
东西到的，相信我们会得到

326
00:15:33,250 --> 00:15:34,620
s的大小。

327
00:15:34,620 --> 00:15:42,270
而这将是下一个
我们的数组的空位。

328
00:15:42,270 --> 00:15:50,510
所以，如果我们有三个东西在我们的协议栈，
然后盘3将是下一个

329
00:15:50,510 --> 00:15:54,290
开放的现场，因为0，1，和
2顷已经填满。

330
00:15:54,290 --> 00:16:01,790
>> 所以我们把值放入
s.trays [s.size]，第三位。

331
00:16:01,790 --> 00:16:06,290
然后我们增加s.size说，
哎，我们之前有三件事情。

332
00:16:06,290 --> 00:16:07,400
现在，我们有四个。

333
00:16:07,400 --> 00:16:10,180
因此，下一次你推，你
打算把东西放到4。

334
00:16:10,180 --> 00:16:15,560
或者下一次你弹出，你会
来看看3而不是4或什么的。

335
00:16:15,560 --> 00:16:18,000
然后我们将返回true
比方说，嘿，我们成功了。

336
00:16:18,000 --> 00:16:19,160
这个工作。

337
00:16:19,160 --> 00:16:22,060
作为一个经验法则，如果一个函数是
应该返回true或

338
00:16:22,060 --> 00:16:26,370
假的总是返回true，则可能
做错事。

339
00:16:26,370 --> 00:16:28,350
所以做这项工作？

340
00:16:28,350 --> 00:16:32,400
>> 好吧，它工作正常1，和
2，和3和4，和5。

341
00:16:32,400 --> 00:16:34,640
但是，让我们说我达到我的能力。

342
00:16:34,640 --> 00:16:38,750
然后，我遇到了一个问题，因为
如果大小是一样的能力，我

343
00:16:38,750 --> 00:16:43,340
现在试图把东西放到一个
数组，其中我没有空间。

344
00:16:43,340 --> 00:16:46,980
所以简单的检查，以解决这个问题。

345
00:16:46,980 --> 00:16:51,630
如果s.size ==容量，返回false。

346
00:16:51,630 --> 00:16:54,130
否则，去做我们所做的事情。

347
00:16:54,130 --> 00:16:55,660
那么，我们还有什么可以问
有关栈？

348
00:16:55,660 --> 00:16:56,460
还有什么你应该学习？

349
00:16:56,460 --> 00:16:57,690
还有什么你应该练习？

350
00:16:57,690 --> 00:17:01,030
>> 好吧，实施弹出。

351
00:17:01,030 --> 00:17:02,370
我们已经做了推送。

352
00:17:02,370 --> 00:17:04,280
我会解决这个问题。

353
00:17:04,280 --> 00:17:08,180
非数组实现，其中
你用一个链表，也许。

354
00:17:08,180 --> 00:17:09,390
非整数实现。

355
00:17:09,390 --> 00:17:10,940
我们做了整型这里。

356
00:17:10,940 --> 00:17:11,880
但它可能是花车。

357
00:17:11,880 --> 00:17:13,010
我本来是字符串。

358
00:17:13,010 --> 00:17:14,290
它可能是字符明星。

359
00:17:14,290 --> 00:17:17,960
看看以往测验的种类
问题我们已经问栈。

360
00:17:17,960 --> 00:17:20,000
>> 我会说，我们周围覆盖栈
正如我们已经讨论了他们在同一个

361
00:17:20,000 --> 00:17:20,540
过去几年。

362
00:17:20,540 --> 00:17:24,400
因此，问答题应
是一个很好的迹象。

363
00:17:24,400 --> 00:17:27,010
展望未来更快，排队。

364
00:17:27,010 --> 00:17:28,200
他们就像栈。

365
00:17:28,200 --> 00:17:29,960
但他们是先入先出。

366
00:17:29,960 --> 00:17:33,530
如果你是英国人，字队列
大概做了很多有意义的你。

367
00:17:33,530 --> 00:17:36,390
否则，你可能有
听说它作为一条线。

368
00:17:36,390 --> 00:17:38,120
他们的工作就像行
在苹果商店。

369
00:17:38,120 --> 00:17:40,740
的第一人出现在3:00
早晨是第一

370
00:17:40,740 --> 00:17:42,880
人买他的iPad。

371
00:17:42,880 --> 00:17:44,260
>> 因此，我们有两个操作 - 

372
00:17:44,260 --> 00:17:45,720
入队和出队。

373
00:17:45,720 --> 00:17:47,560
排队的人把在该行。

374
00:17:47,560 --> 00:17:50,070
出列拉第一
人断了线。

375
00:17:50,070 --> 00:17:52,640
同样，我们可以实现
这同一个数组。

376
00:17:52,640 --> 00:17:54,880
那么，什么是结构我们
在演讲显示？

377
00:17:54,880 --> 00:17:57,660
它是这一个。

378
00:17:57,660 --> 00:17:59,300
再次，数字。

379
00:17:59,300 --> 00:18:02,020
再次，大小和这个新事物面前。

380
00:18:02,020 --> 00:18:04,880
为什么会出现一些所谓的面前？

381
00:18:04,880 --> 00:18:07,050
它的下一个索引
元素出列。

382
00:18:07,050 --> 00:18:12,210
这只是内部保持跟踪
第一个人展现出来，让大家

383
00:18:12,210 --> 00:18:15,005
可以拉出来的时候，我们需要。

384
00:18:15,005 --> 00:18:19,322
>> 一定要看看讲义，并尝试
实施入队和出队

385
00:18:19,322 --> 00:18:21,700
攻读测验时。

386
00:18:21,700 --> 00:18:23,190
重要的事情要思考的问题。

387
00:18:23,190 --> 00:18:27,260
环绕着，如果前面加上
大小最终大于能力。

388
00:18:27,260 --> 00:18:32,670
同样，如果你的结构是完整的，
你将有问题。

389
00:18:32,670 --> 00:18:34,780
哈希你以前见过的表。

390
00:18:34,780 --> 00:18:39,820
大多数时候，你可能实现
这些对pset6。

391
00:18:39,820 --> 00:18:44,210
这是一个结构，其目的是为O（1）
固定时间的插入和O（1）

392
00:18:44,210 --> 00:18:46,430
恒定的时间查找。

393
00:18:46,430 --> 00:18:49,760
>> 在CS50，我们实施这个作为
链表的数组。

394
00:18:49,760 --> 00:18:53,690
关键部件到一个哈希表
是散列函数。

395
00:18:53,690 --> 00:18:58,350
所以它转换成你的输入，让我们说，
字典中的词，变成一个数字，

396
00:18:58,350 --> 00:18:59,560
这将是我们的索引。

397
00:18:59,560 --> 00:19:01,410
我们将使用该索引
进入我们的数组。

398
00:19:01,410 --> 00:19:05,374
所以这里有一个可爱的小图片
从study.50.net。

399
00:19:05,374 --> 00:19:08,060
我们扔掉所有的话到
我们的哈希函数。

400
00:19:08,060 --> 00:19:10,950
和散列函数告诉我们
在哪里把这些话。

401
00:19:10,950 --> 00:19:15,650
>> 这是所有伟大的土地上
这里只有一个用于每个时隙字。

402
00:19:15,650 --> 00:19:20,480
但是当你从pset6记得，有
比插槽更多的单词。

403
00:19:20,480 --> 00:19:23,080
所以会发生什么，当你
得到一个碰撞？

404
00:19:23,080 --> 00:19:26,730
相反，在存储一个值
让我们说，哈希表3，你

405
00:19:26,730 --> 00:19:27,990
存储一个链表。

406
00:19:27,990 --> 00:19:32,900
并因此而不必哈密瓜
在这里，你将有一个链表，

407
00:19:32,900 --> 00:19:34,190
其中的第一个节点是香瓜。

408
00:19:34,190 --> 00:19:35,260
和下一个节点是猫。

409
00:19:35,260 --> 00:19:38,970
和第三节点是碰撞，让我们
说，因为所有的这些词开始

410
00:19:38,970 --> 00:19:41,110
与C

411
00:19:41,110 --> 00:19:42,700
>> 所以，你最该做的pset6。

412
00:19:42,700 --> 00:19:45,685
如果你没有做一个哈希表上pset6
而您试图像

413
00:19:45,685 --> 00:19:47,720
一个线索，进行检讨哈希表。

414
00:19:47,720 --> 00:19:50,650
如果你确实这样做了就pset6，绝对
检查哈希表。

415
00:19:50,650 --> 00:19:53,610
如果你做到了对pset6才没有
制定出完全正确，你

416
00:19:53,610 --> 00:19:56,150
有很多麻烦吧，绝对
检查哈希表。

417
00:19:56,150 --> 00:20:01,610
所以，真正的教训肯定是
检查哈希表。

418
00:20:01,610 --> 00:20:07,130
>> 你试过广大少数民族
出试穿pset6。

419
00:20:07,130 --> 00:20:08,570
高层次的图片。

420
00:20:08,570 --> 00:20:15,150
它是这样的，其中每个
节点有一组儿童，其中每个

421
00:20:15,150 --> 00:20:17,100
孩子对应一个字母。

422
00:20:17,100 --> 00:20:20,520
并且每个节点还表示，
哎，我是一个字。

423
00:20:20,520 --> 00:20:25,933
所以在这种情况下，字麦克斯韦
如果你按照M来了A到

424
00:20:25,933 --> 00:20:28,530
X-W-E-L-L，然后按照它多。

425
00:20:28,530 --> 00:20:32,800
你会得到这个符号，三角形，这
我们要表明的意思是这是一个词。

426
00:20:32,800 --> 00:20:34,780
因此，麦克斯韦是一个词。

427
00:20:34,780 --> 00:20:38,430
这些增量在整个符号化
这东西的话，哪些

428
00:20:38,430 --> 00:20:40,360
东西都没有。

429
00:20:40,360 --> 00:20:46,400
>> 所以在pset6，数据存储我们
沿着我们的任何节点是“我是一个

430
00:20:46,400 --> 00:20:52,630
一句话。“而关于尝试的很酷的事情
是他们表现出的插入和

431
00:20:52,630 --> 00:20:55,080
查找在O（一个字的长度）。

432
00:20:55,080 --> 00:20:59,450
因此，只要打通麦克斯韦，它的
M-A-X-W-E-L-L。所以，七，八 - 

433
00:20:59,450 --> 00:21:00,360
我不能指望 - 

434
00:21:00,360 --> 00:21:03,920
步骤到达终点
并检查出来的东西。

435
00:21:03,920 --> 00:21:06,800
这么快实现这里。

436
00:21:06,800 --> 00:21:10,230
罗布通过链接去
列出在他死后。

437
00:21:10,230 --> 00:21:11,600
因此，检查了这一点。

438
00:21:11,600 --> 00:21:11,720
抱歉。

439
00:21:11,720 --> 00:21:13,240
通过他死后一个线索去了。

440
00:21:13,240 --> 00:21:14,260
因此，检查了这一点。

441
00:21:14,260 --> 00:21:24,410
>> 但你基本上每个节点有27个
指针到下一个节点和一个

442
00:21:24,410 --> 00:21:27,050
布尔对我是一个字。

443
00:21:27,050 --> 00:21:31,530
退房Rob的死后如何
这实际上是落实。

444
00:21:31,530 --> 00:21:34,750
我们的最终结构，我们的树
和二叉搜索树。

445
00:21:34,750 --> 00:21:41,530
所以，看着这些，这些被覆盖
最近8周，周一。

446
00:21:41,530 --> 00:21:46,960
树是类似于特里，除了你
不一定必须在27个节点

447
00:21:46,960 --> 00:21:47,500
每个点。

448
00:21:47,500 --> 00:21:52,820
而你没有在每一个有这种数据
一步，标志着是否 - 

449
00:21:52,820 --> 00:21:54,030
路径无所谓。

450
00:21:54,030 --> 00:22:00,870
而一个线索，该路径从顶部到
底，麦克斯韦，重要的是我们。

451
00:22:00,870 --> 00:22:05,270
>> 但每个节点有多个
孩子，也许。

452
00:22:05,270 --> 00:22:07,290
我们有更多的词汇。

453
00:22:07,290 --> 00:22:09,530
树的根
是在最高层。

454
00:22:09,530 --> 00:22:12,520
而我们说的很底层
有没有节点

455
00:22:12,520 --> 00:22:14,530
孩子是树叶。

456
00:22:14,530 --> 00:22:18,040
所以，像特里，一棵树是
节点的结构。

457
00:22:18,040 --> 00:22:21,490
树，我们要去一个常见类型
谈的是一个二叉树，其中

458
00:22:21,490 --> 00:22:26,040
每个节点没有子节点或
一个孩子或两个孩子。

459
00:22:26,040 --> 00:22:28,890
所以，这幅画在这里就不
一个二叉树，因为

460
00:22:28,890 --> 00:22:32,890
节点3有三个孩子。

461
00:22:32,890 --> 00:22:38,140
>> 但如果我们忽视这些，剩下的
它是一个二叉树，因为它

462
00:22:38,140 --> 00:22:43,200
表明每个节点的属性
具有零个，一个或两个孩子。

463
00:22:43,200 --> 00:22:46,400
所以，我们怎么能表达这种代码？

464
00:22:46,400 --> 00:22:51,460
我们可以有一个节点，其中每个节点有
在它的内部的一个整数，以及

465
00:22:51,460 --> 00:22:55,590
作为指向左侧的树
和一个指向上的树

466
00:22:55,590 --> 00:22:59,510
对，所以这两个孩子。

467
00:22:59,510 --> 00:23:00,880
这是怎么有用吗？

468
00:23:00,880 --> 00:23:05,740
那么，如果我们做出有关规定，我们
把节点，我们可以使搜索更快。

469
00:23:05,740 --> 00:23:10,630
>> 所以这是一个二分查找的概念
树，在那里上的所有节点

470
00:23:10,630 --> 00:23:14,420
左子树有一个较小的值
比节点，我们正在寻找。

471
00:23:14,420 --> 00:23:17,880
和右子树的所有节点
有一个更大的价值

472
00:23:17,880 --> 00:23:18,660
比根节点。

473
00:23:18,660 --> 00:23:20,670
现在，看起来像很多的话。

474
00:23:20,670 --> 00:23:23,770
我打算把它的内部双
报价和展示你的照片。

475
00:23:23,770 --> 00:23:27,010
因此，这里是一个例子
二叉搜索树。

476
00:23:27,010 --> 00:23:28,770
看到我们开始10。

477
00:23:28,770 --> 00:23:31,780
一切向左侧
图10是比它小。

478
00:23:31,780 --> 00:23:33,130
和我的一切的权利
大于它。

479
00:23:33,130 --> 00:23:37,620
>> 但更重要的是，在每个节点
树表示这个属性。

480
00:23:37,620 --> 00:23:42,110
所以，节点7具有3到
左和9到右侧。

481
00:23:42,110 --> 00:23:44,440
因此，所有这些都小于10。

482
00:23:44,440 --> 00:23:50,470
但看着眼前这些时，有7
3到它的左和9在它的右边。

483
00:23:50,470 --> 00:23:56,100
同样在右侧，15有14个
到它的左和50在其右侧。

484
00:23:56,100 --> 00:24:03,770
所以那边的三个节点，15，14，
和50，也是一个有效的二进制树

485
00:24:03,770 --> 00:24:05,480
或有效的二叉搜索树。

486
00:24:05,480 --> 00:24:07,250
而且他们都大于10。

487
00:24:07,250 --> 00:24:08,960
因此，他们被允许为
就在那里。

488
00:24:08,960 --> 00:24:09,940
有没有问题？

489
00:24:09,940 --> 00:24:12,580
>> 观众：你如何处理时，
你有两个七人榄球赛？

490
00:24:12,580 --> 00:24:12,850
>> R.J.阿基诺：是啊。

491
00:24:12,850 --> 00:24:16,550
你如何处理与两个值
这是一样的吗？

492
00:24:16,550 --> 00:24:21,465
一些二叉搜索树说，你
忽略重复的，因为我们的目标是

493
00:24:21,465 --> 00:24:24,280
只是说，我见过
这些事情至今。

494
00:24:24,280 --> 00:24:28,120
一些二叉搜索树，你可以说
有节点的内部计数。

495
00:24:28,120 --> 00:24:32,000
其他人可能会说，一切以
左边是小于或等于。

496
00:24:32,000 --> 00:24:33,470
和我的一切的权利
大于。

497
00:24:33,470 --> 00:24:36,520
>> 这只是取决于什么
问题是你正在解决。

498
00:24:36,520 --> 00:24:40,840
因此，在一个字典，例如，你
不会在乎重复。

499
00:24:40,840 --> 00:24:41,490
你会扔出来。

500
00:24:41,490 --> 00:24:44,719
但其他一些问题，你可能会在乎。

501
00:24:44,719 --> 00:24:49,242
>> 观众：是否有可能有
一个1到15的左侧，而

502
00:24:49,242 --> 00:24:50,590
小于10？

503
00:24:50,590 --> 00:24:51,885
>> R.J.阿基诺：号

504
00:24:51,885 --> 00:24:56,570
如果这里的14是一个1，这将
不是一个有效的二叉搜索树，

505
00:24:56,570 --> 00:25:00,840
因为一切的权利
10必须是大于它。

506
00:25:00,840 --> 00:25:02,300
我们就会明白为什么。

507
00:25:02,300 --> 00:25:07,960
如果在搜索的土地我的目标是
找到14，我从根开始。

508
00:25:07,960 --> 00:25:08,500
所以我期待。

509
00:25:08,500 --> 00:25:08,710
确定。

510
00:25:08,710 --> 00:25:10,670
我们打​​算从根开始。

511
00:25:10,670 --> 00:25:12,500
看10。

512
00:25:12,500 --> 00:25:16,050
>> 好了，14，我们的目标，
大于10。

513
00:25:16,050 --> 00:25:17,370
因此它必须是在右侧。

514
00:25:17,370 --> 00:25:21,780
这是非常相似的整个电话
本书的事情，我们所做的，二进制

515
00:25:21,780 --> 00:25:23,720
搜索那里。

516
00:25:23,720 --> 00:25:26,430
但是，而不是二进制搜索
在阵列中，我们的二进制

517
00:25:26,430 --> 00:25:28,490
在搜索这棵树。

518
00:25:28,490 --> 00:25:31,260
因此，我们仍然在寻找14。

519
00:25:31,260 --> 00:25:32,480
以及，图14是小于15。

520
00:25:32,480 --> 00:25:36,430
所以，如果它在我们的树，它必须
在这个区域在这里。

521
00:25:36,430 --> 00:25:39,680
它必须向右侧
10和15的左侧。

522
00:25:39,680 --> 00:25:42,250
>> 因此，我们检查这个节点。

523
00:25:42,250 --> 00:25:45,790
和耶，我们发现有14条。

524
00:25:45,790 --> 00:25:46,760
我不打算走过它。

525
00:25:46,760 --> 00:25:48,090
但这里的代码。

526
00:25:48,090 --> 00:25:49,690
它实际上是相对
简单，

527
00:25:49,690 --> 00:25:52,630
因为这是递归的。

528
00:25:52,630 --> 00:25:55,420
还有什么比我们要求你做一个小测验？

529
00:25:55,420 --> 00:25:57,000
我们可以要求你写这段代码。

530
00:25:57,000 --> 00:25:59,170
我们可以请你看看这个代码
并修改这个代码，并解释

531
00:25:59,170 --> 00:26:00,210
它在干什么。

532
00:26:00,210 --> 00:26:00,390
是啊。

533
00:26:00,390 --> 00:26:00,770
问题？

534
00:26:00,770 --> 00:26:04,240
>> 观众：难道这些幻灯片将是
提供，因为他们是最后一次？

535
00:26:04,240 --> 00:26:04,740
>> R.J.阿基诺：是的。

536
00:26:04,740 --> 00:26:06,460
所以，这些幻灯片肯定会
发布。

537
00:26:06,460 --> 00:26:08,640
>> 观众：他们实际上张贴
现在在网站上。

538
00:26:08,640 --> 00:26:10,020
大卫只是做了。

539
00:26:10,020 --> 00:26:12,720
>> R.J.阿基诺：该幻灯片
现在在网站上。

540
00:26:12,720 --> 00:26:16,420
我可能会修补了几个
错别字我注意到和解决这些问题。

541
00:26:16,420 --> 00:26:19,940
但是有一个电流
版本在网站上。

542
00:26:19,940 --> 00:26:21,820
其他的事情，我们可以要求你做 - 

543
00:26:21,820 --> 00:26:23,790
写插件。

544
00:26:23,790 --> 00:26:27,490
写一个迭代版本的
递归函数，我们刚才给你看

545
00:26:27,490 --> 00:26:32,520
或谈论这些事情，就像在
段落，文字，句子。

546
00:26:32,520 --> 00:26:35,760
比较运行时间，并解释
你想使用二进制什么

547
00:26:35,760 --> 00:26:39,200
供，而不是一个搜索树
哈希表，例如。

548
00:26:39,200 --> 00:26:43,580
>> 因此，了解这些结构
在一个相当深的程度。

549
00:26:43,580 --> 00:26:47,440
了解如何编写它们，如何
使用它们，如何谈论他们。

550
00:26:47,440 --> 00:26:50,270
，你会被所有的设置。

551
00:26:50,270 --> 00:26:50,630
问题？

552
00:26:50,630 --> 00:26:55,070
>> 观众：当你写的
二叉搜索树，你怎么了

553
00:26:55,070 --> 00:27:01,460
确定什么样的价值，以
把它作为根？

554
00:27:01,460 --> 00:27:06,120
>> R.J.阿基诺：所以现在的问题是，是什么
值做才能让你以root？

555
00:27:06,120 --> 00:27:08,760
根据你的代码，你
可能有一个全球性的根源。

556
00:27:08,760 --> 00:27:14,290
所以，你可能已经可能在过
pset6一个全球性的哈希表。

557
00:27:14,290 --> 00:27:18,640
或者你可以通过根
作为一个参数。

558
00:27:18,640 --> 00:27:23,810
所以这个搜索功能在这里
需要一个参数，一个节点*。

559
00:27:23,810 --> 00:27:27,420
所以任何节点你碰巧是
看到的是你对待一个

560
00:27:27,420 --> 00:27:31,510
作为你的根，当你通过它。

561
00:27:31,510 --> 00:27:32,320
和我都准备好。

562
00:27:32,320 --> 00:27:33,480
这些都是我的幻灯片。

563
00:27:33,480 --> 00:27:35,940
旁边的人可以来交换
在一台笔记本电脑和麦克风。

564
00:27:35,940 --> 00:27:47,390

565
00:27:47,390 --> 00:27:49,760
>> ROB BOWDEN：我想我可能有
不同的解释这个问题。

566
00:27:49,760 --> 00:27:53,826
但我把它理解成，如果你有
数字1，2和3，我们如何

567
00:27:53,826 --> 00:27:56,720
知道要2根
相对于1或3？

568
00:27:56,720 --> 00:27:59,480
如果我们让2根，那么它的好听
1和3的左侧和右侧。

569
00:27:59,480 --> 00:28:04,610
但是，如果1是根，那么它的1到
顶，2右，3到右侧。

570
00:28:04,610 --> 00:28:10,880
因此默认情况下，你不知道
怎样弄根。

571
00:28:10,880 --> 00:28:15,400
而对于任何算法，我们正在期待
给你，只是你首先

572
00:28:15,400 --> 00:28:16,680
插入将是根。

573
00:28:16,680 --> 00:28:19,890
或者，我们会给您一个二进制树
已存在有一个根。

574
00:28:19,890 --> 00:28:24,760
但其他的算法存在，使得
根将更新，所以，如果

575
00:28:24,760 --> 00:28:28,370
结束的情况下，其中它的1，2，
3，它会自动更新到

576
00:28:28,370 --> 00:28:30,900
使2新根，使
它还是很好的平衡。

577
00:28:30,900 --> 00:28:33,750

578
00:28:33,750 --> 00:28:34,833
>> 安琪拉李：酷。

579
00:28:34,833 --> 00:28:36,170
嘿，伙计们。

580
00:28:36,170 --> 00:28:37,810
我是安吉拉。

581
00:28:37,810 --> 00:28:42,490
我要去干掉我们的C
然后进入我们的一些网页

582
00:28:42,490 --> 00:28:43,120
技术 - 

583
00:28:43,120 --> 00:28:46,570
HTTP，HTML和CSS。

584
00:28:46,570 --> 00:28:49,610
所以，第一件事就是缓冲
溢出攻击。

585
00:28:49,610 --> 00:28:53,070
因此，让我们来看看这段代码。

586
00:28:53,070 --> 00:28:54,260
这是很简单的。

587
00:28:54,260 --> 00:28:55,460
有一个函数foo。

588
00:28:55,460 --> 00:28:56,990
它不返回任何东西。

589
00:28:56,990 --> 00:29:00,950
但它需要在一个指针
一个叫巴字符串。

590
00:29:00,950 --> 00:29:04,920
>> 并且它要声明这个
缓冲器，它是一个字符

591
00:29:04,920 --> 00:29:07,690
阵列有12个插槽。

592
00:29:07,690 --> 00:29:11,730
它使用的memcpy，这仅仅是一个
函数，从一个地址拷贝

593
00:29:11,730 --> 00:29:12,910
到另一个。

594
00:29:12,910 --> 00:29:19,400
因此，这是试图复制到
我们无论从任何缓冲

595
00:29:19,400 --> 00:29:21,140
酒吧指向。

596
00:29:21,140 --> 00:29:24,640
所以任何想法什么是错的
与此代码？

597
00:29:24,640 --> 00:29:27,568

598
00:29:27,568 --> 00:29:30,830
>> 观众：如果酒吧是长于
C，它们将覆盖。

599
00:29:30,830 --> 00:29:31,520
>> 安琪拉李：是的，没错。

600
00:29:31,520 --> 00:29:34,200
我们不能保证吧
将是小于12。

601
00:29:34,200 --> 00:29:36,080
我们只是做了一些任意数量的12。

602
00:29:36,080 --> 00:29:38,380
和我们一样，让我们​​希望，
我们的用户输入小于

603
00:29:38,380 --> 00:29:40,440
12个字符长。

604
00:29:40,440 --> 00:29:46,320
因此，在一个理想的世界，如果我们的输入是
总是不如预期，那么我们会得到

605
00:29:46,320 --> 00:29:47,550
类似的东西，你好。

606
00:29:47,550 --> 00:29:48,920
这是少于12个字符。

607
00:29:48,920 --> 00:29:51,870
它被读入字符角

608
00:29:51,870 --> 00:29:53,280
然后我们用它做什么。

609
00:29:53,280 --> 00:29:54,800
这其实并不重要。

610
00:29:54,800 --> 00:29:59,740
>> 但是恶意的人可以做
更多的东西像这样，他们在那里

611
00:29:59,740 --> 00:30:04,760
给我们什么吧指向，
它会指向这个巨大的数组

612
00:30:04,760 --> 00:30:06,280
只是A的。

613
00:30:06,280 --> 00:30:10,680
这是比12路更长。

614
00:30:10,680 --> 00:30:13,830
所以它会一路走下去
到这里，以那里的回报

615
00:30:13,830 --> 00:30:15,420
地址曾经是。

616
00:30:15,420 --> 00:30:17,860
所以我们可以说这个功能
被叫做foo。

617
00:30:17,860 --> 00:30:20,970
也许富被称为由其他
功能，这是由主程序调用的。

618
00:30:20,970 --> 00:30:24,890
因此，当foo的运行，它需要
知道在哪里返回。

619
00:30:24,890 --> 00:30:29,130
>> 如果foo调用一些函数命名
巴兹，它必须知道它的

620
00:30:29,130 --> 00:30:30,250
得回去巴兹。

621
00:30:30,250 --> 00:30:34,040
而这正是这个返回地址
这儿告诉我们。

622
00:30:34,040 --> 00:30:38,340
但是，如果我们覆盖它与其他一些
地址，在这种情况下，这是一个

623
00:30:38,340 --> 00:30:42,650
在地址的表示
最开始这个缓冲区，然后

624
00:30:42,650 --> 00:30:45,240
什么实际将要发生的是，
而不是返回回巴兹，

625
00:30:45,240 --> 00:30:48,470
这被称为我们的函数，它只是
要去这段代码的前面。

626
00:30:48,470 --> 00:30:53,930
>> 如果这是因为有一个
恶意黑客的家伙来了，

627
00:30:53,930 --> 00:30:56,820
注射这一点，那么也许这个数额
A的实际上不是的。

628
00:30:56,820 --> 00:31:02,030
它实际上只是代码的休息
你的电脑什么的。

629
00:31:02,030 --> 00:31:05,930
因此，为了防守这类型的
首先，你必须永远不能假定

630
00:31:05,930 --> 00:31:09,120
用户输入是在一定
数目的字符。

631
00:31:09,120 --> 00:31:13,310
例如，当你在做
拼写检查，你被告知的话是

632
00:31:13,310 --> 00:31:15,580
只有将是40个字符
长的最大值。

633
00:31:15,580 --> 00:31:16,570
那是不错的。

634
00:31:16,570 --> 00:31:20,150
>> 但如果没有，那么你就必须
请务必阅读只是在45

635
00:31:20,150 --> 00:31:21,520
字符的时间。

636
00:31:21,520 --> 00:31:24,430
否则，你可能会覆盖
您的缓冲区。

637
00:31:24,430 --> 00:31:26,140
上的任何问题。

638
00:31:26,140 --> 00:31:26,733
是啊。

639
00:31:26,733 --> 00:31:28,850
>> 观众：你能不能谈谈
多一点关于这些？

640
00:31:28,850 --> 00:31:29,790
>> 安琪拉李：对不起。

641
00:31:29,790 --> 00:31:31,040
是。

642
00:31:31,040 --> 00:31:32,813

643
00:31:32,813 --> 00:31:35,870
>> 观众：麦克只是视频。

644
00:31:35,870 --> 00:31:37,640
我会尽量和项目。

645
00:31:37,640 --> 00:31:39,900
嗨，伙计们。

646
00:31:39,900 --> 00:31:40,920
燮？

647
00:31:40,920 --> 00:31:45,330
所以，让我们在不多的事在
CS50库，你一直在使用这

648
00:31:45,330 --> 00:31:49,072
所有学期，主要是
获取用户输入。

649
00:31:49,072 --> 00:31:53,140
如你所知，你包括CS50
只是在做CS50.h，图书馆，

650
00:31:53,140 --> 00:31:55,660
包含了所有的原型
功能，您可以使用，像

651
00:31:55,660 --> 00:31:58,640
GetString和调用getInt，并
GetFloat和等等。

652
00:31:58,640 --> 00:32:02,870
还有的这一行中的CS50
库，它定义了一个字符串，它

653
00:32:02,870 --> 00:32:05,380
你们都知道了吧
仅仅是一个char *。

654
00:32:05,380 --> 00:32:07,900
>> 但是，让我们看一下在
GetString的是如何工作的。

655
00:32:07,900 --> 00:32:10,010
这是一个非常删节版。

656
00:32:10,010 --> 00:32:15,090
你可以拉起CS50库文件
从，我认为，manuals.CS50.net。

657
00:32:15,090 --> 00:32:16,750
而且你可以通过阅读
实际的功能。

658
00:32:16,750 --> 00:32:19,330
但是，这涉及一些
的重要组成部分。

659
00:32:19,330 --> 00:32:23,870
因此，我们已经创造了一些缓冲
有一些能力。

660
00:32:23,870 --> 00:32:27,570
而我们做的是我们得到一个字符
从标准的N时间。

661
00:32:27,570 --> 00:32:30,910
这就是用户输入
在文本控制台。

662
00:32:30,910 --> 00:32:33,430
>> 所以我们要读入
字符，只要它不是一个新的

663
00:32:33,430 --> 00:32:37,220
行，它不是最终的文件，其中
是标准输入的结束。

664
00:32:37,220 --> 00:32:45,690
为此，我们在阅读每一个字，
如果该字符结束了加入

665
00:32:45,690 --> 00:32:50,120
到的字符数，我们读过
在那超过我们的能力，

666
00:32:50,120 --> 00:32:53,490
那么我们做的是我们刚刚调整了
缓冲区，以便它的两倍长。

667
00:32:53,490 --> 00:32:56,950
如此反复，这样可以防止缓存
溢出攻击，因为你读的

668
00:32:56,950 --> 00:32:58,315
一个字符的时间。

669
00:32:58,315 --> 00:33:02,290
如果在任何时候你在阅读过
许多人来说，你只是扩大你的缓冲区。

670
00:33:02,290 --> 00:33:03,330
你乘以2。

671
00:33:03,330 --> 00:33:05,510
然后你有更多的空间。

672
00:33:05,510 --> 00:33:09,120
>> 否则，你只需要添加
一个字符缓冲区。

673
00:33:09,120 --> 00:33:15,080
和你读过的所有后
字符，它会收缩缓冲

674
00:33:15,080 --> 00:33:18,510
回落到正常大小，加
null结束，然后返回。

675
00:33:18,510 --> 00:33:21,880

676
00:33:21,880 --> 00:33:24,960
现在，让我们来看看调用getInt。

677
00:33:24,960 --> 00:33:27,700
你们可以看吗？

678
00:33:27,700 --> 00:33:30,710
我可以在一个位放大。

679
00:33:30,710 --> 00:33:33,410

680
00:33:33,410 --> 00:33:34,660
我不知道怎么的计算机。

681
00:33:34,660 --> 00:33:40,840

682
00:33:40,840 --> 00:33:41,270
没关系。

683
00:33:41,270 --> 00:33:42,520
我不能放大正常。

684
00:33:42,520 --> 00:33:47,500

685
00:33:47,500 --> 00:33:48,770
>> 这真的很难。

686
00:33:48,770 --> 00:33:49,180
对不起。

687
00:33:49,180 --> 00:33:51,490
就让我们看看这个。

688
00:33:51,490 --> 00:33:57,140
那么，什么调用getInt所做的是它首先读取
从GetString的，一个字符串，它

689
00:33:57,140 --> 00:33:59,250
我们之前已经实现。

690
00:33:59,250 --> 00:34:02,945
和重要组成部分，这里要注意
如果是这种共享，它结束了

691
00:34:02,945 --> 00:34:06,400
阅读是像也不是一个字符串，
那么我们就返回到INT_MAX

692
00:34:06,400 --> 00:34:09,409
代表失败。

693
00:34:09,409 --> 00:34:12,645
为什么我们返回INT_MAX而不是
负1或1？

694
00:34:12,645 --> 00:34:13,895
任何想法？

695
00:34:13,895 --> 00:34:16,853

696
00:34:16,853 --> 00:34:19,350
>> 观众：[听不清]
负1的之一。

697
00:34:19,350 --> 00:34:20,070
>> 安琪拉李：是的，没错。

698
00:34:20,070 --> 00:34:24,560
所以你的方式更可能只是想
输入1或负1时提示

699
00:34:24,560 --> 00:34:27,469
为第n个和第n个什么马克塞斯。

700
00:34:27,469 --> 00:34:27,969
这是巨大的。

701
00:34:27,969 --> 00:34:29,690
你可能不打算使用它。

702
00:34:29,690 --> 00:34:32,690
因此，这就像一个设计决定
确保你不小心

703
00:34:32,690 --> 00:34:38,540
返回一个错误或你不回
1，可能被解析

704
00:34:38,540 --> 00:34:41,199
作为一个正确的答案。

705
00:34:41,199 --> 00:34:45,110
因此，如果一个行不存在，则
我们返回INT-MAX。

706
00:34:45,110 --> 00:34:48,090
否则，我们使用sscanf的，
这就好比scanf函数。

707
00:34:48,090 --> 00:34:49,449
但它读取一个字符串。

708
00:34:49,449 --> 00:34:54,310
>> 我们有这样的格式化
字符串，是我％％C。

709
00:34:54,310 --> 00:34:57,440
我们尝试和匹配，与
无论用户给我们。

710
00:34:57,440 --> 00:35:01,420
我们要的东西相匹配的数量
为1，这意味着我们只

711
00:35:01,420 --> 00:35:04,940
确实想匹配一个整数
由也许包围的白色

712
00:35:04,940 --> 00:35:06,840
空间，也许不是。

713
00:35:06,840 --> 00:35:10,710
在这种情况下，如果你把东西
像酒吧，酒吧不匹配可言，

714
00:35:10,710 --> 00:35:14,400
因为需要有
在开始的整数。

715
00:35:14,400 --> 00:35:17,060
所以sscan从来没有把0。

716
00:35:17,060 --> 00:35:19,640
这样你就不会返回。

717
00:35:19,640 --> 00:35:23,850
>> 另外，如果你把东西
如1，2，3，A，B，C，那场比赛

718
00:35:23,850 --> 00:35:27,180
无论是整数，但也
后的字符。

719
00:35:27,180 --> 00:35:29,990
这样的sscanf会返回2，这
也并不理想。

720
00:35:29,990 --> 00:35:34,620
你不想1，2，3，A，
B，C是有效的int。

721
00:35:34,620 --> 00:35:36,990
这样也不起作用。

722
00:35:36,990 --> 00:35:38,530
但是，说你把喜欢的东西50。

723
00:35:38,530 --> 00:35:42,460
我就要匹配％，这意味着
它会读成n。

724
00:35:42,460 --> 00:35:44,790
而现在，正将包含数50。

725
00:35:44,790 --> 00:35:46,110
然后你就可以返回。

726
00:35:46,110 --> 00:35:49,270
>> 否则，你打重试。

727
00:35:49,270 --> 00:35:55,790
然后它只是一次又一次，直到
您从用户得到正确的输入。

728
00:35:55,790 --> 00:35:56,891
上有问题吗？

729
00:35:56,891 --> 00:36:02,182
>> 观众：所以，如果你要打印出
调用getInt在[听不清]的值

730
00:36:02,182 --> 00:36:06,250
会是公正的整数和最大？

731
00:36:06,250 --> 00:36:07,440
>> 安琪拉李：是啊。

732
00:36:07,440 --> 00:36:11,780
所以，如果你使用调用getInt，你应该假设
你不希望第n为最大

733
00:36:11,780 --> 00:36:15,328
是一个有效的输入，因为你会
假设这是不好的。

734
00:36:15,328 --> 00:36:27,740
>> 观众：如果我们没有字符c和
有人把在1，2，3，山姆，它会

735
00:36:27,740 --> 00:36:29,430
1，2，3还有效吗？

736
00:36:29,430 --> 00:36:29,750
>> 安琪拉李：我觉得这是可行的。

737
00:36:29,750 --> 00:36:33,340
但你不想123Sam到
是有效的由用户输入的。

738
00:36:33,340 --> 00:36:34,670
这是不是一个真正的整数。

739
00:36:34,670 --> 00:36:36,840
因此，它似乎不公平
解析它作为一个int。

740
00:36:36,840 --> 00:36:40,910

741
00:36:40,910 --> 00:36:42,160
确定。

742
00:36:42,160 --> 00:36:45,800
在这种情况下，让我们继续前进
上到互联网。

743
00:36:45,800 --> 00:36:49,120
因此，HTTP是不是一种语言。

744
00:36:49,120 --> 00:36:56,060
HTTP是只是一组标准
你如何从客户端发送的东西，

745
00:36:56,060 --> 00:36:57,280
这就是你，给服务器。

746
00:36:57,280 --> 00:36:59,730
这是其他人在网络上。

747
00:36:59,730 --> 00:37:02,900
>> 所以HTTP代表超文本
传输协议。

748
00:37:02,900 --> 00:37:04,610
它的心脏和灵魂
整个网络的。

749
00:37:04,610 --> 00:37:07,050
超文本只是部分
指的是HTML。

750
00:37:07,050 --> 00:37:10,690
转移是像客户端
您将请求发送到

751
00:37:10,690 --> 00:37:13,060
服务器，这给反应。

752
00:37:13,060 --> 00:37:16,380
而协议只是，怎么办
你期望一个服务器的行为？

753
00:37:16,380 --> 00:37:19,960
怎么是你应该表现
这样，您可以简化这个

754
00:37:19,960 --> 00:37:21,920
沟通过程？

755
00:37:21,920 --> 00:37:26,650
>> 所以HTTP请求看起来很像这个。

756
00:37:26,650 --> 00:37:28,070
GET是请求的类型。

757
00:37:28,070 --> 00:37:31,220
你们已经看到的GET请求
和POST请求。

758
00:37:31,220 --> 00:37:36,690
这第二件事情有，/我来说，这
只是URI或您所在的URL

759
00:37:36,690 --> 00:37:38,140
要在主机内去。

760
00:37:38,140 --> 00:37:44,140
因此，这要求是要求有
页，像www.facebook.com /我。

761
00:37:44,140 --> 00:37:45,300
这是一个GET请求。

762
00:37:45,300 --> 00:37:51,020
然后这个HTTP/1.1，这只是
HTTP的你正在使用的版本。

763
00:37:51,020 --> 00:37:55,020
它几乎总是1.1。

764
00:37:55,020 --> 00:37:56,880
>> 然后有一堆
其他的东西了。

765
00:37:56,880 --> 00:38:02,510
实际上，你可以看到这些，如果你
打开你的控制台，当你

766
00:38:02,510 --> 00:38:03,770
浏览网页。

767
00:38:03,770 --> 00:38:07,290
反应看起来
更多同类产品。

768
00:38:07,290 --> 00:38:09,620
顶部的部分是，一遍，
您正在使用HTTP的类型

769
00:38:09,620 --> 00:38:12,310
其次是状态代码。

770
00:38:12,310 --> 00:38:14,700
所以200 OK是一切工作。

771
00:38:14,700 --> 00:38:16,200
这里是您的内容。

772
00:38:16,200 --> 00:38:17,390
您的内容将会随之而来。

773
00:38:17,390 --> 00:38:21,730
然后它会告诉你什么样的
的内容和其他东西太多。

774
00:38:21,730 --> 00:38:24,620
>> 该状态码，也有少数
重要的是你应该知道。

775
00:38:24,620 --> 00:38:26,460
200 OK是像一切的金色。

776
00:38:26,460 --> 00:38:28,490
一切正常。

777
00:38:28,490 --> 00:38:29,710
403禁止。

778
00:38:29,710 --> 00:38:32,910
这一点，你可能已经看到了，如果你忘了
正确搭配chmod东西。

779
00:38:32,910 --> 00:38:34,510
这意味着，你不必
正确的权限

780
00:38:34,510 --> 00:38:36,210
访问该服务器上。

781
00:38:36,210 --> 00:38:38,110
这就像，不，你不能看到它。

782
00:38:38,110 --> 00:38:39,780
404指的事情不存在。

783
00:38:39,780 --> 00:38:40,400
没有找到。

784
00:38:40,400 --> 00:38:41,640
你可能已经看到了很多。

785
00:38:41,640 --> 00:38:45,510
>> 500内部服务器错误通常是
好像出事了就在身边

786
00:38:45,510 --> 00:38:46,460
服务器。

787
00:38:46,460 --> 00:38:50,830
所以，当你正在实施pset7，
如果你有PHP错误，你可以

788
00:38:50,830 --> 00:38:53,890
其实去的网页，看到一个
一大堆的PHP的错误的东西。

789
00:38:53,890 --> 00:38:56,900
但是，这并不常发生，
因为网站并不真的想

790
00:38:56,900 --> 00:38:58,830
告诉你为什么他们的网站被打破。

791
00:38:58,830 --> 00:39:03,370
他们可能会只返回一个
500内部服务器错误。

792
00:39:03,370 --> 00:39:06,120
>> 再有就是418我是一个茶壶。

793
00:39:06,120 --> 00:39:07,910
有大约原委
为什么这是一个事。

794
00:39:07,910 --> 00:39:09,860
但你可以阅读有关
在你自己的时间。

795
00:39:09,860 --> 00:39:11,450
还有一大堆的
其他状态码了。

796
00:39:11,450 --> 00:39:12,700
但这些是那些
你应该知道。

797
00:39:12,700 --> 00:39:15,660

798
00:39:15,660 --> 00:39:18,610
因此，让我们来谈谈HTML。

799
00:39:18,610 --> 00:39:22,180
HTML，记住，不是
编程语言。

800
00:39:22,180 --> 00:39:23,510
这是一种标记语言。

801
00:39:23,510 --> 00:39:25,210
这意味着它描述的内容。

802
00:39:25,210 --> 00:39:30,440
它会告诉你什么是HTML文档看起来
喜欢与否是什么样子

803
00:39:30,440 --> 00:39:32,230
但它是如何构成的。

804
00:39:32,230 --> 00:39:36,110
>> 因此它定义了一个结构和
网页的语义。

805
00:39:36,110 --> 00:39:37,830
这就像，这是一个段落。

806
00:39:37,830 --> 00:39:40,060
这是一个有序列表。

807
00:39:40,060 --> 00:39:42,360
这就像我的网页的一部分。

808
00:39:42,360 --> 00:39:43,260
这里的标题。

809
00:39:43,260 --> 00:39:44,310
它类似的东西。

810
00:39:44,310 --> 00:39:48,770
它没有任何样式的，由于
这就是你在CSS中做。

811
00:39:48,770 --> 00:39:50,270
它看起来像一个系列
嵌套标签。

812
00:39:50,270 --> 00:39:54,720
因此，要使用的一个非常基本的一个例子
HTML页面，您可以在DOCTYPE

813
00:39:54,720 --> 00:39:56,720
声明那里。

814
00:39:56,720 --> 00:40:00,940
>> 这DOCTYPE声明
说，我们正在使用HTML5。

815
00:40:00,940 --> 00:40:03,370
那么你有很大的HTML标签。

816
00:40:03,370 --> 00:40:05,230
它包含一个头部和主体。

817
00:40:05,230 --> 00:40:06,970
里面的头，你的标题。

818
00:40:06,970 --> 00:40:12,950
这就是所发生的称号
巴您的浏览器。

819
00:40:12,950 --> 00:40:15,810
我们有一个链接一个链接标签
在外部的样式表。

820
00:40:15,810 --> 00:40:19,880
然后我们有一个拉一个脚本
从外部JavaScript以及。

821
00:40:19,880 --> 00:40:23,750
>> 然后我们的身体里面实际上是
什么被显示在页面上。

822
00:40:23,750 --> 00:40:28,210
我们已经有了一个段落，然后一个
像那款内。

823
00:40:28,210 --> 00:40:32,000
这一个是小猫的图片。

824
00:40:32,000 --> 00:40:35,840
请注意，该图像
标签关闭本身。

825
00:40:35,840 --> 00:40:41,760
所以不是开口与图像
然后做一套/图像，你

826
00:40:41,760 --> 00:40:47,500
只是有这个小斜线
在这里，它会关闭它。

827
00:40:47,500 --> 00:40:53,670
和图像标签也有这个键
value属性称为ALT。

828
00:40:53,670 --> 00:40:56,970
这就是替代文本
当你悬停发生。

829
00:40:56,970 --> 00:41:03,170
>> 大多数HTML元素有一定的键值
的东西，你可以给它，各种

830
00:41:03,170 --> 00:41:04,420
定制。

831
00:41:04,420 --> 00:41:06,230

832
00:41:06,230 --> 00:41:08,705
是啊。

833
00:41:08,705 --> 00:41:09,955
>> 观众：[听不清]。

834
00:41:09,955 --> 00:41:17,510

835
00:41:17,510 --> 00:41:19,680
>> 安琪拉李：嗯，所以它是一个
标签的属性。

836
00:41:19,680 --> 00:41:25,320
所以，如果你使用jQuery，你可以
做选择image.getAttribute。

837
00:41:25,320 --> 00:41:27,930
然后你就可以搜索
得到的alt属性。

838
00:41:27,930 --> 00:41:31,040
它会给你的小猫。

839
00:41:31,040 --> 00:41:37,400
如果你还记得的形式在HTML中，输入
元素将名称属性。

840
00:41:37,400 --> 00:41:41,870
而这正是PHP使用发​​送
当表单被提交请求。

841
00:41:41,870 --> 00:41:44,762

842
00:41:44,762 --> 00:41:50,064
>> 观众：你提的东西
有关如何如果你使用kittens.jpg或

843
00:41:50,064 --> 00:41:54,410
一些有缺失
文件夹或其他文件？

844
00:41:54,410 --> 00:41:54,750
>> 安琪拉李：是的。

845
00:41:54,750 --> 00:41:57,010
因此，这是什么所谓的相对
路径，因为我不会放弃

846
00:41:57,010 --> 00:41:58,740
您的完整路径。

847
00:41:58,740 --> 00:42:05,160
这就像当以C，如果你做的fopen
一些文件，如果你的fopen hi.txt，那

848
00:42:05,160 --> 00:42:09,190
hi.txt预计是在同一
目录，除非你给它一个更

849
00:42:09,190 --> 00:42:11,530
复杂的路径。

850
00:42:11,530 --> 00:42:14,900
>> 观众：所以，你可以指定
该文件夹[听不清]？

851
00:42:14,900 --> 00:42:17,660
>> 安琪拉李：是啊。

852
00:42:17,660 --> 00:42:19,370
并且你可以看看该怎么做。

853
00:42:19,370 --> 00:42:23,480
但是，如果我想获得kittens.jpg出
父目录的，我会做

854
00:42:23,480 --> 00:42:24,730
。/ kittens.jpg。

855
00:42:24,730 --> 00:42:29,680

856
00:42:29,680 --> 00:42:30,930
是啊。

857
00:42:30,930 --> 00:42:32,960

858
00:42:32,960 --> 00:42:33,760
抱歉。

859
00:42:33,760 --> 00:42:34,045
是啊。

860
00:42:34,045 --> 00:42:35,700
哦，天哪，我忘了这个问题。

861
00:42:35,700 --> 00:42:36,460
究竟是什么问题？

862
00:42:36,460 --> 00:42:39,570
呵呵，问题是就是，kittens.jpg
预计将在同一目录下？

863
00:42:39,570 --> 00:42:40,630
在这种情况下，它是。

864
00:42:40,630 --> 00:42:44,030
但你也可以给它一定的路径
例如，它不必须是。

865
00:42:44,030 --> 00:42:47,100

866
00:42:47,100 --> 00:42:48,350
好？

867
00:42:48,350 --> 00:42:50,190

868
00:42:50,190 --> 00:42:51,350
>> CSS。

869
00:42:51,350 --> 00:42:55,420
这样的CSS，HTML一样，是不是
一种编程语言。

870
00:42:55,420 --> 00:42:58,250
CSS是只是一系列的样式规则。

871
00:42:58,250 --> 00:43:00,130
它代表了层叠样式表。

872
00:43:00,130 --> 00:43:03,910
和你一起使用
使用HTML样式的页面。

873
00:43:03,910 --> 00:43:08,140
因此，有三种方式
你可以包含它。

874
00:43:08,140 --> 00:43:11,950
你可以做到这一点的方法之一是在头部
你的HTML的一部分，你可以只

875
00:43:11,950 --> 00:43:15,410
打开一个风格标签，然后坚持
一些CSS规则在里面。

876
00:43:15,410 --> 00:43:16,759
这是非常确定。

877
00:43:16,759 --> 00:43:17,228
是啊。

878
00:43:17,228 --> 00:43:21,449
>> 观众：你能不能把那些
风格标签之间，让我们

879
00:43:21,449 --> 00:43:22,860
比方说，身体和/身体。

880
00:43:22,860 --> 00:43:27,400
然后你会造型
只有在身体。

881
00:43:27,400 --> 00:43:28,840
>> 安琪拉李：你能。

882
00:43:28,840 --> 00:43:29,590
它会工作。

883
00:43:29,590 --> 00:43:33,990
但你不应该，因为造型
一种元数据，应该在去

884
00:43:33,990 --> 00:43:35,890
您的文档的头部。

885
00:43:35,890 --> 00:43:38,280
身体真的应该只包含
什么是究竟要

886
00:43:38,280 --> 00:43:39,420
显示您的网页上。

887
00:43:39,420 --> 00:43:42,155
>> 观众：所以你把风格
在你的脑袋样式化

888
00:43:42,155 --> 00:43:43,930
整个网页，对不对？

889
00:43:43,930 --> 00:43:44,300
>> 安琪拉李：是啊。

890
00:43:44,300 --> 00:43:50,470
所以把这里的风格，这些CSS规则
将适用于基于整个页面

891
00:43:50,470 --> 00:43:52,100
他们的选择。

892
00:43:52,100 --> 00:43:57,090
所以更好的方式来做到这一点是不是
具有在你的脑袋风格标签，

893
00:43:57,090 --> 00:44:00,430
你有这样的链接到一个外部的样式
表像我在向您展示

894
00:44:00,430 --> 00:44:01,980
前面的例子。

895
00:44:01,980 --> 00:44:05,920
这里做的事情是它尝试并找到
文件style.css文件，然后拉它

896
00:44:05,920 --> 00:44:08,470
中，并将其用作本
样式的页面。

897
00:44:08,470 --> 00:44:10,500
和你的style.css会
只是看起来像这样。

898
00:44:10,500 --> 00:44:13,330
这纯粹是一堆的CSS。

899
00:44:13,330 --> 00:44:16,210
>> 最后，还有另一种方式，你
可以包括CSS，真的你

900
00:44:16,210 --> 00:44:17,480
不应该永远做。

901
00:44:17,480 --> 00:44:18,950
这是调用内联样式。

902
00:44:18,950 --> 00:44:22,650
所以任何HTML元素也可以
取样式属性。

903
00:44:22,650 --> 00:44:26,320
然后在该样式属性，
你可以给它的CSS规则。

904
00:44:26,320 --> 00:44:29,140
因此，在这种情况下，我是什么格
定义就在这里，它要

905
00:44:29,140 --> 00:44:32,580
有一个黑色的背景和
白色的文字颜色。

906
00:44:32,580 --> 00:44:35,620
但你不应该这样做，因为什么
但这是它把你的造型

907
00:44:35,620 --> 00:44:36,850
在你的HTML。

908
00:44:36,850 --> 00:44:40,530
>> 我知道，我们一直在谈论的HTML
是结构和CSS是样式。

909
00:44:40,530 --> 00:44:42,790
如果你这样做，它混合
它们连接在一起。

910
00:44:42,790 --> 00:44:44,550
它不是很干净。

911
00:44:44,550 --> 00:44:45,800
所以不要做。

912
00:44:45,800 --> 00:44:47,690

913
00:44:47,690 --> 00:44:52,100
使用CSS的一个例子，在那里，我们
只需选择HTML的身体

914
00:44:52,100 --> 00:44:52,380
纪录片。

915
00:44:52,380 --> 00:44:55,110
和我们一样，一切都
将是Comic Sans字体。

916
00:44:55,110 --> 00:44:57,290
我也不建议。

917
00:44:57,290 --> 00:44:59,940
但你能做到这一点。

918
00:44:59,940 --> 00:45:03,140
>> 第二条规则就在这里，这是怎么回事
选择的元素

919
00:45:03,140 --> 00:45:04,880
页面ID为主要。

920
00:45:04,880 --> 00:45:11,690
所以，无论HTML元素，我说的ID
=主，我要去给一个

921
00:45:11,690 --> 00:45:16,020
20像素的边距和对齐的一切，
所有的文字，到中心。

922
00:45:16,020 --> 00:45:19,030
过去的事情由CSS类选择。

923
00:45:19,030 --> 00:45:24,450
所以，在页面上，我给任何元素
一节课，我要使它

924
00:45:24,450 --> 00:45:26,602
淡蓝色的背景色。

925
00:45:26,602 --> 00:45:29,380

926
00:45:29,380 --> 00:45:30,040
没错。

927
00:45:30,040 --> 00:45:30,700
这就是我的一切。

928
00:45:30,700 --> 00:45:30,890
问题？

929
00:45:30,890 --> 00:45:34,020
>> 观众：什么包括hashtag
之前主要做什么？

930
00:45:34,020 --> 00:45:36,310
>> 安琪拉李：现在的问题是有哪些呢
之前主要做这个标签？

931
00:45:36,310 --> 00:45:40,770
在这种情况下，在哈希
CSS是指通过ID选择。

932
00:45:40,770 --> 00:45:47,490
所以，如果我有一些HTML元素，如
DIVID =主，这个CSS规则选择

933
00:45:47,490 --> 00:45:49,260
东西用的ID为主。

934
00:45:49,260 --> 00:45:53,940
类似地，在周期中的前
部分是通过CSS类选择或

935
00:45:53,940 --> 00:45:56,558
通过HTML类选择。

936
00:45:56,558 --> 00:46:00,940
>> 观众：为什么会出现一个有前
在背景颜色6？

937
00:46:00,940 --> 00:46:01,270
>> 安琪拉李：是啊。

938
00:46:01,270 --> 00:46:03,360
所以，问题是，为什么会出现
6前一个哈希？

939
00:46:03,360 --> 00:46:05,320
这是比散列不同。

940
00:46:05,320 --> 00:46:09,500
这意味着，你给
一个十六进制颜色。

941
00:46:09,500 --> 00:46:14,260
所以十六进制的颜色，这只是
代表色。

942
00:46:14,260 --> 00:46:17,860
你还记得的RGB三元组时，
你做了取证PSET？

943
00:46:17,860 --> 00:46:18,770
这是类似的。

944
00:46:18,770 --> 00:46:21,590
前两个数字代表
多少是红色的颜色。

945
00:46:21,590 --> 00:46:23,260
后两个代表
多少绿色。

946
00:46:23,260 --> 00:46:25,450
和第三指
多少蓝。

947
00:46:25,450 --> 00:46:30,060
和散列这是怎么回事
来表示一种颜色。

948
00:46:30,060 --> 00:46:35,660
>> 所以从0，0，0，0，0，0的任何
高达F，F，F，F，F，F是有效的。

949
00:46:35,660 --> 00:46:39,550
这是一些有效的颜色，可以
您的浏览器显示。

950
00:46:39,550 --> 00:46:39,790
问题？

951
00:46:39,790 --> 00:46:43,590
>> 观众：什么是之间的区别
利用ID和类？

952
00:46:43,590 --> 00:46:46,470
>> 安琪拉李：现在的问题是什么
之间的差

953
00:46:46,470 --> 00:46:48,950
利用ID和类？

954
00:46:48,950 --> 00:46:54,390
你只能有一个一个元素
具有给定的ID的HTML文档。

955
00:46:54,390 --> 00:46:58,660
所以只有一件事在我的网页
允许有ID为主。

956
00:46:58,660 --> 00:47:02,580
所以你使用它，这是头。

957
00:47:02,580 --> 00:47:03,850
这是导航。

958
00:47:03,850 --> 00:47:05,230
这是页脚。

959
00:47:05,230 --> 00:47:09,070
类是不同的，因为你可以
应用类，以尽可能多的HTML元素

960
00:47:09,070 --> 00:47:10,100
只要你想。

961
00:47:10,100 --> 00:47:15,860
>> 因此，举例来说，我做了类部分，
因为有可能不止一个

962
00:47:15,860 --> 00:47:17,540
部分在我的网页。

963
00:47:17,540 --> 00:47:20,200
你只是允许有多达
用相同的页面上的元素

964
00:47:20,200 --> 00:47:23,190
类，但只有一个具有一定标识。

965
00:47:23,190 --> 00:47:25,600
>> 观众：所以圆点代表
类？

966
00:47:25,600 --> 00:47:26,090
>> 安琪拉李：是啊。

967
00:47:26,090 --> 00:47:27,380
一个点代表一个类。

968
00:47:27,380 --> 00:47:29,990

969
00:47:29,990 --> 00:47:31,540
凉爽。

970
00:47:31,540 --> 00:47:32,370
这就是我的一切，伙计们。

971
00:47:32,370 --> 00:47:33,544
谢谢。

972
00:47:33,544 --> 00:48:13,380
>> [掌声]

973
00:48:13,380 --> 00:48:14,290
>> ZAMYLA陈：嗨，大家好。

974
00:48:14,290 --> 00:48:14,880
我Zamyla。

975
00:48:14,880 --> 00:48:18,830
我将要覆盖的PHP，
MVC和SQL今天。

976
00:48:18,830 --> 00:48:22,350

977
00:48:22,350 --> 00:48:26,110
很多，我会的材料
覆盖将是相当多

978
00:48:26,110 --> 00:48:29,100
右出pset7的。

979
00:48:29,100 --> 00:48:29,700
好的。

980
00:48:29,700 --> 00:48:31,180
那么，什么是PHP？

981
00:48:31,180 --> 00:48:35,150
PHP代表PHP超文本
预处理器。

982
00:48:35,150 --> 00:48:38,740
所以，本身是一个递归
命名，这是很酷。

983
00:48:38,740 --> 00:48:42,220
PHP是一种服务器端脚本语言，
和它所提供的后端

984
00:48:42,220 --> 00:48:44,610
和逻辑基础
我们的网站。

985
00:48:44,610 --> 00:48:48,520
>> 所以安吉拉谈了很多有关HTML
和CSS，这将使结构

986
00:48:48,520 --> 00:48:49,530
本网站。

987
00:48:49,530 --> 00:48:53,210
但是，如果你想改变什么
动态或者如果它的内容各不相同

988
00:48:53,210 --> 00:48:55,240
基于用户或
一定条件下？

989
00:48:55,240 --> 00:48:57,060
这就是PHP的用武之地。

990
00:48:57,060 --> 00:49:02,610
现在，通常情况下，PHP可能需要几分钟
少来实现同样的事情线

991
00:49:02,610 --> 00:49:07,380
在C这是因为PHP处理内存
管理的程序员，

992
00:49:07,380 --> 00:49:11,170
而不是我们不得不的malloc
自由，这样的事情。

993
00:49:11,170 --> 00:49:15,430
>> 但是，由于PHP是一种解释
语言，典型地，它可能执行

994
00:49:15,430 --> 00:49:19,540
比C多一点缓慢，这
是编译型语言。

995
00:49:19,540 --> 00:49:23,150
因为我们正在规划
语言，让我们来看看如何

996
00:49:23,150 --> 00:49:24,570
语法将有所不同。

997
00:49:24,570 --> 00:49:28,770
让我们必须非常小心，不要
感到困惑与此有关。

998
00:49:28,770 --> 00:49:33,750
综上所述，使用PHP语法，无论你是
嵌入你的PHP的HTML里面

999
00:49:33,750 --> 00:49:40,430
文件或在。php文件本身，你
需要附上代码开放

1000
00:49:40,430 --> 00:49:45,270
PHP和封闭的PHP标签像
如下，喜欢在屏幕上。

1001
00:49:45,270 --> 00:49:46,660
>> PHP中的变量。

1002
00:49:46,660 --> 00:49:51,490
每一个变量将开始
$符号后面的名字

1003
00:49:51,490 --> 00:49:53,150
您的变量。

1004
00:49:53,150 --> 00:49:56,530
现在，在PHP中的变量松散类型，
这意味着你不需要

1005
00:49:56,530 --> 00:50:00,030
要说明什么数据类型
是当你声明它。

1006
00:50:00,030 --> 00:50:03,505
然而，这并不意味着它们
不具有任何类型的。

1007
00:50:03,505 --> 00:50:09,370
所以，如果我声明了一个变量，只设置
它等于1，然后我声明

1008
00:50:09,370 --> 00:50:15,140
另一个变量，将其设置为“1”
然后另外一个1.0，好了，

1009
00:50:15,140 --> 00:50:19,410
根据平等的类型
运营商我用，如果我想比较

1010
00:50:19,410 --> 00:50:21,830
在所有类型，然后
他们将是平等的。

1011
00:50:21,830 --> 00:50:25,570
但是，如果我想确保了
类型相同，PHP还可以做

1012
00:50:25,570 --> 00:50:28,690
如此，即使我们并不表明
它是什么类型时，我们

1013
00:50:28,690 --> 00:50:31,170
先使文件。

1014
00:50:31,170 --> 00:50:33,990
>> 现在，在PHP中，即使我们
从编程切换

1015
00:50:33,990 --> 00:50:39,360
在C语言中，我们仍然有我们的
值得信赖的if条件，就是这样。

1016
00:50:39,360 --> 00:50:43,270
我们仍然有我们的while循环，只
这样，你把你的

1017
00:50:43,270 --> 00:50:47,300
状态，然后在
体循环。

1018
00:50:47,300 --> 00:50:50,360
然后我们也有我们的for循环，
通常看起来像这样。

1019
00:50:50,360 --> 00:50:55,330
所以，如果我想遍历所有
9 pset和提交，并调用

1020
00:50:55,330 --> 00:50:58,960
功能submitPset，那么我就可以做到这一点
在这里，这你们都

1021
00:50:58,960 --> 00:50:59,830
由这点做的。

1022
00:50:59,830 --> 00:51:01,080
恭喜，顺便说一句。

1023
00:51:01,080 --> 00:51:04,560

1024
00:51:04,560 --> 00:51:07,550
>> 对于摄像头，人
说，谢谢你。

1025
00:51:07,550 --> 00:51:11,220
现在，如果你不想只是用这个
for循环，那么PHP居然还

1026
00:51:11,220 --> 00:51:13,580
有东西叫做foreach循环。

1027
00:51:13,580 --> 00:51:22,210
所以，如果我有一个整数数组，0
通过8中，存储在阵列的pset，

1028
00:51:22,210 --> 00:51:27,290
然后我可以有一个foreach循环，
遍历在pset中的每一个数字。

1029
00:51:27,290 --> 00:51:30,640
然后我可以调用相同
功能8倍，

1030
00:51:30,640 --> 00:51:31,910
就像我以前那样。

1031
00:51:31,910 --> 00:51:36,480
因此，这对每个回路是好的，因为
你不必，如果你不知道

1032
00:51:36,480 --> 00:51:39,470
阵列的确切长度，你
有，然后使用这个foreach循环

1033
00:51:39,470 --> 00:51:42,800
将采取照顾你。

1034
00:51:42,800 --> 00:51:45,410
>> 所以我做的pset为一个数组。

1035
00:51:45,410 --> 00:51:46,700
让我们来看看这个。

1036
00:51:46,700 --> 00:51:51,290
在PHP数组通常是一样的
我们已经在C中，那些地方

1037
00:51:51,290 --> 00:51:52,960
你可以声明一个数组。

1038
00:51:52,960 --> 00:51:59,200
在这里，我可以声明一个空数组
然后动态地使用建立

1039
00:51:59,200 --> 00:52:00,850
指数为整数。

1040
00:52:00,850 --> 00:52:04,140
所以索引0，我要存储
一个整数命名1。

1041
00:52:04,140 --> 00:52:09,210
在我的清单索引1，我要去
存储值2。

1042
00:52:09,210 --> 00:52:12,670
以及第三索引，但在
第二个数字，我要去

1043
00:52:12,670 --> 00:52:14,870
储存号码12。

1044
00:52:14,870 --> 00:52:17,250
>> 现在，这是罚款，这
工作效果很好。

1045
00:52:17,250 --> 00:52:21,310
但说是我的问题
什么每个索引保存。

1046
00:52:21,310 --> 00:52:24,500
对于我来说，索引0表示如何
许多猫我有。

1047
00:52:24,500 --> 00:52:27,400
和索引1表示如何
许多猫头鹰我。

1048
00:52:27,400 --> 00:52:29,450
和下一个意思有多少狗。

1049
00:52:29,450 --> 00:52:34,140
好吧，那么它来指定，而不是
不必记住0涉及

1050
00:52:34,140 --> 00:52:38,090
猫和1至猫头鹰，我可以使用
关联数组，表示

1051
00:52:38,090 --> 00:52:42,260
而不是整数作为我的指标，
其实我可以使用字符串。

1052
00:52:42,260 --> 00:52:43,290
>> 所以这是非常有用的。

1053
00:52:43,290 --> 00:52:47,130
你已经基本上只是更换
整数与字符串。

1054
00:52:47,130 --> 00:52:50,074
有你有一个
关联数组。

1055
00:52:50,074 --> 00:52:51,930
是啊。

1056
00:52:51,930 --> 00:52:55,800
>> 观众：还有一个原因为什么有
下划线第二

1057
00:52:55,800 --> 00:52:58,750
的一部分，因为我的列表中有数组。

1058
00:52:58,750 --> 00:53:01,330
>> ZAMYLA陈：现在的问题是，现在是
还有一个原因是有一个

1059
00:53:01,330 --> 00:53:03,320
我和列表之间的底线？

1060
00:53:03,320 --> 00:53:03,610
号

1061
00:53:03,610 --> 00:53:06,878
这只是我如何命名
我的变量。

1062
00:53:06,878 --> 00:53:11,670
>> 观众：在第一
线，它的一个字。

1063
00:53:11,670 --> 00:53:12,560
>> ZAMYLA陈：我的道歉。

1064
00:53:12,560 --> 00:53:13,410
我会解决这个问题。

1065
00:53:13,410 --> 00:53:13,620
是啊。

1066
00:53:13,620 --> 00:53:15,460
他们应该是相同的变量名。

1067
00:53:15,460 --> 00:53:16,710
良好的渔获物。

1068
00:53:16,710 --> 00:53:19,640

1069
00:53:19,640 --> 00:53:19,950
确定。

1070
00:53:19,950 --> 00:53:22,610
所以，让我们继续为字符串
串联。

1071
00:53:22,610 --> 00:53:27,500
如果我想采取两个字符串，
然后我就可以将它们串联

1072
00:53:27,500 --> 00:53:28,550
用点操作符。

1073
00:53:28,550 --> 00:53:32,440
所以，如果我有米洛的名字
与香蕉作为姓氏，然后

1074
00:53:32,440 --> 00:53:35,430
与点运算符和串联
然后把一个空间之间

1075
00:53:35,430 --> 00:53:39,210
将包含米洛的字符串
香蕉，我就可以回显或，

1076
00:53:39,210 --> 00:53:41,280
相反，打印出来。

1077
00:53:41,280 --> 00:53:44,465
>> 说到回声，让我们来谈谈
约了几个有用的 - 

1078
00:53:44,465 --> 00:53:44,920
哎呀。

1079
00:53:44,920 --> 00:53:46,030
对不起。

1080
00:53:46,030 --> 00:53:52,920
一些有用的PHP函数。

1081
00:53:52,920 --> 00:53:56,240
所以，我们有 - 

1082
00:53:56,240 --> 00:53:57,444
技术上的困难。

1083
00:53:57,444 --> 00:53:58,694
一秒钟。

1084
00:53:58,694 --> 00:54:16,960

1085
00:54:16,960 --> 00:54:19,550
我送它。

1086
00:54:19,550 --> 00:54:22,320
PowerPoint中的问题。

1087
00:54:22,320 --> 00:54:29,200
我们回来了PHP函数。

1088
00:54:29,200 --> 00:54:32,010

1089
00:54:32,010 --> 00:54:35,150
我们回来了PHP函数。

1090
00:54:35,150 --> 00:54:39,890
>> 因此，我们需要的函数，其中
如果你传递一个文件，这里的只是

1091
00:54:39,890 --> 00:54:43,300
一个文件的一个例子是
我可能会传递英寸

1092
00:54:43,300 --> 00:54:47,605
然后，将包含PHP代码
从该文件中，我指出。

1093
00:54:47,605 --> 00:54:49,940
它会评估，在。

1094
00:54:49,940 --> 00:54:54,450
那么我们也有回音，这
是一个平行的printf。

1095
00:54:54,450 --> 00:54:57,710
退出是一个平行的断裂，
其中出口的块

1096
00:54:57,710 --> 00:54:58,570
你是英寸代码

1097
00:54:58,570 --> 00:55:03,180
然后空检查是否给定的
变量就像是null或零或

1098
00:55:03,180 --> 00:55:08,482
无论是等同于为空。

1099
00:55:08,482 --> 00:55:09,438
是啊。

1100
00:55:09,438 --> 00:55:15,341
>> 观众：对于字符串连接
点运算符之一，在PHP中，就是

1101
00:55:15,341 --> 00:55:20,158
相同的JavaScript那里它使用
点串联的意思加？

1102
00:55:20,158 --> 00:55:27,440
因此，对于全名，你可以有美元
签署第一+，然后+持续多久？

1103
00:55:27,440 --> 00:55:27,720
>> ZAMYLA陈：是的。

1104
00:55:27,720 --> 00:55:32,150
所以现在的问题是，是否在PHP中，我们
可以使用相同的字符串连接

1105
00:55:32,150 --> 00:55:33,890
如在JavaScript中的加号。

1106
00:55:33,890 --> 00:55:35,410
约瑟将进入的后来。

1107
00:55:35,410 --> 00:55:36,620
我想他对一个幻灯片。

1108
00:55:36,620 --> 00:55:37,570
其实，这是不同的。

1109
00:55:37,570 --> 00:55:41,310
所以在JavaScript中，你需要使用
加来连接字符串。

1110
00:55:41,310 --> 00:55:43,280
而在PHP中，你必须
使用点运算符。

1111
00:55:43,280 --> 00:55:44,530
因此，它们是不同的。

1112
00:55:44,530 --> 00:55:46,680

1113
00:55:46,680 --> 00:55:46,910
>> 确定。

1114
00:55:46,910 --> 00:55:49,500
所以，现在我们已经涵盖了所有
这个PHP，它在哪里

1115
00:55:49,500 --> 00:55:50,490
真正派上用场？

1116
00:55:50,490 --> 00:55:54,470
那么，它派上用场的时候，我们
可以与我们的HTML相结合。

1117
00:55:54,470 --> 00:55:59,550
所以，我们的PHP会给我们的力量
改变页面的HTML内容之前，

1118
00:55:59,550 --> 00:56:00,000
它的加载。

1119
00:56:00,000 --> 00:56:04,270
这样根据不同的条件，
通常在特定的用户那

1120
00:56:04,270 --> 00:56:07,520
登录后，我们就可以显示
不同的信息。

1121
00:56:07,520 --> 00:56:08,800
琳达，你有问题吗？

1122
00:56:08,800 --> 00:56:15,510
>> 观众：你能串连
一个整数也？

1123
00:56:15,510 --> 00:56:16,760
>> ZAMYLA陈：是的，可以。

1124
00:56:16,760 --> 00:56:19,530

1125
00:56:19,530 --> 00:56:23,270
所以现在的问题是，如果你能
串连整数或其他

1126
00:56:23,270 --> 00:56:28,920
variable.s现在，我们进入到MVC，这
的是，我们在使用一个范例

1127
00:56:28,920 --> 00:56:33,380
pset7和很多网页设计者使用
组织代码中的文件

1128
00:56:33,380 --> 00:56:34,490
在他们的网站。

1129
00:56:34,490 --> 00:56:35,870
M代表模型。

1130
00:56:35,870 --> 00:56:41,450
基本上，模型文件将处理
与数据库交互。

1131
00:56:41,450 --> 00:56:44,640
查看文件，它们涉及到了
本网站的美观性。

1132
00:56:44,640 --> 00:56:47,550
和控制器处理
用户请求，解析

1133
00:56:47,550 --> 00:56:49,230
数据，做其他的逻辑。

1134
00:56:49,230 --> 00:56:52,520
>> 在pset7，我们结合模型
和控制器。

1135
00:56:52,520 --> 00:56:55,880
我们只是叫他们和控制器
把它们放在公共目录。

1136
00:56:55,880 --> 00:57:01,730
和视图文件，我们把它们作为
模板中的模板目录。

1137
00:57:01,730 --> 00:57:07,260
所以这里这个图也代表
与同类型的划分

1138
00:57:07,260 --> 00:57:10,510
模型和紫色控制器
这里在左边和

1139
00:57:10,510 --> 00:57:12,770
右边的图。

1140
00:57:12,770 --> 00:57:16,020
因此，这是一个示意图，是你们中的一些
可能已经看到在办公时间或

1141
00:57:16,020 --> 00:57:19,130
我们被绘制为您图解
是搞清楚你的​​pset中。

1142
00:57:19,130 --> 00:57:25,030
>> 因此，这里，在一个给定的控制器，一个模型
控制器，我们有功能

1143
00:57:25,030 --> 00:57:30,490
这涉及到查询的SQL
数据库，PHP的执行逻辑。

1144
00:57:30,490 --> 00:57:32,370
也许你会抬头
在雅虎股票

1145
00:57:32,370 --> 00:57:34,590
财务。

1146
00:57:34,590 --> 00:57:37,390
或许，你只是要检查
看看用户是否提交了一份

1147
00:57:37,390 --> 00:57:40,250
有之前就已经形成
访问你的页面。

1148
00:57:40,250 --> 00:57:43,390
然后你会渲染
一个形成在这里。

1149
00:57:43,390 --> 00:57:48,210
已提交的表单后曾
由用户，这是动作

1150
00:57:48,210 --> 00:57:53,470
在表单的HTML标记指定
将指示该页面，它

1151
00:57:53,470 --> 00:57:55,620
返回的数据。

1152
00:57:55,620 --> 00:57:59,460
>> 因此，所有这些信息将
发送回您的控制器。

1153
00:57:59,460 --> 00:58:02,620
那么你可能会做多一点
在这一逻辑，也许执行了几个

1154
00:58:02,620 --> 00:58:06,510
在SQL数据库的详细查询和
然后，终于，想出了一个很好的

1155
00:58:06,510 --> 00:58:11,930
包装组信息，你会
传递到一些其他的模板

1156
00:58:11,930 --> 00:58:13,950
所显示的信息。

1157
00:58:13,950 --> 00:58:17,030
现在，我们到底怎么打包
这些信息呢？

1158
00:58:17,030 --> 00:58:23,980
好了，我们有一个叫做渲染功能
那是在functions.php文件

1159
00:58:23,980 --> 00:58:29,950
pset7，在那里你传递的名义
一个文件，一个模板的名称。

1160
00:58:29,950 --> 00:58:32,160
>> 然后你也传递
一个关联数组。

1161
00:58:32,160 --> 00:58:37,150
并且使关联数组表示
不同的信息

1162
00:58:37,150 --> 00:58:39,040
要传递英寸

1163
00:58:39,040 --> 00:58:43,460
现在，将是在不断的
这些例子是，钥匙，或

1164
00:58:43,460 --> 00:58:47,070
而是，关联的键
数组，这些都是正在发生的事情是

1165
00:58:47,070 --> 00:58:51,050
预期由模板常数，
因为它知道它需要

1166
00:58:51,050 --> 00:58:53,990
一些所谓的消息
或者叫名字。

1167
00:58:53,990 --> 00:58:56,940
然后在右边的东西，在
实际值，所以在这种情况下，谁的

1168
00:58:56,940 --> 00:59:00,750
一个好男孩和米洛，那些打算
是正在改变的值

1169
00:59:00,750 --> 00:59:05,610
该控制器每一次改变
或基于某一条件和

1170
00:59:05,610 --> 00:59:07,120
将传递英寸

1171
00:59:07,120 --> 00:59:12,790
>> 所以在这里在模板中，我们看到我们
使用HTML特殊字符，

1172
00:59:12,790 --> 00:59:16,370
这只是基本上意味着我们要
得到同行的字符串，该

1173
00:59:16,370 --> 00:59:17,580
用户放进去。

1174
00:59:17,580 --> 00:59:20,880
我们想替换
在那里的消息。

1175
00:59:20,880 --> 00:59:26,110
所以后来当我们真正看到
该文件，该特定

1176
00:59:26,110 --> 00:59:28,700
信息传入

1177
00:59:28,700 --> 00:59:33,850
请注意，关键是如何呈现的作品是
该缔合的键

1178
00:59:33,850 --> 00:59:37,170
数组，这些成为变量
名字在这里。

1179
00:59:37,170 --> 00:59:40,720
所以在该键的值
关联数组，然后成为

1180
00:59:40,720 --> 00:59:41,970
该变量的值。

1181
00:59:41,970 --> 00:59:44,800

1182
00:59:44,800 --> 00:59:46,040
>> 现在，让我们进入到SQL。

1183
00:59:46,040 --> 00:59:48,010
它代表结构
查询语言。

1184
00:59:48,010 --> 00:59:50,460
所以这只是一个编程
语言设计

1185
00:59:50,460 --> 00:59:51,880
用于管理数据库。

1186
00:59:51,880 --> 00:59:56,860
它派上了用场，我们在
我们pset7财经网站。

1187
00:59:56,860 --> 01:00:00,510
从本质上讲，它只是一个简单的方法来
跟踪和管理对象和表

1188
01:00:00,510 --> 01:00:02,070
并将其链接到对方。

1189
01:00:02,070 --> 01:00:06,860
现在，想想你的SQL数据库中
基本上作为一个Excel文件，或许，

1190
01:00:06,860 --> 01:00:10,040
多标签页。

1191
01:00:10,040 --> 01:00:13,820
>> 所以，你可以有多个表，
也许，彼此连接。

1192
01:00:13,820 --> 01:00:19,420
而就像Excel中，我们有很多的
我们想要的功能。

1193
01:00:19,420 --> 01:00:22,300
例如，我们可以选择
某些行。

1194
01:00:22,300 --> 01:00:24,110
我们可以插入信息。

1195
01:00:24,110 --> 01:00:25,560
我们可以更新的行。

1196
01:00:25,560 --> 01:00:27,440
而且我们还可以删除的东西。

1197
01:00:27,440 --> 01:00:30,920

1198
01:00:30,920 --> 01:00:36,560
>> 通过选择行的SQL选择作品
或行从一个指定的列

1199
01:00:36,560 --> 01:00:39,640
数据库匹配有一定
标准，你指出。

1200
01:00:39,640 --> 01:00:44,930
所以，在这里，当我看到选择*从
巫师那里的房子=拉文克劳，然后

1201
01:00:44,930 --> 01:00:48,340
我选择*，这意味着我
在选择每一个列

1202
01:00:48,340 --> 01:00:56,340
从奇才表，但只有当排
房子列等于拉文克劳。

1203
01:00:56,340 --> 01:00:57,840
现在，这是纯粹的或SQL。

1204
01:00:57,840 --> 01:01:02,680
所以，如果我进入phpMyAdmin的，这是
我们使用管理的具体办法

1205
01:01:02,680 --> 01:01:07,040
我们的SQL数据库，那么我可以插入
即进入phpMyAdmin的网站。

1206
01:01:07,040 --> 01:01:08,290
并且将执行。

1207
01:01:08,290 --> 01:01:11,280
>> 但我们真正想要做的
这在PHP端。

1208
01:01:11,280 --> 01:01:12,580
那么，如何才能做到这一点？

1209
01:01:12,580 --> 01:01:20,180
好了，我们使用查询功能，
基本上执行的SQL查询。

1210
01:01:20,180 --> 01:01:21,830
使用？

1211
01:01:21,830 --> 01:01:25,850
作为一个占位符，我们可以通过在某些
值，以我们的字符串，我们

1212
01:01:25,850 --> 01:01:26,920
要更换。

1213
01:01:26,920 --> 01:01:32,110
所以也许我存储不同
在curr_house值，这

1214
01:01:32,110 --> 01:01:34,400
代表了目前房子
我正在经历的一切。

1215
01:01:34,400 --> 01:01:39,040
这样我就可以把它传递作为占位符
与问号。

1216
01:01:39,040 --> 01:01:43,290
然后我就基本上执行
同样的事情，我做之前，除

1217
01:01:43,290 --> 01:01:45,550
现在，我在PHP。

1218
01:01:45,550 --> 01:01:51,300
>> 和查询将返回一个
关联数组。

1219
01:01:51,300 --> 01:01:53,470
我要去把它存储在列。

1220
01:01:53,470 --> 01:01:56,880
现在，查询可以总是失败。

1221
01:01:56,880 --> 01:02:02,870
也许SQL查询不能执行
因为表不存在。

1222
01:02:02,870 --> 01:02:04,310
或者，该列中不存在。

1223
01:02:04,310 --> 01:02:05,400
出事了。

1224
01:02:05,400 --> 01:02:08,170
那么，在这种情况下，你会希望
确保您检查是否

1225
01:02:08,170 --> 01:02:09,700
查询返回false。

1226
01:02:09,700 --> 01:02:15,590
这就是使用三
等于操作有。

1227
01:02:15,590 --> 01:02:19,660
>> 然后我道歉，这是另一种
CS50函数，传递一个消息。

1228
01:02:19,660 --> 01:02:23,435
如果你看看道歉，这一切
确实是呈现apology.php。

1229
01:02:23,435 --> 01:02:26,100

1230
01:02:26,100 --> 01:02:26,410
是啊。

1231
01:02:26,410 --> 01:02:29,630
>> 观众：你能解释一下是什么
选择并从恒星之间呢​​？

1232
01:02:29,630 --> 01:02:30,710
>> ZAMYLA陈：是的，绝对。

1233
01:02:30,710 --> 01:02:35,220
因此，在选择和之间的明星
也就是说，我要选择整个

1234
01:02:35,220 --> 01:02:37,440
从我的桌子整行。

1235
01:02:37,440 --> 01:02:41,900
我可能已经表示选择
名称，年份，房子。

1236
01:02:41,900 --> 01:02:46,160
而我只得到这三个
列在我的表。

1237
01:02:46,160 --> 01:02:51,560
但如果我说选择*，然后我会
得到一切在该列中。

1238
01:02:51,560 --> 01:02:53,760
然后我会去你
在后面的第一个。

1239
01:02:53,760 --> 01:02:57,656
>> 观众：所以这仍然是
在SQL中，对不对？

1240
01:02:57,656 --> 01:02:59,610
这是查询还是这个PHP？

1241
01:02:59,610 --> 01:03:00,550
>> ZAMYLA陈：我们正处在一个查询中。

1242
01:03:00,550 --> 01:03:01,940
所以这是在PHP。

1243
01:03:01,940 --> 01:03:06,280
因此，使用PHP函数查询，
我们正在执行一个SQL查询。

1244
01:03:06,280 --> 01:03:11,988

1245
01:03:11,988 --> 01:03:15,364
>> 观众：是在SQL什么
区分大小写，如选择

1246
01:03:15,364 --> 01:03:17,834
或向导或房子？

1247
01:03:17,834 --> 01:03:20,050
>> ZAMYLA陈：是什么
在SQL区分大小写？

1248
01:03:20,050 --> 01:03:21,760
我相信是这样，是的。

1249
01:03:21,760 --> 01:03:24,620
我相信，选择和
和WHERE是区分大小写的。

1250
01:03:24,620 --> 01:03:25,535
没有？

1251
01:03:25,535 --> 01:03:27,500
>> ROB BOWDEN：所以，这是相反的。

1252
01:03:27,500 --> 01:03:32,030
列名和表的手段，
所有这些都是区分大小写的。

1253
01:03:32,030 --> 01:03:35,470
但任何MySQL的关键词，如
SELECT，FROM和WHERE，这些都不是

1254
01:03:35,470 --> 01:03:36,140
区分大小写。

1255
01:03:36,140 --> 01:03:36,420
确定。

1256
01:03:36,420 --> 01:03:37,780
所以，我说的是相反的。

1257
01:03:37,780 --> 01:03:40,420
因此，所有的MySQL的关键字 - 

1258
01:03:40,420 --> 01:03:42,670
选择从，在那里 - 那些
不区分大小写。

1259
01:03:42,670 --> 01:03:44,630
但一切是。

1260
01:03:44,630 --> 01:03:45,210
确定。

1261
01:03:45,210 --> 01:03:46,500
你在前面。

1262
01:03:46,500 --> 01:03:52,041
>> 观众：如果我有$来讲行
多行，意思是

1263
01:03:52,041 --> 01:03:53,640
只是变成一个关联数组？

1264
01:03:53,640 --> 01:03:59,550
>> ZAMYLA陈：所以现在的问题是，如果行
有一个以上的列在其中，并

1265
01:03:59,550 --> 01:04:01,800
它成为一个关联数组？

1266
01:04:01,800 --> 01:04:05,680
因此它是可结合的阵列
阵列了。

1267
01:04:05,680 --> 01:04:10,730
所以，即使只有一个行
回来了，那么你必须去

1268
01:04:10,730 --> 01:04:12,690
这一结果的索引为0。

1269
01:04:12,690 --> 01:04:15,316
然后你就会有第一行。

1270
01:04:15,316 --> 01:04:17,482
是的，贝琳达？

1271
01:04:17,482 --> 01:04:21,258
>> 观众：当你使用=​​==，
这是唯一的实例？

1272
01:04:21,258 --> 01:04:22,210
还是有其他人呢？

1273
01:04:22,210 --> 01:04:26,815
>> ZAMYLA陈：所以在这种情况下，===
是跨类型的比较。

1274
01:04:26,815 --> 01:04:29,870

1275
01:04:29,870 --> 01:04:34,050
抱歉。 ===是一个比较
用于比较的类型。

1276
01:04:34,050 --> 01:04:37,620
然后==在所有类型的比较。

1277
01:04:37,620 --> 01:04:41,620
>> 观众：你能解释一下
行是在这种情况呢？

1278
01:04:41,620 --> 01:04:45,120
它是一行数据？

1279
01:04:45,120 --> 01:04:48,100
>> ZAMYLA陈：在接下来的幻灯片，我
将解释什么是行。

1280
01:04:48,100 --> 01:04:49,890
所以，如果你不介意持有
关上了。

1281
01:04:49,890 --> 01:04:50,620
然后你在后面？

1282
01:04:50,620 --> 01:04:54,699
>> 观众：对于像查询功能，
渲染和道歉[听不清]？

1283
01:04:54,699 --> 01:04:59,050

1284
01:04:59,050 --> 01:05:03,050
>> ZAMYLA陈：现在的问题是，是否
这些功能 - 查询，道歉，

1285
01:05:03,050 --> 01:05:04,510
和渲染 - 

1286
01:05:04,510 --> 01:05:05,930
是通用的PHP。

1287
01:05:05,930 --> 01:05:09,460
这些都是那些CS50
写了pset7。

1288
01:05:09,460 --> 01:05:09,910
和杰伊？

1289
01:05:09,910 --> 01:05:15,333
>> 观众：当你需要说
$ _SESSION，是只为ID吗？

1290
01:05:15,333 --> 01:05:17,310
或者可能你说过吗？

1291
01:05:17,310 --> 01:05:23,440
>> ZAMYLA陈：所以现在的问题是，当
我们使用$ _SESSION，这是一个特定的

1292
01:05:23,440 --> 01:05:25,290
我们正在使用的全局变量。

1293
01:05:25,290 --> 01:05:32,080
在这里，这个变量将
是本地的我们的函数。

1294
01:05:32,080 --> 01:05:36,588
所以，我们只是声明
一个新的变量。

1295
01:05:36,588 --> 01:05:38,460
>> 观众：如何道歉
实施？

1296
01:05:38,460 --> 01:05:40,960
>> ZAMYLA陈：现在的问题是，
是如何实现的道歉？

1297
01:05:40,960 --> 01:05:44,180
我认为这实际上是一个非常
好习惯为你们进入

1298
01:05:44,180 --> 01:05:49,260
在functions.php的部分和看
道歉，看看你可以有

1299
01:05:49,260 --> 01:05:50,670
做你自己。

1300
01:05:50,670 --> 01:05:55,620
所以，我可以留给你，但只是
说，如果你道歉，

1301
01:05:55,620 --> 01:06:02,110
那么它需要的信息是，你
提交道歉，然后将其

1302
01:06:02,110 --> 01:06:06,570
呈现该消息。

1303
01:06:06,570 --> 01:06:08,240
还有什么问题吗？

1304
01:06:08,240 --> 01:06:08,710
我爱的问题。

1305
01:06:08,710 --> 01:06:09,555
所以回头率。

1306
01:06:09,555 --> 01:06:11,888
>> 观众：[听不清]

1307
01:06:11,888 --> 01:06:13,840
echo或print那里？

1308
01:06:13,840 --> 01:06:15,900
>> ZAMYLA陈：现在的问题是，
我们不能只是已经把

1309
01:06:15,900 --> 01:06:17,000
echo或print那里。

1310
01:06:17,000 --> 01:06:19,710
让会做什么
略有不同。

1311
01:06:19,710 --> 01:06:23,750
那将打印出来的查询
没成 - 

1312
01:06:23,750 --> 01:06:27,420
好了，现在，我们实际上
在我们的控制器。

1313
01:06:27,420 --> 01:06:30,350
所以我们实际上没有
HTML设在这里。

1314
01:06:30,350 --> 01:06:34,946
通过渲染apologize.php道歉
实际上将您重定向到apology.php。

1315
01:06:34,946 --> 01:06:39,560

1316
01:06:39,560 --> 01:06:42,200
确定。

1317
01:06:42,200 --> 01:06:45,880
>> 所以，现在，让我们去解决
从早期的问题是关于什么

1318
01:06:45,880 --> 01:06:47,330
真的是行。

1319
01:06:47,330 --> 01:06:51,960
那么，查询将返回
列的阵列。

1320
01:06:51,960 --> 01:06:55,020
而每一行代表
通过一个关联数组。

1321
01:06:55,020 --> 01:07:02,840
所以，如果我执行一些SQL查询，
我已经存储的结果行，然后

1322
01:07:02,840 --> 01:07:07,850
使用foreach循环，那么阵列
名字是有第一个 - 行。

1323
01:07:07,850 --> 01:07:13,170
然后我要去打电话
每一行中有$行。

1324
01:07:13,170 --> 01:07:20,060
>> 这样遍历了，然后我就可以
访问给定行的名称列，

1325
01:07:20,060 --> 01:07:22,340
年柱，和房子列。

1326
01:07:22,340 --> 01:07:28,010
请注意，我不会已经能够
做这个行，因为行的索引

1327
01:07:28,010 --> 01:07:29,290
名称不存在。

1328
01:07:29,290 --> 01:07:31,970
行是只是一个数组
关联数组。

1329
01:07:31,970 --> 01:07:34,870
所以，你有两个层面存在。

1330
01:07:34,870 --> 01:07:37,170
一旦你有行的数组，
你必须去那个。

1331
01:07:37,170 --> 01:07:39,110
然后你就可以访问该列。

1332
01:07:39,110 --> 01:07:41,636
这是否说清楚？

1333
01:07:41,636 --> 01:07:42,520
是啊，在前面？

1334
01:07:42,520 --> 01:07:45,490
>> 观众：[听不清]打开
括号内为[听不清]？

1335
01:07:45,490 --> 01:07:46,220
>> ZAMYLA陈：请原谅我吗？

1336
01:07:46,220 --> 01:07:49,740
>> 观众：开括号。

1337
01:07:49,740 --> 01:07:52,420
>> ZAMYLA陈：这些吗？

1338
01:07:52,420 --> 01:07:58,520
这让我有
该变量。

1339
01:07:58,520 --> 01:07:58,670
是啊。

1340
01:07:58,670 --> 01:08:01,900
>> 观众：当您打印，是您
打印到的HTML代码？

1341
01:08:01,900 --> 01:08:03,110
>> ZAMYLA陈：是的。

1342
01:08:03,110 --> 01:08:07,720
当我打印，这在这里是内
我的模板，因此

1343
01:08:07,720 --> 01:08:10,310
我的看法MVC的方法。

1344
01:08:10,310 --> 01:08:12,750
所以我打印到HTML。

1345
01:08:12,750 --> 01:08:16,670
>> 观众：所以，如果我们走进开发商
运行此工具后，我们可以

1346
01:08:16,670 --> 01:08:17,160
实际上在代码中？

1347
01:08:17,160 --> 01:08:18,410
>> ZAMYLA陈：这是一个伟大的
的问题，是的。

1348
01:08:18,410 --> 01:08:22,359
所以，如果你走进了开发者工具
使用Firebug的或Firefox中

1349
01:08:22,359 --> 01:08:26,109
Chrome浏览器，那么是的，你可以
请参阅特定的HTML。

1350
01:08:26,109 --> 01:08:28,470
所以它不会显示$行[“名称”]。

1351
01:08:28,470 --> 01:08:32,524
它会显示为准
名字是该行。

1352
01:08:32,524 --> 01:08:36,268
>> 观众：只是一个一般性的问题，
什么是TR和TD定义为？

1353
01:08:36,268 --> 01:08:37,672
为什么我们[听不清]？

1354
01:08:37,672 --> 01:08:41,850

1355
01:08:41,850 --> 01:08:44,814
>> ZAMYLA陈：表列TR，
表，然后TD列。

1356
01:08:44,814 --> 01:08:48,060

1357
01:08:48,060 --> 01:08:49,310
确定。

1358
01:08:49,310 --> 01:08:55,771

1359
01:08:55,771 --> 01:08:56,835
>> 观众：是的，这是表中的数据。

1360
01:08:56,835 --> 01:08:58,770
>> ZAMYLA陈：表数据。

1361
01:08:58,770 --> 01:08:59,894
是啊。

1362
01:08:59,894 --> 01:09:08,670
>> 观众：这是一个排在其中
行被视为一个列？

1363
01:09:08,670 --> 01:09:08,910
>> ZAMYLA陈：对不起。

1364
01:09:08,910 --> 01:09:10,570
你能再说一遍吗？

1365
01:09:10,570 --> 01:09:14,450
>> 观众：你将如何
可视化行？

1366
01:09:14,450 --> 01:09:16,310
>> ZAMYLA陈：你将如何显现
以什么样的方式行？

1367
01:09:16,310 --> 01:09:21,796
你说的是这些
这里的行或TR行？

1368
01:09:21,796 --> 01:09:22,630
>> 观众：该行。

1369
01:09:22,630 --> 01:09:25,229
>> ZAMYLA陈：这里这些行？

1370
01:09:25,229 --> 01:09:28,620
我会想象这是
我执行我的查询。

1371
01:09:28,620 --> 01:09:38,729
它说，好吧，我是0到n
符合条件的行的金额

1372
01:09:38,729 --> 01:09:40,510
你曾质疑。

1373
01:09:40,510 --> 01:09:43,740
所以，我有行的某个数字。

1374
01:09:43,740 --> 01:09:51,450
所以行时，$行，每个门店
1阵列中的那些行。

1375
01:09:51,450 --> 01:09:58,110
因此，即使它只是其中之一，它的
还是它相匹配的行的数组。

1376
01:09:58,110 --> 01:10:03,010
>> 是这样，那么，举例来说，这是
类似的，当你取出

1377
01:10:03,010 --> 01:10:05,390
从用户的缓存。

1378
01:10:05,390 --> 01:10:10,810
与标准有地方
ID等于会话ID。

1379
01:10:10,810 --> 01:10:14,250
真的只能是一行
可能匹配。

1380
01:10:14,250 --> 01:10:18,960
但仍行刚刚返回一行。

1381
01:10:18,960 --> 01:10:22,620
所以你必须去行，
指数为0，索引缓存到

1382
01:10:22,620 --> 01:10:26,195
实际进行缓存。

1383
01:10:26,195 --> 01:10:29,650
>> 观众：是对打印功能
在呼应同样的事情？

1384
01:10:29,650 --> 01:10:30,670
>> ZAMYLA陈：是的。

1385
01:10:30,670 --> 01:10:31,190
是。

1386
01:10:31,190 --> 01:10:33,304
打印相同的回声。

1387
01:10:33,304 --> 01:10:42,400
>> 观众：是对foreach循环的
只有这样，才能索引行？

1388
01:10:42,400 --> 01:10:46,110
>> ZAMYLA陈：是foreach循环
唯一的办法，你可以

1389
01:10:46,110 --> 01:10:47,030
通过行迭代？

1390
01:10:47,030 --> 01:10:47,180
号

1391
01:10:47,180 --> 01:10:51,000
您也可以使用for循环，提供
你知道的长度

1392
01:10:51,000 --> 01:10:53,024
行的数组。

1393
01:10:53,024 --> 01:10:58,500
>> 观众：你能访问它
使用行为[听不清]？

1394
01:10:58,500 --> 01:11:01,640
>> ZAMYLA陈：所以你不能访问它
只是使用行，如果你没有一个

1395
01:11:01,640 --> 01:11:05,160
foreach循环条件是
您还没有宣布一行。

1396
01:11:05,160 --> 01:11:08,150

1397
01:11:08,150 --> 01:11:09,660
是。

1398
01:11:09,660 --> 01:11:10,810
是啊，在白色的。

1399
01:11:10,810 --> 01:11:13,990
>> 听众：那TR和TD呢？

1400
01:11:13,990 --> 01:11:16,790
>> ZAMYLA陈：所以tr和
TD是HTML标签。

1401
01:11:16,790 --> 01:11:19,590
TR表示开始
的表行。

1402
01:11:19,590 --> 01:11:26,625
而每个TD表示
新表中的数据列。

1403
01:11:26,625 --> 01:11:32,275
>> 观众：对于一个视觉的东西一排
很喜欢，只是想象中的SQL语句，如何

1404
01:11:32,275 --> 01:11:33,510
它们具有一排。

1405
01:11:33,510 --> 01:11:35,980
[听不清]。

1406
01:11:35,980 --> 01:11:36,390
>> ZAMYLA陈：是的。

1407
01:11:36,390 --> 01:11:37,630
这是一个很大的问题。

1408
01:11:37,630 --> 01:11:41,510
你可以想像行作为刚
像在Excel表中，只

1409
01:11:41,510 --> 01:11:44,540
的行的列表。

1410
01:11:44,540 --> 01:11:46,870
确定。

1411
01:11:46,870 --> 01:11:47,230
好的。

1412
01:11:47,230 --> 01:11:50,740
所以，现在我们已经讨论了选择，如果
不会有任何问题，我们将

1413
01:11:50,740 --> 01:11:52,970
在去到插入。

1414
01:11:52,970 --> 01:11:58,220
所以，如果我想插入一些
表并插入某些列

1415
01:11:58,220 --> 01:12:02,320
价值观，我可以自己插入
进入拉文克劳的7年。

1416
01:12:02,320 --> 01:12:07,245
但有时可能会有重复的
价值观，正如我们在pset7看到，当我们

1417
01:12:07,245 --> 01:12:09,240
更新了我们的产品组合。

1418
01:12:09,240 --> 01:12:15,610
>> 因此，在这种情况下，我们希望使用开启
重复键更新，让我们不

1419
01:12:15,610 --> 01:12:18,280
存储多个行具有相同
珍惜而是对其进行更新。

1420
01:12:18,280 --> 01:12:21,780

1421
01:12:21,780 --> 01:12:25,560
那么我们其实有更新，
这不是一个插入。

1422
01:12:25,560 --> 01:12:30,100
它只是在那里你更新的更新
在一定的表与一个给定

1423
01:12:30,100 --> 01:12:34,403
条件，然后，最后，删除
这确实一个非常类似的事情。

1424
01:12:34,403 --> 01:12:40,200
>> 您能否简要：观众
走在重复键？

1425
01:12:40,200 --> 01:12:40,850
>> ZAMYLA陈：是的。

1426
01:12:40,850 --> 01:12:48,340
从本质上讲这里，我有INSERT INTO
古灵阁，是，帆船，这些值。

1427
01:12:48,340 --> 01:12:56,900
但ID，想必，是一个独特的关键
值设置在MySQL表。

1428
01:12:56,900 --> 01:13:06,750
所以，如果我已经有了这个ID设置，
然后我不能插入新行。

1429
01:13:06,750 --> 01:13:10,961
因此，如果它不存在，则
那我也来更新它。

1430
01:13:10,961 --> 01:13:16,040

1431
01:13:16,040 --> 01:13:17,722
在白色的中间。

1432
01:13:17,722 --> 01:13:21,570
>> 观众：所以插入，更新，删除，
和选择，是那些所有可用

1433
01:13:21,570 --> 01:13:22,875
当地[听不清]？

1434
01:13:22,875 --> 01:13:27,320

1435
01:13:27,320 --> 01:13:29,630
>> ZAMYLA陈：所以插入，
更新，删除和

1436
01:13:29,630 --> 01:13:31,120
选择是所有的SQL查询。

1437
01:13:31,120 --> 01:13:34,970
所以每当你使用SQL，
你有那些可用。

1438
01:13:34,970 --> 01:13:38,226

1439
01:13:38,226 --> 01:13:40,706
>> 观众：回到过去的测验 - 

1440
01:13:40,706 --> 01:13:44,178
有一个问题，处理
如果你有一个表，并希望

1441
01:13:44,178 --> 01:13:52,610
插入测试成绩中的一个，你插入
你的名字，所以它不会让你

1442
01:13:52,610 --> 01:13:54,594
[听不清]你的朋友的测试成绩。

1443
01:13:54,594 --> 01:13:59,060
你会怎么做，与插入？

1444
01:13:59,060 --> 01:14:02,490
>> ZAMYLA陈：所以现在的问题是关于
前一期中的问题。

1445
01:14:02,490 --> 01:14:04,320
我不知道其中的
一方面，这是现在。

1446
01:14:04,320 --> 01:14:06,790
因此，也许以后，如果你想
上来，告诉我，然后我就可以

1447
01:14:06,790 --> 01:14:08,155
肯定给你提示。

1448
01:14:08,155 --> 01:14:11,250

1449
01:14:11,250 --> 01:14:15,460
但讲的东西插入，像
走别人的分数，当你

1450
01:14:15,460 --> 01:14:18,800
不应该，让我们来谈谈
SQL注入攻击。

1451
01:14:18,800 --> 01:14:22,050
因此，SQL注入攻击本质上是
如果有人需要

1452
01:14:22,050 --> 01:14:27,680
优势的低安全性
你正在服用的数据的方式。

1453
01:14:27,680 --> 01:14:35,660
>> 所以在这里，就像在CS50金融，
当我们登录的，我们可以在输入

1454
01:14:35,660 --> 01:14:39,510
用户名的登录表单，
第一个文本框，

1455
01:14:39,510 --> 01:14:41,570
然后在密码输入。

1456
01:14:41,570 --> 01:14:45,610
也许我们的PHP代码看起来可能
这样的事情，$ username的

1457
01:14:45,610 --> 01:14:51,410
是后数据的用户名和密码
是后数据的密码。

1458
01:14:51,410 --> 01:14:55,110
然后，我们只是执行我们的查询，比如，
好了，好了，我们的查询是要

1459
01:14:55,110 --> 01:14:57,990
从我们的用户选择，其中
用户名是

1460
01:14:57,990 --> 01:14:58,970
一个他们提交。

1461
01:14:58,970 --> 01:15:06,870
而密码是密码，
这意味着口令匹配。

1462
01:15:06,870 --> 01:15:12,670
>> 现在，如果不是实际
提交一个实际的密码，如

1463
01:15:12,670 --> 01:15:16,850
12345和猜测叉，上面写着
密码，并试图破解他们的

1464
01:15:16,850 --> 01:15:21,460
帐户，如果有什么，而不是
他们提交了这一点。

1465
01:15:21,460 --> 01:15:24,380
他们可以键入也许
一个猜测的密码。

1466
01:15:24,380 --> 01:15:30,480
然后，他们将完成
报价然后输入或1 = 1。

1467
01:15:30,480 --> 01:15:35,160
这将直接踱步到SQL
查询到是这个样子。

1468
01:15:35,160 --> 01:15:38,200
从用户选择其中的username
=插脚和密码

1469
01:15:38,200 --> 01:15:41,450
等于百合或1 = 1。

1470
01:15:41,450 --> 01:15:45,450
>> 因此，无论密码有
为正确或1 = 1，

1471
01:15:45,450 --> 01:15:47,870
这始终是真实的。

1472
01:15:47,870 --> 01:15:52,780
所以在这种情况下，基本上，使用者可
利用这一优势，只要登录

1473
01:15:52,780 --> 01:15:55,240
自己在和黑客
别人的账户。

1474
01:15:55,240 --> 01:15:58,950
所以这就是为什么我们要避免
有人不得不这样做。

1475
01:15:58,950 --> 01:16:03,890
但幸运的是，通过查询功能
通过在占位符会

1476
01:16:03,890 --> 01:16:04,800
这种照顾你。

1477
01:16:04,800 --> 01:16:08,570
此外，你通常会永远都不想
实际提交的密码

1478
01:16:08,570 --> 01:16:09,310
他们自己。

1479
01:16:09,310 --> 01:16:14,115
这就是为什么我们散列或加密
他们在CS50融资。

1480
01:16:14,115 --> 01:16:17,553
>> 观众：过去谈到测验
关于MySQL的转义字符串。

1481
01:16:17,553 --> 01:16:21,800
我们要担心？

1482
01:16:21,800 --> 01:16:22,670
>> ZAMYLA陈：这是一个很好的问题。

1483
01:16:22,670 --> 01:16:29,050
MySQL的转义字符串肯定是一个
函数是在我们的查询中使用。

1484
01:16:29,050 --> 01:16:30,420
但一定要看看那。

1485
01:16:30,420 --> 01:16:32,950
我会说这是公平的游戏知道
那你需要调用

1486
01:16:32,950 --> 01:16:34,370
功能上的绳子。

1487
01:16:34,370 --> 01:16:35,245
是啊，贝琳达？

1488
01:16:35,245 --> 01:16:38,606
>> 观众：你怎么知道什么时候
单引号或双引号？

1489
01:16:38,606 --> 01:16:43,516
而且，我觉得自己像在课堂上你
提及有关没有

1490
01:16:43,516 --> 01:16:48,426
在[听不清]或某事或
在结束第二个单引号。

1491
01:16:48,426 --> 01:16:56,407

1492
01:16:56,407 --> 01:17:00,825
我觉得他指出，在该演讲
你应该有撇号1

1493
01:17:00,825 --> 01:17:04,290
再没有撇号
什么的。

1494
01:17:04,290 --> 01:17:05,540
>> 观众：[听不清]。

1495
01:17:05,540 --> 01:17:14,860

1496
01:17:14,860 --> 01:17:18,657
>> 观众：事情是最后一个
报价有在第二个框

1497
01:17:18,657 --> 01:17:19,391
不应该存在。

1498
01:17:19,391 --> 01:17:21,840
[听不清]

1499
01:17:21,840 --> 01:17:26,730
因为当你把去年单
引述出来，匹配这些内容

1500
01:17:26,730 --> 01:17:30,522
其中的密码，如果你有
查询中，有在一个单引号

1501
01:17:30,522 --> 01:17:31,340
结束了。

1502
01:17:31,340 --> 01:17:36,580
你要使用单引号
作为面向1所述一个

1503
01:17:36,580 --> 01:17:37,574
[听不清]。

1504
01:17:37,574 --> 01:17:42,820
那么什么是真正的文本
盒子不应该有。

1505
01:17:42,820 --> 01:17:44,070
>> ZAMYLA陈：我会改变这种状况。

1506
01:17:44,070 --> 01:17:56,490

1507
01:17:56,490 --> 01:17:56,880
确定。

1508
01:17:56,880 --> 01:18:00,435
如果没有任何问题，然后我会
将它传递给约瑟夫谈

1509
01:18:00,435 --> 01:18:04,332
有关JavaScript的，等等。

1510
01:18:04,332 --> 01:18:09,540
>> [掌声]

1511
01:18:09,540 --> 01:18:11,660
>> 王阳：所以我们正在运行
有点落后。

1512
01:18:11,660 --> 01:18:13,280
所以，如果你要离开，那也无妨。

1513
01:18:13,280 --> 01:18:16,540
但我们要求你保持你的头向下
如果你是在中间，所以你

1514
01:18:16,540 --> 01:18:19,560
不要挡住相机，并使用
如果你有到后面退出。

1515
01:18:19,560 --> 01:18:25,010

1516
01:18:25,010 --> 01:18:26,306
我是约瑟夫的方式。

1517
01:18:26,306 --> 01:18:27,556
你好。

1518
01:18:27,556 --> 01:18:37,910

1519
01:18:37,910 --> 01:18:38,630
测试，测试。

1520
01:18:38,630 --> 01:18:39,630
丹，是好？

1521
01:18:39,630 --> 01:18:40,880
凉爽。

1522
01:18:40,880 --> 01:18:44,460

1523
01:18:44,460 --> 01:18:47,600
>> 因此视频也将发布
网上的那些

1524
01:18:47,600 --> 01:18:48,850
现在不得不离开。

1525
01:18:48,850 --> 01:18:51,350

1526
01:18:51,350 --> 01:18:52,600
别扭。

1527
01:18:52,600 --> 01:18:56,300

1528
01:18:56,300 --> 01:18:57,510
确定。

1529
01:18:57,510 --> 01:18:59,730
所以测验复习。

1530
01:18:59,730 --> 01:19:00,980
这是一只猫。

1531
01:19:00,980 --> 01:19:03,150

1532
01:19:03,150 --> 01:19:07,170
现在，JavaScript中，这也许是不
作为AWW一些你们的。

1533
01:19:07,170 --> 01:19:07,370
确定。

1534
01:19:07,370 --> 01:19:09,280
所以这是第一次，记得Zamyla。

1535
01:19:09,280 --> 01:19:11,270
请记住，PHP是
在服务器上运行。

1536
01:19:11,270 --> 01:19:15,230
和很多次，你们写循环
在PHP中打印出来的HTML，对不对？

1537
01:19:15,230 --> 01:19:19,170
所以一旦该代码执行，即
你打印出HTML输出

1538
01:19:19,170 --> 01:19:20,500
被发送给用户。

1539
01:19:20,500 --> 01:19:25,960
而一旦出现这种情况，没有更多的PHP可以
运行的，除非你重新加载页面，

1540
01:19:25,960 --> 01:19:27,660
当然，这重新执行PHP的。

1541
01:19:27,660 --> 01:19:30,080
但是，一旦你打印出的HTML，
你不能去任何地方。

1542
01:19:30,080 --> 01:19:33,580
>> 使得HTML被发送给用户，
这是浏览器在这里，在这里

1543
01:19:33,580 --> 01:19:35,470
高粱是使用计算机。

1544
01:19:35,470 --> 01:19:40,340
和这么好，有几件事情
一旦我们发送HTML给用户。

1545
01:19:40,340 --> 01:19:43,350
有时候，我们想这样做
当你点击的东西，我们要

1546
01:19:43,350 --> 01:19:47,350
弹出，那些各种各样的警告框
相互作用，当您按下喜欢

1547
01:19:47,350 --> 01:19:50,740
键，当您单击上的东西
页，我想要的东西发生。

1548
01:19:50,740 --> 01:19:54,550
嗯，你可以不重新执行PHP
一旦代码的HTML设置。

1549
01:19:54,550 --> 01:19:55,900
那么，你如何做到这一点？

1550
01:19:55,900 --> 01:19:59,930
>> 我们引入了一个新的语言称为
JavaScript中，它运行在浏览器中

1551
01:19:59,930 --> 01:20:02,890
可以让你做的事情
您收到后为HTML

1552
01:20:02,890 --> 01:20:04,020
他们从服务器。

1553
01:20:04,020 --> 01:20:07,050
这就是为什么我们称之为客户端
编程语言。

1554
01:20:07,050 --> 01:20:09,110
它可以在电脑上 - 

1555
01:20:09,110 --> 01:20:11,400
客户端。

1556
01:20:11,400 --> 01:20:13,830
有关迄今有问题吗？

1557
01:20:13,830 --> 01:20:15,650
这种格局是有道理的人呢？

1558
01:20:15,650 --> 01:20:16,010
确定。

1559
01:20:16,010 --> 01:20:16,790
好。

1560
01:20:16,790 --> 01:20:17,340
好的。

1561
01:20:17,340 --> 01:20:20,850
所以，首先要注意
是JavaScript是不是PHP。

1562
01:20:20,850 --> 01:20:23,010
>> 他们有一些不同的语法，
我们将去成。

1563
01:20:23,010 --> 01:20:24,530
和他们有很不同的用途。

1564
01:20:24,530 --> 01:20:26,640
JavaScript中，再次为您
浏览器，用于客户端。

1565
01:20:26,640 --> 01:20:30,640
服务器在某处运行在别人的
计算机发送信息

1566
01:20:30,640 --> 01:20:31,720
对你，对不对？

1567
01:20:31,720 --> 01:20:36,730
因此，如果我们要求你写PHP代码
关于考试的问题，不写

1568
01:20:36,730 --> 01:20:38,710
JavaScript的，反之亦然。

1569
01:20:38,710 --> 01:20:41,710
你只失分，
它不会是正确的。

1570
01:20:41,710 --> 01:20:43,690
>> 所以，让我们来看看一些
语法差异 - 

1571
01:20:43,690 --> 01:20:46,140
JavaScript的左侧
而右边的PHP。

1572
01:20:46,140 --> 01:20:48,670
你会注意到的第一件事情
JavaScript中，我们声明变量

1573
01:20:48,670 --> 01:20:49,440
var关键字 - 

1574
01:20:49,440 --> 01:20:53,590
V-A-R。 PHP中的美元符号，
作为Zamyla前面所讨论的。

1575
01:20:53,590 --> 01:20:57,570
如果你想声明一个关联
数组，我们看到了熟悉的语法上

1576
01:20:57,570 --> 01:20:59,030
右侧用PHP。

1577
01:20:59,030 --> 01:21:01,630
在左边，而不是
您使用大括号。

1578
01:21:01,630 --> 01:21:03,280
然后你的钥匙是在左边。

1579
01:21:03,280 --> 01:21:04,670
那么你有一个冒号。

1580
01:21:04,670 --> 01:21:06,560
然后你有值
你想要的。

1581
01:21:06,560 --> 01:21:09,840
>> 因此，这是你将如何做到这一点在PHP
在右侧与该第二

1582
01:21:09,840 --> 01:21:10,955
，在米洛启动线。

1583
01:21:10,955 --> 01:21:14,540
那就是你将如何做到这一点的
左侧在JavaScript中，如果你想

1584
01:21:14,540 --> 01:21:16,110
我们所说的对象。

1585
01:21:16,110 --> 01:21:19,340
而在JavaScript中的对象是
只是关联数组。

1586
01:21:19,340 --> 01:21:23,710
所以，如果您要访问的字段，在
PHP中使用这种支架的语法。

1587
01:21:23,710 --> 01:21:27,170
而这样一来，您可以重新分配
这个所有者字段劳伦。

1588
01:21:27,170 --> 01:21:30,150
>> 那么，在JavaScript中，如果一个人想
访问一个字段并改变它，你可以

1589
01:21:30,150 --> 01:21:31,370
使用点语法。

1590
01:21:31,370 --> 01:21:33,860
您也可以使用括号语法。

1591
01:21:33,860 --> 01:21:35,550
但你无法使用
点语法在PHP。

1592
01:21:35,550 --> 01:21:36,525
这是行不通的。

1593
01:21:36,525 --> 01:21:38,910
它仅适用于PHP的。

1594
01:21:38,910 --> 01:21:42,060
最后，要打印的东西到
控制台，您可以使用console.log的，这

1595
01:21:42,060 --> 01:21:43,720
你们在pset8使用了很多。

1596
01:21:43,720 --> 01:21:45,260
您可以CONSOLE.LOG的。

1597
01:21:45,260 --> 01:21:50,030
>> 如果你想在打印一个数组
PHP中，你必须使用打印河

1598
01:21:50,030 --> 01:21:53,240
而在右边，你看我哈希
字符串串联那边。

1599
01:21:53,240 --> 01:21:54,070
早些时候有人问。

1600
01:21:54,070 --> 01:21:55,850
我在JavaScript中使用一个加号。

1601
01:21:55,850 --> 01:21:59,800
如果我想的东西串连
在PHP中，我使用点。

1602
01:21:59,800 --> 01:22:00,800
这些是不同的。

1603
01:22:00,800 --> 01:22:03,420
如果你正在编写PHP代码，
不要用一个加号。

1604
01:22:03,420 --> 01:22:06,810
如果你正在编写的JavaScript
代码，不写一个点。

1605
01:22:06,810 --> 01:22:08,230
这将是错误的。

1606
01:22:08,230 --> 01:22:09,640
，你会伤心。

1607
01:22:09,640 --> 01:22:11,000
>> 所以语法的差异。

1608
01:22:11,000 --> 01:22:14,710
了解你的语法，因为如果你有
写一个问题，你用语法

1609
01:22:14,710 --> 01:22:16,890
从错误的语言，
它不会工作。

1610
01:22:16,890 --> 01:22:19,520
这将是错误的。

1611
01:22:19,520 --> 01:22:22,420
因此，让我们来谈谈一些控制
流的差异，你如何使用

1612
01:22:22,420 --> 01:22:24,040
循环在他们每个人。

1613
01:22:24,040 --> 01:22:26,610
Zamyla走到右边。

1614
01:22:26,610 --> 01:22:27,780
东西的右侧
应该很熟悉。

1615
01:22:27,780 --> 01:22:29,670
让我们来看看在左侧。

1616
01:22:29,670 --> 01:22:34,830
>> 当您使用在JavaScriptÑ环，
你的循环变量，变种我在那边，

1617
01:22:34,830 --> 01:22:37,210
遍历数组的键。

1618
01:22:37,210 --> 01:22:39,150
所以你看名字，房子和作用。

1619
01:22:39,150 --> 01:22:42,440
如果我CONSOLE.LOG我，我得到
名称，门牌和作用。

1620
01:22:42,440 --> 01:22:44,720
这些是密​​钥。

1621
01:22:44,720 --> 01:22:50,080
在JavaScript中，foreach循环进入
在这个数组的值。

1622
01:22:50,080 --> 01:22:52,040
那么，你注意到他们俩都是我。

1623
01:22:52,040 --> 01:22:56,000
但在这里在PHP端，它打印
出米洛，CS50，和吉祥物。

1624
01:22:56,000 --> 01:22:57,390
这些都是在PHP中的值。

1625
01:22:57,390 --> 01:23:00,180
>> 因此，这些都是怎么这两个是不同的
在不同的语言。

1626
01:23:00,180 --> 01:23:02,970
所以，如果你正在使用一个foreach
循环，不要以为它

1627
01:23:02,970 --> 01:23:03,760
给你钥匙。

1628
01:23:03,760 --> 01:23:08,010
如果您使用的是n个循环，不
假设它可以让你的价值观。

1629
01:23:08,010 --> 01:23:10,420
这是否有道理这么远吗？

1630
01:23:10,420 --> 01:23:13,630
下一张幻灯片是要告诉你
您如何访问在对面

1631
01:23:13,630 --> 01:23:15,160
他们每个人。

1632
01:23:15,160 --> 01:23:18,550
>> 好吧，如果你有钥匙在JavaScript
和你想要的值了，

1633
01:23:18,550 --> 01:23:20,440
你只是索引到
数组这一点。

1634
01:23:20,440 --> 01:23:23,640
所以我米洛将让你什么
你想要的 - 值。

1635
01:23:23,640 --> 01:23:25,260
有一个在PHP中，这不同的语法。

1636
01:23:25,260 --> 01:23:28,140
如果你真的想知道的话，我不
认为我们已经把它拿给你呢。

1637
01:23:28,140 --> 01:23:31,740
但是，如果你有兴趣，你可以使用
右边这个附加的语法

1638
01:23:31,740 --> 01:23:35,130
侧，实际上将让你的
当你使用PHP的一键

1639
01:23:35,130 --> 01:23:35,880
foreach循环。

1640
01:23:35,880 --> 01:23:39,640
琐事所以只是一点点
如果你有兴趣。

1641
01:23:39,640 --> 01:23:42,630
>> 所以，这只是为了演示
这两个循环之间的差异。

1642
01:23:42,630 --> 01:23:47,060
不要混淆起来，当你
编程的问题。

1643
01:23:47,060 --> 01:23:49,774
有关的任何问题。

1644
01:23:49,774 --> 01:23:50,770
凉爽。

1645
01:23:50,770 --> 01:23:51,310
好的。

1646
01:23:51,310 --> 01:23:52,250
JavaScript对象。

1647
01:23:52,250 --> 01:23:53,040
我谈到了他们。

1648
01:23:53,040 --> 01:23:54,650
他们就像关联数组。

1649
01:23:54,650 --> 01:23:57,730
有一件事我想请你注意
这里是在关联的值

1650
01:23:57,730 --> 01:23:59,540
数组可以在JavaScript的任何东西。

1651
01:23:59,540 --> 01:24:02,240
>> 它甚至可以是一个函数，
就像那边。

1652
01:24:02,240 --> 01:24:04,600
我有一个函数，
是一个关键的值。

1653
01:24:04,600 --> 01:24:07,030
如果我想调用该函数，
我刚刚接触树皮。

1654
01:24:07,030 --> 01:24:08,490
然后我把括号
后。

1655
01:24:08,490 --> 01:24:09,790
并且工作。

1656
01:24:09,790 --> 01:24:15,570
因此，任何问题吗？

1657
01:24:15,570 --> 01:24:16,370
没有？

1658
01:24:16,370 --> 01:24:16,650
确定。

1659
01:24:16,650 --> 01:24:18,190
好。

1660
01:24:18,190 --> 01:24:20,130
JavaScript中，如PHP，
是弱类型。

1661
01:24:20,130 --> 01:24:20,970
这是什么意思？

1662
01:24:20,970 --> 01:24:22,380
>> 它也有类型。

1663
01:24:22,380 --> 01:24:24,800
但是，当你声明一个JavaScript
变量，你说我变种。

1664
01:24:24,800 --> 01:24:25,850
你不用说了吧。

1665
01:24:25,850 --> 01:24:26,460
这不是一个东西。

1666
01:24:26,460 --> 01:24:28,000
你刚才说这是一个变量。

1667
01:24:28,000 --> 01:24:31,590
然后用JavaScript处理
引擎盖为你种下的。

1668
01:24:31,590 --> 01:24:34,390
我们之间自由转换
类型，因为这个原因。

1669
01:24:34,390 --> 01:24:37,360
所以我开始了作为一个数
在这种情况下。

1670
01:24:37,360 --> 01:24:38,790
然后，我有一个字符串。

1671
01:24:38,790 --> 01:24:39,710
而我想补充我给它。

1672
01:24:39,710 --> 01:24:41,810
我重新分配它放回我。

1673
01:24:41,810 --> 01:24:43,640
>> 因此，在首行，
i是数量。

1674
01:24:43,640 --> 01:24:47,310
在第二行，我现在变成了
字符串后，我做了重新分配。

1675
01:24:47,310 --> 01:24:52,820
在这里，我只是串连
该数字到字符串。

1676
01:24:52,820 --> 01:24:56,210
所以你看，即使我是一个
在第一部分的整数，它的排序

1677
01:24:56,210 --> 01:24:58,500
像被转换为
字符串，然后被添加

1678
01:24:58,500 --> 01:25:00,510
到那个打招呼的字符串。

1679
01:25:00,510 --> 01:25:02,340
所以这就是我的意思
由松散打字。

1680
01:25:02,340 --> 01:25:04,760
这就是你转换之间
类型变得非常容易。

1681
01:25:04,760 --> 01:25:08,840
而且它不会抛出警告
在你如同C那样。

1682
01:25:08,840 --> 01:25:12,420
>> 所以我现在包含打招呼
123的字符串。

1683
01:25:12,420 --> 01:25:13,270
下一步。

1684
01:25:13,270 --> 01:25:15,610
我们还可以比较自如
类型之间。

1685
01:25:15,610 --> 01:25:19,310
所以，如果你只是用==，很
像在PHP中，JavaScript的

1686
01:25:19,310 --> 01:25:20,480
做了类似的事情。

1687
01:25:20,480 --> 01:25:24,780
字符串123是相同的数
123，当你使用双等号。

1688
01:25:24,780 --> 01:25:27,820
当使用三重等号，但也
要确保

1689
01:25:27,820 --> 01:25:29,240
的类型是一样的。

1690
01:25:29,240 --> 01:25:31,960
所以，因为这是一个字符串，这是
一个数字，尽管它们都是

1691
01:25:31,960 --> 01:25:35,280
123，当你使用三
等于，你会得到错误的。

1692
01:25:35,280 --> 01:25:39,330
在双相等的情况下，你会得到真正的，
因为双等于没有

1693
01:25:39,330 --> 01:25:40,020
在乎的类型。

1694
01:25:40,020 --> 01:25:42,500
三重等号并不关心类型。

1695
01:25:42,500 --> 01:25:43,750
有问题吗？

1696
01:25:43,750 --> 01:25:45,790

1697
01:25:45,790 --> 01:25:48,390
确定。

1698
01:25:48,390 --> 01:25:52,870
>> 而关于JavaScript的另一件事是
范围是一种全球除非你

1699
01:25:52,870 --> 01:25:53,460
中的函数。

1700
01:25:53,460 --> 01:25:55,660
它的工作原理相同
方法在PHP实际上。

1701
01:25:55,660 --> 01:25:57,500
所以，让我们通过这个例子。

1702
01:25:57,500 --> 01:25:59,110
我设置我999。

1703
01:25:59,110 --> 01:26:00,900
然后，我进入这个循环。

1704
01:26:00,900 --> 01:26:06,110
所以，如果我打印我在此对
环，我希望0，1，2，3，4。

1705
01:26:06,110 --> 01:26:07,390
我得到到i = 4。

1706
01:26:07,390 --> 01:26:10,770
它增加我现在到5日
在fo​​r循环的结束。

1707
01:26:10,770 --> 01:26:13,300
然后它打破跳出循环，
因为它不符合

1708
01:26:13,300 --> 01:26:14,550
调理了。

1709
01:26:14,550 --> 01:26:16,650
>> 什么你认为你未来
的console.log打印出来？

1710
01:26:16,650 --> 01:26:20,570

1711
01:26:20,570 --> 01:26:24,790
所以，这就是它会做在C在C中，
因为如果你有一个像我变种外

1712
01:26:24,790 --> 01:26:28,855
和你有一个循环内变种我，像一个
for循环，那么它使得如

1713
01:26:28,855 --> 01:26:30,690
它的范围内的，两
我的是不同的。

1714
01:26:30,690 --> 01:26:34,630
在JavaScript中，它只是
把它当作同一个我。

1715
01:26:34,630 --> 01:26:37,870
我得到5，因为那是价值
后退出圈外。

1716
01:26:37,870 --> 01:26:39,120
因此，那些我的是一样的我。

1717
01:26:39,120 --> 01:26:42,620

1718
01:26:42,620 --> 01:26:44,130
这是否有道理？

1719
01:26:44,130 --> 01:26:45,720
>> 嗯，这是有道理的
一个JavaScript的立场。

1720
01:26:45,720 --> 01:26:49,510
但是，同样的模式不
结转到下他们有

1721
01:26:49,510 --> 01:26:50,310
不同的作用域规则。

1722
01:26:50,310 --> 01:26:50,630
是。

1723
01:26:50,630 --> 01:26:52,566
>> 观众：[听不清]

1724
01:26:52,566 --> 01:26:54,990
在函数外[听不清]？

1725
01:26:54,990 --> 01:26:58,340
>> 王阳：所以外面哪个函数？

1726
01:26:58,340 --> 01:27:00,810
所以，我会得到，在短短一秒钟。

1727
01:27:00,810 --> 01:27:02,580
所以我们调用foo（i）条。

1728
01:27:02,580 --> 01:27:06,920
这传递我到foo中，增量
它，然后记录它。

1729
01:27:06,920 --> 01:27:07,750
所以这是5。

1730
01:27:07,750 --> 01:27:09,210
因此它成为6。

1731
01:27:09,210 --> 01:27:11,670
但我说的是
我在该函数。

1732
01:27:11,670 --> 01:27:14,430
因为它是一个参数，它的
作用域的函数。

1733
01:27:14,430 --> 01:27:17,800
所以一旦我真正摆脱这
功能，它现在打算去

1734
01:27:17,800 --> 01:27:19,860
回到旧我。

1735
01:27:19,860 --> 01:27:23,000
我只是因为范围
它是在一个函数。

1736
01:27:23,000 --> 01:27:24,200
我们有范围和职能。

1737
01:27:24,200 --> 01:27:29,080
但我们没有范围
在JavaScript函数。

1738
01:27:29,080 --> 01:27:31,170
这是否有道理？

1739
01:27:31,170 --> 01:27:31,320
是。

1740
01:27:31,320 --> 01:27:31,660
问题。

1741
01:27:31,660 --> 01:27:34,030
>> 观众：同[听不清]？

1742
01:27:34,030 --> 01:27:34,500
>> 王阳：所以呀。

1743
01:27:34,500 --> 01:27:36,260
在PHP中，这是同样的类型的东西。

1744
01:27:36,260 --> 01:27:37,680
有一个轻微的微妙实际。

1745
01:27:37,680 --> 01:27:40,130
但是你可以问我
该复查。

1746
01:27:40,130 --> 01:27:43,930
你并不真正需要知道的
这微妙的测验。

1747
01:27:43,930 --> 01:27:47,600
对于所有意图和目的，如
变量，全局和PHP，除非

1748
01:27:47,600 --> 01:27:49,150
他们是在一个函数，同一
在JavaScript中的事情。

1749
01:27:49,150 --> 01:27:49,480
是。

1750
01:27:49,480 --> 01:27:52,890
>> 观众：这是为什么在允许
JavaScript和没有别的地方？

1751
01:27:52,890 --> 01:27:55,010
>> 王阳：那么，为什么它让
在JavaScript中，而不是C语言？

1752
01:27:55,010 --> 01:27:58,180
这只是谁想出了
JavaScript的决定，这是在确定

1753
01:27:58,180 --> 01:27:59,510
JavaScript的。

1754
01:27:59,510 --> 01:28:02,430
所以，它就像一门编程语言
约定我们会说。

1755
01:28:02,430 --> 01:28:02,580
是。

1756
01:28:02,580 --> 01:28:04,480
>> 观众：那么，为什么
他走6至5？

1757
01:28:04,480 --> 01:28:08,280
>> 王阳：所以从6到5，
因为当我通过我到foo中，该

1758
01:28:08,280 --> 01:28:13,420
我的foo里面，现在范围为foo，
因为范围存在于功能

1759
01:28:13,420 --> 01:28:15,050
JavaScript的。

1760
01:28:15,050 --> 01:28:18,720
但是，一旦我离开这里，因为它
在作用域的功能，我只是

1761
01:28:18,720 --> 01:28:24,300
使用常规的我这是内
控制流的其余部分。

1762
01:28:24,300 --> 01:28:25,210
有意义吗？

1763
01:28:25,210 --> 01:28:26,910
我可以继续前进？

1764
01:28:26,910 --> 01:28:27,320
好的。

1765
01:28:27,320 --> 01:28:29,180
凉爽。

1766
01:28:29,180 --> 01:28:31,890
>> 这样做的接受对象是
通过引用传递。

1767
01:28:31,890 --> 01:28:33,990
你知道当你通过
一个数组转换成C你可以

1768
01:28:33,990 --> 01:28:35,810
其实修改数组？

1769
01:28:35,810 --> 01:28:37,350
这是在JavaScript中同样的事情。

1770
01:28:37,350 --> 01:28:42,960
如果我通过一个对象，在这种情况下，我
米洛传递到这个catify功能。

1771
01:28:42,960 --> 01:28:44,490
米洛开始了。

1772
01:28:44,490 --> 01:28:46,310
他的名字叫米洛香蕉。

1773
01:28:46,310 --> 01:28:51,670
我通过该对象到一个函数
因为它是一个对象，一个关联

1774
01:28:51,670 --> 01:28:53,730
数组中的JavaScript。

1775
01:28:53,730 --> 01:28:57,110
>> 当我执行一个操作
在该函数中，它会

1776
01:28:57,110 --> 01:28:58,560
真正改变的对象。

1777
01:28:58,560 --> 01:29:01,720
因此，这只会发生的对象
在JavaScript中，就像它发生

1778
01:29:01,720 --> 01:29:09,230
为C。所以米罗的名字里面阵列
实际上将变成猫了。

1779
01:29:09,230 --> 01:29:10,090
这是否有道理？

1780
01:29:10,090 --> 01:29:11,840
因此，这仅适用于对象。

1781
01:29:11,840 --> 01:29:13,090
对象是通过引用传递。

1782
01:29:13,090 --> 01:29:13,400
是。

1783
01:29:13,400 --> 01:29:16,850
>> 观众：所以你说
相反，变量i。

1784
01:29:16,850 --> 01:29:17,240
>> 王阳：是啊。

1785
01:29:17,240 --> 01:29:20,330
其中变量i只是
一个数字，对不对？

1786
01:29:20,330 --> 01:29:25,280
这就像C语言，当你传递一个
一个整数，它使一个副本。

1787
01:29:25,280 --> 01:29:28,130
而当你传递一个数组，它实际上
改变了实际的数组

1788
01:29:28,130 --> 01:29:32,870
C.同样的事情发生与
中的JavaScript这种情况。

1789
01:29:32,870 --> 01:29:34,070
好的。

1790
01:29:34,070 --> 01:29:38,134
而接下来，米洛是可悲的，因为
他现在是一只猫。

1791
01:29:38,134 --> 01:29:40,790

1792
01:29:40,790 --> 01:29:45,060
这实际上米洛后
一些一趟兽医。

1793
01:29:45,060 --> 01:29:46,860
>> 那么，我们如何使用JavaScript
在一个网页？

1794
01:29:46,860 --> 01:29:47,790
我们可以将其包含。

1795
01:29:47,790 --> 01:29:50,090
这是与带标签的HTML代码。

1796
01:29:50,090 --> 01:29:51,300
所以，我必须带标签存在。

1797
01:29:51,300 --> 01:29:54,820
然后我把一些JavaScript
脚本标签中的代码。

1798
01:29:54,820 --> 01:29:56,390
然后执行此。

1799
01:29:56,390 --> 01:29:58,830
当我只是不喜欢这样，它的
所谓内联JavaScript。

1800
01:29:58,830 --> 01:30:02,400
这有点凌乱，因为
JavaScript是实际上在HTML。

1801
01:30:02,400 --> 01:30:07,010
>> 一个更好的方法来做到这一点，更漂亮，
是写在你的JavaScript

1802
01:30:07,010 --> 01:30:10,920
外部文件，然后提供
脚本标记与源。

1803
01:30:10,920 --> 01:30:14,920
这将转到该JavaScript文件
和读取JavaScript代码

1804
01:30:14,920 --> 01:30:15,960
该文件来代替。

1805
01:30:15,960 --> 01:30:18,820
而这样一来，你没有很多的
JavaScript的在你的开始

1806
01:30:18,820 --> 01:30:20,760
HTML文件，这使得
它非常的混乱。

1807
01:30:20,760 --> 01:30:21,860
你只要把它在其他地方。

1808
01:30:21,860 --> 01:30:24,310
然后它会从那里读取它。

1809
01:30:24,310 --> 01:30:25,560
这样做是有道理的？

1810
01:30:25,560 --> 01:30:27,990

1811
01:30:27,990 --> 01:30:29,640
>> 安置事宜。

1812
01:30:29,640 --> 01:30:32,620
在这种特殊情况下，
剧本是身体。

1813
01:30:32,620 --> 01:30:36,090
所以，当我执行了，有
没有在身体呢。

1814
01:30:36,090 --> 01:30:39,920
也许这会让多一点点
当我告诉这下一部分的感觉。

1815
01:30:39,920 --> 01:30:43,210
在这种情况下，脚本
自带的分区之后。

1816
01:30:43,210 --> 01:30:46,620
因此，格实际上出现
在第一页上。

1817
01:30:46,620 --> 01:30:49,470
在这里，在这个小小的红色圆圈，
你看到显示的文本。

1818
01:30:49,470 --> 01:30:51,810
然后警报显示出来。

1819
01:30:51,810 --> 01:30:54,890
>> 在第一种情况中，因为脚本
是格前，

1820
01:30:54,890 --> 01:30:56,170
警报显示第一。

1821
01:30:56,170 --> 01:30:59,250
然后在div后显示出来
您关闭了对话框。

1822
01:30:59,250 --> 01:31:01,330
所以执行事项。

1823
01:31:01,330 --> 01:31:02,290
因此，我们将记住这一点。

1824
01:31:02,290 --> 01:31:03,640
这将是非常重要
在一点点。

1825
01:31:03,640 --> 01:31:08,730

1826
01:31:08,730 --> 01:31:09,540
确定。

1827
01:31:09,540 --> 01:31:12,750
这么好，你怎么等到
加载那么在你整个页面

1828
01:31:12,750 --> 01:31:13,580
执行一些代码？

1829
01:31:13,580 --> 01:31:15,540
我们将进入这个有点
位以后了。

1830
01:31:15,540 --> 01:31:19,016
但只要保持这个位置
记事项时，我们

1831
01:31:19,016 --> 01:31:20,570
走到另一张幻灯片。

1832
01:31:20,570 --> 01:31:22,030
>> 所以我们得到的DOM现在。

1833
01:31:22,030 --> 01:31:23,550
什么是DOM？

1834
01:31:23,550 --> 01:31:26,830
所以，如果你看一下HTML代码，它只是
一群在屏幕上的文字。

1835
01:31:26,830 --> 01:31:30,560
那么，如何的JavaScript知道
这是一个HTML元素？

1836
01:31:30,560 --> 01:31:33,410
因此，我们必须有一些记忆
这种表示法

1837
01:31:33,410 --> 01:31:34,930
结构，我们有。

1838
01:31:34,930 --> 01:31:40,240
每当我们有这个在内存中
在JavaScript中表示，我们称之为

1839
01:31:40,240 --> 01:31:41,750
该DOM。

1840
01:31:41,750 --> 01:31:45,130
它只是一种方式，人们决定
我们应该代表这

1841
01:31:45,130 --> 01:31:46,400
HTML结构。

1842
01:31:46,400 --> 01:31:47,940
>> 而这是什么DOM的样子？

1843
01:31:47,940 --> 01:31:50,460
那么，在内存中的表示，
我们把这个文本。

1844
01:31:50,460 --> 01:31:52,870
我们把它变成记忆
表示。

1845
01:31:52,870 --> 01:31:54,400
因此，这是HTML。

1846
01:31:54,400 --> 01:31:58,090
所以，我们首先发现，每
DOM树中有一个文件。

1847
01:31:58,090 --> 01:31:59,400
它看起来像一棵树。

1848
01:31:59,400 --> 01:32:03,550
并且文档包含HTML
标签，其实一切

1849
01:32:03,550 --> 01:32:05,150
在这里面，现在。

1850
01:32:05,150 --> 01:32:06,970
HTML标记有两个孩子。

1851
01:32:06,970 --> 01:32:08,630
它有一个脑袋。

1852
01:32:08,630 --> 01:32:12,380
这头，如果你看一下缩进
那边怎么它的结构

1853
01:32:12,380 --> 01:32:14,960
结束标签之间，
头上有一个孩子。

1854
01:32:14,960 --> 01:32:17,130
孩子是冠军。

1855
01:32:17,130 --> 01:32:18,370
没错。

1856
01:32:18,370 --> 01:32:21,000
>> 现在，我们有一个身体的孩子。

1857
01:32:21,000 --> 01:32:24,870
然后是身体有
孩子所谓的家庭。

1858
01:32:24,870 --> 01:32:27,950
而且家里有三个孩子 - 

1859
01:32:27,950 --> 01:32:29,550
最古老的，中间和最年轻的。

1860
01:32:29,550 --> 01:32:31,960
所以，你应该知道如何画一个图
这样，当我们问你怎么

1861
01:32:31,960 --> 01:32:34,270
画一个图，当我们给
您左方的HTML。

1862
01:32:34,270 --> 01:32:36,350
知道如何生产的DOM树。

1863
01:32:36,350 --> 01:32:38,930
而这些东西在里面，但只是
一些文字，我已经代表

1864
01:32:38,930 --> 01:32:40,180
作为小盒子。

1865
01:32:40,180 --> 01:32:42,750

1866
01:32:42,750 --> 01:32:47,980
>> 这是否DOM树结构，使
感和DOM是什么？

1867
01:32:47,980 --> 01:32:49,300
那么，在p代表什么？

1868
01:32:49,300 --> 01:32:51,850
在这里，在p那边
在该标签代表一个

1869
01:32:51,850 --> 01:32:54,510
段落标记在HTML中。

1870
01:32:54,510 --> 01:32:57,080
所以，你可以看看它。

1871
01:32:57,080 --> 01:32:59,290
但它只是意味着它的一些
空间的一些文字。

1872
01:32:59,290 --> 01:33:02,910
它有一些默认的CSS样式，
因为它是一个段落标记。

1873
01:33:02,910 --> 01:33:05,130
但真的不担心
该部分太多。

1874
01:33:05,130 --> 01:33:07,510
只知道它是一个占位符
对于一些文字。

1875
01:33:07,510 --> 01:33:08,480
是。

1876
01:33:08,480 --> 01:33:10,200
问题？

1877
01:33:10,200 --> 01:33:11,021
是。

1878
01:33:11,021 --> 01:33:12,374
>> 观众：你刚才提到的CSS。

1879
01:33:12,374 --> 01:33:15,492
哈希家庭和散列
所有的东西基本上是

1880
01:33:15,492 --> 01:33:17,400
即在CSS中的ID？

1881
01:33:17,400 --> 01:33:18,440
>> 王阳：是的，没错。

1882
01:33:18,440 --> 01:33:20,380
我会得到什么这些哈希
是指在一秒钟。

1883
01:33:20,380 --> 01:33:23,480
当安吉拉走过去的CSS，她
谈到CSS选择器。

1884
01:33:23,480 --> 01:33:26,770
这些是CSS选择器的
她在说什么。

1885
01:33:26,770 --> 01:33:28,268
是的，罗布？

1886
01:33:28,268 --> 01:33:32,060
>> ROB BOWDEN：我也想发表评论
标题标签里面的DOM

1887
01:33:32,060 --> 01:33:35,385
也是一个文本节点。

1888
01:33:35,385 --> 01:33:36,070
>> 王阳：对。

1889
01:33:36,070 --> 01:33:38,370
所以标题标签里面，
我有一些文字的DOM。

1890
01:33:38,370 --> 01:33:42,730
因此，其实，这个称号应该有一个像
小箱脱落的它。

1891
01:33:42,730 --> 01:33:45,740
但它其实并不重要
在这种情况下，太多。

1892
01:33:45,740 --> 01:33:49,620
我们真的不关心文本节点，
当我们打电话给他们，太多了。

1893
01:33:49,620 --> 01:33:50,270
OK，我们做的。

1894
01:33:50,270 --> 01:33:51,520
显然，我们做的。

1895
01:33:51,520 --> 01:33:54,260

1896
01:33:54,260 --> 01:33:57,100
我会解决，当
我再次上​​传。

1897
01:33:57,100 --> 01:33:59,830
这是否有道理？

1898
01:33:59,830 --> 01:34:01,160
>> 那么，我们如何使用DOM工作？

1899
01:34:01,160 --> 01:34:03,790
每当你处理DOM中
JavaScript中，有两个步骤。

1900
01:34:03,790 --> 01:34:05,030
你选择一个DOM元素。

1901
01:34:05,030 --> 01:34:06,580
然后你做的东西出来。

1902
01:34:06,580 --> 01:34:11,480
因此，在这种情况下，抽象的，我
选择的中间元素。

1903
01:34:11,480 --> 01:34:14,530
然后做的东西的一个例子
它会改变的文本。

1904
01:34:14,530 --> 01:34:16,020
曾经是鲍勃。

1905
01:34:16,020 --> 01:34:19,930
现在，我所做的是我改变
鲍勃米洛在这种情况下。

1906
01:34:19,930 --> 01:34:22,130
>> 那么，我们实际上做如何？

1907
01:34:22,130 --> 01:34:23,440
我们如何做选择？

1908
01:34:23,440 --> 01:34:26,560
我们如何做的做的东西
事情一旦我们去的吗？

1909
01:34:26,560 --> 01:34:30,470
嗯，顺便你们已经学会了
在这个类是通过使用我们的东西

1910
01:34:30,470 --> 01:34:32,420
所谓的jQuery。

1911
01:34:32,420 --> 01:34:33,910
那么，什么是jQuery的？

1912
01:34:33,910 --> 01:34:37,220
jQuery是一个库，它使得
JavaScript的更容易编写。

1913
01:34:37,220 --> 01:34:39,500
所以有人花时间
并写了jQuery的。

1914
01:34:39,500 --> 01:34:41,530
>> jQuery的实际写入
在JavaScript中。

1915
01:34:41,530 --> 01:34:44,550
然后，因为他们现在这样做，我们
有一大堆的函数，

1916
01:34:44,550 --> 01:34:46,020
我们可以使用，使我们的
生活真的很容易。

1917
01:34:46,020 --> 01:34:48,580

1918
01:34:48,580 --> 01:34:50,030
那么，什么是一些
它的东西呢？

1919
01:34:50,030 --> 01:34:51,650
这使得选择的元素更容易。

1920
01:34:51,650 --> 01:34:54,020
这使得改变的HTML，
添加类更容易。

1921
01:34:54,020 --> 01:34:55,360
它使阿贾克斯更容易。

1922
01:34:55,360 --> 01:34:58,230
我们会得到，在第二。

1923
01:34:58,230 --> 01:35:00,630
>> 而且它类似于C库。

1924
01:35:00,630 --> 01:35:03,090
所以，你有string.h中，
你得到strlen的。

1925
01:35:03,090 --> 01:35:04,680
你得到的strcpy，所有这些事情。

1926
01:35:04,680 --> 01:35:09,650
当你有jQuery的，你会得到很好的
方式选择要素的变化

1927
01:35:09,650 --> 01:35:10,390
活动，等等。

1928
01:35:10,390 --> 01:35:12,990
你会得到额外的功能，
JavaScript不给你。

1929
01:35:12,990 --> 01:35:15,310
所以jQuery的JavaScript不。

1930
01:35:15,310 --> 01:35:18,660
jQuery是那是写在库
的JavaScript，使JavaScript的

1931
01:35:18,660 --> 01:35:20,440
更容易编写。

1932
01:35:20,440 --> 01:35:23,170
>> 所以，jQuery是不是一种编程
语言。

1933
01:35:23,170 --> 01:35:24,540
但JavaScript。

1934
01:35:24,540 --> 01:35:27,420

1935
01:35:27,420 --> 01:35:27,590
做。

1936
01:35:27,590 --> 01:35:30,420
确保你正确的术语。

1937
01:35:30,420 --> 01:35:32,490
有问题吗？

1938
01:35:32,490 --> 01:35:33,882
是。

1939
01:35:33,882 --> 01:35:35,132
那是一个问题吗？

1940
01:35:35,132 --> 01:35:37,910

1941
01:35:37,910 --> 01:35:38,350
好的。

1942
01:35:38,350 --> 01:35:40,080
那么，你如何使用jQuery？

1943
01:35:40,080 --> 01:35:42,390
那么，当你在写一些
JavaScript代码和你有一个

1944
01:35:42,390 --> 01:35:45,570
jQuery的在您的文件的顶部为
脚本文件，可以使用美元符号

1945
01:35:45,570 --> 01:35:47,310
现在可以访问jQuery的。

1946
01:35:47,310 --> 01:35:49,860
这是从不同的
美元符号在PHP。

1947
01:35:49,860 --> 01:35:51,590
>> 这是相同的符号，你
输入您的键盘上。

1948
01:35:51,590 --> 01:35:52,780
但他们的意思非常不同的事情。

1949
01:35:52,780 --> 01:35:56,090
在PHP中美元符号表示该
是我声明一个变量。

1950
01:35:56,090 --> 01:35:59,120
在JavaScript中，当你拍了
jQuery的，它代表的jQuery。

1951
01:35:59,120 --> 01:36:01,280
所以记住这一点。

1952
01:36:01,280 --> 01:36:03,420
那么，如何可能，我们选择DOM元素？

1953
01:36:03,420 --> 01:36:06,500
那么，当你这样做的丑陋的JavaScript
这样，您访问

1954
01:36:06,500 --> 01:36:08,240
记录全局变量。

1955
01:36:08,240 --> 01:36:11,170
然后你通过ID家人得到元素。

1956
01:36:11,170 --> 01:36:15,270
这真是漫长而罗嗦
而且不是很好。

1957
01:36:15,270 --> 01:36:18,190
>> 或者，你可以得到所有元素
这是一个p标签。

1958
01:36:18,190 --> 01:36:20,080
这在JavaScript中工作过。

1959
01:36:20,080 --> 01:36:22,470
但我们从来没有真正表现出
你的语法太多。

1960
01:36:22,470 --> 01:36:24,620
我们向您展示了jQuery的。

1961
01:36:24,620 --> 01:36:28,720
使整个选择了那里，
有人在JavaScript中只是得到

1962
01:36:28,720 --> 01:36:33,320
浓缩至这个很不错的美元
签署包括hashtag家庭。

1963
01:36:33,320 --> 01:36:38,480
和$ P，只是它是这样的。

1964
01:36:38,480 --> 01:36:41,690
如果你想选择所有p标签
一个家庭里面，我们把空间

1965
01:36:41,690 --> 01:36:42,890
两者之间。

1966
01:36:42,890 --> 01:36:44,815
而现在，我们得到所有的p
标记一个家庭里面。

1967
01:36:44,815 --> 01:36:48,740

1968
01:36:48,740 --> 01:36:50,380
>> 和看起来很熟悉？

1969
01:36:50,380 --> 01:36:52,880
那么，安吉拉谈到
CSS选择器。

1970
01:36:52,880 --> 01:36:54,200
给我一秒钟。

1971
01:36:54,200 --> 01:36:57,230
因此，为了选择一个元素，
你只需要使用同样的事情，你

1972
01:36:57,230 --> 01:36:58,530
会做一个CSS选择器。

1973
01:36:58,530 --> 01:37:00,910
如果你把一个哈希在前面
它，它会选择通过ID。

1974
01:37:00,910 --> 01:37:02,220
一个点按类选择。

1975
01:37:02,220 --> 01:37:06,230
如果你只是有一点不
哈希或点，它选择这些标签。

1976
01:37:06,230 --> 01:37:07,140
的问题。

1977
01:37:07,140 --> 01:37:07,470
是吗？

1978
01:37:07,470 --> 01:37:11,510
>> 观众：当我们使用点在我们的
HTML，是不jQuery的？

1979
01:37:11,510 --> 01:37:13,520
>> 王阳：点在我们的HTML
是一个JavaScript的事情。

1980
01:37:13,520 --> 01:37:14,750
这不是一个jQuery的事情。

1981
01:37:14,750 --> 01:37:17,620
你们学会了它的方式
jQuery是使用。HTML。

1982
01:37:17,620 --> 01:37:21,510
然后你通过它的任何
在HTML将是。

1983
01:37:21,510 --> 01:37:23,480
所以，我会得到，在刚刚
第二个实际上。

1984
01:37:23,480 --> 01:37:27,800
那么，我们如何做的东西到元
一旦我们选择了它？

1985
01:37:27,800 --> 01:37:30,130
所以这是一个例子
选择一个元素。

1986
01:37:30,130 --> 01:37:32,280
所以，现在，我们想要做的东西给它。

1987
01:37:32,280 --> 01:37:35,730
>> 因此，在这种情况下，让我回去
到上一张幻灯片。

1988
01:37:35,730 --> 01:37:37,360
之前，它是鲍勃。

1989
01:37:37,360 --> 01:37:40,660
我想改变这种状况
里面的HTML米洛。

1990
01:37:40,660 --> 01:37:43,240
所以，我所说的HTML功能
从元素。

1991
01:37:43,240 --> 01:37:45,580
该HTML功能
元件的方法。

1992
01:37:45,580 --> 01:37:47,430
然后我给它什么
我想在HTML的人。

1993
01:37:47,430 --> 01:37:50,560
它只是取代了什么里面
该标签与任何我给它。

1994
01:37:50,560 --> 01:37:50,830
是。

1995
01:37:50,830 --> 01:37:51,170
问题？

1996
01:37:51,170 --> 01:37:57,397
>> 观众：这个标签是用来
只对jQuery的。

1997
01:37:57,397 --> 01:37:59,313
[听不清]

1998
01:37:59,313 --> 01:38:01,230
我们不会使用它。

1999
01:38:01,230 --> 01:38:01,960
>> 王阳：是的，没错。

2000
01:38:01,960 --> 01:38:03,750
不过不要太担心
关于纯JavaScript。

2001
01:38:03,750 --> 01:38:06,670
我只是想让你们把重点放在如何
会做它用jQuery，因为

2002
01:38:06,670 --> 01:38:10,020
这将是重要的
部分的测验。

2003
01:38:10,020 --> 01:38:10,400
右。

2004
01:38:10,400 --> 01:38:10,880
没错。

2005
01:38:10,880 --> 01:38:16,025
所以你看到，包括hashtag，使
对应于与选择元件

2006
01:38:16,025 --> 01:38:18,310
因为该主题标签的ID中。

2007
01:38:18,310 --> 01:38:19,670
包括hashtag指证。

2008
01:38:19,670 --> 01:38:22,870
而这种元素具有中等的ID。

2009
01:38:22,870 --> 01:38:24,366
所以这是我们选择的元素。

2010
01:38:24,366 --> 01:38:27,160
>> 观众：[听不清]。

2011
01:38:27,160 --> 01:38:31,090
美元符号包括hashtag [听不清]？

2012
01:38:31,090 --> 01:38:31,710
>> 王阳：因此，没有。

2013
01:38:31,710 --> 01:38:33,280
现在的问题是，您可以使用。值。

2014
01:38:33,280 --> 01:38:36,445
和。值仅适用于元素
是输入。

2015
01:38:36,445 --> 01:38:40,950

2016
01:38:40,950 --> 01:38:45,495
在jQuery中，这将是
，缬氨酸，不是。价值。

2017
01:38:45,495 --> 01:38:49,080
所以，我会得到一个小例子，
演示这一切组合

2018
01:38:49,080 --> 01:38:49,850
在第二个。

2019
01:38:49,850 --> 01:38:53,130
但我认为这提供一个小片段
有意义的人为止。

2020
01:38:53,130 --> 01:38:55,450
要更改HTML，
调用HTML的方法。

2021
01:38:55,450 --> 01:38:56,432
是。

2022
01:38:56,432 --> 01:38:58,200
>> 观众：你能解释一下
再次的方法？

2023
01:38:58,200 --> 01:39:01,900
>> 王阳：所以一个方法仅仅是一个
功能属于1，在该

2024
01:39:01,900 --> 01:39:04,590
情况下，这些DOM元素之一，
因为你看到我

2025
01:39:04,590 --> 01:39:05,940
第一个选择的元素。

2026
01:39:05,940 --> 01:39:07,320
其实，让我用鼠标。

2027
01:39:07,320 --> 01:39:09,330
我选择的第一个元素。

2028
01:39:09,330 --> 01:39:12,310
然后我打电话给这个HTML
功能，它有。

2029
01:39:12,310 --> 01:39:15,710
而且由于该功能属于
这件事情，我们把它的方法。

2030
01:39:15,710 --> 01:39:19,480
这是因为它只是一个花哨的名字。

2031
01:39:19,480 --> 01:39:20,730
再说一遍。

2032
01:39:20,730 --> 01:39:22,880

2033
01:39:22,880 --> 01:39:25,170
所以请记住，我们选择
现在的元素。

2034
01:39:25,170 --> 01:39:27,810
我们已经把它的内部
元素变量。

2035
01:39:27,810 --> 01:39:28,600
正确吗？

2036
01:39:28,600 --> 01:39:34,380
>> 因此，当我们想改变的HTML上
在里面，因为它是鲍勃之前，您

2037
01:39:34,380 --> 01:39:36,420
希望该文本更改为米洛。

2038
01:39:36,420 --> 01:39:37,920
所以我们称之为的HTML。

2039
01:39:37,920 --> 01:39:41,610
我们告诉它什么是HTML中
该元素应该是现在。

2040
01:39:41,610 --> 01:39:44,107
所以它改变它米洛，
因为我给它米洛。

2041
01:39:44,107 --> 01:39:46,542
>> 观众：所以他们一起工作。

2042
01:39:46,542 --> 01:39:47,030
[听不清]

2043
01:39:47,030 --> 01:39:47,390
>> 王阳：是啊，是啊。

2044
01:39:47,390 --> 01:39:48,180
他们一起工作。

2045
01:39:48,180 --> 01:39:50,210
所以，他们中的一个选择
该元素。

2046
01:39:50,210 --> 01:39:52,863
和第二个不
什么东西。

2047
01:39:52,863 --> 01:39:53,790
是。

2048
01:39:53,790 --> 01:39:56,168
>> 观众：[听不清]。

2049
01:39:56,168 --> 01:40:01,280
如果此方法是从不同的HTML
你有法等于实际。

2050
01:40:01,280 --> 01:40:01,560
>> 王阳：是啊。

2051
01:40:01,560 --> 01:40:03,370
这是一种不同的方法。

2052
01:40:03,370 --> 01:40:04,670
这是一种不同的方法。

2053
01:40:04,670 --> 01:40:07,860
我们可以覆盖，在短短一秒钟
当我们到达一个例子。

2054
01:40:07,860 --> 01:40:12,000
我想确保我们加快
因为我们的时间不多了。

2055
01:40:12,000 --> 01:40:15,360
但是我们现在运行的方式随着时间的推移。

2056
01:40:15,360 --> 01:40:15,490
确定。

2057
01:40:15,490 --> 01:40:16,430
凉爽。

2058
01:40:16,430 --> 01:40:20,130
所以，如果你想添加一个类，有
还有一个附加的类方法。

2059
01:40:20,130 --> 01:40:24,300
这是什么只是一个例子
你可以使用jQuery做。

2060
01:40:24,300 --> 01:40:25,950
这只是增加了一个类。

2061
01:40:25,950 --> 01:40:28,660
>> 如果你想删除它，
你可以调用删除。

2062
01:40:28,660 --> 01:40:32,280
这只是另一件你可以做的。

2063
01:40:32,280 --> 01:40:35,680
因此，更多的例子可以做的事。

2064
01:40:35,680 --> 01:40:37,510
所以，我可以只把它放在
像这样的顶部？

2065
01:40:37,510 --> 01:40:38,760
老三删除。

2066
01:40:38,760 --> 01:40:42,470

2067
01:40:42,470 --> 01:40:45,930
如果我只是执行的JavaScript在
我的文件的顶部，将这项工作？

2068
01:40:45,930 --> 01:40:48,540

2069
01:40:48,540 --> 01:40:48,920
右。

2070
01:40:48,920 --> 01:40:50,530
因为中间不存在。

2071
01:40:50,530 --> 01:40:51,840
因此，这是行不通的。

2072
01:40:51,840 --> 01:40:52,800
执行顺序。

2073
01:40:52,800 --> 01:40:55,040
它去顶第一。

2074
01:40:55,040 --> 01:40:55,540
什么？

2075
01:40:55,540 --> 01:40:57,450
>> 观众：老三不存在了吗？

2076
01:40:57,450 --> 01:40:57,810
>> 王阳：是啊。

2077
01:40:57,810 --> 01:40:58,710
年龄最小的还不存在。

2078
01:40:58,710 --> 01:40:59,600
没错。

2079
01:40:59,600 --> 01:41:01,320
>> 观众：你说中间。

2080
01:41:01,320 --> 01:41:01,510
>> 王阳：对不起。

2081
01:41:01,510 --> 01:41:02,720
年龄最小的还不存在。

2082
01:41:02,720 --> 01:41:04,510
而另一件事是我没有
包含了jQuery

2083
01:41:04,510 --> 01:41:06,580
文件要求脚本的src。

2084
01:41:06,580 --> 01:41:07,960
所以这是行不通的。

2085
01:41:07,960 --> 01:41:09,580
其实，我并没有这样做，在
下一张幻灯片，这是

2086
01:41:09,580 --> 01:41:10,700
应该解决，要么。

2087
01:41:10,700 --> 01:41:14,120
但我们这样做的方式是JavaScript的
是事件驱动的。

2088
01:41:14,120 --> 01:41:17,410
所以，我们做的是我们使用一个事件
处理程序来实现这一目标。

2089
01:41:17,410 --> 01:41:19,510
所以，我选择文档
设置第一。

2090
01:41:19,510 --> 01:41:23,810
我说好，当文档
准备好了，让我运行一个函数。

2091
01:41:23,810 --> 01:41:25,470
所以，这是所有的语法手段。

2092
01:41:25,470 --> 01:41:27,100
>> 我选择的文件。

2093
01:41:27,100 --> 01:41:29,530
现在，当该文件是
准备好后，运行该函数。

2094
01:41:29,530 --> 01:41:32,970
所以在这里当文档
准备好了，这意味着所有的HTML有

2095
01:41:32,970 --> 01:41:36,140
装，然后我运行功能
去除该元素。

2096
01:41:36,140 --> 01:41:40,270
所以现在，当我运行这个功能
我传递给准备好了，我

2097
01:41:40,270 --> 01:41:43,780
保证在所有的HTML
页面会先存在。

2098
01:41:43,780 --> 01:41:44,100
是。

2099
01:41:44,100 --> 01:41:44,425
问题？

2100
01:41:44,425 --> 01:41:48,200
>> 观众：什么是事件关键字
中的函数？

2101
01:41:48,200 --> 01:41:51,750
>> 王阳：所以在该事件关键字
功能仅仅是一个参数，

2102
01:41:51,750 --> 01:41:53,490
被传递给函数
对于任何事件。

2103
01:41:53,490 --> 01:41:55,470
这只是一些
你得到免费的。

2104
01:41:55,470 --> 01:41:59,320
当您在使用密钥句柄
pset8，该事件可以告诉你，对

2105
01:41:59,320 --> 01:42:01,350
你压上的例子，其中的关键。

2106
01:42:01,350 --> 01:42:05,540
在这种情况下，一个准备好的情况下，
它实际上不是超级有用。

2107
01:42:05,540 --> 01:42:08,640
但是，对于一个键按下的事件，它更
有用的，因为你知道哪些

2108
01:42:08,640 --> 01:42:12,330
关键你通过访问键按下
代码关闭该事件的对象。

2109
01:42:12,330 --> 01:42:13,530
正确吗？

2110
01:42:13,530 --> 01:42:15,160
这是否有道理？

2111
01:42:15,160 --> 01:42:16,280
确定。

2112
01:42:16,280 --> 01:42:16,580
是。

2113
01:42:16,580 --> 01:42:17,150
问题？

2114
01:42:17,150 --> 01:42:19,290
>> 观众：所以你能放
脚本标记低了下去？

2115
01:42:19,290 --> 01:42:19,940
>> 王阳：所以呀。

2116
01:42:19,940 --> 01:42:21,500
你可以把脚本
标记低了下去。

2117
01:42:21,500 --> 01:42:23,090
但当时它只是变得非常凌乱。

2118
01:42:23,090 --> 01:42:26,590
我们想集中所有
我们在一个地方的代码。

2119
01:42:26,590 --> 01:42:28,290
这将使我们能够做到这一点。

2120
01:42:28,290 --> 01:42:32,010
还记得前面我说，有一个更好的
这样才能保证元素

2121
01:42:32,010 --> 01:42:33,880
在页面上你执行代码之前？

2122
01:42:33,880 --> 01:42:36,079
而这仅仅是一个很好的方式
你会做到这一点。

2123
01:42:36,079 --> 01:42:37,329
>> 观众：[听不清]。

2124
01:42:37,329 --> 01:42:41,710

2125
01:42:41,710 --> 01:42:42,230
>> 王阳：是啊。

2126
01:42:42,230 --> 01:42:43,460
您仍然必须，对不对？

2127
01:42:43,460 --> 01:42:46,930
因为记得，你包括
文件在页面的顶部。

2128
01:42:46,930 --> 01:42:49,890
所以它会之前，先执行
你到了页面底部。

2129
01:42:49,890 --> 01:42:54,600

2130
01:42:54,600 --> 01:42:55,180
确定。

2131
01:42:55,180 --> 01:42:59,210
所以你也可以添加不同的
类型的事件处理程序。

2132
01:42:59,210 --> 01:43:00,640
这其中只是处理点击。

2133
01:43:00,640 --> 01:43:03,910
当我点击老三，然后
它会弹出一个警告。

2134
01:43:03,910 --> 01:43:05,440
这仅仅是一个不同的
类型的事件。

2135
01:43:05,440 --> 01:43:08,840
相对于ready事件，你现在
使用click事件，当您收到

2136
01:43:08,840 --> 01:43:10,190
点击一个元素。

2137
01:43:10,190 --> 01:43:13,860
>> 所以在这种情况下，请记住，点击
处理程序附加到最小。

2138
01:43:13,860 --> 01:43:16,080
因此，它只能发生在
我点击最小。

2139
01:43:16,080 --> 01:43:19,510
而在另一篇ready事件
被附加到文档。

2140
01:43:19,510 --> 01:43:23,750
所以它会等待该文件
要准备好。

2141
01:43:23,750 --> 01:43:25,120
有意义吗？

2142
01:43:25,120 --> 01:43:26,190
我想我可以继续前进。

2143
01:43:26,190 --> 01:43:26,610
是。

2144
01:43:26,610 --> 01:43:26,980
问题？

2145
01:43:26,980 --> 01:43:28,230
>> 观众：[听不清]。

2146
01:43:28,230 --> 01:43:31,676

2147
01:43:31,676 --> 01:43:33,620
在这种情况下，你使用[听不清]。

2148
01:43:33,620 --> 01:43:36,650
>> 王阳：哦，是的，因为在这个
情况下，我必须等待最年轻的

2149
01:43:36,650 --> 01:43:40,740
元素出现在屏幕上第一
之前，我可以附加一个单击处理程序

2150
01:43:40,740 --> 01:43:43,062
它，这就是为什么我把它放在里面
的文件准备好。

2151
01:43:43,062 --> 01:43:45,780

2152
01:43:45,780 --> 01:43:46,840
确定。

2153
01:43:46,840 --> 01:43:52,390
而接下来的，所以这是一个很大的例子
你将如何结合起来的一切。

2154
01:43:52,390 --> 01:43:55,930
这仅仅是一个表单验证的例子
你已经看到了讲座。

2155
01:43:55,930 --> 01:43:58,410
因此，需要一步一步来的
你通过这个。

2156
01:43:58,410 --> 01:43:59,590
这将是完全确定。

2157
01:43:59,590 --> 01:44:01,400
刚读它从上到下。

2158
01:44:01,400 --> 01:44:03,030
>> 我有一个窗体底部。

2159
01:44:03,030 --> 01:44:07,590
当文档准备好了，我附上
提交处理程序的形式，这样，

2160
01:44:07,590 --> 01:44:12,910
当我提交表单，我得到的值
里面每个这些投入。

2161
01:44:12,910 --> 01:44:14,560
我检查它是否为空。

2162
01:44:14,560 --> 01:44:17,090
如果是空白的，我返回false，因为
我并不想提交表单，

2163
01:44:17,090 --> 01:44:18,950
因为形式是错误的。

2164
01:44:18,950 --> 01:44:22,040
如果密码为空或者它的不足
超过八个字符，不提交

2165
01:44:22,040 --> 01:44:24,470
的形式，因为这也是错误的。

2166
01:44:24,470 --> 01:44:28,150
而返回false只是防止
从提交和表单

2167
01:44:28,150 --> 01:44:30,150
去到一个新的页面。

2168
01:44:30,150 --> 01:44:31,310
>> 并希望，这是有道理的。

2169
01:44:31,310 --> 01:44:34,650
我想你们应该走通
这段代码一步你自己的一步。

2170
01:44:34,650 --> 01:44:38,350
一旦你明白什么叫做选择
元素和做的东西给它

2171
01:44:38,350 --> 01:44:40,520
实际上涉及，这将使
很多道理给你。

2172
01:44:40,520 --> 01:44:41,295
是吗？

2173
01:44:41,295 --> 01:44:44,150
>> 观众：什么的
名称=用户名是什么意思？

2174
01:44:44,150 --> 01:44:48,530
>> 王阳：所以名=用户名和
名=密码只是意味着看

2175
01:44:48,530 --> 01:44:50,730
不论属性
你选择。

2176
01:44:50,730 --> 01:44:51,790
再有相匹配。

2177
01:44:51,790 --> 01:44:53,870
所以我们进入注册。

2178
01:44:53,870 --> 01:44:56,240
然后我们来看看所有输入
和登记。

2179
01:44:56,240 --> 01:44:59,990
然后我们挑了一个地方的名字
属性等于用户名。

2180
01:44:59,990 --> 01:45:04,040
因此，首先选择只有选择
用户名输入。

2181
01:45:04,040 --> 01:45:08,220
而这第二个选择只选择
密码之一，因为那些有

2182
01:45:08,220 --> 01:45:12,240
他们的名字属性设置为什么
他们应该是。

2183
01:45:12,240 --> 01:45:12,575
问题？

2184
01:45:12,575 --> 01:45:17,030
>> 观众：在提交，请问该怎么做
底部化解顶部？

2185
01:45:17,030 --> 01:45:19,350
>> 王阳：所以，这是因为
事件处理程序。

2186
01:45:19,350 --> 01:45:23,000
所以，我们正在等待提交事件
任何从形式发射。

2187
01:45:23,000 --> 01:45:24,730
而这一切都是服从。

2188
01:45:24,730 --> 01:45:26,080
为什么我打电话提交了那里？

2189
01:45:26,080 --> 01:45:28,870
它说，当提交表单时，
我得到一个提交事件。

2190
01:45:28,870 --> 01:45:33,480
所以我只截取和
然后运行此代码来代替。

2191
01:45:33,480 --> 01:45:33,823
是吗？

2192
01:45:33,823 --> 01:45:35,866
>> 观众：你为什么有
有功能的事件？

2193
01:45:35,866 --> 01:45:38,580
为什么你就不能[听不清]？

2194
01:45:38,580 --> 01:45:41,140
>> 王阳：因为在JavaScript中，你
要声明的函数。

2195
01:45:41,140 --> 01:45:42,910
这就是它是如何工作的
在JavaScript中。

2196
01:45:42,910 --> 01:45:44,800
你不得不说这是怎么回事
运行一个函数。

2197
01:45:44,800 --> 01:45:47,290
所以，你告诉它你
期待一个函数在这里，而不是

2198
01:45:47,290 --> 01:45:48,260
只是大括号。

2199
01:45:48,260 --> 01:45:50,460
>> 观众：和函数
是什么如下？

2200
01:45:50,460 --> 01:45:50,650
>> 王阳：是啊。

2201
01:45:50,650 --> 01:45:52,790
该功能是什么在里面
后花括号

2202
01:45:52,790 --> 01:45:53,630
该函数的关键字。

2203
01:45:53,630 --> 01:45:54,045
是吗？

2204
01:45:54,045 --> 01:45:55,295
>> 观众：[听不清]。

2205
01:45:55,295 --> 01:46:00,180

2206
01:46:00,180 --> 01:46:00,660
>> 王阳：对于提交？

2207
01:46:00,660 --> 01:46:03,520
>> 观众：不，对于功能
没有事件。

2208
01:46:03,520 --> 01:46:03,770
>> 王阳：是啊。

2209
01:46:03,770 --> 01:46:05,610
因此，如果没有的情况下，
你可以有。

2210
01:46:05,610 --> 01:46:08,480
如果你并不需要的情况下，
那么你可以忽略它。

2211
01:46:08,480 --> 01:46:12,220
但如果这样做，那么你
只是把它放在那里。

2212
01:46:12,220 --> 01:46:12,520
是。

2213
01:46:12,520 --> 01:46:13,190
快速的问题？

2214
01:46:13,190 --> 01:46:14,440
>> 观众：[听不清]。

2215
01:46:14,440 --> 01:46:21,170

2216
01:46:21,170 --> 01:46:21,440
>> 王阳：是啊。

2217
01:46:21,440 --> 01:46:24,550
因为你需要做的
的document.ready只是说等待所有

2218
01:46:24,550 --> 01:46:26,540
在页面上的HTML来首先加载。

2219
01:46:26,540 --> 01:46:30,510
通常，你希望你的元素
在地方，你运行任何代码之前。

2220
01:46:30,510 --> 01:46:31,030
好的。

2221
01:46:31,030 --> 01:46:32,180
我们必须让阿贾克斯。

2222
01:46:32,180 --> 01:46:33,110
我们没有多少时间了。

2223
01:46:33,110 --> 01:46:35,170
所以利弊。

2224
01:46:35,170 --> 01:46:37,450
JavaScript是比较容易的尝试
写与jQuery。

2225
01:46:37,450 --> 01:46:38,930
但jQuery是一种缓慢。

2226
01:46:38,930 --> 01:46:42,290
>> 这就像PHP是比C慢，
因为它的解释。

2227
01:46:42,290 --> 01:46:45,690
和jQuery是不是有点慢
JavaScript的，因为它做了很多

2228
01:46:45,690 --> 01:46:46,630
引擎盖下的东西。

2229
01:46:46,630 --> 01:46:48,660
所以，如果你正在使用jQuery，它是
不只是一点点慢

2230
01:46:48,660 --> 01:46:51,630
JavaScript的，尽管它
为您提供了很好的优雅。

2231
01:46:51,630 --> 01:46:53,970
最后，阿贾克斯。

2232
01:46:53,970 --> 01:46:59,170
因此，与阿贾克斯远，你没见过的Ajax
在pset7的词条，因为

2233
01:46:59,170 --> 01:47:01,150
当你这样做，你提交
一种形式的报价。

2234
01:47:01,150 --> 01:47:02,350
它加载一个新的页面。

2235
01:47:02,350 --> 01:47:04,440
所以，你得到这个大的白色闪光
在页面上，而

2236
01:47:04,440 --> 01:47:06,820
第二个页面加载时，是否正确？

2237
01:47:06,820 --> 01:47:08,780
>> 这将是非常好的，如果你
没有这个闪光灯。

2238
01:47:08,780 --> 01:47:11,600
像Facebook，如果你只是滚动到
底部，它增加了新的内容

2239
01:47:11,600 --> 01:47:13,490
而无需刷新整个页面。

2240
01:47:13,490 --> 01:47:15,420
因此，像这样就好了。

2241
01:47:15,420 --> 01:47:17,370
这是JavaScript代码
在左侧。

2242
01:47:17,370 --> 01:47:19,390
你得到的是输入的内部。

2243
01:47:19,390 --> 01:47:21,340
你从雅虎股票信息

2244
01:47:21,340 --> 01:47:27,440
然后你犯了一个很大的字符串，
说，OK，这是我要留言

2245
01:47:27,440 --> 01:47:28,400
显示在屏幕上。

2246
01:47:28,400 --> 01:47:32,280
然后你把这个信息里面
这得到了一些HTML元素

2247
01:47:32,280 --> 01:47:33,970
显示在屏幕上。

2248
01:47:33,970 --> 01:47:35,540
>> 所以，这一切发生的事情在这里。

2249
01:47:35,540 --> 01:47:39,410
所以基本上，因为这是所有
JavaScript和你不需要运行

2250
01:47:39,410 --> 01:47:42,980
了PHP的，这将确保
该页面不刷新。

2251
01:47:42,980 --> 01:47:47,470
所以这只是一个抽象的概念
我是说这里现在。

2252
01:47:47,470 --> 01:47:50,630
抽象的想法是，如果你这样做
所有在JavaScript中，你没有一个

2253
01:47:50,630 --> 01:47:52,330
页面刷新。

2254
01:47:52,330 --> 01:47:53,800
但你如何真正做到这一点？

2255
01:47:53,800 --> 01:47:56,230
>> 嗯，事实上，让我们来谈谈
一个问题，这第一。

2256
01:47:56,230 --> 01:47:59,340
一个问题是在JavaScript中，
执行是同步的。

2257
01:47:59,340 --> 01:48:02,000
所以，你必须等待一个
行前，你完成

2258
01:48:02,000 --> 01:48:03,370
执行下一行。

2259
01:48:03,370 --> 01:48:06,130
而如果我要去了雅虎，
和他们的服务器是很慢，和

2260
01:48:06,130 --> 01:48:08,790
他们花三秒钟
给我回该股票的信息？

2261
01:48:08,790 --> 01:48:12,620
当我打的价格线，如果
执行是同步的，因为它是由

2262
01:48:12,620 --> 01:48:15,390
默认情况下，它只是要做的是
您的浏览器会拖延

2263
01:48:15,390 --> 01:48:15,930
三秒钟。

2264
01:48:15,930 --> 01:48:18,900
而且你不会是能够做到
任何事情，而它得到的数据。

2265
01:48:18,900 --> 01:48:20,010
这将被冻结。

2266
01:48:20,010 --> 01:48:20,800
>> 这就是坏的。

2267
01:48:20,800 --> 01:48:23,390
你不希望用户
具有冷冻网页。

2268
01:48:23,390 --> 01:48:24,170
正确吗？

2269
01:48:24,170 --> 01:48:25,480
这只是坏。

2270
01:48:25,480 --> 01:48:26,770
每个人都同意？

2271
01:48:26,770 --> 01:48:29,270
如果你在浏览Facebook和它
冻结，你不能做任何事情，你

2272
01:48:29,270 --> 01:48:31,920
得到真正沮丧。

2273
01:48:31,920 --> 01:48:34,960
所以，解决的办法是我们做什么
异步代替。

2274
01:48:34,960 --> 01:48:38,910
因此，所有这种异步的事情说
是，我要问这个

2275
01:48:38,910 --> 01:48:40,280
的URL的一些数据。

2276
01:48:40,280 --> 01:48:41,610
然后我会坚持下去。

2277
01:48:41,610 --> 01:48:45,330
我只是要保持执行
不管那是以后的代码。

2278
01:48:45,330 --> 01:48:49,290
>> 然后每当该数据已准备就绪，
然后，我会处理它。

2279
01:48:49,290 --> 01:48:50,540
这就是它在说什么。

2280
01:48:50,540 --> 01:48:52,795

2281
01:48:52,795 --> 01:48:56,710
>> 观众：阿贾克斯只是使
代码异步？

2282
01:48:56,710 --> 01:48:58,560
>> 王阳：这是一个异步
取数据的方法。

2283
01:48:58,560 --> 01:49:01,230
所以，关于Ajax的第一件事
是它让我得到的数据

2284
01:49:01,230 --> 01:49:03,170
从外部网站。

2285
01:49:03,170 --> 01:49:07,045
第二件事是它可以确保
我的页面不熄火，而我

2286
01:49:07,045 --> 01:49:07,970
取该数据。

2287
01:49:07,970 --> 01:49:09,600
这就是它的异步的一部分。

2288
01:49:09,600 --> 01:49:13,040
因为它熄灭别的地方，
因为我说我坚持去做，而

2289
01:49:13,040 --> 01:49:14,900
它读取该数据，即
使得异步的。

2290
01:49:14,900 --> 01:49:17,170
我一直在执行。

2291
01:49:17,170 --> 01:49:18,960
>> 因此，保持异步
心里有数。

2292
01:49:18,960 --> 01:49:22,010
我会告诉你什么是
所不同的是。

2293
01:49:22,010 --> 01:49:23,920
同步版本
是在左边。

2294
01:49:23,920 --> 01:49:26,240
异步版本
是在右侧。

2295
01:49:26,240 --> 01:49:29,170
看数字，看哪个
步骤对应于哪

2296
01:49:29,170 --> 01:49:30,610
执行在每一行。

2297
01:49:30,610 --> 01:49:32,730
那边，警报显示第一。

2298
01:49:32,730 --> 01:49:34,590
因为得到股票信息从雅虎

2299
01:49:34,590 --> 01:49:37,250
需要三秒钟，停转
三秒钟。

2300
01:49:37,250 --> 01:49:39,880
然后它会提醒价格
那些在三秒钟后。

2301
01:49:39,880 --> 01:49:43,690
>> 所以，现在，该警报显示
向上当时 - 

2302
01:49:43,690 --> 01:49:44,610
3秒英寸

2303
01:49:44,610 --> 01:49:47,670
再后，提醒了。

2304
01:49:47,670 --> 01:49:48,930
所以它只是一步一步来。

2305
01:49:48,930 --> 01:49:51,200
这就像你们什么
会接受，是否正确？

2306
01:49:51,200 --> 01:49:54,170
与异步执行，
你第一次提醒。

2307
01:49:54,170 --> 01:49:57,410
然后你去上这个网址。

2308
01:49:57,410 --> 01:49:59,530
和你说，我要去
只要求该数据。

2309
01:49:59,530 --> 01:50:01,170
然后我要去
以后再处理它。

2310
01:50:01,170 --> 01:50:04,230
所以它会立即执行
接下来之后，我做这行

2311
01:50:04,230 --> 01:50:05,710
异步请求。

2312
01:50:05,710 --> 01:50:08,920
>> 所以0.001秒，你看到警报喜。

2313
01:50:08,920 --> 01:50:10,960
执行该功能，警报再见。

2314
01:50:10,960 --> 01:50:14,240
因为我做了一个承诺，我
以后会处理数据，有什么

2315
01:50:14,240 --> 01:50:17,920
发生时的数据回来
三秒钟后，然后我运行

2316
01:50:17,920 --> 01:50:21,380
功能，我有在那里。

2317
01:50:21,380 --> 01:50:21,870
是吗？

2318
01:50:21,870 --> 01:50:25,750
>> 观众：你可以指定或
澄清一下Ajax的意思吗？

2319
01:50:25,750 --> 01:50:30,460
>> 王阳：那么Ajax是一种方式，如果我
需要数据时，我在一个网站，我

2320
01:50:30,460 --> 01:50:34,690
不想刷新页面，则
我使用名为Ajax的这种技术。

2321
01:50:34,690 --> 01:50:40,630
这本质上只是手段，去获取
从其他网站的数据。

2322
01:50:40,630 --> 01:50:43,724
而做到这一点的方式，只是
不熄火我的网页。

2323
01:50:43,724 --> 01:50:46,650
>> 观众：所以是一种内在的
JavaScript或jQuery的一部分吗？

2324
01:50:46,650 --> 01:50:50,590
>> 王阳：所以有人写了一个方法来做到
这在JavaScript中很长一段时间以前。

2325
01:50:50,590 --> 01:50:52,050
在一个点上，它是不存在的。

2326
01:50:52,050 --> 01:50:56,630
于是有人发明了这种技术
让人们请求此数据

2327
01:50:56,630 --> 01:50:57,680
以这种方式。

2328
01:50:57,680 --> 01:50:59,550
他们写了一些东西
要为你做它。

2329
01:50:59,550 --> 01:51:01,605
和jQuery只是给你这个
很不错的办法做到这一点

2330
01:51:01,605 --> 01:51:03,112
与此$。get函数。

2331
01:51:03,112 --> 01:51:07,200

2332
01:51:07,200 --> 01:51:09,480
问题？

2333
01:51:09,480 --> 01:51:11,560
我可以回答有关问题
阿贾克斯之后了。

2334
01:51:11,560 --> 01:51:13,870
我会在这里。

2335
01:51:13,870 --> 01:51:16,390
>> 所以，让我们我们获取数据而不
刷新页面。

2336
01:51:16,390 --> 01:51:18,200
它让我们在这样做
异步方式

2337
01:51:18,200 --> 01:51:19,450
不冻结的页面。

2338
01:51:19,450 --> 01:51:22,680

2339
01:51:22,680 --> 01:51:27,310
太长了，没看过，如果是
解释是太长了你。

2340
01:51:27,310 --> 01:51:29,430
所以最后，跨站点
脚本攻击。

2341
01:51:29,430 --> 01:51:30,910
我们认为这与Zamyla。

2342
01:51:30,910 --> 01:51:34,285
如果我的数据库有人有这个名字，
这是这个脚本标记，而我

2343
01:51:34,285 --> 01:51:38,280
有我的网页上一些代码，打印
出人的一排名字，或者我有

2344
01:51:38,280 --> 01:51:43,310
中插入JavaScript代码
这个名字到页面中，

2345
01:51:43,310 --> 01:51:45,680
什么Html获取产生的？

2346
01:51:45,680 --> 01:51:47,290
好吧，我打印出来的HTML标记。

2347
01:51:47,290 --> 01:51:48,390
我打印出所有这些标签。

2348
01:51:48,390 --> 01:51:50,740
>> 我去哪里，我打印的部分
和朋友们聚会。

2349
01:51:50,740 --> 01:51:52,980
我打印出来劳伦。

2350
01:51:52,980 --> 01:51:54,200
它打印出来米洛。

2351
01:51:54,200 --> 01:51:56,810
然后我在数据库名称
是剧本后

2352
01:51:56,810 --> 01:51:58,060
直言不讳的Facebook状态。

2353
01:51:58,060 --> 01:52:00,740

2354
01:52:00,740 --> 01:52:04,330
因为我这个插入到页面
因为它看起来像JavaScript中，当

2355
01:52:04,330 --> 01:52:07,930
当前页被发送给用户，
它被执行为JavaScript。

2356
01:52:07,930 --> 01:52:10,800
所以这就是我们所说的
跨站点脚本攻击。

2357
01:52:10,800 --> 01:52:14,570
有人把恶意信息
您可能对应于数据库

2358
01:52:14,570 --> 01:52:17,080
一些额外的字符串或
一些JavaScript字符串。

2359
01:52:17,080 --> 01:52:20,130
>> 而当它被打印出来的
以这种方式页面，那么什么

2360
01:52:20,130 --> 01:52:22,580
发生的情况是不好的代码被执行
我没打算

2361
01:52:22,580 --> 01:52:25,110
它得到执行。

2362
01:52:25,110 --> 01:52:28,230
而这一切，一个跨站点
脚本攻击。

2363
01:52:28,230 --> 01:52:31,790
和你周围的路
这就像Zamyla说。

2364
01:52:31,790 --> 01:52:34,340
你只是包装的东西
HTML特殊字符。

2365
01:52:34,340 --> 01:52:39,460
与此HTML特殊字符是一个PHP
功能，以防止这种

2366
01:52:39,460 --> 01:52:42,000
从发生在你身上的事情
如果你有一个恶意的

2367
01:52:42,000 --> 01:52:43,830
字符串在数据库中。

2368
01:52:43,830 --> 01:52:47,650
它只是逃脱它，所以它不
得到解释为HTML。

2369
01:52:47,650 --> 01:52:50,960
它取代了小括号
我们所说的实体。

2370
01:52:50,960 --> 01:52:52,250
于是我们过了这个讲座中也。

2371
01:52:52,250 --> 01:52:55,800
所以，我想你们应该有
把握好这一点。

2372
01:52:55,800 --> 01:52:57,420
有问题吗？

2373
01:52:57,420 --> 01:52:57,820
是。

2374
01:52:57,820 --> 01:53:00,860
>> 观众：那么，如何将
在[听不清]？

2375
01:53:00,860 --> 01:53:01,555
>> 王阳：再说了。

2376
01:53:01,555 --> 01:53:02,500
>> 观众：如何将显示器 - 

2377
01:53:02,500 --> 01:53:02,860
>> 王阳：对。

2378
01:53:02,860 --> 01:53:06,080
所以，你有什么事情，说，当
我注册，输入我的名字。

2379
01:53:06,080 --> 01:53:09,390
我只需键入在这一领域，我的名字是
剥后直言不讳的Facebook

2380
01:53:09,390 --> 01:53:11,570
状态密切的脚本标记。

2381
01:53:11,570 --> 01:53:15,690
而这只是被放入
数据库，因为我不能说别人

2382
01:53:15,690 --> 01:53:18,260
在世界上没有一个名字
用左箭头，或在

2383
01:53:18,260 --> 01:53:19,036
在它的字的脚本。

2384
01:53:19,036 --> 01:53:21,330
这并没有真正意义。

2385
01:53:21,330 --> 01:53:24,560
所以，我只是要确保我
消毒的东西之前，我打印出来

2386
01:53:24,560 --> 01:53:25,420
出到页面中。

2387
01:53:25,420 --> 01:53:27,140
>> 观众：所以HTML特殊卡
防止脚本标签？

2388
01:53:27,140 --> 01:53:28,710
>> 王阳：是啊。

2389
01:53:28,710 --> 01:53:29,960
所以它不会阻止脚本标记。

2390
01:53:29,960 --> 01:53:32,320
它只是可以确保
script标签没有得到

2391
01:53:32,320 --> 01:53:35,120
解释为HTML或 - 

2392
01:53:35,120 --> 01:53:35,400
是的。

2393
01:53:35,400 --> 01:53:38,470
它只是出来作为什么
它实际上是。

2394
01:53:38,470 --> 01:53:39,220
好的。

2395
01:53:39,220 --> 01:53:40,930
所以这是测验检讨。

2396
01:53:40,930 --> 01:53:41,830
凉爽。

2397
01:53:41,830 --> 01:53:45,088
>> [掌声]