1
00:00:00,000 --> 00:00:02,750
[Powered by Google Translate] [第9條] [舒適]

2
00:00:02,750 --> 00:00:04,750
羅布·鮑登] [哈佛大學]

3
00:00:04,750 --> 00:00:06,750
這是CS50。[CS50.TV]

4
00:00:06,750 --> 00:00:12,130
>> 好的。基本上，今天這一切都取決於你們問的一些問題。

5
00:00:12,130 --> 00:00:15,070
一些主題，我也許可以漫步

6
00:00:15,070 --> 00:00:17,570
一下，如果沒有人有任何問題要問。

7
00:00:17,570 --> 00:00:20,660
希望你這樣做。有沒有人有什麼問題嗎？

8
00:00:20,660 --> 00:00:25,220
從過去的測驗，也許事情你不舒服與目前。

9
00:00:34,630 --> 00:00:37,850
>> 是。 >> [學生]：你去了緩衝區溢出攻擊？ >> [搶]當然。

10
00:00:37,850 --> 00:00:45,530
主要的例子實際上可能是正確的。

11
00:00:45,530 --> 00:00:48,720
緩衝區溢出攻擊的主要交易背後

12
00:00:48,720 --> 00:00:51,540
我們有一定的緩衝，在這裡。

13
00:00:51,540 --> 00:00:54,110
字符c  - 這是唯一的尺寸為12  - 

14
00:00:54,110 --> 00:00:57,580
但我們插入到該緩衝區的東西

15
00:00:57,580 --> 00:01:00,050
但沒有檢查到底有多少，我們插入。

16
00:01:00,050 --> 00:01:06,740
在這裡，我們要插入到C的strlen（酒吧），但誰知道多久的酒吧。

17
00:01:06,740 --> 00:01:11,970
如果它的長度超過12個字符，那麼這是怎麼回事溢出這個緩衝區。

18
00:01:11,970 --> 00:01:15,830
看到這一幕 - 

19
00:01:15,830 --> 00:01:20,840
如果你把61你會得到更加熟悉這種佈局

20
00:01:20,840 --> 00:01:25,760
和處理與保存的幀指針和返回地址和父母的日常堆棧

21
00:01:25,760 --> 00:01:27,760
和所有這些實際的事情。

22
00:01:27,760 --> 00:01:31,340
但在這裡，你只需要知道，我們有

23
00:01:31,340 --> 00:01:35,990
這為我們的緩衝空間不大。

24
00:01:35,990 --> 00:01:39,480
在這裡，我們有c（0），然後，我們有C，1，2，3，4，5和左右。

25
00:01:39,480 --> 00:01:44,810
在正常情況下，我們會按通常填充此緩衝區。

26
00:01:44,810 --> 00:01:50,480
如果我們插入了'你好'，我們不得不H-E-L-L-O / 0，

27
00:01:50,480 --> 00:01:52,900
然後只是一堆空的空間。

28
00:01:52,900 --> 00:01:57,910
對於黑客 - 哦，我想這是例子。

29
00:01:57,910 --> 00:02:02,470
對於黑客，我們得到這樣的事情，

30
00:02:02,470 --> 00:02:04,760
特別是，他們正在試圖做的是什麼

31
00:02:04,760 --> 00:02:07,890
通常覆蓋返回地址。

32
00:02:07,890 --> 00:02:12,510
當你調用一個函數的堆棧幀被壓入堆棧

33
00:02:12,510 --> 00:02:14,690
該堆棧幀需要知道如何 - 

34
00:02:14,690 --> 00:02:21,020
，功能，被稱為需要知道如何返回到調用它的函數。

35
00:02:21,020 --> 00:02:23,780
所以，如果主要調用foo，foo的需要返回到主，

36
00:02:23,780 --> 00:02:26,300
所以這就是這個返回地址。

37
00:02:26,300 --> 00:02:28,800
但是黑客會做什麼

38
00:02:28,800 --> 00:02:30,820
一個特殊的返回地址覆蓋它

39
00:02:30,820 --> 00:02:40,090
地方 - 小印度 - 它不是簡單，但每一個字節是倒退。

40
00:02:40,090 --> 00:02:47,300
這個返回地址的計算機

41
00:02:47,300 --> 00:02:51,390
返回到這個地址相當於返回到foo或主

42
00:02:51,390 --> 00:02:53,850
或任何函數調用。

43
00:02:53,850 --> 00:02:54,800
因此，它會返回到這個地址

44
00:02:54,800 --> 00:02:58,130
這恰好是這樣的地址

45
00:02:58,130 --> 00:03:04,740
而有的時候，他們在這裡做的是使用的返回地址

46
00:03:04,740 --> 00:03:09,150
一個特定的功能，他們知道已經存在。

47
00:03:09,150 --> 00:03:12,630
我不記得什麼的函數的調用。

48
00:03:12,630 --> 00:03:14,630
我會看它。

49
00:03:14,630 --> 00:03:17,570
>> 在這裡他們是怎麼做的，是通過返回地址

50
00:03:17,570 --> 00:03:26,310
棧本身，這是有些奇怪，

51
00:03:26,310 --> 00:03:29,530
有記憶體中的例子 - 

52
00:03:29,530 --> 00:03:34,350
存儲器可以分成只讀，讀，寫和可執行內存

53
00:03:34,350 --> 00:03:38,710
我們已經看到只讀存儲器之前所在 - 

54
00:03:38,710 --> 00:03:43,960
如果我說的char * s =你好，我可以不修改打招呼。

55
00:03:43,960 --> 00:03:46,200
這是只讀存儲器。

56
00:03:46,200 --> 00:03:49,570
也有這種想法的可執行內存

57
00:03:49,570 --> 00:03:53,870
的可執行內存將是你的代碼的文本段。

58
00:03:53,870 --> 00:03:57,350
看在你平時的地址空間佈局 - 

59
00:03:57,350 --> 00:04:03,090
我相信這將是一個很好的圖片 - 

60
00:04:08,200 --> 00:04:12,170
 - 我們有我們的堆棧。我們有數據存儲器。

61
00:04:12,170 --> 00:04:16,360
基本上可以忽略此。這是我們的堆。

62
00:04:16,360 --> 00:04:18,810
然後我們有我們的主要程序代碼。

63
00:04:18,810 --> 00:04:27,480
這是類似的地方，我們把我們的字符串如char * =你好

64
00:04:27,480 --> 00:04:29,730
這是只讀的。

65
00:04:29,730 --> 00:04:33,590
但是你也可以紀念這個主要為可執行的程序代碼。

66
00:04:33,590 --> 00:04:37,950
如果你這樣做，或者你的操作系統不能夠正確

67
00:04:37,950 --> 00:04:40,910
然後在內存中，這應該是唯一的地方

68
00:04:40,910 --> 00:04:44,830
該代碼可以實際執行

69
00:04:44,830 --> 00:04:48,550
這意味著，這類的緩衝區溢出攻擊，我們在這裡

70
00:04:48,550 --> 00:04:53,800
將是無效的，因為這是試圖執行我們的堆棧內存在這裡。

71
00:04:53,800 --> 00:04:57,230
請注意，這些照片是第一次。

72
00:04:57,230 --> 00:04:59,270
我們有我們的協議棧。

73
00:04:59,270 --> 00:05:01,270
這裡堆棧增長下降。

74
00:05:01,270 --> 00:05:03,270
CS50目的堆棧的增長。

75
00:05:03,270 --> 00:05:09,520
>> 這是可能的，以規避這種特殊類型的緩衝區溢出

76
00:05:09,520 --> 00:05:15,110
通過這些可執行區域內存在非可執行區域。

77
00:05:15,110 --> 00:05:21,420
但它碰巧的是，很少是可執行的內存標記為可執行。

78
00:05:21,420 --> 00:05:26,520
這往往是只讀的，重新寫所使用的唯一的東西，

79
00:05:26,520 --> 00:05:28,990
所以這仍然是非常有效的。

80
00:05:28,990 --> 00:05:31,950
在這裡，我們可以把任何我們想要的。

81
00:05:31,950 --> 00:05:35,020
實際上它不是一個PSET在61年，

82
00:05:35,020 --> 00:05:38,400
但如果你看看在去年的產品或以往任何一年

83
00:05:38,400 --> 00:05:44,110
一個PSET為你特別應該在這裡插入代碼，應該是

84
00:05:44,110 --> 00:05:48,960
打印一些特定的值或返回的值是不同的

85
00:05:48,960 --> 00:05:51,400
假定要被打印的值，該值。

86
00:05:51,400 --> 00:05:57,770
或者更巧妙的是，它要你打電話或寫信 - 

87
00:05:57,770 --> 00:06:03,320
所以這將返回到這裡，然後你會執行一些編碼，在這裡，

88
00:06:03,320 --> 00:06:09,720
最聰明的溢出，然後返回到這個返回地址，用於。

89
00:06:09,720 --> 00:06:11,970
因此，即使我們需要覆蓋

90
00:06:11,970 --> 00:06:16,720
來這裡，大家還記得，返回地址的地方

91
00:06:16,720 --> 00:06:18,890
這樣我們就可以回到主或什麼的，

92
00:06:18,890 --> 00:06:23,800
它就像我們從來沒有注意到，事情發生了錯誤。

93
00:06:23,800 --> 00:06:30,100
但這樣做是這樣的話，也許裡面，在這裡，我們gelbroke我們的iPhone。

94
00:06:30,100 --> 00:06:35,670
作為正常的事 - 就像我們運行一些程序和活動結束返回

95
00:06:35,670 --> 00:06:38,540
無論它應該返回，但在此期間

96
00:06:38,540 --> 00:06:41,820
你設法摧毀整個操作系統。

97
00:06:41,820 --> 00:06:50,950
你並不需要知道關於緩衝區溢出的代碼，或利用。

98
00:06:50,950 --> 00:06:58,060
您需要知道的基本思路是緩衝區的溢出，

99
00:06:58,060 --> 00:07:02,010
這是原因，它可以溢出，因為我們沒有檢查是否

100
00:07:02,010 --> 00:07:06,110
我們實際上它的範圍內。

101
00:07:06,110 --> 00:07:09,880
>> [學生]的解決方案，以防止它僅僅是檢查的範圍？

102
00:07:09,880 --> 00:07:13,600
[搶]是的。在這種情況下的解決方案將是

103
00:07:13,600 --> 00:07:20,850
你可以說，如果strlen的酒吧大於12-1  - 

104
00:07:20,850 --> 00:07:24,970
因為你需要在/ 0結尾 - 

105
00:07:24,970 --> 00:07:34,090
或者你也可以手動做一個for循環，只有前11個字符複製，

106
00:07:34,090 --> 00:07:39,710
或只是什麼你實際檢查，以確保你不這樣做，緩衝溢出。

107
00:07:45,580 --> 00:07:49,050
>> 其他問題嗎？是嗎？

108
00:07:49,050 --> 00:07:52,760
[學生]：您能談一下嘗試，也許是關於編程的（聽不清）。

109
00:07:52,760 --> 00:07:58,720
[搶]當然。

110
00:07:58,720 --> 00:08:03,500
實際的程序 - 

111
00:08:03,500 --> 00:08:08,190
我們將永遠不會讓你做的特里在考試的實施

112
00:08:08,190 --> 00:08:12,840
因為這將是不公平的，誰做哈希表。

113
00:08:12,840 --> 00:08:16,030
同樣，我們永遠不會讓你實現一個哈希表的考試

114
00:08:16,030 --> 00:08:18,560
因為這將是不公平的，誰做了嘗試。

