1
00:00:00,000 --> 00:00:02,270
>> [评论：测验1]

2
00:00:02,270 --> 00:00:04,620
[阿里的Nahm，Oreoluwa Barbarinsa，卢卡斯塔斯，罗布鲍登] [哈佛大学]

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

4
00:00:07,660 --> 00:00:11,610
[卢卡斯塔斯]欢迎大家。这是审查测验1。

5
00:00:11,610 --> 00:00:15,040
正如一个声明，这是 - 我的意思是，我们要尽量覆盖

6
00:00:15,040 --> 00:00:17,770
尽可能多的材料成为可能，但是，这并不意味着

7
00:00:17,770 --> 00:00:20,780
我们将覆盖所有的东西，可以在测验1。

8
00:00:20,780 --> 00:00:25,270
所以，要确保你也来看看演讲，路段，一切，你可以。

9
00:00:25,270 --> 00:00:28,240
测验1将是周三，下周三。

10
00:00:28,240 --> 00:00:33,800
所以一定要学习。这将是，相当多，像第一次测验

11
00:00:33,800 --> 00:00:36,390
关于它的格式，但它可能将是更难。

12
00:00:36,390 --> 00:00:39,600
至少，在去年的时候我花了50，我还以为是更难。

13
00:00:39,600 --> 00:00:42,410
所以，学习了很多。

14
00:00:42,410 --> 00:00:45,190
>>我要说的是，数据结构和哈夫曼编码。

15
00:00:45,190 --> 00:00:47,910
这一点是很多人都认为是复杂的，

16
00:00:47,910 --> 00:00:51,930
但我要去尝试，使之尽可能简单。

17
00:00:51,930 --> 00:00:56,330
首先，我们要你们知道问答1什么是

18
00:00:56,330 --> 00:01:00,970
了解每个数据结构，我要呈现的概念性描述。

19
00:01:00,970 --> 00:01:03,960
这意味着，你不必实际

20
00:01:03,960 --> 00:01:07,020
在你的测验1实现一个哈希表。

21
00:01:07,020 --> 00:01:10,250
我们不想让你实现一个整体的哈希表，也许我们会尽力

22
00:01:10,250 --> 00:01:13,090
让你实现一些功能，

23
00:01:13,090 --> 00:01:16,940
最常见的操作，但我们不会让你实现一切。

24
00:01:16,940 --> 00:01:21,010
所以，你了解每个数据结构背后的概念很重要

25
00:01:21,010 --> 00:01:23,510
并且还可以为您能够在C代码，

26
00:01:23,510 --> 00:01:27,880
只是他们对每一个数据结构中最常见的操作。

27
00:01:27,880 --> 00:01:30,090
并且还能够审查指针和结构，

28
00:01:30,090 --> 00:01:33,470
因为他们出现了很多在这些数据结构。

29
00:01:33,470 --> 00:01:37,380
>>首先，链表。链表实际上是非常相似的阵列，

30
00:01:37,380 --> 00:01:39,930
但是链表和数组之间的差别，

31
00:01:39,930 --> 00:01:45,160
首先，这是一个链表有一个非常灵活的尺寸，

32
00:01:45,160 --> 00:01:50,060
而在数组，你必须要么选择一个非常大的规模为阵，

33
00:01:50,060 --> 00:01:53,710
所以你知道你要能够存储所有的数据在阵列中，

34
00:01:53,710 --> 00:01:59,370
或者你必须使用malloc有数组的长度灵活。

35
00:01:59,370 --> 00:02:03,680
在链表它很容易就得到更多的元素，

36
00:02:03,680 --> 00:02:07,210
把更多的元素在链表或删除元素。

37
00:02:07,210 --> 00:02:09,370
而实际上，如果你不想链表进行排序，

38
00:02:09,370 --> 00:02:13,950
您可以搜索并删除在常数时间的元素，

39
00:02:13,950 --> 00:02:16,800
所以为O（1）的时间，所以这是非常方便的。

40
00:02:16,800 --> 00:02:20,660
你一定要小心，要永远记住malloc和free的节点，

41
00:02:20,660 --> 00:02:25,510
只是因为如果你不这样做，你就会有内存泄漏。

42
00:02:25,510 --> 00:02:31,480
所以链表 - 一个节点的定义就像我们所拥有的权利在那里。

43
00:02:31,480 --> 00:02:35,110
我把整数n，但是你可以存储你想要的任何数据。

44
00:02:35,110 --> 00:02:37,280
所以，如果你想存储一个字符串，它的罚款。

45
00:02:37,280 --> 00:02:41,690
如果你想存储一个结构，它的罚款，双，任何你想要的。

46
00:02:41,690 --> 00:02:44,630
我只是把INT N为这里的例子。

47
00:02:44,630 --> 00:02:46,800
和你有一个指向下一个节点。

48
00:02:46,800 --> 00:02:51,940
因此，基本上是一个链表有一些数据，然后将它指向下一个节点。

49
00:02:51,940 --> 00:02:56,710
如果它在链表中的最后一个元素，它会指向NULL。

50
00:02:56,710 --> 00:02:59,060
所以这是一个链表的示例。

51
00:02:59,250 --> 00:03:05,960
>>好了，现在让我们来看看我们应该做的，如果我要插入一个链表的元素。

52
00:03:05,960 --> 00:03:08,810
首先，一个函数插入将是void类型

53
00:03:08,810 --> 00:03:11,350
因为我不想返回任何东西。

54
00:03:11,350 --> 00:03:14,200
我要去参加一个int作为参数，

55
00:03:14,200 --> 00:03:17,090
因为我想知道我要插入。

56
00:03:17,090 --> 00:03:21,840
那么什么是我应该做的第一件事？嗯，我应该用malloc上newnode，

57
00:03:21,840 --> 00:03:24,240
所以这是第一行。

58
00:03:24,240 --> 00:03:27,580
我只是创建一个新的节点放在一个链表。

59
00:03:27,580 --> 00:03:32,360
所以，我能做些什么？好吧，我们知道，在我们的链表的实现

60
00:03:32,360 --> 00:03:38,180
在课堂上，我们总是把头部作为一个全局变量。

61
00:03:38,180 --> 00:03:41,800
所以，我们能做的就是改变头。

62
00:03:41,800 --> 00:03:44,300
我可以使这个新的节点是新的头，

63
00:03:44,300 --> 00:03:46,670
并且它要指向以前头。

64
00:03:46,670 --> 00:03:50,390
我们怎样才能做到这一点？首先我必须做的

65
00:03:50,390 --> 00:03:54,770
改变是在新的节点值'N'，

66
00:03:54,770 --> 00:03:57,530
这是传递给函数。

67
00:03:57,530 --> 00:04:01,050
然后newnode下一步将是头部。

68
00:04:01,050 --> 00:04:05,800
头将被newnode。所以这是非常简单的。

69
00:04:05,800 --> 00:04:10,090
若要删除一个节点，我们可以像 - 

70
00:04:10,090 --> 00:04:14,790
我们能做到这一点的方法之一是说，

71
00:04:14,790 --> 00:04:18,160
好吧，如果我想删除，例如，3，

72
00:04:18,160 --> 00:04:24,850
有什么我可以做的就是指向前一个节点

73
00:04:24,850 --> 00:04:27,580
到3的下一个节点。

74
00:04:27,580 --> 00:04:29,400
所以，我只想做这样的事情。

75
00:04:29,400 --> 00:04:33,400
但是，什么是这样做的问题？

76
00:04:33,400 --> 00:04:37,400
我有内存泄漏，所以我不能够访问数字3了。

77
00:04:37,400 --> 00:04:42,480
与该问题是，我不打算要能够释放该节点。

78
00:04:42,480 --> 00:04:45,360
我要去有内存泄漏和（不知所云）是要恨我。

79
00:04:45,360 --> 00:04:49,370
而不是这样做的话，我也许应该有一个临时指针。

80
00:04:49,370 --> 00:04:53,210
所以我把温度。它要指向我要删除的节点。

81
00:04:53,210 --> 00:04:58,170
然后我就可以将以前的节点指向下一个节点

82
00:04:58,170 --> 00:05:00,390
我要删除的节点。

83
00:05:00,390 --> 00:05:02,730
终于，我可以自由的指针。

84
00:05:02,730 --> 00:05:07,480
我一定要自由，我创建了在那里的指针？

85
00:05:07,480 --> 00:05:09,560
我没有要，只因为 - 

86
00:05:09,560 --> 00:05:13,430
不同的是，该节点被用malloc创建

87
00:05:13,430 --> 00:05:17,280
所以它是在堆中，而这本是刚刚宣布为在堆栈中一个NULL开关。

88
00:05:17,280 --> 00:05:20,000
所以，我没有释放它。

89
00:05:20,000 --> 00:05:22,030
>>好吧。所以，现在让我们来谈谈栈。

90
00:05:22,030 --> 00:05:24,680
栈是相当简单的。

91
00:05:24,680 --> 00:05:29,540
我们只是使用数组一样栈和队列的类，

92
00:05:29,540 --> 00:05:32,820
但你应该很熟悉 - 只是知道

93
00:05:32,820 --> 00:05:40,740
您还可以使用链表以及队列做堆栈。

94
00:05:40,740 --> 00:05:44,460
所以，如果你有一个数组，这将是一个栈？

95
00:05:44,460 --> 00:05:46,810
堆栈，首先，必须有一个尺寸。

96
00:05:46,810 --> 00:05:49,950
你要存储什么是你现在所拥有的栈的大小。

97
00:05:49,950 --> 00:05:52,980
而你也将有一个数组，在数量上的这种情况下，

98
00:05:52,980 --> 00:05:55,120
但如果你愿意，也可以是一个数组

99
00:05:55,120 --> 00:06:00,380
字符串，结构的数组，要存储任何东西。

100
00:06:00,380 --> 00:06:03,240
有关堆栈：堆栈和一个链表的区别

101
00:06:03,240 --> 00:06:08,590
是在栈中，只能访问到被放置在堆栈中的最后一个元素。

102
00:06:08,590 --> 00:06:11,770
这就是所谓的后进先出。

103
00:06:11,770 --> 00:06:15,090
就像你有一摞托盘，

104
00:06:15,090 --> 00:06:17,670
如果你把一个托盘上的堆栈的顶部，

105
00:06:17,670 --> 00:06:22,670
你必须先删除该盘有机会到其它纸盘。

106
00:06:22,670 --> 00:06:26,310
这是同样的事情栈。

107
00:06:26,310 --> 00:06:31,220
所以，如果我想，例如，一个元素添加到堆栈中，我该怎么办？

108
00:06:31,220 --> 00:06:34,070
这就是所谓的推，它是非常简单的。

109
00:06:34,070 --> 00:06:37,130
你所要做的第一件事是检查是否堆栈的大小

110
00:06:37,130 --> 00:06:40,150
不是大于或等于所述堆栈的容量。

111
00:06:40,150 --> 00:06:45,810
因为如果你已经是在满负荷生产，可以不加任何东西。

112
00:06:45,810 --> 00:06:51,140
然后如果没有，你只需要在元素添加到堆栈中。

113
00:06:51,140 --> 00:06:54,530
最后，增加的大小。所以这是非常简单的。

114
00:06:54,530 --> 00:06:57,140
所以，我想补充的数量2。

115
00:06:57,140 --> 00:07:00,350
如果我想弹出，这意味着我想删除

116
00:07:00,350 --> 00:07:03,870
已添加，并返回该元素的值的最后一个元素，

117
00:07:03,870 --> 00:07:09,180
的第一件事，我要检查的是，堆栈不为空。

118
00:07:09,180 --> 00:07:11,510
因为如果它是空的，我不能返回任何东西。

119
00:07:11,510 --> 00:07:14,820
在这种情况下，我返回-1。

120
00:07:14,820 --> 00:07:18,960
否则，我将减小规格的大小，

121
00:07:18,960 --> 00:07:22,510
并返回数字（s.size）。

122
00:07:22,510 --> 00:07:27,230
为何我递减的大小，然后返回s.size？

123
00:07:27,230 --> 00:07:30,930
这是因为，在这种情况下，该规范具有大小为4，

124
00:07:30,930 --> 00:07:33,810
我想返回的第四个元素，对不对？

125
00:07:33,810 --> 00:07:36,030
但是，什么是第四个元素的索引？三。

126
00:07:36,030 --> 00:07:44,510
由于我的大小 - 将是3，我可以只返回s.numbers（s.size）

127
00:07:44,510 --> 00:07:48,410
因为它是3。所以它只是索引。

128
00:07:48,410 --> 00:07:50,380
>>现在排队。队列是几乎同样的事情。

129
00:07:50,380 --> 00:07:54,950
唯一的区别是，而不是具有最后在于，第一列，

130
00:07:54,950 --> 00:07:57,480
你必须先入先出。

131
00:07:57,480 --> 00:07:59,460
或许，如果你等着去看演唱会，

132
00:07:59,460 --> 00:08:04,260
你会不会很高兴，如果你有一个堆栈，而不是一个队列。

133
00:08:04,260 --> 00:08:07,730
作为最后一个人来将进入演唱会的第一人。

134
00:08:07,730 --> 00:08:09,760
你可能不会得到幸福。

135
00:08:09,760 --> 00:08:15,020
在队列中的第一人获得在也是第一人出去。

136
00:08:15,020 --> 00:08:18,720
因此，在一个队列的定义中，除了在阵列中具有的大小，

137
00:08:18,720 --> 00:08:23,360
你也得有头，这是该指数到堆栈的头。

138
00:08:23,360 --> 00:08:29,000
因此，第一个元素现在。

139
00:08:29,000 --> 00:08:32,710
排队是一回事推栈。

140
00:08:32,710 --> 00:08:34,980
如果你是非常幼稚的，你只说，

141
00:08:34,980 --> 00:08:39,289
好了，我可以做同样的事情，因为我做了推送。

142
00:08:39,289 --> 00:08:44,030
我可以检查它是否不超出能力。

143
00:08:44,030 --> 00:08:48,760
如果是，我返回false，否则我可以导出新的价值

144
00:08:48,760 --> 00:08:50,630
然后递增的大小。

145
00:08:50,630 --> 00:08:52,750
但为什么这是错的？

146
00:08:52,750 --> 00:08:55,010
让我们来看看这个例子。

147
00:08:55,010 --> 00:08:57,020
我试图排队了一堆东西，

148
00:08:57,020 --> 00:08:58,390
然后我会和出队入队。

149
00:08:58,390 --> 00:09:00,550
有很多的命令，但它是非常简单的。

150
00:09:00,550 --> 00:09:04,790
我要去排队5，所以加5，然后7，

151
00:09:04,790 --> 00:09:09,310
1，4，6，然后我想离队的东西，

152
00:09:09,310 --> 00:09:12,000
这意味着我将要删除第一个元素。

153
00:09:12,000 --> 00:09:14,640
所以我要删除的号码3，对不对？

154
00:09:14,640 --> 00:09:17,320
第一个元素。好吧。

155
00:09:17,320 --> 00:09:21,450
现在，如果我尝试排队别的东西，有什么事情发生？

156
00:09:21,450 --> 00:09:24,290
据我的实现，

157
00:09:24,290 --> 00:09:31,040
我打算把下一个数字索引q.size。

158
00:09:31,040 --> 00:09:35,140
在这种情况下，大小为8，

159
00:09:35,140 --> 00:09:38,640
所以该指数8将在这里的最后一个位置。

160
00:09:38,640 --> 00:09:43,900
如果我尝试入队1在这里，我将覆盖的最后一个位置

161
00:09:43,900 --> 00:09:45,870
为数字1，这是完全错误的。

162
00:09:45,870 --> 00:09:49,870
我想要做的就是环绕并进入到第一个位置。

