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

2
00:00:08,090 --> 00:00:09,810
>> JASON HIRSCHHORN：歡迎光臨，
每個人，至10週。

3
00:00:09,810 --> 00:00:15,130
這是一個令人興奮的一周，因為
明天是測驗1，我們將得到

4
00:00:15,130 --> 00:00:16,400
在第二個。

5
00:00:16,400 --> 00:00:21,770
今天在節中，我們將去
對一些資源進行測驗，並

6
00:00:21,770 --> 00:00:24,890
然後，我會回答任何和所有
問題你們有。

7
00:00:24,890 --> 00:00:27,880
我們將最終結束於
一些實際問題。

8
00:00:27,880 --> 00:00:30,940
>> 我們可以花整款
回答問題。

9
00:00:30,940 --> 00:00:33,240
我們可以花整款
去在實踐中的問題。

10
00:00:33,240 --> 00:00:36,890
我們只會擴大，以填補
空間和時間，我們有。

11
00:00:36,890 --> 00:00:40,590
>> 所以我每星期把這個名單了，但
這個星期是特別重要的。

12
00:00:40,590 --> 00:00:44,980
對於學習，如果你還沒有
已經開始了，男孩哦。

13
00:00:44,980 --> 00:00:46,400
但希望你已經開始。

14
00:00:46,400 --> 00:00:50,710
和你正在經歷的材料
這裡列出的資源。

15
00:00:50,710 --> 00:00:54,300
我會極力推薦
許多這些。

16
00:00:54,300 --> 00:00:58,780
>> 特別是，課堂筆記是
非常重要和有益的。

17
00:00:58,780 --> 00:01:02,880
該study.cs50.net提供
在很多大底

18
00:01:02,880 --> 00:01:04,250
我們討論的主題。

19
00:01:04,250 --> 00:01:07,810
它也有一些偉大的
實踐問題。

20
00:01:07,810 --> 00:01:11,260
然後，谷歌是偉大的，太。

21
00:01:11,260 --> 00:01:12,360
我不知道你會用它來幹什麼。

22
00:01:12,360 --> 00:01:14,090
但使用谷歌，以及。

23
00:01:14,090 --> 00:01:16,680
>> 伸手給我，如果您有任何
問題，意見或疑慮。

24
00:01:16,680 --> 00:01:19,420
期待在審查會議
幻燈片從昨晚。

25
00:01:19,420 --> 00:01:21,540
或者，如果你有一段時間了，
觀看視頻。

26
00:01:21,540 --> 00:01:24,930
它們提供了很多有幫助的
材料和信息。

27
00:01:24,930 --> 00:01:29,730
並設法彌補，如果不是全部，很多的
我們已經討論了，而且你的主題

28
00:01:29,730 --> 00:01:32,610
在測驗可能會看到。

29
00:01:32,610 --> 00:01:35,590
>> 說到測驗，即
將是明天。

30
00:01:35,590 --> 00:01:37,260
它擁有75分鐘之久。

31
00:01:37,260 --> 00:01:40,740
你們中許多人正在服用它在1
點多了，有些人相當

32
00:01:40,740 --> 00:01:42,740
把它在5:30。

33
00:01:42,740 --> 00:01:45,300
當時你正在服用它和
你正在做它的位置，確保

34
00:01:45,300 --> 00:01:49,400
您簽出該文檔
在CS50.net主頁。

35
00:01:49,400 --> 00:01:54,340
>> 請記住，你可以得到一個8 1/2
由11片隨身攜帶。

36
00:01:54,340 --> 00:01:57,310
通常情況下，人們不使用此
表在所有的考試中。

37
00:01:57,310 --> 00:01:59,740
不過說真的，這是一個令人難以置信
有用的學習工具。

38
00:01:59,740 --> 00:02:04,370
所以這片放在一起是什麼
我花了大概三四個小時

39
00:02:04,370 --> 00:02:07,110
當我攻讀CS50做什麼，
這是很容易的最有幫助

40
00:02:07,110 --> 00:02:08,740
這樣我可以學習的測驗。

41
00:02:08,740 --> 00:02:10,949
所以，即使你有一些其他人的
學習指南來看待和

42
00:02:10,949 --> 00:02:14,740
作為參考使用，我強烈推薦
使自己的學習指南，把

43
00:02:14,740 --> 00:02:15,490
這些東西在一起。

44
00:02:15,490 --> 00:02:17,335
這確實能幫助你學習
所有的材料。

45
00:02:17,335 --> 00:02:20,270

46
00:02:20,270 --> 00:02:24,810
>> 最後但並非最不重要在本節中，
有一個明天的測驗後，

47
00:02:24,810 --> 00:02:25,940
更多講座 - 

48
00:02:25,940 --> 00:02:26,960
下週一。

49
00:02:26,960 --> 00:02:30,430
還有一節，沒有未來
週二感恩節前，但

50
00:02:30,430 --> 00:02:31,630
週二之後。

51
00:02:31,630 --> 00:02:36,600
我們將一起開會作最後
再見了黨和也做了一些很酷

52
00:02:36,600 --> 00:02:41,530
事情讓你們感到興奮
進一步研究在計算機科學。

53
00:02:41,530 --> 00:02:45,040
>> 還有一個多項目，多了一個
公平的，多一個hackathon。

54
00:02:45,040 --> 00:02:47,900
我們正在接近CS50年底，
這是令人興奮的 - 

55
00:02:47,900 --> 00:02:50,950
而且，如果你像
我，有點難過。

56
00:02:50,950 --> 00:02:53,950
在我繼續前進，沒有任何人有
大約有任何疑問什麼

57
00:02:53,950 --> 00:02:55,200
我們已經討論了這麼遠嗎？

58
00:02:55,200 --> 00:03:02,760

59
00:03:02,760 --> 00:03:08,730
>> 好了，好讓我們在一些問題
您有測驗和主題

60
00:03:08,730 --> 00:03:09,960
我們可能涵蓋。

61
00:03:09,960 --> 00:03:11,540
所以這是一個列表，我放在一起。

62
00:03:11,540 --> 00:03:15,500
它絕不是詳盡，但
希望能喚起你的記憶，如果你

63
00:03:15,500 --> 00:03:20,310
有任何關於這些問題的一些
主題，或者如果您有關於問題

64
00:03:20,310 --> 00:03:23,260
從測驗練習題
在過去的幾年。

65
00:03:23,260 --> 00:03:27,470
>> 我有幾個問題，是
通過電子郵件發送給我，但我想暫緩

66
00:03:27,470 --> 00:03:29,490
那些一秒鐘。

67
00:03:29,490 --> 00:03:34,570
沒有任何人有任何疑問，
他們不明白的問題，

68
00:03:34,570 --> 00:03:38,100
答案他們不明白
讓我們開始？

69
00:03:38,100 --> 00:03:39,520
阿維。

70
00:03:39,520 --> 00:03:41,585
>> 觀眾：你能隨便去了
DOM和Ajax的真快？

71
00:03:41,585 --> 00:03:46,540
就像，我們需要知道或應該
了解他們的？

72
00:03:46,540 --> 00:03:49,750
>> JASON HIRSCHHORN：我要回答
通常這個問題，有什麼事我

73
00:03:49,750 --> 00:03:52,100
需要了解特定主題X'

74
00:03:52,100 --> 00:03:55,280
因為我有一種感覺，你們中許多人
要問我，或者是

75
00:03:55,280 --> 00:03:56,570
好奇的。

76
00:03:56,570 --> 00:04:02,920
所以，在某種程度上，這一專題
涵蓋演講，或部分，或

77
00:04:02,920 --> 00:04:06,460
study.cs50.net，問題集，你
應該熟悉它。

78
00:04:06,460 --> 00:04:10,580
>> 所以，你不需要知道每一種類型
標籤，是HTML中可用或

79
00:04:10,580 --> 00:04:15,950
每一種類型的屬性或屬性的
你可以給一些在CSS中。

80
00:04:15,950 --> 00:04:20,204
但是，如果你看到它在一個演講的例子，
如果你看到它在一個問題

81
00:04:20,204 --> 00:04:23,290
集，你應該很熟悉
有了它，你看到特別的東西

82
00:04:23,290 --> 00:04:24,260
在演講。

83
00:04:24,260 --> 00:04:28,510
所以我們討論的文件
在對象模型中的位

84
00:04:28,510 --> 00:04:30,530
部分，更多的是在演講。

85
00:04:30,530 --> 00:04:32,990
你應該很熟悉
有這麼大的它。

86
00:04:32,990 --> 00:04:34,750
>> 而且你應該熟悉
AJAX到相同的程度。

87
00:04:34,750 --> 00:04:38,105
我們從來沒有見過難以置信的先進或
阿賈克斯的複雜的例子，所以

88
00:04:38,105 --> 00:04:40,920
你不會被要求做
一些令人難以置信的複雜。

89
00:04:40,920 --> 00:04:45,180
但你可能會問，我怎麼
使用jQuery做一個Ajax調用？

90
00:04:45,180 --> 00:04:47,350
這是你已經看到了一些東西
之前的時間，無論是在

91
00:04:47,350 --> 00:04:51,370
審查會議，並在講座中，和
它的代碼只有兩個十歲上下行。

92
00:04:51,370 --> 00:04:53,190
>> 所以這是你應該
熟悉。

93
00:04:53,190 --> 00:04:55,550
但同樣，對於所有這些主題，
如果你已經看到了

94
00:04:55,550 --> 00:04:59,220
之前，它是公平的遊戲。

95
00:04:59,220 --> 00:05:01,540
我們可能會問你 - 很明顯，我們是
要問你的事情你

96
00:05:01,540 --> 00:05:02,340
以前沒有見過的。

97
00:05:02,340 --> 00:05:04,240
編碼的東西你有沒有
以前見過。

98
00:05:04,240 --> 00:05:06,570
這並不是說你有沒有
看到解決工具

99
00:05:06,570 --> 00:05:08,120
這個問題之前。

100
00:05:08,120 --> 00:05:09,200
你已經看到了這些工具。

101
00:05:09,200 --> 00:05:11,160
>> 例如，在測試1，如果
你需要編寫strlen的。

102
00:05:11,160 --> 00:05:12,790
我們以前沒有編碼的strlen。

103
00:05:12,790 --> 00:05:14,980
但你知道如何使用for循環，
你知道如何，如果條件下使用。

104
00:05:14,980 --> 00:05:18,570
你知道如何用C編寫的變量
這將是在這裡同樣的事情。

105
00:05:18,570 --> 00:05:22,350
你不會被要求做
你有沒有看到過，但什麼

106
00:05:22,350 --> 00:05:25,150
你可能會問到，像，放
東西一起以一種新穎的方式，或

107
00:05:25,150 --> 00:05:27,650
解決不同類型的問題。

108
00:05:27,650 --> 00:05:30,830
>> 對不起，這不是特定於您
的問題，但我不能回答有關

109
00:05:30,830 --> 00:05:34,390
每一個話題你
做或不需要知道。

110
00:05:34,390 --> 00:05:36,830
但同時，對不起，這最後的事情。

111
00:05:36,830 --> 00:05:42,900
我們花了顯著更多的時間
在鏈接列表比我們對阿賈克斯。

112
00:05:42,900 --> 00:05:46,160
你沒有在問題集中使用Ajax。

113
00:05:46,160 --> 00:05:48,510
其中所述中心功能
問題設置了鏈接列表。

114
00:05:48,510 --> 00:05:50,370
我們花了很多時間在講座
和使用它部分。

115
00:05:50,370 --> 00:05:57,080
>> 所以，賠率是鏈接列表將拿出更多
經常在測驗比阿賈克斯的意志。

116
00:05:57,080 --> 00:06:00,390
或問題不得不與鏈接
名單將是值得更多的積分。

117
00:06:00,390 --> 00:06:03,520
所以，你可以肯定聚焦和窄
在東西比較多

118
00:06:03,520 --> 00:06:06,720
可能是因為我們要拿出
花更多的時間在他們身上。

119
00:06:06,720 --> 00:06:08,700
>> 確定沒有別的問題？

120
00:06:08,700 --> 00:06:09,890
是啊。

121
00:06:09,890 --> 00:06:13,660
>> 觀眾：我們可以走了過來使用
在JavaScript中的匿名函數？

122
00:06:13,660 --> 00:06:17,140
我是有一點困惑了。

123
00:06:17,140 --> 00:06:20,180
>> JASON HIRSCHHORN：那麼在JavaScript  - 

124
00:06:20,180 --> 00:06:24,400
我試圖想我怎麼樣
可以寫這樣的 - 

125
00:06:24,400 --> 00:06:27,590
讓我們實際打開了這個代碼。

126
00:06:27,590 --> 00:06:31,830

127
00:06:31,830 --> 00:06:36,030
所以這是代碼的最後一周，我們做到了。

128
00:06:36,030 --> 00:06:41,400
和你以前，如果你看到了這
曾在這裡一節的最後一周。

129
00:06:41,400 --> 00:06:43,180
或者你已經看到的東西
之前與此類似。

130
00:06:43,180 --> 00:06:44,800
>> 但你可以看看這個第一道防線。

131
00:06:44,800 --> 00:06:46,950
這是你如何開始 - 

132
00:06:46,950 --> 00:06:48,010
大家以前也見過這個。

133
00:06:48,010 --> 00:06:51,930
如果你想要把一些JavaScript代碼，
你把它放在這裡面，假設

134
00:06:51,930 --> 00:06:53,520
您正在使用JQuery。

135
00:06:53,520 --> 00:06:56,940
這是說，什麼也不做
直到文件的加載。

136
00:06:56,940 --> 00:06:59,940
>> 然後，簡略的，你看這裡
我們正在做這樣的事情 - 

137
00:06:59,940 --> 00:07:02,560
功能開括號，括號封閉。

138
00:07:02,560 --> 00:07:05,250
因此，我們沒有給這個
函數的名稱。

139
00:07:05,250 --> 00:07:09,160
我們不會定義這個函數
應該運行，然後

140
00:07:09,160 --> 00:07:10,830
說它是一堆倍。

141
00:07:10,830 --> 00:07:15,140
我們只是說這個文件
已經接受一個函數。

142
00:07:15,140 --> 00:07:16,690
一對夫婦的事情要做。

143
00:07:16,690 --> 00:07:20,670
>> 我們不想花時間
給它一個名稱，或將其保存為

144
00:07:20,670 --> 00:07:21,650
永久。

145
00:07:21,650 --> 00:07:24,150
我們只是想運行一些事情。

146
00:07:24,150 --> 00:07:27,500
因此，一個匿名函數排序
的服務的目的。

147
00:07:27,500 --> 00:07:30,280
如果你不打算使用的東西
一遍又一遍，所以你不需要

148
00:07:30,280 --> 00:07:32,420
給它一個名字 - 你只是
想一次使用它 - 

149
00:07:32,420 --> 00:07:36,720
你只說功能，
例如，在這種情況下，你只是

150
00:07:36,720 --> 00:07:38,280
定義的東西，
你可以給一個名稱。

151
00:07:38,280 --> 00:07:40,920
>> 喜歡，我們可以拉這個功能了
並給它一個名稱，然後調用

152
00:07:40,920 --> 00:07:41,760
在這裡發揮作用。

153
00:07:41,760 --> 00:07:44,270
但是，我們並不需要，因為我們不
不想浪費時間給它一個名稱或

154
00:07:44,270 --> 00:07:46,240
浪費的東西在我們的名稱空間。

155
00:07:46,240 --> 00:07:47,530
而且你會看到很多。

156
00:07:47,530 --> 00:07:52,810
例如，我們看到了很多在這
代碼，但是你以前見過這個時

157
00:07:52,810 --> 00:07:54,010
你點擊的東西 - 

158
00:07:54,010 --> 00:07:55,980
運行此類型的代碼。

159
00:07:55,980 --> 00:07:59,850
>> 我們可以定義我們想要的代碼
運行時點擊的，在這種情況下，

160
00:07:59,850 --> 00:08:03,450
這個ID，作為一個單獨的函數
然後運行該功能。

161
00:08:03,450 --> 00:08:07,940
但在這種情況下，我們只是跳繩
該步驟和在這裡將它移入和

162
00:08:07,940 --> 00:08:10,340
只是一切定義
我們希望發生的，並

163
00:08:10,340 --> 00:08:12,450
不給它一個名字。

164
00:08:12,450 --> 00:08:15,550
這仍然可能沒有
回答你的問題。

165
00:08:15,550 --> 00:08:15,960
>> 觀眾：不是，它的作用。

166
00:08:15,960 --> 00:08:18,290
我的意思是，我想我只是真的不
知道為什麼它會是一個

167
00:08:18,290 --> 00:08:20,800
功能可言，雖然。

168
00:08:20,800 --> 00:08:21,590
因為它沒有真正被調用。

169
00:08:21,590 --> 00:08:23,170
它並沒有真正有一個名字。

170
00:08:23,170 --> 00:08:25,510
>> JASON HIRSCHHORN：這是在一個函數
感，它的一系列步驟，

171
00:08:25,510 --> 00:08:28,460
就像你把一個函數。

172
00:08:28,460 --> 00:08:29,970
然後這就是為什麼我們稱之為
它的匿名函數。

173
00:08:29,970 --> 00:08:30,815
我們不打算給它一個名字。

174
00:08:30,815 --> 00:08:33,159
我們不會浪費嘗試
以它命名的，但我們可以。

175
00:08:33,159 --> 00:08:34,890
>> 匿名函數，你
總是可以給一個名稱。

176
00:08:34,890 --> 00:08:37,620
因此，舉例來說，這段​​代碼就在這裡，
我們可以把這段代碼裡面

177
00:08:37,620 --> 00:08:39,929
函數，然後調用
此功能在這裡。

178
00:08:39,929 --> 00:08:41,600
相反，我們說，我們不打算
打擾了。

179
00:08:41,600 --> 00:08:44,390
我們只是去寫
這一切就在這裡。

180
00:08:44,390 --> 00:08:49,840
>> 這就像有時當你正在寫
四迴路用C  - 你們

181
00:08:49,840 --> 00:08:51,630
之前已經看到這一點 - 也許你
通過forloop迭代

182
00:08:51,630 --> 00:08:53,090
進入i等於0。

183
00:08:53,090 --> 00:08:54,830
I小於strlen的。

184
00:08:54,830 --> 00:08:59,520
否則你會通過一些
數組，你可以保存數組

185
00:08:59,520 --> 00:09:01,580
索引i中的一些變量。

186
00:09:01,580 --> 00:09:02,830
並使用該變量。

187
00:09:02,830 --> 00:09:06,550
所以，你不需要重寫數組
支架我一遍又一遍又一遍。

188
00:09:06,550 --> 00:09:08,160
>> 而這有點像
一個虛擬變量。

189
00:09:08,160 --> 00:09:10,790
這不是服務於很多其他用途，
使你的代碼有點清潔

190
00:09:10,790 --> 00:09:12,120
並且更容易閱讀。

191
00:09:12,120 --> 00:09:13,290
類似的功能在這裡。

192
00:09:13,290 --> 00:09:15,665
只是使它更容易一點，但
在功能上沒有區別。

193
00:09:15,665 --> 00:09:18,620

194
00:09:18,620 --> 00:09:19,330
這是否回答你的問題？

195
00:09:19,330 --> 00:09:19,970
>> 觀眾：是的。

196
00:09:19,970 --> 00:09:20,720
>> JASON HIRSCHHORN：OK。

197
00:09:20,720 --> 00:09:21,880
馬里奧？

198
00:09:21,880 --> 00:09:25,380
>> 觀眾：昨天他們往往把
函數括號事件。

199
00:09:25,380 --> 00:09:26,420
這是否意味著什麼？

200
00:09:26,420 --> 00:09:30,500
或者是它的事情，比如
他們會做

201
00:09:30,500 --> 00:09:35,100
的document.ready功能的事件。

202
00:09:35,100 --> 00:09:37,130
>> JASON HIRSCHHORN：我們已經看到了這一點，
再次，這些都是小事情，

203
00:09:37,130 --> 00:09:39,590
也許我不想
花太多時間。

204
00:09:39,590 --> 00:09:43,200
因為有時候我不希望人們
得到嚇壞了，他們有沒有

205
00:09:43,200 --> 00:09:44,220
聽到這些事情那麼多。

206
00:09:44,220 --> 00:09:46,200
但是，我們討論了一些
事件處理程序。

