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

2
00:00:08,350 --> 00:00:09,710
>> KEVIN SCHMID：大家好。

3
00:00:09,710 --> 00:00:12,640
歡迎來到CS50研討會
關於Node.js的

4
00:00:12,640 --> 00:00:13,955
我的名字是凱文。

5
00:00:13,955 --> 00:00:15,580
我是一個CS50 TF。

6
00:00:15,580 --> 00:00:17,650
和我有點像真的很興奮
關於本次研討會。

7
00:00:17,650 --> 00:00:20,430
我覺得Node.js的是非常酷的。

8
00:00:20,430 --> 00:00:24,200
我希望，這次研討會可以使用
作為一個好，我猜，跳板

9
00:00:24,200 --> 00:00:26,380
一些最終的項目如果
你有興趣使用

10
00:00:26,380 --> 00:00:27,630
像Node.js的

11
00:00:27,630 --> 00:00:29,770

12
00:00:29,770 --> 00:00:33,320
>> 排序我們將通過啟動研討會關閉
剛才談到的一點點

13
00:00:33,320 --> 00:00:36,970
樣的背景可擴展性
Node.js的的觀點，然後

14
00:00:36,970 --> 00:00:39,240
我們將移動到一些代碼示例。

15
00:00:39,240 --> 00:00:42,340
而且我還會在網站上的代碼，
你可以看一下代碼。

16
00:00:42,340 --> 00:00:45,475
並在研討會後，我會整理的通話
有關如何設置的Node.js

17
00:00:45,475 --> 00:00:48,220
您的計算機上。

18
00:00:48,220 --> 00:00:48,710
>> 確定。

19
00:00:48,710 --> 00:00:49,760
所以，讓我們開始吧。

20
00:00:49,760 --> 00:00:53,700
所以，我想我只是想談談
Web服務器，真的，第一次。

21
00:00:53,700 --> 00:00:59,730
並開始討論，我
基本上有一個圖，它是從

22
00:00:59,730 --> 00:01:04,269
用於CS61的教科書，這
基本上顯示了交互

23
00:01:04,269 --> 00:01:08,510
一個客戶端程序，就像你的網頁之間
瀏覽器或像你的目標客戶端或

24
00:01:08,510 --> 00:01:11,340
類似的東西，和Web服務器。

25
00:01:11,340 --> 00:01:15,150
所以這種看起來類似
您在講座上看到的圖片

26
00:01:15,150 --> 00:01:19,270
週三在那裡基本上我們有一些
客戶端程序，如谷歌Chrome瀏覽器。

27
00:01:19,270 --> 00:01:22,980
>> 然後一步一個是
客戶端發送一個請求。

28
00:01:22,980 --> 00:01:27,510
這樣就可以是這樣的好，讓我們
參觀，我不知道，CS50.net。

29
00:01:27,510 --> 00:01:29,320
因此，我們發出了請求。

30
00:01:29,320 --> 00:01:34,280
並沒有任何人記得名字
的協議，規定怎麼說

31
00:01:34,280 --> 00:01:35,610
請求應該被構成的？

32
00:01:35,610 --> 00:01:36,382
沒錯。

33
00:01:36,382 --> 00:01:37,650
>> 觀眾：[聽不清]。

34
00:01:37,650 --> 00:01:38,150
>> 凱文·施密德：沒錯。

35
00:01:38,150 --> 00:01:40,100
所以它就像HTTP的，對不對？

36
00:01:40,100 --> 00:01:44,720
所以基本上在如何規範
這一要求實際上應該被解僱

37
00:01:44,720 --> 00:01:47,450
出來，因為在一天結束時，
該請求是真的只是喜歡

38
00:01:47,450 --> 00:01:50,240
字符串，它基本上
說我想要這個。

39
00:01:50,240 --> 00:01:53,580
和本說明書
因為這是HTTP。

40
00:01:53,580 --> 00:01:55,270
所以這就像一個協議。

41
00:01:55,270 --> 00:01:57,920
>> 那麼接下來的服務器接收
該請求。

42
00:01:57,920 --> 00:02:01,610
所以，你們有安裝一個Web服務器
在CS50設備。

43
00:02:01,610 --> 00:02:02,460
這是Apache的。

44
00:02:02,460 --> 00:02:06,230
而本週，當你的工作問題
設置7，你實際上是工作

45
00:02:06,230 --> 00:02:08,160
與該Web服務器。

46
00:02:08,160 --> 00:02:12,380
因此，服務器接收到請求，
那麼它有一種劃傷其

47
00:02:12,380 --> 00:02:15,090
頭，說喜歡什麼好
我該怎麼做？

48
00:02:15,090 --> 00:02:20,060
>> 那麼基於它決定這樣做，那麼
它可能有聯繫的某種

49
00:02:20,060 --> 00:02:20,730
的資源。

50
00:02:20,730 --> 00:02:23,700
以及該資源可以是一個
很多不同的事情。

51
00:02:23,700 --> 00:02:26,810
首先，它可能只是
就像一個靜態的HTML文件。

52
00:02:26,810 --> 00:02:29,820
所以它可能只是像一些
HTML是一樣的

53
00:02:29,820 --> 00:02:31,100
您的個人網站。

54
00:02:31,100 --> 00:02:35,360
它可能是一個靜態文件等的圖像
或者像電影，你有。

55
00:02:35,360 --> 00:02:37,660
它甚至可能不得不談
以某種數據庫

56
00:02:37,660 --> 00:02:39,530
就像一個MySQL數據庫。

57
00:02:39,530 --> 00:02:43,910
因此它並不總是具有通信
用的資源，但在

58
00:02:43,910 --> 00:02:45,700
某些情況下，它可以。

59
00:02:45,700 --> 00:02:47,800
>> 所以那麼它要做的事情
之後就是它要

60
00:02:47,800 --> 00:02:49,430
發送回響應。

61
00:02:49,430 --> 00:02:53,130
與此響應為
還通過HTTP指定。

62
00:02:53,130 --> 00:02:54,830
這樣的話，客戶端可以接收它。

63
00:02:54,830 --> 00:02:56,740
它可以把它拆開，並對其進行處理。

64
00:02:56,740 --> 00:03:00,900
然後你會得到一個網頁
像谷歌或CS50.net或

65
00:03:00,900 --> 00:03:02,240
不管你去。

66
00:03:02,240 --> 00:03:03,100
好不好？

67
00:03:03,100 --> 00:03:06,080
>> 因此，這是基本的互動，
我們將要處理的。

68
00:03:06,080 --> 00:03:08,770
而且我們幾乎將是
專注於這部分的

69
00:03:08,770 --> 00:03:10,640
相互作用，該服務器。

70
00:03:10,640 --> 00:03:10,990
確定。

71
00:03:10,990 --> 00:03:12,210
涼爽。

72
00:03:12,210 --> 00:03:15,500
任何人有任何疑問這麼遠嗎？

73
00:03:15,500 --> 00:03:17,720
確定。

74
00:03:17,720 --> 00:03:22,430
>> 所以，當我們說，Web服務器接收
這個HTTP請求，然後發出這

75
00:03:22,430 --> 00:03:24,760
HTTP響應。

76
00:03:24,760 --> 00:03:29,100
而像我們談到前，
CS50家電網絡服務器是Apache。

77
00:03:29,100 --> 00:03:32,490
所以，當你們的工作P上設置7，
你將要與工作

78
00:03:32,490 --> 00:03:34,120
Apache Web服務器。

79
00:03:34,120 --> 00:03:37,890
你將永遠不會有真正的工作
與Apache直接太多。

80
00:03:37,890 --> 00:03:41,920
那種你配置Apache一點點
當你指定虛擬主機或

81
00:03:41,920 --> 00:03:44,970
在V主機，我們會得到
要在一點點。

82
00:03:44,970 --> 00:03:50,620
>> 但基本上，Apache Web服務器
建立用PHP樣的工作

83
00:03:50,620 --> 00:03:51,730
的開箱即用。

84
00:03:51,730 --> 00:03:56,170
所以當你去什麼實際的情況是
您的網站公司，比如之一，

85
00:03:56,170 --> 00:04:00,360
本地主機斜線的index.php什麼​​的，
是您的瀏覽器發送一個

86
00:04:00,360 --> 00:04:04,330
請求，然後Apache是​​坐
那裡，計算出用它做。

87
00:04:04,330 --> 00:04:08,840
和行動是執行
在index.php文件中的代碼和

88
00:04:08,840 --> 00:04:11,330
然後發送回其關閉。

89
00:04:11,330 --> 00:04:15,640
因此，有一點。

90
00:04:15,640 --> 00:04:16,980
所以我們有點談過這個。

91
00:04:16,980 --> 00:04:21,990
所以它可能只是成為一個靜態文件
或者運行一些PHP代碼，然後問題

92
00:04:21,990 --> 00:04:23,510
的響應。

93
00:04:23,510 --> 00:04:27,670
>> 這樣的話，可以來一個常見的問題
起來是好，我們怎麼真正處理

94
00:04:27,670 --> 00:04:31,750
具有多用戶
在同一時間？

95
00:04:31,750 --> 00:04:36,930
所以，如果你正在寫一個web想像
服務器，如果你有一個Web服務器，

96
00:04:36,930 --> 00:04:39,900
您試圖在寫東西
像C或類似的東西，

97
00:04:39,900 --> 00:04:45,150
基本上你可以想想如何有
可能是某種形式的代碼，

98
00:04:45,150 --> 00:04:49,330
將接收請求，但隨後
它必須做所有這些工作就可以了。

99
00:04:49,330 --> 00:04:53,060
它可以具有，例如，直接從
數據庫或類似的東西。

100
00:04:53,060 --> 00:04:53,300
對不對？

101
00:04:53,300 --> 00:04:56,010
然後它會做那種
處理，然後

102
00:04:56,010 --> 00:04:57,060
發回的響應。

103
00:04:57,060 --> 00:04:58,950
這就是像高
概述。

104
00:04:58,950 --> 00:05:04,210
>> 但它不會立即明顯你如何
能做到這一點，讓兩個人或

105
00:05:04,210 --> 00:05:09,040
甚至1000人可以與你的
Web服務器在同一時間。

106
00:05:09,040 --> 00:05:14,880
讓Apache使用的解決方案
被稱為線程或進程。

107
00:05:14,880 --> 00:05:16,770
所以，你可能聽說過
這些條款之前。

108
00:05:16,770 --> 00:05:22,190
這是確定的，如果你還沒有，但只是覺得
關於線程或進程的途徑

109
00:05:22,190 --> 00:05:26,290
操作系統或用戶程序或
類似的東西或Web服務器

110
00:05:26,290 --> 00:05:28,810
排序執行多個
件事情。

111
00:05:28,810 --> 00:05:31,760
所以，你可能已經聽說過這個詞
像執行的線程。

112
00:05:31,760 --> 00:05:34,140
所以它有點像你
排序多任務。

113
00:05:34,140 --> 00:05:37,710
>> 如果你看過上的框中輸入您的
筆記本電腦，或者類似的東西，

114
00:05:37,710 --> 00:05:43,040
多核，你可以做的是，你可以
運行在不同的兩個不同的線程

115
00:05:43,040 --> 00:05:46,700
CPU的部分，以便它們可以
實際上發生在同一時間。

116
00:05:46,700 --> 00:05:48,100
所以這真的很強大。

117
00:05:48,100 --> 00:05:52,270
這是一種Apache的中
解決這個問題的。

118
00:05:52,270 --> 00:05:57,900
>> 那麼，有沒有一種像任何問題
這種方法雖然？

119
00:05:57,900 --> 00:05:59,870
所以我想那種我寫了他們那裡。

120
00:05:59,870 --> 00:06:03,440
但他們都有點
使用大量的內存。

121
00:06:03,440 --> 00:06:07,490
這是非常昂貴的創建
一個線程或進程。

122
00:06:07,490 --> 00:06:11,750
>> 和推理的部分是，僅僅
就像當你正在運行一個C程序

123
00:06:11,750 --> 00:06:15,090
喜歡你的主，那麼該呼叫
另一個函數，有

124
00:06:15,090 --> 00:06:16,520
某種堆棧。

125
00:06:16,520 --> 00:06:19,910
因此，線程也需要一個完全
獨立的堆棧，

126
00:06:19,910 --> 00:06:21,220
可能相當大。

127
00:06:21,220 --> 00:06:25,170
如果你能想像有萬噸
在您的網站的用戶，你將有

128
00:06:25,170 --> 00:06:26,280
有很多不同的線程。

129
00:06:26,280 --> 00:06:28,230
這是一個很大棧來
管理和維護。

130
00:06:28,230 --> 00:06:31,280
所以它的內存消耗大戶。

131
00:06:31,280 --> 00:06:35,650
>> 然後，也，讓我們說你只有
一個CPU，還是讓我們說你有

132
00:06:35,650 --> 00:06:38,460
比你有更多的線程
這些多核。

133
00:06:38,460 --> 00:06:38,730
對不對？

134
00:06:38,730 --> 00:06:43,280
因此，讓我們說你有10個線程
而你只有5個CPU。

135
00:06:43,280 --> 00:06:46,260
有種你必須做這件事情的地方
您當前的之間切換

136
00:06:46,260 --> 00:06:49,090
一個是因為你運行
不能運行所有10一次。

137
00:06:49,090 --> 00:06:50,980
這就是所謂的上下文切換。

138
00:06:50,980 --> 00:06:54,260
和這個詞實際上有幾個
不同的上下文，但我們只

139
00:06:54,260 --> 00:06:56,620
把它當做交換
兩個線程之間。

140
00:06:56,620 --> 00:06:59,730
這可以是相當昂貴的，因為
基本上你需要做的就是你

141
00:06:59,730 --> 00:07:03,340
要停止你正在做什麼，救
即正在運行的線程的狀態，

142
00:07:03,340 --> 00:07:05,440
然後切換到別的地方去。

143
00:07:05,440 --> 00:07:09,420
>> 那種所以沒有大家看到的
為什麼線程和動機

144
00:07:09,420 --> 00:07:12,030
過程可能會有點笨重？

145
00:07:12,030 --> 00:07:13,840
和你有問題嗎？

