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
>> [掌声]