207
00:09:46,200 --> 00:09:50,360
所以有事，然後
這個功能被執行。

208
00:09:50,360 --> 00:09:53,210
然後，我們也想知道
關於一些細節是什麼

209
00:09:53,210 --> 00:09:54,450
在發生此事件。

210
00:09:54,450 --> 00:09:55,730
>> 所以想回習題集4。

211
00:09:55,730 --> 00:09:58,390
這可能是最簡單的方式
明白打出來。

212
00:09:58,390 --> 00:09:59,740
有一些代碼 - 

213
00:09:59,740 --> 00:10:01,980
就像一個事件會發生，但
事件可能意味著很多東西。

214
00:10:01,980 --> 00:10:06,240
如果可能意味著鼠標被點擊時，它
可能意味著你打箭頭鍵，等。

215
00:10:06,240 --> 00:10:07,190
等等，等等。

216
00:10:07,190 --> 00:10:09,800
>> 但是，這一切都保存在這個通用
東西叫做事件。

217
00:10:09,800 --> 00:10:12,340
然後我們就可以說，是
本次活動這件事情？

218
00:10:12,340 --> 00:10:13,640
或者這是事件這件事情？

219
00:10:13,640 --> 00:10:15,500
或者，什麼樣的事
與該事件？

220
00:10:15,500 --> 00:10:18,660
所以這就是為什麼您創建的變量
那裡保存額外的信息

221
00:10:18,660 --> 00:10:21,420
關於究竟發生了什麼的
你會想

222
00:10:21,420 --> 00:10:24,840
利用在該功能。

223
00:10:24,840 --> 00:10:28,200
但同樣，這可能是一個
是超級不那麼重要的東西

224
00:10:28,200 --> 00:10:29,450
熟悉。

225
00:10:29,450 --> 00:10:31,470

226
00:10:31,470 --> 00:10:36,110
>> 好了，有什麼其他問題才有人
已經或者絆腳石，他們已經

227
00:10:36,110 --> 00:10:37,360
在審查遇到過嗎？

228
00:10:37,360 --> 00:10:41,260

229
00:10:41,260 --> 00:10:42,510
我們將回到那個列表。

230
00:10:42,510 --> 00:10:52,550

231
00:10:52,550 --> 00:10:56,080
在練習測驗怎麼樣，如果
人們已經採取了那些已經？

232
00:10:56,080 --> 00:10:59,110
什麼是一些問題
絆倒你們了？

233
00:10:59,110 --> 00:11:08,970

234
00:11:08,970 --> 00:11:12,720
我知道一個事實，去年的
測驗真的很難。

235
00:11:12,720 --> 00:11:15,670
>> 觀眾：你能解釋一下
SQL注入攻擊是什麼？

236
00:11:15,670 --> 00:11:18,970
>> JASON HIRSCHHORN：好，太好了。

237
00:11:18,970 --> 00:11:20,440
所以我們談到這一點。

238
00:11:20,440 --> 00:11:22,050
有關於安全的講座。

239
00:11:22,050 --> 00:11:25,670
再次，正如我剛才所說，
這是一個在一邊。

240
00:11:25,670 --> 00:11:30,010
但你會在測驗受挫
當你讀了一些小二點

241
00:11:30,010 --> 00:11:33,040
的問題，你像，當
我曾經學來的？

242
00:11:33,040 --> 00:11:35,560
>> 所有這些東西在那些講座
你你需要的沒想到

243
00:11:35,560 --> 00:11:38,290
知道，或者你可以粉飾，因為
他們沒有做的

244
00:11:38,290 --> 00:11:41,860
習題集，這些將有可能
再上來的測驗。

245
00:11:41,860 --> 00:11:45,030
所以，酷，有趣的東西，你只是
以為大衛告訴你來

246
00:11:45,030 --> 00:11:49,070
享受，他告訴你你來
享受，並讓你僅僅是超級

247
00:11:49,070 --> 00:11:50,550
對學習充滿興趣的一切
有學習

248
00:11:50,550 --> 00:11:51,670
關於計算機科學。

249
00:11:51,670 --> 00:11:53,680
那些東西也拿出了上測驗。

250
00:11:53,680 --> 00:11:56,440
所以，即使是沒有這些小東西
直接關係到您的問題

251
00:11:56,440 --> 00:11:59,630
設置，如你們所熟悉的
測驗0，可能會冒出來。

252
00:11:59,630 --> 00:12:01,530
這是一個很好的例子
的東西。

253
00:12:01,530 --> 00:12:10,140
>> 因此，一個SQL注入攻擊是當你
從用戶獲得一些信息和

254
00:12:10,140 --> 00:12:15,090
你想用它插入到一個表
SQL INSERT語句，但你

255
00:12:15,090 --> 00:12:17,680
沒有淨化輸入
提前。

256
00:12:17,680 --> 00:12:21,560
所以，很明顯，我們已經看到了
SQL語句。

257
00:12:21,560 --> 00:12:22,810
我就打開了 - 

258
00:12:22,810 --> 00:12:25,590

259
00:12:25,590 --> 00:12:26,840
讓我們去 - 

260
00:12:26,840 --> 00:12:31,290

261
00:12:31,290 --> 00:12:31,960
我們會去檢討 - 

262
00:12:31,960 --> 00:12:35,180
我認為，誰支付呢？

263
00:12:35,180 --> 00:12:36,350
我覺得Samala做到了。

264
00:12:36,350 --> 00:12:39,292
所以我們可以得到 - 

265
00:12:39,292 --> 00:12:41,270
>> 觀眾：你在哪裡找到呢？

266
00:12:41,270 --> 00:12:44,990
>> JASON HIRSCHHORN：所以，如果你去
CS50.net，測驗，然後你就可以

267
00:12:44,990 --> 00:12:47,170
翻閱過，並得到滑梯
從審查會議。

268
00:12:47,170 --> 00:12:49,860
但你可以看到這是一個很好的例子
的SQL注入攻擊。

269
00:12:49,860 --> 00:12:53,690
我們從用戶處獲得的一些信息
他們給我們一個字符串，然後我們

270
00:12:53,690 --> 00:12:55,780
要插入的字符串
到數據庫中。

271
00:12:55,780 --> 00:12:59,780
一般來說，我們要消毒的
輸入，表示有一些

272
00:12:59,780 --> 00:13:01,050
字符是危險的。

273
00:13:01,050 --> 00:13:04,000
>> 例如，在SQL字符串，
這些報價 - 

274
00:13:04,000 --> 00:13:05,000
單引號或雙引號 - 

275
00:13:05,000 --> 00:13:05,620
意味著什麼。

276
00:13:05,620 --> 00:13:08,380
他們的意思是在這裡結束這個字符串。

277
00:13:08,380 --> 00:13:13,090
所以，如果用戶給你一個
或雙引號，他們可能是

278
00:13:13,090 --> 00:13:18,970
試圖絆倒你的SQL查詢，
插入一些不好的東西進去。

279
00:13:18,970 --> 00:13:23,130
如果他們這樣做，他們可以得到
你的數據庫的控制權，或做一些

280
00:13:23,130 --> 00:13:24,760
東西，你不希望他們做的。

281
00:13:24,760 --> 00:13:28,300
>> 所以這就是為什麼每當我們需要的SQL
查詢，我們淨化輸入之前

282
00:13:28,300 --> 00:13:31,090
將其放入數據庫中，這
意味著我們逃避這些字符。

283
00:13:31,090 --> 00:13:32,590
我們將討論，在第二。

284
00:13:32,590 --> 00:13:35,820
不過長話短說，SQL注入
攻擊是，如果你不這樣做 - 

285
00:13:35,820 --> 00:13:39,760
如果你不把輸入的護理
他們給了你把你的前

286
00:13:39,760 --> 00:13:46,830
數據庫，他們可以，你下來看看
在這裡，運行查詢，其實 - 

287
00:13:46,830 --> 00:13:52,470
他們把他們的代碼到這裡，並
這個選擇線下這裡將選擇

288
00:13:52,470 --> 00:13:56,360
一切從表姑
什麼是給定的密碼。

289
00:13:56,360 --> 00:13:58,960
因為你有1或等於1。

290
00:13:58,960 --> 00:14:02,750
>> 所以基本上，長話短說，
一種方法來接管數據庫。

291
00:14:02,750 --> 00:14:07,570
的問題，那麼，對於你們，是
凡在p設置7你消毒所有

292
00:14:07,570 --> 00:14:10,010
輸入您的SQL查詢？

293
00:14:10,010 --> 00:14:11,230
在哪裡這一步發生的呢？

294
00:14:11,230 --> 00:14:14,150
你在哪裡防止SQL注入
發生用p襲擊設置7？

295
00:14:14,150 --> 00:14:20,100

296
00:14:20,100 --> 00:14:20,490
是啊。

297
00:14:20,490 --> 00:14:21,870
>> 觀眾：地穴？

298
00:14:21,870 --> 00:14:23,120
>> JASON HIRSCHHORN：所以它不是隱窩。

299
00:14:23,120 --> 00:14:52,360

300
00:14:52,360 --> 00:14:55,380
我們沒有讓你這樣做的這個
特別是設置的問題，但它發生

301
00:14:55,380 --> 00:14:58,190
在查詢功能。

302
00:14:58,190 --> 00:15:00,930
實際上，我們寫了你，
我們花了照顧

303
00:15:00,930 --> 00:15:03,040
消毒的投入為您服務。

304
00:15:03,040 --> 00:15:07,790
但在過去的幾年中，學生有
上鍵入他們自己的輸入。

305
00:15:07,790 --> 00:15:10,020
IN P組7，很多你 - 

306
00:15:10,020 --> 00:15:11,270
讓我打開另外一個文件。

307
00:15:11,270 --> 00:15:18,530

308
00:15:18,530 --> 00:15:22,590
>> 所以，你會發現在這裡有很多
人，在問題設置7，沒叫

309
00:15:22,590 --> 00:15:25,240
此功能對字符串。

310
00:15:25,240 --> 00:15:27,880
這個函數，用htmlspecialchars，
再次 - 

311
00:15:27,880 --> 00:15:31,410
該字符串可能有一些東西
在HTML中是指別的。

312
00:15:31,410 --> 00:15:36,160
像一個大括號，方，或者角度
支架意味著什麼在HTML中。

313
00:15:36,160 --> 00:15:38,980
>> 所以，如果你打印出來的
屏幕或者如果你只是採取和

314
00:15:38,980 --> 00:15:42,260
打印出你的HTML，這可能
做一些你不希望。

315
00:15:42,260 --> 00:15:45,180
所以用htmlspecialchars越過所有那些
有特殊字符

316
00:15:45,180 --> 00:15:47,030
會議和逃脫他們。

317
00:15:47,030 --> 00:15:51,450
因此，它被打印出來的文字
你想看到的，而不是

318
00:15:51,450 --> 00:15:53,280
搞砸了你的HTML。

319
00:15:53,280 --> 00:15:55,040
我們在標題中所謂的功能。

320
00:15:55,040 --> 00:15:57,390
和很多人忘了
在程序中調用該函數

321
00:15:57,390 --> 00:15:58,700
你在寫代碼。

322
00:15:58,700 --> 00:16:03,970
>> 因此，舉例來說，如果一隻股票名稱有一個
在它的角括號，你忘了

323
00:16:03,970 --> 00:16:06,675
調用這個函數，這個角度
支架可能已經揭去什麼

324
00:16:06,675 --> 00:16:08,250
你的HTML的樣子。

325
00:16:08,250 --> 00:16:11,810
但調用這個函數將難逃
該所以實際打印出來作為一個

326
00:16:11,810 --> 00:16:15,870
尖括號並不會拋出
關閉你的HTML代碼。

327
00:16:15,870 --> 00:16:18,760
>> 我們已經看到了同樣的原因，有時，
在雙引號前斜線

328
00:16:18,760 --> 00:16:22,310
printf的線路，因為我們不希望
雙引號下來的字符串。

329
00:16:22,310 --> 00:16:24,050
我們想打印出來
輸出到屏幕上。

330
00:16:24,050 --> 00:16:26,920
所以，這一切是同樣的想法。

331
00:16:26,920 --> 00:16:28,260
這是否回答你的問題？

332
00:16:28,260 --> 00:16:31,529

333
00:16:31,529 --> 00:16:33,870
>> 種類：受眾。

334
00:16:33,870 --> 00:16:35,300
>> JASON HIRSCHHORN：你
有一個跟進？

335
00:16:35,300 --> 00:16:43,252
>> 觀眾：我猜的SQL注入
攻擊都有做呢？

336
00:16:43,252 --> 00:16:45,720
我不知道如何
這兩者是相關的。

337
00:16:45,720 --> 00:16:47,610
為什麼你會做specialChars中？

338
00:16:47,610 --> 00:16:51,200
>> JASON HIRSCHHORN：好的，那麼在SQL
當你注入注入攻擊

339
00:16:51,200 --> 00:16:59,180
一些惡意的字符串到別人的
程序，他們只是把它和運行

340
00:16:59,180 --> 00:17:01,230
用字符串的SQL查詢
你給了他們。

341
00:17:01,230 --> 00:17:04,220
正如你所看到這兒，那
可能是有問題的。

342
00:17:04,220 --> 00:17:07,480
所以你防止對的方法是
你把自己的字符串，他們給

343
00:17:07,480 --> 00:17:09,220
你 - 那麼這個字符串就在這裡 - 

344
00:17:09,220 --> 00:17:11,240
你消毒了。

345
00:17:11,240 --> 00:17:14,305
你逃避所有的事情，
是潛在的問題。

346
00:17:14,305 --> 00:17:18,626
所以，你不理解他們的東西
這意味著什麼。

347
00:17:18,626 --> 00:17:23,390
>> 以及與一個例子
HTML是這個功能。

348
00:17:23,390 --> 00:17:26,060
所以它在這裡同樣的想法。

349
00:17:26,060 --> 00:17:27,579
而我只是向您展示其他
當你已經實例

350
00:17:27,579 --> 00:17:29,030
以前見過這樣的想法。

351
00:17:29,030 --> 00:17:33,913
付印前逃逸用戶輸入
它的屏幕還是把它

352
00:17:33,913 --> 00:17:36,782
裡面的SQL語句。

353
00:17:36,782 --> 00:17:40,790
>> 因此，在這種情況下，用戶：觀眾
是搞亂與編程。

354
00:17:40,790 --> 00:17:41,240
>> JASON HIRSCHHORN：是的。

355
00:17:41,240 --> 00:17:44,800
與所有這些安全攻擊，
這總是一般的用戶，或

356
00:17:44,800 --> 00:17:47,470
一個人，正試圖一塌糊塗
與你的程序員。

357
00:17:47,470 --> 00:17:51,038
而這些辦法可以
防止對他們。

358
00:17:51,038 --> 00:17:54,280
>> 觀眾：所以，我有一個問題
關於雜湊函數。

359
00:17:54,280 --> 00:17:59,340
在測驗1自2011年，有兩個
關於片面哈希值的問題。

360
00:17:59,340 --> 00:18:02,540
我只是想知道
這是什麼意思。

361
00:18:02,540 --> 00:18:03,660
>> JASON HIRSCHHORN：OK，這測驗？

362
00:18:03,660 --> 00:18:03,770
2011？

363
00:18:03,770 --> 00:18:04,705
>> 觀眾：是啊。

364
00:18:04,705 --> 00:18:06,720
>> 觀眾：測驗1？

365
00:18:06,720 --> 00:18:08,620
>> 觀眾：[聽不清]。

366
00:18:08,620 --> 00:18:09,940
這就像一個散列密碼。

367
00:18:09,940 --> 00:18:12,220
這不是把事情 - 

368
00:18:12,220 --> 00:18:13,440
>> JASON HIRSCHHORN：什麼頁面呢？

369
00:18:13,440 --> 00:18:15,720
>> 觀眾：我認為這是
9或10，或兩者。

370
00:18:15,720 --> 00:18:16,720
>> JASON HIRSCHHORN：好吧，
繼續前進，柯特。

371
00:18:16,720 --> 00:18:17,780
你可以回答，而我們期待。

372
00:18:17,780 --> 00:18:19,540
>> 觀眾：我認為這是在說
關於散列密碼。

373
00:18:19,540 --> 00:18:24,430
象，當有人輸入密碼，
你把它變成一個加密的東西。

374
00:18:24,430 --> 00:18:27,395
這是密碼散列，這是
從散列函數不同的是

375
00:18:27,395 --> 00:18:30,900
把東西放到一個哈希表。

376
00:18:30,900 --> 00:18:31,610
>> JASON HIRSCHHORN：讓我們來看看。

377
00:18:31,610 --> 00:18:33,930
讓我拉他們
給出的答案。

378
00:18:33,930 --> 00:18:35,440
然後我們將通過它走。

379
00:18:35,440 --> 00:18:42,430

380
00:18:42,430 --> 00:18:45,400
>> 所以簡略的給了一個很好的例子
一個單向散列。

381
00:18:45,400 --> 00:18:48,800
當我們以前看到這一點，我們
取密碼並開啟 - 

382
00:18:48,800 --> 00:18:53,040
請記住，在p將7，有人可能
有一個密碼，這只是密碼，

383
00:18:53,040 --> 00:18:55,300
但後​​來它被加密成
一些很長的事情。

384
00:18:55,300 --> 00:18:59,830
單向散列意味著它是非常容易
從一條路可以走其他的，但

385
00:18:59,830 --> 00:19:02,800
它很難從去
另一種方式回來。

386
00:19:02,800 --> 00:19:05,230
>> 所以你知道，當你檢查
人的密碼的問題

387
00:19:05,230 --> 00:19:08,820
設置7，你會拿自己 - 

388
00:19:08,820 --> 00:19:11,953
因此，舉例來說，說他們想
更改他們的密碼，你問他們

389
00:19:11,953 --> 00:19:13,130
他們的舊密碼。

390
00:19:13,130 --> 00:19:13,910
你把自己的舊密碼。

391
00:19:13,910 --> 00:19:15,150
你加密了。

392
00:19:15,150 --> 00:19:19,240
然後比較了兩種加密
而不是unencrypting原

393
00:19:19,240 --> 00:19:20,780
之一，因為它是真正
難走那條路。

394
00:19:20,780 --> 00:19:27,070

395
00:19:27,070 --> 00:19:28,035
是啊。

396
00:19:28,035 --> 00:19:31,430
>> 觀眾：如何深入我們不
的telnet理解必須是？

397
00:19:31,430 --> 00:19:34,870

398
00:19:34,870 --> 00:19:41,360
>> JASON HIRSCHHORN：如果有人提到
在簡短的演講，只是一個短暫的

399
00:19:41,360 --> 00:19:43,260
理解。

400
00:19:43,260 --> 00:19:45,585
再次，回到答案
為AVI的問題 - 

401
00:19:45,585 --> 00:19:48,260

402
00:19:48,260 --> 00:19:50,430
在更多的事情上來，就越有可能
它是你必須要超

403
00:19:50,430 --> 00:19:51,530
熟悉他們。

404
00:19:51,530 --> 00:19:54,730
如果他們來了才在演講中，
這只是一個地方。

405
00:19:54,730 --> 00:19:57,180
但是，如果他們拿出在講座中，段，
和問題設置，那麼你

406
00:19:57,180 --> 00:19:58,710
大概得超
熟悉他們。

407
00:19:58,710 --> 00:20:01,320

408
00:20:01,320 --> 00:20:03,960
>> 所以，我有一個問題，從
早期有關 - 

409
00:20:03,960 --> 00:20:06,950
IS是2010年秋季 - 

410
00:20:06,950 --> 00:20:08,520
測驗1，讓我們拉起 - 

411
00:20:08,520 --> 00:20:17,390

412
00:20:17,390 --> 00:20:21,790
這個問題在棧和隊列，
我們確實花了時間的公平一點點

413
00:20:21,790 --> 00:20:23,720
講座中談到，即使
雖然我們並沒有真正

414
00:20:23,720 --> 00:20:26,020
曾經擊中了它的部分。

415
00:20:26,020 --> 00:20:33,190
所以這個問題是給你一個系列
的命令，並要求你什麼

416
00:20:33,190 --> 00:20:35,560
被印刷在這種情況下。

417
00:20:35,560 --> 00:20:40,180
所以這是一個完全合理的問題
可能被問的你

418
00:20:40,180 --> 00:20:43,090
傢伙，然後你們應該
能夠回答它。

