1
00:00:00,000 --> 00:00:02,270
[Powered by Google Translate] [評論：測驗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
我只是把整數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
那麼，什麼是我應該做的第一件事情嗎？好吧，我應該newnode的malloc上，

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
如果我試圖排隊在這裡，我會覆蓋上一次的位置

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使用模。

173
00:10:22,040 --> 00:10:29,090
您可以嘗試在家裡明白你為什麼會做q.size + q.head

174
00:10:29,090 --> 00:10:31,080
模的能力，但如果你在這裡檢查，

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。 >>習題集，是的。由於搶劫。

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
要翻譯的關鍵，每一個整數索引。

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
所以，我知道，我想在24個存儲B.哈里森。

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首先，我要去看，是7大於或小於5？

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
所以int 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
我們將不得不做的第一件事是檢查，如果根是NULL。

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
所以，我應該使用else if和else if人在這裡嗎？

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
一試的是樹的數組。

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
只是有名字的人有B.

283
00:17:32,510 --> 00:17:37,960
這是很容易實現的，使用一個嘗試，例如。

284
00:17:37,960 --> 00:17:39,820
你如何定義一個節點在一個try？

285
00:17:39,820 --> 00:17:43,910
你只需要一個布爾值，將是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
我有一個布爾值，表示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
如果我想補充的'a'到本字典，那麼我有什麼關係？

302
00:18:46,320 --> 00:18:49,760
我只想有對malloc一個新的節點為'A'，

303
00:18:49,760 --> 00:18:54,630
然後添加其字為true。

304
00:18:54,630 --> 00:19:00,180
因此，它只是表示'A'是真實的。有意義嗎？

305
00:19:00,180 --> 00:19:04,120
然後，如果我想，我將不得不對malloc 1'B'添加'BA'，

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'，然後去為'a'，和我看到真正的，所以它是一個單詞。有意義嗎？

315
00:19:38,010 --> 00:19:41,950
很多人都感到困惑的嘗試。不是嗎？

316
00:19:41,950 --> 00:19:44,740
>> 最後，霍夫曼編碼。霍夫曼編碼是非常有用的

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
每單 - 我們的ASCII表中的256個字符，是不是很理想，

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
我如何使用Huffman編碼？

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
你會重複，直到你只有一棵樹在森林裡。

341
00:21:18,930 --> 00:21:23,840
因此，讓我們來看看你會怎麼做一個Huffman樹ZAMYLA。

342
00:21:23,840 --> 00:21:29,220
您可以在這裡看到，除了'A'，所有的字母頻率1，頻率為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
所以，這一切對我來說，Rob的接管。

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庫，然後HTTP，HTML，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
我們將在很快在這裡，但它是很好的知道，這些都是存在的。

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，完全翻轉所有的“0”和所有“0”到“1”。

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個二進制數字，這兩個數字

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
因此，在左側，我們有a 1和a 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
你能想到的，就像你的邏輯的口服補液鹽。

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
在這裡，如果我們資本與OX20'A'，

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。因此分裂成二進制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，因為剛剛O型環'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
“A”。因為這是目前的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的情況下是不與異或。

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
'A'^ 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'，和我們的'A'已經變成了'“。

491
00:33:33,280 --> 00:33:36,910
因此，XOR，只是翻轉的情況下是一個非常方便的方法。

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左移，這給了我們104。

502
00:34:24,699 --> 00:34:32,530
所以左移，我們在這裡看到的，基本上是X << Y X * 2 ^ Y。

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
我們只是把8位4的地方，

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 ^ y的

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
為foo回去，我要回去的地方，黑客想要我回去。

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
因此，我們必須char *字符串，這就是抽象，我們吹去

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
X將獲取存儲在字符，

637
00:43:59,620 --> 00:44:06,410
sscanf函數將返回2，我們將重試，因為我們只想要一個整數。

638
00:44:06,410 --> 00:44:09,810
>> 快速通過HTTP，HTML，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 OK。

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
>> 下HTTP，TCP / IP是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
所以，如果你鍵入一個URL，IP地址，

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
我們的最後一件事是港口，這是TCP IP的一部分。

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
每個應用程序獲取特定的端口，它可以聽上，

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層疊樣式表（Cascading Style Sheets）。

716
00:49:32,010 --> 00:49:36,030
我們的風格，而不是HTML與CSS的網頁。

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
第一個例子是我們身體相匹配標籤，

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個等號，等號。

766
00:52:47,280 --> 00:52:49,990
行，有沒有4等號，但也有2和3。

767
00:52:49,990 --> 00:52:53,320
您可以使用等號（=）檢查值。

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
我有迴聲，空間字符串2串1。

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
，現在它是KEY1，KEY2，KEY3，他們在雙引號，以表示他們的所有字符串。

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 num將舉行，，然後也許將舉行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
然後，我們要增加它的循環，

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，所以我們將擺脫的循環。

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
所以，當我們打印時，我們將​​打印'我'+ +，這是要打印出來，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
這意味著，當我們使用echo'我'，它並沒有改變在職能範圍的，

886
00:59:38,960 --> 00:59:43,660
這樣的話，我們要再次打印3。

887
00:59:43,660 --> 00:59:47,520
C.比範圍在PHP不同的事情

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。有2種不同的方式，你可以做到這一點。

904
01:00:43,450 --> 01:00:48,980
因此，我們將通過正確的現在。第一種方法是，你 - 是啊，對不起。

905
01:00:48,980 --> 01:00:51,150
所以，你只需要您的正常循環在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
所以這是兩種不同的方式做同樣的事情。

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
我們有4個重要的事情，我們使用的SQL命令。

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
我們有這兩個不同的東西，我們要選擇的類別表

960
01:03:56,740 --> 01:04:01,480
真棒 - 在的真棒列的值是1。

961
01:04:01,480 --> 01:04:04,460
所以，你可以在這裡看到，我們有兩件事情的類名，

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
我們總是要檢查，如果行的三重平等的，如果假的。

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
所以他們把OR“1”= 1。

997
01:06:16,520 --> 01:06:20,880
類有一個愚蠢的密碼。

998
01:06:20,880 --> 01:06:25,070
現在，讓我們只是取代它，你會注意到，在現在的SQL查詢，

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。

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
你不能有前面的變量VAR，

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
這簡化了操縱網頁，因此，它只是，

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“MYID。”

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
因此，我們得到這個“世界你好”，並在此成功的，

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
很容易讓用戶使用它，不讓它喜歡這張幻燈片，實際上是一個巨大的blob的文字。

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]