163
00:09:49,870 --> 00:09:52,870
也许你只是说，好吧，我只需要检查

164
00:09:52,870 --> 00:09:55,600
如果我能真正把东西存在。

165
00:09:55,600 --> 00:09:58,560
如果没有，我只是说，哦，新的满负荷生产

166
00:09:58,560 --> 00:10:02,010
其实容量 -  1，你不能把一个元素存在。

167
00:10:02,010 --> 00:10:06,150
但是，是什么问题？问题是，如果我只是出列的一切就在这里

168
00:10:06,150 --> 00:10:08,240
然后我尝试添加别的东西，它只是说，

169
00:10:08,240 --> 00:10:11,210
好了，你是在满负荷，这是0。

170
00:10:11,210 --> 00:10:13,620
所以，你的队列消失了。

171
00:10:13,620 --> 00:10:16,990
你有环绕和环绕着的一种方式

172
00:10:16,990 --> 00:10:22,040
那你们的远见卓识和其他pset中了解到，使用MOD。

173
00:10:22,040 --> 00:10:29,090
你可以在家里尝试理解为什么你会做q.size + q.head

174
00:10:29,090 --> 00:10:31,080
MOD能力，但如果你在这里检查，

175
00:10:31,080 --> 00:10:34,760
我们可以看到，它的工作原理。

176
00:10:34,760 --> 00:10:37,760
因此，在最后一个例子，q.size为8

177
00:10:37,760 --> 00:10:47,590
和头部为1，因为它是这个位置在这里的数组。

178
00:10:47,590 --> 00:10:51,970
所以这将是8 + 1，9。国防部容量9将是0。

179
00:10:51,970 --> 00:10:56,640
它会去到索引0。我们会在合适的位置。

180
00:10:56,640 --> 00:10:59,750
然后尝试队列在家里。

181
00:10:59,750 --> 00:11:04,950
一些重要的事情：试着去了解栈和队列之间的差异。

182
00:11:04,950 --> 00:11:11,620
在家里，试图让很熟悉执行入队，出队，push和pop。

183
00:11:11,620 --> 00:11:16,560
同时也明白什么时候你会使用它们。

184
00:11:16,560 --> 00:11:22,830
>>因此，让我们放松10秒，一帮小宠物。

185
00:11:22,830 --> 00:11:26,080
现在让我们再回到数据结构。

186
00:11:26,080 --> 00:11:29,770
哈希表。许多人被吓坏了哈希表。

187
00:11:29,770 --> 00:11:33,650
在问题设置6，拼写检查器。

188
00:11:33,650 --> 00:11:35,980
哈希表和尝试，很多人会害怕他们。

189
00:11:35,980 --> 00:11:38,540
他们认为，他们很难理解。是吗？

190
00:11:38,540 --> 00:11:41,490
[罗布鲍登]习题集5。 >>习题集5，是的。感谢罗布。

191
00:11:41,490 --> 00:11:43,370
是啊。六是哈夫N'噗，是啊。

192
00:11:43,370 --> 00:11:49,340
习题集5被拼写检查，而你不得不使用一个哈希表或一试。

193
00:11:49,340 --> 00:11:55,360
很多人以为自己是超级很难理解，但他们其实很简单。

194
00:11:55,360 --> 00:12:01,290
什么是哈希表，基本上？哈希表是链表的数组。

195
00:12:01,290 --> 00:12:06,730
数组和哈希表的唯一区别

196
00:12:06,730 --> 00:12:09,730
是，在哈希表中你有一些所谓的哈希函数。

197
00:12:09,730 --> 00:12:12,080
散列函数是什么？

198
00:12:12,080 --> 00:12:13,970
我不知道，如果你们可以在这里阅读。

199
00:12:13,970 --> 00:12:16,090
这是一个哈希表的一个例子。

200
00:12:16,090 --> 00:12:19,220
所以，你可以看到，你有31个元素的数组。

201
00:12:19,220 --> 00:12:22,440
而我们在做一个哈希表是什么有一个散列函数

202
00:12:22,440 --> 00:12:26,660
这是要翻译的关键，每个INT到一个索引。

203
00:12:26,660 --> 00:12:31,740
如果，例如，如果我要选择适合B.哈里森，

204
00:12:31,740 --> 00:12:34,190
我会把B.哈里森在我的哈希函数，

205
00:12:34,190 --> 00:12:36,960
和散列函数将返回24。

206
00:12:36,960 --> 00:12:40,930
所以我知道我想要存储B.哈里森在24。

207
00:12:40,930 --> 00:12:46,580
所以，这只是有一个数组，并有一个哈希表之间的差异。

208
00:12:46,580 --> 00:12:48,740
在哈希表你就会有一个是要告诉你一个函数

209
00:12:48,740 --> 00:12:54,740
在哪里存储您要存储的数据。

210
00:12:54,740 --> 00:12:57,040
对于散列函数，你要寻找一个哈希函数

211
00:12:57,040 --> 00:13:00,600
这是确定的，均匀分布。

212
00:13:00,600 --> 00:13:07,810
正如你可以在这里看到，你看到了很多，我想存储数据的竟是19

213
00:13:07,810 --> 00:13:12,470
而不是使用31和30和29，这都是免费的。

214
00:13:12,470 --> 00:13:16,920
所以我使用了哈希函数不是很均匀分布。

215
00:13:16,920 --> 00:13:20,710
当我们说分布均匀，这意味着我们想拥有，

216
00:13:20,710 --> 00:13:26,520
粗略地说，至少有1或2个为每个 - 

217
00:13:26,520 --> 00:13:32,190
像，1或2中的每个阵列的指数的差异。

218
00:13:32,190 --> 00:13:43,950
你想有，大致在每个链表元件的阵列中的相同的编号。

219
00:13:43,950 --> 00:13:48,600
并可以很容易地检查它是否有效的哈希表中，查看哈希表。

220
00:13:48,600 --> 00:13:51,770
>>然后树。这是一棵树。

221
00:13:51,770 --> 00:13:56,400
在计算机科学中的树木是倒挂的一些原因。

222
00:13:56,400 --> 00:14:00,150
所以，在这里你有树的叶子的根部，然后。

223
00:14:00,150 --> 00:14:05,630
你应该知道的术语为家长和孩子。

224
00:14:05,630 --> 00:14:12,880
每个节点都有它的孩子，这是属于母公司下面的节点。

225
00:14:12,880 --> 00:14:19,660
因此，举例来说，2将是父为3和另一子在那里，

226
00:14:19,660 --> 00:14:25,290
而3将是父为1，其余的孩子，都在那里。

227
00:14:25,290 --> 00:14:29,990
和1将是3的孩子，等等。

228
00:14:29,990 --> 00:14:34,610
我们有一些更有趣，叫做二叉搜索树，

229
00:14:34,610 --> 00:14:39,040
其中一个节点的右侧所有的值

230
00:14:39,040 --> 00:14:41,660
将要在右边，就在这里 - 在右边，

231
00:14:41,660 --> 00:14:46,780
要大于在根元素。

232
00:14:46,780 --> 00:14:49,780
所以，如果我有5号在这里，所有的右边元素

233
00:14:49,780 --> 00:14:51,940
将要大于5，并且在左侧

234
00:14:51,940 --> 00:14:56,770
所有的元素都将是小于5。

235
00:14:56,770 --> 00:14:58,780
为什么这是有用的？

236
00:14:58,780 --> 00:15:01,660
好吧，如果我要检查，如果数字7是在这里，例如，

237
00:15:01,660 --> 00:15:05,960
我只是去5第一，我要去看看，是不是5 7或大或小？

238
00:15:05,960 --> 00:15:09,540
这是更大的，所以我知道这将必须在树的右侧。

239
00:15:09,540 --> 00:15:13,980
所以，我有少得多的东西来看待。

240
00:15:13,980 --> 00:15:19,520
在实现二叉搜索树，节点，我只是要必须有数据，

241
00:15:19,520 --> 00:15:21,750
所以诠释n;你也可以有一个字符串

242
00:15:21,750 --> 00:15:23,630
或者你想要的任何东西。

243
00:15:23,630 --> 00:15:28,100
你一定要小心，在界定什么是更大的，什么是少。

244
00:15:28,100 --> 00:15:30,390
所以，如果你有字符串，例如，你可以定义

245
00:15:30,390 --> 00:15:34,690
所有这些东西放在右边将会有更大的长度，

246
00:15:34,690 --> 00:15:40,940
左边将会有更低的长度，所以它真的取决于你。

247
00:15:40,940 --> 00:15:44,930
>>我如何能实现找到BST？

248
00:15:44,930 --> 00:15:47,840
我们必须做的第一件事就是检查根是空的。

249
00:15:47,840 --> 00:15:50,920
如果是NULL，则这意味着该事情是不存在的

250
00:15:50,920 --> 00:15:53,330
因为你甚至没有一棵树，对不对？

251
00:15:53,330 --> 00:15:55,790
于是我返回false。

252
00:15:55,790 --> 00:15:58,740
否则，我要检查，如果数量大

253
00:15:58,740 --> 00:16:01,720
比在根目录中的值。

254
00:16:01,720 --> 00:16:04,250
我要去尝试找到正确的元素

255
00:16:04,250 --> 00:16:08,590
的树状结构。

256
00:16:08,590 --> 00:16:11,310
你看，我在这里使用递归。

257
00:16:11,310 --> 00:16:14,150
然后，如果它的不足，我要去看看左边。

258
00:16:14,150 --> 00:16:18,330
终于，否则，如果它不小于或不大于，

259
00:16:18,330 --> 00:16:20,660
这意味着它本身的价值。

260
00:16:20,660 --> 00:16:23,010
于是我就返回true。

261
00:16:23,010 --> 00:16:26,360
你可以在这里看到我使用，如果，如​​果，如​​果。

262
00:16:26,360 --> 00:16:30,820
请记住，在测验0，我们有一个问题，如果有如果，如果，

263
00:16:30,820 --> 00:16:32,780
而你应该找到效率低下，

264
00:16:32,780 --> 00:16:35,180
而效率低下是你使用，如果。

265
00:16:35,180 --> 00:16:39,060
你应该使用，如果，否则，如果，否则，如果和其他人。

266
00:16:39,060 --> 00:16:44,240
所以，我应该用别的if和else if和else这里？

267
00:16:44,240 --> 00:16:46,200
有没有人 - 耶？

268
00:16:46,200 --> 00:16:51,140
[学生来讲，无声]

269
00:16:51,140 --> 00:16:53,480
那很完美。所以，她说，不要紧，

270
00:16:53,480 --> 00:16:55,930
只是因为我们之前所拥有的低效率

271
00:16:55,930 --> 00:16:59,550
是因为，也许，如果某些条件被满足，

272
00:16:59,550 --> 00:17:03,570
所以你执行的操作，但随后你要检查所有的其他条件。

273
00:17:03,570 --> 00:17:06,319
但在这种情况下，它返回的时候了，所以没关系。

274
00:17:06,319 --> 00:17:09,220
所以，你不必如果要使用其他。

275
00:17:09,220 --> 00:17:11,740
>>最后，让我们来谈谈尝试，

276
00:17:11,740 --> 00:17:13,800
这是每个人的最爱。

277
00:17:13,800 --> 00:17:15,980
一个try是阵列的树。

278
00:17:15,980 --> 00:17:20,369
它非常快速查找值，但它使用了大量的内存。

279
00:17:20,369 --> 00:17:22,530
这通常过滤的话，那么当你

280
00:17:22,530 --> 00:17:27,920
想要实现，例如，我不知道，像电话簿中的电话

281
00:17:27,920 --> 00:17:30,440
并且希望能B型

282
00:17:30,440 --> 00:17:32,510
而只是谁的人有二名

283
00:17:32,510 --> 00:17:37,960
它非常容易使用try来实现，例如。

284
00:17:37,960 --> 00:17:39,820
在一个try你如何定义一个节点？

285
00:17:39,820 --> 00:17:43,910
你只需要拥有一个bool，是要被is_word。

286
00:17:43,910 --> 00:17:48,660
它表示使用的所有字符的节点之前，

287
00:17:48,660 --> 00:17:51,920
你能形成一个字，

288
00:17:51,920 --> 00:17:57,230
然后你就会有一个指针数组节点。

289
00:17:57,230 --> 00:18:03,120
你可以看到，我们有父节点的数组，所以节点*数组？是吗？

290
00:18:03,120 --> 00:18:06,050
因此，让我们来看看如何将工作。对于拼写检查，

291
00:18:06,050 --> 00:18:08,230
我们有27个元素的数组，

292
00:18:08,230 --> 00:18:12,150
因为我们拥有所有的字母加上单引号。

293
00:18:12,150 --> 00:18:17,800
在这里我只是要使用2，因为我希望能够在黑板上写字。

294
00:18:17,800 --> 00:18:20,230
好吧。所以这是一个尝试的一个例子。

295
00:18:20,230 --> 00:18:25,600
如果我只是定义的第一个节点，我将有2个元素的数组

296
00:18:25,600 --> 00:18:29,290
这2个指针为NULL，所以我只是把'A'和'B'。

297
00:18:29,290 --> 00:18:32,430
我要去有一个bool，说is_word。

298
00:18:32,430 --> 00:18:34,420
这将是虚假的第一个，

299
00:18:34,420 --> 00:18:37,370
只是因为，在这之前你没有任何字符。

300
00:18:37,370 --> 00:18:40,900
因此，一个空字是不是一个词。因此，它是假的。

301
00:18:40,900 --> 00:18:46,320
如果我想'一'加入到这个字典中，那么我有什么关系？

302
00:18:46,320 --> 00:18:49,760
我只是将malloc为'一'一个新的节点，

303
00:18:49,760 --> 00:18:54,630
然后将其单词添加为true。

304
00:18:54,630 --> 00:19:00,180
因此，它只是表示有'一'将是真实的。有意义吗？

305
00:19:00,180 --> 00:19:04,120
那么如果我想添加'BA'，我得的malloc 1'B'，

306
00:19:04,120 --> 00:19:07,550
然后我要去布尔设置为false，

307
00:19:07,550 --> 00:19:10,160
因为'B'本身不是一个字。

308
00:19:10,160 --> 00:19:13,010
然后我会用malloc另一个为'A'，所以'BA'，

309
00:19:13,010 --> 00:19:16,290
然后我要建立它的一个字为true。

310
00:19:16,290 --> 00:19:18,950
因为'BA'这个词。

311
00:19:18,950 --> 00:19:21,910
然后如果我想看看'b'是本词典，

312
00:19:21,910 --> 00:19:26,730
我可以去到的第一个，'B'。我要下去，我看是字，和它说假的。

313
00:19:26,730 --> 00:19:30,110
所以它不是一个字。如果我要检查'BA'，

314
00:19:30,110 --> 00:19:38,010
我去的第一个，'B'，然后去'一'，我看真正的，所以它是一个字。有意义吗？

315
00:19:38,010 --> 00:19:41,950
很多人通过尝试感到困惑。没有？

316
00:19:41,950 --> 00:19:44,740
>>最后，Huffman编码。霍夫曼编码是非常有用的

317
00:19:44,740 --> 00:19:47,550
为了节省内存和压缩文本文件，

318
00:19:47,550 --> 00:19:52,270
只是因为很多你用'a'和'E'，例如时间，

319
00:19:52,270 --> 00:19:57,710
在文档中，但我不知道，如果你们使用'Q'或'Z'为多。

320
00:19:57,710 --> 00:20:02,040
刚走1个字节为每一个字符，

321
00:20:02,040 --> 00:20:08,520
每一个 - 在256个字符，我们在ASCII表不是很理想，

322
00:20:08,520 --> 00:20:11,410
只是因为有您使用更一些字符，

323
00:20:11,410 --> 00:20:15,180
所以你应该使用更少的内存为那些。