115
00:08:18,560 --> 00:08:25,220
然而，你應該知道的trie樹的結構或結構的哈希表或任何。

116
00:08:25,220 --> 00:08:30,230
這實際上是任何類型的數據結構，我們已經看到了真實的。

117
00:08:30,230 --> 00:08:33,559
鍊錶，堆疊傾斜，二叉樹 - 

118
00:08:33,559 --> 00:08:38,190
你應該能夠確定這些結構由心。

119
00:08:38,190 --> 00:08:44,810
也許我們可以給你一個特里 - 這意味著你唯一需要做的是

120
00:08:44,810 --> 00:08:50,070
一些字的東西，我們會說：“興建的線索， - 

121
00:08:50,070 --> 00:08:52,870
也許我們會給你一組單詞

122
00:08:52,870 --> 00:08:56,280
和我們一樣構造一個代表本字典的線索。

123
00:08:56,280 --> 00:09:05,980
>> 讓我們把我們的字典貓，狗等。

124
00:09:05,980 --> 00:09:10,790
在特里的想法是，我們開始了與這個數組 - 

125
00:09:10,790 --> 00:09:16,510
26個插槽 - 

126
00:09:16,510 --> 00:09:24,490
每個插槽中的實際索引的插槽對應的信我們關注。

127
00:09:24,490 --> 00:09:28,560
所以在這裡，如果我們試圖將貓到我們的特里

128
00:09:28,560 --> 00:09:35,360
的第一個字符是'c'的，這將是“如果a是0，則b是1，c是2。

129
00:09:35,360 --> 00:09:38,090
我們將進入第二個索引，

130
00:09:38,090 --> 00:09:41,100
我們要創建一個特里的關閉。

131
00:09:41,100 --> 00:09:47,080
我們將有26個插槽。

132
00:09:47,080 --> 00:09:51,140
然後，我們將指數的第二個字符貓。

133
00:09:51,140 --> 00:09:53,340
這是'一'，這將是0點。

134
00:09:53,340 --> 00:09:56,960
這是怎麼回事有26點。

135
00:09:56,960 --> 00:10:05,650
然後我們去't'和我們也有開始下降，這實際上是一種重要的

136
00:10:05,650 --> 00:10:13,990
因為 - 讓我們來這裡。下面是我們的'T'trie樹。

137
00:10:13,990 --> 00:10:23,370
比方說，這是索引't'是19。

138
00:10:23,370 --> 00:10:31,020
重要的是要記住的嘗試是，你不能只是跟踪這些指針。

139
00:10:31,020 --> 00:10:35,470
您還可以跟踪是否這實際上是一個單詞的結尾。

140
00:10:35,470 --> 00:10:38,570
所以，在這裡，我們需要某種標誌，上面寫著

141
00:10:38,570 --> 00:10:41,520
好吧，其實這是一個單詞的結尾。

142
00:10:41,520 --> 00:10:46,830
原因是，如果我們稍後再嘗試插入到我們的字典裡的災難

143
00:10:46,830 --> 00:10:49,930
具有相同的起始3個字符

144
00:10:49,930 --> 00:10:57,250
但進一步，我們需要認識到，這是一個單詞的結尾。

145
00:10:57,250 --> 00:11:01,330
相反，如果我們嘗試看看'C​​A'，這可能是一個字

146
00:11:01,330 --> 00:11:06,100
但我們坐下來，那麼我們就在這裡 - 

147
00:11:06,100 --> 00:11:10,270
或會是c，然後我們看一個 - 

148
00:11:10,270 --> 00:11:13,940
我們需要認識到，即使有這個節點是一個指針

149
00:11:13,940 --> 00:11:15,940
它並不代表結束的詞語。

150
00:11:15,940 --> 00:11:19,430
>> 那麼，是什麼意思 - 你要什麼說的嗎？

151
00:11:19,430 --> 00:11:22,760
這是什麼意思我們的結構看起來像嗎？

152
00:11:22,760 --> 00:11:25,760
[學生]：這是一個數組的指針是26長，然後一個布爾值，是或不是人。

153
00:11:25,760 --> 00:11:47,430
[搶]是啊。因此，我們將有一個struct線索*指針 - 在這裡，我們會說[26]

154
00:11:47,430 --> 00:11:49,590
然後在這裡的分號。

155
00:11:49,590 --> 00:11:53,210
但在PSET，我們還需要考慮為單引號，

156
00:11:53,210 --> 00:11:58,170
這意味著你需要硬編碼，單引號指數27或東西。

157
00:11:58,170 --> 00:12:00,440
但在這裡我們只關心26。

158
00:12:00,440 --> 00:12:11,830
然後，也許我們需要一個char或bool  - 我們姑且稱之為它是字。

159
00:12:11,830 --> 00:12:18,120
這是2的3件事情，我想你會需要了解試圖 - 

160
00:12:18,120 --> 00:12:24,370
建築，結構，他們的最後一件事是它們的運行時間。

161
00:12:24,370 --> 00:12:28,250
>> 什麼是運行時的特里 - 或查找在特里的嗎？

162
00:12:28,250 --> 00:12:47,500
這是我們說，這是O（K），其中k是我們正好要尋找的字的長度;

163
00:12:47,500 --> 00:12:53,850
但同時，我們說 - 至少Pset的拼寫檢查器的緣故 - 我們說

164
00:12:53,850 --> 00:12:59,470
在字典中最長的單詞是45個字符，所以這基本上是

165
00:12:59,470 --> 00:13:04,900
O的45，這是恆定的時間。

166
00:13:04,900 --> 00:13:09,660
所以，如果有一個上限的最長的單詞，然後 - 

167
00:13:09,660 --> 00:13:15,130
甚至像英語詞典 - 有一個上限，你的最長的單詞。

168
00:13:15,130 --> 00:13:19,970
或者任何字典 - 有您的高位字上最長約束。

169
00:13:19,970 --> 00:13:25,480
無論你在做什麼固定的時間，

170
00:13:25,480 --> 00:13:33,810
但為O k的是不錯的，因為實際運行之間是有區別的說

171
00:13:33,810 --> 00:13:40,120
45個字符的字與字母的話，其中只有3個字符。

172
00:13:40,120 --> 00:13:52,870
另一個事情是， - 

173
00:13:52,870 --> 00:13:57,520
哦，因為只是說，45正好是我們最長的單詞

174
00:13:57,520 --> 00:14:02,330
是一種愚蠢的，因為在同一時間讓我們說的複雜度為O的N.

175
00:14:02,330 --> 00:14:06,510
好吧，因為內存最多只支持2 ^ 32字節，

176
00:14:06,510 --> 00:14:11,770
然後N是至多4億，恆定的時間，這就是為什麼在一些點

177
00:14:11,770 --> 00:14:14,870
這是愚蠢的，說這樣的事情，有一個上限

178
00:14:14,870 --> 00:14:19,540
我們就可以減少固定的時間，因為一切都是固定的時間

179
00:14:19,540 --> 00:14:22,320
當你認為它以這種方式。

180
00:14:22,320 --> 00:14:25,470
但是，我們可能會接受這些。

181
00:14:25,470 --> 00:14:31,780
在任何情況下解釋，O（1）意味著你有一個上界字的長度;

182
00:14:31,780 --> 00:14:34,070
O（K）是指您的單詞長度 - 

183
00:14:34,070 --> 00:14:40,900
良好，k表示這個詞的長度。

184
00:14:44,060 --> 00:14:47,280
>> 是啊。 >> [學生]：BOOL  - 因為當你讓你特里

185
00:14:47,280 --> 00:14:53,220
它看起來就像是 - 你會走貓，然後你去到​​下一個指針

186
00:14:53,220 --> 00:14:59,860
然後你告訴等於真實的 - 你把真正喜歡的T？

187
00:14:59,860 --> 00:15:06,560
[搶]我們認為，這種情況下的例子很多，你可以只是嘗試，並提出了

188
00:15:06,560 --> 00:15:12,310
簡單和/或極端的例子，它應該是什麼，讓我們覺得這個詞'A'。

189
00:15:12,310 --> 00:15:21,320
在我們原特里 - 

190
00:15:21,320 --> 00:15:35,510
我們想將一個1在這裡，我們希望把一個在這裡。

191
00:15:35,510 --> 00:15:41,350
我要說的是，到底它可能會是/或。

192
00:15:41,350 --> 00:15:46,000
我不能想到一個理由 - 你真的wouldn't  - 

193
00:15:46,000 --> 00:15:51,060
我不會把它在那裡的原因是因為你甚至不需要走那麼遠。

194
00:15:51,060 --> 00:15:55,820
我們永遠需要分配特里。

195
00:15:55,820 --> 00:15:57,950
我們只是把在那裡。

196
00:15:57,950 --> 00:16:03,310
這仍然是指向NULL。

197
00:16:03,310 --> 00:16:09,430
如果我們只在有單個字符

198
00:16:09,430 --> 00:16:17,220
我們沒有理由向下延伸到另一個特里只是為了紀念那封信所使用。

199
00:16:17,220 --> 00:16:21,260
同樣，如果我們把那裡的'a'

200
00:16:21,260 --> 00:16:27,860
然後所有這些在任何時候也只是0。

201
00:16:27,860 --> 00:16:36,060
>> [學生]：但我們需要一個線索將指向這個'一'？

202
00:16:36,060 --> 00:16:43,570
[搶]我們有一些全球或東西線索* T

203
00:16:43,570 --> 00:16:47,270
這點在這裡，但是這只是一個指針。

204
00:16:47,270 --> 00:16:51,500
這不是一個成熟的線索指向它。

205
00:16:51,500 --> 00:17:02,000
[學生]：好的。我們將如何分配的字母'I' - 這個詞我嗎？

206
00:17:02,000 --> 00:17:06,380
[搶]他的問題可能會回答。等一等。

207
00:17:06,380 --> 00:17:15,060
這是一個問題，在特里和本身 - 

208
00:17:15,060 --> 00:17:17,880
我不知道Pset中寫它的方式。

209
00:17:17,880 --> 00:17:19,880
以前的結構是壞的。

210
00:17:19,880 --> 00:17:41,690
但是，我們也可以做結構的節點是一個bool  - 指針 - 

211
00:17:41,690 --> 00:17:46,500
其實有多種方法，你可以把它寫。

212
00:17:46,500 --> 00:18:01,800
另外，特里並不需要是一個結構。

213
00:18:01,800 --> 00:18:21,250
它甚至可能是特里 - 類型定義節點*  - 

214
00:18:21,250 --> 00:18:34,760
節點[26]是一個特里，這已不再是結構。

215
00:18:34,760 --> 00:18:44,270
現在，將是 - 我試圖想的方式，PSET你所期望的。

216
00:18:44,270 --> 00:18:47,650
[學生]：我把這個審查會議，我認為他們只是去 - 

217
00:18:47,650 --> 00:18:50,670
一樣，如果你​​有一個，然後你去到​​下一個 -  >> [搶]這是如何做到這一點？

218
00:18:50,670 --> 00:18:53,750
[學生]：然後，如果有一個真實的存在這是行不通的 - 

219
00:18:53,750 --> 00:18:58,710
[搶]是啊。這工作。它浪費的空間 - 

220
00:18:58,710 --> 00:19:03,910
你一定有一個整體的其他級別的特里，你會不會需要擺在首位。

221
00:19:03,910 --> 00:19:08,410
在這裡它是越來越難看，每個 - 

222
00:19:08,410 --> 00:19:11,530
基本上我想在這裡做什麼是聯營公司 - 

223
00:19:11,530 --> 00:19:15,000
26指針，而不是你的嘗試，

