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]