324
00:20:15,180 --> 00:20:17,560
我如何使用霍夫曼编码？

325
00:20:17,560 --> 00:20:20,010
我们要做一个哈夫曼树。

326
00:20:20,010 --> 00:20:23,370
 哈夫曼树有节点

327
00:20:23,370 --> 00:20:27,760
有，是要像，'A'，'B'，'C'，信的象征，

328
00:20:27,760 --> 00:20:32,990
不管信你，一个频率，这个词出现在文本的频率，

329
00:20:32,990 --> 00:20:36,280
您正在创建哈夫曼树，

330
00:20:36,280 --> 00:20:41,800
然后，是要指向哈夫曼树的左节点

331
00:20:41,800 --> 00:20:47,210
并且，是要指向正确的另一个节点。所以就像一棵树。

332
00:20:47,210 --> 00:20:49,440
你如何建立一个哈夫曼树？

333
00:20:49,440 --> 00:20:54,020
你会挑2个节点具有最低频率。

334
00:20:54,020 --> 00:20:56,490
如果你有一个领带你要挑2个节点

335
00:20:56,490 --> 00:20:59,870
具有最低的ASCII值也是如此。

336
00:20:59,870 --> 00:21:02,420
然后，你要创建一个新的树掉那些2节点

337
00:21:02,420 --> 00:21:08,030
这是要在父节点的合并次数。

338
00:21:08,030 --> 00:21:13,240
然后你会从林中删除了2名儿童

339
00:21:13,240 --> 00:21:15,570
并与家长进行更换。

340
00:21:15,570 --> 00:21:18,930
而你要再说一遍，直到你只有1棵树在森林里。

341
00:21:18,930 --> 00:21:23,840
因此，让我们看看你会怎么做一个哈夫曼树ZAMYLA。

342
00:21:23,840 --> 00:21:29,220
你可以在这里看到，所有的字母有频率1，除了“A”，即具有频率2。

343
00:21:29,220 --> 00:21:34,090
所以我创建了所有我整理的ASCII值和频率的字母节点。

344
00:21:34,090 --> 00:21:40,090
所以，如果我要创建的第一棵树，它会以'L'和'M'。

345
00:21:40,090 --> 00:21:43,100
所以它在这里。该对的频率将是2

346
00:21:43,100 --> 00:21:49,470
因为它是1 +1，然后在接下来的2具有最低的频率是“Y”和“Z”。

347
00:21:49,470 --> 00:21:53,180
然后，我有所有的人是 - 有2的频率。

348
00:21:53,180 --> 00:22:00,470
那么哪些是那些有下一个最低的ASCII值？

349
00:22:00,470 --> 00:22:04,830
'A'和'L'。所以我创建了新的节点，

350
00:22:04,830 --> 00:22:09,930
最后，它是4和2，因此2将是在左边。

351
00:22:09,930 --> 00:22:12,430
这就是哈夫曼树。

352
00:22:12,430 --> 00:22:16,060
然后，如果我想写一些文字，

353
00:22:16,060 --> 00:22:24,440
像二进制转换为文本，使用霍夫曼树是很容易的。

354
00:22:24,440 --> 00:22:30,220
举例来说，如果我说移动到左边是一个0和移动到右边是一个1，

355
00:22:30,220 --> 00:22:32,410
什么是去代表什么？

356
00:22:32,410 --> 00:22:35,530
因此，像1，1，所以右，右，

357
00:22:35,530 --> 00:22:40,370
然后0，所以左将L，然后1，0，0。

358
00:22:40,370 --> 00:22:43,950
所以，1，0，所以只是1，0，'A'。

359
00:22:43,950 --> 00:22:47,540
然后0，1，因此“Z”。

360
00:22:47,540 --> 00:22:52,170
然后1，0，0  - 没有。

361
00:22:52,170 --> 00:22:56,780
0,0将是'Y'，那么懒惰。

362
00:22:56,780 --> 00:23:06,060
所以，这一切对我来说，罗布的去接管。

363
00:23:06,060 --> 00:23:08,400
>> [罗布鲍登]所以，​​每周7的东西。

364
00:23:08,400 --> 00:23:11,390
我们已经得到了很多去了真快。

365
00:23:11,390 --> 00:23:13,430
位运算符，缓冲区溢出，

366
00:23:13,430 --> 00:23:16,760
CS50库，然后HTML，HTTP，CSS。

367
00:23:16,760 --> 00:23:20,990
所有在像15到20分钟。

368
00:23:20,990 --> 00:23:24,330
位运算符。有他们的6，你需要知道的。

369
00:23:24,330 --> 00:23:31,200
按位与，按位或，异或，左移，右移，而不是。

370
00:23:31,200 --> 00:23:35,420
右移，而不是你在演讲几乎没有看到的。

371
00:23:35,420 --> 00:23:40,480
我们就去了它很快在这里，但它是很好的了解，这些都是存在的6。

372
00:23:40,480 --> 00:23:45,070
请记住，按位运算符是当你做3 + 4等。

373
00:23:45,070 --> 00:23:49,420
你所面对的并非是3和4的二进制文件。

374
00:23:49,420 --> 00:23:56,550
与位运算符实际上是在处理数字3和4的各个位。

375
00:23:56,550 --> 00:23:59,120
>>所以我们会说的第一个是按位没有，

376
00:23:59,120 --> 00:24:02,340
而它所做的就是翻转所有位。

377
00:24:02,340 --> 00:24:05,500
所以在这里，如果你正在写在C，你不会写

378
00:24:05,500 --> 00:24:09,380
作为〜11011或什么的，你会写什么样子〜4，

379
00:24:09,380 --> 00:24:12,970
然后将翻转的4的二进制表示。

380
00:24:12,970 --> 00:24:24,800
所以在这里，〜的一些二进制数1101101是要精确地翻转全1到0和1的全0。

381
00:24:24,800 --> 00:24:27,600
正如我说有，经常利用这一点，

382
00:24:27,600 --> 00:24:30,830
我们会看到它的有点，就像是我们要拿出一些数字

383
00:24:30,830 --> 00:24:35,460
其中所有的位都为1，除了其中之一。

384
00:24:35,460 --> 00:24:38,560
因此，它通常更容易表达数

385
00:24:38,560 --> 00:24:40,630
其中只是单位被设置，

386
00:24:40,630 --> 00:24:44,650
然后利用它的〜，所以每隔位被置位，除了那一个。

387
00:24:44,650 --> 00:24:50,300
所以，这就是我们要使用更多的位。

388
00:24:50,300 --> 00:24:58,220
>>按位或。这里有2二进制数，而这些2号

389
00:24:58,220 --> 00:25:00,780
有相当代表性，因为它们代表每一个可能的

390
00:25:00,780 --> 00:25:07,290
位的组合，你可能需要进行操作。

391
00:25:07,290 --> 00:25:13,540
在这里，当我逻辑或运算的每一位，我们只是将直降比较。

392
00:25:13,540 --> 00:25:15,410
这样的左侧，我们有一个1和1。

393
00:25:15,410 --> 00:25:20,510
当我按位|那些，我该怎么走？之一。

394
00:25:20,510 --> 00:25:25,320
然后按位| 0和1是要给我吗？之一。

395
00:25:25,320 --> 00:25:27,840
按位1和0的将是同样的东西，1。

396
00:25:27,840 --> 00:25:31,880
按位0 | 0是要给我0。

397
00:25:31,880 --> 00:25:37,300
所以，在这里我得到0的唯一情况是在0 | 0例。

398
00:25:37,300 --> 00:25:40,020
和你能想到的，就像你的逻辑OR。

399
00:25:40,020 --> 00:25:44,830
所以，如果你认为1为真和0为假，同样的道理也适用于这里。

400
00:25:44,830 --> 00:25:50,040
所以，真正的或真实不虚;真或假为真。

401
00:25:50,040 --> 00:25:57,150
或真或假为真，假的还是假的是唯一的事情，实际上是假的。

402
00:25:57,150 --> 00:26:00,100
下面是你应该知道的例子

403
00:26:00,100 --> 00:26:05,160
作为一个相当不错的，当位运算符的使用的例子。

404
00:26:05,160 --> 00:26:08,660
在这里，如果我们或大写A与OX20，

405
00:26:08,660 --> 00:26:11,830
我们将看看这些在第二，我们得到的东西。

406
00:26:11,830 --> 00:26:16,020
如果我们还是小写'A'与OX20，我们得到的东西。

407
00:26:16,020 --> 00:26:26,750
因此，让我们拉起ASCII表。

408
00:26:26,750 --> 00:26:34,000
好吧。在这里，我们看到，'A'是 - 

409
00:26:34,000 --> 00:26:36,920
在这里，我们有'A'是十进制的65。

410
00:26:36,920 --> 00:26:45,120
但我会去用十六进制，这是Ox41。

411
00:26:45,120 --> 00:26:48,280
敢肯定，我们看到它在课堂上。我认为，我们看到它在课堂上

412
00:26:48,280 --> 00:26:52,730
这是很容易转换为十六进制二进制。

413
00:26:52,730 --> 00:26:55,280
所以在这里，如果我想要把4成二进制，

414
00:26:55,280 --> 00:26:59,550
这只是将是0100。

415
00:26:59,550 --> 00:27:03,620
这是1个位，2个位，4个位，所以这是4。

416
00:27:03,620 --> 00:27:08,550
然后，我可以一拆二，这将是0001。

417
00:27:08,550 --> 00:27:14,280
所以这将是二进制“A”的表示。

418
00:27:14,280 --> 00:27:22,720
以小写字母'A'，它现在将是Ox61，

419
00:27:22,720 --> 00:27:27,050
在那里，这些分裂成它的二进制，所以6  - 

420
00:27:27,050 --> 00:27:37,830
让我们真正做到这一点 - 有没有橡皮擦？橡皮擦。

421
00:27:37,830 --> 00:27:48,220
Ox61。因此分裂6成二进制将是0 + 4 + 2 + 0。

422
00:27:48,220 --> 00:27:54,610
和分割1将是0001。

423
00:27:54,610 --> 00:27:56,520
看着这两个之间的区别，

424
00:27:56,520 --> 00:28:04,250
我们看到，一个小写和大写“A”之间的唯一区别是这样的单个位。

425
00:28:04,250 --> 00:28:11,810
于是又回到这里 - 好吧。

426
00:28:11,810 --> 00:28:15,920
回来到这里，如果我们再看一下位OX20是，

427
00:28:15,920 --> 00:28:22,210
因此分裂OX20转换为二进制，

428
00:28:22,210 --> 00:28:27,310
是0010，0000。

429
00:28:27,310 --> 00:28:33,470
OX20，所设置的唯一的一点是此位是我们所关注的，

430
00:28:33,470 --> 00:28:38,210
资本和小写'A'之间的切换。

431
00:28:38,210 --> 00:28:47,610
如果我或'A'，这是这个，'A'，

432
00:28:47,610 --> 00:28:50,580
如果我或'A'与OX20，

433
00:28:50,580 --> 00:28:53,490
我该怎么走？

434
00:28:53,490 --> 00:28:58,960
[学生，无声] >>小写字母'A'，因为它会翻转该位为1。

435
00:28:58,960 --> 00:29:04,170
如果我或'a'与OX20，我该怎么走？

436
00:29:04,170 --> 00:29:08,780
小写a，因为刚奥林格'A'与OX20，

437
00:29:08,780 --> 00:29:14,580
我只是将要奥林格此单位为1，它已经是一个1，所以也无所谓。

438
00:29:14,580 --> 00:29:17,960
因此，我们得到'A'和'a'。

439
00:29:17,960 --> 00:29:24,820
>>按位与。同样，我们可以认为这是我们的逻辑和对应。

440
00:29:24,820 --> 00:29:28,180
在左侧，我们有真正的和真实的。

441
00:29:28,180 --> 00:29:31,160
这将是真实的，并为所有的情况下，

442
00:29:31,160 --> 00:29:36,270
假及真或真，假，假，假，

443
00:29:36,270 --> 00:29:38,550
没有这些东西都是真实的。

444
00:29:38,550 --> 00:29:44,170
因此，我们最终得到的是1000。

445
00:29:44,170 --> 00:29:48,830
所以，现在，这里，这里就是我用的值得信赖的按位没有，

446
00:29:48,830 --> 00:29:52,230
在那里我们有OX20。

447
00:29:52,230 --> 00:29:54,350
因此，这是OX20。

448
00:29:54,350 --> 00:29:59,570
现在我想做的事情，按位OX20的〜。

449
00:29:59,570 --> 00:30:03,600
这是要翻转的所有位。

450
00:30:03,600 --> 00:30:09,330
所以，我有1101 1111

451
00:30:09,330 --> 00:30:18,940
所以“A”相与〜OX20是要给我什么？

452
00:30:18,940 --> 00:30:22,430
我们真正需要思考的唯一的一点是这个，

453
00:30:22,430 --> 00:30:26,020
因为，如果所有这些位都设置为1，

454
00:30:26,020 --> 00:30:29,000
然后我们将得到完全'A'是什么，

455
00:30:29,000 --> 00:30:31,260
除了，可能，这是什么位。

456
00:30:31,260 --> 00:30:34,460
因为，如果它是1，现在它的将被设置为0，

457
00:30:34,460 --> 00:30:39,810
因为不管这是，相与与这个将是0。

458
00:30:39,810 --> 00:30:43,280
那么，什么是“A”＆〜OX20要给我？

459
00:30:43,280 --> 00:30:48,200
[学生回答，无声] >>什么是'a'和 - 这是“A”。

460
00:30:48,200 --> 00:30:52,170
什么是'a'＆〜OX20要给我？

461
00:30:52,170 --> 00:30:56,720
'答：'因为这是目前一个1。

462
00:30:56,720 --> 00:30:59,570
安定与这个0是要使它成为一个0，

463
00:30:59,570 --> 00:31:02,530
现在我们要得到一个“A”。

464
00:31:02,530 --> 00:31:06,600
>>两者都是'A'，以及最后但并非最不重要的这种类型的，

465
00:31:06,600 --> 00:31:10,830
我们有异。它非常像，或

466
00:31:10,830 --> 00:31:14,400
除了它是指专用于或。

467
00:31:14,400 --> 00:31:18,420
这就像你通常所认为的，或在现实世界中。

468
00:31:18,420 --> 00:31:23,190
所以，你要么做“X”或“Y”，但不能同时使用。

469
00:31:23,190 --> 00:31:28,700
在这里，1 ^ 1将是0。

470
00:31:28,700 --> 00:31:33,650
因为如此，这是 - 它并不与逻辑真和假的工作，以及

471
00:31:33,650 --> 00:31:37,150
如按位与和或做什么，

472
00:31:37,150 --> 00:31:40,100
但真正的^真为假。

473
00:31:40,100 --> 00:31:44,810
因为我们只想要返回true，如果只有其中一个是真实的。

474
00:31:44,810 --> 00:31:50,950
所以1 ^ 1是0。怎么样0 ^ 1？

475
00:31:50,950 --> 00:31:56,010
为1。 1 ^ 0是1，0 ^ 0是0。

476
00:31:56,010 --> 00:32:03,890
所以，在任何情况下，0位运算的东西0将是0。

477
00:32:03,890 --> 00:32:10,270
1位运算的东西0或0按位1，

478
00:32:10,270 --> 00:32:14,660
如果它的|或^，这将是一个1，如果它是和它会是0。

479
00:32:14,660 --> 00:32:20,850
而唯一的情况下，其中1位运算1不1是异或。

480
00:32:20,850 --> 00:32:24,580
那是0110。

481
00:32:24,580 --> 00:32:36,520
所以现在在这里，使用XOR  - 所以我们回到20。

482
00:32:36,520 --> 00:32:43,480
'A'^ OX20是这2位我们比较。