146
00:07:13,840 --> 00:07:14,376
確定。

147
00:07:14,376 --> 00:07:15,070
涼爽。

148
00:07:15,070 --> 00:07:18,090
任何人有任何問題嗎？

149
00:07:18,090 --> 00:07:19,620
確定。

150
00:07:19,620 --> 00:07:26,720
>> 因此，如果我們退後一步一秒鐘，
有一種像一個

151
00:07:26,720 --> 00:07:30,350
觀察，我們可以對
大量的Web應用程序。

152
00:07:30,350 --> 00:07:34,810
那真的是他們中的很多
其實不這樣做多少有用的

153
00:07:34,810 --> 00:07:37,140
一個線程裡面工作。

154
00:07:37,140 --> 00:07:41,170
因此，有沒有人在開始
p將7呢？

155
00:07:41,170 --> 00:07:45,650
所以，你想也許描述
一些零件？

156
00:07:45,650 --> 00:07:47,850
你處理過登錄
或者類似的東西？

157
00:07:47,850 --> 00:07:49,330
>> 觀眾：號

158
00:07:49,330 --> 00:07:49,780
>> KEVIN SCHMID：確定。

159
00:07:49,780 --> 00:07:50,150
沒關係。

160
00:07:50,150 --> 00:07:50,900
抱歉。

161
00:07:50,900 --> 00:07:55,790
但基本上，在P組，你
要掙很多樣的

162
00:07:55,790 --> 00:07:59,760
查詢數據庫得到一些
從該數據庫中的信息。

163
00:07:59,760 --> 00:08:03,330
和你的代碼將被執行，
什麼是Apache進程或

164
00:08:03,330 --> 00:08:06,030
Apache的線程將要幹什麼
同時它具有與該

165
00:08:06,030 --> 00:08:08,990
數據庫是那種它的將是
坐在那裡，這將是

166
00:08:08,990 --> 00:08:12,130
等待數據庫答辯。

167
00:08:12,130 --> 00:08:16,290
>> 現在，聽起來並不像一個大
處理，因為數據庫是你的

168
00:08:16,290 --> 00:08:18,240
CS50家電，對不對？

169
00:08:18,240 --> 00:08:22,930
但有一些類型的網絡
等待時間也因為現在的網絡

170
00:08:22,930 --> 00:08:26,830
服務器必須發出自己的請求
數據庫與溝通

171
00:08:26,830 --> 00:08:29,520
數據庫，然後得到
信息反饋。

172
00:08:29,520 --> 00:08:33,190
所以，現在它就像好等我，我
打算去得到的東西從

173
00:08:33,190 --> 00:08:35,770
數據庫，然後有一個
很多等待事情。

174
00:08:35,770 --> 00:08:36,870
這是否有道理？

175
00:08:36,870 --> 00:08:38,580
>> 而對於一些東西，它不是那麼糟糕。

176
00:08:38,580 --> 00:08:41,950
如果它僅僅具有例如
存取存儲器，即不喜歡

177
00:08:41,950 --> 00:08:44,100
可怕的I / O延遲。

178
00:08:44,100 --> 00:08:47,110
當我說，I / O延遲，就是我
指的是像任何一種像

179
00:08:47,110 --> 00:08:48,290
輸入輸出。

180
00:08:48,290 --> 00:08:52,950
但訪問磁盤上的文件，如
如果我想服務於靜態HTML

181
00:08:52,950 --> 00:08:57,850
文件，該文件是在我的網頁或
這樣的事情，我種得

182
00:08:57,850 --> 00:09:02,310
停止位，讀取該文件
在從磁盤，然後在

183
00:09:02,310 --> 00:09:04,400
這個過程中我在等待。

184
00:09:04,400 --> 00:09:06,700
我不是在做無用功。

185
00:09:06,700 --> 00:09:11,270
>> 這是不是一切的事實，但它
常見於像寶潔這樣一套應用程序

186
00:09:11,270 --> 00:09:13,960
七個很多的應用
你不是

187
00:09:13,960 --> 00:09:15,440
實際上做了很多的思考。

188
00:09:15,440 --> 00:09:19,090
當我說的思想，我的意思是
像計算工作。

189
00:09:19,090 --> 00:09:23,270
所以計算工作可能會是
像，比如說，你想

190
00:09:23,270 --> 00:09:26,590
編寫一個能夠計算一個Web服務器
第n個Fibonacci數。

191
00:09:26,590 --> 00:09:29,300
這聽起來並不像一個特別
有趣的Web服務器。

192
00:09:29,300 --> 00:09:34,220
就像我不希望該網站是
下一個Facebook，但這是一些

193
00:09:34,220 --> 00:09:35,610
樣的計算工作。

194
00:09:35,610 --> 00:09:39,570
>> 你能想像更換與
一些其他類型的有趣的

195
00:09:39,570 --> 00:09:43,070
計算工作。

196
00:09:43,070 --> 00:09:46,050
比方說，你寫的東西
該計算出的度

197
00:09:46,050 --> 00:09:49,170
兩個人之間的分離
或者類似的東西。

198
00:09:49,170 --> 00:09:51,860
所以，這的確涉及某種
計算的，對不對？

199
00:09:51,860 --> 00:09:56,630
即使如此，要做到這一點你仍然有
做了很多的等待也許

200
00:09:56,630 --> 00:09:59,550
你必須查詢數據庫看看
了誰是朋友誰或

201
00:09:59,550 --> 00:10:00,600
類似的東西。

202
00:10:00,600 --> 00:10:03,510
因此，有那種概念
的計算工作。

203
00:10:03,510 --> 00:10:05,260
這是否有道理？

204
00:10:05,260 --> 00:10:08,258
沒有任何人有任何問題嗎？

205
00:10:08,258 --> 00:10:11,960
>> 哦，我想我把聊天服務器有
因為聊天服務器是一種

206
00:10:11,960 --> 00:10:13,240
這另一個很好的例子。

207
00:10:13,240 --> 00:10:15,250
一個聊天服務器不具備
做太多的思考。

208
00:10:15,250 --> 00:10:18,350
它只是要等待的人
發送消息，然後當

209
00:10:18,350 --> 00:10:19,800
他們，送他們。

210
00:10:19,800 --> 00:10:21,050
好不好？

211
00:10:21,050 --> 00:10:23,410

212
00:10:23,410 --> 00:10:28,180
>> 因此，只是為了再次回顧一下，Apache和
像叉子類似的Web服務器

213
00:10:28,180 --> 00:10:31,470
大量的線程和進程的這
可以是種浪費。

214
00:10:31,470 --> 00:10:37,530
所以我想這可能出現的問題
從正在做我們需要有

215
00:10:37,530 --> 00:10:39,610
多線程和進程？

216
00:10:39,610 --> 00:10:41,890
如果我們只是有一個？

217
00:10:41,890 --> 00:10:45,710
>> 因此，讓我們種的畫畫
什麼這會是什麼樣子。

218
00:10:45,710 --> 00:10:47,810
因此，讓我們只使用一個線程。

219
00:10:47,810 --> 00:10:48,660
好不好？

220
00:10:48,660 --> 00:10:52,790
所以，想像一下這一個線程。

221
00:10:52,790 --> 00:10:56,600
>> 讓我們假設我們並沒有真正做
那麼多有用的 - 當我說

222
00:10:56,600 --> 00:10:59,450
有用的，我的意思是計算工作 - 

223
00:10:59,450 --> 00:11:01,130
在之前的多個線程。

224
00:11:01,130 --> 00:11:04,180
因此，讓我們種的鞏固
一切都在一個線程。

225
00:11:04,180 --> 00:11:07,780
那麼，如果我們有一個線程的那種
只是繞著中環和

226
00:11:07,780 --> 00:11:10,880
不斷檢查，做了一件
新的情況發生。

227
00:11:10,880 --> 00:11:15,130
因此，例如，新的東西發生了
可能意味著我得到的東西從後面

228
00:11:15,130 --> 00:11:19,310
數據庫，或有人送
我一個新的HTTP請求。

229
00:11:19,310 --> 00:11:22,290
因此，這些都是這類事件
這種情況發生，對不對？

230
00:11:22,290 --> 00:11:26,130
>> 然後我能做些什麼時，這些新
事情發生在這同一個線程

231
00:11:26,130 --> 00:11:30,120
執行的，這個單線程
執行，我可以調用一些代碼，

232
00:11:30,120 --> 00:11:32,410
將處理特定的事情。

233
00:11:32,410 --> 00:11:36,640
因此，舉例來說，如果我得到的東西回來
從數據庫，我可以運行我

234
00:11:36,640 --> 00:11:40,960
它小的計算部分的
實際上只是準備的事情

235
00:11:40,960 --> 00:11:42,620
發回給用戶。

236
00:11:42,620 --> 00:11:46,710
因此，沒有那種有意義嗎？

237
00:11:46,710 --> 00:11:49,940
>> 但什麼是真正的
這意味著什麼呢？

238
00:11:49,940 --> 00:11:50,660
對不對？

239
00:11:50,660 --> 00:11:53,730
因為我們已經寫了
大量的代碼 - 

240
00:11:53,730 --> 00:11:58,330
我只是要跳躍前進
在幻燈片中，如果這是確定。

241
00:11:58,330 --> 00:12:00,930
所以，如果你不介意，我只是
要退一步。

242
00:12:00,930 --> 00:12:03,410
所以這種事情是
稱為一個事件循環。

243
00:12:03,410 --> 00:12:04,070
好不好？

244
00:12:04,070 --> 00:12:07,240
而且它是一種基本的
背後Node.js的想法

245
00:12:07,240 --> 00:12:11,240
>> 那麼，什麼Node.js的是真正做一個網站
服務器是有一個單獨的線程

246
00:12:11,240 --> 00:12:14,850
這基本上是繞來繞去在一個循環
像一陣一種下

247
00:12:14,850 --> 00:12:18,510
Node.js的引擎蓋那不斷
檢查，我們沒有收到新的東西？

248
00:12:18,510 --> 00:12:22,720
然後它會運行處理程序
您設置。

249
00:12:22,720 --> 00:12:26,720
但是一個很好的問題要問的是，
我們如何才能做到這一點

250
00:12:26,720 --> 00:12:28,090
與現有的東西？

251
00:12:28,090 --> 00:12:32,440
>> 所以我把行C代碼在這裡，
基本上看起來像它的打開

252
00:12:32,440 --> 00:12:33,060
文件，對不對？

253
00:12:33,060 --> 00:12:36,090
我她剛出來的時候帶一張專輯。

254
00:12:36,090 --> 00:12:39,600
因此，我不得不打開她的一個新的文件。

255
00:12:39,600 --> 00:12:43,810
所以，我們的方式操作的C代碼 - 

256
00:12:43,810 --> 00:12:47,890
我猜我選擇文件的原因是
因為這是一種程度

257
00:12:47,890 --> 00:12:52,000
我們已經用C在完成I / O的工作
從某種意義上說，有輸入輸出。

258
00:12:52,000 --> 00:12:55,070
所以我們稱這個代碼
這是否f開。

259
00:12:55,070 --> 00:12:59,370
然後在我們的下一行
程序，我們現在可以與f工作。

260
00:12:59,370 --> 00:13:02,710
>> 因此，這將是東西的例子
這就像同步或

261
00:13:02,710 --> 00:13:06,850
在那第一線阻斷，因為
有我們在等待，直到我們

262
00:13:06,850 --> 00:13:08,110
得到的文件打開。

263
00:13:08,110 --> 00:13:12,260
因此，在第二行，我們知道，我們
可以與f工作，但是這意味著

264
00:13:12,260 --> 00:13:16,240
那第二行不能真正運行
直到第一行被完成。

265
00:13:16,240 --> 00:13:17,760
這是否有道理？

266
00:13:17,760 --> 00:13:20,890
>> 因此，這將是壞把
在事件處理程序。

267
00:13:20,890 --> 00:13:23,920
和用於該原因是
這種等待，對嗎？

268
00:13:23,920 --> 00:13:26,500
因此，這將恢復我們回
同樣的事情。

269
00:13:26,500 --> 00:13:29,470
現在我們甚至不會有
多線程的利益或

270
00:13:29,470 --> 00:13:32,390
進程，因為我們得到了
在Node.js的一個線程

271
00:13:32,390 --> 00:13:35,496
這是否是有意義的人呢？

272
00:13:35,496 --> 00:13:35,990
>> 觀眾：請等待。

273
00:13:35,990 --> 00:13:36,980
那麼，有什麼替代？

274
00:13:36,980 --> 00:13:37,840
>> KEVIN SCHMID：哦，所以是的。

275
00:13:37,840 --> 00:13:39,560
所以我打算去
更換。

276
00:13:39,560 --> 00:13:40,430
確定。

277
00:13:40,430 --> 00:13:42,960
那麼，如果我們有一些東西
這看起來是這樣？

278
00:13:42,960 --> 00:13:45,730
那麼，如果現在我編輯的
F打開一點點？

279
00:13:45,730 --> 00:13:48,370
所以我通過在同一個
兩個參數和以前一樣。

280
00:13:48,370 --> 00:13:52,610
我仍然愛新曲
她想出了。

281
00:13:52,610 --> 00:13:57,260
但我傳遞的第三件事，
在這個變量調用的代碼。

282
00:13:57,260 --> 00:14:02,280
>> 但是，什麼是真正的代碼
在此上下文中？

283
00:14:02,280 --> 00:14:05,360
是不是像一個普通的C變量？

284
00:14:05,360 --> 00:14:06,740
這是一個函數，對不對？

285
00:14:06,740 --> 00:14:09,450
而這可能是一個有點古怪，因為
我其實像現在傳遞

286
00:14:09,450 --> 00:14:12,320
函數到另一個函數。

287
00:14:12,320 --> 00:14:14,400
>> 所以，有兩件事情需要注意這一點。

288
00:14:14,400 --> 00:14:17,145
一，我沒有實際調用
對碼功能。

289
00:14:17,145 --> 00:14:20,650
所以，你不看代碼的
左括號，右括號。

290
00:14:20,650 --> 00:14:23,010
我只是路過的代碼。