419
00:20:43,090 --> 00:20:50,020
>> 那麼，為什麼你不看它30
秒，然後如果有人想

420
00:20:50,020 --> 00:20:52,140
建議答案給我，
然後我們將通過它走。

421
00:20:52,140 --> 00:21:22,590

422
00:21:22,590 --> 00:21:24,235
好吧，誰擁有一個答案
問題27？

423
00:21:24,235 --> 00:21:31,740

424
00:21:31,740 --> 00:21:33,860
是啊。

425
00:21:33,860 --> 00:21:40,250
>> 觀眾：它是1，2，3，3？

426
00:21:40,250 --> 00:21:40,780
>> JASON HIRSCHHORN：這是正確的。

427
00:21:40,780 --> 00:21:42,570
圖27是1，2，3，3。

428
00:21:42,570 --> 00:21:44,510
所以，讓我們來看看我們是如何走到這一點。

429
00:21:44,510 --> 00:21:48,930
>> 首先，我們要說，如果s
隊列中的，得到印？

430
00:21:48,930 --> 00:21:53,360
所以q是先入先出。

431
00:21:53,360 --> 00:21:54,680
之前我們已經看到了。

432
00:21:54,680 --> 00:21:56,820
我們看到的人的圖片
在蘋果等待

433
00:21:56,820 --> 00:21:58,400
商店買一些產品。

434
00:21:58,400 --> 00:22:00,900
在是第一人
第一批人出來。

435
00:22:00,900 --> 00:22:02,940
在隊列中的第一件事情
是第一個出來的東西。

436
00:22:02,940 --> 00:22:08,320
>> 所以，如果我們把東西放到一個隊列中，
你推了1，那麼我們彈出1。

437
00:22:08,320 --> 00:22:09,630
流行只是意味著冒了出來。

438
00:22:09,630 --> 00:22:11,080
在這種情況下，只取出來的東西。

439
00:22:11,080 --> 00:22:12,910
我們拿出第一
的事情，這是一個1。

440
00:22:12,910 --> 00:22:15,200
所以我們把我們的事情
打印下來在這裡。

441
00:22:15,200 --> 00:22:18,110
這不再是我們的隊列中。

442
00:22:18,110 --> 00:22:23,500
>> 然後我們推a 2和a 3，和
我們流行過的第一件事。

443
00:22:23,500 --> 00:22:25,030
再次，因為它是一個隊列。

444
00:22:25,030 --> 00:22:33,320
所以，我們得到了一個2，那麼我們就把另一
3，再次調用pop。

445
00:22:33,320 --> 00:22:34,980
我們的3是第一。

446
00:22:34,980 --> 00:22:40,940
>> 然後我們有一大堆的
其他的東西，調用pop。

447
00:22:40,940 --> 00:22:43,740
但同樣，因為這是一個隊列，
先入先出。

448
00:22:43,740 --> 00:22:45,980
我們拿出的第一件事情
這是以往任何時候都放​​進去。

449
00:22:45,980 --> 00:22:47,100
這是我們的3。

450
00:22:47,100 --> 00:22:50,060
並且，在這種情況下，我們也不用擔心
所有其他的事情。

451
00:22:50,060 --> 00:22:51,310
所以這是，如果這是一個隊列。

452
00:22:51,310 --> 00:22:58,917

453
00:22:58,917 --> 00:23:00,167
關於隊列的任何問題嗎？

454
00:23:00,167 --> 00:23:03,290

455
00:23:03,290 --> 00:23:04,040
>> 堆棧的不同。

456
00:23:04,040 --> 00:23:07,782
什麼是我們擁有的縮寫
對於理解一疊？

457
00:23:07,782 --> 00:23:08,750
>> 觀眾：後進先出。

458
00:23:08,750 --> 00:23:10,130
>> JASON HIRSCHHORN：後進先出法，我想。

459
00:23:10,130 --> 00:23:11,830
後進先出。

460
00:23:11,830 --> 00:23:15,630
因此，我們看到一個棧的實例
在一個食堂托盤。

461
00:23:15,630 --> 00:23:17,590
無論是托盤頂部
撿起。

462
00:23:17,590 --> 00:23:19,550
然後，如果新來的托盤
中，他們得到放在上面。

463
00:23:19,550 --> 00:23:21,070
然後無論是在
頂部撿起。

464
00:23:21,070 --> 00:23:24,010
因此，那些在底部托盤威力
在那裡呆上一段時間。

465
00:23:24,010 --> 00:23:28,480
>> 在這種情況下，同樣，我們將
得出了這一點。

466
00:23:28,480 --> 00:23:31,770
我們推進的，所以一
是排在第一位。

467
00:23:31,770 --> 00:23:32,790
而我們彈出的東西了。

468
00:23:32,790 --> 00:23:37,280
還有的只有一件事在那裡，
所以我們移動1到這裡。

469
00:23:37,280 --> 00:23:41,940
然後，我們把2和3
我們流行的東西了。

470
00:23:41,940 --> 00:23:43,650
>> 但同樣，因為這是一個隊列 - 

471
00:23:43,650 --> 00:23:45,010
或者這是一個堆棧，而 - 

472
00:23:45,010 --> 00:23:47,480
我們採取一切是最後一次。

473
00:23:47,480 --> 00:23:49,300
不管是在最後出來先。

474
00:23:49,300 --> 00:23:50,890
和3是最後一次。

475
00:23:50,890 --> 00:23:56,110
所以我們把3出現了下滑，那麼
我們把另外3我們

476
00:23:56,110 --> 00:23:57,360
再彈出的東西。

477
00:23:57,360 --> 00:23:59,990

478
00:23:59,990 --> 00:24:05,710
最後，我們將在4，5，
6，和7，在這裡我們彈出。

479
00:24:05,710 --> 00:24:09,060
並且因為它是一個棧，我們採取
無論是放在最後的，寫

480
00:24:09,060 --> 00:24:10,240
下來這裡。

481
00:24:10,240 --> 00:24:14,256
因此，我們最終以1，3，3，7。

482
00:24:14,256 --> 00:24:17,380

483
00:24:17,380 --> 00:24:21,380
沒有任何人有任何的問題
堆棧或隊列，或這個例子嗎？

484
00:24:21,380 --> 00:24:27,540

485
00:24:27,540 --> 00:24:29,030
>> 確定。

486
00:24:29,030 --> 00:24:30,440
讓我們回到主題列表中。

487
00:24:30,440 --> 00:24:32,510
不是這樣的，這樣一來。

488
00:24:32,510 --> 00:24:34,280
還有什麼其他的問題人們有哪些？

489
00:24:34,280 --> 00:24:37,550

490
00:24:37,550 --> 00:24:39,480
>> 觀眾：我不知道有多麼重要
這是，但我感到困惑的

491
00:24:39,480 --> 00:24:43,550
不同類型之間的差別
語言，如標記，編譯，

492
00:24:43,550 --> 00:24:45,980
解釋。

493
00:24:45,980 --> 00:24:46,750
>> JASON HIRSCHHORN：這是
一個很好的問題。

494
00:24:46,750 --> 00:24:50,500
我覺得這是比較重要，
讓我們趕緊去了吧。

495
00:24:50,500 --> 00:24:56,850
我們已經看到了很大的語言至今都
C，PHP和JavaScript，在條款

496
00:24:56,850 --> 00:24:58,330
的編程語言。

497
00:24:58,330 --> 00:25:01,060
HTML，正如你所說，是不是
一種編程語言。

498
00:25:01,060 --> 00:25:02,260
這是一種標記語言。

499
00:25:02,260 --> 00:25:05,700
然後我們有CSS，這也是
不是一種編程語言。

500
00:25:05,700 --> 00:25:10,330
>> 我們也看到SQL中，這是不
一種編程語言要么。

501
00:25:10,330 --> 00:25:15,695
所以SQL允許你寫
查詢一個數據庫。

502
00:25:15,695 --> 00:25:18,370

503
00:25:18,370 --> 00:25:20,140
HTML是一種標記語言。

504
00:25:20,140 --> 00:25:22,570
它定義了事物是如何構成的。

505
00:25:22,570 --> 00:25:26,250
和CSS可以讓你的風格的東西。

506
00:25:26,250 --> 00:25:28,520
這可能是在多大程度上為你
需要了解這三個。

507
00:25:28,520 --> 00:25:32,920
但更有趣的數字
輸出C，PHP之間的差異，

508
00:25:32,920 --> 00:25:34,320
和JavaScript。

509
00:25:34,320 --> 00:25:37,900
>> 因此，一個最大的不同，
正如你所說，是他們如何是

510
00:25:37,900 --> 00:25:40,550
編譯，或任何
相當於是。

511
00:25:40,550 --> 00:25:42,580
所以C編譯。

512
00:25:42,580 --> 00:25:43,950
我們將始終運行一個編譯器。

513
00:25:43,950 --> 00:25:51,100
然後在那裡是你的錯誤
當您運行C編譯器？

514
00:25:51,100 --> 00:25:55,740
它在哪裡告訴你
代碼中的錯誤？

515
00:25:55,740 --> 00:25:57,860
你怎麼知道有一個
在C語言代碼中的錯誤？

516
00:25:57,860 --> 00:25:58,770
>> 觀眾：這表明你
在終端中。

517
00:25:58,770 --> 00:26:00,410
>> JASON HIRSCHHORN：這表明你在
終端為你編譯。

518
00:26:00,410 --> 00:26:02,620
如果有錯誤，它
實際上不會編譯它。

519
00:26:02,620 --> 00:26:04,830
所以，你知道，有右的錯誤
走，時間提前，然後再

520
00:26:04,830 --> 00:26:06,050
即使運行代碼。

521
00:26:06,050 --> 00:26:10,010
>> 當然，您可能會遇到你的代碼，
得到一個段錯誤，但那是

522
00:26:10,010 --> 00:26:12,350
可能是因為你沒有
一些愚蠢的邏輯的事情。

523
00:26:12,350 --> 00:26:15,770
但隨著技術的代碼
所有正確的，可以運行。

524
00:26:15,770 --> 00:26:18,210
所以C代碼被編譯的時間提前。

525
00:26:18,210 --> 00:26:19,760
怎麼樣的PHP代碼？

526
00:26:19,760 --> 00:26:21,430
在哪裡在你的PHP代碼中的錯誤？

527
00:26:21,430 --> 00:26:23,170
你怎麼知道你有錯誤
在你的PHP代碼？

528
00:26:23,170 --> 00:26:26,038

529
00:26:26,038 --> 00:26:28,430
>> 觀眾：運行時間？

530
00:26:28,430 --> 00:26:31,230
>> JASON HIRSCHHORN：是啊，當你
將運行它，您將運行

531
00:26:31,230 --> 00:26:32,180
在後面的PHP代碼。

532
00:26:32,180 --> 00:26:33,300
然後你會顯示一個畫面。

533
00:26:33,300 --> 00:26:35,260
你可能會看到一些東西在上面，
但隨後你會看到，像一些

534
00:26:35,260 --> 00:26:36,710
橙色，醜表。

535
00:26:36,710 --> 00:26:41,420
它會給你一個行號和
比方說，胡說，胡說，胡說，這東西

536
00:26:41,420 --> 00:26:42,400
沒有工作。

537
00:26:42,400 --> 00:26:48,730
>> 所以PHP是一行一行
並在服務器上運行。

538
00:26:48,730 --> 00:26:52,380
然後，結果是
發送給您。

539
00:26:52,380 --> 00:26:53,340
大。

540
00:26:53,340 --> 00:26:56,410
在執行逐行服務器產品線
然後發送給你。

541
00:26:56,410 --> 00:26:59,010
如果有錯誤，它會發送
你的錯誤，但你可能有

542
00:26:59,010 --> 00:27:00,400
得到的時間提前一些東西。

543
00:27:00,400 --> 00:27:02,730
所以它的一些可能有工作，但
後來，一些東西可能沒有

544
00:27:02,730 --> 00:27:03,890
沒有奏效。

545
00:27:03,890 --> 00:27:04,600
>> 怎麼樣的JavaScript？

546
00:27:04,600 --> 00:27:06,065
你在哪裡看到JavaScript錯誤？

547
00:27:06,065 --> 00:27:10,860

548
00:27:10,860 --> 00:27:12,870
P中設置8，當你得到一個
錯誤，你是怎麼知道的？

549
00:27:12,870 --> 00:27:13,710
會在哪裡出現呢？

550
00:27:13,710 --> 00:27:15,900
>> 觀眾：在控制台中，
在底部。

551
00:27:15,900 --> 00:27:17,650
>> JASON HIRSCHHORN：在
控制台上的底部。

552
00:27:17,650 --> 00:27:20,160
它還會給你
行號，它會

553
00:27:20,160 --> 00:27:21,330
顯示在底部。

554
00:27:21,330 --> 00:27:24,320
與未執行的JavaScript
在服務器上。

555
00:27:24,320 --> 00:27:27,800
JavaScript最初被發送到你的電腦，
然後當它是時間來運行

556
00:27:27,800 --> 00:27:31,670
JavaScript中，JavaScript的是
由行上線運行

557
00:27:31,670 --> 00:27:33,410
客戶端，就在你身邊。

558
00:27:33,410 --> 00:27:35,570
沒有服務器，客戶端。

559
00:27:35,570 --> 00:27:37,690
>> 同樣地，它是
通過線運行線路。

560
00:27:37,690 --> 00:27:40,630
然後當你將得到一個錯誤，
它會顯示在底部。

561
00:27:40,630 --> 00:27:44,580
類似於PHP的，它的一些可能
執行，那麼你可能會得到一個

562
00:27:44,580 --> 00:27:46,310
錯誤以後。

563
00:27:46,310 --> 00:27:49,910
>> 此外，有一點不像PHP的，如果
你得到了一個JavaScript錯誤 - 

564
00:27:49,910 --> 00:27:52,780
說你沒有做正確的
對於一個警告框代碼 - 

565
00:27:52,780 --> 00:27:55,800
你可以繼續運行你的程序。

566
00:27:55,800 --> 00:27:58,180
該警告框是行不通的，但
你的程序將被罰款。

567
00:27:58,180 --> 00:28:00,490
只是也許該函數將失敗。

568
00:28:00,490 --> 00:28:02,610
>> 因此，有一些最大
在如何將這些術語的區別

569
00:28:02,610 --> 00:28:09,230
語言，或如何編程代碼
你寫的是實際評估。

570
00:28:09,230 --> 00:28:11,970
也有在其他方面的差異
最大的區別 - 條款

571
00:28:11,970 --> 00:28:15,590
我們已經看到在變量方面
在不同的語言。

572
00:28:15,590 --> 00:28:19,660
所以，有誰能夠給我一個差
變量之間

573
00:28:19,660 --> 00:28:20,910
在這三種語言？

574
00:28:20,910 --> 00:28:24,802

575
00:28:24,802 --> 00:28:25,770
是。

576
00:28:25,770 --> 00:28:27,130
>> 觀眾：在C中，他們
嚴格的類型。

577
00:28:27,130 --> 00:28:28,550
在另外兩個，它們是
鬆散類型。

578
00:28:28,550 --> 00:28:30,040
>> JASON HIRSCHHORN：與
這是什麼意思？

579
00:28:30,040 --> 00:28:31,775
>> 觀眾：那在C中，你必須聲明
該變量的類型時，

580
00:28:31,775 --> 00:28:36,140
你聲明的變量，
像interbool或char。

581
00:28:36,140 --> 00:28:36,990
>> JASON HIRSCHHORN：優秀。

582
00:28:36,990 --> 00:28:39,780
在C語言中，我們總是不得不把
一個類型的變量。

583
00:28:39,780 --> 00:28:41,360
我們不能真正混合類型。

584
00:28:41,360 --> 00:28:45,750
你不能做一個整數
加的字符串。

585
00:28:45,750 --> 00:28:48,760
但是，正如我們已經看到的這些其他
語言，你其實可以混合類型，

586
00:28:48,760 --> 00:28:51,230
你從來沒有真正得給
什麼類型，直到永遠。

587
00:28:51,230 --> 00:28:53,905
>> 那麼，我們如何知道的事情是變量
在PHP和JavaScript？

588
00:28:53,905 --> 00:28:57,120

589
00:28:57,120 --> 00:28:58,685
>> 觀眾：在PHP中，他們開始
用一個美元符號。

590
00:28:58,685 --> 00:29:00,810
在JavaScript中，當你聲明
他們，你必須有一個酒吧。

591
00:29:00,810 --> 00:29:01,760
>> JASON HIRSCHHORN：對。

592
00:29:01,760 --> 00:29:03,535
所以在PHP中，他們開始
用一個美元符號。

593
00:29:03,535 --> 00:29:06,300
在JavaScript中，他們必須有吧，
雖然有時候他們實際上並不

594
00:29:06,300 --> 00:29:07,520
得有吧。

595
00:29:07,520 --> 00:29:09,240
但是，這是正確的。

596
00:29:09,240 --> 00:29:13,300
>> 所以這是一個很大的區別
之間的變量。

597
00:29:13,300 --> 00:29:16,140
我認為這些都是可能，關閉
頂我的頭，兩個最大

598
00:29:16,140 --> 00:29:19,250
這之間的差異
三種語言。

599
00:29:19,250 --> 00:29:20,594
但是，是的。

600
00:29:20,594 --> 00:29:24,720
>> 觀眾：和C變量的作用域
被限制在花括號

601
00:29:24,720 --> 00:29:27,760
當其他的，它只是喜歡，
它死了，如果是在只有一個功能，

602
00:29:27,760 --> 00:29:29,650
但除此之外，it's  - 

603
00:29:29,650 --> 00:29:30,240
>> JASON HIRSCHHORN：對。

604
00:29:30,240 --> 00:29:36,780
所以範圍略有不同。作為
你還記得，大括號定義

605
00:29:36,780 --> 00:29:37,710
變量的範圍。

606
00:29:37,710 --> 00:29:41,680
所以，如果有人在裡面，如果定義
條件，這是一個內部循環，

607
00:29:41,680 --> 00:29:44,290
該變量只存在在那裡。

608
00:29:44,290 --> 00:29:47,760
>> 在JavaScript中，如果一個變量被定義
內部的if條件 - 

609
00:29:47,760 --> 00:29:50,750
裡面的for循環 - 它會存在
該函數，但它不會存在

610
00:29:50,750 --> 00:29:52,330
以外的功能。

611
00:29:52,330 --> 00:29:59,250
所以範圍是一點點更靈活
在JavaScript和PHP。

612
00:29:59,250 --> 00:30:00,500
這回答這個問題？

613
00:30:00,500 --> 00:30:03,110

614
00:30:03,110 --> 00:30:04,635
好了，沒有別的問題？

615
00:30:04,635 --> 00:30:07,260

616
00:30:07,260 --> 00:30:08,865
我們可以做四個多分鐘
的問題，那麼

617
00:30:08,865 --> 00:30:10,740
我們會跳進編碼。

618
00:30:10,740 --> 00:30:12,645
>> 觀眾：我們可以進入阿賈克斯
並說說是什麼嗎？

619
00:30:12,645 --> 00:30:15,670

620
00:30:15,670 --> 00:30:17,800
>> JASON HIRSCHHORN：交談後為AVI。

621
00:30:17,800 --> 00:30:19,170
他問這個問題前面。

622
00:30:19,170 --> 00:30:19,630
>> 觀眾：我的壞。

623
00:30:19,630 --> 00:30:20,880
>> JASON HIRSCHHORN：不用擔心。

624
00:30:20,880 --> 00:30:22,740

625
00:30:22,740 --> 00:30:24,290
>> 觀眾：究竟什麼是JSON？

626
00:30:24,290 --> 00:30:28,360

627
00:30:28,360 --> 00:30:28,900
>> JASON HIRSCHHORN：JSON是什麼？

628
00:30:28,900 --> 00:30:29,930
什麼是你的問題？

629
00:30:29,930 --> 00:30:31,350
>> 觀眾：剛才真的很快，
之間的差

630
00:30:31,350 --> 00:30:32,870
在PHP打印和迴聲。

631
00:30:32,870 --> 00:30:36,200

632
00:30:36,200 --> 00:30:38,490
>> JASON HIRSCHHORN：你為什麼不谷歌
打印和迴聲之間的區別？

633
00:30:38,490 --> 00:30:40,670
細微的差別。

634
00:30:40,670 --> 00:30:42,020
不是什麼大不了的事的。