483
00:32:43,480 --> 00:32:50,020
因此，一个1 ^ 0是要给我一个什么？一个。

484
00:32:50,020 --> 00:32:58,430
'A'^ OX20是要给我吗？小写a。

485
00:32:58,430 --> 00:33:04,010
'一'^ OX20是要给我吗？ A.资本

486
00:33:04,010 --> 00:33:09,310
因为不管这是干什么的，这个异或与OX20

487
00:33:09,310 --> 00:33:15,380
有效地翻转不管该位。

488
00:33:15,380 --> 00:33:21,240
如果这是一个0，它现在会成为一个1。

489
00:33:21,240 --> 00:33:26,160
由于这是一个1，1 ^ 1是0。

490
00:33:26,160 --> 00:33:33,280
因此，我们的'一'已经变成了'A'，而我们的'A'已经变成了'一'。

491
00:33:33,280 --> 00:33:36,910
因此，异或仅仅是翻转的情况下，一个真正方便的方式。

492
00:33:36,910 --> 00:33:39,960
你只是想遍历字母串

493
00:33:39,960 --> 00:33:44,330
和交替的每一个字符的情况下，

494
00:33:44,330 --> 00:33:50,680
你只是XOR一切与OX20。

495
00:33:50,680 --> 00:33:55,220
>>现在我们已经左移。左移只是要，基本上，

496
00:33:55,220 --> 00:34:01,250
推动所有数字成，或左侧，并插入0的甩在身后。

497
00:34:01,250 --> 00:34:05,550
所以在这里我们有00001101。

498
00:34:05,550 --> 00:34:08,560
我们打​​算从右边推3 0在，

499
00:34:08,560 --> 00:34:13,580
我们得到01101000。

500
00:34:13,580 --> 00:34:16,380
在非二进制计算，

501
00:34:16,380 --> 00:34:24,699
我们看到，这是真正处理13左移3，这给了我们104。

502
00:34:24,699 --> 00:34:32,530
所以左移位，我们在这里看到，X << y是基本X * 2 ^年。

503
00:34:32,530 --> 00:34:40,139
13 * 2 ^ 3,2 ^ 3为8位，所以13 * 8是104。

504
00:34:40,139 --> 00:34:45,679
如果你只是想二进制一般来说，每个数字如何，

505
00:34:45,679 --> 00:34:49,530
如果我们从右边开始，它是1的位置，那么2的地方，那么4的地方。

506
00:34:49,530 --> 00:34:51,330
因此，通过从右边0的推动，

507
00:34:51,330 --> 00:34:55,080
我们只是推的东西，分别在4的地方到8的位置，

508
00:34:55,080 --> 00:34:57,920
和事情是在8的位置到16的位置。

509
00:34:57,920 --> 00:35:01,280
每班只需乘以2。是吗？

510
00:35:01,280 --> 00:35:05,210
[学生]：如果你通过5移，会发生什么？

511
00:35:05,210 --> 00:35:10,790
[鲍登]如果通过5转移你只是失去位数。

512
00:35:10,790 --> 00:35:15,410
不可避免的是，这是同样的事情。像，整数仅为32位，

513
00:35:15,410 --> 00:35:20,750
所以，如果你添加2真正的大整数，它只是不适合在一个整数。

514
00:35:20,750 --> 00:35:23,660
所以它在这里同样的事情。如果通过5移，

515
00:35:23,660 --> 00:35:25,650
我们只是失去的那一个。

516
00:35:25,650 --> 00:35:28,820
这就是那种我所说的“大致”

517
00:35:28,820 --> 00:35:37,470
在那里，如果你移动得太远，你输了位。

518
00:35:37,470 --> 00:35:39,830
>>右移将是相反的，

519
00:35:39,830 --> 00:35:43,090
我们要去的地方，以推0的关底，

520
00:35:43,090 --> 00:35:48,400
并为我们的宗旨，填0的从左边。

521
00:35:48,400 --> 00:35:52,910
所以这样做，我们基本上扭转了我们已经做了。

522
00:35:52,910 --> 00:35:57,780
而且我们看到，三个0的右侧刚刚脱落，

523
00:35:57,780 --> 00:36:02,020
我们已经推1101一路的权利。

524
00:36:02,020 --> 00:36:08,380
这是做104 >> 3，这是有效的，X / 2 ^年。

525
00:36:08,380 --> 00:36:11,200
所以，现在，在这里，这是一个类似的想法。

526
00:36:11,200 --> 00:36:18,720
为何说是大致的x / 2 ^ y和不实际的x / 2 ^ Y'

527
00:36:18,720 --> 00:36:22,240
因为如果我已经转移了4，我已经失去了一个1。

528
00:36:22,240 --> 00:36:25,950
基本上，你怎么想的，只是觉得整数除法的一般。

529
00:36:25,950 --> 00:36:31,070
所以，像第5/2为2。这不是2.5。

530
00:36:31,070 --> 00:36:35,000
它在这里同样的想法。当我们除以2，

531
00:36:35,000 --> 00:36:39,910
我们可以失去奇数位前进的道路。

532
00:36:39,910 --> 00:36:43,870
所以，现在 - 这是它的按位。这就是所有你需要知道的。

533
00:36:43,870 --> 00:36:46,340
还记得我们在课堂上看到了用例，

534
00:36:46,340 --> 00:36:49,340
就像一个位掩码是位运算符很有用，

535
00:36:49,340 --> 00:36:53,220
或者你使用它们的位掩码。

536
00:36:53,220 --> 00:36:58,620
大写字母和小写字母，转换是一个非常典型的例子。

537
00:36:58,620 --> 00:37:01,640
>>好吧，缓冲区溢出攻击。

538
00:37:01,640 --> 00:37:05,110
还有人记得什么是错用这个功能呢？

539
00:37:05,110 --> 00:37:10,140
请注意，我们宣布的12字节的数组，12个字符，

540
00:37:10,140 --> 00:37:18,510
然后我们复制到我们的12个字符的整个字符串酒吧缓冲区。

541
00:37:18,510 --> 00:37:25,080
那么，有什么问题吗？

542
00:37:25,080 --> 00:37:32,270
神奇的数字12应该几乎立刻蹦出来的 - 为什么是12？

543
00:37:32,270 --> 00:37:35,050
如果有什么酒吧恰好是超过12个字符？

544
00:37:35,050 --> 00:37:41,200
如果有什么酒吧是几百万字？

545
00:37:41,200 --> 00:37:46,010
这里的问题是memcpy的调用。如果酒吧是足够长的时间，

546
00:37:46,010 --> 00:37:50,330
它只会彻底 - 'C'，'C'并不关心，这是只有12个字符;

547
00:37:50,330 --> 00:37:53,280
'C'不关心它不适合很多字节。

548
00:37:53,280 --> 00:37:58,250
它只是将完全覆盖字符，我们已经为它分配了12个字节，

549
00:37:58,250 --> 00:38:01,830
一切都过去，它在内存中实际上并不属于该缓冲区

550
00:38:01,830 --> 00:38:06,520
与任何字符串酒吧。

551
00:38:06,520 --> 00:38:09,780
所以这是我们在课堂上看到的图片

552
00:38:09,780 --> 00:38:12,220
我们有我们的堆栈成长。

553
00:38:12,220 --> 00:38:16,040
您应使用这些图片或熟悉一遍。

554
00:38:16,040 --> 00:38:21,260
我们已经把我们的叠成长过程中，内存地址为0开始顶部

555
00:38:21,260 --> 00:38:26,270
和发展下来，如4十亿在底部。

556
00:38:26,270 --> 00:38:28,820
我们有我们的数组'C'在内存的某个地方，

557
00:38:28,820 --> 00:38:32,260
那么，我们有我们的指针吧正下方写着，

558
00:38:32,260 --> 00:38:38,720
然后我们在我们的返回地址，这样保存的帧指针和我们的父母日常的堆栈。

559
00:38:38,720 --> 00:38:40,800
记住的返回地址是什么？

560
00:38:40,800 --> 00:38:45,360
这是当主调用函数foo，调用一个函数吧，

561
00:38:45,360 --> 00:38:48,100
不可避免的，酒吧的回报。

562
00:38:48,100 --> 00:38:52,610
所以，当酒吧的回报，他们需要知道，它会返回到foo的调用它。

563
00:38:52,610 --> 00:39:01,360
因此返回地址是它的函数的地址，返回在函数返回时。

564
00:39:01,360 --> 00:39:05,830
究其原因，是对缓冲区溢出攻击重要的是因为，方便，

565
00:39:05,830 --> 00:39:09,580
黑客喜欢改变返回地址。

566
00:39:09,580 --> 00:39:14,950
而不是要回富的，我要回去的地方黑客要我回去。

567
00:39:14,950 --> 00:39:17,760
而且，方便，那里的黑客经常想回去

568
00:39:17,760 --> 00:39:22,400
是，我们原本有缓冲区的开始。

569
00:39:22,400 --> 00:39:26,170
所以请注意，再次，小印度。

570
00:39:26,170 --> 00:39:28,490
该设备是一个小印第安人系统的一个例子，

571
00:39:28,490 --> 00:39:34,140
这样的一个整数或者指针被存储并反转字节。

572
00:39:34,140 --> 00:39:38,980
所以在这里，我们看到 - 是什么？是啊。

573
00:39:38,980 --> 00:39:45,660
我们看到Ox80，OxC0，Ox35，OxO8。

574
00:39:45,660 --> 00:39:48,250
还记得十六进制数字？

575
00:39:48,250 --> 00:39:50,640
我们不扭转小印度的十六进制数字，

576
00:39:50,640 --> 00:39:56,110
因为2个十六进制数字组成一个字节，而我们扭转字节。

577
00:39:56,110 --> 00:40:00,300
这就是为什么我们不存储一样，80530CO8。

578
00:40:00,300 --> 00:40:07,520
我们存储，相反，每对2个数字，从右边开始。

579
00:40:07,520 --> 00:40:10,880
该地址是指起始地址

580
00:40:10,880 --> 00:40:15,190
我们的缓冲，我们其实是想复制到摆在首位。

581
00:40:15,190 --> 00:40:19,230
究其原因，是非常有用的，因为，如果有什么攻击

582
00:40:19,230 --> 00:40:24,100
事，而不是有一个字符串，它只是为了，

583
00:40:24,100 --> 00:40:27,060
像一个无害的字符串，他们的名字什么的，

584
00:40:27,060 --> 00:40:33,900
如果，相反，该字符串只是一些任意代码

585
00:40:33,900 --> 00:40:38,610
那做任何他们想要它做什么？

586
00:40:38,610 --> 00:40:45,630
这样他们就可以 - 我想不出任何很酷的代码。

587
00:40:45,630 --> 00:40:47,780
它可以是任何东西，但。任何灾难性的代码。

588
00:40:47,780 --> 00:40:51,440
如果他们想，他们可能只是做一些在段错误，但是这将是毫无意义的。

589
00:40:51,440 --> 00:40:54,950
他们通常做破解你的系统。

590
00:40:54,950 --> 00:40:59,930
>>好吧。 CS50库。

591
00:40:59,930 --> 00:41:04,800
这是，基本上，调用getInt，的getString，我们为您提供所有这些功能。

592
00:41:04,800 --> 00:41:10,630
因此，我们有字符*字符串，这就是我们吹散了抽象

593
00:41:10,630 --> 00:41:12,450
在学期中的一些点。

594
00:41:12,450 --> 00:41:18,220
请记住，一个字符串是一个字符只是一个数组。

595
00:41:18,220 --> 00:41:23,240
所以在这里我们看到的getString的删节版。

596
00:41:23,240 --> 00:41:25,920
你应该回头看一看它记得它是如何实际执行。

597
00:41:25,920 --> 00:41:30,950
关键的细节，注意我们得到一个字符的时间

598
00:41:30,950 --> 00:41:34,570
从在，这就像我们在键盘上的标准。

599
00:41:34,570 --> 00:41:37,890
因此，在每次一个字符，如果我们得到了太多的字符，

600
00:41:37,890 --> 00:41:40,580
所以如果n + 1大于容量

601
00:41:40,580 --> 00:41:44,140
那么我们需要增加我们的缓冲区的容量。

602
00:41:44,140 --> 00:41:47,780
所以在这里我们要加倍我们的缓冲区的大小。

603
00:41:47,780 --> 00:41:51,840
而且一直持续，我们插入字符到我们的缓冲区

604
00:41:51,840 --> 00:41:56,220
直到我们得到一个新行或文件或任何的结束，

605
00:41:56,220 --> 00:41:59,380
在这种情况下，我们用字符串，然后真正做的getString

606
00:41:59,380 --> 00:42:05,120
收缩的记忆，就像如果我们分配过多的内存，它会回去缩了一下。

607
00:42:05,120 --> 00:42:08,830
所以我们不显示，但其主要思想是

608
00:42:08,830 --> 00:42:11,960
它具有一次读取一个字符。

609
00:42:11,960 --> 00:42:17,140
它不能只是读了整个事情一次，

610
00:42:17,140 --> 00:42:19,550
因为他们的缓冲区只有具备一定规模。

611
00:42:19,550 --> 00:42:26,590
所以，如果它试图插入到缓冲区中的字符串是太大了，那么它会溢出。

612
00:42:26,590 --> 00:42:28,940
所以在这里我们防止只读取一个字符

613
00:42:28,940 --> 00:42:33,750
在时间和不断增长的时候，我们需要。

614
00:42:33,750 --> 00:42:40,270
所以调用getInt和其他CS50库函数趋向于使用的getString

615
00:42:40,270 --> 00:42:42,310
在它们的实现。

616
00:42:42,310 --> 00:42:45,370
所以我强调重要的东西在这里。

617
00:42:45,370 --> 00:42:49,460
它调用GetString来得到一个字符串。

618
00:42:49,460 --> 00:42:51,710
如果失败的getString返回的内存，

619
00:42:51,710 --> 00:42:54,270
记住的getString mallocs的东西，所以每当你需要调用getString

620
00:42:54,270 --> 00:42:57,820
你不应该（不知所云）释放，你有这个字符串。

621
00:42:57,820 --> 00:43:02,870
所以在这里，如果失败将malloc的东西，我们返回INT_MAX只是一个标志，该标志，

622
00:43:02,870 --> 00:43:05,650
哎，我们实际上并不能够得到一个整数。

623
00:43:05,650 --> 00:43:10,830
你应该忽略不管我回报给你，或

624
00:43:10,830 --> 00:43:15,540
你不应该把这个作为一个有效输入。

625
00:43:15,540 --> 00:43:21,360
最后，假设没有成功，我们使用sscanf的与该特殊标志，

626
00:43:21,360 --> 00:43:23,820
这意味着，第一匹配的整数，

627
00:43:23,820 --> 00:43:26,770
则该整数后匹配任何字符。

628
00:43:26,770 --> 00:43:29,070
所以请注意，我们希望它等于1。

629
00:43:29,070 --> 00:43:32,940
所以sscanf的回报有多少，如果匹配成功呢？

630
00:43:32,940 --> 00:43:37,010
它会返回1，如果匹配成功的一个整数，

631
00:43:37,010 --> 00:43:40,890
它会返回0，如果它不匹配的整数，并且它会返回2

632
00:43:40,890 --> 00:43:45,920
如果它匹配的整数，后面跟一些字符。

633
00:43:45,920 --> 00:43:49,780
所以，我们看到重试，如果我们配合什么，但1。

634
00:43:49,780 --> 00:43:55,230
因此，如果我们输入1，2，3，C或1，2，3，X，

635
00:43:55,230 --> 00:43:57,400
然后1，2，3会被存储在整数，

636
00:43:57,400 --> 00:43:59,620
十大将获取存储在字符，