291
00:14:23,010 --> 00:14:26,990
而在C中，這是什麼實際上會做
是給我一個指針，它指向的實際

292
00:14:26,990 --> 00:14:29,740
代碼，那麼這可能會運行它。

293
00:14:29,740 --> 00:14:33,350
但只是想想而已，你是
通過代碼運行時

294
00:14:33,350 --> 00:14:35,150
該文件被打開。

295
00:14:35,150 --> 00:14:41,430
>> 但是，這是什麼意思是，現在的
其餘的我的程序中哪些可以做

296
00:14:41,430 --> 00:14:47,050
其他的東西，可以繼續做其他的
東西，而我們，沒有真正等待，但

297
00:14:47,050 --> 00:14:50,890
只是在我們頭上的那回
當該文件的打開，運行

298
00:14:50,890 --> 00:14:52,130
在上面的代碼。

299
00:14:52,130 --> 00:14:53,390
這是否有道理？

300
00:14:53,390 --> 00:14:58,060
>> 現在Node.js的背後的想法是，
在做的東西與f的代碼

301
00:14:58,060 --> 00:15:04,590
部分應該是很短，簡單
而直接的，而不是真的

302
00:15:04,590 --> 00:15:06,160
非常密集的計算。

303
00:15:06,160 --> 00:15:09,390
它可能需要打開另一個文件，但
這也應該是相當快

304
00:15:09,390 --> 00:15:14,710
因為它應該只是說做一套f
打開，然後調用該其他代碼。

305
00:15:14,710 --> 00:15:19,100
>> 因此，只要是完全清楚，在F
打開，做了新的Katy Perry的歌

306
00:15:19,100 --> 00:15:23,060
做過MP3，那將相當
多立即返回。

307
00:15:23,060 --> 00:15:27,820
然後我們就可以繼續做
其他的東西，因為所有的，現在f

308
00:15:27,820 --> 00:15:33,410
公開徵集沒有被告知基本
底層F打開代碼打開這個文件

309
00:15:33,410 --> 00:15:36,020
而當你完成打開此
文件或當你把它找回來，

310
00:15:36,020 --> 00:15:37,480
然後運行該代碼。

311
00:15:37,480 --> 00:15:39,540
但它實際上並沒有執行該代碼。

312
00:15:39,540 --> 00:15:41,815
和你有一個問題嗎？

313
00:15:41,815 --> 00:15:46,180
>> 觀眾：你似乎暗示了幾個
，添加計算時代

314
00:15:46,180 --> 00:15:50,545
排序密集型代碼破解
[聽不清]驅動系統。

315
00:15:50,545 --> 00:15:51,795
[聽不清]？

316
00:15:51,795 --> 00:15:54,450

317
00:15:54,450 --> 00:15:55,290
>> KEVIN SCHMID：這是一個很大的問題。

318
00:15:55,290 --> 00:15:59,280
所以，我其實有多麼的例子
你可以計算整合

319
00:15:59,280 --> 00:16:01,090
在一點點密集型代碼。

320
00:16:01,090 --> 00:16:03,620
所以，當我們到達的代碼示例，
我一定會拉那一個。

321
00:16:03,620 --> 00:16:04,700
這樣可以嗎？

322
00:16:04,700 --> 00:16:05,950
謝謝。

323
00:16:05,950 --> 00:16:07,690

324
00:16:07,690 --> 00:16:08,750
>> 你叫什麼名字？

325
00:16:08,750 --> 00:16:10,620
>> 觀眾：亞倫。

326
00:16:10,620 --> 00:16:14,830
>> KEVIN SCHMID：亞倫帶來了一個非常
好點的，那就是如果我有

327
00:16:14,830 --> 00:16:18,560
在某些計算密集型代碼
與f的一部分，其餘的做的東西

328
00:16:18,560 --> 00:16:22,880
我的程序不能運行，不能聽
新的請求或任何東西，直到所有

329
00:16:22,880 --> 00:16:24,270
這些東西完成。

330
00:16:24,270 --> 00:16:27,390
所以，如果我寫代碼的節點一般
除非我們做一些像我要去

331
00:16:27,390 --> 00:16:33,060
後來建議，當我們看
代碼示例，我必須確保

332
00:16:33,060 --> 00:16:36,060
我的代碼不會佔用
此事件循環。

333
00:16:36,060 --> 00:16:38,120
這是否有道理？

334
00:16:38,120 --> 00:16:38,350
確定。

335
00:16:38,350 --> 00:16:40,040
涼爽。

336
00:16:40,040 --> 00:16:47,090
>> 所以Node.js的提供了這種框架，
驅動你可以建立這些事件

337
00:16:47,090 --> 00:16:48,210
服務器用。

338
00:16:48,210 --> 00:16:53,460
所以它有這類異步
非阻塞I / O庫，而

339
00:16:53,460 --> 00:16:56,800
我們已經得到了標準C函數庫
用，工作一樣，如果你​​只是

340
00:16:56,800 --> 00:16:59,500
使用他們，因為我們已經以同樣的方式
一直在使用他們與f打開，

341
00:16:59,500 --> 00:17:03,000
的東西，那些被封鎖，因為
你居然要等

342
00:17:03,000 --> 00:17:04,470
該文件將其打開。

343
00:17:04,470 --> 00:17:09,290
>> 但Node.js的給你，和它
基本上是關係到谷歌的V8

344
00:17:09,290 --> 00:17:14,030
JavaScript引擎，這是什麼原因
認為Chrome是在處理如此之快

345
00:17:14,030 --> 00:17:17,040
JavaScript的，因為它
有這樣的V8發動機。

346
00:17:17,040 --> 00:17:22,460
所以我知道這聽起來像一個
WWDC開發者大會的事情

347
00:17:22,460 --> 00:17:25,390
在那裡，他們只是扔了一堆的
信號東西處理器

348
00:17:25,390 --> 00:17:26,910
並說這是太酷了。

349
00:17:26,910 --> 00:17:34,200
但它很酷，他們沒有
這是因為JavaScript的 - 

350
00:17:34,200 --> 00:17:37,010
也許，如果你不熟悉
JavaScript尚未因為我們還沒有

351
00:17:37,010 --> 00:17:38,180
其上的演講 - 

352
00:17:38,180 --> 00:17:40,770
但是JavaScript是一種解釋性
語言。

353
00:17:40,770 --> 00:17:41,970
>> 這是一個重要的點了。

354
00:17:41,970 --> 00:17:45,790
所以這是我們的重要
服務器要快，對不對？

355
00:17:45,790 --> 00:17:49,970
如果我們只是運行的JavaScript
這被解釋與代碼只是

356
00:17:49,970 --> 00:17:52,130
任何舊的解釋器可能會很慢。

357
00:17:52,130 --> 00:17:55,980
從有這個所以節點的好處
超快速的V8翻譯。

358
00:17:55,980 --> 00:17:59,580
我不知道他們把它命名為
因為在額頭上的V8引擎耳光

359
00:17:59,580 --> 00:18:01,110
的事情，但確定。

360
00:18:01,110 --> 00:18:07,070
>> 所以，我準備了一些例子
在此URL。

361
00:18:07,070 --> 00:18:10,490
會後，我有點要
談談你如何能得到的節點集

362
00:18:10,490 --> 00:18:13,570
了，但現在，我只是有點想
步行通過一些代碼示例。

363
00:18:13,570 --> 00:18:17,250
所以，如果你想跟著，所有的
源代碼可以在那裡。

364
00:18:17,250 --> 00:18:18,720
好不好？

365
00:18:18,720 --> 00:18:22,280
>> 所以我會離開這個網址
向上一點點。

366
00:18:22,280 --> 00:18:24,440
然後，我只是要
切換到端子。

367
00:18:24,440 --> 00:18:29,670

368
00:18:29,670 --> 00:18:34,400
是大家用好這個網址？

369
00:18:34,400 --> 00:18:37,990
所以，我要切換
在這裡我的終端。

370
00:18:37,990 --> 00:18:42,030
>> 因此，這裡的代碼，
我有今天。

371
00:18:42,030 --> 00:18:43,960
為什麼我們不開始
simpler.js文件？

372
00:18:43,960 --> 00:18:49,110

373
00:18:49,110 --> 00:18:52,100
另一件事是，所有這一切
代碼將要被寫在

374
00:18:52,100 --> 00:18:56,660
JavaScript的，你可能會或
可能不熟悉。

375
00:18:56,660 --> 00:19:00,170
我想有兩件事情是，很多
JavaScript代碼是什麼樣的

376
00:19:00,170 --> 00:19:04,000
語法和結構是非常相似的
C，太客氣了，你可以把它撿起來作為

377
00:19:04,000 --> 00:19:05,020
你走。

378
00:19:05,020 --> 00:19:08,750
我試著寫了很多的
這在某種程度上是起始碼

379
00:19:08,750 --> 00:19:11,230
類似於C，使得它的
多一點可讀。

380
00:19:11,230 --> 00:19:15,980
但是，正如我們進步，我會
展示一些額外的

381
00:19:15,980 --> 00:19:18,980
JavaScript的功能，
是挺酷的。

382
00:19:18,980 --> 00:19:21,510
>> 但是讓我們看看這個示例程序。

383
00:19:21,510 --> 00:19:24,820
我想一切都切斷了那裡。

384
00:19:24,820 --> 00:19:28,500
我只是去解決，真正的
快，如果這是確定與否。

385
00:19:28,500 --> 00:19:31,400
我不知道這是什麼要做。

386
00:19:31,400 --> 00:19:34,660
那是好一點？

387
00:19:34,660 --> 00:19:36,510
你可以看到var和東西？

388
00:19:36,510 --> 00:19:39,320
確定。

389
00:19:39,320 --> 00:19:44,120
>> 所以，第一行是像JavaScript的
版本的變量

390
00:19:44,120 --> 00:19:44,800
聲明。

391
00:19:44,800 --> 00:19:49,870
因此，只是為了突出這是什麼會
看起來像在C因此，這就像

392
00:19:49,870 --> 00:19:52,620
我說指數等於三
或者類似的東西。

393
00:19:52,620 --> 00:19:55,740
所以我沒有指定類型。

394
00:19:55,740 --> 00:20:00,780
JavaScript的確實有類型的，但它的
非常的自然動態類型，所以

395
00:20:00,780 --> 00:20:02,580
沒有提供它的任何一種類型的。

396
00:20:02,580 --> 00:20:03,670
所以它只是變種。

397
00:20:03,670 --> 00:20:05,320
這就像變量。

398
00:20:05,320 --> 00:20:05,920
好不好？

399
00:20:05,920 --> 00:20:08,340
>> 而且我調用這個變量的HTTP。

400
00:20:08,340 --> 00:20:12,480
而在我的右手邊，我有
我希望把HTTP中的表達。

401
00:20:12,480 --> 00:20:14,960
這表示需要HTTP。

402
00:20:14,960 --> 00:20:18,500
因此，這是種類似於包含。

403
00:20:18,500 --> 00:20:22,940
這是一個有點像強大的比
包括在包含感

404
00:20:22,940 --> 00:20:26,100
將剛才複製並粘貼頭
文件中的函數原型或

405
00:20:26,100 --> 00:20:27,930
無論與類型定義。

406
00:20:27,930 --> 00:20:30,590
但要求其實已在進行
讓我們的代碼。

407
00:20:30,590 --> 00:20:33,280
>> 所以，你可以把它看作
導入一些代碼。

408
00:20:33,280 --> 00:20:37,960
因此，在某處Node.js的模塊中
系統或什麼，他們有這一切

409
00:20:37,960 --> 00:20:40,790
HTTP服務器代碼，所以我只是
取它為我自己

410
00:20:40,790 --> 00:20:43,130
個人使用此計劃。

411
00:20:43,130 --> 00:20:44,260
好不好？

412
00:20:44,260 --> 00:20:46,930
>> 於是我有這個功能
我寫。

413
00:20:46,930 --> 00:20:50,330
並請注意，我沒有指定
返回類型或的類型

414
00:20:50,330 --> 00:20:51,140
爭論了。

415
00:20:51,140 --> 00:20:54,440
所以，那種鬆散的類型
那種感覺。

416
00:20:54,440 --> 00:20:57,290
兩個參數，它需要的，
請求和響應。

417
00:20:57,290 --> 00:21:02,080
所以這是概念上有點像
事實是，我們有熟悉的畫面

418
00:21:02,080 --> 00:21:05,280
在屏幕上，因為前
我們得到這個要求，我們

419
00:21:05,280 --> 00:21:06,410
有來自用戶。

420
00:21:06,410 --> 00:21:09,170
然後我們有一個響應
我們可以寫的東西。

421
00:21:09,170 --> 00:21:15,060
>> 所以這個第一行不
res.writeHead 200，然後該

422
00:21:15,060 --> 00:21:17,070
內容類型文本平原。

423
00:21:17,070 --> 00:21:19,300
因此，讓我們這一塊分開一點點。

424
00:21:19,300 --> 00:21:22,340
所以讓我們只專注於res.write
一點點。

425
00:21:22,340 --> 00:21:28,420
這樣寫是基本上和寫頭，
只是方式來排序的寫出來

426
00:21:28,420 --> 00:21:29,960
活動的響應。

427
00:21:29,960 --> 00:21:30,770
好不好？

428
00:21:30,770 --> 00:21:36,230
所以寫頭，如果有人記得
從HTTP講座，做你們

429
00:21:36,230 --> 00:21:39,940
記得頭在
的HTTP的東西上面？

430
00:21:39,940 --> 00:21:43,580
那麼，為什麼不讓我演示
頭真正的快。

431
00:21:43,580 --> 00:21:44,640
請問這是否有幫助嗎？

432
00:21:44,640 --> 00:21:45,500
排序還是應該只是 - 

433
00:21:45,500 --> 00:21:46,070
確定。

434
00:21:46,070 --> 00:21:46,740
當然可以。

435
00:21:46,740 --> 00:21:52,340
>> 所以，當您的瀏覽器去google.com
或類似的東西，

436
00:21:52,340 --> 00:21:54,250
那裡實際上是一個多一點 - 

437
00:21:54,250 --> 00:21:55,380
這就像一個秘密 - 