635
00:30:42,020 --> 00:30:44,960
但你一定要google一下，
而且會給你一個很好的答案。

636
00:30:44,960 --> 00:30:46,910
>> JSON，可能更大的一筆交易。

637
00:30:46,910 --> 00:30:49,300
代表JavaScript對象表示法。

638
00:30:49,300 --> 00:30:51,865
而當我們已經看到的JSON被使用？

639
00:30:51,865 --> 00:30:55,110

640
00:30:55,110 --> 00:30:55,900
當你看到 - 

641
00:30:55,900 --> 00:30:57,400
為什麼你甚至不知道這個詞的JSON？

642
00:30:57,400 --> 00:30:59,140
當你看過了嗎？

643
00:30:59,140 --> 00:31:02,200
>> 觀眾：當我們得到
股票行情融資。

644
00:31:02,200 --> 00:31:02,690
>> JASON HIRSCHHORN：所以你看到
當你獲得了

645
00:31:02,690 --> 00:31:04,830
股票行情融資。

646
00:31:04,830 --> 00:31:07,340
又為什麼你看到了嗎？

647
00:31:07,340 --> 00:31:09,000
>> 觀眾：當我們檢索
的所有信息，

648
00:31:09,000 --> 00:31:10,400
排在該格式。

649
00:31:10,400 --> 00:31:11,700
>> JASON HIRSCHHORN：所以你會得到 - 

650
00:31:11,700 --> 00:31:12,540
是的。

651
00:31:12,540 --> 00:31:13,020
來吧。

652
00:31:13,020 --> 00:31:15,210
>> 觀眾：[聽不清]的信息
出的對象的？

653
00:31:15,210 --> 00:31:17,170
>> JASON HIRSCHHORN：無論那些
放在一起就是答案

654
00:31:17,170 --> 00:31:18,100
我們正在尋找。

655
00:31:18,100 --> 00:31:21,240
你想要的信息
這另一個網頁。

656
00:31:21,240 --> 00:31:23,790
而你希望，當你
獲取這些信息，這將是

657
00:31:23,790 --> 00:31:26,720
在某些類型的呈現給大家
標準化的格式。

658
00:31:26,720 --> 00:31:29,530
>> 每個人都可能是熟悉
用逗號分隔的值。

659
00:31:29,530 --> 00:31:32,970
您可以導出為Excel電子表格或
任何類型的電子表格作為一個列表

660
00:31:32,970 --> 00:31:34,540
逗號分隔值。

661
00:31:34,540 --> 00:31:37,370
和逗號分隔的所有
在不同的領域。

662
00:31:37,370 --> 00:31:38,780
JavaScript對象符號 - 

663
00:31:38,780 --> 00:31:39,440
JSON  - 

664
00:31:39,440 --> 00:31:43,540
是另一種類型的標準化的
物聯網佈局。

665
00:31:43,540 --> 00:31:49,010
這就是通常我們如何檢索
從我們的Ajax查詢的信息。

666
00:31:49,010 --> 00:31:51,770
>> 因此，在這種情況下，我們得到了它
從雅虎網站。

667
00:31:51,770 --> 00:31:53,600
他們返回的東西
我們在一個JSON對象。

668
00:31:53,600 --> 00:31:56,790
然後，我們知道，因為它是
一個標準，它是什麼

669
00:31:56,790 --> 00:31:57,250
將會是什麼樣。

670
00:31:57,250 --> 00:32:00,760
因此，我們可以通過遍歷數組
這是退還給我們，數組

671
00:32:00,760 --> 00:32:03,180
返回到我們的對象。

672
00:32:03,180 --> 00:32:07,770
>> 我們可能需要知道密鑰，
但他們通常給你

673
00:32:07,770 --> 00:32:11,370
在該網站的文件時，
你想拿幾個JSON

674
00:32:11,370 --> 00:32:12,170
標記他們。

675
00:32:12,170 --> 00:32:16,940
同樣，你可以JSON
編碼的對象。

676
00:32:16,940 --> 00:32:19,900
所以這是一個函數的JSON
強調編碼。

677
00:32:19,900 --> 00:32:22,970
所以你可以採取一個對象，
你已經創建，JSON編碼它，

678
00:32:22,970 --> 00:32:26,390
它傳遞的東西
否則，如果你想。

679
00:32:26,390 --> 00:32:30,770
和JSON解碼也存在
類似的目的，或用於

680
00:32:30,770 --> 00:32:31,780
相反的目的。

681
00:32:31,780 --> 00:32:36,570
>> 觀眾：我們是否需要知道編碼
哈希表和嘗試？

682
00:32:36,570 --> 00:32:40,300
還是我們只是需要理解
他們是如何使用的，概念上？

683
00:32:40,300 --> 00:32:44,570
>> JASON HIRSCHHORN：那麼，舉起你的手
如果你沒有對p哈希表中設置4

684
00:32:44,570 --> 00:32:46,920
帶有鏈接列表。

685
00:32:46,920 --> 00:32:47,960
或p設置5。

686
00:32:47,960 --> 00:32:49,060
所以這是絕大多數人。

687
00:32:49,060 --> 00:32:50,390
p將5，6，誰知道。

688
00:32:50,390 --> 00:32:51,240
很久很久以前。

689
00:32:51,240 --> 00:32:54,140
>> 所以，你絕大多數做
哈希表與鏈接列表。

690
00:32:54,140 --> 00:32:56,525
而且因為這可能是更
常用的方法，因為我們花了

691
00:32:56,525 --> 00:32:59,460
大量的時間做鏈接列表和哈希
表，你也許應該

692
00:32:59,460 --> 00:33:02,600
非常熟悉如何編寫代碼
哈希表和鏈接列表。

693
00:33:02,600 --> 00:33:05,060
>> 如果你覺得回到了這個問題
設置，它是不是真的

694
00:33:05,060 --> 00:33:06,410
硬如您預期。

695
00:33:06,410 --> 00:33:08,120
並有少了很多
比你預期的代碼。

696
00:33:08,120 --> 00:33:11,150

697
00:33:11,150 --> 00:33:14,650
我會說你應該知道如何
編寫一個哈希表或鏈接列表。

698
00:33:14,650 --> 00:33:17,010
這並不是說你會問，
不一定，但你應該

699
00:33:17,010 --> 00:33:19,730
當然知道。

700
00:33:19,730 --> 00:33:21,860
>> 另外，如果你去翻過去的測驗，
已經有很多

701
00:33:21,860 --> 00:33:26,450
關於編寫功能上的問題
鏈接列表或雙向鍊錶。

702
00:33:26,450 --> 00:33:28,370
這似乎想出
每一年。

703
00:33:28,370 --> 00:33:31,940
右側插入一個鏈接列表，右邊
從鍊錶中刪除，用鼠標右鍵插入

704
00:33:31,940 --> 00:33:33,610
對於一個雙向鍊錶，等等。

705
00:33:33,610 --> 00:33:36,170
所以，我覺得挺舒服的
說你應該知道這一點。

706
00:33:36,170 --> 00:33:40,600
>> 對於嘗試，我會說你應該
當然知道它是如何工作的，也許

707
00:33:40,600 --> 00:33:43,570
給一些偽代碼如何
它的代碼，並設置它。

708
00:33:43,570 --> 00:33:45,600
但它不會是最糟糕的事情
世界上，如果你不知道如何

709
00:33:45,600 --> 00:33:48,870
它在C代碼這將是巨大的，如果你
知道如何編寫代碼在C，但我認為

710
00:33:48,870 --> 00:33:52,516
可能是偽代碼試試看會
是你最需要的

711
00:33:52,516 --> 00:33:53,270
要知道一試。

712
00:33:53,270 --> 00:33:53,930
>> 觀眾：附加題？

713
00:33:53,930 --> 00:33:58,290
>> JASON HIRSCHHORN：而且用相同的，如果我們
進入二叉搜索樹，你可能

714
00:33:58,290 --> 00:34:02,320
需要 - 你已經看到在過去，
我們已經做了很多 - 你知道如何

715
00:34:02,320 --> 00:34:03,380
二叉搜索樹的作品。

716
00:34:03,380 --> 00:34:07,150
你或許應該能夠
設置一個偽代碼。

717
00:34:07,150 --> 00:34:10,510
但由於絕大多數人
沒有這樣做的問題

718
00:34:10,510 --> 00:34:13,880
集，我會說這是不太可能
重要的是你知道如何編寫代碼

719
00:34:13,880 --> 00:34:17,380
並成立了這樣一棵樹。

720
00:34:17,380 --> 00:34:19,679
>> 還有沒有其他問題？

721
00:34:19,679 --> 00:34:23,234
另外，我們可以在整個問他們
因為我們經歷了一些問題。

722
00:34:23,234 --> 00:34:27,170
好了，我們要繼續前進。

723
00:34:27,170 --> 00:34:28,230
跳過該幻燈片現在。

724
00:34:28,230 --> 00:34:32,449
>> 發言的樹，也就是第一
問題我已經為你們。

725
00:34:32,449 --> 00:34:34,270
因為這是一個問題。

726
00:34:34,270 --> 00:34:37,380
我會說這是極有可能你會
得到這樣一個問題，在您的測驗

727
00:34:37,380 --> 00:34:43,659
要求您編寫一些類型的插入，
刪除，查找，一類

728
00:34:43,659 --> 00:34:45,270
數據結構我們已經看到了。

729
00:34:45,270 --> 00:34:47,719
>> 需要達到的每一年，我們花了
這種大量的時間下半年

730
00:34:47,719 --> 00:34:50,270
學期要對這些數據類型。

731
00:34:50,270 --> 00:34:54,170
所以現在，我已經定義了一個節點
在二叉搜索樹。

732
00:34:54,170 --> 00:34:58,490
而我希望你做的是給定的
啟動一個二叉搜索樹

733
00:34:58,490 --> 00:35:05,450
在這個節點星級根，完成
執行下面的功能，

734
00:35:05,450 --> 00:35:07,430
這恰好是一個查找功能。

735
00:35:07,430 --> 00:35:09,260
並有和沒有遞歸做到這一點。

736
00:35:09,260 --> 00:35:10,860
>> 所以，我希望你寫兩個函數。

737
00:35:10,860 --> 00:35:14,310
一個用遞歸，一個人在做這個
這樣做並沒有遞歸。

738
00:35:14,310 --> 00:35:18,050
也不要假設
根將成為非null。

739
00:35:18,050 --> 00:35:21,790
因此，我們正在尋找我的整數
樹開始在根，我們需要

740
00:35:21,790 --> 00:35:25,280
遞歸寫這
和迭代。

741
00:35:25,280 --> 00:35:26,300
是啊。

742
00:35:26,300 --> 00:35:29,730
>> 觀眾：所以，你要我們返回true
如果我們發現，假如果我們

743
00:35:29,730 --> 00:35:30,480
並不覺得。

744
00:35:30,480 --> 00:35:32,160
>> JASON HIRSCHHORN：你怎麼知道的？

745
00:35:32,160 --> 00:35:33,100
你是怎麼知道的？

746
00:35:33,100 --> 00:35:36,500
>> 觀眾：我是問第一次，但我
假設，因為它說，在布爾

747
00:35:36,500 --> 00:35:37,490
該函數的開頭。

748
00:35:37,490 --> 00:35:37,880
>> JASON HIRSCHHORN：對。

749
00:35:37,880 --> 00:35:41,020
它說BOOL，所以我什至都不需要
告訴你，我希望你能返回

750
00:35:41,020 --> 00:35:41,350
因為它說在那裡。

751
00:35:41,350 --> 00:35:42,280
但是，這是正確的。

752
00:35:42,280 --> 00:35:43,510
返回，真或假。

753
00:35:43,510 --> 00:35:47,630
>> 在開始之前，我會建議，
如果您不熟悉

754
00:35:47,630 --> 00:35:51,300
二叉搜索樹，快速繪製
它的照片，讓您的

755
00:35:51,300 --> 00:35:51,750
的理解，正確的。

756
00:35:51,750 --> 00:35:54,720
寫作時，也將幫助您
您的代碼並檢查它。

757
00:35:54,720 --> 00:35:57,830
同樣，你也沒有那麼多
時間上的測驗，做所有的事情

758
00:35:57,830 --> 00:35:59,030
我們要求你這樣做。

759
00:35:59,030 --> 00:36:02,350
所以寫的偽代碼
是非常有幫助的。

760
00:36:02,350 --> 00:36:05,310
>> 而我們一般提供有關 - 

761
00:36:05,310 --> 00:36:06,820
如果偽代碼是完全
正確的，這是

762
00:36:06,820 --> 00:36:08,910
通常50％的問題。

763
00:36:08,910 --> 00:36:11,410
所以它不是一個硬性規定，但如果
你只寫偽代碼，它的

764
00:36:11,410 --> 00:36:13,460
正確的，它通常50％。

765
00:36:13,460 --> 00:36:14,970
所以我總是建議 - 

766
00:36:14,970 --> 00:36:16,870
如果你時間緊迫，或者即使
你只是想弄明白 - 

767
00:36:16,870 --> 00:36:18,290
開始的偽代碼。

768
00:36:18,290 --> 00:36:24,840
最後，如果你能寫這
所有在C中，這將是非常美妙的。

769
00:36:24,840 --> 00:36:29,010
>> 因此，讓我們3分鐘
在這方面努力的程序。

770
00:36:29,010 --> 00:36:33,120
然後我們將要編寫
偽代碼，它只是一次，然後

771
00:36:33,120 --> 00:36:35,455
我們要遞歸編寫它
然後反复。

772
00:36:35,455 --> 00:37:28,720

773
00:37:28,720 --> 00:37:30,760
>> 如果您有任何疑問，請隨時
免費舉起你的手。

774
00:37:30,760 --> 00:37:34,270
快樂的四處走動，並回答他們
在我們開始之前為一組。

775
00:37:34,270 --> 00:39:22,600

776
00:39:22,600 --> 00:39:27,200
>> 讓我們重新開始，而且我們要
偽代碼的遞歸版本

777
00:39:27,200 --> 00:39:29,830
這一點，那麼我們將對其進行編碼。

778
00:39:29,830 --> 00:39:33,380
因此，一個遞歸函數
需要兩件事情。

779
00:39:33,380 --> 00:39:35,960
這可能是一個問題，
你可能會問。

780
00:39:35,960 --> 00:39:37,950
需要兩件事情。

781
00:39:37,950 --> 00:39:40,610
誰可以提高他們的手，告訴我
什麼兩樣東西遞歸

782
00:39:40,610 --> 00:39:43,680
函數需要？

783
00:39:43,680 --> 00:39:45,030
根據定義它有兩件事情。

784
00:39:45,030 --> 00:39:46,280
什麼是這兩件事情？

785
00:39:46,280 --> 00:39:48,580

786
00:39:48,580 --> 00:39:49,830
新的手。

787
00:39:49,830 --> 00:39:55,050

788
00:39:55,050 --> 00:39:56,390
是的，奧爾登。

789
00:39:56,390 --> 00:39:57,980
>> 觀眾：所以我不能完全肯定，如果
這是術語，但是 - 

790
00:39:57,980 --> 00:39:59,715
>> JASON HIRSCHHORN：我很高興
你養你的手。

791
00:39:59,715 --> 00:40:03,380
>> 觀眾：它需要一個基礎的情況下，
並且它需要一個遞歸步驟。

792
00:40:03,380 --> 00:40:03,960
>> JASON HIRSCHHORN：完美。

793
00:40:03,960 --> 00:40:06,340
它需要一個基本情況和
一個遞歸步驟。

794
00:40:06,340 --> 00:40:10,430
那麼什麼是我們的基本情況嗎？

795
00:40:10,430 --> 00:40:12,950
>> 觀眾：F盤根等於等於null。

796
00:40:12,950 --> 00:40:15,110
對不起，只是偽代碼，
如果它為空。

797
00:40:15,110 --> 00:40:16,360
如果root為null。

798
00:40:16,360 --> 00:40:21,900

799
00:40:21,900 --> 00:40:23,540
>> JASON HIRSCHHORN：如果root為null。

800
00:40:23,540 --> 00:40:23,850
這是極好的。

801
00:40:23,850 --> 00:40:24,610
這是我們的基本情況。

802
00:40:24,610 --> 00:40:25,910
這就是我們要去
檢查每一個時間。

803
00:40:25,910 --> 00:40:28,000
和基本情況是
你首先要做的。

804
00:40:28,000 --> 00:40:29,720
如果你打的基本情況，你就大功告成了。

805
00:40:29,720 --> 00:40:34,140
>> 現在，我們需要我們的遞歸調用，而且我
願意打賭，我們需要一對夫婦

806
00:40:34,140 --> 00:40:35,440
這裡的遞歸調用。

807
00:40:35,440 --> 00:40:39,630
因為它是一棵樹，而我們
可以去多種方式。

808
00:40:39,630 --> 00:40:43,190
所以，如果根是空，我們是很好的。

809
00:40:43,190 --> 00:40:44,970
>> 你有什麼建議？

810
00:40:44,970 --> 00:40:49,640
而現在我要開始呼叫
對你們，因為我知道你們

811
00:40:49,640 --> 00:40:50,540
都知道這一點。

812
00:40:50,540 --> 00:40:52,610
但安妮，又該
下一行是什麼？

813
00:40:52,610 --> 00:40:53,570
如果我們找到了嗎？

814
00:40:53,570 --> 00:40:55,526
我們該怎麼辦？

815
00:40:55,526 --> 00:40:57,300
>> 觀眾：如果我們找到了嗎？

816
00:40:57,300 --> 00:40:59,160
>> JASON HIRSCHHORN：還是什麼
應該是 - 

817
00:40:59,160 --> 00:41:02,124
給我的偽代碼
行，我們發現了它。

818
00:41:02,124 --> 00:41:04,700
>> 觀眾：如果我等於根我？

819
00:41:04,700 --> 00:41:06,650
>> JASON HIRSCHHORN：與
那麼我們該怎麼做？

820
00:41:06,650 --> 00:41:07,590
>> 觀眾：返回true。

821
00:41:07,590 --> 00:41:08,530
>> JASON HIRSCHHORN：太好了。

822
00:41:08,530 --> 00:41:16,890
所以，如果我是我 - 

823
00:41:16,890 --> 00:41:17,400
哦，他們兩個叫我。

824
00:41:17,400 --> 00:41:18,470
這得到混亂。

825
00:41:18,470 --> 00:41:23,830
但如果我是我返回true。

826
00:41:23,830 --> 00:41:25,620
這可能是下一個
我們應該做的事情。

827
00:41:25,620 --> 00:41:27,300
有道理。

828
00:41:27,300 --> 00:41:30,610
>> OK，現在我們還沒有做我們的遞歸
調用的是，雖然，因為一個遞歸

829
00:41:30,610 --> 00:41:32,300
呼叫會再次調用該函數。

830
00:41:32,300 --> 00:41:41,460
那麼又該下一
偽代碼的行會？

831
00:41:41,460 --> 00:41:42,730
安娜。

832
00:41:42,730 --> 00:41:43,980
>> 觀眾：左邊。

833
00:41:43,980 --> 00:41:47,040

834
00:41:47,040 --> 00:41:47,590
>> JASON HIRSCHHORN：要具體，雖然。

835
00:41:47,590 --> 00:41:50,600
這是一個二叉搜索樹，還等什麼
並檢查左側意味著什麼？

836
00:41:50,600 --> 00:41:51,890
>> 觀眾：那麼節點 - 

837
00:41:51,890 --> 00:41:53,342
對不起，根。

838
00:41:53,342 --> 00:41:55,306
然後向左箭頭。

839
00:41:55,306 --> 00:41:59,234

840
00:41:59,234 --> 00:42:00,720
節點，節點，對不起。

841
00:42:00,720 --> 00:42:01,978
我不會讀它正確。

842
00:42:01,978 --> 00:42:05,700
這就是所謂的節點，對不對？

843
00:42:05,700 --> 00:42:09,270
>> JASON HIRSCHHORN：它會被稱為根
在該功能，但無論哪種方式。

844
00:42:09,270 --> 00:42:10,925
左側的 - 是嗎？

845
00:42:10,925 --> 00:42:13,780
>> 觀眾：如果它不等於
我，然後我們將調用

846
00:42:13,780 --> 00:42:15,130
該功能了嗎？

847
00:42:15,130 --> 00:42:15,490
>> JASON HIRSCHHORN：這是正確的。