637
00:43:59,620 --> 00:44:06,410
sscanf的将返回2，我们会重试，因为我们只想要一个整数。

638
00:44:06,410 --> 00:44:09,810
>>快速通过HTML，HTTP，CSS扑面而来。

639
00:44:09,810 --> 00:44:15,340
超文本标记语言是纤维网的结构和语义。

640
00:44:15,340 --> 00:44:19,960
下面是演讲，我们有HTML标签的例子。

641
00:44:19,960 --> 00:44:22,110
我们有head标签，body标签，

642
00:44:22,110 --> 00:44:27,770
我们有我们的地方居然没有一个开始和结束标记的空标签的例子，

643
00:44:27,770 --> 00:44:30,820
我们只是链接和图像。

644
00:44:30,820 --> 00:44:38,480
没有关闭图像标签;有只是完成一切的标签需要做一个标记。

645
00:44:38,480 --> 00:44:41,950
这个链接是一个例子，我们将看到如何链接到的CSS，

646
00:44:41,950 --> 00:44:45,910
该脚本是如何链接到外部JavaScript的一个例子。

647
00:44:45,910 --> 00:44:53,100
这是很简单的，记住，HTML不是一种编程语言。

648
00:44:53,100 --> 00:44:58,250
在这里，记住你将如何定义表单，或者至少这是什么会做什么？

649
00:44:58,250 --> 00:45:01,740
这种形式有一个动作和方法。

650
00:45:01,740 --> 00:45:06,210
你只会看到过的方法是GET和POST。

651
00:45:06,210 --> 00:45:09,040
所以得到的是那里的东西被放在URL中的版本。

652
00:45:09,040 --> 00:45:11,680
POST是它没有把在URL中。

653
00:45:11,680 --> 00:45:18,520
相反，从表单中的所有数据被插入更多隐藏在HTTP请求。

654
00:45:18,520 --> 00:45:22,390
所以在这里，行动定义了HTTP请求去。

655
00:45:22,390 --> 00:45:27,490
在那里它将会是google.com /搜索。

656
00:45:27,490 --> 00:45:32,890
方法。记住GET和POST之间的差异，

657
00:45:32,890 --> 00:45:37,200
和，只说作为一个例子，如果你想收藏的东西。

658
00:45:37,200 --> 00:45:40,660
你将永远无法书签一个POST的URL

659
00:45:40,660 --> 00:45:44,970
因为数据是不包含在URL中。

660
00:45:44,970 --> 00:45:49,790
>> HTTP，现在，是超文本传输​​协议。

661
00:45:49,790 --> 00:45:54,080
超文本传输​​协议，你会期望它来传输

662
00:45:54,080 --> 00:45:57,710
超文本标记语言，以及它的作用。

663
00:45:57,710 --> 00:46:00,170
但它也传递你找到在网络上的任何图像，

664
00:46:00,170 --> 00:46:05,400
你做任何下载开始作为一个HTTP请求。

665
00:46:05,400 --> 00:46:10,350
因此，HTTP是刚刚万维网的语言。

666
00:46:10,350 --> 00:46:15,610
在这里，你需要认识到这种HTTP请求的。

667
00:46:15,610 --> 00:46:19,300
这里HTTP/1.1就在身边只是说那是版本

668
00:46:19,300 --> 00:46:21,570
该协议的我使用。

669
00:46:21,570 --> 00:46:25,770
它几乎总是将是HTTP/1.1，你会看到它。

670
00:46:25,770 --> 00:46:30,110
然后，我们看到这是GET，替代是POST，你可能会看到。

671
00:46:30,110 --> 00:46:40,790
而我试图访问的URL是www.google.com/search?q =胡说，胡说，胡说。

672
00:46:40,790 --> 00:46:44,240
因此请记住这一点，问号Q =等等等等，

673
00:46:44,240 --> 00:46:49,040
是的东西，是通过提交表单的排序。

674
00:46:49,040 --> 00:46:51,830
它可能会返回到我的反应会是这个样子。

675
00:46:51,830 --> 00:46:54,050
再次，从协议，这将是如此，

676
00:46:54,050 --> 00:46:59,190
接着的状态代码。在这里，它是200行。

677
00:46:59,190 --> 00:47:05,060
最后，该网页实际上我要求将紧随其后。

678
00:47:05,060 --> 00:47:08,210
可能的状态代码，你可能会看到，你应该知道其中几个。

679
00:47:08,210 --> 00:47:12,770
200 OK你可能已经见过。

680
00:47:12,770 --> 00:47:17,830
403禁止，404未找​​到，500内部服务器错误

681
00:47:17,830 --> 00:47:22,140
通常如果你去一个网站，有什么地方不对头或他们的PHP代码崩溃，

682
00:47:22,140 --> 00:47:24,930
而在家电，我们有一个大的橙色框

683
00:47:24,930 --> 00:47:27,830
，来了，说，喜欢，什么是错的，这个代码不能正常工作

684
00:47:27,830 --> 00:47:30,380
或此功能的糟糕。

685
00:47:30,380 --> 00:47:33,230
通常网站不想让你知道什么是函数实际上是不好的，

686
00:47:33,230 --> 00:47:37,880
所以不是他们只会给你500内部服务器错误。

687
00:47:37,880 --> 00:47:43,050
>> TCP / IP是在HTTP的1层。

688
00:47:43,050 --> 00:47:47,550
请记住，有互联网万维网之外。

689
00:47:47,550 --> 00:47:52,270
就像如果你玩网络游戏，不通过HTTP，

690
00:47:52,270 --> 00:47:55,740
它会通过不同的 - 它仍然使用互联网，

691
00:47:55,740 --> 00:47:58,900
但它不使用HTTP。

692
00:47:58,900 --> 00:48:02,470
HTTP协议是建立在TCP / IP协议只是一个例子。

693
00:48:02,470 --> 00:48:07,820
IP的字面意思是互联网协议。

694
00:48:07,820 --> 00:48:11,500
每台计算机都有一个IP地址，它们是那些4位数字的东西

695
00:48:11,500 --> 00:48:16,510
像192.168.2.1，或者什么，这往往是一个地方之一。

696
00:48:16,510 --> 00:48:23,390
但是，这是一个IP地址的模式。

697
00:48:23,390 --> 00:48:29,060
因此，DNS，域名服务，

698
00:48:29,060 --> 00:48:33,410
这就是翻译的东西如google.com到实际的IP地址。

699
00:48:33,410 --> 00:48:37,700
所以，如果你键入IP地址转换成一个URL，

700
00:48:37,700 --> 00:48:40,850
这将带您到谷歌，但你往往不记得那些事情。

701
00:48:40,850 --> 00:48:45,470
你会记得google.com来代替。

702
00:48:45,470 --> 00:48:51,560
我们的最后一件事就是口，如果这是知识产权的技术合作计划的一部分。

703
00:48:51,560 --> 00:48:54,880
TCP会更多。想想看，像，你有你的网页浏览器中运行。

704
00:48:54,880 --> 00:48:58,670
也许你有一些运行电子邮件应用程序;

705
00:48:58,670 --> 00:49:02,150
也许你有一个使用互联网上运行的其他程序。

706
00:49:02,150 --> 00:49:05,090
他们都需要接入互联网，

707
00:49:05,090 --> 00:49:08,100
但你的电脑只有1 WiFi卡或什么的。

708
00:49:08,100 --> 00:49:10,780
所以端口是我们能够分裂方式

709
00:49:10,780 --> 00:49:13,550
这些应用程序都能够使用互联网。

710
00:49:13,550 --> 00:49:17,230
每个应用程序获得1特定的端口，它可以监听，

711
00:49:17,230 --> 00:49:19,670
并且默认情况下，HTTP使用端口80。

712
00:49:19,670 --> 00:49:22,410
有些电子邮件服务使用25。

713
00:49:22,410 --> 00:49:24,490
低编号的人往往会被保留。

714
00:49:24,490 --> 00:49:29,270
你通常能够获得更高的编号，那些为自己。

715
00:49:29,270 --> 00:49:32,010
>> CSS，层叠样式表。

716
00:49:32,010 --> 00:49:36,030
我们的风格网页使用CSS，不使用HTML。

717
00:49:36,030 --> 00:49:38,440
有3个地方，你可以把你的CSS。

718
00:49:38,440 --> 00:49:46,300
它可以是内联的，风格标签之间，或者在一个完全独立的文件，然后挂英寸

719
00:49:46,300 --> 00:49:48,470
这里是CSS只是一个例子。

720
00:49:48,470 --> 00:49:50,450
你应该认识到这种模式，

721
00:49:50,450 --> 00:49:54,310
其中第一个例子是我们相匹配的body标签，

722
00:49:54,310 --> 00:49:56,680
在这里，我们正在围绕body标签。

723
00:49:56,680 --> 00:50:00,420
第二个例子中，我们是匹配的东西

724
00:50:00,420 --> 00:50:04,740
ID为页脚，我们正在应用一些样式了。

725
00:50:04,740 --> 00:50:07,310
请注意，ID页脚文本对齐到左边，

726
00:50:07,310 --> 00:50:09,840
而正文文本对齐中心。

727
00:50:09,840 --> 00:50:13,180
页脚是身体内部。

728
00:50:13,180 --> 00:50:16,470
它将代替，文本左对齐，即使身体说的text-align中心。

729
00:50:16,470 --> 00:50:18,880
这是它的整个级联的一部分。

730
00:50:18,880 --> 00:50:22,110
你可以有 - 你可以为身体指定样式，

731
00:50:22,110 --> 00:50:25,320
然后东西在身上，可以指定更具体的款式，

732
00:50:25,320 --> 00:50:28,160
和事像您期望的工作。

733
00:50:28,160 --> 00:50:34,420
更具体的CSS规范优先。

734
00:50:34,420 --> 00:50:46,140
我觉得就是这样。

735
00:50:46,140 --> 00:50:49,260
>> [阿里的Nahm]大家好。如果我能得到你的注意。

736
00:50:49,260 --> 00:50:53,990
我是阿里，我要去通过PHP和SQL的真快。

737
00:50:53,990 --> 00:51:00,310
因此，我们可以开始了。 PHP是短为PHP：Hypertext Preprocessor的。

738
00:51:00,310 --> 00:51:03,730
而且大家都应该知道，这是一个服务器端脚本语言，

739
00:51:03,730 --> 00:51:06,800
我们将其用于网站的后端，

740
00:51:06,800 --> 00:51:12,540
以及它是如何做了很多的计算，背后的幕后部分。

741
00:51:12,540 --> 00:51:17,510
语法。它不象C，惊喜，惊喜。

742
00:51:17,510 --> 00:51:22,060
它总是开始与，如果你能看到的， - 我不能继续向前迈进。

743
00:51:22,060 --> 00:51:31,340
你可以看到你所需要的新型大括号，然后你还需要的？PHP。

744
00:51:31,340 --> 00:51:35,780
这总是你是如何帧你的PHP文本，你的PHP代码。

745
00:51:35,780 --> 00:51:39,180
因此，它不能只是像C，有种你把它放在第一。

746
00:51:39,180 --> 00:51:42,290
你需要始终围绕着它。

747
00:51:42,290 --> 00:51:47,610
而现在，各大语法是所有的变量需要开始以$字符。

748
00:51:47,610 --> 00:51:49,490
你需要做的是，当你定义它们，你需要做的

749
00:51:49,490 --> 00:51:51,860
如果你指的是对他们以后。

750
00:51:51,860 --> 00:51:56,510
你总是需要一个$。这是你最好的朋友，漂亮多了。

751
00:51:56,510 --> 00:52:01,690
你不 - 与C不同，你不需要把它是什么样的变量类型。

752
00:52:01,690 --> 00:52:04,940
因此，当你确实需要美元，你不需要把一样，

753
00:52:04,940 --> 00:52:09,470
诠释x或y字符串，等等，等等。

754
00:52:09,470 --> 00:52:11,490
所以，一个细微的差别。

755
00:52:11,490 --> 00:52:15,590
作为这样的结果，则意味着PHP是一种弱类型。

756
00:52:15,590 --> 00:52:19,310
PHP是一种弱类型语言，它已经弱类型变量。

757
00:52:19,310 --> 00:52:24,020
换言之，这意味着，可以在不同种类的变量类型之间的切换。

758
00:52:24,020 --> 00:52:27,230
你可以存储你的电话号码1为int，

759
00:52:27,230 --> 00:52:29,650
您可以将其存储为一个字符串，你可以将其存储为float，

760
00:52:29,650 --> 00:52:33,550
和它都将是数字1。

761
00:52:33,550 --> 00:52:36,080
即使你将它存储在不同的形式，

762
00:52:36,080 --> 00:52:39,120
它仍然是 - 变量类型仍持有到底。

763
00:52:39,120 --> 00:52:41,540
所以，如果你看这里，如果你从pset中7记，

764
00:52:41,540 --> 00:52:43,500
你们中许多人可能有这个问题。

765
00:52:43,500 --> 00:52:47,280
两个等号，3等号，4等号。

766
00:52:47,280 --> 00:52:49,990
好吧，有没有4等号，但也有2和3。

767
00:52:49,990 --> 00:52:53,320
您可以使用2等号检查的值。

768
00:52:53,320 --> 00:52:55,830
它可以检查跨类型。

769
00:52:55,830 --> 00:52:58,770
所以，如果你可以在第一个例子中看到的，

770
00:52:58,770 --> 00:53:02,210
我有num_int == num_string。

771
00:53:02,210 --> 00:53:06,710
所以，你的int和你的字符串都是，在技术上，1，

772
00:53:06,710 --> 00:53:10,790
但他们是不同的类型。但对于双等号，它仍然通过。

773
00:53:10,790 --> 00:53:15,510
然而，对于三重等号，它检查值以及不同类型。

774
00:53:15,510 --> 00:53:18,760
这意味着，它不会到那第二种情况下在这里，

775
00:53:18,760 --> 00:53:22,350
您使用的是3等号代替。

776
00:53:22,350 --> 00:53:26,590
所以这就是你应该所有现在已经证明的主要区别。

777
00:53:26,590 --> 00:53:31,570
>>字符串连接是另一种强大的东西你可以在PHP中使用。

778
00:53:31,570 --> 00:53:34,080
它基本上只是这个方便点符号，

779
00:53:34,080 --> 00:53:36,230
这就是你如何绑定字符串连接在一起。

780
00:53:36,230 --> 00:53:40,800
所以，如果你有猫，你有狗，和你想放的2串在一起，

781
00:53:40,800 --> 00:53:44,080
您可以使用期，这是一种工作方式。

782
00:53:44,080 --> 00:53:46,660
你也可以将它们彼此相邻，

783
00:53:46,660 --> 00:53:49,030
你可以看到在底部的例子在这里，

784
00:53:49,030 --> 00:53:51,610
在那里我有回声串1，空间字符串2。

785
00:53:51,610 --> 00:53:56,930
PHP将知道把它们放回这样。

786
00:53:56,930 --> 00:53:59,780
数组。现在，在PHP中，有2个不同类型的数组。

787
00:53:59,780 --> 00:54:03,180
你可以有规则排列，并且你也可以有关联数组，

788
00:54:03,180 --> 00:54:06,040
而且我们要通过他们去现在。

789
00:54:06,040 --> 00:54:08,280
常规数组只是在C，

790
00:54:08,280 --> 00:54:11,240
所以您有编号的指标。

791
00:54:11,240 --> 00:54:13,160
现在我们只是要创建一个，并把 - 

792
00:54:13,160 --> 00:54:15,500
所以这是我们如何创建一个空的数组，然后我们要

793
00:54:15,500 --> 00:54:17,310
投入的索引号0。

794
00:54:17,310 --> 00:54:19,200
我们打​​算把数字6，值6。

795
00:54:19,200 --> 00:54:21,500
您可以在底部看到它在这里。