224
00:19:15,000 --> 00:19:20,810
它的26布爾指針，布爾指針，布爾指針，等等。

225
00:19:28,940 --> 00:19:34,410
>> [學生]：你不能，2個數組？ bool值和一個指針數組的數組？

226
00:19:34,410 --> 00:19:38,060
[搶]你可以，但然後你需要 - 

227
00:19:38,060 --> 00:19:41,500
2布爾值的數組和指針。

228
00:19:41,500 --> 00:19:47,340
您將需要再建立你的布爾值數組 - 

229
00:19:47,340 --> 00:19:51,240
您的布爾值數組需要有大的特里

230
00:19:51,240 --> 00:19:53,200
因為你不能只是有26個布爾值。

231
00:19:53,200 --> 00:19:57,010
它成長的每一個可能的 - 

232
00:19:57,010 --> 00:20:03,240
想你的特里有超過26個可能的話真或假的。

233
00:20:03,240 --> 00:20:08,240
在這一點上，他們也可能只是一個單個的結構，你的特里向下增長的。

234
00:20:08,240 --> 00:20:15,210
這似乎並不正確，因為 - 你有什麼我想在這裡嗎？

235
00:20:15,210 --> 00:20:23,640
因此，特里* T  - 

236
00:20:23,640 --> 00:20:30,200
你可以做的typedef（節點）[26]特里;

237
00:20:30,200 --> 00:20:33,090
這可能是我在尋找的語法。

238
00:20:36,740 --> 00:20:41,450
這應該只是一個普通的特里。

239
00:20:44,900 --> 00:20:47,440
我不太肯定。

240
00:20:47,440 --> 00:20:54,850
但是，這是我們這樣做，是在審查的方式，使工作完全正常，太。

241
00:20:54,850 --> 00:20:57,850
在這種情況下，如果它僅僅是布爾字，然後一個數組26

242
00:20:57,850 --> 00:21:01,750
那麼你就必須去到一個新的水平。

243
00:21:01,750 --> 00:21:05,420
我會考慮我的方式做到這一點。

244
00:21:07,500 --> 00:21:09,550
>> 其他問題嗎？

245
00:21:09,550 --> 00:21:12,540
[學生]：我想問別的東西的問題嗎？ >> [搶]是的。

246
00:21:12,540 --> 00:21:19,040
[學生]：你能去的區別是什麼，當你使用jQuery與Ajax的？

247
00:21:19,040 --> 00:21:24,550
[搶]他們是在和自己完全不同的。

248
00:21:24,550 --> 00:21:32,720
JQuery的啟用Ajax。它確實給我們一些更容易使用的Ajax。

249
00:21:32,720 --> 00:21:38,480
但是Ajax運的JavaScript。 JavaScript有Ajax功能。

250
00:21:38,480 --> 00:21:47,490
我已經在頁面上時，我想，所有的Ajax手段的比喻 - 

251
00:21:47,490 --> 00:21:52,820
當我點擊的東西，我不需要刷新頁面來下載新的信息。

252
00:21:52,820 --> 00:21:55,020
我只是要求，新的信息。

253
00:21:55,020 --> 00:22:01,220
你可以看一下它在Facebook或東西。

254
00:22:01,220 --> 00:22:05,580
檢查網絡。

255
00:22:05,580 --> 00:22:07,460
收縮這一點。

256
00:22:12,070 --> 00:22:14,940
在這裡我們可以看到，我們得到的這些要求。

257
00:22:14,940 --> 00:22:18,990
現在，當我點擊 - 好了，它做的Ajax之前，我什點擊任何東西。

258
00:22:18,990 --> 00:22:24,140
但是，如果我點擊，然後它要在這兒一堆的請求

259
00:22:24,140 --> 00:22:33,530
只是這些請求 - 哦，現在是在這裡。

260
00:22:33,530 --> 00:22:36,590
讓我們來刷新。

261
00:22:36,590 --> 00:22:38,580
再這樣做。

262
00:22:38,580 --> 00:22:42,090
我們看到，我們得到了所有這些要求，但是這仍然是在頁面加載的過程中。

263
00:22:42,090 --> 00:22:47,400
公告Facebook是即使在頁面加載後，這些常量的要求。

264
00:22:47,400 --> 00:22:51,470
如果我點擊這裡，它會讓更多的要求對某些數據

265
00:22:51,470 --> 00:22:54,990
這是在響應的事情，我只是點擊。

266
00:22:54,990 --> 00:23:04,660
這正是Ajax是。它可以讓你拉，這不是原來的頁面下載數據。

267
00:23:04,660 --> 00:23:12,050
>> jQuery是獨立的。 jQuery是一個JavaScript庫，做了很多事情更容易。

268
00:23:12,050 --> 00:23:28,660
使用jQuery，這是一個很大的優勢，這只是 - 

269
00:23:28,660 --> 00:23:34,030
美元符號 - 美元符號是一個有效的變量在JavaScript中。

270
00:23:34,030 --> 00:23:43,460
因此，jQuery的 - 它做的是說像var $ =一大堆的東西 - 

271
00:23:43,460 --> 00:23:46,690
所有這一切的東西在裡面，像一些大的功能 - 

272
00:23:46,690 --> 00:23:52,650
然後使用美元符號的方式，如

273
00:23:52,650 --> 00:24:23,940
$（“＃頁腳”）。樣式（“文本對齊”，“中心”）。

274
00:24:23,940 --> 00:24:32,330
JQuery的為我們提供了這樣的語法，其中的一大優勢 - 

275
00:24:32,330 --> 00:24:35,650
它還有其他的功能，但我們希望您能夠專注於最

276
00:24:35,650 --> 00:24:38,760
只能夠選擇這樣的元素。

277
00:24:38,760 --> 00:24:42,780
在一般的，普通的舊JavaScript，你可以做這樣的事情

278
00:24:42,780 --> 00:24:50,490
文件點得到元素的ID頁腳點 - 我不知道它是什麼，在這一點上 - 

279
00:24:50,490 --> 00:24:52,790
一些關於CSS或樣式或東西 - 

280
00:24:52,790 --> 00:24:58,930
另外，我們說，我們要選擇的類。

281
00:24:58,930 --> 00:25:06,330
現在，我們的一類頁腳這種風格造型的一切。

282
00:25:06,330 --> 00:25:16,070
即使我們想要的任何段落的樣式。

283
00:25:16,070 --> 00:25:22,000
所以，這個選擇 - 可以選擇在DOM這樣的事情，是非常方便的

284
00:25:22,000 --> 00:25:29,420
因為在普通的舊JavaScript，你必須做的文件點得到元素的類名

285
00:25:29,420 --> 00:25:34,260
不管它是什麼，如果我想要一個標籤，我需要說的標記名稱的元素。

286
00:25:34,260 --> 00:25:37,530
所以，我需要知道具體的方法，我訪問所有這些事情。

287
00:25:37,530 --> 00:25:40,810
這些功能將是不同的，這取決於我使用的類或ID

288
00:25:40,810 --> 00:25:46,420
或標記或什麼，而jQuery的，我只是做。

289
00:25:46,420 --> 00:25:53,120
>> [學生]：是jQuery將被用來當你在做初步造型的頁面？

290
00:25:53,120 --> 00:25:56,570
為了改變造型後，它已經 -  >> [搶]要改變它。

291
00:25:56,570 --> 00:25:58,440
[學生]：它已經加載。 >> [搶]是啊。

292
00:25:58,440 --> 00:26:07,020
任何初始的造型 - 好了，即使是 - 

293
00:26:07,020 --> 00:26:09,970
通常，你會使用這種變化。

294
00:26:09,970 --> 00:26:14,330
你會不會改變 - 這將工作完全正常。

295
00:26:14,330 --> 00:26:17,720
但是通常你會不會改變這樣的風格。

296
00:26:17,720 --> 00:26:20,610
相反，你想給它一個新的類或某事

297
00:26:20,610 --> 00:26:24,650
而CSS已經被定義為該類以某種方式。

298
00:26:24,650 --> 00:26:28,920
通過給這些項目中，我選擇了一個新的類

299
00:26:28,920 --> 00:26:32,200
我已經下載應用的樣式。

300
00:26:32,200 --> 00:26:36,720
[學生]：所以，你選擇複選框和一對夫婦的事情，你所選擇的

301
00:26:36,720 --> 00:26:41,820
改變到一個新的風格，並開始尋找不同的。 >> [搶]是啊。

302
00:26:41,820 --> 00:26:45,490
其他的事情要記住的 - 

303
00:26:45,490 --> 00:26:48,350
好了，有幾個函數，你應該還記得關於jQuery。

304
00:26:48,350 --> 00:26:55,570
比方說，我們選擇的東西ID P.

305
00:26:55,570 --> 00:27:00,500
>> [學生]：你總是必須使用英鎊？

306
00:27:00,500 --> 00:27:09,600
[搶]這意味著ID。這相當於CSS，所以CSS選擇器 - 它的靈感來自那個。

307
00:27:09,600 --> 00:27:12,410
在CSS，如果我想要的風格頁腳 - 

308
00:27:12,410 --> 00:27:16,950
或與ID頁腳的東西 - 

309
00:27:16,950 --> 00:27:23,490
它會像文本對齊：中心;

310
00:27:23,490 --> 00:27:28,820
你不需要寫CSS的考試，但你需要知道選擇器。

311
00:27:28,820 --> 00:27:34,280
你需要知道的是什麼 - 你需要知道如何閱讀。

312
00:27:34,280 --> 00:27:36,000
但是，我們絕不會 - 

313
00:27:36,000 --> 00:27:42,390
您不需要記住所有可能的不同風格的東西。或者任何人。

314
00:27:42,390 --> 00:27:50,020
>> JQuery的事情你應該記住 - 

315
00:27:50,020 --> 00:27:58,380
你應該還記得點HTML和jQuery中的一個共同的模式 - 讓我們重新寫這篇文章。

316
00:27:58,380 --> 00:28:09,640
一個常見的模式是，我們有$（“F”）的HTML

317
00:28:09,640 --> 00:28:15,650
如果我只是簡單的括號，這意味著在HTML;

318
00:28:15,650 --> 00:28:23,870
而如果我說HTML，並把我想做的事情的東西在這裡 - 一些鏈接 - 

319
00:28:23,870 --> 00:28:30,410
把現在的括號裡面的東西設置的HTML。

320
00:28:30,410 --> 00:28:33,760
這是很常見的，其中包括一組函數。

321
00:28:33,760 --> 00:28:38,360
有相同的文字處理。

322
00:28:38,360 --> 00:28:41,720
HTML和文本之間的差異是文本要插入

323
00:28:41,720 --> 00:28:46,350
小於，大於，而不是作為一個錨定標記文字。

324
00:28:46,350 --> 00:28:53,000
而文本將是相同的，如果我只是這樣做。

325
00:28:53,000 --> 00:28:55,760
它要檢索的文件的文本 - 而不是HTML的文件

326
00:28:55,760 --> 00:29:01,810
但只是這個元素內的文字。

327
00:29:01,810 --> 00:29:08,430
另一種是，如果“f”則恰好是一個為一個輸入ID，

328
00:29:08,430 --> 00:29:14,250
哈希-F點的時間間隔 - 如果我想設置輸入喜歡的東西 - 

329
00:29:14,250 --> 00:29:17,900
比方說，我打了一個複選框，我想設置一個默認值 - 

330
00:29:17,900 --> 00:29:26,070
點VAL  - 我什至不知道 -  3  - 因此，它會自動插入文本框3，