848
00:42:15,490 --> 00:42:17,870
如果它不等於我，我們要去
再次調用該函數。

849
00:42:17,870 --> 00:42:21,435
然而，我們要什麼副作用的樹
再次調用該函數？

850
00:42:21,435 --> 00:42:22,685
>> 觀眾：在左側。

851
00:42:22,685 --> 00:42:25,932

852
00:42:25,932 --> 00:42:27,670
>> JASON HIRSCHHORN：我們並不總是
要調用它的左邊，如果它

853
00:42:27,670 --> 00:42:29,190
不等於它。

854
00:42:29,190 --> 00:42:29,610
>> 觀眾：哦，對不起。

855
00:42:29,610 --> 00:42:31,200
呼籲的權利。

856
00:42:31,200 --> 00:42:33,680
>> JASON HIRSCHHORN：我們想知道
具體而言，雖然 - 還記得，在一個

857
00:42:33,680 --> 00:42:37,700
二叉搜索樹，一切
左手側越小。

858
00:42:37,700 --> 00:42:40,460
一切的權利
手側更大。

859
00:42:40,460 --> 00:42:43,990
所以它只是不 - 是啊，去吧。

860
00:42:43,990 --> 00:42:46,805
>> 觀眾：如果它的不到我，然後 - 

861
00:42:46,805 --> 00:42:52,130

862
00:42:52,130 --> 00:42:53,380
如果它是在左邊 ​​- 

863
00:42:53,380 --> 00:42:56,160

864
00:42:56,160 --> 00:42:58,606
>> JASON HIRSCHHORN：所以，如果
ri為小於 - 

865
00:42:58,606 --> 00:43:01,854

866
00:43:01,854 --> 00:43:09,110
因此，如果我們數小於我，
我們想去什麼副作用？

867
00:43:09,110 --> 00:43:15,120
>> 觀眾：我們想去
向右側。

868
00:43:15,120 --> 00:43:16,250
>> JASON HIRSCHHORN：我們想要去 - 

869
00:43:16,250 --> 00:43:19,210
讓我畫一個快速的樹。

870
00:43:19,210 --> 00:43:23,850
如果這是5，這將是3。

871
00:43:23,850 --> 00:43:29,410
因此，如果ri為小於5，什麼
一邊做我們想要去？

872
00:43:29,410 --> 00:43:30,390
>> 觀眾：對不起，什麼？

873
00:43:30,390 --> 00:43:33,190
>> JASON HIRSCHHORN：我們的電話號碼是
小於我們的數

874
00:43:33,190 --> 00:43:34,710
現在在看。

875
00:43:34,710 --> 00:43:35,890
>> 觀眾：哦，那我們要
去的左側。

876
00:43:35,890 --> 00:43:36,240
是啊。

877
00:43:36,240 --> 00:43:36,920
抱歉。

878
00:43:36,920 --> 00:43:37,230
>> JASON HIRSCHHORN：沒錯。

879
00:43:37,230 --> 00:43:38,480
無後顧之憂。

880
00:43:38,480 --> 00:43:41,020
在二叉搜索樹，一切
下是到左邊，

881
00:43:41,020 --> 00:43:42,110
更大的是在右邊。

882
00:43:42,110 --> 00:43:46,700
因此，如果我們的數目小於
我們正在檢查我 - 

883
00:43:46,700 --> 00:43:48,790
因為你在看
節點，它有一個i  - 

884
00:43:48,790 --> 00:43:50,040
那麼你想要去到左邊。

885
00:43:50,040 --> 00:43:55,480

886
00:43:55,480 --> 00:43:56,720
>> 這是一個輕鬆的一年。

887
00:43:56,720 --> 00:44:01,700
這是它的偽代碼的其他線
我們需要寫？

888
00:44:01,700 --> 00:44:02,910
卡洛斯？

889
00:44:02,910 --> 00:44:05,970
>> 觀眾：同樣的事情，你只需切換
它以一個大於號

890
00:44:05,970 --> 00:44:07,420
和去的權利。

891
00:44:07,420 --> 00:44:08,350
>> JASON HIRSCHHORN：你能
說這一次嗎？

892
00:44:08,350 --> 00:44:11,640
>> 觀眾：如果我們的數大於
比我去的權利。

893
00:44:11,640 --> 00:44:24,900

894
00:44:24,900 --> 00:44:26,690
>> JASON HIRSCHHORN：優秀
就業上的偽代碼。

895
00:44:26,690 --> 00:44:28,700
讓我們在真正的代碼做到這一點。

896
00:44:28,700 --> 00:44:33,280
再次，這將偽代碼
可能會得到你的，因為它是

897
00:44:33,280 --> 00:44:35,480
正確的，50％在這個問題上。

898
00:44:35,480 --> 00:44:39,720
但這個偽也意味著1
一，從本質上講，成代碼。

899
00:44:39,720 --> 00:44:44,380
>> 因此，讓我們在C誰能給做到這一點
我的第一行代碼？

900
00:44:44,380 --> 00:44:48,390
其實，第一次，以前我做的
這一點，讓我拉過來 - 

901
00:44:48,390 --> 00:44:49,260
>> 觀眾：我有一個問題。

902
00:44:49,260 --> 00:44:52,430
你為什麼要縮進
行我給你？

903
00:44:52,430 --> 00:44:54,160
>> JASON HIRSCHHORN：因為
我不能寫。

904
00:44:54,160 --> 00:44:55,240
我不知道。

905
00:44:55,240 --> 00:44:55,650
你說得對。

906
00:44:55,650 --> 00:44:57,780
該行應該在那裡。

907
00:44:57,780 --> 00:45:11,600

908
00:45:11,600 --> 00:45:14,480
>> 好了，這裡是我們的函數。

909
00:45:14,480 --> 00:45:18,090
讓我拉過來，也，
我們定義一個節點。

910
00:45:18,090 --> 00:45:23,320

911
00:45:23,320 --> 00:45:27,180
如果我們沒有發生什麼
寫的typedef？

912
00:45:27,180 --> 00:45:30,240
有誰知道？

913
00:45:30,240 --> 00:45:32,570
>> 觀眾：它不會編譯。

914
00:45:32,570 --> 00:45:33,860
>> JASON HIRSCHHORN：它會
編譯，是的。

915
00:45:33,860 --> 00:45:37,120
>> 觀眾：難道只是聲明了一個
實例，而不是使之成為一個新的

916
00:45:37,120 --> 00:45:39,840
鍵入您可以聲明多個
的實例？

917
00:45:39,840 --> 00:45:41,700
>> JASON HIRSCHHORN：所以它不會
知道 - 它不會

918
00:45:41,700 --> 00:45:43,120
只是聲明了一個類型。

919
00:45:43,120 --> 00:45:46,150
你仍然可以做出很多節點。

920
00:45:46,150 --> 00:45:48,070
>> 觀眾：但是難道我們要
每次寫結構節點？

921
00:45:48,070 --> 00:45:48,640
>> JASON HIRSCHHORN：這是正確的。

922
00:45:48,640 --> 00:45:50,960
你必須編寫結構節點
每一次，而不是僅僅節點。

923
00:45:50,960 --> 00:45:55,270
但用typedef，你可以只
寫節點每一次。

924
00:45:55,270 --> 00:45:58,240
好了，誰沒有給出 - 是啊，Avica。

925
00:45:58,240 --> 00:46:01,520
>> 觀眾：如果root等於等於
空，返回false。

926
00:46:01,520 --> 00:46:07,130

927
00:46:07,130 --> 00:46:09,490
>> JASON HIRSCHHORN：大和
這是我們的基本情況。

928
00:46:09,490 --> 00:46:11,200
下一行代碼。

929
00:46:11,200 --> 00:46:13,999
誰沒有給別人
我的代碼行了嗎？

930
00:46:13,999 --> 00:46:14,945
是啊。

931
00:46:14,945 --> 00:46:23,360
>> 觀眾：根箭頭我
等於等於i。

932
00:46:23,360 --> 00:46:27,260
然後返回true。

933
00:46:27,260 --> 00:46:29,162
>> JASON HIRSCHHORN：太好了。

934
00:46:29,162 --> 00:46:32,048
下一行？

935
00:46:32,048 --> 00:46:32,790
是啊。

936
00:46:32,790 --> 00:46:34,010
別人？

937
00:46:34,010 --> 00:46:36,774
然後你可以去下一個。

938
00:46:36,774 --> 00:46:44,820
>> 觀眾：否則，如果根箭頭
i小於我返回

939
00:46:44,820 --> 00:46:47,737
函數調用查找根源 - 

940
00:46:47,737 --> 00:46:50,611
>> JASON HIRSCHHORN：對不起。

941
00:46:50,611 --> 00:46:56,272
>> 觀眾：返回找到根
指向左側逗號我。

942
00:46:56,272 --> 00:47:01,760

943
00:47:01,760 --> 00:47:08,440
>> JASON HIRSCHHORN：所以，如果ri為更大
比樹的東西，我們要

944
00:47:08,440 --> 00:47:09,573
去左邊？

945
00:47:09,573 --> 00:47:11,790
>> 觀眾：不，我有這樣的切換。

946
00:47:11,790 --> 00:47:13,040
>> JASON HIRSCHHORN：哪一個？

947
00:47:13,040 --> 00:47:16,310

948
00:47:16,310 --> 00:47:16,950
>> 觀眾：沒有，是的。

949
00:47:16,950 --> 00:47:19,050
我有一個小於號那裡。

950
00:47:19,050 --> 00:47:22,890
>> JASON HIRSCHHORN：對，如果ri為
不到什麼是根 - 

951
00:47:22,890 --> 00:47:25,660
我們當前的根 - 那麼我們
想要去到左邊。

952
00:47:25,660 --> 00:47:26,960
什麼是最後一行，你呢？

953
00:47:26,960 --> 00:47:30,930
>> 觀眾：基本上同樣的事情，
除了切換大於或

954
00:47:30,930 --> 00:47:34,690
等於小於和左到右。

955
00:47:34,690 --> 00:47:43,590

956
00:47:43,590 --> 00:47:43,680
>> JASON HIRSCHHORN：優秀。

957
00:47:43,680 --> 00:47:48,430
沒有任何人有任何疑問，
這件事？

958
00:47:48,430 --> 00:47:52,560
因此，一些其他的東西，會
已經正確的是

959
00:47:52,560 --> 00:47:53,810
可能是 -  ltiff。

960
00:47:53,810 --> 00:47:56,520

961
00:47:56,520 --> 00:47:59,520
猜測，在技術上，沒有這些
真的還需要，ltiff。

962
00:47:59,520 --> 00:48:00,950
>> 此外，有可能只
一個案件到這裡。

963
00:48:00,950 --> 00:48:02,380
所以這可能是你最後一種情況。

964
00:48:02,380 --> 00:48:04,000
你甚至不需要說 -  ltiff。

965
00:48:04,000 --> 00:48:06,160
但可能好寫
它是明確的。

966
00:48:06,160 --> 00:48:06,660
是啊。

967
00:48:06,660 --> 00:48:09,200
>> 觀眾：所以你不認為測驗 - 
如果我們的錯誤，例如，

968
00:48:09,200 --> 00:48:11,725
在語法 - 

969
00:48:11,725 --> 00:48:13,990
小語法錯誤 - 

970
00:48:13,990 --> 00:48:17,810
那怎麼得到採取的測驗？

971
00:48:17,810 --> 00:48:21,300
>> JASON HIRSCHHORN：一般的測驗，
小的語法錯誤或小

972
00:48:21,300 --> 00:48:24,010
風格的錯誤不會失去你點。

973
00:48:24,010 --> 00:48:26,610
所以，如果你忘了一個分號
在這裡，這將是確定。

974
00:48:26,610 --> 00:48:30,290
如果您忘記關閉這個括號，
這將是確定。

975
00:48:30,290 --> 00:48:34,880
>> 這改變了巨大的語法錯誤
你的代碼功能意義

976
00:48:34,880 --> 00:48:37,600
戲劇性的是，你可能會得到
起飛的點。

977
00:48:37,600 --> 00:48:40,330
或一般，只是你分級
是否不是你的

978
00:48:40,330 --> 00:48:42,150
代碼的功能，甚至 - 

979
00:48:42,150 --> 00:48:44,830
不是它的設計這麼多，
而不是它的風格。

980
00:48:44,830 --> 00:48:50,780

981
00:48:50,780 --> 00:48:55,480
>> 現在，讓我們編寫一個迭代
版本發現的。

982
00:48:55,480 --> 00:49:00,400

983
00:49:00,400 --> 00:49:03,450
因此，這將是相當類似的，但
當然，還有將要

984
00:49:03,450 --> 00:49:06,250
一些關鍵的差別。

985
00:49:06,250 --> 00:49:09,160
然而，我們的偽代碼
大概可以走 - 

986
00:49:09,160 --> 00:49:11,610
我們仍然可以採取一系的
偽代碼，弄清了

987
00:49:11,610 --> 00:49:14,160
線是在這種情況下。

988
00:49:14,160 --> 00:49:18,010
>> 因此，在一個迭代版本，什麼
你認為，朱莉婭，應

989
00:49:18,010 --> 00:49:19,260
在第一線？

990
00:49:19,260 --> 00:49:23,100

991
00:49:23,100 --> 00:49:26,920
>> 觀眾：同樣，在迭代布爾，
您需要建立一個for循環，對不對？

992
00:49:26,920 --> 00:49:27,660
>> JASON HIRSCHHORN：確定。

993
00:49:27,660 --> 00:49:38,480
>> 觀眾：那麼像，K，對於x
等於0時，x是小於我。

994
00:49:38,480 --> 00:49:42,260
或無，x是小於
樹的大小。

995
00:49:42,260 --> 00:49:42,760
>> JASON HIRSCHHORN：樹。

996
00:49:42,760 --> 00:49:46,660
所以我們真的不知道的大小
樹，我們真的不知道

997
00:49:46,660 --> 00:49:48,900
多少次，我們可以走了，有啥
不同類型的循環，它可能是

998
00:49:48,900 --> 00:49:50,150
在這種情況下更好？

999
00:49:50,150 --> 00:49:53,250

1000
00:49:53,250 --> 00:49:55,244
>> 觀眾：如果別的嗎？

1001
00:49:55,244 --> 00:49:57,070
>> JASON HIRSCHHORN：如果其他人
不能為一個循環。

1002
00:49:57,070 --> 00:49:58,935
那麼什麼是循環類型，我們可以只
去，直到某些情況下得到滿足？

1003
00:49:58,935 --> 00:50:07,250

1004
00:50:07,250 --> 00:50:11,560
什麼是唯一的其他類型的循環
C語言除了for循環？

1005
00:50:11,560 --> 00:50:11,930
>> 觀眾：雖然。

1006
00:50:11,930 --> 00:50:13,380
>> JASON HIRSCHHORN：雖然，沒錯。

1007
00:50:13,380 --> 00:50:16,430
在while循環中，不
需要知道如何 - 

1008
00:50:16,430 --> 00:50:18,450
while循環和for循環可以做
同樣的事情，但美好的東西

1009
00:50:18,450 --> 00:50:21,500
關於while循環是我們不需要
要知道有多大我們的樹。

1010
00:50:21,500 --> 00:50:23,060
因此，我們打算去，直到什麼？

1011
00:50:23,060 --> 00:50:25,880

1012
00:50:25,880 --> 00:50:28,032
>> 觀眾：直到它等於
的大小 - 

1013
00:50:28,032 --> 00:50:32,320
>> JASON HIRSCHHORN：嗯，這是非常
類似我們的遞歸情況。

1014
00:50:32,320 --> 00:50:33,360
所以 - 

1015
00:50:33,360 --> 00:50:36,470
>> 觀眾：雖然根
我不等於我。

1016
00:50:36,470 --> 00:50:37,620
>> JASON HIRSCHHORN：這是真的很近。

1017
00:50:37,620 --> 00:50:39,430
而根I  - 

1018
00:50:39,430 --> 00:50:40,610
讓我們來試試吧。

1019
00:50:40,610 --> 00:50:41,180
我不認為[聽不清]

1020
00:50:41,180 --> 00:50:43,026
其中root我不等於我。

1021
00:50:43,026 --> 00:50:47,380

1022
00:50:47,380 --> 00:50:49,460
我們可能需要在一點點改變它
位，但聽起來​​就像是相當

1023
00:50:49,460 --> 00:50:50,160
好，現在。

1024
00:50:50,160 --> 00:50:51,710
因此，我們將做到這一點。

1025
00:50:51,710 --> 00:50:55,660
>> 此外，請記住，我們不能假設
每個問題。

1026
00:50:55,660 --> 00:50:57,880
你不假設
根將成為非null。

1027
00:50:57,880 --> 00:51:01,914
那麼你覺得很
我們應該做的第一件事是什麼？

1028
00:51:01,914 --> 00:51:02,770
>> 觀眾：剛剛做同樣的
和以前一樣的事情。

1029
00:51:02,770 --> 00:51:05,260
如果根等於等號
空，返回false。

1030
00:51:05,260 --> 00:51:11,030

1031
00:51:11,030 --> 00:51:12,130
>> JASON HIRSCHHORN：太好了。

1032
00:51:12,130 --> 00:51:13,820
因此它可以為null。

1033
00:51:13,820 --> 00:51:15,810
因此，我們要擺脫
它的時候了。

1034
00:51:15,810 --> 00:51:19,560
然後我們要去檢查，如果
根我不等於我。

1035
00:51:19,560 --> 00:51:24,480
所以，說我們正在尋找在這棵樹
3，根我不等於我，現在

1036
00:51:24,480 --> 00:51:25,950
我們在我們的while循環。

1037
00:51:25,950 --> 00:51:27,500
我們究竟想幹什麼？

1038
00:51:27,500 --> 00:51:32,320

1039
00:51:32,320 --> 00:51:35,430
再次，這將是相當
類似於我們的遞歸版本。

1040
00:51:35,430 --> 00:51:36,230
是啊。

1041
00:51:36,230 --> 00:51:40,470
>> 觀眾：所以你想要遍歷，或
不斷下降的樹，只要

1042
00:51:40,470 --> 00:51:42,400
根不等於空。

1043
00:51:42,400 --> 00:51:45,120

1044
00:51:45,120 --> 00:51:46,640
>> JASON HIRSCHHORN：只要
根不等於空？

1045
00:51:46,640 --> 00:51:50,200
>> 觀眾：根破折號我
不等於空。

1046
00:51:50,200 --> 00:51:51,220
只是根，是啊。

1047
00:51:51,220 --> 00:51:52,920
作為一個長期的根源是
不等於空。

1048
00:51:52,920 --> 00:51:54,240
>> JASON HIRSCHHORN：所以，你想要
要改變這種成根

1049
00:51:54,240 --> 00:51:56,590
不等於空？

1050
00:51:56,590 --> 00:51:59,020
>> 觀眾：是啊。

1051
00:51:59,020 --> 00:52:00,800
>> 觀眾：我們可以結合
這些，對不對？

1052
00:52:00,800 --> 00:52:02,990
我們不需要的，如果，最初。

1053
00:52:02,990 --> 00:52:05,180
>> JASON HIRSCHHORN：OK，所以如果我們鴕鳥政策 - 

1054
00:52:05,180 --> 00:52:08,140
如果我們結合它們，所以我們要做的
而根不等於空，

1055
00:52:08,140 --> 00:52:10,800
如果根恰好是在空
開始，我們怎麼辦下來嗎？

1056
00:52:10,800 --> 00:52:11,450
>> 觀眾：返回false。

1057
00:52:11,450 --> 00:52:12,730
>> JASON HIRSCHHORN：太好了。

1058
00:52:12,730 --> 00:52:14,110
因此，兩種方式可能
會工作。

1059
00:52:14,110 --> 00:52:15,645
這是一種不同的方式，
而這個結合了。

1060
00:52:15,645 --> 00:52:18,950
但同樣，如果你​​沒有任何辦法，我們
不打算脫下設計

1061
00:52:18,950 --> 00:52:19,800
點上的測驗。

1062
00:52:19,800 --> 00:52:21,020
但這個看起來不錯。

1063
00:52:21,020 --> 00:52:23,940
>> 因此，儘管根不等於
空，什麼是第一

1064
00:52:23,940 --> 00:52:25,400
的事情，我們要檢查？

1065
00:52:25,400 --> 00:52:26,330
別人？