796
00:54:21,500 --> 00:54:24,240
Where's  - 索引号为1，我们打算把价值数4，

797
00:54:24,240 --> 00:54:26,720
所以你可以看到有一个6，有一个4，

798
00:54:26,720 --> 00:54:29,160
然后当我们要打印的东西，

799
00:54:29,160 --> 00:54:33,550
当我们试图和打印存储在索引号为0的值，

800
00:54:33,550 --> 00:54:36,900
然后我们会看到值6被打印出来。酷？

801
00:54:36,900 --> 00:54:40,160
所以这是常规数组为您服务。

802
00:54:40,160 --> 00:54:42,750
另一种方法，你也可以添加东西经常阵列现在

803
00:54:42,750 --> 00:54:44,780
是你可以将它们附加在最后。

804
00:54:44,780 --> 00:54:47,240
这意味着，你不必指定具体的指标。

805
00:54:47,240 --> 00:54:51,000
你可以看到号码，然后在方括号中有没有指定的索引。

806
00:54:51,000 --> 00:54:56,270
它会知道 -  PHP会知道只需将其添加到列表中，下一个空闲点的结束。

807
00:54:56,270 --> 00:54:59,190
所以，你可以看到1正好遇上了0点，

808
00:54:59,190 --> 00:55:02,690
2去正好遇上的第一个点。

809
00:55:02,690 --> 00:55:04,690
3云 - 添加有作为。

810
00:55:04,690 --> 00:55:06,720
所以，那种是有道理的。你只是不断地增加它，

811
00:55:06,720 --> 00:55:09,360
然后当我们回响着数1的指数，

812
00:55:09,360 --> 00:55:13,080
它会打印出值2。

813
00:55:13,080 --> 00:55:16,800
>>然后我们有数组是关联数组。

814
00:55:16,800 --> 00:55:19,370
关联数组而不是有数字索引，

815
00:55:19,370 --> 00:55:23,630
他们做的是什么，他们有指数是由字符串。

816
00:55:23,630 --> 00:55:25,670
你可以看到，而不是 - 我摆脱了所有这些数量指标，

817
00:55:25,670 --> 00:55:32,140
现在它的密钥1，密钥2，密钥3，而且他们在双引号，以表明他们都是字符串。

818
00:55:32,140 --> 00:55:34,470
所以我们可以有这样的一个例子。

819
00:55:34,470 --> 00:55:38,790
这样做的例子是，我们有TF，这就是索引名称。

820
00:55:38,790 --> 00:55:42,030
我们打​​算把“阿里”作为名称，该指数在，吃的热量，

821
00:55:42,030 --> 00:55:47,640
我们可以把而不是字符串一个int这个时候，

822
00:55:47,640 --> 00:55:52,240
然后在指数喜欢，我们可以把整个数组里面它。

823
00:55:52,240 --> 00:55:55,490
因此，这是一种 - 这是一个类似的概念，我们怎么了

824
00:55:55,490 --> 00:55:58,930
用数字索引，但现在我们可以改变周围的指标

825
00:55:58,930 --> 00:56:03,890
有他们作为字符串来代替。

826
00:56:03,890 --> 00:56:06,070
您也可以做到这一点，除了刚刚做单独，

827
00:56:06,070 --> 00:56:09,400
你可以做到这一切在一个块。所以，你可以看到，数组的TF，

828
00:56:09,400 --> 00:56:13,350
然后我们将它们都在一个巨大的方括号集。

829
00:56:13,350 --> 00:56:15,220
这样就可以加快速度。

830
00:56:15,220 --> 00:56:19,730
它更多的是一种风格上的选择不是。

831
00:56:19,730 --> 00:56:21,550
我们也有循环。

832
00:56:21,550 --> 00:56:26,020
在C语言中，我们有这样的工作循环。

833
00:56:26,020 --> 00:56:29,690
我们有我们的数组，我们从索引0到该列表的末尾，

834
00:56:29,690 --> 00:56:31,740
我们打​​印出来，对吗？

835
00:56:31,740 --> 00:56:33,880
除了这个问题，对于关联数组，

836
00:56:33,880 --> 00:56:36,610
我们并不一定知道那些数字索引

837
00:56:36,610 --> 00:56:39,610
因为现在我们有字符串索引。

838
00:56:39,610 --> 00:56:44,800
现在我们使用foreach循环，其中，再次，你希望在PSET 7中使用。

839
00:56:44,800 --> 00:56:48,930
foreach循环将只知道列表的每一个部分。

840
00:56:48,930 --> 00:56:52,450
并且它没有确切地知道您有数字索引。

841
00:56:52,450 --> 00:56:56,490
所以，你必须在foreach的语法，所以它的foreach，你把数组。

842
00:56:56,490 --> 00:57:00,430
所以，我的数组被称为pset中，然后作为，字如，

843
00:57:00,430 --> 00:57:04,530
然后你把你要使用这个局部临时变量

844
00:57:04,530 --> 00:57:10,690
只是对于具体的事情，那将持有的具体 - 

845
00:57:10,690 --> 00:57:14,770
一个实例或数组中的一个部分。

846
00:57:14,770 --> 00:57:18,350
PSET民将举行1，然后说不定还会举办数6，

847
00:57:18,350 --> 00:57:20,410
然后将持有的数量2。

848
00:57:20,410 --> 00:57:26,630
但它保证要经过的每一个值，该值的数组中。

849
00:57:26,630 --> 00:57:30,530
有用的功能，你应该知道在PHP中是需要，

850
00:57:30,530 --> 00:57:35,880
这样就使得确保您包括某些文件，回声，退出，空的。

851
00:57:35,880 --> 00:57:40,490
我强烈建议你看看PSET 7，看看这些功能。

852
00:57:40,490 --> 00:57:42,810
你可能需要知道这些，

853
00:57:42,810 --> 00:57:47,060
所以我肯定会知道，究竟是什么，这些都在做的事情。

854
00:57:47,060 --> 00:57:50,080
>>现在我们要真正快速办理范围。

855
00:57:50,080 --> 00:57:53,490
在范围上，PHP是一种时髦的东西，不像C，

856
00:57:53,490 --> 00:57:56,170
所以我们只是要快速通过它去。

857
00:57:56,170 --> 00:57:58,930
因此，让我们说，我们开始在那个方向，我们有在那里。

858
00:57:58,930 --> 00:58:02,900
而且我们要以$开头我。这样的变量i将是0，

859
00:58:02,900 --> 00:58:06,730
而我们只是要保持在大的白色盒印刷它在那里。

860
00:58:06,730 --> 00:58:09,220
我们将开始与I0，然后我们要呼应它。

861
00:58:09,220 --> 00:58:12,670
因此，有0。

862
00:58:12,670 --> 00:58:15,210
然后我们将通过for循环来增加它，

863
00:58:15,210 --> 00:58:17,810
然后它会是1的值。

864
00:58:17,810 --> 00:58:20,070
一个是小于3，所以它要穿过那个for循环，

865
00:58:20,070 --> 00:58:23,230
然后我们将看到它再次打印。

866
00:58:23,230 --> 00:58:25,520
我们将再次增加它到2，

867
00:58:25,520 --> 00:58:29,860
和2小于3，所以它会通过for循环，它会打印2。

868
00:58:29,860 --> 00:58:35,100
然后，你会注意到，3不小于3，所以我们会打出来的for循环。

869
00:58:35,100 --> 00:58:40,050
所以，现在我们已经退出了，然后我们将进入机能缺失。

870
00:58:40,050 --> 00:58:45,010
好吧。所以，你必须要注意，这个变量，我们已经创建，

871
00:58:45,010 --> 00:58:48,270
“我”的变量，是不是局部范围。

872
00:58:48,270 --> 00:58:50,280
这意味着，它不是本地的循环，

873
00:58:50,280 --> 00:58:58,060
和变量，我们仍然可以访问并更改之后，它仍然是有效的。

874
00:58:58,060 --> 00:59:02,160
所以，如果你现在进入的功能，你会看到，我们还可以使用'我'的变量，

875
00:59:02,160 --> 00:59:05,320
而且我们要增加'I'+ +。

876
00:59:05,320 --> 00:59:09,410
你可能会认为，首先，基于C，那这就是'我'的变量的副本。

877
00:59:09,410 --> 00:59:12,830
这是一个完全不同的事情，这是正确的。

878
00:59:12,830 --> 00:59:16,560
因此，当我们打印时，我们将打印的“i”+ +，这是会打印出4，

879
00:59:16,560 --> 00:59:19,640
然后我们要 - 对不起。

880
00:59:19,640 --> 00:59:22,030
然后，我们要结束了该功能的，

881
00:59:22,030 --> 00:59:24,820
并且我们将会在那里的箭头是现在。

882
00:59:24,820 --> 00:59:29,190
这意味着，然后，然而，即使该功能改变的“i”的值，

883
00:59:29,190 --> 00:59:32,620
它并没有改变的功能外，

884
00:59:32,620 --> 00:59:35,060
因为该函数有一个单独的范围。

885
00:59:35,060 --> 00:59:38,960
这意味着，当我们回显'我'，它并没有在函数的范围变化，

886
00:59:38,960 --> 00:59:43,660
所以当时我们要再次打印3。

887
00:59:43,660 --> 00:59:47,520
有关范围在PHP中不同的东西比C

888
00:59:47,520 --> 00:59:51,130
>>现在在PHP和HTML。

889
00:59:51,130 --> 00:59:53,510
PHP是用来制作网页的动态。

890
00:59:53,510 --> 00:59:58,660
那种它使事情有所不同。

891
00:59:58,660 --> 01:00:02,090
我们把它与HTML不同。

892
01:00:02,090 --> 01:00:05,230
在HTML中，我们始终只是有相同的静态的东西，像罗布如何表现，

893
01:00:05,230 --> 01:00:09,370
而PHP中，你可以根据用户是谁改变的事情。

894
01:00:09,370 --> 01:00:11,830
所以，如果我有这个，我，“你登录为 - ”，然后名字，

895
01:00:11,830 --> 01:00:14,420
我可以更改名称。所以，现在的名字是约瑟夫，

896
01:00:14,420 --> 01:00:18,880
它具有“关于我”，但后来我也可以改名字有汤米。

897
01:00:18,880 --> 01:00:21,700
而这将是一个不同的事情。

898
01:00:21,700 --> 01:00:23,840
这样的话，我们也可以改变对他的不同的事情，

899
01:00:23,840 --> 01:00:27,070
并且基于该名称将显示不同的内容。

900
01:00:27,070 --> 01:00:31,430
这么说PHP可以种改变什么在你的网站怎么回事。

901
01:00:31,430 --> 01:00:33,540
同样在这里。还是请注意，它们具有不同的内容，

902
01:00:33,540 --> 01:00:38,870
即使你是在技术上还是访问表面上的同一个网页。

903
01:00:38,870 --> 01:00:43,450
生成HTML。有两种不同的方式，你可以做到这一点。

904
01:00:43,450 --> 01:00:48,980
所以我们现在要通过正确的。第一种方法是，你必须 - 是啊，对不起。

905
01:00:48,980 --> 01:00:51,150
所以你只要你经常for循环在PHP中，

906
01:00:51,150 --> 01:00:56,270
然后回响在PHP和你回音了HTML。

907
01:00:56,270 --> 01:00:58,720
用什么罗布显示HTML脚本的你

908
01:00:58,720 --> 01:01:04,030
然后使用PHP打印刚刚打印出来的网页。

909
01:01:04,030 --> 01:01:09,520
另一种方法就是做它，如果你分离出的PHP和HTML。

910
01:01:09,520 --> 01:01:11,940
所以你可以有一个启动循环线的PHP，

911
01:01:11,940 --> 01:01:16,020
那么你可以让HTML的线在一个独立的东西，

912
01:01:16,020 --> 01:01:19,700
然后就结束循环，再次用一个PHP。

913
01:01:19,700 --> 01:01:21,800
所以这是一种分离出来。

914
01:01:21,800 --> 01:01:24,020
在左侧，你可以说你把所有的 - 

915
01:01:24,020 --> 01:01:26,360
这只是1块的PHP。

916
01:01:26,360 --> 01:01:28,510
在右边你可以看到，你有一个行PHP的，

917
01:01:28,510 --> 01:01:32,540
你有一行HTML，和你有一个行PHP的一次。

918
01:01:32,540 --> 01:01:36,870
所以分离出来成为他们在做什么。

919
01:01:36,870 --> 01:01:39,330
而且你会注意到，无论哪种方式，对于其中任何一个，

920
01:01:39,330 --> 01:01:41,980
他们还是打印出来的图像，图像，图像，

921
01:01:41,980 --> 01:01:44,540
使得HTML仍然被印刷的方式相同。

922
01:01:44,540 --> 01:01:49,870
然后你仍然会看到3张图片显示在您的网站上。

923
01:01:49,870 --> 01:01:52,820
所以这是2个不同的做同样的事情的方法。

924
01:01:52,820 --> 01:01:55,060
>>现在我们有形式和要求。正如罗布表明您，

925
01:01:55,060 --> 01:01:59,400
有HTML的形式，我们将只通过这个微风。

926
01:01:59,400 --> 01:02:02,040
你有一个动作，你有一个方法，而你的行动

927
01:02:02,040 --> 01:02:04,350
那种告诉你你要去哪里送呢，而且方法是否

928
01:02:04,350 --> 01:02:06,960
这将是一个GET或POST一个。

929
01:02:06,960 --> 01:02:11,220
和一个GET请求，罗布说，这意味着你要放在一个表格

930
01:02:11,220 --> 01:02:15,760
你会看到它作为一个URL，而POST请求，你不会在URL中看到。

931
01:02:15,760 --> 01:02:17,840
所以，一个细微的差别。

932
01:02:17,840 --> 01:02:19,950
然而，有一点是类似的事情

933
01:02:19,950 --> 01:02:22,560
是POST和GET同样不安全。

934
01:02:22,560 --> 01:02:26,430
所以，你可能会认为只是因为你没有看到它在URL中，

935
01:02:26,430 --> 01:02:28,790
这意味着在POST更安全，

936
01:02:28,790 --> 01:02:34,420
但你仍然可以看到它在你的cookies在你发送的信息。

937
01:02:34,420 --> 01:02:38,260
所以，不要认为对一个或另一个。

938
01:02:38,260 --> 01:02:42,160
另一个要注意的是，你也有部分变量。

939
01:02:42,160 --> 01:02:45,850
你们用这个在pset中7得到你的用户ID信息。

940
01:02:45,850 --> 01:02:48,550
当时的情况是，你可以用这个关联数组，

941
01:02:48,550 --> 01:02:53,310
在$ _SESSION，然后就可以访问不同的东西

942
01:02:53,310 --> 01:02:57,720
并存储整个页面不同的事情。

943
01:02:57,720 --> 01:03:00,750
>>最后一件事是，我们有SQL，结构化查询语言，

944
01:03:00,750 --> 01:03:04,360
这是一种编程语言来管理数据库。

945
01:03:04,360 --> 01:03:08,220
究竟是什么，是数据库？他们是表的集合，

946
01:03:08,220 --> 01:03:10,630
每个表只能有相似的类型的对象。

947
01:03:10,630 --> 01:03:14,990
因此，我们在你的财务pset中有一个用户表。

948
01:03:14,990 --> 01:03:20,610
他们为什么有用？因为它是永久存储信息的一种方式。

949
01:03:20,610 --> 01:03:22,840
这是事物的跟踪和管理事物的一种方式

950
01:03:22,840 --> 01:03:25,890
实际上看到它在不同的页面和跟踪。

951
01:03:25,890 --> 01:03:29,930
而如果你只是存放在那一个瞬间眼前

952
01:03:29,930 --> 01:03:33,720
再后来使用它，你将无法访问您保存任何东西。