438
00:21:55,380 --> 00:21:58,340
有像一個小的更多信息
這是通過管道不僅僅是

439
00:21:58,340 --> 00:22:00,180
小查和一切。

440
00:22:00,180 --> 00:22:03,550
所以，向你展示這一點，我要去
使用一個名為捲曲的程序。

441
00:22:03,550 --> 00:22:04,260
好不好？

442
00:22:04,260 --> 00:22:08,020
因此，這是東西，你可以在運行
您的Mac OSX命令行或在

443
00:22:08,020 --> 00:22:09,830
電器或什麼的。

444
00:22:09,830 --> 00:22:17,050
所以，如果我不捲曲的HTTP google.com，
我要看到HTML。

445
00:22:17,050 --> 00:22:21,230
這就是，在公平，公正的
HTML類型的，它告訴你

446
00:22:21,230 --> 00:22:24,695
重定向到www如果您的瀏覽器不
自動處理

447
00:22:24,695 --> 00:22:27,110
重定向。

448
00:22:27,110 --> 00:22:33,390
>> 所以這只是HTML，但我要去
要添加到這個蜷縮連字符I標誌。

449
00:22:33,390 --> 00:22:33,600
好不好？

450
00:22:33,600 --> 00:22:35,600
這是要告訴
我的頭。

451
00:22:35,600 --> 00:22:40,640
所以這也是自帶信息
通過當我得到這個答复。

452
00:22:40,640 --> 00:22:41,260
好不好？

453
00:22:41,260 --> 00:22:45,320
>> 所以在頂部，你看這
HTTP 301永久移動。

454
00:22:45,320 --> 00:22:49,470
這是一種重要的，因為
這指的是狀態代碼。

455
00:22:49,470 --> 00:22:53,750
因此，這裡的301狀態碼，
這基本上只是一個整數

456
00:22:53,750 --> 00:22:57,750
，告訴瀏覽器或誰是
讀這篇文章，如果你假裝

457
00:22:57,750 --> 00:23:01,460
你是一個瀏覽器，你看到這一點，
基本上現在如果你看一下

458
00:23:01,460 --> 00:23:04,960
這一點，你看到一個301，你知道我有
做基於一些特別的東西

459
00:23:04,960 --> 00:23:08,810
301，什麼特別的事發生
基於301。

460
00:23:08,810 --> 00:23:12,640
所以說，永久移動。

461
00:23:12,640 --> 00:23:17,700
>> 然後，基本上，我們也
一堆鍵值對。

462
00:23:17,700 --> 00:23:22,100
所以我們得到的位置
是www.google.com。

463
00:23:22,100 --> 00:23:25,190
然後那種所有這些其他的東西，
但基本上，位置是什麼

464
00:23:25,190 --> 00:23:29,662
說是新的位置
是在www.google.com。

465
00:23:29,662 --> 00:23:33,800
所以，現在如果你去到google.com，你會
排序看到瀏覽器那種閃爍的

466
00:23:33,800 --> 00:23:38,770
一秒鐘，然後重定向
右後衛上www.google.com。

467
00:23:38,770 --> 00:23:41,840
這樣的反應可以包含
這些頭文件。

468
00:23:41,840 --> 00:23:43,330
>> 和幾件事情要指出。

469
00:23:43,330 --> 00:23:46,890
所以我們說，我們實際上是成功的
在訪問一個網頁。

470
00:23:46,890 --> 00:23:49,040
所以讓我去 - 

471
00:23:49,040 --> 00:23:51,080
什麼是一個好的網站？

472
00:23:51,080 --> 00:23:53,285
我是壞的好思路
當場網站。

473
00:23:53,285 --> 00:23:53,640
>> 觀眾：維基百科。

474
00:23:53,640 --> 00:23:54,160
>> KEVIN SCHMID：確定。

475
00:23:54,160 --> 00:23:56,040
讓我們做維基百科。

476
00:23:56,040 --> 00:23:58,680
所以在這裡我很感動。

477
00:23:58,680 --> 00:23:59,240
哦，等等。

478
00:23:59,240 --> 00:24:00,160
是我？

479
00:24:00,160 --> 00:24:00,890
是的，我是。

480
00:24:00,890 --> 00:24:01,100
確定。

481
00:24:01,100 --> 00:24:03,005
所以，我必須做的www。

482
00:24:03,005 --> 00:24:06,006
所以我要做的www。

483
00:24:06,006 --> 00:24:09,680
正如你可以看到，這裡的所有的HTML
該瀏覽器將處理

484
00:24:09,680 --> 00:24:10,910
維基百科。

485
00:24:10,910 --> 00:24:14,055
>> 但是，如果我繼續在這裡滾動起來，
我會看到在頂部 - 

486
00:24:14,055 --> 00:24:17,800
哇，有很多的
HTML在維基百科 - 

487
00:24:17,800 --> 00:24:22,550
但我可以在上面看到這裡
這200狀態碼，相對於

488
00:24:22,550 --> 00:24:24,570
301，我在前面看到的。

489
00:24:24,570 --> 00:24:27,100
並注意到它有一個很好的
友好確定它旁邊。

490
00:24:27,100 --> 00:24:29,470
因此，這是像好狀態代碼。

491
00:24:29,470 --> 00:24:31,160
>> 這是否200號眼熟？

492
00:24:31,160 --> 00:24:34,120

493
00:24:34,120 --> 00:24:39,880
是的，因為當我做simpler.js，
我寫了一個200那裡。

494
00:24:39,880 --> 00:24:43,290
所以這基本上是說告訴
瀏覽器或任何人試圖去

495
00:24:43,290 --> 00:24:45,440
這一點，他們是成功的。

496
00:24:45,440 --> 00:24:49,040
或者說，有點像我們的
是成功了。

497
00:24:49,040 --> 00:24:54,320
>> 還有的這種特殊的語法
在Javascript中用於聲明一個

498
00:24:54,320 --> 00:24:59,870
映射這些鍵，如內容類型
而像純文本這些值。

499
00:24:59,870 --> 00:25:03,780
所以，如果你看一下反應，我們
得到了來自維基百科回來之前， - 

500
00:25:03,780 --> 00:25:06,200
我要去嘗試滾動
起來快一點 - 

501
00:25:06,200 --> 00:25:09,900
你有這些按鍵像服務器
並且這些值的Apache。

502
00:25:09,900 --> 00:25:12,120
所以，你有鍵和值。

503
00:25:12,120 --> 00:25:15,930
而且你可以指定此
節點是什麼送回去。

504
00:25:15,930 --> 00:25:19,380
>> 因此，這是一種實際上，在某些
方式，並在某些方面它不是

505
00:25:19,380 --> 00:25:23,170
真的，但它是一個低一點的水平
比你可能會對PHP代碼

506
00:25:23,170 --> 00:25:26,980
寫作對於P設置7，因為PHP和
排序阿帕奇採取一些護理

507
00:25:26,980 --> 00:25:28,150
這些東西給你。

508
00:25:28,150 --> 00:25:32,520
在PHP中，你可以覆蓋默認
行為通過編寫自己的頭。

509
00:25:32,520 --> 00:25:35,520
但對於這個目的，我們得到
寫出自己的頭。

510
00:25:35,520 --> 00:25:38,210

511
00:25:38,210 --> 00:25:41,105
>> 那麼，這行是有意義的
大家好，寫磁頭線？

512
00:25:41,105 --> 00:25:41,380
確定。

513
00:25:41,380 --> 00:25:42,280
真棒。

514
00:25:42,280 --> 00:25:45,870
>> 所以後來我做的是我最終的響應
說你好的世界。

515
00:25:45,870 --> 00:25:47,040
確定。

516
00:25:47,040 --> 00:25:49,920
但是這只是一個函數
被稱為請求處理程序。

517
00:25:49,920 --> 00:25:53,510
所以，現在我居然有一種做
一些與這一功能，對不對？

518
00:25:53,510 --> 00:25:59,170
>> 所以在這裡我要做的就是有這個
這確實變種服務器等號線

519
00:25:59,170 --> 00:26:03,530
HTTP.create服務器，然後我
通過在請求處理程序。

520
00:26:03,530 --> 00:26:06,080
因此，這是一種對節點
創建服務器的方式。

521
00:26:06,080 --> 00:26:08,790
並注意到我傳遞
在請求處理程序。

522
00:26:08,790 --> 00:26:12,290
因此，這是告訴createServer
函數，我要你為我做

523
00:26:12,290 --> 00:26:16,270
服務器，並且當該服務器接收
一個回應，我需要你調用這個

524
00:26:16,270 --> 00:26:18,680
請求處理函數。

525
00:26:18,680 --> 00:26:18,990
好不好？

526
00:26:18,990 --> 00:26:22,290
>> 因此，該行幾乎
結束的時候了。

527
00:26:22,290 --> 00:26:28,780
因此，無功服務器產品線是做正確的
你這樣做之後漂亮多了。

528
00:26:28,780 --> 00:26:31,770
我的意思是，它必須設置一些內部
狀態要知道，你將不得不

529
00:26:31,770 --> 00:26:35,400
調用請求處理功能，但
它不會坐在那裡，

530
00:26:35,400 --> 00:26:37,730
比如說有發送用戶
我還請求？

531
00:26:37,730 --> 00:26:39,270
有用戶發過來的請求了嗎？

532
00:26:39,270 --> 00:26:40,780
所以它不會阻止。

533
00:26:40,780 --> 00:26:41,650
好不好？

534
00:26:41,650 --> 00:26:46,120
>> 那麼，這帶給我們的是它基本上
現在存儲一個指向這段代碼，

535
00:26:46,120 --> 00:26:49,670
申請的處理函數，然後
將運行該代碼，當有人

536
00:26:49,670 --> 00:26:52,170
發出請求。

537
00:26:52,170 --> 00:26:54,120
然後我們做server.listen。

538
00:26:54,120 --> 00:26:56,950

539
00:26:56,950 --> 00:26:59,960
>> 1337有相當隨意的。

540
00:26:59,960 --> 00:27:02,285
我沒有特別的原因
用於拾取該號碼。

541
00:27:02,285 --> 00:27:03,860
這是完全隨機的。

542
00:27:03,860 --> 00:27:07,010
但是，這只是指定端口。

543
00:27:07,010 --> 00:27:10,640
所以大多數Web服務器，你會看到他們
使用80端口，因為這是一種

544
00:27:10,640 --> 00:27:11,810
像的慣例。

545
00:27:11,810 --> 00:27:16,170
所以，如果我去喜歡的東西，
我不知道，Wikipedia.org，

546
00:27:16,170 --> 00:27:17,700
我把結腸8  - 

547
00:27:17,700 --> 00:27:18,610
哇哦，你看不到這一點。

548
00:27:18,610 --> 00:27:19,370
對不起。

549
00:27:19,370 --> 00:27:21,820
但如果我這樣做維基百科 - 

550
00:27:21,820 --> 00:27:24,810
我會在這裡寫出來只是讓
很明顯在相機上。

551
00:27:24,810 --> 00:27:29,150
但是，如果我拿這與一個瀏覽器
一個冒號80，指定去

552
00:27:29,150 --> 00:27:31,430
Wikipedia.org在端口80。

553
00:27:31,430 --> 00:27:36,200
所以它就像美國如何有
喜歡在那裡你可以出貨多個端口

554
00:27:36,200 --> 00:27:37,440
事情來樣。

555
00:27:37,440 --> 00:27:40,730
所以它就像去這個特殊的
放在該服務器上。

556
00:27:40,730 --> 00:27:40,990
確定。

557
00:27:40,990 --> 00:27:45,730
>> 所以，我只是選擇了1337。

558
00:27:45,730 --> 00:27:47,910
有數字的整個範圍
你可以挑選。

559
00:27:47,910 --> 00:27:50,390
這不是完全特殊。

560
00:27:50,390 --> 00:27:54,560
>> 但我現在打算怎麼辦
是我要運行節點。

561
00:27:54,560 --> 00:27:59,730
讓我真正進入，一對夫婦
台詞背下來了，這樣你可以看到它。

562
00:27:59,730 --> 00:28:03,130
我要做節點，和我
要運行simpler.js。

563
00:28:03,130 --> 00:28:06,880
我們將討論如何獲得
節點設置在一點點。

564
00:28:06,880 --> 00:28:09,350
但現在它只是運行的服務器。

565
00:28:09,350 --> 00:28:14,360
>> 因此，有一點我們可以嘗試這可能不
是，令人興奮的是，我們實際上可以

566
00:28:14,360 --> 00:28:16,300
嘗試訪問它的捲曲。

567
00:28:16,300 --> 00:28:20,680
所以我可以做捲髮，和我
機器是本地主機。

568
00:28:20,680 --> 00:28:24,600
您還可以看到這樣寫
這樣有時。

569
00:28:24,600 --> 00:28:29,810
本地主機和127.0.0.1是善良
像您的家用電腦。

570
00:28:29,810 --> 00:28:33,180
所以它就像說話
您自己的電腦。

571
00:28:33,180 --> 00:28:33,760
確定。

572
00:28:33,760 --> 00:28:36,030
>> 然後我可以說1337。

573
00:28:36,030 --> 00:28:39,630
所以，如果我運行這行代碼，
它說的hello world。

574
00:28:39,630 --> 00:28:44,050
如果我想看到的東西，
有內容類型的文本或純

575
00:28:44,050 --> 00:28:46,560
什麼，我什至可以把這個在這裡。

576
00:28:46,560 --> 00:28:48,810
並注意到它說OK。

577
00:28:48,810 --> 00:28:50,810
和我有文字平原。

578
00:28:50,810 --> 00:28:53,140
再有就是那種所有這些其他
的東西，節點將加入

579
00:28:53,140 --> 00:28:54,440
還有我。

580
00:28:54,440 --> 00:28:55,700
這不是超級重要。

581
00:28:55,700 --> 00:28:58,230
>> 我的意思是，有某種技術
在客氣的方面

582
00:28:58,230 --> 00:29:02,280
爽談，但只是為了顯示
你，我也有權力

583
00:29:02,280 --> 00:29:03,070
圍繞改變這些。

584
00:29:03,070 --> 00:29:06,280
所以，我可以再補充了一堆
之類的東西。