1066
00:52:26,330 --> 00:52:29,720
空，什麼是第一件事情？

1067
00:52:29,720 --> 00:52:32,850
>> 觀眾：如果RI小於 - 

1068
00:52:32,850 --> 00:52:36,140
哦，我想，如果我們已經
發現它的根。

1069
00:52:36,140 --> 00:52:40,830
因此，如果根箭頭i是等於i  - 

1070
00:52:40,830 --> 00:52:40,990
>> JASON HIRSCHHORN：對不起？

1071
00:52:40,990 --> 00:52:45,840
>> 觀眾：如果根箭頭
i等於等於I  - 

1072
00:52:45,840 --> 00:52:47,090
>> JASON HIRSCHHORN：我們該怎麼辦？

1073
00:52:47,090 --> 00:52:50,300

1074
00:52:50,300 --> 00:52:51,550
>> 觀眾：返回true。

1075
00:52:51,550 --> 00:52:58,850

1076
00:52:58,850 --> 00:52:59,280
>> JASON HIRSCHHORN：太好了。

1077
00:52:59,280 --> 00:53:00,530
而下一步是什麼？

1078
00:53:00,530 --> 00:53:04,510

1079
00:53:04,510 --> 00:53:06,843
傑夫，什麼是下一行代碼？

1080
00:53:06,843 --> 00:53:16,190
>> 觀眾：如果i小於根箭頭
i，則根等於根箭頭左邊。

1081
00:53:16,190 --> 00:53:21,550
>> JASON HIRSCHHORN：根等號
根箭離開了。

1082
00:53:21,550 --> 00:53:24,530
所以，這可能是最大的
區別就在這裡在這個迭代

1083
00:53:24,530 --> 00:53:26,600
版本相對於
遞歸版本。

1084
00:53:26,600 --> 00:53:28,970
遞歸版本，我們
再次調用該函數。

1085
00:53:28,970 --> 00:53:32,640
我們將更新時，根
我們所說的新功能。

1086
00:53:32,640 --> 00:53:34,170
在這裡，我們不調用一個新的函數。

1087
00:53:34,170 --> 00:53:37,610
我們只是簡單地更新
根此功能。

1088
00:53:37,610 --> 00:53:38,880
這是極好的。

1089
00:53:38,880 --> 00:53:40,730
什麼是代碼的最後一行？

1090
00:53:40,730 --> 00:53:43,950

1091
00:53:43,950 --> 00:53:44,880
是啊，馬里奧？

1092
00:53:44,880 --> 00:53:48,290
>> 觀眾：否則等於根
根右側的箭頭。

1093
00:53:48,290 --> 00:53:49,492
>> JASON HIRSCHHORN：對不起？

1094
00:53:49,492 --> 00:53:52,340
>> 觀眾：根等號
根右側的箭頭。

1095
00:53:52,340 --> 00:53:55,590

1096
00:53:55,590 --> 00:53:57,140
>> JASON HIRSCHHORN：你也可以
寫這樣的事情？

1097
00:53:57,140 --> 00:54:02,786

1098
00:54:02,786 --> 00:54:03,890
>> 觀眾：我不知道。

1099
00:54:03,890 --> 00:54:05,140
>> JASON HIRSCHHORN：不能。

1100
00:54:05,140 --> 00:54:07,302

1101
00:54:07,302 --> 00:54:08,270
你不能這樣做，加上等號。

1102
00:54:08,270 --> 00:54:10,780
好了，這個不錯。

1103
00:54:10,780 --> 00:54:13,620
為什麼我們不這樣做
把它清理乾淨。

1104
00:54:13,620 --> 00:54:15,220
這看起來不錯，這是可行的。

1105
00:54:15,220 --> 00:54:16,920
而我們將要爆發。

1106
00:54:16,920 --> 00:54:21,460
>> 如果root左為null或向右根
為null，我們會來這兒。

1107
00:54:21,460 --> 00:54:22,470
根將等於空。

1108
00:54:22,470 --> 00:54:24,270
我們會打破我們的循環，
我們會返回false。

1109
00:54:24,270 --> 00:54:26,280
所以，當我們跳出的
循環中，我們返回false。

1110
00:54:26,280 --> 00:54:29,520

1111
00:54:29,520 --> 00:54:32,793
>> 再次，在一個while循環是完美的
在這裡，因為我們不知道如何

1112
00:54:32,793 --> 00:54:33,850
大我們的樹。

1113
00:54:33,850 --> 00:54:36,460
我們試著寫for循環，但我們
意識到你必須弄清楚如何

1114
00:54:36,460 --> 00:54:37,410
大的是時間提前。

1115
00:54:37,410 --> 00:54:38,720
是啊。

1116
00:54:38,720 --> 00:54:41,790
>> 觀眾：如果這不是一個二進制
搜索樹，這​​將是真正的數學-Y

1117
00:54:41,790 --> 00:54:44,220
要反复寫，對不對？

1118
00:54:44,220 --> 00:54:47,170
一樣，如果它是一棵樹，
但不一定 - 

1119
00:54:47,170 --> 00:54:49,730
所以它不是在左邊的所有越小，
而右邊都較大。

1120
00:54:49,730 --> 00:54:52,540
這將是非常困難的
遍歷它，對不對？

1121
00:54:52,540 --> 00:54:55,720
我們不得不拯救早期是什麼
在樹回去，

1122
00:54:55,720 --> 00:54:56,970
和類似的東西。

1123
00:54:56,970 --> 00:54:59,690

1124
00:54:59,690 --> 00:55:02,010
>> JASON HIRSCHHORN：如果它不是一個二進制
搜索樹，如果它只是一個

1125
00:55:02,010 --> 00:55:04,740
樹，事情沒
整理這樣的 - 

1126
00:55:04,740 --> 00:55:07,440
和我們之前意識到，當安娜
在幫助我們，使

1127
00:55:07,440 --> 00:55:08,800
排序的幫助了我們很多 - 

1128
00:55:08,800 --> 00:55:12,610
我們需要的，是的，永遠保存
我們以前。

1129
00:55:12,610 --> 00:55:14,430
但有可能是一個很大的
我們在哪裡previouslys。

1130
00:55:14,430 --> 00:55:17,730
可能有很多父節點的。

1131
00:55:17,730 --> 00:55:22,530
>> 可能做到這一點的最好辦法就是
是要繼續推動東西到一些

1132
00:55:22,530 --> 00:55:24,170
類型堆棧或隊列。

1133
00:55:24,170 --> 00:55:26,030
你將永遠不需要編寫本
因為這是一個困難的問題。

1134
00:55:26,030 --> 00:55:30,820
但你把一些東西到堆棧
或隊列，然後彈出他們關閉，

1135
00:55:30,820 --> 00:55:31,890
然後評估他們。

1136
00:55:31,890 --> 00:55:34,200
>> 然後有一些其他的東西在那裡
你實際上是把節點，

1137
00:55:34,200 --> 00:55:36,090
然後創建一個，然後
通過搜索。

1138
00:55:36,090 --> 00:55:38,700
這可能是做的最好的方式。

1139
00:55:38,700 --> 00:55:42,410
好了，關於這個問題的任何問題嗎？

1140
00:55:42,410 --> 00:55:44,670
>> 觀眾：這是一個相關的說明。

1141
00:55:44,670 --> 00:55:50,460
我們將要比較運行時間
對哈希表，二進制

1142
00:55:50,460 --> 00:55:52,160
搜索樹，等等？

1143
00:55:52,160 --> 00:55:54,310
>> JASON HIRSCHHORN：可能吧。

1144
00:55:54,310 --> 00:55:56,150
因此，讓我們做到這一點真的很快。

1145
00:55:56,150 --> 00:55:58,490
運行時間為哈希表 - 

1146
00:55:58,490 --> 00:55:59,090
什麼樣的人？

1147
00:55:59,090 --> 00:56:00,050
二叉樹？

1148
00:56:00,050 --> 00:56:02,920
>> 觀眾：鏈接列表。

1149
00:56:02,920 --> 00:56:04,780
>> JASON HIRSCHHORN：好，讓我們做插入。

1150
00:56:04,780 --> 00:56:09,980
什麼是插件的大O
在一個哈希表？

1151
00:56:09,980 --> 00:56:13,080

1152
00:56:13,080 --> 00:56:15,285
什麼是假設
你在做什麼？

1153
00:56:15,285 --> 00:56:17,760
>> 觀眾：你要插入的
開頭的鏈接列表。

1154
00:56:17,760 --> 00:56:19,860
>> JASON HIRSCHHORN：可能第一
假設是不存在衝突。

1155
00:56:19,860 --> 00:56:22,340
如果沒有衝突，則
插入時間就是其中之一。

1156
00:56:22,340 --> 00:56:26,560
如果有衝突，你就
做單獨的鏈接和插入

1157
00:56:26,560 --> 00:56:31,880
在鏈接列表的開頭，
然後插入也是恆定的。

1158
00:56:31,880 --> 00:56:34,700
>> 如果你正在做一個哈希表，但你
有處理的方法不同

1159
00:56:34,700 --> 00:56:36,040
有碰撞，有什麼
不同的方法？

1160
00:56:36,040 --> 00:56:41,580

1161
00:56:41,580 --> 00:56:42,960
什麼是一個不同的方法
處理的

1162
00:56:42,960 --> 00:56:44,205
在哈希表中的碰撞？

1163
00:56:44,205 --> 00:56:44,915
>> 觀眾：線性規劃。

1164
00:56:44,915 --> 00:56:45,540
>> JASON HIRSCHHORN：線性規劃。

1165
00:56:45,540 --> 00:56:47,770
所以，我們要繼續尋找
下一個空位。

1166
00:56:47,770 --> 00:56:50,390
這不是恆定的插入時間。

1167
00:56:50,390 --> 00:56:52,266
你可能不得不通過
整個表，使

1168
00:56:52,266 --> 00:56:53,936
可能的n大O。

1169
00:56:53,936 --> 00:56:54,740
是啊。

1170
00:56:54,740 --> 00:56:57,690
>> 觀眾：否則只是鏈接？

1171
00:56:57,690 --> 00:57:00,160
>> JASON HIRSCHHORN：我們做了
單獨的鏈接。

1172
00:57:00,160 --> 00:57:00,720
這是第一個。

1173
00:57:00,720 --> 00:57:01,560
這就是鏈接列表。

1174
00:57:01,560 --> 00:57:03,720
花哨的名字是單獨的鏈接。

1175
00:57:03,720 --> 00:57:06,880
它可以是任何類型的列表結構
我們正好在做鏈接列表。

1176
00:57:06,880 --> 00:57:10,490
>> 如此反复，插在一個哈希表
可能是恆定的時間。

1177
00:57:10,490 --> 00:57:13,160
關於插入什麼
在堆垛機的隊列？

1178
00:57:13,160 --> 00:57:19,260

1179
00:57:19,260 --> 00:57:20,640
>> 觀眾：是不是恆定的？

1180
00:57:20,640 --> 00:57:21,530
>> JASON HIRSCHHORN：這是不變的時間。

1181
00:57:21,530 --> 00:57:23,420
你只是推動它。

1182
00:57:23,420 --> 00:57:24,120
確定。

1183
00:57:24,120 --> 00:57:25,380
插入，請問是什麼其他的？

1184
00:57:25,380 --> 00:57:27,100
上一試？

1185
00:57:27,100 --> 00:57:30,252
什麼是插在一個try大O？

1186
00:57:30,252 --> 00:57:32,808
>> 觀眾：長度是恆定的。

1187
00:57:32,808 --> 00:57:34,560
最長長度 - 

1188
00:57:34,560 --> 00:57:36,998
字的長度
要插入。

1189
00:57:36,998 --> 00:57:38,210
>> JASON HIRSCHHORN：對不起？

1190
00:57:38,210 --> 00:57:39,120
等等，所以我怎麼聽見了嗎？

1191
00:57:39,120 --> 00:57:40,260
你說 - 你說什麼？

1192
00:57:40,260 --> 00:57:41,650
什麼是你的答案，馬庫斯？

1193
00:57:41,650 --> 00:57:43,640
>> 觀眾：這個詞的長度
你要插入的字符，

1194
00:57:43,640 --> 00:57:45,480
假設它是一個字符嘗試。

1195
00:57:45,480 --> 00:57:46,840
>> JASON HIRSCHHORN：好了，
字的長度。

1196
00:57:46,840 --> 00:57:49,500
我們會做一個假設，即
它的字符的字符串。

1197
00:57:49,500 --> 00:57:51,930
你說不同的東西，雖然。

1198
00:57:51,930 --> 00:57:55,490
你說的最長的單詞的長度。

1199
00:57:55,490 --> 00:57:57,600
>> 觀眾：這只是常數，對不對？

1200
00:57:57,600 --> 00:57:58,440
>> JASON HIRSCHHORN：為什麼會
它是恆定的？

1201
00:57:58,440 --> 00:58:00,970
>> 觀眾：就像，如果你使用大O
符號，那麼它不是基於變化

1202
00:58:00,970 --> 00:58:04,680
對事物的數
已經在嘗試。

1203
00:58:04,680 --> 00:58:07,344
>> JASON HIRSCHHORN：所以我們
說它是常量時間。

1204
00:58:07,344 --> 00:58:11,840
它是恆定的插入，並
那是因為這樣的想法 - 

1205
00:58:11,840 --> 00:58:14,820
說我們有一個字，就是45，
或一個詞，就是60，那

1206
00:58:14,820 --> 00:58:16,800
有一個恆定的數量。

1207
00:58:16,800 --> 00:58:21,050
它只會被插入
在常數時間。

1208
00:58:21,050 --> 00:58:26,060
>> 但在實踐中，它不會是，
顯然，發生在一毫秒內

1209
00:58:26,060 --> 00:58:26,590
例如。

1210
00:58:26,590 --> 00:58:28,880
但我們會說大O是
不斷的嘗試。

1211
00:58:28,880 --> 00:58:31,330
這就是它的一個
最大的優點。

1212
00:58:31,330 --> 00:58:33,330
>> 怎麼樣插入一個鏈接列表？

1213
00:58:33,330 --> 00:58:37,220
只需一個通用的，排序的鏈接列表？

1214
00:58:37,220 --> 00:58:37,700
是啊。

1215
00:58:37,700 --> 00:58:38,530
>> 觀眾：我有一個問題。

1216
00:58:38,530 --> 00:58:42,670
在測試中，他們會不斷問我們的
插入時間這四個步驟，

1217
00:58:42,670 --> 00:58:43,270
還是什麼？

1218
00:58:43,270 --> 00:58:44,300
還是只是 - 

1219
00:58:44,300 --> 00:58:47,670
當你說的插入時間為一，
這只是意味著恆定的時間？

1220
00:58:47,670 --> 00:58:49,770
>> JASON HIRSCHHORN：是啊，他們會
總是問，是它的n大O？

1221
00:58:49,770 --> 00:58:51,440
日誌的n大O？

1222
00:58:51,440 --> 00:58:53,960
Ñ​​平方不變。

1223
00:58:53,960 --> 00:58:56,520
這些都是真正的唯一
那些你需要知道的。

1224
00:58:56,520 --> 00:58:58,420
什麼插入到
排序的鏈接列表？

1225
00:58:58,420 --> 00:58:59,440
>> 觀眾：我有一個問題 - 

1226
00:58:59,440 --> 00:58:59,980
一個問題 - 

1227
00:58:59,980 --> 00:59:01,060
>> JASON HIRSCHHORN：答案是什麼
對這個問題有關係嗎？

1228
00:59:01,060 --> 00:59:02,120
>> 觀眾：等等，你問什麼？

1229
00:59:02,120 --> 00:59:06,750
>> JASON HIRSCHHORN：什麼是大O
插入排序的鏈接列表？

1230
00:59:06,750 --> 00:59:07,070
>> 觀眾：一？

1231
00:59:07,070 --> 00:59:09,400
無等待，無等待，正。

1232
00:59:09,400 --> 00:59:11,420
>> JASON HIRSCHHORN：N.除了
鏈接列表。

1233
00:59:11,420 --> 00:59:12,706
什麼是你的問題？

1234
00:59:12,706 --> 00:59:16,440
>> 觀眾：所以你會寫
Øk或鄰1對的 - 

1235
00:59:16,440 --> 00:59:18,150
>> JASON HIRSCHHORN：哦。

1236
00:59:18,150 --> 00:59:21,830
我會寫鄰1，大概。

1237
00:59:21,830 --> 00:59:24,160
還有另外一個數據結構
這將是良好的。

1238
00:59:24,160 --> 00:59:25,730
樹，二叉搜索樹。

1239
00:59:25,730 --> 00:59:27,510
什麼是插入在
二叉查找樹？

1240
00:59:27,510 --> 00:59:31,190

1241
00:59:31,190 --> 00:59:33,900
>> 觀眾：登錄。

1242
00:59:33,900 --> 00:59:39,260
>> JASON HIRSCHHORN：那麼，什麼是最糟糕的
情況二叉搜索樹？

1243
00:59:39,260 --> 00:59:45,350
因此，如果我們碰巧從5開始，每
數大於5，則

1244
00:59:45,350 --> 00:59:48,760
我們已經有了5，7，9，11，等等。

1245
00:59:48,760 --> 00:59:52,255
在這種情況下，它基本上只是一個鏈接
列表，我們需要插入所有

1246
00:59:52,255 --> 00:59:52,680
的方式在末端。

1247
00:59:52,680 --> 00:59:54,350
所以它的n個大O。

1248
00:59:54,350 --> 00:59:57,720
>> 這可能是我們最糟糕的情況
在二叉搜索樹。

1249
00:59:57,720 --> 01:00:00,890
很明顯，你永遠不會建造
與5中的一個二分搜索樹

1250
01:00:00,890 --> 01:00:04,270
中間，知道5將
是最低的數字。

1251
01:00:04,270 --> 01:00:08,030
但它可能是，如果你
從頭開始。

1252
01:00:08,030 --> 01:00:10,980
這之前的任何問題，我
移動到另一個問題？

1253
01:00:10,980 --> 01:00:11,560
這是一個很好的問題。

1254
01:00:11,560 --> 01:00:15,100
我想知道大O  - 

1255
01:00:15,100 --> 01:00:18,620
>> 觀眾：關於搜索什麼
這四個？

1256
01:00:18,620 --> 01:00:20,400
>> JASON HIRSCHHORN：當然我們
沒有搜索和排序。

1257
01:00:20,400 --> 01:00:22,160
我們做了所有這些算法，對吧。

1258
01:00:22,160 --> 01:00:23,390
等待，是測驗1？

1259
01:00:23,390 --> 01:00:23,980
是蓋 - 

1260
01:00:23,980 --> 01:00:25,860
你已經有
問題在測驗1？

1261
01:00:25,860 --> 01:00:29,650
二進制搜索的大O運行時，
插入排序，冒泡排序？

1262
01:00:29,650 --> 01:00:30,160
>> 觀眾：是啊。

1263
01:00:30,160 --> 01:00:32,790
>> JASON HIRSCHHORN：如果您有這樣的
在測驗0的問題，可能你不會

1264
01:00:32,790 --> 01:00:35,180
得到測驗1完全相同的問題。

1265
01:00:35,180 --> 01:00:36,300
可能是還是不錯的知道這些。

1266
01:00:36,300 --> 01:00:38,520
你應該希望知道的GH了。

1267
01:00:38,520 --> 01:00:40,740
>> 但其他數運行時間
可能是很好的了解。

1268
01:00:40,740 --> 01:00:42,890
未涉及的測驗0的東西。

1269
01:00:42,890 --> 01:00:47,300
像所有的這些運算符的
這些抽象數據類型。

1270
01:00:47,300 --> 01:00:50,760
>> 好吧，讓我們繼續前進。

1271
01:00:50,760 --> 01:00:52,190
這應該是相當快的。

1272
01:00:52,190 --> 01:00:56,170
這是一種新的語言，我們沒有
其實在編碼之前。

1273
01:00:56,170 --> 01:00:59,300
這是一個問題，問
在PHP代碼。

1274
01:00:59,300 --> 01:01:01,950
因此，考慮下面的PHP數組。

1275
01:01:01,950 --> 01:01:06,150
寫PHP和/或HTML代碼，使得它
輸出與TFS一個兩列的表格

1276
01:01:06,150 --> 01:01:08,810
名稱和房屋。