953
01:03:33,720 --> 01:03:37,660
我们有我们使用的SQL命令4件大事。

954
01:03:37,660 --> 01:03:40,190
我们有选择，插入，删除和更新。

955
01:03:40,190 --> 01:03:42,880
这些都是非常重要的，你们要知道你的测验。

956
01:03:42,880 --> 01:03:45,990
>>我们将快速选择现在。

957
01:03:45,990 --> 01:03:48,540
基本上，你从数据库中选择行。

958
01:03:48,540 --> 01:03:52,400
所以，如果你有，就在这里 - 

959
01:03:52,400 --> 01:03:56,740
我们有这2个不同的东西，我们希望从类表选择

960
01:03:56,740 --> 01:04:01,480
其中真棒 - 凡在真棒列中的值是1。

961
01:04:01,480 --> 01:04:04,460
所以，你可以在这里看到，我们有这2个东西的类名，

962
01:04:04,460 --> 01:04:08,490
CS50和Stat110，并且我们有一流的ID和口号。

963
01:04:08,490 --> 01:04:13,150
所以，我们要选择所有的信息。

964
01:04:13,150 --> 01:04:17,480
然后，你可以看到在这里种，它的挑选出真棒列，

965
01:04:17,480 --> 01:04:25,170
那里所有的东西都是1，然后将其拥有的类ID，类名和口号，它可以挑选出。

966
01:04:25,170 --> 01:04:28,100
你是做这个的代码究竟怎么了？你必须使用PHP。

967
01:04:28,100 --> 01:04:33,830
所以这是怎么样的PHP和SQL是相互关联的。

968
01:04:33,830 --> 01:04:38,130
现在，我们有我们的代码，我们将使用我们的查询功能

969
01:04:38,130 --> 01:04:41,370
因为我们没有在PSET 7，和我们要执行的SQL查询。

970
01:04:41,370 --> 01:04:43,870
然后，我们就要有 - 

971
01:04:43,870 --> 01:04:46,280
我们总要检查，如果行的三重平等的，如果为false。

972
01:04:46,280 --> 01:04:49,010
所以，再一次，你要检查的类型和价值，

973
01:04:49,010 --> 01:04:53,880
然后，如果它不工作，那么你要道歉，像往常一样，就像我们在PSET 7一样。

974
01:04:53,880 --> 01:04:55,870
否则，你经历的一切与方便要循环

975
01:04:55,870 --> 01:04:59,410
foreach循环，我们只是走过去。

976
01:04:59,410 --> 01:05:01,280
现在，我们正在遍历和我们过去做了，

977
01:05:01,280 --> 01:05:05,080
让我们假设我们的查询过去了，现在我们有我们的foreach循环。

978
01:05:05,080 --> 01:05:11,050
和第一行有，所以这里的行，就在这里，它的盒装。

979
01:05:11,050 --> 01:05:14,010
这将打印出所有它得到的信息。

980
01:05:14,010 --> 01:05:18,070
所以它会打印出在底部“想学HTML吗？”

981
01:05:18,070 --> 01:05:23,370
然后它会去到下一行，因为它完成了第一个for循环，

982
01:05:23,370 --> 01:05:26,510
等等然后它会打印出它的第二行，

983
01:05:26,510 --> 01:05:32,120
这将是STAT110，查找所有的时刻。

984
01:05:32,120 --> 01:05:34,290
>>最后一件事是对的SQL漏洞。

985
01:05:34,290 --> 01:05:37,300
我知道大卫在这感动的演讲一点点。

986
01:05:37,300 --> 01:05:40,730
您可以稍后阅读。这真的很有趣。

987
01:05:40,730 --> 01:05:45,320
SQL注入是一种棘手的事情。

988
01:05:45,320 --> 01:05:49,890
比方说，你只是这些变量坚持正确进入您的查询，

989
01:05:49,890 --> 01:05:52,290
你可以在第一行看到。

990
01:05:52,290 --> 01:05:54,520
因此，它似乎罚款，对不对？你只是把在用户名

991
01:05:54,520 --> 01:05:58,820
和密码到您的SQL查询，并且要出货其关闭，并获得无论是在你的数据表。

992
01:05:58,820 --> 01:06:01,450
这似乎很简单。因此，可以说有人把中，

993
01:06:01,450 --> 01:06:04,910
输入密码，这或文字在这里 - 

994
01:06:04,910 --> 01:06:06,780
实际上应该是在红色框。

995
01:06:06,780 --> 01:06:11,920
所以我们说，他们把该密码进入 - 这就是他们进入。

996
01:06:11,920 --> 01:06:16,520
所以他们把或“1”= 1。

997
01:06:16,520 --> 01:06:20,880
样一个愚蠢的密码有。

998
01:06:20,880 --> 01:06:25,070
现在，让我们只需更换它，你会注意到，在S​​QL查询现在，

999
01:06:25,070 --> 01:06:29,090
它的计算结果总是正确的，因为你会注意到，

1000
01:06:29,090 --> 01:06:32,240
你可以在SQL查询中选择所有这些信息

1001
01:06:32,240 --> 01:06:35,420
或者你可以有1 = 1。

1002
01:06:35,420 --> 01:06:41,030
所以这总是会评估为true。

1003
01:06:41,030 --> 01:06:46,610
这不会对真正的工作，因为这意味着黑客可以侵入你的系统。

1004
01:06:46,610 --> 01:06:49,300
该解决方案是，你必须使用PDO的系统，

1005
01:06:49,300 --> 01:06:51,360
这意味着你必须使用问号，

1006
01:06:51,360 --> 01:06:53,350
这是你在​​pset中7人使用，

1007
01:06:53,350 --> 01:06:57,620
你要去的地方使用一个问号的地方，你想放的东西，

1008
01:06:57,620 --> 01:07:01,430
然后你将有一个逗号，然后你就会有后，

1009
01:07:01,430 --> 01:07:07,610
你的字符串后，您希望不同的变量替换成你的问号。

1010
01:07:07,610 --> 01:07:10,330
所以，你会注意到在这里，现在我有这些红色的问号。

1011
01:07:10,330 --> 01:07:15,420
然后，我把我的琴弦后，变量，所以我知道他们更换的顺序之后。

1012
01:07:15,420 --> 01:07:18,470
这将确保如果有人确实是这样的，

1013
01:07:18,470 --> 01:07:24,050
并且他们有或1 = 1的情况下，这将确保，

1014
01:07:24,050 --> 01:07:30,490
在后端，确保它不会真正打破SQL查询。

1015
01:07:30,490 --> 01:07:33,660
好了，所以这是相当多了，PHP和SQL的旋风。

1016
01:07:33,660 --> 01:07:41,520
好运来各位的，现在到俄勒冈州

1017
01:07:41,520 --> 01:07:44,270
>> [Oreoluwatomiwa Babarinsa]好了大家。走的时候了一些JavaScript

1018
01:07:44,270 --> 01:07:48,840
和其他一些东西非常快，所以我们不耽误你了今晚。

1019
01:07:48,840 --> 01:07:56,930
JavaScript的。是。 JavaScript是一种一件很酷的事情，据称。

1020
01:07:56,930 --> 01:07:59,090
你真的需要知道关于JavaScript的事情，它有点像

1021
01:07:59,090 --> 01:08:03,810
为你的web应用程序将是做客户端。

1022
01:08:03,810 --> 01:08:08,280
有一些事情你只是不想把所有的时间护理在服务器端。

1023
01:08:08,280 --> 01:08:12,880
所有的小互动，突出的一件事，使东西消失。

1024
01:08:12,880 --> 01:08:15,340
你真的不希望有跟你的服务器的所有时间的。

1025
01:08:15,340 --> 01:08:18,069
而一些甚至不是可以做到在服务器端。

1026
01:08:18,069 --> 01:08:21,899
这就是为什么我们需要类似的JavaScript。

1027
01:08:21,899 --> 01:08:24,359
关于JavaScript很酷的事情：它是动态类型。

1028
01:08:24,359 --> 01:08:27,149
这句话的意思是，你的程序并不需要知道

1029
01:08:27,149 --> 01:08:30,970
究竟是什么，该变量是当你写出来。

1030
01:08:30,970 --> 01:08:34,510
排序它会只是弄清楚，因为它的运行。

1031
01:08:34,510 --> 01:08:37,520
这是很酷的吧其他的东西：这是一个大括号的语言，

1032
01:08:37,520 --> 01:08:41,359
这意味着语法类似于C和PHP。

1033
01:08:41,359 --> 01:08:47,050
你不必做太多的返工，当你学习JavaScript。

1034
01:08:47,050 --> 01:08:49,180
在这里，我们有一个JavaScript的一点点。

1035
01:08:49,180 --> 01:08:52,560
有趣的事情在这里是，如果你看一下吧，

1036
01:08:52,560 --> 01:08:56,330
我们有一点JavaScript有权利在head标签。

1037
01:08:56,330 --> 01:08:59,479
什么是它基本上只包含一个JavaScript文件。

1038
01:08:59,479 --> 01:09:02,260
这是一种方式你可以包含JavaScript到你的程序。

1039
01:09:02,260 --> 01:09:06,910
那么第二个点点实际上是一些内嵌的JavaScript，

1040
01:09:06,910 --> 01:09:10,790
非常类似于使用CSS内联样式，

1041
01:09:10,790 --> 01:09:16,180
而你只是写一些代码很快出现。

1042
01:09:16,180 --> 01:09:18,120
JavaScript有数组。

1043
01:09:18,120 --> 01:09:20,850
只是另一种方式来保持数据周围，非常有用。

1044
01:09:20,850 --> 01:09:25,180
非常好，容易语法。

1045
01:09:25,180 --> 01:09:29,870
您可以使用方括号来访问一切，把一切都在一起。

1046
01:09:29,870 --> 01:09:35,020
没有什么太复杂。

1047
01:09:35,020 --> 01:09:38,630
关于JavaScript和脚本语言一般很酷的事情

1048
01:09:38,630 --> 01:09:40,920
是，你不必担心数组的大小。

1049
01:09:40,920 --> 01:09:43,880
你可以只使用array.length，并保持它的轨道，

1050
01:09:43,880 --> 01:09:46,960
也是数组可以增大或缩小，因为你需要它。

1051
01:09:46,960 --> 01:09:49,279
所以你甚至不需要担心任何形式的，

1052
01:09:49,279 --> 01:09:57,050
哦，不，我需要分配更多的东西，或者类似的东西。

1053
01:09:57,050 --> 01:10:00,090
>>这里很酷的事情是，JavaScript有一些所谓的对象。

1054
01:10:00,090 --> 01:10:04,800
这是一种面向对象的语言，因此它已经是，本质上，

1055
01:10:04,800 --> 01:10:10,100
一个方法可以让你组数据放在一起，有点类似于一个结构，

1056
01:10:10,100 --> 01:10:17,280
但你可以访问它像一个结构或一个关联数组的语法。

1057
01:10:17,280 --> 01:10:22,520
这是很简单，你可以用这个做的是组数据一起

1058
01:10:22,520 --> 01:10:24,810
如果你有一堆数据的的关联。

1059
01:10:24,810 --> 01:10:26,850
因为它是所有你需要描述一辆车的事情，

1060
01:10:26,850 --> 01:10:29,050
你不需要把它在一堆不同的地方。

1061
01:10:29,050 --> 01:10:35,300
您只需把它贴到JavaScript中对象1。

1062
01:10:35,300 --> 01:10:39,090
正如你可能知道，迭代是那些繁琐的任务之一。

1063
01:10:39,090 --> 01:10:43,810
你只需做一遍过。你需要跟每一个对象在车上，

1064
01:10:43,810 --> 01:10:47,340
或者你需要通过每一个项目列表或类似的东西。

1065
01:10:47,340 --> 01:10:51,770
所以，JavaScript有，类似于PHP的，一个foreach语法。

1066
01:10:51,770 --> 01:10:54,590
在这种情况下，它是一个用于在回路。

1067
01:10:54,590 --> 01:10:57,300
你想只在对象使用这个。

1068
01:10:57,300 --> 01:11:01,030
还有，如果你使用这个阵列上所发生的一些问题。

1069
01:11:01,030 --> 01:11:03,750
它一般是其中的一件事情，虽然，这是非常有用的，

1070
01:11:03,750 --> 01:11:06,590
因为你消除大量的开销

1071
01:11:06,590 --> 01:11:10,270
因为你没有自己拉起来一切都在你的对象。

1072
01:11:10,270 --> 01:11:12,300
你不必记住所有的键名。

1073
01:11:12,300 --> 01:11:18,270
你只是有点让他们回到这个语法。

1074
01:11:18,270 --> 01:11:21,500
在此，对，你只是要记住

1075
01:11:21,500 --> 01:11:27,180
你得到回所有的钥匙，在一个非常类似的方式来哈希表。

1076
01:11:27,180 --> 01:11:30,880
如果从记住，当你想放在一个字符串，你可以得到的东西

1077
01:11:30,880 --> 01:11:33,840
这将具有与其相关联的值。

1078
01:11:33,840 --> 01:11:36,360
你可以用这个做的是，你可以说，没事，

1079
01:11:36,360 --> 01:11:42,120
我把一辆车，我把它叫做一个法拉利。

1080
01:11:42,120 --> 01:11:45,290
所以，你可以把字符串法拉利再续前缘，你可以得到这一点。

1081
01:11:45,290 --> 01:11:50,000
你也可以这样做，在一个循环中，在循环的。

1082
01:11:50,000 --> 01:11:53,320
所以只是更多的对象。从此，你需要记住的关键一点

1083
01:11:53,320 --> 01:12:00,340
是，你可以使用该对象结构的语法，只要你想用这些，

1084
01:12:00,340 --> 01:12:04,590
除非你有什么打算作为一个字符串使用的是不是一个有效的变量名。

1085
01:12:04,590 --> 01:12:07,650
所以，如果你看一下，有，我们有空格键。

1086
01:12:07,650 --> 01:12:12,500
好吧，如果你把object.key，空间，与空间，空间，

1087
01:12:12,500 --> 01:12:15,320
只是没有意义语法。

1088
01:12:15,320 --> 01:12:22,730
所以，你唯一能做的，随着这种支架的语法。

1089
01:12:22,730 --> 01:12:26,520
>>此外，JavaScript是非常适用范围，明智的PHP。

1090
01:12:26,520 --> 01:12:29,050
你有2种方式解决范围。

1091
01:12:29,050 --> 01:12:31,960
你不能有变种在变量的前面，

1092
01:12:31,960 --> 01:12:34,060
那只是意味着这是全球性的。

1093
01:12:34,060 --> 01:12:37,050
你可以从任何地方看到它。即使你是把这个在if语句中，

1094
01:12:37,050 --> 01:12:42,430
其他地方在你的代码这一点后，你可以看到这个变量。

1095
01:12:42,430 --> 01:12:46,730
另一件事，虽然是用var，它是有限的，以什么功能你英寸

1096
01:12:46,730 --> 01:12:48,870
如果你不是在一个函数，那么，它是全球性的。

1097
01:12:48,870 --> 01:12:53,900
但如果你是在一个函数中，这只是该函数内可见。

1098
01:12:53,900 --> 01:12:56,420
我没有一个例子，但是，是的。这是其中的一件事情，其中

1099
01:12:56,420 --> 01:12:59,900
你可以管理你想成为全球哪些变量，

1100
01:12:59,900 --> 01:13:03,810
你想成为本地的，但你必须要小心这个变量，

1101
01:13:03,810 --> 01:13:06,890
因为你不具备细粒度控制你在C语言中的类型，

1102
01:13:06,890 --> 01:13:15,820
在那里，如果事情是在一个声明for循环，它会留在那个for循环。