585
00:29:06,280 --> 00:29:11,780
然後現在，如果我看在我
輸出，它將是。

586
00:29:11,780 --> 00:29:19,740
所以，這些頭的意思是某些事情
以瀏覽器之類的東西。

587
00:29:19,740 --> 00:29:23,040
>> 和頭基本上可以告訴瀏覽器
如何應對一些東西。

588
00:29:23,040 --> 00:29:26,280
如果你曾經聽說過的餅乾之前，
或者如果你曾經去過惱火

589
00:29:26,280 --> 00:29:29,330
通過網頁設置cookie，
或開啟cookie的塊或

590
00:29:29,330 --> 00:29:30,320
類似的東西。

591
00:29:30,320 --> 00:29:33,040
實際上，你可以設置Cookie
在這些頭。

592
00:29:33,040 --> 00:29:36,990
所以他們告訴瀏覽器如何
行為的情況。

593
00:29:36,990 --> 00:29:37,750
確定。

594
00:29:37,750 --> 00:29:40,310
>> 所以這是simpler.js。

595
00:29:40,310 --> 00:29:42,780
沒有任何人有任何疑問，
該源代碼文件？

596
00:29:42,780 --> 00:29:45,420

597
00:29:45,420 --> 00:29:45,610
確定。

598
00:29:45,610 --> 00:29:46,490
涼爽。

599
00:29:46,490 --> 00:29:50,780
>> 因此，讓我們從除去R
看看simple.js。

600
00:29:50,780 --> 00:29:53,010
所以這是相當多
相同的程序。

601
00:29:53,010 --> 00:29:56,030
我剛寫的有點不同
因為我想排序亮點

602
00:29:56,030 --> 00:29:57,850
JavaScript的某些功能。

603
00:29:57,850 --> 00:30:03,880
>> 所以請注意，請求處理程序
功能已經完全消失了。

604
00:30:03,880 --> 00:30:05,800
哦，是的，你有問題嗎？

605
00:30:05,800 --> 00:30:08,200
>> 觀眾：是的，論據
傳遞給該

606
00:30:08,200 --> 00:30:10,120
函數，它們是什麼？

607
00:30:10,120 --> 00:30:12,050
>> KEVIN SCHMID：因此，這些都是
JavaScript對象。

608
00:30:12,050 --> 00:30:15,230
在Node.js的文檔，它
基本上說用什麼方法都

609
00:30:15,230 --> 00:30:15,910
適用於他們。

610
00:30:15,910 --> 00:30:19,602
我們只是碰巧有訪問
這種方法被稱為寫開頭和結尾

611
00:30:19,602 --> 00:30:20,730
和類似的東西。

612
00:30:20,730 --> 00:30:22,590
但有一大堆
更多的方法。

613
00:30:22,590 --> 00:30:27,670
>> 並舉例說，像他們中的一個
特別是在拍攝，你可以做

614
00:30:27,670 --> 00:30:34,540
像rec.method這將
告訴你，無論它是一個HTTP GET或

615
00:30:34,540 --> 00:30:36,780
HTTP POST請求和
這樣的事情。

616
00:30:36,780 --> 00:30:39,100
因此，有各種不同的
屬性，但他們都

617
00:30:39,100 --> 00:30:42,560
JavaScript對象，而他們只是有
重視他們的功能，你

618
00:30:42,560 --> 00:30:43,850
可以寫的東西。

619
00:30:43,850 --> 00:30:45,520
好不好？

620
00:30:45,520 --> 00:30:49,030
>> 所以請注意，請求處理程序
是完全消失了。

621
00:30:49,030 --> 00:30:52,650
但是，我不得不在請求的代碼
處理程序仍然存在。

622
00:30:52,650 --> 00:30:56,520
我仍然有這個res.writeHead
我仍然有這個res.end。

623
00:30:56,520 --> 00:31:00,270
和這個是什麼的一個例子
JavaScript是這個想法的

624
00:31:00,270 --> 00:31:01,460
匿名函數。

625
00:31:01,460 --> 00:31:04,180
和匿名就像是一個合適的名字
它，因為它字面上不

626
00:31:04,180 --> 00:31:05,180
有一個名字。

627
00:31:05,180 --> 00:31:07,900
有沒有功能要求
處理程序在裡面。

628
00:31:07,900 --> 00:31:10,110
>> 沒有名字，但它仍然
是採取一種說法。

629
00:31:10,110 --> 00:31:12,250
所以我還是得到了REC和水庫。

630
00:31:12,250 --> 00:31:16,180
而且我仍然有代碼。

631
00:31:16,180 --> 00:31:18,930
這是完全正常
JavaScript代碼。

632
00:31:18,930 --> 00:31:22,540
因此，我可以聲明一個函數不
明確地給它起名字。

633
00:31:22,540 --> 00:31:24,250
這是起初有點混亂。

634
00:31:24,250 --> 00:31:26,230
還有一些像有用的東西
你可以用做

635
00:31:26,230 --> 00:31:28,450
這些匿名函數。

636
00:31:28,450 --> 00:31:32,100
沒有任何人對此有任何疑問，
或者是它確定只是，現在，

637
00:31:32,100 --> 00:31:34,130
只是有點接受它
會做同樣的事情？

638
00:31:34,130 --> 00:31:36,700

639
00:31:36,700 --> 00:31:37,125
沒錯？

640
00:31:37,125 --> 00:31:38,680
>> 觀眾：首先功能
在JavaScript類？

641
00:31:38,680 --> 00:31:41,020
>> KEVIN SCHMID：他們是第一
類中的JavaScript。

642
00:31:41,020 --> 00:31:45,490
而只知道這些概念
傳遞像一個匿名函數

643
00:31:45,490 --> 00:31:49,600
這適用於JavaScript的你
可以寫在您的最終項目

644
00:31:49,600 --> 00:31:51,260
Web瀏覽器也。

645
00:31:51,260 --> 00:31:56,700
因此，例如，在JavaScript中
您的瀏覽器，它也有些事件

646
00:31:56,700 --> 00:32:00,680
在這個意義上推動了什麼，你會
已經是當用戶點擊這個

647
00:32:00,680 --> 00:32:02,640
按鈕，我希望你能運行此代碼。

648
00:32:02,640 --> 00:32:07,070
>> 所以它的同類的想法
客戶端當用鼠標點擊或者

649
00:32:07,070 --> 00:32:09,870
鼠標在一些圖像上的
網頁，運行此代碼。

650
00:32:09,870 --> 00:32:11,350
這可以應用到服務器。

651
00:32:11,350 --> 00:32:16,380
所以這是一種像令人興奮
之所以JavaScript是一個非常

652
00:32:16,380 --> 00:32:19,810
適合或有些人認為這是一個
合適的語言為這種

653
00:32:19,810 --> 00:32:22,530
事件驅動的服務器，因為你有
這些匿名函數。

654
00:32:22,530 --> 00:32:26,150
你的整體思路
這個異步代碼。

655
00:32:26,150 --> 00:32:27,060
確定。

656
00:32:27,060 --> 00:32:30,360
任何人有任何問題嗎？

657
00:32:30,360 --> 00:32:30,470
>> 確定。

658
00:32:30,470 --> 00:32:33,440
所以這是simple.js。

659
00:32:33,440 --> 00:32:38,070
因此，讓我們再看一個
或一對夫婦更多。

660
00:32:38,070 --> 00:32:42,040
因此，這是sleep.js。

661
00:32:42,040 --> 00:32:47,160
所以，是任何人都熟悉
C函數的睡眠？

662
00:32:47,160 --> 00:32:50,936
從早期的講座可能是一
或者類似的東西？

663
00:32:50,936 --> 00:32:54,650
>> 所以基本上你可以通過在我認為
秒數，或者如果你使用U形

664
00:32:54,650 --> 00:32:57,080
睡了一毫秒數
或納秒。

665
00:32:57,080 --> 00:33:00,450
和基本程序將停止
運行的時間量。

666
00:33:00,450 --> 00:33:01,280
對不對？

667
00:33:01,280 --> 00:33:06,970
然後它最終會醒來，
然後它會只是繼續運行

668
00:33:06,970 --> 00:33:08,340
該方案。

669
00:33:08,340 --> 00:33:12,740
>> 排序所以這台服務器提供
睡覺的印象。

670
00:33:12,740 --> 00:33:17,580
所以請注意，我們有相同的
res.writeHead 200與作為頭

671
00:33:17,580 --> 00:33:22,130
之前，但隨後我們調用這個
函數調用設置超時。

672
00:33:22,130 --> 00:33:26,170
設置超時也可用於
您的Web瀏覽器谷歌瀏覽器

673
00:33:26,170 --> 00:33:28,000
或Safari或什麼的。

674
00:33:28,000 --> 00:33:31,720
基本上它在做什麼在這裡
是它採取的一個函數。

675
00:33:31,720 --> 00:33:33,360
通知，再次，它是一個
匿名函數。

676
00:33:33,360 --> 00:33:36,310
所以這是一種很酷的，因為我們是
使用中的匿名函數

677
00:33:36,310 --> 00:33:38,950
匿名函數
可以是一個有點怪異。

678
00:33:38,950 --> 00:33:42,270
>> 但它採取這一功能，這是
基本上說 - 而這方式

679
00:33:42,270 --> 00:33:47,430
作品是在5,000毫秒，我想
您可以執行功能，

680
00:33:47,430 --> 00:33:50,830
剛剛結束的響應，並寫入哎。

681
00:33:50,830 --> 00:33:56,730
所以，這給像印象
睡覺，但這種方式實際上

682
00:33:56,730 --> 00:33:59,780
工作原理是，我們將通過運行
這條線非常快。

683
00:33:59,780 --> 00:34:01,190
我們只是寫東西。

684
00:34:01,190 --> 00:34:03,780
然後，我們還可以通過運行
這條線非常快。

685
00:34:03,780 --> 00:34:08,620
因此，我們沒有真正去
等待五秒鐘。

686
00:34:08,620 --> 00:34:11,370
我們只是要運行
這段代碼瞬間。

687
00:34:11,370 --> 00:34:14,219
>> 再有就是，同樣，這一點
事件循環，現在有這個東西

688
00:34:14,219 --> 00:34:17,570
寄存器，基本上只是
不斷繞來繞去轉了一圈

689
00:34:17,570 --> 00:34:21,620
並期待在一個單一的時鐘
螺紋和說法，有5秒

690
00:34:21,620 --> 00:34:22,360
通過了嗎？

691
00:34:22,360 --> 00:34:26,409
然後它看到時，所述第二
手已經搬到像五秒鐘

692
00:34:26,409 --> 00:34:29,190
什麼，那麼它喚醒並說，
哦，我有什麼做的？

693
00:34:29,190 --> 00:34:30,350
哦，我要運行此代碼。

694
00:34:30,350 --> 00:34:33,110
然後它會
運行res.end哎。

695
00:34:33,110 --> 00:34:35,360
>> 所以，再一次，我們永遠在這裡等待。

696
00:34:35,360 --> 00:34:38,590
所以它不是說的這裡面的代碼
此功能是要取五

697
00:34:38,590 --> 00:34:39,900
跑秒。

698
00:34:39,900 --> 00:34:43,090
此代碼將運行幾乎
瞬間，至少相對於

699
00:34:43,090 --> 00:34:46,139
5秒鐘，我們在談論
關於早期之前。

700
00:34:46,139 --> 00:34:52,100
>> 所以，只是為了顯示這個動作，
我可以做Node.sleep.js。

701
00:34:52,100 --> 00:34:55,159
和我做了亂七八糟的東西？

702
00:34:55,159 --> 00:34:56,310
也許吧。

703
00:34:56,310 --> 00:34:57,410
抱歉。

704
00:34:57,410 --> 00:34:59,530
讓我們看看我們能做些什麼來解決這個問題。

705
00:34:59,530 --> 00:35:10,830

706
00:35:10,830 --> 00:35:12,080
確定。

707
00:35:12,080 --> 00:35:15,460

708
00:35:15,460 --> 00:35:17,464
所以，一定要使用Node.js的

709
00:35:17,464 --> 00:35:19,440
我只是在開玩笑。

710
00:35:19,440 --> 00:35:19,570
確定。

711
00:35:19,570 --> 00:35:20,820
只要一秒鐘。

712
00:35:20,820 --> 00:35:27,380

713
00:35:27,380 --> 00:35:27,900
確定。

714
00:35:27,900 --> 00:35:29,130
我知道它是什麼。

715
00:35:29,130 --> 00:35:34,440
>> 所以，問題是，在我的其他選項卡
在這裡，我已經上運行的節點

716
00:35:34,440 --> 00:35:36,590
該相同的地址，1337。

717
00:35:36,590 --> 00:35:43,370
所以錯誤，這扔，如果我們看一下
它真正的緊密結合，是在地址

718
00:35:43,370 --> 00:35:45,180
使用，EADDRINUSE。

719
00:35:45,180 --> 00:35:47,970
所以，我已經使用1337這裡。

720
00:35:47,970 --> 00:35:52,210
所以，如果我關這一關，然後我現在
試圖運行此，希望一切

721
00:35:52,210 --> 00:35:53,210
將被罰款。

722
00:35:53,210 --> 00:35:53,440
確定。

723
00:35:53,440 --> 00:35:57,020
所以，你只能有一件事排序
的端口上監聽一次。

724
00:35:57,020 --> 00:35:59,660
另一種解決方案已經為我
只是編輯程序，並

725
00:35:59,660 --> 00:36:02,370
它是像1338或東西
這樣的。

726
00:36:02,370 --> 00:36:04,100
>> 但現在睡眠運行。

727
00:36:04,100 --> 00:36:06,400
因此，讓我們真正嘗試出來的
瀏覽器這個時間，因為它是一個

728
00:36:06,400 --> 00:36:09,080
小平平無奇，看看
它在一個終端。

729
00:36:09,080 --> 00:36:13,560
所以我只是去那
127地址又在1337。

730
00:36:13,560 --> 00:36:14,850
如果你能看到它 - 

731
00:36:14,850 --> 00:36:18,050
我不知道你能不能 - 但我
瀏覽器採取了很長很長