1277
01:01:08,810 --> 01:01:11,600
>> 你從來沒有這樣做過，
此特定問題。

1278
01:01:11,600 --> 01:01:16,270
但是，這應該是非常熟悉的
你的問題確實設置7。

1279
01:01:16,270 --> 01:01:21,250
所以，我願意打賭你會
問到代碼的東西在PHP中

1280
01:01:21,250 --> 01:01:23,880
非常類似於您
在問題沒有設定7。

1281
01:01:23,880 --> 01:01:26,300
>> 首先，數組是不是特定的。

1282
01:01:26,300 --> 01:01:28,140
什麼數組類型是什麼？

1283
01:01:28,140 --> 01:01:29,080
>> 觀眾：會意字。

1284
01:01:29,080 --> 01:01:31,250
>> JASON HIRSCHHORN：這是
一個關聯數組。

1285
01:01:31,250 --> 01:01:33,750
和什麼之間的區別
關聯數組和對象？

1286
01:01:33,750 --> 01:01:41,780

1287
01:01:41,780 --> 01:01:44,857
>> 觀眾：一個對象數組的索引
整數和一個關聯數組

1288
01:01:44,857 --> 01:01:47,814
是字符串的索引，
或者類似的東西。

1289
01:01:47,814 --> 01:01:50,570

1290
01:01:50,570 --> 01:01:54,880
>> JASON HIRSCHHORN：這麼一個數組
對象將有指標

1291
01:01:54,880 --> 01:01:57,090
整數，但一個對象的字段。

1292
01:01:57,090 --> 01:02:01,590
它也有類似的那些字段名稱
名稱，門牌，學生。

1293
01:02:01,590 --> 01:02:03,720
你有一個想法？

1294
01:02:03,720 --> 01:02:06,630
>> 觀眾：嗯，聯想
數組是PHP的，對不對？

1295
01:02:06,630 --> 01:02:07,880
和對象是在JavaScript？

1296
01:02:07,880 --> 01:02:12,330

1297
01:02:12,330 --> 01:02:14,820
>> JASON HIRSCHHORN：說實話，有沒有
兩者之間真正的區別。

1298
01:02:14,820 --> 01:02:19,540
兩者都有字符串作為密鑰，並能
基本上有什麼作為值。

1299
01:02:19,540 --> 01:02:21,250
不同的語言呼叫一個
事情關聯數組，

1300
01:02:21,250 --> 01:02:22,750
一件事情的對象。

1301
01:02:22,750 --> 01:02:25,960
所以說實話，有沒有真正的
差異，但有一些肯定

1302
01:02:25,960 --> 01:02:27,730
語法差異
兩者之間。

1303
01:02:27,730 --> 01:02:28,200
是啊。

1304
01:02:28,200 --> 01:02:33,580
>> 觀眾：那麼，對象也根據編碼
油煙機作為一個哈希表，然後呢？

1305
01:02:33,580 --> 01:02:35,796
>> JASON HIRSCHHORN：你這是什麼
意思是，引擎蓋下的編碼？

1306
01:02:35,796 --> 01:02:38,017
>> 觀眾：我們被告知，聯想
陣列在技術上是一個

1307
01:02:38,017 --> 01:02:39,960
哈希表。

1308
01:02:39,960 --> 01:02:44,510
那麼，對象也從技術上
哈希表？

1309
01:02:44,510 --> 01:02:45,350
>> JASON HIRSCHHORN：我不會
要回答這個問題。

1310
01:02:45,350 --> 01:02:46,600
我會盡快給你這一點。

1311
01:02:46,600 --> 01:02:48,980
但我不認為任何一個
那些這樣。

1312
01:02:48,980 --> 01:02:53,790
但是，以任何方式，關聯數組和
對象，通常，人們用這些

1313
01:02:53,790 --> 01:02:54,910
術語可以互換。

1314
01:02:54,910 --> 01:02:57,630
在這種情況下，涼爽的一部分
是您可以使用鍵。

1315
01:02:57,630 --> 01:03:00,580
字符串作為鍵，而不是
只是簡單的數字。

1316
01:03:00,580 --> 01:03:02,070
>> 所以我一直在談論
這一段時間。

1317
01:03:02,070 --> 01:03:04,090
我們希望，有些人有
得到就這樣開始了。

1318
01:03:04,090 --> 01:03:08,050
我們將編寫一些PHP和HTML
代碼，這樣，我們得到一個兩列

1319
01:03:08,050 --> 01:03:11,830
表與TFS名和房屋。

1320
01:03:11,830 --> 01:03:15,380
>> 好吧，我也想一個標題
排此表上。

1321
01:03:15,380 --> 01:03:18,410
所以我要得到直
到這一點。

1322
01:03:18,410 --> 01:03:20,770
我們要文件，新建，
而且我們要 - 

1323
01:03:20,770 --> 01:03:27,780

1324
01:03:27,780 --> 01:03:28,320
>> 確定。

1325
01:03:28,320 --> 01:03:29,970
我該如何開始一個表？

1326
01:03:29,970 --> 01:03:32,090
什麼是標籤，邁克爾，
啟動一個表？

1327
01:03:32,090 --> 01:03:32,890
>> 對象：表。

1328
01:03:32,890 --> 01:03:34,020
>> JASON HIRSCHHORN：表。

1329
01:03:34,020 --> 01:03:37,870
如果我打開一個標籤，是什麼
還有什麼我需要什麼？

1330
01:03:37,870 --> 01:03:39,810
>> 觀眾：頭部？

1331
01:03:39,810 --> 01:03:41,040
或者，我猜，類。

1332
01:03:41,040 --> 01:03:41,730
>> JASON HIRSCHHORN：那麼，對不起。

1333
01:03:41,730 --> 01:03:45,430
假定我們已經寫
doctab，HTML，所有的東西。

1334
01:03:45,430 --> 01:03:50,230
但是，如果我打開這個表標籤，是什麼
還有什麼我需要寫？

1335
01:03:50,230 --> 01:03:53,450
為驗證HTML嗎？

1336
01:03:53,450 --> 01:03:55,000
>> 觀眾：關閉它。

1337
01:03:55,000 --> 01:03:56,050
>> JASON HIRSCHHORN：關閉標籤。

1338
01:03:56,050 --> 01:03:57,575
我怎樣寫一個特寫table標籤？

1339
01:03:57,575 --> 01:03:59,580
>> 觀眾：點斜線表。

1340
01:03:59,580 --> 01:04:00,960
>> JASON HIRSCHHORN：斜線表，太好了。

1341
01:04:00,960 --> 01:04:02,730
可能是有道理寫兩個
那些因為一起

1342
01:04:02,730 --> 01:04:03,870
你必須做到這一點。

1343
01:04:03,870 --> 01:04:08,575
好吧，如果我想要一個標題行，怎麼辦
我寫的標題行的標題？

1344
01:04:08,575 --> 01:04:11,650

1345
01:04:11,650 --> 01:04:19,290
>> 觀眾：是不是少
超過10小時密切 - 

1346
01:04:19,290 --> 01:04:21,550
TR，是的。

1347
01:04:21,550 --> 01:04:22,100
>> JASON HIRSCHHORN：TR？

1348
01:04:22,100 --> 01:04:25,080
>> 觀眾：那麼同樣的事情，
斜線，是啊。

1349
01:04:25,080 --> 01:04:26,610
>> JASON HIRSCHHORN：確定，
給我兩列。

1350
01:04:26,610 --> 01:04:30,100

1351
01:04:30,100 --> 01:04:33,210
>> 觀眾：T D？

1352
01:04:33,210 --> 01:04:34,460
>> JASON HIRSCHHORN：確定。

1353
01:04:34,460 --> 01:04:37,730

1354
01:04:37,730 --> 01:04:39,520
我想兩列。

1355
01:04:39,520 --> 01:04:40,960
這是否能給我兩列？

1356
01:04:40,960 --> 01:04:43,880
多少列，這是？

1357
01:04:43,880 --> 01:04:45,920
之一。

1358
01:04:45,920 --> 01:04:47,170
因此，讓我們複製並粘貼此。

1359
01:04:47,170 --> 01:04:59,750

1360
01:04:59,750 --> 01:05:03,390
>> 因此，實際上，在測驗，所有這些代碼
我們已經寫了這麼遠了

1361
01:05:03,390 --> 01:05:04,710
其實給你。

1362
01:05:04,710 --> 01:05:06,200
但你應該還
知道怎麼寫呢。

1363
01:05:06,200 --> 01:05:06,470
是啊。

1364
01:05:06,470 --> 01:05:10,636
>> 觀眾：你的房子
兩者之間。

1365
01:05:10,636 --> 01:05:11,130
>> JASON HIRSCHHORN：繁榮。

1366
01:05:11,130 --> 01:05:12,720
它應該就在那裡，對不對？

1367
01:05:12,720 --> 01:05:14,600
良好的通話。

1368
01:05:14,600 --> 01:05:17,760
所以，再一次，所有這些代碼實際上是
給你實際的測驗。

1369
01:05:17,760 --> 01:05:19,570
但它的樂趣，寫它，你
應該知道怎麼寫呢。

1370
01:05:19,570 --> 01:05:23,640
因此，這就是你需要
開始你的代碼。

1371
01:05:23,640 --> 01:05:25,150
什麼是我們需要在這裡寫？

1372
01:05:25,150 --> 01:05:28,640

1373
01:05:28,640 --> 01:05:30,565
>> 對不起，我需要改變
該文件的名稱。

1374
01:05:30,565 --> 01:05:41,180

1375
01:05:41,180 --> 01:05:44,270
因此，我們將其保存在一個。的HTML文件，
沒有一個。PHP文件。

1376
01:05:44,270 --> 01:05:47,030
這些東西會是什麼呢？
在一個。PHP文件。

1377
01:05:47,030 --> 01:05:48,500
所以我們在一個。的HTML文件。

1378
01:05:48,500 --> 01:05:50,090
什麼是第一件事情
我需要寫？

1379
01:05:50,090 --> 01:05:52,990
我想提出一些PHP
在HTML代碼。

1380
01:05:52,990 --> 01:05:57,300
>> 觀眾：PHP的，像另一個胡蘿蔔
和問號PHP的，對不對？

1381
01:05:57,300 --> 01:05:58,310
>> JASON HIRSCHHORN：太好了。

1382
01:05:58,310 --> 01:05:59,360
如何才能結束呢？

1383
01:05:59,360 --> 01:06:02,510
>> 觀眾：用一個問號。

1384
01:06:02,510 --> 01:06:03,120
>> JASON HIRSCHHORN：那太好了。

1385
01:06:03,120 --> 01:06:07,090
這就是我需要的，如果我想的第一件事
把一些PHP代碼在這裡。

1386
01:06:07,090 --> 01:06:11,210
>> 觀眾：我想一個PHP
文件可以採取的HTML。

1387
01:06:11,210 --> 01:06:12,290
>> JASON HIRSCHHORN：是啊。

1388
01:06:12,290 --> 01:06:15,330
一，PHP文件可以採取一些
HTML和顯示。

1389
01:06:15,330 --> 01:06:16,450
這是我的壞。

1390
01:06:16,450 --> 01:06:18,300
我只是試圖模仿
這是什麼的測驗。

1391
01:06:18,300 --> 01:06:21,910

1392
01:06:21,910 --> 01:06:24,720
>> 好了，對不起你迷惑。

1393
01:06:24,720 --> 01:06:25,550
是的，practice.HTML。

1394
01:06:25,550 --> 01:06:27,340
現在，我們打算把
一些PHP代碼英寸

1395
01:06:27,340 --> 01:06:30,530
這是第一行
PHP代碼我應該怎麼寫？

1396
01:06:30,530 --> 01:06:33,360
我要通過這個數組
並使其成為一個表。

1397
01:06:33,360 --> 01:06:34,600
是啊。

1398
01:06:34,600 --> 01:06:37,160
>> 觀眾：您可以使用
一個的H循環或for循環。

1399
01:06:37,160 --> 01:06:38,415
>> JASON HIRSCHHORN：好的，有什麼
你要使用？

1400
01:06:38,415 --> 01:06:40,720
>> 觀眾：我會用一個for循環。

1401
01:06:40,720 --> 01:06:48,700
對，然後你做的美元符號
i等於0分號美元

1402
01:06:48,700 --> 01:06:51,580
簽署小於2我。

1403
01:06:51,580 --> 01:06:55,455
然後我分號美元
簽署加我加。

1404
01:06:55,455 --> 01:07:01,890

1405
01:07:01,890 --> 01:07:03,880
>> JASON HIRSCHHORN：如何做
你知道使用一個2？

1406
01:07:03,880 --> 01:07:10,444
>> 觀眾：因為有兩個
在較大的關聯數組

1407
01:07:10,444 --> 01:07:11,960
關聯數組。

1408
01:07:11,960 --> 01:07:13,610
>> JASON HIRSCHHORN：那麼大的事情的
沒有聯繫的數組。

1409
01:07:13,610 --> 01:07:15,500
最重要的事情只是一個正常的數組。

1410
01:07:15,500 --> 01:07:17,380
但你說得對，有
2關聯數組

1411
01:07:17,380 --> 01:07:18,910
我們的內部更大的數組。

1412
01:07:18,910 --> 01:07:20,310
這就是為什麼你使用兩個。

1413
01:07:20,310 --> 01:07:24,270
我覺得不舒服假設
他們是2，有啥辦法寫

1414
01:07:24,270 --> 01:07:26,810
這個沒有假設他們是2？

1415
01:07:26,810 --> 01:07:27,507
>> 觀眾：[聽不清]？

1416
01:07:27,507 --> 01:07:29,165
>> JASON HIRSCHHORN：好的，怎麼
你寫的嗎？

1417
01:07:29,165 --> 01:07:35,262
>> 觀眾：Foreach回美元符號
TFS或像美元符號TF。

1418
01:07:35,262 --> 01:07:38,360

1419
01:07:38,360 --> 01:07:41,960
>> JASON HIRSCHHORN：OK，所以對於每個
TFS作為TFS，我想，現在

1420
01:07:41,960 --> 01:07:43,650
再次，有我的表。

1421
01:07:43,650 --> 01:07:45,250
那麼，誰可以給我
下一行代碼？

1422
01:07:45,250 --> 01:07:52,870

1423
01:07:52,870 --> 01:07:59,810
>> 觀眾：打印，然後在
報價，支架TR結束

1424
01:07:59,810 --> 01:08:02,670
支架，最終報價。

1425
01:08:02,670 --> 01:08:05,300
結束括號，分號。

1426
01:08:05,300 --> 01:08:07,135
>> JASON HIRSCHHORN：確定，
什麼該怎麼辦呢？

1427
01:08:07,135 --> 01:08:08,610
>> 觀眾：它會說，新行。

1428
01:08:08,610 --> 01:08:11,070
它會放
標記為新行。

1429
01:08:11,070 --> 01:08:13,000
>> JASON HIRSCHHORN：對，這個PHP一樣
我們前面談到的 - 這

1430
01:08:13,000 --> 01:08:22,160
PHP將被求值，然後
它會打印出該文件

1431
01:08:22,160 --> 01:08:26,350
表絲束，然後該
HTML將被評估。

1432
01:08:26,350 --> 01:08:27,810
我們只是複製本
HTML我們不得不在這裡。

1433
01:08:27,810 --> 01:08:28,120
是啊。

1434
01:08:28,120 --> 01:08:29,470
>> 觀眾：[聽不清]？

1435
01:08:29,470 --> 01:08:30,290
>> JASON HIRSCHHORN：對不起？

1436
01:08:30,290 --> 01:08:31,240
就是這裡。

1437
01:08:31,240 --> 01:08:33,590
2012年秋季。

1438
01:08:33,590 --> 01:08:35,970
不要看答案，
讓我們來解決它在一起。

1439
01:08:35,970 --> 01:08:37,330
所以，我們打印的表行。

1440
01:08:37,330 --> 01:08:38,550
所以你可能在
擺動的東西。

1441
01:08:38,550 --> 01:08:41,060
什麼是下一行
代碼，我們需要寫？

1442
01:08:41,060 --> 01:08:42,926
阿薩姆，給我的下一行代碼。

1443
01:08:42,926 --> 01:08:46,290
>> 觀眾：你需要的TF的名字。

1444
01:08:46,290 --> 01:08:54,319
TF開括號引號
名左右方括號。

1445
01:08:54,319 --> 01:08:57,310
>> JASON HIRSCHHORN：給我他們的名字。

1446
01:08:57,310 --> 01:08:58,540
>> 觀眾：你需要打印。

1447
01:08:58,540 --> 01:08:59,790
>> [插VOICES]

1448
01:08:59,790 --> 01:09:01,963

1449
01:09:01,963 --> 01:09:03,430
>> JASON HIRSCHHORN：OK，
我怎麼打印呢？

1450
01:09:03,430 --> 01:09:04,680
>> [插VOICES]

1451
01:09:04,680 --> 01:09:08,609

1452
01:09:08,609 --> 01:09:10,350
>> JASON HIRSCHHORN：我失踪
現在的東西。

1453
01:09:10,350 --> 01:09:12,470
我在想什麼？

1454
01:09:12,470 --> 01:09:13,720
>> 觀眾：你需要一個美元符號。

1455
01:09:13,720 --> 01:09:15,960

1456
01:09:15,960 --> 01:09:17,210
>> JASON HIRSCHHORN：什麼
什麼我失踪？

1457
01:09:17,210 --> 01:09:20,100

1458
01:09:20,100 --> 01:09:21,650
所有我們到目前為止印刷是TR。

1459
01:09:21,650 --> 01:09:25,589

1460
01:09:25,589 --> 01:09:27,470
>> 觀眾：後關閉TR。

1461
01:09:27,470 --> 01:09:28,720
>> JASON HIRSCHHORN：因此，我們需要
後關閉TR。

1462
01:09:28,720 --> 01:09:34,390

1463
01:09:34,390 --> 01:09:37,906
誰看見我們錯過了什麼
第16行？

1464
01:09:37,906 --> 01:09:39,340
是的，安娜。

1465
01:09:39,340 --> 01:09:47,050
>> 觀眾：你需要打開
一個TD和大括號。

1466
01:09:47,050 --> 01:09:49,380
>> JASON HIRSCHHORN：在哪裡
我們把花括號？

1467
01:09:49,380 --> 01:09:51,790
>> 觀眾：圍繞TF名字。

1468
01:09:51,790 --> 01:09:53,080
>> JASON HIRSCHHORN：喜歡這個？

1469
01:09:53,080 --> 01:09:55,420
>> 觀眾：是啊。

1470
01:09:55,420 --> 01:09:59,000
然後關閉TD。

1471
01:09:59,000 --> 01:10:00,250
>> JASON HIRSCHHORN：像這樣？

1472
01:10:00,250 --> 01:10:03,370

1473
01:10:03,370 --> 01:10:06,950
>> 觀眾：你需要雙引號
標記旁邊的大括號？

1474
01:10:06,950 --> 01:10:07,460
>> JASON HIRSCHHORN：就在這裡？

1475
01:10:07,460 --> 01:10:08,710
不，你不知道。

1476
01:10:08,710 --> 01:10:10,820

1477
01:10:10,820 --> 01:10:12,550
所以這是完全正確的。

1478
01:10:12,550 --> 01:10:12,940
是啊。

1479
01:10:12,940 --> 01:10:15,290
>> 觀眾：所以這之間的區別
和用點encatenating是，如果

1480
01:10:15,290 --> 01:10:18,420
你用點，你必須有
雙引號，那麼一個點，

1481
01:10:18,420 --> 01:10:20,370
然後點 - 

1482
01:10:20,370 --> 01:10:20,520
>> JASON HIRSCHHORN：正確。

1483
01:10:20,520 --> 01:10:23,800
所以你說有一個最終的
的方式寫這這樣的。

1484
01:10:23,800 --> 01:10:26,760

1485
01:10:26,760 --> 01:10:28,966
什麼是連接運算符
在JavaScript中？

1486
01:10:28,966 --> 01:10:31,200
>> 觀眾：加號。

1487
01:10:31,200 --> 01:10:34,710
你忘了把
大括號後面。

1488
01:10:34,710 --> 01:10:35,760
>> JASON HIRSCHHORN：太好了。

1489
01:10:35,760 --> 01:10:38,850
並且還有一系
代碼丟失。

1490
01:10:38,850 --> 01:10:40,130
誰可以給我的最後一行
的代碼，我們就錯過？