1103
01:13:15,820 --> 01:13:18,790
我们真正关心使用JavaScript的事情是操纵网页，对不对？

1104
01:13:18,790 --> 01:13:21,800
我的意思是，这就是为什么我们正在这样做。

1105
01:13:21,800 --> 01:13:23,840
>>为了做到这一点，我们使用一种叫做DOM。

1106
01:13:23,840 --> 01:13:25,850
文档对象模型。

1107
01:13:25,850 --> 01:13:29,430
基本上，它的作用是它需要所有的HTML

1108
01:13:29,430 --> 01:13:34,110
它的模型伸到了一堆相互嵌套那些对象。

1109
01:13:34,110 --> 01:13:37,080
你的东西是这样开始了。

1110
01:13:37,080 --> 01:13:44,770
你有，就适合我，一堆代码，在那里，有几分 - 

1111
01:13:44,770 --> 01:13:46,640
你可能会认为这会是很难操纵，

1112
01:13:46,640 --> 01:13:48,700
因为你会透过一堆文字解析

1113
01:13:48,700 --> 01:13:52,080
并有拼凑分开的东西。而如果它没有正确格式化？

1114
01:13:52,080 --> 01:13:54,880
不好的事情会发生。

1115
01:13:54,880 --> 01:13:58,140
因此，JavaScript的需要照顾的为你，你会得到一个很好的数据结构，

1116
01:13:58,140 --> 01:14:01,390
像一个在我左边，在那里你只是有一个文件，

1117
01:14:01,390 --> 01:14:03,530
并且里面，你有一些所谓的HTML，

1118
01:14:03,530 --> 01:14:05,600
并且里面你有一个头和身体，

1119
01:14:05,600 --> 01:14:08,420
而且脑袋里面你有一个标题，等等，等等，等等。

1120
01:14:08,420 --> 01:14:11,810
这简化了操作的Web页面，以便它只是，

1121
01:14:11,810 --> 01:14:14,190
哦，我只是想谈谈这个对象。

1122
01:14:14,190 --> 01:14:21,340
排序的一个非常类似的方式，你会跟你做自己的另一对象。

1123
01:14:21,340 --> 01:14:25,980
就像我说的，所有的DOM是文档对象。

1124
01:14:25,980 --> 01:14:29,290
或者它只是一个地方，那么你可以去在它里面找到的东西，

1125
01:14:29,290 --> 01:14:33,880
你可以做到这一点 - 这是旧的风格做，在那里的，

1126
01:14:33,880 --> 01:14:38,130
你在那里做的document.getElementById，然后将名称，

1127
01:14:38,130 --> 01:14:42,420
正如你可能会说，这得到了一段时间后，很笨重。

1128
01:14:42,420 --> 01:14:44,480
所以，你可能不希望这样做。这就是为什么我们有

1129
01:14:44,480 --> 01:14:48,760
我们将在此之后谈论未来的事情。

1130
01:14:48,760 --> 01:14:52,510
这里的关键是，没事，你拥有所有这些元素，对不对？

1131
01:14:52,510 --> 01:14:56,400
所以也许我可以改变的页面加载时的东西的颜色。

1132
01:14:56,400 --> 01:14:58,380
还等什么？如果我的用户点击的东西？

1133
01:14:58,380 --> 01:15:00,540
我想要它做的一些有趣的事情，当他们点击什么。

1134
01:15:00,540 --> 01:15:02,600
这就是为什么我们有活动。

1135
01:15:02,600 --> 01:15:05,330
可以，基本上，找到DOM中的任何元素，

1136
01:15:05,330 --> 01:15:08,560
然后说，嘿。当此负载或有人点击它，

1137
01:15:08,560 --> 01:15:11,410
或者当他们鼠标移到它，用它做什么。

1138
01:15:11,410 --> 01:15:15,330
和你有什么，你有函数处理这个给你。

1139
01:15:15,330 --> 01:15:17,980
这些函数是事件处理程序。

1140
01:15:17,980 --> 01:15:20,440
什么不着痕迹 - 它的说法只是一种奇特的方式，

1141
01:15:20,440 --> 01:15:23,500
当这种事件发生，此功能仅执行。

1142
01:15:23,500 --> 01:15:28,070
因此处理时发生的事件。

1143
01:15:28,070 --> 01:15:30,810
这是你将如何布置一个事件处理程序。

1144
01:15:30,810 --> 01:15:34,750
我有一些按钮，当你点击它，它爆炸。

1145
01:15:34,750 --> 01:15:40,560
所以，不要单击该按钮。

1146
01:15:40,560 --> 01:15:42,910
这是接近它的方法之一，对不对？

1147
01:15:42,910 --> 01:15:46,430
你有一个按钮标签，并在点击你有一个字符串，上面写着：

1148
01:15:46,430 --> 01:15:50,460
哦，顺便说一下，我这样做是爆炸事情对我来说。

1149
01:15:50,460 --> 01:15:53,990
否则，它就像你刚才做了一个常规按钮。

1150
01:15:53,990 --> 01:15:56,550
您也可以做到这一点的另一种方式，

1151
01:15:56,550 --> 01:16:02,770
通过抓取DOM元素，但我们会拯救我们谈论的jQuery之后。

1152
01:16:02,770 --> 01:16:07,580
>> jQuery的：它是一个库，它是跨浏览器。

1153
01:16:07,580 --> 01:16:09,580
你可以在几乎任何使用它。

1154
01:16:09,580 --> 01:16:12,090
它只是给你很多的工具一起工作。

1155
01:16:12,090 --> 01:16:15,850
因为JavaScript虽然强大，没有您需要的所有工具

1156
01:16:15,850 --> 01:16:20,550
开箱真正解决一个web应用程序中你可能想要做的。

1157
01:16:20,550 --> 01:16:24,650
因此，它简化了很多东西，给你很多的功能

1158
01:16:24,650 --> 01:16:28,760
出，你通常会需要重新写自己，一遍又一遍又一遍的方块。

1159
01:16:28,760 --> 01:16:31,600
而只是使事情非常简单。

1160
01:16:31,600 --> 01:16:35,780
你也有选择，这让你把所有这些元素

1161
01:16:35,780 --> 01:16:42,800
从你的DOM更简单的，而不必使用这些很长的函数调用。

1162
01:16:42,800 --> 01:16:46,630
更多关于这些选择。你有，在那里你有，让我们说

1163
01:16:46,630 --> 01:16:49,800
我想获得一个元素ID为“岩石”。

1164
01:16:49,800 --> 01:16:56,450
那么，在jQuery的，它只是$，然后在出现一斤的字符串，然后“石头”。

1165
01:16:56,450 --> 01:17:01,960
这很简单，不是解决这个问题的传统的JavaScript方法快了很多。

1166
01:17:01,960 --> 01:17:06,120
和你有类和元素类型类似的事情。

1167
01:17:06,120 --> 01:17:08,140
jQuery是 - 凉爽的特点之一是某种可以压缩

1168
01:17:08,140 --> 01:17:14,350
您的查询您的DOM非常，非常快。

1169
01:17:14,350 --> 01:17:18,980
现在，我们又回到了事件处理，这是你将如何处理jQuery的一个事件。

1170
01:17:18,980 --> 01:17:23,090
所以我们要在这里是什么我们说，没事的。我有一个脚本标记，对不对？

1171
01:17:23,090 --> 01:17:25,400
所以，我有这个内嵌的JavaScript。

1172
01:17:25,400 --> 01:17:27,750
我们现在要做的是我们要去说，没事。

1173
01:17:27,750 --> 01:17:30,860
当文档准备，这意味着该文件的加载，

1174
01:17:30,860 --> 01:17:34,660
我们要去的那个函数，并且我们会说，没事，

1175
01:17:34,660 --> 01:17:37,060
这个功能实际上是做别的事情。

1176
01:17:37,060 --> 01:17:42,320
它基本上是说，没事的，让我的ID的元素“身份识别码”。

1177
01:17:42,320 --> 01:17:47,960
然后给这个，当你点击它执行的功能的处理程序。

1178
01:17:47,960 --> 01:17:49,820
基本上，这是什么做的是，它说，所有的权利。

1179
01:17:49,820 --> 01:17:52,630
在页面加载，所以我要在，找到这个元素，

1180
01:17:52,630 --> 01:17:56,420
给它这个事件处理程序，它基本上设置页面为您服务。

1181
01:17:56,420 --> 01:18:00,520
这是你想怎么去想事件处理。

1182
01:18:00,520 --> 01:18:06,310
你只需要考虑一下，没事的时候发生的东西，我想要什么发生？

1183
01:18:06,310 --> 01:18:10,520
你不想去想，好吧，我需要确保这件事情要谈这件事情，

1184
01:18:10,520 --> 01:18:14,660
这个东西等等等等，因为你只是想谈的事情在活动方面。

1185
01:18:14,660 --> 01:18:17,650
当此情况发生时，发生这种情况。当此情况发生时，发生这种情况。

1186
01:18:17,650 --> 01:18:20,240
如果事情引发其他的事情，这是伟大的。

1187
01:18:20,240 --> 01:18:22,150
但是，你不想尝试做复杂的代码

1188
01:18:22,150 --> 01:18:24,130
您要去哪里触发多个事物的同时，

1189
01:18:24,130 --> 01:18:28,860
因为你只是给自己一个头痛的问题。

1190
01:18:28,860 --> 01:18:32,340
>>所有权利。现在，我们可以得到我们的页面来处理事件，

1191
01:18:32,340 --> 01:18:35,640
但让我们说我的用户点击一个按钮。

1192
01:18:35,640 --> 01:18:38,040
如果我想这一请求发送回服务器，

1193
01:18:38,040 --> 01:18:41,100
但我不想重新载入页面，因为不必重新加载一个新的页面

1194
01:18:41,100 --> 01:18:44,390
每一次得到种繁琐，为什么我需要

1195
01:18:44,390 --> 01:18:47,430
拉下头又一次，又一次页脚，

1196
01:18:47,430 --> 01:18:49,670
而页面的所有再次要素

1197
01:18:49,670 --> 01:18:53,180
刚刷新的问候语或时间？

1198
01:18:53,180 --> 01:18:55,290
所以这就是为什么我们有类似的Ajax。

1199
01:18:55,290 --> 01:18:59,150
我们可以使用Ajax在这里做的是，我们可以说，没事，

1200
01:18:59,150 --> 01:19:01,290
我要一些数据发送到服务器时，

1201
01:19:01,290 --> 01:19:04,010
我想获得回应，所以我可以更新我的网页，

1202
01:19:04,010 --> 01:19:12,120
或者只是做一些算法计算，这并不一定显示任何内容给用户。

1203
01:19:12,120 --> 01:19:15,500
你有什么需要做的？那么，你需要你需要跟一个URL。

1204
01:19:15,500 --> 01:19:18,650
您的服务器无法奇迹般地从无处收听。

1205
01:19:18,650 --> 01:19:21,960
你需要有你要发送这个数据到一个特定的地方。

1206
01:19:21,960 --> 01:19:26,240
而且你还需要一些数据要发送，或者也许这是一个无数据的查询。

1207
01:19:26,240 --> 01:19:31,380
你只是想要Ping回服务器，说，哎，我还活​​着，或者类似的东西。

1208
01:19:31,380 --> 01:19:35,150
然后你想要一个函数，基本上处理与成功。

1209
01:19:35,150 --> 01:19:38,250
比方说，你从你的服务器取回一些信息，

1210
01:19:38,250 --> 01:19:42,960
并且要更改用户的标题上他们的网页。

1211
01:19:42,960 --> 01:19:44,930
所以，你会得到信息反馈，

1212
01:19:44,930 --> 01:19:48,860
而你将推动该到屏幕上。

1213
01:19:48,860 --> 01:19:51,170
什么情况是，当页面准备就绪，

1214
01:19:51,170 --> 01:19:56,500
你为这个按钮叫迎宾创建的点击功能。

1215
01:19:56,500 --> 01:19:58,810
这是什么然后做的是，当按下该按钮，

1216
01:19:58,810 --> 01:20:03,700
你跟greetings.php，你犯了一个POST请求，

1217
01:20:03,700 --> 01:20:07,290
和你说，哎，让我从你的网页的东西。

1218
01:20:07,290 --> 01:20:09,890
我们并不真的需要来形容，但greetings.php，

1219
01:20:09,890 --> 01:20:12,480
我们只能说，给后面的“hello world”。

1220
01:20:12,480 --> 01:20:15,650
因此，我们得到这回的“hello world”，并在这一成功，

1221
01:20:15,650 --> 01:20:20,730
假设一切正常，那么我们只要到这个目标的地方

1222
01:20:20,730 --> 01:20:25,720
我们指定的，我们只是坚持的响应在那里。

1223
01:20:25,720 --> 01:20:31,560
这是建立一个Ajax查询的一个非常简单的方法。

1224
01:20:31,560 --> 01:20:34,340
>>很快，罗布那种提到这个已经，

1225
01:20:34,340 --> 01:20:37,170
事情都可能出错，坏事情都可能发生，

1226
01:20:37,170 --> 01:20:42,660
所以你要熟悉这些HTTP响应代码。

1227
01:20:42,660 --> 01:20:46,030
这是什么意思，只是，像200，一切正常。

1228
01:20:46,030 --> 01:20:48,670
别的东西，不好的事情发生了。

1229
01:20:48,670 --> 01:20:50,790
它通常你想记住的东西。

1230
01:20:50,790 --> 01:20:53,440
但它是很好的知道所有的这些。

1231
01:20:53,440 --> 01:20:55,970
最后，一​​旦我们通过了这一切消失了，

1232
01:20:55,970 --> 01:20:58,680
我们需要谈谈很快对设计，

1233
01:20:58,680 --> 01:21:00,620
然后我们就可以让大家都离开了。

1234
01:21:00,620 --> 01:21:03,410
设计。你要记住的东西。

1235
01:21:03,410 --> 01:21:06,950
问问自己这些问题：谁将会使用这个？

1236
01:21:06,950 --> 01:21:09,580
他们会怎么使用它呢？什么我的用户关心的？

1237
01:21:09,580 --> 01:21:11,750
什么他们不关心？

1238
01:21:11,750 --> 01:21:14,500
你只是不想让一个应用程序，让它刚长出

1239
01:21:14,500 --> 01:21:18,270
并成为这个巨大的，所有费力的事情，你甚至不能完成。

1240
01:21:18,270 --> 01:21:23,900
你想拥有你想要解决离散的目标和计划与事。

1241
01:21:23,900 --> 01:21:29,000
使其毫不费力。所有这一切说，基本上

1242
01:21:29,000 --> 01:21:34,950
很容易让用户使用它，不让它文本的巨型一滴这样的幻灯片是，其实。

1243
01:21:34,950 --> 01:21:38,020
你只是希望它是什么它是非常容易有人进去

1244
01:21:38,020 --> 01:21:40,800
，做他们想做的事情。

1245
01:21:40,800 --> 01:21:42,920
你不希望他们有浏览5页

1246
01:21:42,920 --> 01:21:45,460
去你的网站的主要功能。

1247
01:21:45,460 --> 01:21:49,290
如果谷歌有5个页面之前，你甚至可以搜索一些东西，

1248
01:21:49,290 --> 01:21:53,080
没有人会使用它。

1249
01:21:53,080 --> 01:21:55,890
最后，纸上原型，焦点小组。

1250
01:21:55,890 --> 01:21:59,220
有良好的设计和测试实践。

1251
01:21:59,220 --> 01:22:00,730
只是因为你觉得你的作品，

1252
01:22:00,730 --> 01:22:04,860
不意味着别人想它的工作原理。

1253
01:22:04,860 --> 01:22:14,490
但是，是的，就是这样。

1254
01:22:14,490 --> 01:22:17,490
[CS50.TV]