331
00:29:26,070 --> 00:29:35,980
但如果我說3點的時間間隔，無論是在我的文本框，將檢索。

332
00:29:35,980 --> 00:29:39,690
>> 這是非常有用的表單驗證，其中

333
00:29:39,690 --> 00:29:48,030
如果我只是想使確保他們其實充滿了所有的事情。

334
00:29:48,030 --> 00:29:54,710
這樣做的方法之一是，如果我打提交不可避免地發送到服務器上的一些頁面 - 

335
00:29:54,710 --> 00:30:00,190
像這對我們來說將是PHP  - 這將嘗試對數據進行處理，它會說

336
00:30:00,190 --> 00:30:03,030
他們沒有填寫的東西，所以，現在將他們重定向到另一個頁面，上面寫著

337
00:30:03,030 --> 00:30:05,050
你沒有填寫。

338
00:30:05,050 --> 00:30:11,650
而不必做到這一點，在JavaScript / jQuery的，你才可以看到，如果值是空的。

339
00:30:11,650 --> 00:30:17,270
或者是值 - 空引號。

340
00:30:17,270 --> 00:30:23,120
這只是 - 現在，我們可以提醒他們，你沒有填寫這一領域。

341
00:30:23,120 --> 00:30:26,990
不可避免的是，你需要做的PHP服務器端檢查，因為

342
00:30:26,990 --> 00:30:31,210
你可以在所有瀏覽器中禁用JavaScript。

343
00:30:31,210 --> 00:30:36,180
但是，JavaScript，方便那些誰已經激活，

344
00:30:36,180 --> 00:30:42,940
幾乎99點的東西％的瀏覽器上時下。

345
00:30:42,940 --> 00:30:46,630
極少數人打開JavaScript後。

346
00:30:46,630 --> 00:30:52,850
這是一個用戶的便利性。你需要做的PHP驗證。

347
00:30:52,850 --> 00:30:55,990
你應該做的JavaScript驗證。

348
00:30:55,990 --> 00:30:57,950
>> [學生]：什麼是＃樓參考這裡嗎？

349
00:30:57,950 --> 00:31:00,020
[搶]＃F是指什麼？

350
00:31:00,020 --> 00:31:04,350
有一些元素在我的文檔中ID為'F'。

351
00:31:04,350 --> 00:31:09,850
我們來看看 - 可能是Facebook有大量的例子，如果我來給元素

352
00:31:09,850 --> 00:31:17,820
看這裡，我看到這個特定的div，在這裡被強調的元素標籤 - 

353
00:31:17,820 --> 00:31:22,670
或者是整個頁面 - 是的，它的存在。這ID pagelet_bluebar。

354
00:31:22,670 --> 00:31:26,730
在控制台中，我想他們就使用jQuery。

355
00:31:26,730 --> 00:31:40,030
所以，我可以選擇pagelet_bluebar所以，選擇那個，和我做錯了什麼。

356
00:31:46,470 --> 00:31:52,250
讓我們嘗試 - 或者也許他們不使用jQuery和該字符的映射到別的東西。

357
00:31:52,250 --> 00:32:04,970
在我所知道的事情是一個更好的例子使用jQuery  - 

358
00:32:04,970 --> 00:32:10,600
還在尋找我們的元素在這裡 - 我們這裡有節課的Navbar。

359
00:32:10,600 --> 00:32:12,330
這是與類Navbar的，

360
00:32:12,330 --> 00:32:19,180
我們的控制台內，我們可以看的東西類的navbar。

361
00:32:19,180 --> 00:32:21,770
在這裡，我們可以在這個滾動，看看，這是什麼。

362
00:32:21,770 --> 00:32:29,850
如果我想做的事。這是該文本的文本，所以我看到上面的日誌設置為報告

363
00:32:29,850 --> 00:32:35,760
這是所有在這裡，但是這仍然文本，HTML標籤內。

364
00:32:35,760 --> 00:32:52,230
我可以將HTML只是一些鏈接，

365
00:32:52,230 --> 00:32:56,550
所以我會擺脫我的吧。我們擺脫完全只是鏈接到YouTube的頭。

366
00:32:56,550 --> 00:32:59,630
>> 是否有任何形式的例子嗎？

367
00:32:59,630 --> 00:33:01,940
這裡的一種形式。

368
00:33:01,940 --> 00:33:05,830
我可以右鍵單擊並檢查元素來這裡。

369
00:33:05,830 --> 00:33:08,460
我看到它的ID是文本搜索，

370
00:33:08,460 --> 00:33:16,910
所以在這裡，如果我做ID文本搜索。

371
00:33:16,910 --> 00:33:23,190
我會帶過來，我看到的是正確的事情，我正在尋找。

372
00:33:23,190 --> 00:33:27,670
如果我想做的事情。VAL它會給我什麼，我輸入了。

373
00:33:27,670 --> 00:33:36,010
如果我想要做的招呼它會改變它在這裡對你好 -  jQuery的。

374
00:33:36,010 --> 00:33:45,780
當然，我可以做荒謬的像document.get元素的ID  - 全文搜索 - 

375
00:33:45,780 --> 00:33:54,000
我什至不知道它是什麼，在這一點上 - 點值 - 不，我忘了那傢伙。

376
00:33:54,000 --> 00:33:59,110
所以，這是個招呼。我不知道我怎麼會設置它等於什麼。

377
00:33:59,110 --> 00:34:00,930
是啊，所以改變了這一切。

378
00:34:00,930 --> 00:34:07,510
但你並不需要使用很多網站在這一點上使用jQuery。

379
00:34:07,510 --> 00:34:13,050
即使喜歡上一個最終的項目 - 如果你正在做一個Web項目 - 第一件事

380
00:34:13,050 --> 00:34:20,030
我建議只包括jQuery的，所以你可以得到所有這些功能的方便。

381
00:34:22,580 --> 00:34:27,750
>> [學生]：我覺得我看到了一個不同的方式來使用dom的一個元素。

382
00:34:27,750 --> 00:34:32,520
你一定要使用點，然後保持下去嗎？

383
00:34:32,520 --> 00:34:36,630
[搶]你可以做到這一點。我不知道這是否會工作得很好。

384
00:34:36,630 --> 00:34:38,900
導航這樣是很困難的。

385
00:34:38,900 --> 00:34:43,179
其中一個例子是 - 我什至不知道我們是否有任何形式的 - 

386
00:34:43,179 --> 00:34:48,940
但document.forms會以列表的形式返回此頁面上，

387
00:34:48,940 --> 00:34:55,070
然後，我可以做document.forms 0，那麼第一種形式。

388
00:34:55,070 --> 00:35:03,070
點 - 我不知道我們已經叫 - 它不甚至有一個名字，

389
00:35:03,070 --> 00:35:08,050
所以也許輸入工作。號

390
00:35:08,050 --> 00:35:11,050
我什至不知道如何得到這 - 得到元素-I輸入標籤名稱。

391
00:35:11,050 --> 00:35:23,630
是啊，這給了我的輸入，現在我想0設置為輸入

392
00:35:23,630 --> 00:35:31,320
我想選擇它的價值，所以這將是文本。

393
00:35:31,320 --> 00:35:33,890
我不得不做元素標籤名稱反正。

394
00:35:33,890 --> 00:35:36,210
有可能以某種方式直接選擇

395
00:35:36,210 --> 00:35:43,480
通過形式0，但有關這方面的好東西還是很喜歡，我只用了稱為輸入的標籤

396
00:35:43,480 --> 00:35:49,880
孩子的這種形式，否則的話，我就這樣做直線上升前

397
00:35:49,880 --> 00:35:56,680
這將選擇整個頁面上的所有元素，整個文檔中的

398
00:35:56,680 --> 00:36:00,580
而不是只是形式，它甚至可能不會是我想要的。

399
00:36:00,580 --> 00:36:06,180
我什至不知道它是哪一個。我不知道。

400
00:36:06,180 --> 00:36:13,450
我想第一個輸入我們的網頁元素是這個小複選框。

401
00:36:13,450 --> 00:36:20,450
>> [學生]：這是非常無關

402
00:36:20,450 --> 00:36:27,420
可能有點愚蠢，但對答案的關鍵，它說，PHP  - 

403
00:36:27,420 --> 00:36:35,660
我不知道這是否是答案的關鍵或票據，但它說PHP是服務器端

404
00:36:35,660 --> 00:36:39,590
JavaScript是客戶端。 2之間的區別是什麼？

405
00:36:39,590 --> 00:36:45,550
[搶] JavaScript客戶端和PHP服務器端之間的區別。

406
00:36:45,550 --> 00:36:51,890
如果你聽說過的斜線/使用節點JS之前，你可能會認為，

407
00:36:51,890 --> 00:36:56,280
JavaScript是不只是客戶端的，但，CS50目的是 - 

408
00:36:56,280 --> 00:36:59,340
或至少​​在該測驗的目的，它是。

409
00:36:59,340 --> 00:37:03,800
PHP是服務器端。沒有JavaScript。

410
00:37:03,800 --> 00:37:08,700
當你寫你的網頁，你會寫PHP在服務器上。

411
00:37:08,700 --> 00:37:11,670
你將永遠不會被寫入服務器上的JavaScript。

412
00:37:11,670 --> 00:37:17,190
Javascript的結束時間發送給瀏覽器執行的JavaScript代碼。

413
00:37:17,190 --> 00:37:22,250
在瀏覽器中的JavaScript代碼需要生活，因為否則，當我想

414
00:37:22,250 --> 00:37:25,830
做任何形式使用Javascript-Y東西，如點擊這個，

415
00:37:25,830 --> 00:37:31,720
我不重新加載頁面。這只是JavaScript重新格式化的東西，對我來說。

416
00:37:31,720 --> 00:37:36,490
如果JavaScript在服務器上生活，那麼我會不可避免地要求的東西

417
00:37:36,490 --> 00:37:39,490
服務器知道該怎麼辦。

418
00:37:39,490 --> 00:37:45,380
PHP  -  PHP在瀏覽器中有沒有這樣的事情。

419
00:37:45,380 --> 00:37:52,090
當我請求一個頁面 - 讓我們在這裡所講的話，我這份特別的一頁。

420
00:37:52,090 --> 00:37:57,270
這意味著，這是怎麼回事要求 - 

421
00:37:57,270 --> 00:38:04,270
刷新 - 這將刷新此頁 - 

422
00:38:04,270 --> 00:38:07,210
所以這個請求進入到我們的服務器。

423
00:38:07,210 --> 00:38:13,190
它認為，它需要返回這個特定的線程，這個特定的ID，

424
00:38:13,190 --> 00:38:23,740
所以現在將是PHP，PHP解釋器將解釋該頁面

425
00:38:23,740 --> 00:38:28,680
並將其轉換成HTML，CSS，也許JavaScript中，任何。

426
00:38:28,680 --> 00:38:36,930
這是PHP處理這個請求並檢索所有的文字之類的東西

427
00:38:36,930 --> 00:38:39,170
實際上，我從數據庫中尋找。

428
00:38:39,170 --> 00:38:44,750
但離開服務器僅僅是HTML / JS / CSS。

429
00:38:44,750 --> 00:38:48,630
有沒有PHP離開服務器，因為如果它確實

430
00:38:48,630 --> 00:38:53,890
然後，瀏覽器會不知道用它做什麼，因為它不知道什麼是PHP。

431
00:38:53,890 --> 00:39:00,250
但在同樣的想法，因為JavaScript是客戶端，

432
00:39:00,250 --> 00:39:02,250
你永遠不能訪問MySQL。