1491
01:10:40,130 --> 01:10:43,940

1492
01:10:43,940 --> 01:10:47,602
>> 觀眾：剛才完全一樣的東西，
剛剛與房子，而不是名稱。

1493
01:10:47,602 --> 01:10:52,960

1494
01:10:52,960 --> 01:10:53,450
大

1495
01:10:53,450 --> 01:10:54,390
>> JASON HIRSCHHORN：太好了。

1496
01:10:54,390 --> 01:10:59,320
和你的語法是完全正確的
在獲得一個關聯數組的東西。

1497
01:10:59,320 --> 01:11:04,450
因此，在實際測驗，你是
實際上放棄了，直到這裡。

1498
01:11:04,450 --> 01:11:05,710
所以這段代碼是給你的。

1499
01:11:05,710 --> 01:11:07,750
你不得不寫有這些
四行並記住

1500
01:11:07,750 --> 01:11:09,190
關閉表標籤。

1501
01:11:09,190 --> 01:11:11,370
你這傢伙居然沒
一切和更多。

1502
01:11:11,370 --> 01:11:11,810
是啊。

1503
01:11:11,810 --> 01:11:14,850
>> 觀眾：所以這將是功能
如果你只是有相同的，所有的

1504
01:11:14,850 --> 01:11:17,250
一個大的打印通話，對吧？

1505
01:11:17,250 --> 01:11:19,630
然後就連接在一起
其上，等等？

1506
01:11:19,630 --> 01:11:20,730
>> JASON HIRSCHHORN：像這樣？

1507
01:11:20,730 --> 01:11:21,980
>> 觀眾：是啊。

1508
01:11:21,980 --> 01:11:23,810

1509
01:11:23,810 --> 01:11:26,940
它只是不會好看，如果你是
看著它，當你檢查

1510
01:11:26,940 --> 01:11:28,550
在您的網站元素，對不對？

1511
01:11:28,550 --> 01:11:29,800
>> JASON HIRSCHHORN：我同意。

1512
01:11:29,800 --> 01:11:35,410

1513
01:11:35,410 --> 01:11:38,710
如果我裝了這個網頁，我會成為
能夠看到這個PHP代碼，永遠不會消失？

1514
01:11:38,710 --> 01:11:39,240
>> 觀眾：號

1515
01:11:39,240 --> 01:11:40,080
>> JASON HIRSCHHORN：號

1516
01:11:40,080 --> 01:11:42,240
而實際上，我不會。

1517
01:11:42,240 --> 01:11:43,920
>> 觀眾：這是不是HTML，對不對？

1518
01:11:43,920 --> 01:11:45,000
所以，你也許可以 - 

1519
01:11:45,000 --> 01:11:46,780
>> JASON HIRSCHHORN：所以這個PHP將
評估服務器端。

1520
01:11:46,780 --> 01:11:51,020
PHP總是被判斷服務器端，所以
你永遠能看到PHP代碼。

1521
01:11:51,020 --> 01:11:52,980
>> 觀眾：但是你能夠
看到打印的結果。

1522
01:11:52,980 --> 01:11:53,480
>> JASON HIRSCHHORN：對。

1523
01:11:53,480 --> 01:11:55,510
而且說實話可能不
把它全部上線。

1524
01:11:55,510 --> 01:11:59,740
它可能很好地格式化你，
或者它可能把它放在同一行。

1525
01:11:59,740 --> 01:12:01,521
不清楚。

1526
01:12:01,521 --> 01:12:03,596
但是，是的，好一點。

1527
01:12:03,596 --> 01:12:06,470
>> 觀眾：怎麼會有的
沒有文字的高亮

1528
01:12:06,470 --> 01:12:07,550
任何PHP的命令？

1529
01:12:07,550 --> 01:12:09,370
因為我記得看到這一點。

1530
01:12:09,370 --> 01:12:11,620
>> JASON HIRSCHHORN：因為它是一個
。html文件在這裡在頂部。

1531
01:12:11,620 --> 01:12:20,390

1532
01:12:20,390 --> 01:12:21,650
你去那裡。

1533
01:12:21,650 --> 01:12:25,752

1534
01:12:25,752 --> 01:12:28,800
>> 觀眾：如果我們做了初步的方法
用for循環，正確的，如果我們

1535
01:12:28,800 --> 01:12:33,500
要訪問TFS，我們會
做TFS支架0支架，然後

1536
01:12:33,500 --> 01:12:35,180
[聽不清]？

1537
01:12:35,180 --> 01:12:35,970
>> JASON HIRSCHHORN：你會 - 

1538
01:12:35,970 --> 01:12:40,560
所以你說的for循環，你
會做的美元符號TFS支架1

1539
01:12:40,560 --> 01:12:41,850
或者我，對吧。

1540
01:12:41,850 --> 01:12:46,780
或美元符號我關閉支架
然後括號

1541
01:12:46,780 --> 01:12:49,600
雙引號，是的。

1542
01:12:49,600 --> 01:12:50,640
>> 好的，優秀的。

1543
01:12:50,640 --> 01:12:53,020
我們有一個更快的之一。

1544
01:12:53,020 --> 01:12:55,090
七分鐘，所以我想
走在這一個。

1545
01:12:55,090 --> 01:12:56,160
這是另一個例子。

1546
01:12:56,160 --> 01:12:58,740
我們現在是一個完全另一種語言。

1547
01:12:58,740 --> 01:12:59,990
>> 我們有一些HTML代碼。

1548
01:12:59,990 --> 01:13:02,480

1549
01:13:02,480 --> 01:13:07,460
這是在屏幕上種小，但
我希望你仔細看看它真的

1550
01:13:07,460 --> 01:13:11,140
很快，有人可以告訴我，
如果我要載入這個網頁，

1551
01:13:11,140 --> 01:13:12,390
我會看到什麼？

1552
01:13:12,390 --> 01:13:22,710

1553
01:13:22,710 --> 01:13:26,450
詳細說明一切
此網頁。

1554
01:13:26,450 --> 01:13:28,630
諾亞？

1555
01:13:28,630 --> 01:13:30,450
那麼我看到了什麼？

1556
01:13:30,450 --> 01:13:38,140
>> 觀眾：在代碼的前端
谷歌有感覺的文字和

1557
01:13:38,140 --> 01:13:39,190
提交按鈕。

1558
01:13:39,190 --> 01:13:41,180
>> JASON HIRSCHHORN：什麼
將按鈕說呢？

1559
01:13:41,180 --> 01:13:42,430
>> 觀眾：提交。

1560
01:13:42,430 --> 01:13:44,620

1561
01:13:44,620 --> 01:13:45,160
哦，搜索。

1562
01:13:45,160 --> 01:13:45,840
對不起。

1563
01:13:45,840 --> 01:13:46,830
>> JASON HIRSCHHORN：它會說搜索。

1564
01:13:46,830 --> 01:13:47,520
請記住，名稱。

1565
01:13:47,520 --> 01:13:50,550
我們使用什麼名稱？

1566
01:13:50,550 --> 01:13:53,774
這個name屬性，有什麼
用的？

1567
01:13:53,774 --> 01:13:55,470
>> [插VOICES]

1568
01:13:55,470 --> 01:13:59,300
>> 觀眾：這就是它的名字
因為當它被點擊？

1569
01:13:59,300 --> 01:14:00,160
>> JASON HIRSCHHORN：這可能是。

1570
01:14:00,160 --> 01:14:02,690
但是，我們通常看到的 - 為什麼
是我們給這個名稱的隊列？

1571
01:14:02,690 --> 01:14:03,830
為什麼我們看到了嗎？

1572
01:14:03,830 --> 01:14:05,220
是啊。

1573
01:14:05,220 --> 01:14:08,600
>> 觀眾：那豈不是成了指數
超級全局變量？

1574
01:14:08,600 --> 01:14:12,740
>> JASON HIRSCHHORN：是啊，一般當
這種形式會提交，然後在那裡

1575
01:14:12,740 --> 01:14:13,500
將這個提交給？

1576
01:14:13,500 --> 01:14:14,750
哪一頁？

1577
01:14:14,750 --> 01:14:16,820

1578
01:14:16,820 --> 01:14:18,460
諾亞，哪一頁將這個提交給？

1579
01:14:18,460 --> 01:14:25,710

1580
01:14:25,710 --> 01:14:27,700
>> 觀眾：我不知道。

1581
01:14:27,700 --> 01:14:28,920
>> JASON HIRSCHHORN：在哪裡
可能我們能找到它嗎？

1582
01:14:28,920 --> 01:14:31,025
你在哪裡找到什麼
頁面提交給？

1583
01:14:31,025 --> 01:14:32,850
哪一行代碼？

1584
01:14:32,850 --> 01:14:34,040
>> 觀眾：表單操作。

1585
01:14:34,040 --> 01:14:34,650
>> JASON HIRSCHHORN：沒錯。

1586
01:14:34,650 --> 01:14:35,130
行動。

1587
01:14:35,130 --> 01:14:37,100
所以它提交到搜索頁面。

1588
01:14:37,100 --> 01:14:38,630
反斜杠搜索。

1589
01:14:38,630 --> 01:14:40,140
所以這是完全正確的。

1590
01:14:40,140 --> 01:14:40,680
用什麼方法？

1591
01:14:40,680 --> 01:14:42,090
>> 觀眾：獲取。

1592
01:14:42,090 --> 01:14:42,490
>> JASON HIRSCHHORN：獲取。

1593
01:14:42,490 --> 01:14:43,420
沒錯。

1594
01:14:43,420 --> 01:14:44,490
所以我們閱讀這一點。

1595
01:14:44,490 --> 01:14:45,180
這將是一種形式。

1596
01:14:45,180 --> 01:14:45,910
你說得對。

1597
01:14:45,910 --> 01:14:50,340
兩件事情的形式，的標題
頁面和頂部將是谷歌。

1598
01:14:50,340 --> 01:14:54,270
>> 因此，這裡有兩個問題，你應該
能回答這個頁面。

1599
01:14:54,270 --> 01:15:01,760
如果此HTML住在這個網站，
用戶輸入錯誤到這個文本

1600
01:15:01,760 --> 01:15:06,900
場就在這裡，什麼URL將
用戶發現自己因

1601
01:15:06,900 --> 01:15:08,150
提交表單？

1602
01:15:08,150 --> 01:15:10,980

1603
01:15:10,980 --> 01:15:12,510
>> 因此，我們有這個權利在這裡。

1604
01:15:12,510 --> 01:15:13,720
我要回去
此頁，雖然。

1605
01:15:13,720 --> 01:15:16,980
我會寫了第一部分。

1606
01:15:16,980 --> 01:15:18,230
大家可以看到在這裡？

1607
01:15:18,230 --> 01:15:30,620

1608
01:15:30,620 --> 01:15:32,906
好了，馬里奧，你以為你知道嗎？

1609
01:15:32,906 --> 01:15:34,700
哪一頁？

1610
01:15:34,700 --> 01:15:37,630
>> 觀眾：反斜杠搜索。

1611
01:15:37,630 --> 01:15:38,880
>> JASON HIRSCHHORN：我要去
搬到這裡了。

1612
01:15:38,880 --> 01:15:44,800

1613
01:15:44,800 --> 01:15:49,155
OK，反斜線搜索問題
馬克Q等於錯誤。

1614
01:15:49,155 --> 01:15:53,560

1615
01:15:53,560 --> 01:15:55,165
任何人有不同的建議嗎？

1616
01:15:55,165 --> 01:15:57,910

1617
01:15:57,910 --> 01:15:59,160
是啊。

1618
01:15:59,160 --> 01:16:01,700

1619
01:16:01,700 --> 01:16:03,740
>> 那麼，如何才能得到這個？

1620
01:16:03,740 --> 01:16:05,520
好了，我們以前見過這個。

1621
01:16:05,520 --> 01:16:07,170
而你想出了這點。

1622
01:16:07,170 --> 01:16:08,870
你說的沒錯，諾亞，該
行動告訴我們什麼

1623
01:16:08,870 --> 01:16:11,700
頁面我們​​要。

1624
01:16:11,700 --> 01:16:12,820
>> 我們也知道用什麼方法。

1625
01:16:12,820 --> 01:16:13,420
我們正在做的get。

1626
01:16:13,420 --> 01:16:17,040
和GET和POST的區別
是，獲得顯示在URL

1627
01:16:17,040 --> 01:16:18,490
及後則沒有。

1628
01:16:18,490 --> 01:16:22,760
所以，如果我在寫帖子就在那裡
方法，會有什麼不同？

1629
01:16:22,760 --> 01:16:24,250
>> 觀眾：它只是
是斜線搜索。

1630
01:16:24,250 --> 01:16:25,400
>> JASON HIRSCHHORN：它會
剛剛被削減搜索。

1631
01:16:25,400 --> 01:16:27,400
沒有什麼比在這裡會發生什麼。

1632
01:16:27,400 --> 01:16:30,030
但因為它是一個得到，網址
顯示如下。

1633
01:16:30,030 --> 01:16:35,140
首先我們看到了一個問號和
我們看到的名稱和值。

1634
01:16:35,140 --> 01:16:42,730
說有另外一個文本字段，並
我給它r的名字，我輸入一個

1635
01:16:42,730 --> 01:16:45,220
值，毛蟲。

1636
01:16:45,220 --> 01:16:48,560
什麼現在這個樣子？

1637
01:16:48,560 --> 01:16:52,040
我還有一個文本字段，我給一個
r和毛毛蟲的值的名稱。

1638
01:16:52,040 --> 01:16:56,990
>> 觀眾：酒吧後你就會有
＆符號毛蟲。

1639
01:16:56,990 --> 01:16:58,380
>> JASON HIRSCHHORN：這是
沒有連字符。

1640
01:16:58,380 --> 01:17:00,500
>> 觀眾：或者只是什麼
在和符號。

1641
01:17:00,500 --> 01:17:01,330
>> JASON HIRSCHHORN：是啊，沒有。

1642
01:17:01,330 --> 01:17:03,700
你是對的，我錯了。

1643
01:17:03,700 --> 01:17:05,660
這就像一克。

1644
01:17:05,660 --> 01:17:06,910
>> 對象：卡特彼勒。

1645
01:17:06,910 --> 01:17:08,840

1646
01:17:08,840 --> 01:17:11,090
r等於毛毛蟲，對不起。

1647
01:17:11,090 --> 01:17:13,970

1648
01:17:13,970 --> 01:17:14,700
>> JASON HIRSCHHORN：有
在那裡沒有R？

1649
01:17:14,700 --> 01:17:16,680
>> 觀眾：沒有，沒有。

1650
01:17:16,680 --> 01:17:18,030
>> JASON HIRSCHHORN：我們將討論
關於下課。

1651
01:17:18,030 --> 01:17:18,930
這是完全正確的。

1652
01:17:18,930 --> 01:17:20,530
所以，是正確的。

1653
01:17:20,530 --> 01:17:23,430
然後你可以有很多這樣的，
他們將全部串連

1654
01:17:23,430 --> 01:17:24,950
連同這一點，。

1655
01:17:24,950 --> 01:17:25,900
所以這是完全正確的。

1656
01:17:25,900 --> 01:17:27,700
>> 還有一個問題。

1657
01:17:27,700 --> 01:17:30,676
畫出此HTML的DOM，開始
與文件。

1658
01:17:30,676 --> 01:17:33,330

1659
01:17:33,330 --> 01:17:34,570
我們可以這樣做，在兩分鐘。

1660
01:17:34,570 --> 01:17:36,790
我們將在這裡做了。

1661
01:17:36,790 --> 01:17:38,040
我將回到這個網頁。

1662
01:17:38,040 --> 01:17:40,630

1663
01:17:40,630 --> 01:17:42,160
OK，我們開始文檔。

1664
01:17:42,160 --> 01:17:49,698

1665
01:17:49,698 --> 01:17:52,090
>> 下一步是什麼？

1666
01:17:52,090 --> 01:17:53,910
所以，當你通讀 - 

1667
01:17:53,910 --> 01:17:54,540
>> 觀眾：HTML。

1668
01:17:54,540 --> 01:17:55,790
>> JASON HIRSCHHORN：HTML是下一個。

1669
01:17:55,790 --> 01:17:57,850
我們將通過標籤去標記。

1670
01:17:57,850 --> 01:18:00,890
什麼是HTML呢？

1671
01:18:00,890 --> 01:18:01,550
>> 觀眾：頭。

1672
01:18:01,550 --> 01:18:02,800
>> JASON HIRSCHHORN：頭。

1673
01:18:02,800 --> 01:18:05,090

1674
01:18:05,090 --> 01:18:08,520
頭後有什麼？

1675
01:18:08,520 --> 01:18:09,770
>> 觀眾：標題。

1676
01:18:09,770 --> 01:18:11,880

1677
01:18:11,880 --> 01:18:12,560
>> JASON HIRSCHHORN：標題。

1678
01:18:12,560 --> 01:18:14,740
和標題有谷歌的價值，
但我不會去

1679
01:18:14,740 --> 01:18:16,240
寫在現在。

1680
01:18:16,240 --> 01:18:18,750
好了，哪裡的身體去了？

1681
01:18:18,750 --> 01:18:20,890
>> 觀眾：還有脫落的HTML。

1682
01:18:20,890 --> 01:18:21,490
>> JASON HIRSCHHORN：沒錯。

1683
01:18:21,490 --> 01:18:22,820
機身自帶了這裡。

1684
01:18:22,820 --> 01:18:25,970

1685
01:18:25,970 --> 01:18:30,330
難道大家都明白為什麼
是這樣的話？

1686
01:18:30,330 --> 01:18:32,970
你應該能夠計算
這一點，也一樣，即使我沒有

1687
01:18:32,970 --> 01:18:33,665
這個漂亮的縮進。

1688
01:18:33,665 --> 01:18:37,680
>> 排序的縮進給它拿走，
但你可以看到，頭部標記有

1689
01:18:37,680 --> 01:18:41,240
被關閉，這意味著我們可能
不能下去在這裡。

1690
01:18:41,240 --> 01:18:43,460
我們需要回到多達什麼
是頭向右​​前

1691
01:18:43,460 --> 01:18:44,730
標籤，或未滿。

1692
01:18:44,730 --> 01:18:46,720
我們甚至用頭標記。

1693
01:18:46,720 --> 01:18:48,560
>> 並在進入身體的形式。

1694
01:18:48,560 --> 01:18:50,300
下形式，有兩個輸入端。

1695
01:18:50,300 --> 01:18:53,330

1696
01:18:53,330 --> 01:18:54,420
確定。

1697
01:18:54,420 --> 01:18:55,490
這就是我的一切。

1698
01:18:55,490 --> 01:18:56,980
測驗1是明天。

1699
01:18:56,980 --> 01:18:58,350
我很高興為你們。

1700
01:18:58,350 --> 01:18:59,690
這將是一個爆炸。

1701
01:18:59,690 --> 01:19:00,250
>> 如果你有 - 

1702
01:19:00,250 --> 01:19:00,600
>> 觀眾：[掌聲]

1703
01:19:00,600 --> 01:19:02,460
>> JASON HIRSCHHORN：哦停下來，停下來。

1704
01:19:02,460 --> 01:19:04,520
不過沒有關係，我在開玩笑。

1705
01:19:04,520 --> 01:19:07,220
如果您有任何疑問，右
節後，我在外面。

1706
01:19:07,220 --> 01:19:11,700
如果您有任何疑問，今晚，
隨時來電，電子郵件，gchat，

1707
01:19:11,700 --> 01:19:12,740
信鴿我。

1708
01:19:12,740 --> 01:19:13,950
祝你好運明天。

1709
01:19:13,950 --> 01:19:16,220
有一個美好的感恩節假期，
如果我沒有看到你在那之前。

1710
01:19:16,220 --> 01:19:19,320
我會在感恩節之後見到你
對我們的最終週二

1711
01:19:19,320 --> 01:19:20,295
部分黨永遠。

1712
01:19:20,295 --> 01:19:21,545
>> 觀眾：[聽不清]。

1713
01:19:21,545 --> 01:19:25,270

1714
01:19:25,270 --> 01:19:25,790
>> JASON HIRSCHHORN：太好了。

1715
01:19:25,790 --> 01:19:28,900
好吧，我看下你們
一周或兩週。

1716
01:19:28,900 --> 01:19:30,150
而明天好運。

1717
01:19:30,150 --> 01:19:32,203