732
00:36:18,050 --> 00:36:20,600
時間來加載或類似的五秒鐘。

733
00:36:20,600 --> 00:36:23,460
>> 然後在這之後，它終於
結束了回應。

734
00:36:23,460 --> 00:36:29,070
而你看不到它，因為事情
移過一點，​​但如果我做

735
00:36:29,070 --> 00:36:32,500
這個有點小，你
可以看到它說，哎。

736
00:36:32,500 --> 00:36:35,130
所以我得到了哎，但
後五秒鐘。

737
00:36:35,130 --> 00:36:38,510
它可能是一個小吸塵器看
在這裡在終端上，所以我

738
00:36:38,510 --> 00:36:40,980
要做一個 - 

739
00:36:40,980 --> 00:36:43,540
讓我們做在這裡 - 

740
00:36:43,540 --> 00:36:48,370
讓我們做捲曲的地址
再次與1337。

741
00:36:48,370 --> 00:36:50,820
我只是那種有坐
這裡五秒鐘。

742
00:36:50,820 --> 00:36:53,760
但是請注意，該服務器
可以接受新的回應。

743
00:36:53,760 --> 00:36:54,940
所以它打印哎。

744
00:36:54,940 --> 00:36:58,720
>> 並演示這一點，基本上是什麼
我可以做這個的其他標籤 - 

745
00:36:58,720 --> 00:37:02,640
所以讓我們說我這樣做是在另一個選項卡，
我打算做捲曲和相同

746
00:37:02,640 --> 00:37:03,780
事情再次。

747
00:37:03,780 --> 00:37:06,600
我要去嘗試踢這些
關閉傢伙在同一時間。

748
00:37:06,600 --> 00:37:08,260
所以，我要做到這一點，而且我
去比賽在這裡，我

749
00:37:08,260 --> 00:37:09,650
要再做一次。

750
00:37:09,650 --> 00:37:14,030
>> 讓我們做它，以便您
可以看到他們兩個。

751
00:37:14,030 --> 00:37:20,250
這一個印刷哎並且一個
印哎一路在 - 

752
00:37:20,250 --> 00:37:22,550
讓我們做實驗了。

753
00:37:22,550 --> 00:37:25,100
其實，讓我們用這個
欺騙，如果這是確定。

754
00:37:25,100 --> 00:37:30,520
>> 所以我打算使用shell的事情，
讓我基本上跑兩個副本

755
00:37:30,520 --> 00:37:32,630
這個程序並行的。

756
00:37:32,630 --> 00:37:36,070
所以它會運行的第一個程序，並
並聯的第二程序。

757
00:37:36,070 --> 00:37:39,060
所以，現在如果我按下Enter鍵，它會
作出這樣的要求幾乎

758
00:37:39,060 --> 00:37:40,570
瞬時地在同一時間。

759
00:37:40,570 --> 00:37:42,620
因此，讓我們給這個一桿。

760
00:37:42,620 --> 00:37:44,950
>> 所以，現在發現它說兩個過程。

761
00:37:44,950 --> 00:37:50,630
如果你很好奇，那27,000
數基本上是進程ID。

762
00:37:50,630 --> 00:37:52,940
然後請注意，他們印製
哎在同一時間。

763
00:37:52,940 --> 00:37:56,820
這不像我們不得不等待五
為1，然後經過該秒，

764
00:37:56,820 --> 00:37:59,640
五秒鐘後獲得的第二個。

765
00:37:59,640 --> 00:38:03,300
所以這樣的，在某些方面，它的
沒有真正的證據，但它的

766
00:38:03,300 --> 00:38:07,390
直觀的證據表明，它不只是
喜歡等待五秒鐘，阻斷

767
00:38:07,390 --> 00:38:08,960
整個主題。

768
00:38:08,960 --> 00:38:10,720
好涼。

769
00:38:10,720 --> 00:38:17,850
>> 因此，阿龍問了一個問題早些時候，
是，還有什麼，如果我們不做些什麼 - 

770
00:38:17,850 --> 00:38:18,735
沒錯？

771
00:38:18,735 --> 00:38:19,051
>> 觀眾：請等待。

772
00:38:19,051 --> 00:38:21,585
如何是，從不同的
printf的緩衝，但？

773
00:38:21,585 --> 00:38:23,010
沒有它會自動做呢？

774
00:38:23,010 --> 00:38:25,390
我們為什麼要擔心呢？

775
00:38:25,390 --> 00:38:26,555
>> KEVIN SCHMID：哦，你可以
說一次嗎？

776
00:38:26,555 --> 00:38:29,510
>> 觀眾：不喜歡printf的緩衝
做同樣的事情？

777
00:38:29,510 --> 00:38:31,280
>> KEVIN SCHMID：在printf的緩衝？

778
00:38:31,280 --> 00:38:32,753
>> 觀眾：是啊。

779
00:38:32,753 --> 00:38:33,244
確定。

780
00:38:33,244 --> 00:38:40,609
在他們的測驗之一是不
談到如何，如果你正確的printf

781
00:38:40,609 --> 00:38:42,899
的東西，然後有它停頓1
第二個，然後你把它圈10

782
00:38:42,899 --> 00:38:46,530
有時，它會等待十秒鐘，
然後printf的一切融合在一起？

783
00:38:46,530 --> 00:38:47,460
>> KEVIN SCHMID：哦，好吧。

784
00:38:47,460 --> 00:38:49,170
>> 觀眾：難道做同樣的
事情那麼在這種情況下？

785
00:38:49,170 --> 00:38:52,630
>> KEVIN SCHMID：所以現在的問題是
基本上在前測驗之一

786
00:38:52,630 --> 00:38:57,200
什麼的，有一個問題，
基本上，如果你說的打印F 10

787
00:38:57,200 --> 00:39:01,490
在一個時間的事情，然後睡在像
這些打印出來的過程中，

788
00:39:01,490 --> 00:39:04,850
在端由於某種原因，它會
只轉儲所有那些在屏幕上。

789
00:39:04,850 --> 00:39:06,740
因此，有一種兩個不同的
概念在這裡。

790
00:39:06,740 --> 00:39:10,400
>> 所以我想有一件事是，在這
情況下，我們正在處理兩個不同的

791
00:39:10,400 --> 00:39:13,510
樣的人要求服務器
事情的同時。

792
00:39:13,510 --> 00:39:17,455
而且該printf的那種原因
等待這樣的，它轉儲全力以赴

793
00:39:17,455 --> 00:39:21,760
一次更多的是
printf的怎麼樣 - 

794
00:39:21,760 --> 00:39:25,100
所以printf的方式實際上是
實行的是它基本上有

795
00:39:25,100 --> 00:39:28,850
聊到操作系統來寫
這些東西到控制台。

796
00:39:28,850 --> 00:39:33,460
因此，它並不想這樣做了這一切
當你說printf的東西立刻

797
00:39:33,460 --> 00:39:36,260
一些字符串，因為它可以
得到昂貴的，如果它有

798
00:39:36,260 --> 00:39:37,340
做每一次。

799
00:39:37,340 --> 00:39:41,530
>> 所以，如果你做的printf哎，你的程序
實際可能不打印

800
00:39:41,530 --> 00:39:43,040
馬上到控制台。

801
00:39:43,040 --> 00:39:46,080
它可能會說，好吧，我寫的。

802
00:39:46,080 --> 00:39:49,570
然後那種等待你給
之前確實有點多

803
00:39:49,570 --> 00:39:51,380
寫它輸出到控制台。

804
00:39:51,380 --> 00:39:54,040
>> 所以這是這種情況的原因 - 

805
00:39:54,040 --> 00:39:56,450
它是種無關
到睡眠 - 

806
00:39:56,450 --> 00:40:00,060
是，睡眠是那種剛
注射在那裡展示

807
00:40:00,060 --> 00:40:02,480
事實上，它並沒有寫
它同步。

808
00:40:02,480 --> 00:40:06,210
但對於其原因僅僅是
性能，讓您不必

809
00:40:06,210 --> 00:40:08,920
讓很多接觸，
該操作系統。

810
00:40:08,920 --> 00:40:12,300
>> 但在這裡，我們真正要做的
這種睡眠事情就是秀

811
00:40:12,300 --> 00:40:17,730
當我們有兩個人訪問
這個網站，它不會把

812
00:40:17,730 --> 00:40:22,310
他們在一個行，其中它會說
我一定要幫你，然後當我

813
00:40:22,310 --> 00:40:25,350
完全完成，幫助你以後這些
五秒鐘，然後我要去

814
00:40:25,350 --> 00:40:26,750
移動到下一個人。

815
00:40:26,750 --> 00:40:29,515
所以第一人的要求不
佔用的事件循環

816
00:40:29,515 --> 00:40:31,610
如果是有道理的。

817
00:40:31,610 --> 00:40:34,980
>> 但這裡實際上是一個例子
的東西，將配合

818
00:40:34,980 --> 00:40:36,090
了事件循環。

819
00:40:36,090 --> 00:40:39,130
所以這裡有一個可怕的功能
計算第n個斐波那契數。

820
00:40:39,130 --> 00:40:43,510
這是字面上的糟糕方式，您可以
計算第n個Fibonacci數。

821
00:40:43,510 --> 00:40:48,480
這其實只是承認
這哪裡是來自，

822
00:40:48,480 --> 00:40:49,330
實際上，有 - 

823
00:40:49,330 --> 00:40:53,230
我的意思是，你可以嘗試去找到它 - 但
有沒有像一個非常漫長的博客

824
00:40:53,230 --> 00:40:54,130
後有人寫道。

825
00:40:54,130 --> 00:40:55,660
這就像那些書籤交易的事情之一。

826
00:40:55,660 --> 00:40:59,650
但有人批評Node.js的，並
他們用這個作為一個例子。

827
00:40:59,650 --> 00:41:03,700
樣的，所以我想只顯示兩個
不同的觀點只是為了得到

828
00:41:03,700 --> 00:41:07,320
概念的一般理解
後面這兩個東西。

829
00:41:07,320 --> 00:41:13,050
>> 但這個選擇只是一個可怕的，
可怕的低效計算

830
00:41:13,050 --> 00:41:15,940
密集的方式來計算
第n個Fibonacci數。

831
00:41:15,940 --> 00:41:21,180
因此，正如一個側面說明，為什麼
它像可怕的一種方式？

832
00:41:21,180 --> 00:41:23,210
沒錯？

833
00:41:23,210 --> 00:41:25,130
>> 觀眾：說你開始
用1,000。

834
00:41:25,130 --> 00:41:27,050
1,000分裂成999和998。

835
00:41:27,050 --> 00:41:28,970
每一個這樣分割成兩件事情。

836
00:41:28,970 --> 00:41:30,890
每一個這樣分割成兩件事情。

837
00:41:30,890 --> 00:41:31,355
>> 凱文·施密德：對。

838
00:41:31,355 --> 00:41:32,400
>> 觀眾：一路下來。

839
00:41:32,400 --> 00:41:32,840
>> 凱文·施密德：沒錯。

840
00:41:32,840 --> 00:41:37,330
因此，只要重複的攝像頭，如果我
打電話撒謊像1,000或東西

841
00:41:37,330 --> 00:41:41,810
這樣，它顯然不低於
或等於一所以我要去

842
00:41:41,810 --> 00:41:46,040
去這個東西的情況下，然後我要去
打電話撒謊999加些小謊998。

843
00:41:46,040 --> 00:41:50,290
然後幾乎所有的
FIB表999做的工作是

844
00:41:50,290 --> 00:41:52,950
那種在這個水平。

845
00:41:52,950 --> 00:41:55,620
如果你去了，它甚至更多的冗餘
比，但如果你只是

846
00:41:55,620 --> 00:42:01,390
想計算FIB 998得到
我們非常接近，撒謊999。

847
00:42:01,390 --> 00:42:05,860
所以，我們真的應該多一點
關於巧樣的，我們如何重複使用

848
00:42:05,860 --> 00:42:07,580
這些，但我們不重用
這些東西都沒有。

849
00:42:07,580 --> 00:42:11,860
所以你可以想像這個龐大的，
巨大的樹，這只是太可怕了。

850
00:42:11,860 --> 00:42:12,940
>> 但無論如何，確定。

851
00:42:12,940 --> 00:42:14,040
所以這是謊。

852
00:42:14,040 --> 00:42:15,530
它只是需要一段時間來運行。

853
00:42:15,530 --> 00:42:16,510
沒錯？

854
00:42:16,510 --> 00:42:17,760
>> 觀眾：[聽不清]。

855
00:42:17,760 --> 00:42:20,430

856
00:42:20,430 --> 00:42:22,481
>> KEVIN SCHMID：哦，你可以
重複的問題？

857
00:42:22,481 --> 00:42:23,731
>> 觀眾：[聽不清]。

858
00:42:23,731 --> 00:42:30,840

859
00:42:30,840 --> 00:42:33,990
>> KEVIN SCHMID：哦所以這只是代碼
這將是某種對

860
00:42:33,990 --> 00:42:34,850
服務器端。

861
00:42:34,850 --> 00:42:38,100
因此，這是不會被發現
在瀏覽器或任何東西。

862
00:42:38,100 --> 00:42:42,160
這基本上是我們所擁有的是，當
這裡的用戶幾乎使

863
00:42:42,160 --> 00:42:45,300
他們的要求再次，當某種我們
提出一個請求，我們將調用

864
00:42:45,300 --> 00:42:47,040
此功能在服務器端。

865
00:42:47,040 --> 00:42:50,480
然後我們會得到結果返回
從調用該函數。

866
00:42:50,480 --> 00:42:52,460
然後我們將只打印
它給用戶。

867
00:42:52,460 --> 00:42:54,580
所以用戶並沒有真正處理
使用此功能太多。

868
00:42:54,580 --> 00:42:57,270
>> 是這個問題嗎？

869
00:42:57,270 --> 00:42:58,470
這是否有道理？

870
00:42:58,470 --> 00:42:58,810
確定。

871
00:42:58,810 --> 00:43:00,930
涼爽。

872
00:43:00,930 --> 00:43:04,240
>> 所以，再一次，我們做這整個res.writeHead
在這裡我們打印出來的東西