433
00:39:02,250 --> 00:39:07,430
由於PHP是服務器端，你訪問MySQL。

434
00:39:07,430 --> 00:39:12,880
>> [學生]：你可以去一些HTTP cookies在安全方面的問題？

435
00:39:12,880 --> 00:39:18,390
[搶]這些都不是我們需要知道的東西。

436
00:39:18,390 --> 00:39:24,500
有些的HTTP cookies在安全方面的問題。

437
00:39:24,500 --> 00:39:28,550
這裡最大的問題是，我們在這裡看到我的Cookie的PHP / ID。

438
00:39:28,550 --> 00:39:33,560
這是通用的PHP的會話。

439
00:39:33,560 --> 00:39:39,550
您的會話的PHP裡面的東西，永遠不會需要驗證

440
00:39:39,550 --> 00:39:45,690
因為它的服務器有完全的控制權的會話。

441
00:39:45,690 --> 00:39:47,690
你不能觸摸它。

442
00:39:47,690 --> 00:39:53,120
但是，這個cookie  - 這 - 

443
00:39:53,120 --> 00:39:57,500
我想你可以登錄我現在，如果你想使用 - 

444
00:39:57,500 --> 00:40:06,610
但該cookie  - 不可避免地你使一個單一的請求到服務器。

445
00:40:06,610 --> 00:40:09,890
服務器返回的頁面。請求完成。

446
00:40:09,890 --> 00:40:12,580
它不再有任何想法，你是誰。

447
00:40:12,580 --> 00:40:17,230
所以，你的下一個請求會包括該cookie，以便它知道

448
00:40:17,230 --> 00:40:19,810
這是人誰提出這個要求之前。

449
00:40:19,810 --> 00:40:23,830
這是與該用戶相關聯的會話數據。

450
00:40:23,830 --> 00:40:28,210
這就是為什麼你沒有登錄的每一個頁面使用。

451
00:40:28,210 --> 00:40:33,380
這裡的安全問題是該cookie在網絡上發送出去。

452
00:40:33,380 --> 00:40:41,490
我們使用的是HTTPS在這裡，所以在這種情況下，這意味著我們要加密這東西。

453
00:40:41,490 --> 00:40:49,870
有人可以不來的，只是偷了我的餅乾，現在的服務器會認為他們是我。

454
00:40:49,870 --> 00:40:52,060
但隨著直HTTP他們。

455
00:40:52,060 --> 00:40:57,650
就像這的Wireshark的/ FireSheep的東西，你可以只聽空氣中所有的Wi-FIS

456
00:40:57,650 --> 00:41:01,380
和攔截任何你想要的，所以是。

457
00:41:01,380 --> 00:41:12,430
>> [學生]：一種類似的安全風險是存儲用戶ID後

458
00:41:12,430 --> 00:41:16,860
因為，可以自由編輯使用遊戲機和活動。

459
00:41:16,860 --> 00:41:23,410
[搶]是的。有很多問題，喜歡的任何東西都來自於用戶的

460
00:41:23,410 --> 00:41:26,940
你需要驗證。

461
00:41:26,940 --> 00:41:37,650
有很多的情況下，這將是有益的，像我作出後。

462
00:41:37,650 --> 00:41:39,650
廢話，廢話，廢話，廢話，廢話。然後我打的答复。

463
00:41:39,650 --> 00:41:44,540
這將是非常有用的，如果POST請求中包含了我的ID，因為

464
00:41:44,540 --> 00:41:48,610
 我想我到這個職位的關聯。

465
00:41:48,610 --> 00:41:54,820
但我不能這樣做，因為我免費做一個POST請求 - 就像手動

466
00:41:54,820 --> 00:41:57,820
拿出我自己的職位要求 - 

467
00:41:57,820 --> 00:42:00,960
使用您的用戶ID和現在將發布。

468
00:42:00,960 --> 00:42:07,440
這就是為什麼我不能依靠服務器端請求中包含了正確的用戶ID後。

469
00:42:07,440 --> 00:42:09,720
這就是為什麼它有屬於我的會議。

470
00:42:09,720 --> 00:42:15,140
所以，我看看你的用戶ID，我在我的會議陣列插入到我的數據庫

471
00:42:15,140 --> 00:42:17,580
作為用戶究竟是誰發的這個帖子。

472
00:42:17,580 --> 00:42:19,580
[學生]：這是基於您的Cookie？

473
00:42:19,580 --> 00:42:24,690
[搶]是啊。它使用cookie來匹配你的用戶提出這一要求。

474
00:42:24,690 --> 00:42:30,570
它把從該會話和用戶ID，然後插入到數據庫中

475
00:42:30,570 --> 00:42:32,960
使用該用戶ID。

476
00:42:32,960 --> 00:42:40,330
這就好比按鈕 - 那實際上做的是 - 

477
00:42:40,330 --> 00:42:43,810
我不打算在這裡找到它。這將是一個Ajax功能

478
00:42:43,810 --> 00:42:46,780
什麼是Ajax功能？

479
00:42:46,780 --> 00:42:55,500
讓我找到了我的JavaScript是什麼。

480
00:42:55,500 --> 00:42:59,710
前一段時間，這是一個CS50項目。

481
00:42:59,710 --> 00:43:02,880
我不記得它是什麼。

482
00:43:02,880 --> 00:43:12,530
Ajax功能 - 所有的Ajax功能做一個Ajax請求的頁面與此ID  - 

483
00:43:12,530 --> 00:43:15,810
與識別編號22453。

484
00:43:15,810 --> 00:43:20,180
它甚至不是一個POST請求。這是一個GET請求，這使得它更容易。

485
00:43:20,180 --> 00:43:27,860
如果我知道的URL是什麼 - 它的東西，像這樣/ ID = 22453  - 

486
00:43:27,860 --> 00:43:33,290
？ID = 22453  - 

487
00:43:33,290 --> 00:43:40,290
訪問這個URL會喜歡的。

488
00:43:40,290 --> 00:43:44,600
這不會是太大的問題，但它是令人難以置信的容易寫一個循環

489
00:43:44,600 --> 00:43:48,500
這是剛剛去訪問這個URL，一遍又一遍，這就是為什麼你看到的

490
00:43:48,500 --> 00:43:51,180
成千上萬的事情Isawyouharvard後。

491
00:43:51,180 --> 00:43:56,960
而且他們往往CS50基於Isawyouharvard職位。

492
00:43:56,960 --> 00:44:01,200
我如何找到最喜歡的嗎？

493
00:44:01,200 --> 00:44:03,720
他們往往很快被刪除了。

494
00:44:03,720 --> 00:44:06,490
這是不是最喜歡。我們走吧。

495
00:44:06,490 --> 00:44:13,400
作弊者最喜歡的頁面 - 這是非常相關的，以現在的這種權利。

496
00:44:13,400 --> 00:44:21,230
哇哦。他們已經刪除那些今年已

497
00:44:21,230 --> 00:44:25,590
被騙了。這些都被刪除。

498
00:44:25,590 --> 00:44:28,680
永遠不會有後，得到這樣高的。

499
00:44:28,680 --> 00:44:32,860
顯然，這一次是被騙最喜歡的網頁。

500
00:44:36,570 --> 00:44:39,310
>> 還有問題嗎？

501
00:44:39,310 --> 00:44:46,050
[學生]：我們應該知道的XHTML？

502
00:44:46,050 --> 00:44:49,710
[搶]幾乎什麼都沒有。它究竟是什麼。

503
00:44:49,710 --> 00:44:59,220
它和HTML之間的區別在於，XML是在外觀上非常相似

504
00:44:59,220 --> 00:45:09,080
HTML除了在HTML中，我們只需要一組預定義的標籤。

505
00:45:09,080 --> 00:45:15,380
但隨著XML  -  XML就像是一個通用格式，您可以在其中一個XML文檔

506
00:45:15,380 --> 00:45:17,580
任何你想要的目的。

507
00:45:17,580 --> 00:45:25,950
因此，舉例來說，如果我想我可以構造一個XML的課程 - 

508
00:45:25,950 --> 00:45:28,860
其實，我覺得，CS50的API。

509
00:45:28,860 --> 00:45:31,590
我的XML文件可能看起來像 - 

510
00:45:31,590 --> 00:45:39,330
課程，當然，我需要一些結束課程。

511
00:45:39,330 --> 00:45:48,920
我能有一個過程，它可以有名稱等於CS50。

512
00:45:48,920 --> 00:45:58,080
然後我結束課程，我可以把裡面的，這裡的學生，

513
00:45:58,080 --> 00:46:07,010
然後在裡面的學生，我有一個列表的一個學生，他的名字是什麼。

514
00:46:07,010 --> 00:46:10,180
我結束，學生等。

515
00:46:10,180 --> 00:46:16,070
我只是碰巧已經構建了一些任意的XML文件，但它是有效的XML。

516
00:46:16,070 --> 00:46:23,700
XML  - 它是這樣的結構和美好的事情 - 因為，我們甚至把它XML

517
00:46:23,700 --> 00:46:26,820
是，這樣的事情是很容易分析。

518
00:46:26,820 --> 00:46:32,580
這是很容易藉此文檔和陣列。

519
00:46:32,580 --> 00:46:39,370
因此，XHTML是HTML是有效的XML。

520
00:46:39,370 --> 00:46:42,580
這已經看起來很類似HTML。

521
00:46:42,580 --> 00:46:52,160
一些差異也許是HTML你是能夠做到的事情，如輸入的類型等於文本

522
00:46:52,160 --> 00:46:55,550
這是默認的，所以我不必說。

523
00:46:55,550 --> 00:47:00,010
殘疾人士。

524
00:47:00,010 --> 00:47:05,160
>> 在這裡有兩件事情，使這個無效的XHTML。

525
00:47:05,160 --> 00:47:08,750
第一件事是所有XML標記都需要一個結束標記。

526
00:47:08,750 --> 00:47:13,040
因此，在輸入的情況下，我需要做的 - 的斜線方向是什麼？

527
00:47:13,040 --> 00:47:15,060
這個方向？這看起來是錯誤的。

528
00:47:15,060 --> 00:47:19,380
其他方向。

529
00:47:19,380 --> 00:47:21,960
自閉標籤。

530
00:47:21,960 --> 00:47:29,560
第二件事是，XML，你需要這種類型的鍵值對一樣。

531
00:47:29,560 --> 00:47:32,130
它需要與它相關聯的值。

532
00:47:32,130 --> 00:47:35,050
因此，即使禁用表達我想要的 - 

533
00:47:35,050 --> 00:47:37,110
應禁用此輸入 - 

534
00:47:37,110 --> 00:47:39,110
這是無效的XHTML。

535
00:47:39,110 --> 00:47:47,110
我確實需要寫的是禁用等於禁用。

536
00:47:47,110 --> 00:47:49,620
現在，它是有效的XHTML。

537
00:47:49,620 --> 00:47:54,850
這些都只是這些細微的差別，將HTML一種基於XML的類的事情。

538
00:47:54,850 --> 00:48:04,880
>> [學生]：XML是像拉通過自己的X完全想，為什麼是（聽不清）

539
00:48:04,880 --> 00:48:19,450
[搶]的東西，像一個CSV  - 一個的CSV你有正義價值觀的分離 - 

540
00:48:19,450 --> 00:48:23,550
只是想試算表。一個CSV基本上是一個電子表格。

541
00:48:23,550 --> 00:48:26,720
您有可能列，你有一大堆的行

542
00:48:26,720 --> 00:48:29,600
聯營公司與列的數據，但僅此而已。

543
00:48:29,600 --> 00:48:38,310
XML中，你可以更加靈活 - 你有一個任意層次結構的數據。

544
00:48:38,310 --> 00:48:43,200
內有多個學生，我可以有多個課程

545
00:48:43,200 --> 00:48:45,460
這將是很難想到一個電子表格 - 

546
00:48:45,460 --> 00:48:51,010
只是單一的電子表格 - ，CSV特別是像只是一個單一的電子表格 - 

547
00:48:51,010 --> 00:48:58,760
使單個電子表格具有所有CS50，51，和61，在這些所有的內

548
00:48:58,760 --> 00:49:03,230
那些時代的學生，也許會議的時間和所有這一類的事情。

549
00:49:03,230 --> 00:49:09,140
另一件事是，變量名稱的所有元素給一個好聽的名字

550
00:49:09,140 --> 00:49:13,140
讀取一個CSV文件，可以嘗試和解析什麼實際看到的。

551
00:49:13,140 --> 00:49:20,130
XML更是人類可讀的，所以這就是為什麼喜歡 - 一些人誰不

552
00:49:20,130 --> 00:49:26,380
真的知道什麼是一個CSV文件，或者喜歡的是不是一個程序員或東西 - 

553
00:49:26,380 --> 00:49:30,640
你可以給他們一個模板XML文件，他們可以按照行和 - 

554
00:49:30,640 --> 00:49:33,590
哦，我應該在這裡插入我的名字。

555
00:49:33,590 --> 00:49:37,440
這是一個更有用的格式。

556
00:49:37,440 --> 00:49:42,440
CSV有很多用途，但，XML具有不同的用途。

557
00:49:46,050 --> 00:49:49,680
>> 還有問題嗎？

558
00:49:49,680 --> 00:49:51,900
其他問題嗎？

559
00:49:56,410 --> 00:50:00,520
[學生]：從以前的測驗 - 垂直與水平縮放比例縮放。

560
00:50:00,520 --> 00:50:04,660
[搶]你不會需要知道這一點。我不認為我們甚至討論了。

561
00:50:04,660 --> 00:50:07,340
我猜它只是一個一次性的評論。

562
00:50:07,340 --> 00:50:12,660
哦。水平與垂直縮放是不是你需要知道的東西。

563
00:50:12,660 --> 00:50:18,570
所不同的是，我認為只是想 - 哦，好吧，接聽鍵會說的區別。

564
00:50:18,570 --> 00:50:26,030
垂直縮放只是喜歡哦，我的電腦的表現不佳。我會得到一個更好的。

565
00:50:26,030 --> 00:50:29,150
而水平比例是哦，我的電腦表現不佳 - 

566
00:50:29,150 --> 00:50:33,360
讓我得到其中20個在同一任務的所有工作。

567
00:50:40,300 --> 00:50:45,520
>> [學生]：我們可以在鍊錶的方式使隊列。 >> [搶]當然。

568
00:50:45,520 --> 00:50:50,000
這是比數組的方式更容易。

569
00:50:50,000 --> 00:50:53,140
使隊列鍊錶的方式。

570
00:50:53,140 --> 00:50:58,350
首先，什麼是我們的結構的鍊錶的樣子嗎？

571
00:50:58,350 --> 00:51:17,060
[學生]：我們這樣做是為了 -  >> [搶]讓我們做它 - 是啊。

572
00:51:17,060 --> 00:51:30,000
智力值，然後結構節點下;

573
00:51:30,000 --> 00:51:34,560
所以這就是我們將使用這裡的例子。

574
00:51:34,560 --> 00:51:37,660
讓我們輸入這個東西。

575
00:51:40,030 --> 00:51:49,600
讓我們做linked_list。

576
00:51:51,750 --> 00:51:53,750
我們的結構 - 

577
00:52:05,360 --> 00:52:13,060
好吧。現在，在我們的隊列中，我們有 - 

578
00:52:13,060 --> 00:52:16,090
讓我們建立一個全球性的隊列。

579
00:52:16,090 --> 00:52:23,130
這將是節點*隊列，我們有一個出列的功能。

580
00:52:23,130 --> 00:52:28,330
我想這些東西也可以推翻真或假的 - 讓我們做到這一點。

581
00:52:28,330 --> 00:52:38,690
布爾出隊 - 我們出隊 - 哦。嗯。

582
00:52:38,690 --> 00:52:45,200
詮釋出隊 - 我們做了什麼，這之前呢？

583
00:52:45,200 --> 00:52:54,340
詮釋出隊，我們有布爾排隊，我們需要排隊的一些手段真的。

584
00:52:54,340 --> 00:53:01,360
讓我們排隊第一。

585
00:53:01,360 --> 00:53:06,520
我們有我們的隊列。我們要插入到隊列中的東西。

586
00:53:06,520 --> 00:53:12,720
什麼是最好的方式做到這一點？

587
00:53:12,720 --> 00:53:20,270
在這裡，我們的隊列中當前看起來我們有一些全球性的指針開始。

588
00:53:20,270 --> 00:53:24,910
這就是我們的隊列。

589
00:53:24,910 --> 00:53:30,350
假設我們出列的第一個元素，

590
00:53:30,350 --> 00:53:36,570
我們要去哪裡要插入的節點，使隊列，因為他們的工作呢？

591
00:53:36,570 --> 00:53:43,440
[學生]：在最末端。 >> [搶]是啊。應該是第一，先出隊列。

592
00:53:43,440 --> 00:53:48,030
這意味著在這裡應該插入新的元素。好吧。

593
00:53:48,030 --> 00:53:53,220
>> 回來的代碼，

594
00:53:53,220 --> 00:53:59,760
這意味著我們將要在我們的隊列循環。

595
00:53:59,760 --> 00:54:10,210
讓我們做節點電流=隊列，而當前不等於NULL。

596
00:54:10,210 --> 00:54:16,960
我會做的 - 好吧，讓我們分開。

597
00:54:16,960 --> 00:54:20,460
首先，電流=隊列。

598
00:54:20,460 --> 00:54:24,660
我們該怎麼做，如果目前開始為NULL？

599
00:54:24,660 --> 00:54:28,410
我們會做這2種方式。首先這種方式。

600
00:54:28,410 --> 00:54:31,450
我們該怎麼做，如果目前是空的嗎？

601
00:54:31,450 --> 00:54:34,850
這是等價的，如果隊列是空的？

602
00:54:38,550 --> 00:54:43,960
[學生]：這將返回false。 >> [搶]我們應該返回假的？

603
00:54:43,960 --> 00:54:47,120
將東西放到一個空的列表什麼是錯的？

604
00:54:47,120 --> 00:54:49,080
[學生]：沒有什麼是錯的。抱歉。

605
00:54:49,080 --> 00:54:55,980
[搶]是啊。所以，在這裡，唯一不同的是我的全局隊列被發送到我的新節點。

606
00:54:57,840 --> 00:55:02,880
然後，我做我的支票，當隊列為空。

607
00:55:02,880 --> 00:55:05,960
返回false。

608
00:55:05,960 --> 00:55:20,910
然後，隊列值等於i;隊列下等於NULL;返回true。

609
00:55:20,910 --> 00:55:25,890
好吧。我要在這裡跳槍。

610
00:55:25,890 --> 00:55:29,570
記得我們最後一次這樣做

611
00:55:29,570 --> 00:55:35,660
在這裡我們說，這是與節點**這樣的事情要容易得多。

612
00:55:35,660 --> 00:55:43,880
所以當前要和隊列，這裡 - 

613
00:55:43,880 --> 00:55:53,010
而電流 -  *當前不等於NULL  - 

614
00:55:53,010 --> 00:55:58,230
所以讓我做電流 - 我們將在第二談論這個。

615
00:55:58,230 --> 00:56:00,860
目前的下一個。好吧。

616
00:56:00,860 --> 00:56:12,910
它以這種方式，這是遍歷所有我的指針，直到我達到一個空指針。

617
00:56:12,910 --> 00:56:17,710
空指針將是我想更換我的新節點的指針。

618
00:56:17,710 --> 00:56:21,910
在iPad版 - 

619
00:56:21,910 --> 00:56:27,800
如果我原來的指針和鍊錶為空，則當前點這裡。

620
00:56:27,800 --> 00:56:29,630
這將指向NULL，

621
00:56:29,630 --> 00:56:34,440
因此，這是我最終的指針移動到指向其他一些新的節點。

622
00:56:34,440 --> 00:56:38,150
而如果例子是這樣的話在這裡

623
00:56:38,150 --> 00:56:42,720
當時要經過從這裡開始 - 我搞砸略有上升。

624
00:56:42,720 --> 00:56:50,700
其中，電流應該是當前下一個地址。

625
00:56:50,700 --> 00:57:00,200
難道這就是我的希望嗎？ *電流電流，因此給我一個節點。

626
00:57:00,200 --> 00:57:04,440
下一步運行到下一個。

627
00:57:04,440 --> 00:57:10,700
目前，我指指點點。

628
00:57:10,700 --> 00:57:13,720
讓我們做紅 - 所以我目前指指點點。

629
00:57:13,720 --> 00:57:19,710
*當前要引用此節點。

630
00:57:19,710 --> 00:57:25,080
和電流下引用此節點，但是這不是我想要的。

631
00:57:25,080 --> 00:57:27,700
我想這該節點的指針。

632
00:57:27,700 --> 00:57:40,530
因此，該指針到該節點的符號（電流）下。

633
00:57:47,660 --> 00:57:54,360
>> 在這一點上我正式達成，我想替換的節點。

634
00:57:54,360 --> 00:58:13,770
讓我們來取代所有這些隊列電流 - 現在我們已經完成了。

635
00:58:13,770 --> 00:58:21,760
有可能是拼寫錯誤，但這個想法是，這種方式與插入

636
00:58:21,760 --> 00:58:28,130
它是更容易工作的指針，我們要改變

637
00:58:28,130 --> 00:58:32,780
而不是需要跟踪的 - 好吧，是我開始NULL？

638
00:58:32,780 --> 00:58:36,430
哦，是嗎？然後，我需要創建的起始節點是一些具體的事情

639
00:58:36,430 --> 00:58:40,310
否則我會想迭代，直到接下來的事情，我指的是NULL，

640
00:58:40,310 --> 00:58:46,740
然後我會取代 - 接下來的事情是什麼 - 我的malloc的節點。

641
00:58:46,740 --> 00:58:50,740
而不需要分開這些情況下，在這裡我只處理的情況下，

642
00:58:50,740 --> 00:58:54,990
是什麼，我不再想為NULL，NULL的指針，該指針，

643
00:58:54,990 --> 00:59:01,820
這讓生活更輕鬆，除了這些都應該是*電流，因為現在 - 

644
00:59:01,820 --> 00:59:05,460
[學生]：他們仍然節點的大小嗎？

645
00:59:05,460 --> 00:59:10,480
[搶]是的。我我仍然mallocing的一個節點。

646
00:59:10,480 --> 00:59:12,980
[學生]：它會是一個節點*的大小嗎？

647
00:59:12,980 --> 00:59:20,990
[搶]說到這裡，想到的情況下，如果這是我們的鍊錶。

648
00:59:28,330 --> 00:59:33,190
這傢伙為NULL。

649
00:59:33,190 --> 00:59:36,950
之後，為什麼環，電流點這裡

650
00:59:36,950 --> 00:59:41,510
因為這是指針，該指針為NULL。

651
00:59:41,510 --> 00:59:50,380
現在，我要改變這個指針指向一個新的節點。

652
00:59:50,380 --> 00:59:58,390
首先，我的malloc，新的節點 - 節點這樣的malloc的大小。