873
00:43:04,240 --> 00:43:05,150
頭。

874
00:43:05,150 --> 00:43:09,730
然後我做最終的反應
神奇的數字是FIB 45。

875
00:43:09,730 --> 00:43:12,100
因此，讓我們只需運行該服務器。

876
00:43:12,100 --> 00:43:15,190
所以我要做一個節點fib.js.

877
00:43:15,190 --> 00:43:17,340
所以現在我的FIB服務器正在運行。

878
00:43:17,340 --> 00:43:21,790
>> 然後在這裡，我要去
做其中之一。

879
00:43:21,790 --> 00:43:22,200
好不好？

880
00:43:22,200 --> 00:43:24,960
所以，我只是想說，捲曲。

881
00:43:24,960 --> 00:43:32,226
因此，這將需要一些時間，但
希望很快就會完成，

882
00:43:32,226 --> 00:43:35,660
它會打印出45次
斐波納契數。

883
00:43:35,660 --> 00:43:36,910
>> 觀眾：[聽不清]。

884
00:43:36,910 --> 00:43:40,720

885
00:43:40,720 --> 00:43:42,050
>> KEVIN SCHMID：應該
得到很快完成。

886
00:43:42,050 --> 00:43:43,780
所以應該採取5〜6秒。

887
00:43:43,780 --> 00:43:48,570
我不知道，只是V8發動機被超
快，但在任何情況下，這是一個

888
00:43:48,570 --> 00:43:52,700
很簡單的例子，並故意
不雅的不平凡

889
00:43:52,700 --> 00:43:54,200
計算。

890
00:43:54,200 --> 00:43:56,700
因此，一段時間後，它得到這一點。

891
00:43:56,700 --> 00:44:02,130
>> 但現在，如果我做同一種
實驗和以前一樣，我做

892
00:44:02,130 --> 00:44:04,010
在同一時間兩個請求？

893
00:44:04,010 --> 00:44:06,990
所以在這裡我要對捲曲
該地址，我要去

894
00:44:06,990 --> 00:44:08,260
另做捲曲。

895
00:44:08,260 --> 00:44:12,070
請記住，當我們這樣做的
睡覺的服務器，當我們基本上有它

896
00:44:12,070 --> 00:44:15,320
五秒鐘後，他們很
兩個多回來權利

897
00:44:15,320 --> 00:44:16,380
大約在同一時間。

898
00:44:16,380 --> 00:44:18,650
所以它不是特別綁起來。

899
00:44:18,650 --> 00:44:20,290
>> 但是，讓我們現在就來試試。

900
00:44:20,290 --> 00:44:22,370
好了，我們得到了我們的兩個過程。

901
00:44:22,370 --> 00:44:24,210
還記得那些是進程ID。

902
00:44:24,210 --> 00:44:25,900
這將是一個小
尷尬的同時，我們搪塞。

903
00:44:25,900 --> 00:44:31,340

904
00:44:31,340 --> 00:44:35,360
因此，讓我們住在這兒等待。

905
00:44:35,360 --> 00:44:37,090
>> 所以，他們中的一個應該是
回來後像 - 

906
00:44:37,090 --> 00:44:39,190
好了，一個人回來。

907
00:44:39,190 --> 00:44:43,570
但後​​來為什麼沒有第二
1回來，只是還沒有？

908
00:44:43,570 --> 00:44:44,389
沒錯？

909
00:44:44,389 --> 00:44:49,280
>> 觀眾：服務器不能做任何事情
而它的計算是大數目。

910
00:44:49,280 --> 00:44:51,620
>> 凱文·施密德：對。

911
00:44:51,620 --> 00:44:55,395
因此，反應只是服務器
真的不能做任何事情，而

912
00:44:55,395 --> 00:44:57,460
它的計算是斐波那契數。

913
00:44:57,460 --> 00:44:59,360
所以，現在我剛剛拿到我的兩個東西回來。

914
00:44:59,360 --> 00:45:03,210
但我猜只是想想代碼
多一點，它是如何工作的

915
00:45:03,210 --> 00:45:05,030
和一切。

916
00:45:05,030 --> 00:45:11,750
>> 所以這個功能在這裡是代碼，
我已經告訴這台服務器，當它運行

917
00:45:11,750 --> 00:45:14,100
接收到新的傳入請求。

918
00:45:14,100 --> 00:45:17,940
所以它只是通過這個運行
整個代碼，然後它會去

919
00:45:17,940 --> 00:45:21,120
回到事件循環，然後繼續
檢查是否有新的事件。

920
00:45:21,120 --> 00:45:23,670
所以基本上我們所發生的事情
是服務器

921
00:45:23,670 --> 00:45:25,080
聽新的東西。

922
00:45:25,080 --> 00:45:28,070
第一個人問什麼45。

923
00:45:28,070 --> 00:45:30,490
我們運行這個代碼來計算它。

924
00:45:30,490 --> 00:45:33,420
此代碼需要大約五
六秒運行。

925
00:45:33,420 --> 00:45:36,990
然後我們回到事件循環
並檢查是否有新的要求。

926
00:45:36,990 --> 00:45:42,700
>> 所以這是一個如何一個例子，如果
有事情是所謂的計算

927
00:45:42,700 --> 00:45:48,140
約束，或者使用大量的計算，
沒有權力，但有一樣

928
00:45:48,140 --> 00:45:50,260
計算密集型 - 

929
00:45:50,260 --> 00:45:54,080
我想有一件事要說一下，這是
這個函數是做完全，

930
00:45:54,080 --> 00:45:56,310
在大多數情況下，很
有用的工作權利。

931
00:45:56,310 --> 00:45:59,970
整個時間的回調
功能正在運行，它是非常

932
00:45:59,970 --> 00:46:03,670
多花大部分時間只是
計算的第n個斐波那契數。

933
00:46:03,670 --> 00:46:05,930
>> 但我們只有一個線程
對付。

934
00:46:05,930 --> 00:46:10,270
在Apache的模型中，當兩個人
就該好好撒謊45的要求，我們

935
00:46:10,270 --> 00:46:11,610
將有兩個不同的線程。

936
00:46:11,610 --> 00:46:15,060
然後操作系統的作業
本來，或者用戶級別

937
00:46:15,060 --> 00:46:18,660
用於管理線程中的代碼，會一直
一直到切片，截至上

938
00:46:18,660 --> 00:46:23,060
CPU的，甚至如果你有多個CPU，
均勻地分佈它們在整個CPU的

939
00:46:23,060 --> 00:46:26,130
讓他們都完成
大約在同一時間。

940
00:46:26,130 --> 00:46:31,120
>> 因此，只是為了告訴你如何可以排序的 - 
這不是一個完美的總

941
00:46:31,120 --> 00:46:34,280
排序的解決方案，但我們如何能
賺回來這裡做

942
00:46:34,280 --> 00:46:35,880
好一點點。

943
00:46:35,880 --> 00:46:41,540
那麼，我這裡是一個調用程序
FIB C.這基本上使用

944
00:46:41,540 --> 00:46:45,690
的節點的模塊，另外一個叫
子進程模塊。

945
00:46:45,690 --> 00:46:49,210
所以，我已經包括了在上面種
像我會做一斤包括

946
00:46:49,210 --> 00:46:51,230
孩子PROCESS.H什麼的。

947
00:46:51,230 --> 00:46:56,210
現在我有機會使用新的CP變量
裡面有我所有的功能。

948
00:46:56,210 --> 00:47:01,810
>> 所以，現在我在做什麼在此回應
處理程序是我運行這個程序

949
00:47:01,810 --> 00:47:04,100
點斜線FIB 45。

950
00:47:04,100 --> 00:47:06,820
所以我做了什麼 - 我只是去
走出這一計劃的一個

951
00:47:06,820 --> 00:47:07,620
點點 - 

952
00:47:07,620 --> 00:47:11,060
是我寫了一個C程序
基本計算

953
00:47:11,060 --> 00:47:12,630
第n個Fibonacci數。

954
00:47:12,630 --> 00:47:15,960
因此，這裡只是我寫了一個程序
C語言，計算這一點。

955
00:47:15,960 --> 00:47:19,040
我可以編譯它，我可以運行
它在命令行中。

956
00:47:19,040 --> 00:47:22,150
並且它要計算
第45斐波那契數。

957
00:47:22,150 --> 00:47:24,510
>> 所以，注意它只是需要
相當多長。

958
00:47:24,510 --> 00:47:28,240
我大概也可以使用破折號03
優化它或類似的東西，

959
00:47:28,240 --> 00:47:31,050
但我就是不喜歡常規
編譯器設置。

960
00:47:31,050 --> 00:47:33,260
而且它打印出來。

961
00:47:33,260 --> 00:47:36,830
>> 但現在，我是什麼樣的做什麼？

962
00:47:36,830 --> 00:47:39,800
哦，對不起，錯了文件。

963
00:47:39,800 --> 00:47:42,800
所以我做同樣的東西用
如之前的標頭。

964
00:47:42,800 --> 00:47:45,780
然後，我這樣做cp.exec。

965
00:47:45,780 --> 00:47:49,460
那麼，這是怎麼回事做的是它的
要運行此程序。

966
00:47:49,460 --> 00:47:51,960
但這種工作方式是，
它不會等待

967
00:47:51,960 --> 00:47:53,400
該程序來完成。

968
00:47:53,400 --> 00:47:56,000
它只是基本上說
執行此程序。

969
00:47:56,000 --> 00:47:58,700
所以基本上鍵入此進
命令提示符樣的。

970
00:47:58,700 --> 00:48:02,350
>> 然後，當你與完成
它，運行此功能。

971
00:48:02,350 --> 00:48:04,800
那種所以現在我們得到這個
整個恢復的事情

972
00:48:04,800 --> 00:48:06,750
就像我們不能等待。

973
00:48:06,750 --> 00:48:08,530
這是否一種有意義嗎？

974
00:48:08,530 --> 00:48:08,990
沒錯？

975
00:48:08,990 --> 00:48:11,060
>> 觀眾：[聽不清]？

976
00:48:11,060 --> 00:48:13,610
>> KEVIN SCHMID：這實際上這樣
開闢一個新的進程來做到這一點。

977
00:48:13,610 --> 00:48:19,310
所以實際上，在某些方面，
邪惡的，不是超級邪惡的，但它是

978
00:48:19,310 --> 00:48:22,990
重要的是說，這是一種
回去，一方面，Apache的

979
00:48:22,990 --> 00:48:26,450
模型中，我們做的線程和進程
對於每個請求，或

980
00:48:26,450 --> 00:48:29,280
進程為每個請求。

981
00:48:29,280 --> 00:48:32,090
因此，這是一種類似於
什麼阿帕奇一樣。

982
00:48:32,090 --> 00:48:35,110
在某些情況下，將僅使用一個新的
線程，這是一點光

983
00:48:35,110 --> 00:48:39,040
重量比的過程，但是Apache可以
最終派生一個新的進程

984
00:48:39,040 --> 00:48:43,370
這是什麼樣的，我們在這裡做的
含蓄地做點斜線FIB 45。

985
00:48:43,370 --> 00:48:48,690
>> 然後在這種情況下，我們種產生
的過程相同的開支。

986
00:48:48,690 --> 00:48:50,710
所以這只是一件事情你可以做。

987
00:48:50,710 --> 00:48:52,600
但只是為了顯示這種運行。

988
00:48:52,600 --> 00:48:57,120
而這次談話只是真正目的
提出這些類型的節目作為

989
00:48:57,120 --> 00:49:00,710
的方式展現不同的視角
如何設計這樣的服務器。

990
00:49:00,710 --> 00:49:08,300
所以這個正在運行，那麼現在如果我這樣做
這一次，我有兩個進程ID。

991
00:49:08,300 --> 00:49:10,320
>> 讓我們只談
事情要指出。

992
00:49:10,320 --> 00:49:11,980
所以請注意，他們是增量。

993
00:49:11,980 --> 00:49:12,700
這很酷。

994
00:49:12,700 --> 00:49:15,140
因為它是27,122前。

995
00:49:15,140 --> 00:49:18,580
但現在通知他們回來
在大致相同的時間。

996
00:49:18,580 --> 00:49:23,960
>> 而現在，一個很好的問題請教一下
為什麼是這樣的，他的工作

997
00:49:23,960 --> 00:49:27,590
是現在它的排序，使這些東西
那種與各自發揮公平

998
00:49:27,590 --> 00:49:31,350
其他的，這兩個實例
點斜線FIB 45，我跑了

999
00:49:31,350 --> 00:49:32,880
或者說節點跑？

1000
00:49:32,880 --> 00:49:36,940
那種誰使得它公平，他們都
一種得到平衡的運行時間？

1001
00:49:36,940 --> 00:49:42,900

1002
00:49:42,900 --> 00:49:44,220
>> 觀眾：[聽不清]。

1003
00:49:44,220 --> 00:49:44,620
>> KEVIN SCHMID：是啊。

1004
00:49:44,620 --> 00:49:49,740
所以基本上，當我做點斜線謊
45或類似的東西，現在它的

1005
00:49:49,740 --> 00:49:53,750
種到操作系統來
處理這些程序的運行時間。

1006
00:49:53,750 --> 00:49:56,920
現在它可以安排他們
在不同的CPU或

1007
00:49:56,920 --> 00:49:58,330
可以安排他們。

1008
00:49:58,330 --> 00:50:01,870
時間可以切片，一個
CPU得到它，或者他們得到

1009
00:50:01,870 --> 00:50:03,330
在一個CPU上運行。

1010
00:50:03,330 --> 00:50:05,620
所以，這背後的想法。

1011
00:50:05,620 --> 00:50:07,220
這是否是有意義的人呢？

1012
00:50:07,220 --> 00:50:10,950
所以，現在的節點是不是真的打了
參與瓜分這些任務。

1013
00:50:10,950 --> 00:50:12,200
確定。

1014
00:50:12,200 --> 00:50:14,050

1015
00:50:14,050 --> 00:50:17,840
>> 所以這是幾乎它的例子。

1016
00:50:17,840 --> 00:50:23,370
我只是想表明一件事
因為很多這樣的成績一直