653
00:59:58,390 --> 01:00:11,070
返回一個節點*和改變這個指針*電流等於建設

654
01:00:11,070 --> 01:00:15,780
這個新的節點，我分配。

655
01:00:15,780 --> 01:00:26,490
因此，如果當前是一個節點**，*當前是將是一個節點*

656
01:00:26,490 --> 01:00:32,540
，如果我mallocing的節點的大小的東西那麼這將返回一個指針，指向一個節點

657
01:00:32,540 --> 01:00:39,630
所以這是一個節點*  - 所以正確雙方具有相同的類型。

658
01:00:39,630 --> 01:00:46,610
所以，如果我剛才分配的是NULL，則返回false;

659
01:00:46,610 --> 01:00:54,750
其他完成將它們設置為我想他們是什麼 - 除了這些都需要括號

660
01:00:54,750 --> 01:00:57,730
因為那不是事物的秩序工作。

661
01:00:57,730 --> 01:00:59,690
如果沒有括號被解釋為

662
01:00:59,690 --> 01:01:03,010
目前的箭頭-VAL解引用。

663
01:01:03,010 --> 01:01:07,010
相反，我想取消引用這使我想到一個節點的電流。

664
01:01:07,010 --> 01:01:10,620
然後，我要與該節點關聯的值。

665
01:01:10,620 --> 01:01:17,670
>> [學生]：我想箭頭允許你繞過，直接的價值。

666
01:01:17,670 --> 01:01:22,640
[搶]他們這樣做。那如果我有 - 比方說，隊列就是一個例子。

667
01:01:22,640 --> 01:01:28,400
我可以做的隊列箭頭值等於i，因為隊列是一個節點*。

668
01:01:28,400 --> 01:01:39,160
如果有一些很好的語法像電流不再箭頭Val或東西

669
01:01:39,160 --> 01:01:42,540
並解引用，那麼這將很好地工作。

670
01:01:42,540 --> 01:01:44,790
[學生]：因此，箭頭是只有1解引用。 >> [搶]是啊。

671
01:01:44,790 --> 01:01:53,590
另外，我寫這篇文章作為（** current.val）。

672
01:01:53,590 --> 01:02:02,490
就像我也可以寫隊列（隊列）的值。

673
01:02:04,430 --> 01:02:09,250
因此，讓我們插入。嗯，這是我想在隊列。

674
01:02:09,250 --> 01:02:12,030
出列是顯著更短。

675
01:02:12,030 --> 01:02:18,280
讓我們在這裡無效的清潔。

676
01:02:18,280 --> 01:02:22,820
所以，出隊。我什麼元素出隊？

677
01:02:22,820 --> 01:02:24,820
[學生]：第一個嗎？ >> [搶]是啊。

678
01:02:24,820 --> 01:02:32,880
如果我的第一個NULL  - 回報 - 我不知道我們想做什麼回報 -  INT_MAX;

679
01:02:32,880 --> 01:02:37,580
那麼你應該做一個檢查，看看如果返回了INT_MAX。

680
01:02:37,580 --> 01:02:44,090
這是GET公司做我們想要的東西之類的事情 - 

681
01:02:44,090 --> 01:02:54,610
我們可以只返回隊列VAL？這是我們想要做什麼？

682
01:02:54,610 --> 01:02:58,010
出列也含蓄地從隊列中刪除的項目，

683
01:02:58,010 --> 01:03:10,840
所以，讓我們先說 - 讓我們得到一個tmp目錄指向到我們的隊列中的第一個節點。

684
01:03:10,840 --> 01:03:15,510
現在，我們要推進我們的隊列，在隊列中的下一件事。

685
01:03:15,510 --> 01:03:21,450
現在我們有TMP左。 TMP val是我們要返回的東西。

686
01:03:21,450 --> 01:03:24,180
因此，值= tmp目錄 - >值;

687
01:03:24,180 --> 01:03:31,190
但在此之前，我們返回，我們也應免費tmp和回報VAL。

688
01:03:31,190 --> 01:03:36,350
在這裡操作的順序是很重要的，我們需要抓住一個tmp

689
01:03:36,350 --> 01:03:40,520
在我們繼續之前的隊列中的下一個元素。

690
01:03:40,520 --> 01:03:44,860
我們需要得到的價值之前，我們免費TMP，

691
01:03:44,860 --> 01:03:48,710
然後我們就可以返回的val。

692
01:03:48,710 --> 01:03:50,680
>> [學生]如果我們設置了隊列到隊列未來？

693
01:03:50,680 --> 01:03:57,800
[搶]是的。這是造成不好的循環/後釋放也無妨，這是行不通的。

694
01:03:57,800 --> 01:03:59,900
隊列隊列 - >下一步。

695
01:03:59,900 --> 01:04:03,230
我們要推進到下一個元素的隊列，沒有前進的下一個元素

696
01:04:03,230 --> 01:04:08,170
什麼元素。

697
01:04:08,170 --> 01:04:17,660
堆棧將顯著 - 像更容易，出隊是完全一樣的

698
01:04:17,660 --> 01:04:20,190
因為我們拉關閉前的堆棧。

699
01:04:20,190 --> 01:04:24,030
最終隊列將是非常相似的，我們只是想分配一個節點

700
01:04:24,030 --> 01:04:27,670
並插入到前面的堆棧，所以我們甚至不需要任何東西循環。

701
01:04:27,670 --> 01:04:31,420
我們只是直接插入在了前面。

702
01:04:42,500 --> 01:04:44,640
大家好？

703
01:04:44,640 --> 01:04:49,760
>> 好吧。還有問題嗎？

704
01:04:49,760 --> 01:04:56,570
[學生]：什麼重要的事情，我應該記住，從最近的演講嗎？

705
01:04:56,570 --> 01:04:58,730
[搶]最近的演講。

706
01:04:58,730 --> 01:05:01,620
你不需要知道任何代碼。

707
01:05:01,620 --> 01:05:07,590
你應該知道的總體思路。

708
01:05:07,590 --> 01:05:11,650
Nate的一半沒有任何代碼，所以這些幻燈片是在網上。

709
01:05:11,650 --> 01:05:15,220
他們只是喜歡看他們，他們的主要觀點。

710
01:05:15,220 --> 01:05:28,630
我的一半 - 知道的總體思路，首先你不能相信任何事情。

711
01:05:28,630 --> 01:05:38,070
事實上，喜歡的過程中，編譯器可能是壞的，

712
01:05:38,070 --> 01:05:40,870
但它並不重要的源代碼看起來不錯。

713
01:05:40,870 --> 01:05:46,390
因為編譯器可能會改變，改變的源代碼

714
01:05:46,390 --> 01:05:50,860
 在編譯過程中。

715
01:05:50,860 --> 01:05:58,140
在相同的時間，只是想 - 我想這些都是像它的主要觀點。

716
01:05:59,560 --> 01:06:09,030
>> [學生]：你提到，我們不需要知道任何有關向Firesheep  - 

717
01:06:09,030 --> 01:06:13,110
還是我們需要知道嗎？

718
01:06:13,110 --> 01:06:18,360
[搶] Nate的一半的東西，什麼，內特感動 - 

719
01:06:18,360 --> 01:06:22,760
如，Wireshark的FireSheep  - 我不什至覺得他做了詳細的Firesheep。

720
01:06:22,760 --> 01:06:28,620
你也做了一些與該 - 是Firesheep  - 上週？

721
01:06:28,620 --> 01:06:31,110
在您觸摸，？

722
01:06:31,110 --> 01:06:34,060
[學生]：是的，我想我們可能有 -  >> [搶]是啊。

723
01:06:34,060 --> 01:06:40,880
我們不會給你Firesheep輸出，並說“這解釋”。

724
01:06:40,880 --> 01:06:44,960
它只是將 - 這將是一個問題，比如什麼是Firesheep？

725
01:06:44,960 --> 01:06:47,290
它是什麼用的呢？

726
01:06:47,290 --> 01:06:52,120
[學生]：我認為它僅適用於第4版的Firefox或東西。

727
01:06:52,120 --> 01:06:55,320
[搶]它可能會破壞現在。

728
01:07:11,430 --> 01:07:14,070
我不知道。

729
01:07:14,070 --> 01:07:18,330
他們似乎並沒有手動禁用它，

730
01:07:18,330 --> 01:07:21,210
但也許它不工作，最近的Firefox。

731
01:07:21,210 --> 01:07:24,790
[學生]：其實，我想安裝它，因為它說，這將是兼容的。

732
01:07:24,790 --> 01:07:28,880
[搶]所以，我想這是行不通的，與最近的Firefox。

733
01:07:28,880 --> 01:07:32,360
但這樣的想法仍然有效，它的意思是什麼顯示。

734
01:07:32,360 --> 01:07:39,430
這是荒謬的世界是多少不是生活在HTTPS的時間。

735
01:07:39,430 --> 01:07:43,820
即使在過去的2年或什麼，它仍然是 - 有顯著改善

736
01:07:43,820 --> 01:07:47,210
使用HTTPS的網站數量。

737
01:07:49,920 --> 01:07:52,580
>> [學生]：我們是否需要通過HTTP去嗎？

738
01:07:52,580 --> 01:07:58,050
[搶]的協議呢？ >> [學生]：有的，我們應該知道的事情。

739
01:07:58,050 --> 01:08:06,220
羅布所有權利。基本的東西是我的一切，你可以看到在您的網絡“選項卡。

740
01:08:06,220 --> 01:08:12,160
當我請求一個頁面 - 回來的主要的東西。

741
01:08:12,160 --> 01:08:16,090
這裡你可以看到，我的要求。

742
01:08:16,090 --> 01:08:19,220
Chrome瀏覽器會發生這一切對我們很好地格式化

743
01:08:19,220 --> 01:08:21,970
請求的URL是這樣的，請求方法為GET，

744
01:08:21,970 --> 01:08:24,800
的狀態碼是200 OK。

745
01:08:24,800 --> 01:08:28,279
如果我打“查看源文件”，我看到更多的，直接的 - 

746
01:08:28,279 --> 01:08:35,680
這是 - 我們可以告訴你這些，但是這是不是太難以解釋它們之間的。

747
01:08:35,680 --> 01:08:41,729
下面是我做的直接請求，所以這意味著我去

748
01:08:41,729 --> 01:08:48,160
apps.cs50.net/discuss/threads/inbox/all/HTTP/1.1。

749
01:08:48,160 --> 01:08:57,569
使用的協議是HTTP/1.1這幾乎是 - 它總是要的。

750
01:08:57,569 --> 01:09:01,490
在這裡，我們使用GET，所以這也可能是POST。

751
01:09:01,490 --> 01:09:04,660
然後 - 所有的響應頭 - 如果我們認為這源，

752
01:09:04,660 --> 01:09:07,740
這就是我們看到的200 OK。

753
01:09:07,740 --> 01:09:11,069
了解這些可能的不同的狀態代碼。

754
01:09:11,069 --> 01:09:15,520
我認為，在審查中，我們說一對夫婦這些，

755
01:09:15,520 --> 01:09:20,640
所以403，404  - 那些常見的一種。

756
01:09:20,640 --> 01:09:26,810
這是它的主要思想。

757
01:09:29,990 --> 01:09:35,120
HTTP和HTTPS之間的差異，這是加密的。

758
01:09:35,120 --> 01:09:42,319
>> [學生]：你做了什麼？ >> [搶]我是這麼認為的。嗯，是的。

759
01:09:42,319 --> 01:09:46,470
[學生]：請問你聊的很一般的加密如何工作的呢？

760
01:09:46,470 --> 01:09:49,920
因為我們談到例如壓縮霍夫曼文件時，

761
01:09:49,920 --> 01:09:54,890
你知道如何解壓縮它們，因為你實際發送的哈希表內的文件

762
01:09:54,890 --> 01:09:56,950
那麼，如何加密工作嗎？

763
01:09:56,950 --> 01:10:00,830
你怎麼知道如何對信息進行加密，如果你還沒有真正向客戶端發送

764
01:10:00,830 --> 01:10:05,740
的關鍵 - 實際上，你可以抓住這關鍵 - ？

765
01:10:05,740 --> 01:10:07,740
的一般過程是如何工作的？

766
01:10:07,740 --> 01:10:09,870
[搶]加密的一般過程 - 

767
01:10:09,870 --> 01:10:15,590
這是一個令人難以置信的詳細的問題，我會回答。

768
01:10:15,590 --> 01:10:21,490
有一個短暫的 - 好了，湯米和我做了短。

769
01:10:21,490 --> 01:10:26,060
不幸的是，就像是26分鐘，所以它不是一個短期的。這是一個長期。

770
01:10:26,060 --> 01:10:31,530
但是，我們的短RSA，這只是其中的一個例子，這些，

771
01:10:31,530 --> 01:10:40,420
RSA的整體HTTPS協議的一部分。

772
01:10:40,420 --> 01:10:46,060
這個想法 -  RSA公共密鑰加密的一個例子，

773
01:10:46,060 --> 01:10:49,690
這意味著你有2個獨立的按鍵。

774
01:10:49,690 --> 01:10:51,690
您可以使用一鍵加密東西，

775
01:10:51,690 --> 01:10:54,410
您使用的另一個關鍵解密的東西。

776
01:10:54,410 --> 01:10:58,360
此鍵使用加密的東西是一個公共的。

777
01:10:58,360 --> 01:11:03,500
該網站可以向您發送此加密密鑰。

778
01:11:03,500 --> 01:11:08,280
他們這樣做的加密密鑰發送給您，當你想要送東西還給他們

779
01:11:08,280 --> 01:11:13,550
您使用的加密密鑰來加密所有的數據發送給他們。

780
01:11:13,550 --> 01:11:16,110
因此，他們的私鑰是唯一的。

781
01:11:16,110 --> 01:11:22,630
如果該私鑰出名，那麼任何人都能夠解密您的數據。

782
01:11:22,630 --> 01:11:27,980
但是，私有密鑰 - 這是數學相關的公共密鑰，但你不能

783
01:11:27,980 --> 01:11:33,640
圖一，從其他的 - 這樣的私鑰可以用來對數據進行解密。

784
01:11:33,640 --> 01:11:36,630
由於他們的私鑰是唯一的，

785
01:11:36,630 --> 01:11:38,920
他們是唯一可以讀取數據。

786
01:11:38,920 --> 01:11:44,170
因此，即使公共密鑰是公開的，

787
01:11:44,170 --> 01:11:47,660
我用的是相同的 - 當我去Google.com或別的什麼東西，

788
01:11:47,660 --> 01:11:50,010
他們可能有多個，我不知道 - 但如果我去到Google.com，

789
01:11:50,010 --> 01:11:54,770
他去到Google.com，她去到Google.com  - 

790
01:11:54,770 --> 01:11:59,250
我們都可以使用相同的公鑰來加密自己的信息，但是我們想要的。

791
01:11:59,250 --> 01:12:04,010
但我們沒有能夠弄清楚 - 要能夠解密

792
01:12:04,010 --> 01:12:09,940
他們的信息，因為公鑰是無法解密。

793
01:12:09,940 --> 01:12:13,050
它可以加密。

794
01:12:13,050 --> 01:12:23,250
它的樂趣/詳細的數學 - 像一堆模塊的運營商和指數和東西，

795
01:12:23,250 --> 01:12:28,890
它只是工作的私鑰是唯一可以

796
01:12:28,890 --> 01:12:33,620
解密的公共密鑰加密的東西。

797
01:12:33,620 --> 01:12:38,020
是啊。有關詳細信息，請參閱RSA短。

798
01:12:38,020 --> 01:12:41,880
[學生]：是在網站上呢？

799
01:12:41,880 --> 01:12:46,210
[搶]是的，我認為這是在這一點上。或者至少一個YouTube鏈接到它被張貼。

800
01:12:51,330 --> 01:12:57,190
讓我們來看看。短褲。我認為這將是第2週相關。是啊。 RSA。

801
01:12:57,190 --> 01:13:03,780
它是 - 我們玩不下去 -  24分鐘。

802
01:13:03,780 --> 01:13:05,780
這是一個漫長的。

803
01:13:07,740 --> 01:13:09,740
>> 還有問題嗎？

804
01:13:09,740 --> 01:13:14,770
[學生]：你能簡單談談的位掩碼？ >> [搶]當然。

805
01:13:14,770 --> 01:13:23,090
簡單地說，就是這樣的想法一樣 -  >> [學生]：這是什麼，羅布？

806
01:13:23,090 --> 01:13:32,760
[搶位掩碼。我們的想法是 - 讓我們只說我們有一些 - 我們使用了一些整數 - 

807
01:13:32,760 --> 01:13:41,490
詮釋x  - 所以，我們開始了在0。

808
01:13:41,490 --> 01:13:47,900
現在，該整數是32位，所以任何單一1的那些位可以用來表示

809
01:13:47,900 --> 01:13:50,600
一個特定的FLAC。

810
01:13:50,600 --> 01:13:56,210
這是在操作系統代碼，如果你看一下，他們用這一切的地方

811
01:13:56,210 --> 01:14:03,900
可能往上頂的地方，他們的哈希定義 - 

812
01:14:03,900 --> 01:14:09,020
讓我們來看看一些例子。

813
01:14:09,020 --> 01:14:22,720
人-2  - 開放 - 開放式的系統調用，我們可以在這裡看到它的一個參數的數據類型為int的標誌 - 

814
01:14:22,720 --> 01:14:29,120
什麼期望，這樣的說法是這些標誌。

815
01:14:29,120 --> 01:14:33,030
我們看到O_APPEND，O_ASYNC，O_CLOEXEC，

816
01:14:33,030 --> 01:14:37,130
O_CREAT，依此類推。

817
01:14:37,130 --> 01:14:45,260
O_DIRECT。這些各種各樣的標誌是哈希定義的某個地方。

818
01:14:45,260 --> 01:14:47,260
所有的人都恰好是1位。

819
01:14:47,260 --> 01:14:57,600
所以，O_CREAT可能會對哈希定義為1，左移位，4（1 << 4）。

820
01:14:57,600 --> 01:15:02,280
這將是 - 每當我使用O_CREAT，只是要 - 

821
01:15:02,280 --> 01:15:09,350
在二進制1，0，0，0，和收到的30上下的零。

822
01:15:09,350 --> 01:15:13,930
這是一套只有一個位，該位代表這個標誌。

823
01:15:13,930 --> 01:15:18,160
，所以沒有其它標誌將被左移4。

824
01:15:18,160 --> 01:15:30,390
我能代表一個整數的32個標誌做 - 

825
01:15:30,390 --> 01:15:40,850
X = O_CREAT位聰明或O_DIRECT。

826
01:15:40,850 --> 01:15:43,640
你剛採摘的這些標誌中的任意2。

827
01:15:43,640 --> 01:15:48,600
現在x都將有2比特集對應的2比特

828
01:15:48,600 --> 01:15:53,490
O_CREAT和O_DIRECT。

829
01:15:53,490 --> 01:15:58,740
的方式，然後 - 然後我們通過x轉換成開放的功能，

830
01:15:58,740 --> 01:16:02,950
開放的需要，看看有什麼實際設置標誌。

831
01:16:02,950 --> 01:16:06,480
所以，這就是它會做這樣的事情

832
01:16:06,480 --> 01:16:19,340
如果（X＆O_CREAT）做一些事情，

833
01:16:19,340 --> 01:16:27,110
如果（X＆O_DIRECT）做別的事情，

834
01:16:27,110 --> 01:16:30,300
然後可能有一些標誌，我們並沒有設定 - 

835
01:16:30,300 --> 01:16:35,730
如果（X＆O_  - 我不知道其他標誌是什麼 - 

836
01:16:35,730 --> 01:16:42,140
（x和O_RDONLY） - 該特定的條件時不會被執行。

837
01:16:42,140 --> 01:16:44,030
或代碼塊不會被執行，

838
01:16:44,030 --> 01:16:48,030
但這些是因為這些設置標誌。

839
01:16:48,030 --> 01:16:57,400
注意到，在C，任何不為0的值是真實的。

840
01:16:57,400 --> 01:17:05,020
所以，（X＆O_CREAT）為0或O_CREAT

841
01:17:05,020 --> 01:17:07,990
因為O_CREAT只有一個位設置。

842
01:17:07,990 --> 01:17:12,800
如果該位被設置，那麼這是怎麼回事返回O_CREAT  - 

843
01:17:12,800 --> 01:17:16,640
這一點位被置位的二進制文件。

844
01:17:16,640 --> 01:17:23,400
如果該位下沒有被設置，那麼它會返回0，在這種情況下，我們知道沒有設置標誌。

845
01:17:23,400 --> 01:17:25,400
這就是你使用的位掩碼。

846
01:17:25,400 --> 01:17:29,050
我覺得在以往的考試或可能在課堂上或東西 - 

847
01:17:29,050 --> 01:17:35,150
你也可以使用打印出的二進制變量的位掩碼。

848
01:17:35,150 --> 01:17:46,250
所以我可以使用 - 遍歷 -  1，左移，0  - ，然後打印，如果x  -​​ 

849
01:17:46,250 --> 01:17:52,570
如果X和1，左移，0  - 然後打印一個0或1。或打印一個1，否則為0打印。

850
01:17:52,570 --> 01:18:00,620
然後我去一次 - 如果x＆1，左移位，2  - 那麼這意味著，在第二位

851
01:18:00,620 --> 01:18:04,450
變量的設置，所以我打印，我打印0。

852
01:18:04,450 --> 01:18:06,860
而且我認為我們可能會想這樣做，相反的順序，因為

853
01:18:06,860 --> 01:18:10,120
通常你想的左側是最高位

854
01:18:10,120 --> 01:18:24,510
右側是最低位，所以它可能會循環4 INT I = 31，直到我打了0，

855
01:18:24,510 --> 01:18:32,320
然後做精確的條件 - 如果X和1，左移，我打印1，否則為0。

856
01:18:32,320 --> 01:18:34,320
[學生]：謝謝你。

857
01:18:36,280 --> 01:18:38,550
>> [搶]我認為我們沒時間了。

858
01:18:38,550 --> 01:18:42,840
任何更多的時間秒的最後幾個問題嗎？

859
01:18:42,840 --> 01:18:47,710
好的。祝你好運的明天。

860
01:18:47,710 --> 01:18:54,780
這是最後一節，下週將是可選的。

861
01:18:54,780 --> 01:19:03,770
我會還給測驗，我們可以去他們可能去了其他的東西，

862
01:19:03,770 --> 01:19:09,230
你有興趣，或最終項目的事，或將來的CS類的東西 - 我不知道。

863
01:19:09,230 --> 01:19:12,070
但是，這是最後的填充材料的邊。

864
01:19:12,070 --> 01:19:15,070
再見！

865
01:19:15,070 --> 01:19:20,970
（掌聲）

866
01:19:22,250 --> 01:19:24,420
>> [CS50.TV]