1017
00:50:23,370 --> 00:50:27,350
不完全超實用
在某些情況下。

1018
00:50:27,350 --> 00:50:30,970
我能想像在這之後回家
說話和東西，並說像，

1019
00:50:30,970 --> 00:50:35,710
好樣的我離開了那個說話的那
我可以做一個斐波那契服務器

1020
00:50:35,710 --> 00:50:37,360
我最後的項目。

1021
00:50:37,360 --> 00:50:40,770
因此，這裡只是排序的又一個例子
希望這將是 - 

1022
00:50:40,770 --> 00:50:44,620
也許不是，但也許 - 多一點
排序相關的最終項目和

1023
00:50:44,620 --> 00:50:46,440
超前的思維對這樣的事情。

1024
00:50:46,440 --> 00:50:48,870
>> 因此，這是chat.js.

1025
00:50:48,870 --> 00:50:52,290
因此，這是一種像一些示例
您可以使用服務器端代碼

1026
00:50:52,290 --> 00:50:55,700
設置像一個小的聊天服務器
你可能已經看到在

1027
00:50:55,700 --> 00:50:56,630
Facebook的聊天或什麼的。

1028
00:50:56,630 --> 00:50:59,990
所以，我並不是說這是像Facebook
聊天，但是這是一種

1029
00:50:59,990 --> 00:51:06,230
是個不錯的 - 也許不是很好，但也許
好 - 起點聊天

1030
00:51:06,230 --> 00:51:08,560
服務器為您的網站
對於最終的項目。

1031
00:51:08,560 --> 00:51:11,040
因此，讓我們來看看它在做什麼。

1032
00:51:11,040 --> 00:51:15,500
>> 因此，我們得到這個特別的事情
在頂部，此估計虧損風險SIO

1033
00:51:15,500 --> 00:51:17,050
等於要求Socket.IO。

1034
00:51:17,050 --> 00:51:20,280
因此，這是它不另外一回事
居然來捆綁

1035
00:51:20,280 --> 00:51:22,300
節點，但你可以安裝它。

1036
00:51:22,300 --> 00:51:23,480
這是一個節點模塊。

1037
00:51:23,480 --> 00:51:25,670
所以它只是像一些
擴展節點。

1038
00:51:25,670 --> 00:51:29,220
>> SocketIO實際上是真的
挺酷的。

1039
00:51:29,220 --> 00:51:32,550
這是一個抽象的概念，基本上是什麼
它的作用是是它可以讓你

1040
00:51:32,550 --> 00:51:35,770
有這種通信流
網絡之間

1041
00:51:35,770 --> 00:51:39,430
瀏覽器和Web服務器。

1042
00:51:39,430 --> 00:51:45,250
因此，在大多數情況下，到目前為止，我們已經有
這些非常快速一兩秒鐘

1043
00:51:45,250 --> 00:51:48,790
網絡之間的第二通信
瀏覽器和Web服務器。

1044
00:51:48,790 --> 00:51:53,310
所以它基本上去到google.com，GET
的東西，送它回去，然後

1045
00:51:53,310 --> 00:51:53,770
我們就大功告成了。

1046
00:51:53,770 --> 00:51:56,560
我們從來沒有再說話，直到
在別的用戶類型。

1047
00:51:56,560 --> 00:52:01,090
>> 但是Socket.IO和類似那種
事情 - 和SocketIO實際上是1

1048
00:52:01,090 --> 00:52:03,940
那是建立在作為東西
WebSocket的是那種可

1049
00:52:03,940 --> 00:52:06,440
作為HTML5的一部分 - 

1050
00:52:06,440 --> 00:52:09,620
這可以讓你有這樣的
繼續對話。

1051
00:52:09,620 --> 00:52:13,990
這是非常有用的在聊天服務器
之類的話，因為它是

1052
00:52:13,990 --> 00:52:17,390
有點像在一個持續對話
某些方面，因為如果你聊天

1053
00:52:17,390 --> 00:52:21,540
某人，你只要發送一個
消息向下的管子，然後將

1054
00:52:21,540 --> 00:52:23,940
服務器可以發送消息了下來
管其他人你

1055
00:52:23,940 --> 00:52:24,520
與聊天。

1056
00:52:24,520 --> 00:52:26,903
然後你就可以有這樣的
交換這樣的。

1057
00:52:26,903 --> 00:52:30,590

1058
00:52:30,590 --> 00:52:32,850
>> 所以這是什麼樣的
SocketIO是好的。

1059
00:52:32,850 --> 00:52:38,400
這SocketIO使用的WebSockets的原因
作為一件事是，在

1060
00:52:38,400 --> 00:52:43,980
除了只是普通的舊的WebSockets，
它也做了一些技巧，基本上

1061
00:52:43,980 --> 00:52:45,610
讓瀏覽器兼容。

1062
00:52:45,610 --> 00:52:50,040
因此，瀏覽器，如Internet Explorer
不幸的是不支持的WebSockets

1063
00:52:50,040 --> 00:52:50,810
正確的開箱即用。

1064
00:52:50,810 --> 00:52:55,290
因此它使用了一些其他類型的很酷的整齊
使用Adobe Flash的東西，讓

1065
00:52:55,290 --> 00:52:57,170
你有跨瀏覽器支持。

1066
00:52:57,170 --> 00:52:58,800
所以這是非常有用的。

1067
00:52:58,800 --> 00:53:02,440
>> 而實際上，我知道我是那種
在運行時間在這裡，但CS50

1068
00:53:02,440 --> 00:53:08,490
討論，你見過的東西
喜歡，我不知道，空白某某是

1069
00:53:08,490 --> 00:53:11,030
回复這個帖子什麼的
這樣，該功能？

1070
00:53:11,030 --> 00:53:12,250
這是SocketIO。

1071
00:53:12,250 --> 00:53:15,580
所以，當有人開始輸入的
討論箱作出答复或

1072
00:53:15,580 --> 00:53:20,040
什麼，你的瀏覽器是什麼
叫SocketIO發出某種

1073
00:53:20,040 --> 00:53:22,660
倘若某人說的
回复這個帖子。

1074
00:53:22,660 --> 00:53:26,110
>> 然後，服務器說，OK，
我有什麼做的？

1075
00:53:26,110 --> 00:53:29,270
現在好了，我要告訴那些其他人
誰是對CS50討論尋找

1076
00:53:29,270 --> 00:53:31,170
這個帖子有人回复的。

1077
00:53:31,170 --> 00:53:34,190
所以這是什麼樣的SocketIO是
好，這種持續樣的

1078
00:53:34,190 --> 00:53:35,930
對話流。

1079
00:53:35,930 --> 00:53:37,250
確定。

1080
00:53:37,250 --> 00:53:40,060
>> 因此，我在這裡 - 我們只是
將忽略該連接陣列

1081
00:53:40,060 --> 00:53:41,390
一點點 - 

1082
00:53:41,390 --> 00:53:43,080
我做的是我另一個聽。

1083
00:53:43,080 --> 00:53:46,880
所以，這只是Socket.IO的方式
說讓我們來聽聽這個端口上。

1084
00:53:46,880 --> 00:53:50,060
然後我做這個連接。

1085
00:53:50,060 --> 00:53:53,360
所以，這只是基本的Socket IO的
的說法，當我們收到一個方法

1086
00:53:53,360 --> 00:53:55,840
就此，我想你
要運行此代碼。

1087
00:53:55,840 --> 00:53:59,870
>> 並注意而不是有錄音的
和水庫在那裡通過我的Socket。

1088
00:53:59,870 --> 00:54:03,260
與此Socket的想法基本上是這樣
你可以寫和讀的東西

1089
00:54:03,260 --> 00:54:05,750
從具有該用戶的
消息可能。

1090
00:54:05,750 --> 00:54:10,700
並且，你會發送郵件
可以通過該插座。

1091
00:54:10,700 --> 00:54:12,140
這是否有道理？

1092
00:54:12,140 --> 00:54:14,490
所以它的這種持續的事情。

1093
00:54:14,490 --> 00:54:17,820
>> 所以，我做的是我稱之為Socket.emit。

1094
00:54:17,820 --> 00:54:20,330
並發出需要相當
多兩個參數。

1095
00:54:20,330 --> 00:54:24,100
第一個參數是一個字符串
剛剛代表的類型

1096
00:54:24,100 --> 00:54:25,270
你發光的東西。

1097
00:54:25,270 --> 00:54:28,120
因此，對於這種情況下，我已經使用
這個字符串新的消息。

1098
00:54:28,120 --> 00:54:32,670
而這只是基本上是說，
這個東西的類型，就是我

1099
00:54:32,670 --> 00:54:34,750
發送，是一個新的消息。

1100
00:54:34,750 --> 00:54:38,460
所以，你可以偵聽特定類型
像新的消息或什麼

1101
00:54:38,460 --> 00:54:39,960
使用點上。

1102
00:54:39,960 --> 00:54:44,570
>> 因此，連接和用戶發送那裡，如果
你看看，我們稱之為點上，

1103
00:54:44,570 --> 00:54:48,150
這些都是代表其他字符串
類型的用戶的消息。

1104
00:54:48,150 --> 00:54:52,060
所以基本上你可以有這個EMIT
1這些消息類型，並

1105
00:54:52,060 --> 00:54:55,520
然後做一些回應
這些消息類型之一

1106
00:54:55,520 --> 00:54:57,640
>> 所以我發這個新的消息。

1107
00:54:57,640 --> 00:55:00,540
我們打算忽略connections.push
一秒鐘。

1108
00:55:00,540 --> 00:55:03,360
後來我說，Socket.on用戶發送。

1109
00:55:03,360 --> 00:55:07,540
所以現在有點像當
用戶向我發送一條消息，我想

1110
00:55:07,540 --> 00:55:09,240
你要運行此代碼。

1111
00:55:09,240 --> 00:55:12,080
並注意到，該匿名函數
正在這個變量

1112
00:55:12,080 --> 00:55:16,300
所謂數據，基本上會
有用戶的信息。

1113
00:55:16,300 --> 00:55:20,700
>> 所以，現在讓我們有種談
連接陣列。

1114
00:55:20,700 --> 00:55:24,590
因此，這是專為聊天客戶端
在那裡，基本上每個人的那種在

1115
00:55:24,590 --> 00:55:25,950
同一個聊天室。

1116
00:55:25,950 --> 00:55:29,640
所以基本上，我們需要保持
周圍是一些陣列，基本上

1117
00:55:29,640 --> 00:55:33,170
代表所有的人聊天
從某種角度來說，如果是有道理的。

1118
00:55:33,170 --> 00:55:33,340
對不對？

1119
00:55:33,340 --> 00:55:37,190
因為我們需要知道是誰那些傢伙
那麼，我們可以向他們發送消息

1120
00:55:37,190 --> 00:55:39,140
其他人發送給我們。

1121
00:55:39,140 --> 00:55:44,440
>> 所以這段代碼的功能是什麼，當用戶
發送一個消息 - 這是類型

1122
00:55:44,440 --> 00:55:45,300
事件 - 

1123
00:55:45,300 --> 00:55:47,120
我們要運行此代碼。

1124
00:55:47,120 --> 00:55:51,240
而我們要做的是，我們通過這個運行
數組，我們稱之為連接。

1125
00:55:51,240 --> 00:55:54,390
和幾乎每一個連接
除了一個是我們的，這是

1126
00:55:54,390 --> 00:55:59,520
這是什麼碼說，我們發送一個新的
與附加的郵件消息

1127
00:55:59,520 --> 00:56:01,210
信息。

1128
00:56:01,210 --> 00:56:04,880
>> 所以，如果你在這裡看到，我就是這樣做的時候
用戶實際上使得新

1129
00:56:04,880 --> 00:56:08,560
連接我與加
JavaScript.push方法，這是

1130
00:56:08,560 --> 00:56:12,100
基本上只是說像添加
該插座作為一個值

1131
00:56:12,100 --> 00:56:13,900
我們的連接陣列。

1132
00:56:13,900 --> 00:56:20,560
所以，現在這個代碼運行時，它會
送東西給那些特定的

1133
00:56:20,560 --> 00:56:22,020
連接。

1134
00:56:22,020 --> 00:56:26,980
所以這可能是一個很好的起點
製作一個聊天服務器

1135
00:56:26,980 --> 00:56:28,250
或類似的東西。

1136
00:56:28,250 --> 00:56:33,315
>> 和那種很酷的事情是，
你在這裡看到的像和代碼

1137
00:56:33,315 --> 00:56:36,390
發射和類似的東西是一樣的
樣的JavaScript代碼，你會

1138
00:56:36,390 --> 00:56:39,260
寫在瀏覽器中進行互動
用服務器。

1139
00:56:39,260 --> 00:56:42,480
所以這就是為什麼SocketIO是怎麼樣的
整齊並以這種方式非常有用。

1140
00:56:42,480 --> 00:56:45,680

1141
00:56:45,680 --> 00:56:49,250
>> 呵呵，只是一件事真正的快。

1142
00:56:49,250 --> 00:56:55,970
有一個CS50最終項目去年
基本上實現了一個聊天

1143
00:56:55,970 --> 00:56:57,840
在Node.js的服務器

1144
00:56:57,840 --> 00:57:01,350
我認為這是Harvardchats.org
但我不是 - 

1145
00:57:01,350 --> 00:57:02,940
確定。

1146
00:57:02,940 --> 00:57:06,190
我不知道該URL是什麼，但
我後來送了出來。

1147
00:57:06,190 --> 00:57:09,260
但是，這是一種什麼降溫
你可以用Node.js的做

1148
00:57:09,260 --> 00:57:14,680
>> 所以我希望，在一般情況下，你們有一個
什麼樣的Node.js是很有用的感覺不錯

1149
00:57:14,680 --> 00:57:17,870
並如何可以或許申請
您的最終項目。

1150
00:57:17,870 --> 00:57:21,050
我將派出更多一些
隨著這個資源。

1151
00:57:21,050 --> 00:57:23,170
謝謝你的光臨。

1152
00:57:23,170 --> 00:57:23,610
謝謝。

1153
00:57:23,610 --> 00:57:27,168
>> [掌聲]