1
00:00:00,000 --> 00:00:05,900

2
00:00:05,900 --> 00:00:07,170
>> SAM格林：你好，大家好。

3
00:00:07,170 --> 00:00:08,640
欢迎来到我们的研讨会。

4
00:00:08,640 --> 00:00:10,009
我叫山姆。

5
00:00:10,009 --> 00:00:11,050
休·扎布里斯基：我休。

6
00:00:11,050 --> 00:00:17,420
SAM格林：我们今天要谈
关于JavaScript和Web音频API。

7
00:00:17,420 --> 00:00:21,180
刚开始出来，这是一个大纲
我们的研讨会议程。

8
00:00:21,180 --> 00:00:25,350
我们将先来谈谈
为什么你应该有兴趣的网站

9
00:00:25,350 --> 00:00:30,130
音频API，这是为什么的JavaScript
你需要它的语言，

10
00:00:30,130 --> 00:00:32,619
再谈谈的JavaScript
essentials--这么喜欢，

11
00:00:32,619 --> 00:00:34,800
指导您完成一些
语言的基本知识，

12
00:00:34,800 --> 00:00:37,290
再谈谈
在较高水平的音频的API。

13
00:00:37,290 --> 00:00:41,140
然后，休将谈论一些
音频制作的阶段

14
00:00:41,140 --> 00:00:45,509
然后演示该真棒序
项目他建立并显示你的代码。

15
00:00:45,509 --> 00:00:48,050
然后，我们将有时间
在最后的人的问题

16
00:00:48,050 --> 00:00:49,593
谁在这里居住。

17
00:00:49,593 --> 00:00:50,540
>> 休·扎布里斯基：酷。

18
00:00:50,540 --> 00:00:50,990
>> SAM格林：酷。

19
00:00:50,990 --> 00:00:51,383
>> 休·扎布里斯基：酷。

20
00:00:51,383 --> 00:00:52,170
我将备份。

21
00:00:52,170 --> 00:00:54,960
>> SAM格林：那么，首先第一件事情。

22
00:00:54,960 --> 00:00:57,840
所以，伟大的事情之一
关于网络音频API

23
00:00:57,840 --> 00:01:00,480
是，有不需要的设置。

24
00:01:00,480 --> 00:01:04,230
它配备内置在
大部分现代浏览器，

25
00:01:04,230 --> 00:01:08,630
包括Chrome浏览器，封边，整体
一堆others--所有的人

26
00:01:08,630 --> 00:01:12,650
那大部分
人们今天使用。

27
00:01:12,650 --> 00:01:14,807
所以没有成立，
除了刚开

28
00:01:14,807 --> 00:01:16,890
Web服务器去，为
你就可以开始工作

29
00:01:16,890 --> 00:01:18,420
您的项目，这是伟大的。

30
00:01:18,420 --> 00:01:21,500

31
00:01:21,500 --> 00:01:24,190
>> 我们建议漂亮
巨资您考虑

32
00:01:24,190 --> 00:01:26,530
使用Chrome浏览器
JavaScript的Web开发，

33
00:01:26,530 --> 00:01:30,260
只是因为它的开发者
工具是真正的强者。

34
00:01:30,260 --> 00:01:33,220
由于正是我们所说的一个例子
说打开你的JavaScript

35
00:01:33,220 --> 00:01:38,600
console--如果你去到Chrome浏览器
而且你看任何网页，

36
00:01:38,600 --> 00:01:43,897
你左击
检查元素，然后

37
00:01:43,897 --> 00:01:46,730
你去这个小下拉
在这里，你点击控制台，

38
00:01:46,730 --> 00:01:50,660
你会看到打开了看起来
很多喜欢在命令提示符下，你

39
00:01:50,660 --> 00:01:53,720
在你的Mac可能会看到，或者在标识。

40
00:01:53,720 --> 00:01:59,260
就这样，我们就可以
输入命令在这里，就像清除，

41
00:01:59,260 --> 00:02:01,350
和其它命令那样。

42
00:02:01,350 --> 00:02:04,267
我们可以创建变量，如
我们将在JavaScript中看到。

43
00:02:04,267 --> 00:02:07,100
所以什么我们可以做的
JavaScript中，我们可以通过控制台执行，

44
00:02:07,100 --> 00:02:11,430
这就是一个超级方便的方法
开始的API玩弄

45
00:02:11,430 --> 00:02:15,760
并获得舒适
JavaScript的了蝙蝠的权利。

46
00:02:15,760 --> 00:02:18,290
无需成立，
这是非常好的。

47
00:02:18,290 --> 00:02:18,790
凉。

48
00:02:18,790 --> 00:02:22,064

49
00:02:22,064 --> 00:02:22,880
真棒。

50
00:02:22,880 --> 00:02:24,780
>> 所以，只是一件事的补充。

51
00:02:24,780 --> 00:02:27,780
如果您有任何questions--有
你们中许多人谁不住在这里，

52
00:02:27,780 --> 00:02:31,232
随时以电子邮件us--这些
是我们的电子邮件地址。

53
00:02:31,232 --> 00:02:33,190
如果您有问题
你不想问我们，

54
00:02:33,190 --> 00:02:36,160
就像，哦，我有一个bug
在我的代码，或东西

55
00:02:36,160 --> 00:02:39,270
这是一个更具体一点，
也许首款谷歌它。

56
00:02:39,270 --> 00:02:42,340
有很多伟大的资源
关于网络音频API在那里。

57
00:02:42,340 --> 00:02:44,089
这是真的很好
记录和它的存在

58
00:02:44,089 --> 00:02:47,194
使用一吨的人
工业和人谁是刚刚

59
00:02:47,194 --> 00:02:48,610
建立有趣的东西留给自己。

60
00:02:48,610 --> 00:02:51,306
所以应该有很多
资源在那里。

61
00:02:51,306 --> 00:02:53,040
真棒。

62
00:02:53,040 --> 00:02:56,100
>> 酷，那么，为什么网络音频API？

63
00:02:56,100 --> 00:02:59,840
此图是一点点
的使用方法的演变

64
00:02:59,840 --> 00:03:04,100
声音在网络上在持续增长。

65
00:03:04,100 --> 00:03:13,080
BGSOUND像原始的HTML标签
Internet Explorer使用的支持。

66
00:03:13,080 --> 00:03:16,790
它只能用于非常基本的声音，
功能不是很强大的，

67
00:03:16,790 --> 00:03:19,380
你不能这样做
复杂的排序，

68
00:03:19,380 --> 00:03:21,890
或控制时，声音开始
停了下来非常强劲。

69
00:03:21,890 --> 00:03:23,930
所以，这不是特别
发达。

70
00:03:23,930 --> 00:03:27,470
那之后，闪存
来到along--其中，

71
00:03:27,470 --> 00:03:31,712
我敢肯定，你们都熟悉
与Flash--也许不是它是如何工作的，

72
00:03:31,712 --> 00:03:32,920
但你肯定看到了。

73
00:03:32,920 --> 00:03:35,586
你必须更新您的Flash
插件，所有的那种东西，

74
00:03:35,586 --> 00:03:40,110
那肯定扩大了范围
功能是可用。

75
00:03:40,110 --> 00:03:45,370
但是，让用户安装
插件是肯定

76
00:03:45,370 --> 00:03:48,480
一个缺点，包括Flash
在应用程序中，对不对？

77
00:03:48,480 --> 00:03:52,410
因为那时你依赖
用户会并发现这个插件，

78
00:03:52,410 --> 00:03:54,660
而且很可能被打开
关闭的这个额外的步骤

79
00:03:54,660 --> 00:03:56,640
他们要好好利用您的应用程序。

80
00:03:56,640 --> 00:04:01,270
然后可能有一个更新
那会破坏你的整个应用程序，

81
00:04:01,270 --> 00:04:03,880
并且它最终是一个梦魇
对于开发者也。

82
00:04:03,880 --> 00:04:06,230
所以这是一个路障。

83
00:04:06,230 --> 00:04:10,480
>> 并在那之后走过来，
在HTML音频标签，

84
00:04:10,480 --> 00:04:16,579
是更现代的HTML--一种特性，它
当然允许有更多的东西，

85
00:04:16,579 --> 00:04:20,050
但即使是事情可以做
有一点点有限的刚

86
00:04:20,050 --> 00:04:22,730
作为事情的结果
该HTML是可以胜任的。

87
00:04:22,730 --> 00:04:26,060
所以当JavaScript的
API时，网络音频的API，

88
00:04:26,060 --> 00:04:29,290
成为标准
跨浏览器的做法，

89
00:04:29,290 --> 00:04:32,490
真正扩大了集
对开发者的机会

90
00:04:32,490 --> 00:04:36,590
真正进入建设
很酷的东西的网页。

91
00:04:36,590 --> 00:04:39,220
很长一段时间曾有
一直很强大的工具

92
00:04:39,220 --> 00:04:44,360
原生音频应用，
like--殊不知GarageBand中，

93
00:04:44,360 --> 00:04:48,360
然后明明有更
专业音频混合应用，

94
00:04:48,360 --> 00:04:49,640
而这样的东西。

95
00:04:49,640 --> 00:04:52,690
但是，没有一个
真正的好Cloud--不

96
00:04:52,690 --> 00:04:55,811
云计算，是啊，我猜
Cloud--基于网络的平台

97
00:04:55,811 --> 00:04:58,310
这将让开发者
构建人申请

98
00:04:58,310 --> 00:05:00,570
做混音。

99
00:05:00,570 --> 00:05:03,960
当他会告诉你
后，网络音频API

100
00:05:03,960 --> 00:05:07,470
允许真厉害
东西发生真正简单，

101
00:05:07,470 --> 00:05:09,597
这是很酷。

102
00:05:09,597 --> 00:05:12,680
所以这是该指令，你为什么
应该注意研讨会的休息，

103
00:05:12,680 --> 00:05:14,350
基本上。

104
00:05:14,350 --> 00:05:17,880
>> 而现在，我要谈谈
一些JavaScript--只是基本要素

105
00:05:17,880 --> 00:05:20,240
的语言，以便
我们可以将在同一页上

106
00:05:20,240 --> 00:05:22,470
当我们谈论的
API有点晚。

107
00:05:22,470 --> 00:05:23,260
凉。

108
00:05:23,260 --> 00:05:26,192
>> 所以，这是一个概要。

109
00:05:26,192 --> 00:05:27,150
我忘了这是在这里。

110
00:05:27,150 --> 00:05:27,510
是啊。

111
00:05:27,510 --> 00:05:27,870
>> 休·扎布里斯基：有两个幻灯片在这里。

112
00:05:27,870 --> 00:05:30,245
>> SAM格林：这是汇总
的一些限制

113
00:05:30,245 --> 00:05:35,220
其他具有约束力，老办法。

114
00:05:35,220 --> 00:05:37,828
然后现在，我们有这些东西。

115
00:05:37,828 --> 00:05:40,011
凉。

116
00:05:40,011 --> 00:05:40,510
真棒。

117
00:05:40,510 --> 00:05:43,200
>> 因此，JavaScript的要领。

118
00:05:43,200 --> 00:05:47,230
首先第一件事情，有一个
漂亮显著差异

119
00:05:47,230 --> 00:05:49,940
在JavaScript与在
像C语言，在路上

120
00:05:49,940 --> 00:05:52,050
该变量的创建。

121
00:05:52,050 --> 00:05:55,634
因此，在C，我们已经习惯了有
输入我们的变量，对不对？

122
00:05:55,634 --> 00:05:57,800
我的意思不是喜欢的类型
键入这些，我的意思是类型

123
00:05:57,800 --> 00:06:01,900
就像给它们分配一个类型 - 意思
就像，一个int，一个float，一个char。

124
00:06:01,900 --> 00:06:05,210
在C语言中，我们真的用
不必创建一个变量

125
00:06:05,210 --> 00:06:09,690
然后坚持这种类型的
我们使用该变量整个时间。

126
00:06:09,690 --> 00:06:13,990
并且不一定是差，
但它可能很难使用。

127
00:06:13,990 --> 00:06:16,190
其中一个很酷的功能
JavaScript的是

128
00:06:16,190 --> 00:06:19,740
该变量是什么所谓
“动态类型”，这

129
00:06:19,740 --> 00:06:22,500
意味着我可以创建一个
与语法的变量，

130
00:06:22,500 --> 00:06:25,800
VARx前提等于5，例如。

131
00:06:25,800 --> 00:06:27,790
这种独创
一个整数变量 - 

132
00:06:27,790 --> 00:06:29,870
正下方
引擎盖somewhere--但我

133
00:06:29,870 --> 00:06:33,040
可以改变的变量
指一个串

134
00:06:33,040 --> 00:06:35,820
没有做任何事情一样
创建一个新的变量。

135
00:06:35,820 --> 00:06:37,880
我不需要担心
有关类型变化。

136
00:06:37,880 --> 00:06:45,440
JavaScript的人都知道类型的
改变，并且动态地发生这种情况。

137
00:06:45,440 --> 00:06:48,510
>> 所以，有优惠
而缺点是，

138
00:06:48,510 --> 00:06:51,250
谁在担任人
JavaScript的一段时间可能知道。

139
00:06:51,250 --> 00:06:53,600
有些时候，
你可能会意外地

140
00:06:53,600 --> 00:06:57,720
改变一个变量的类型和
不处理这种类型的变化，

141
00:06:57,720 --> 00:07:01,120
然后你的JavaScript
可以crash--或异常

142
00:07:01,120 --> 00:07:06,070
被抛出，因为你将有
错误的类型，当你想到一种类型。

143
00:07:06,070 --> 00:07:07,040
凉。

144
00:07:07,040 --> 00:07:11,470
>> 因此，scoping--这就好比，如果我们
记得最初几周在使用过程中，

145
00:07:11,470 --> 00:07:15,420
指的是如何看见一个变量
是和在代码的什么区域。

146
00:07:15,420 --> 00:07:18,400
所有这一切看起来非常相似，
它看起来C.方式

147
00:07:18,400 --> 00:07:24,755
所以变量一般范围
在一个函数中大括号内，

148
00:07:24,755 --> 00:07:27,005
然后还有
全球范围的变量

149
00:07:27,005 --> 00:07:29,171
are--如果你写一个变量
一个功能以外，

150
00:07:29,171 --> 00:07:31,790
这将是在整个文本中可见。

151
00:07:31,790 --> 00:07:35,840
>> 之间的一个区别
的JavaScript和C，特别是

152
00:07:35,840 --> 00:07:40,280
是，如果你声明一个全局
在文本文件中变量的任何地方

153
00:07:40,280 --> 00:07:43,324
它在任何函数可见
内的文本文件。

154
00:07:43,324 --> 00:07:44,240
这是正确的，对不对？

155
00:07:44,240 --> 00:07:46,330
>> 休·扎布里斯基：是的。

156
00:07:46,330 --> 00:07:49,120
>> SAM格林：所以这也是一个小
位时髦相比，C，

157
00:07:49,120 --> 00:07:52,660
我们一直有我们的
上述地方变量定义

158
00:07:52,660 --> 00:07:53,770
他们使用。

159
00:07:53,770 --> 00:07:57,957
这不是真实强制一条规则
了，所以，有一点点不同。

160
00:07:57,957 --> 00:08:00,540
而且目的也只是再次强调，
全局与局部variables--

161
00:08:00,540 --> 00:08:03,457
非常类似于C.你可以有
两个变量具有相同名称，

162
00:08:03,457 --> 00:08:06,540
并有他们的一个名字被隐藏
由一个局部变量，如果其中一

163
00:08:06,540 --> 00:08:07,546
是全球性的。

164
00:08:07,546 --> 00:08:09,420
因此，类似那种
的问题，你们中的一些

165
00:08:09,420 --> 00:08:11,920
可能已在一些碰上
您的问题至今集。

166
00:08:11,920 --> 00:08:14,450
酷，所以这是变量。

167
00:08:14,450 --> 00:08:20,310
>> 控制流程，意思一样，
如果-else--逻辑stuff--和循环。

168
00:08:20,310 --> 00:08:24,510
所以下手，这就是的if-else
声明看起来像在JavaScript中。

169
00:08:24,510 --> 00:08:29,750
的各种事物的位置
上的线并不重要。

170
00:08:29,750 --> 00:08:34,409
这只是其中一项公约
为方式，我们的结构代码。

171
00:08:34,409 --> 00:08:38,634
就像在C，我们有一个
“的话，”一个括号声明。

172
00:08:38,634 --> 00:08:40,840

173
00:08:40,840 --> 00:08:42,090
这不是我的意思做。

174
00:08:42,090 --> 00:08:44,860

175
00:08:44,860 --> 00:08:45,550
我再次做到了。

176
00:08:45,550 --> 00:08:46,841
>> 休·扎布里斯基：试图退出？

177
00:08:46,841 --> 00:08:49,770
SAM格林：不，我
只是想进行放大。

178
00:08:49,770 --> 00:08:50,660
不要紧

179
00:08:50,660 --> 00:08:54,730

180
00:08:54,730 --> 00:08:59,370
>> 因此，我们有一个“如果”语句，并
我们有一个条件在它的内部

181
00:08:59,370 --> 00:09:03,130
计算结果为真或假，
并且确定是否

182
00:09:03,130 --> 00:09:04,510
我们进入代码块。

183
00:09:04,510 --> 00:09:09,860
同样地，我们有一个else-if和
一个else，就像我们在C.使用

184
00:09:09,860 --> 00:09:14,010
>> 你也应该很舒服
马上与循环蝙蝠，

185
00:09:14,010 --> 00:09:16,440
因为他们也期待
很像C相。

186
00:09:16,440 --> 00:09:19,600
但是，你会再次发现，我们
有不是int初始化，

187
00:09:19,600 --> 00:09:22,570
我们有变种的初始化。

188
00:09:22,570 --> 00:09:24,650
我猜你有
要小心，使

189
00:09:24,650 --> 00:09:28,460
确保您不会更改值
我从一个int为字符串，

190
00:09:28,460 --> 00:09:31,780
例如，因为那将
导致怪异的行为，你可能不

191
00:09:31,780 --> 00:09:32,280
期望。

192
00:09:32,280 --> 00:09:35,750
但是，这应该是
很熟悉，也是如此。

193
00:09:35,750 --> 00:09:39,460
>> 因此，这就是事情开始
得到一点点疯狂的JavaScript

194
00:09:39,460 --> 00:09:44,920
人谁是从去
C的背景有功能

195
00:09:44,920 --> 00:09:48,070
在JavaScript中，并有一个办法
声明函数，看起来

196
00:09:48,070 --> 00:09:50,361
排序的类似于C，和
然后还有另外一个，

197
00:09:50,361 --> 00:09:52,450
看起来种不同。

198
00:09:52,450 --> 00:09:54,930
>> 第一个版本，
我们可以在这里看到，

199
00:09:54,930 --> 00:09:59,260
是一种类似C，其中，
我们说，这是一个函数，

200
00:09:59,260 --> 00:10:01,490
给它一个名字，给
参数的数量，

201
00:10:01,490 --> 00:10:05,150
的功能，然后将内容
去那些大括号内。

202
00:10:05,150 --> 00:10:08,850
我们将看到的一个例子
在短短的第二个参数。

203
00:10:08,850 --> 00:10:13,420
>> 而在下一行，我们看到，哦，
这里有一个变量叫“myFunction的，”

204
00:10:13,420 --> 00:10:17,546
我们等于给这
通用件事 -  function--的

205
00:10:17,546 --> 00:10:19,170
似乎没有有什么事情。

206
00:10:19,170 --> 00:10:22,780

207
00:10:22,780 --> 00:10:26,080
之所以说是不同的
比C是JavaScript的

208
00:10:26,080 --> 00:10:30,040
是所谓功能性语言，
或具有功能元件，这意味着

209
00:10:30,040 --> 00:10:33,510
其功能实际上是价值观。

210
00:10:33,510 --> 00:10:39,520
这意味着，我们可以设置
一个变量等于一个功能

211
00:10:39,520 --> 00:10:43,210
然后移动的功能
各地，把它作为一个参数，

212
00:10:43,210 --> 00:10:46,550
做各种东西，
像与功能。

213
00:10:46,550 --> 00:10:49,682
>> 另一件事note--
函数都写

214
00:10:49,682 --> 00:10:51,140
具有一定数目的参数。

215
00:10:51,140 --> 00:10:54,056
我们将看到一个函数的例子
对下一张幻灯片的参数。

216
00:10:54,056 --> 00:10:56,720
但是，JavaScript就无法
骂你，如果你尝试

217
00:10:56,720 --> 00:10:59,330
使用带有一个功能
错误的参数数目。

218
00:10:59,330 --> 00:11:05,310
它只会尽力让
这样做，这意味着如果你通过了，

219
00:11:05,310 --> 00:11:09,410
你调用一个函数需要一个
不带参数，所有的说法，

220
00:11:09,410 --> 00:11:13,990
会发生的事情是，它会尽力
尝试并执行该代码，

221
00:11:13,990 --> 00:11:16,541
并且如果最终运行
到一个异常或错误，

222
00:11:16,541 --> 00:11:19,790
它会抛出异常，只是不停
going--这只是的方法之一

223
00:11:19,790 --> 00:11:21,070
该JavaScript的工作。

224
00:11:21,070 --> 00:11:21,781
是啊。

225
00:11:21,781 --> 00:11:24,207
>> 听众：如果发生了什么
有太多的争论？

226
00:11:24,207 --> 00:11:26,040
SAM格林：所以
问题是，会发生什么

227
00:11:26,040 --> 00:11:27,380
如果有太多的争论？

228
00:11:27,380 --> 00:11:29,171
得到的答复是，
JavaScript的只是

229
00:11:29,171 --> 00:11:32,120
忽略那些是
之后，那些预计。

230
00:11:32,120 --> 00:11:36,420
它会尝试执行功能
称，如果它只是前两个。

231
00:11:36,420 --> 00:11:37,075
对？

232
00:11:37,075 --> 00:11:37,700
>> 休·扎布里斯基：是的，是的。

233
00:11:37,700 --> 00:11:39,449
同样地，如果有
太少的参数，

234
00:11:39,449 --> 00:11:42,640
正中下怀它给空所有
参数它不具有任何值

235
00:11:42,640 --> 00:11:43,660
对于。

236
00:11:43,660 --> 00:11:45,810
>> SAM格林：可
其实很方便，如果你

237
00:11:45,810 --> 00:11:49,060
想要写一个函数，
采用可变数量的参数。

238
00:11:49,060 --> 00:11:55,830
您可以设置默认值
的函数的定义，

239
00:11:55,830 --> 00:11:59,060
而且它也可以忽略的事实
该输入的不存在。

240
00:11:59,060 --> 00:12:01,584

241
00:12:01,584 --> 00:12:04,000
所以，我想谈一点点
更多关于这最后一颗子弹

242
00:12:04,000 --> 00:12:05,541
点，这是功能值。

243
00:12:05,541 --> 00:12:07,930

244
00:12:07,930 --> 00:12:11,010
这是一个例子，是
有点令人兴奋

245
00:12:11,010 --> 00:12:14,880
如果你只是读它，不要以为
这是怎么回事就一秒钟。

246
00:12:14,880 --> 00:12:17,910
那么，让我们来看看刚刚在
这里的第一行。

247
00:12:17,910 --> 00:12:24,360
我们有这个变量，F1，我们说
是一个函数，做这件事情。

248
00:12:24,360 --> 00:12:28,535
和功能的内容
被CONSOLE.LOG（'你好'）。

249
00:12:28,535 --> 00:12:32,220
你能想到的console.log作为中
JavaScript的等效printf函数。

250
00:12:32,220 --> 00:12:35,510
所以会发生什么，如果我们
在我们的浏览器运行这段代码，

251
00:12:35,510 --> 00:12:37,530
它会打印出一个字符串。

252
00:12:37,530 --> 00:12:39,342
我可以证明这一点。

253
00:12:39,342 --> 00:12:42,300
听众：通过日志，但是，这是否
意味着它是被记录的地方？

254
00:12:42,300 --> 00:12:42,550
SAM格林：是的。

255
00:12:42,550 --> 00:12:44,216
所以，我会告诉你发生了什么事情要发生。

256
00:12:44,216 --> 00:12:48,085
所以现在的问题是，是什么日志是什么意思？

257
00:12:48,085 --> 00:12:51,262
>> 休·扎布里斯基：所以的console.log
就像printf进行C.

258
00:12:51,262 --> 00:12:52,970
SAM格林：那么的console.log
是如printf，

259
00:12:52,970 --> 00:12:59,240
所以，如果我有这样的console.log（'你好'），
我称之为，字符串“hello”

260
00:12:59,240 --> 00:13:00,730
被打印到控制台。

261
00:13:00,730 --> 00:13:03,340
这是控制台。

262
00:13:03,340 --> 00:13:05,930
这就像printf的，在这里
它打印到标准输出。

263
00:13:05,930 --> 00:13:09,050

264
00:13:09,050 --> 00:13:11,230
我们会在一分钟内看到，
但其实这是

265
00:13:11,230 --> 00:13:16,529
参照控制台对象，
并调用对象的方法。

266
00:13:16,529 --> 00:13:18,320
这会更有意义
在一分钟的时候，我们

267
00:13:18,320 --> 00:13:20,660
去谈论
在JavaScript对象，

268
00:13:20,660 --> 00:13:22,509
但我想我只想提及。

269
00:13:22,509 --> 00:13:24,300
休·扎布里斯基：我们
在C中使用，right--

270
00:13:24,300 --> 00:13:27,580
我们平时写一个大的程序
在主做任何事情。

271
00:13:27,580 --> 00:13:30,700
但是，什么是很酷的JavaScript是你
有这样的解释说

272
00:13:30,700 --> 00:13:33,620
运行在实时，所以它
通过线仅需线，

273
00:13:33,620 --> 00:13:35,320
它可以只解释了当场。

274
00:13:35,320 --> 00:13:37,403
它跟踪
之前已经运行的东西，

275
00:13:37,403 --> 00:13:41,620
所以这是一个非常有用的工具
使用的console.log，或控制台，

276
00:13:41,620 --> 00:13:46,870
通常，对于刚刚打
周围的JavaScript。

277
00:13:46,870 --> 00:13:51,420
>> SAM格林：那么回到这个
example--代码的第二线

278
00:13:51,420 --> 00:13:55,320
这里是非常令人难以置信的在我的脑海。

279
00:13:55,320 --> 00:13:59,790
我第一次读到这一点，
这就像，这是怎么回事？

280
00:13:59,790 --> 00:14:04,580
那么是什么发生的事情是，这
函数声明说，

281
00:14:04,580 --> 00:14:10,170
我有一个功能叫做F2
该公司预计，有一个参数，女，

282
00:14:10,170 --> 00:14:12,990
然后调用
函数f，其

283
00:14:12,990 --> 00:14:17,652
传递给它作为参数
不带参数本身。

284
00:14:17,652 --> 00:14:19,110
所以，这可能是令人困惑的。

285
00:14:19,110 --> 00:14:21,890

286
00:14:21,890 --> 00:14:28,400
如果我们了解这是F2采用F1
作为参数，然后F2内，

287
00:14:28,400 --> 00:14:31,190
˚F得到called--此装置
这行代码，

288
00:14:31,190 --> 00:14:34,192
这两条线后，
码，结果在“你好”

289
00:14:34,192 --> 00:14:35,400
被打印到控制台。

290
00:14:35,400 --> 00:14:41,660

291
00:14:41,660 --> 00:14:44,910
>> 我们可以通过这一事实
围绕功能作为值

292
00:14:44,910 --> 00:14:47,870
最终被一个最
JavaScript的强大功能

293
00:14:47,870 --> 00:14:49,700
作为一种编程语言。

294
00:14:49,700 --> 00:14:52,782
所有的外
真棒的事情可以做，

295
00:14:52,782 --> 00:14:54,990
正如的一个特征
在的方式而言语言

296
00:14:54,990 --> 00:14:58,400
它使事情变得简单
编程，并允许

297
00:14:58,400 --> 00:15:01,060
对于事情是不是特别
非常适合的网络，

298
00:15:01,060 --> 00:15:04,500
函数式编程和功能
的JavaScript编程方面

299
00:15:04,500 --> 00:15:07,130
是一个最
强大的概念，

300
00:15:07,130 --> 00:15:11,030
在JavaScript--存在，如果你问我。

301
00:15:11,030 --> 00:15:11,960
凉。

302
00:15:11,960 --> 00:15:13,534
>> 所以，接下来的事情。

303
00:15:13,534 --> 00:15:16,450
除了是功能性的，
还有的JavaScript元素

304
00:15:16,450 --> 00:15:20,510
这是面向对象的，
这是的极一

305
00:15:20,510 --> 00:15:23,800
流行的时髦词在计算机科学。

306
00:15:23,800 --> 00:15:27,040
面向对象编程
是一个非常流行的东西。

307
00:15:27,040 --> 00:15:34,210
JavaScript有一个版本是，
在那里我相信每一个价值也

308
00:15:34,210 --> 00:15:41,475
一个对象，这意味着每个对象
包装在一起值的一些数字。

309
00:15:41,475 --> 00:15:44,020

310
00:15:44,020 --> 00:15:49,750
因此，对于值是简单的，像
的整数，像VARx前提等于5，

311
00:15:49,750 --> 00:15:52,250
该对象只是包装的一个值。

312
00:15:52,250 --> 00:15:54,760

313
00:15:54,760 --> 00:15:59,036
>> 但是，我们也可以设想一种情况
where--我们可以想想C中的情况下，

314
00:15:59,036 --> 00:16:00,910
我们想要做的
一些与结构，

315
00:16:00,910 --> 00:16:03,285
例如，一个包装数
值加在一起，使

316
00:16:03,285 --> 00:16:05,870
它很容易通过周围的事物。

317
00:16:05,870 --> 00:16:09,270
这时候，一个对象是在JavaScript中。

318
00:16:09,270 --> 00:16:12,340
>> 重要的是要记住很重要
当我说的物体包裹

319
00:16:12,340 --> 00:16:15,330
一些值的数量一起，
该功能也

320
00:16:15,330 --> 00:16:21,506
值，这意味着函数可以
也可以是JavaScript对象的内部。

321
00:16:21,506 --> 00:16:26,910
这是很重要的原因
是这样的，而我们常

322
00:16:26,910 --> 00:16:30,290
想调用的方法
一个对象，它是在

323
00:16:30,290 --> 00:16:35,200
从其他一个流行术语
流行的面向对象的语言，

324
00:16:35,200 --> 00:16:39,330
的区别之一在这里的是，
所有的方法是在JavaScript

325
00:16:39,330 --> 00:16:47,270
被存储的对象的内部的值
这可能执行一些action--

326
00:16:47,270 --> 00:16:51,850
使用其他值是内
该对象的，但不一定。

327
00:16:51,850 --> 00:16:56,930
所以你可以想像一个情况，我
猜在一个疯狂的方式一点点，

328
00:16:56,930 --> 00:17:02,990
在那里你叫了一个方法
对象在另一对象，例如。

329
00:17:02,990 --> 00:17:06,010
所以，这是一个有点古怪的那样。

330
00:17:06,010 --> 00:17:09,369
>> 而且你还可以改变方法
了与某个对象相关联

331
00:17:09,369 --> 00:17:13,740
通过分配的方法
新功能，这也是

332
00:17:13,740 --> 00:17:18,250
从其他相当不同
面向对象的语言，在这里

333
00:17:18,250 --> 00:17:21,410
一旦我们声明一个对象
并创建实例，

334
00:17:21,410 --> 00:17:25,839
我们不能改变的是方法
与该对象不再相关联。

335
00:17:25,839 --> 00:17:28,680
所以，这是相当不同的。

336
00:17:28,680 --> 00:17:29,570
凉。

337
00:17:29,570 --> 00:17:34,010
>> 因此，这里有一个例子，首先，
在动作中的对象。

338
00:17:34,010 --> 00:17:36,390
这就是被称为
一个通用的对象，

339
00:17:36,390 --> 00:17:39,460
意味着它不具有任何
具体名称，不具有类，

340
00:17:39,460 --> 00:17:42,190
它的价值只是一些包装。

341
00:17:42,190 --> 00:17:49,790
这看起来是这样，我们有
此外对花的牙套这里

342
00:17:49,790 --> 00:17:57,950
指示给JavaScript
说，这是一个目的。

343
00:17:57,950 --> 00:18:02,130
它里面的值
在里面的每个值

344
00:18:02,130 --> 00:18:04,590
对象应
被包裹起来。

345
00:18:04,590 --> 00:18:09,180
与该对象的内部，
然后，我们有键值对，

346
00:18:09,180 --> 00:18:13,880
其中的关键是指名称
物体内的值的，

347
00:18:13,880 --> 00:18:16,790
另side--
结肠这里 - 相反

348
00:18:16,790 --> 00:18:19,850
是实际值
应当被存储。

349
00:18:19,850 --> 00:18:26,210
>> 所以，你在这里看到，我们有一个
关键称为FN与价值SAM，

350
00:18:26,210 --> 00:18:29,430
其次是一个逗号，
话说到下一个条目。

351
00:18:29,430 --> 00:18:33,560
然后，一个叫LN关键，
有一个绿色的价值，

352
00:18:33,560 --> 00:18:35,840
其次是一个逗号，
其次是“印”

353
00:18:35,840 --> 00:18:43,209
这将有一个函数值
那会做这行的代码。

354
00:18:43,209 --> 00:18:45,500
让我们退后一步，
解开什么是怎么回事。

355
00:18:45,500 --> 00:18:47,280
所以这是一个有点复杂，
和我们看到新的东西

356
00:18:47,280 --> 00:18:48,071
首次。

357
00:18:48,071 --> 00:18:51,190

358
00:18:51,190 --> 00:18:55,065
而“这个”关键字是新事物
我们看到在这里，这是什么呢

359
00:18:55,065 --> 00:19:00,540
是，是指当前
对象范围，对不对？

360
00:19:00,540 --> 00:19:03,990
所以，当我们说，这
点回来的路上

361
00:19:03,990 --> 00:19:08,140
这整个object--
当我们做this.fn，

362
00:19:08,140 --> 00:19:11,990
我们将一路回去
这个对象，到FN值

363
00:19:11,990 --> 00:19:16,471
并获得SAM，把它所有的方式
回来了，把它贴在这里，然后继续前进。

364
00:19:16,471 --> 00:19:19,838
>> 听众：因此，与检索，是
因为参数的做完

365
00:19:19,838 --> 00:19:20,621
定义？

366
00:19:20,621 --> 00:19:23,870
SAM格林：所以现在的问题是，是
因为参数的检索完成

367
00:19:23,870 --> 00:19:24,727
定义？

368
00:19:24,727 --> 00:19:25,435
是的，绝对。

369
00:19:25,435 --> 00:19:29,660

370
00:19:29,660 --> 00:19:32,470
这是怎么回事在这里发生的是，
这点说给JavaScript，

371
00:19:32,470 --> 00:19:39,990
好吧，我得到一些价值
从我自己这个对象。

372
00:19:39,990 --> 00:19:46,375
然后它会寻找一个条目
所谓的FN，如果它发现它，

373
00:19:46,375 --> 00:19:48,470
它会返回value--是这样，它的SAM。

374
00:19:48,470 --> 00:19:51,540
但是，我也可以键入
这是不是在这里定义的东西，

375
00:19:51,540 --> 00:19:54,090
然后它只是
返回undefined--这

376
00:19:54,090 --> 00:19:58,250
是一个东西，JavaScript可以
这样做，它也有一些好处，

377
00:19:58,250 --> 00:20:03,190
但它的also--如果你犯了一个错字，
它会导致奇怪的错误。

378
00:20:03,190 --> 00:20:05,617
因此，它会只是试图找到
不管你告诉它找到

379
00:20:05,617 --> 00:20:07,700
而且它不会
抱怨，如果没有找到它。

380
00:20:07,700 --> 00:20:11,390
它只想说，我没有
找到它，然后继续前进。

381
00:20:11,390 --> 00:20:17,581
因此，这将是不确定的，
加空白，再加上姓氏。

382
00:20:17,581 --> 00:20:18,080
是啊。

383
00:20:18,080 --> 00:20:21,070
然后我们可以看到，如果我们
可以再下去access--

384
00:20:21,070 --> 00:20:25,450
我们呼吁tf.print（）括号。

385
00:20:25,450 --> 00:20:30,000
这将调用打印
不带参数的功能，对不对？

386
00:20:30,000 --> 00:20:34,490
但是，如果我们刚才说tf.print（）
分号，没有括号，

387
00:20:34,490 --> 00:20:37,480
所有可能做的就是拉
从该值的功能，

388
00:20:37,480 --> 00:20:40,609
但实际上没有把它称为。

389
00:20:40,609 --> 00:20:41,162
凉。

390
00:20:41,162 --> 00:20:42,870
休·扎布里斯基：宜
我们做一个对象？

391
00:20:42,870 --> 00:20:44,161
SAM格林：是的，让我们做到这一点。

392
00:20:44,161 --> 00:20:48,750
因此，我可以将这个
例如控制台。

393
00:20:48,750 --> 00:20:51,380

394
00:20:51,380 --> 00:20:55,466
我们可以想像，我有一个对象。

395
00:20:55,466 --> 00:21:03,026

396
00:21:03,026 --> 00:21:04,150
因此，这是一个简单的对象。

397
00:21:04,150 --> 00:21:06,910

398
00:21:06,910 --> 00:21:11,050
这是一个对象，包含两个
有两个键的值，两个关键的价值

399
00:21:11,050 --> 00:21:12,710
对。

400
00:21:12,710 --> 00:21:21,850
所以，我就可以访问存储的价值
这个对象做x.x1内，

401
00:21:21,850 --> 00:21:23,400
例如，我也得到1回。

402
00:21:23,400 --> 00:21:29,590
同样，x.x2，拿到值回。

403
00:21:29,590 --> 00:21:33,330
>> 而现在的很酷的事情是，我可以
实际上添加的东西到该对象

404
00:21:33,330 --> 00:21:34,316
我已经创造了它之后。

405
00:21:34,316 --> 00:21:36,315
所以你可以想象，让我们
说我有一个功能。

406
00:21:36,315 --> 00:21:44,430

407
00:21:44,430 --> 00:21:46,352
>> 休·扎布里斯基：你
要做按住Shift-Enter键。

408
00:21:46,352 --> 00:21:47,643
>> SAM格林：哦，这很烦人。

409
00:21:47,643 --> 00:22:02,460

410
00:22:02,460 --> 00:22:04,324
那有什么不一样？

411
00:22:04,324 --> 00:22:04,824
哦。

412
00:22:04,824 --> 00:22:07,532

413
00:22:07,532 --> 00:22:08,691
开始了。

414
00:22:08,691 --> 00:22:09,190
凉。

415
00:22:09,190 --> 00:22:12,840
>> 所以，我刚才创建
这个函数f，即

416
00:22:12,840 --> 00:22:17,590
是要去到目前
对象和打印this.x1。

417
00:22:17,590 --> 00:22:20,330
所以，如果我只是调用F通过
本身，没有什么是怎么回事

418
00:22:20,330 --> 00:22:26,970
发生的，正确的，因为没有X1
场中它指的是对象。

419
00:22:26,970 --> 00:22:39,710
但是，如果我说，x.f = F，然后我
调用x.f（），我要拿回1。

420
00:22:39,710 --> 00:22:42,990

421
00:22:42,990 --> 00:22:46,530
也就是说f函数是现在
与对象x关联，

422
00:22:46,530 --> 00:22:51,800
其中有一个关键称为X1
用值1相关联的，

423
00:22:51,800 --> 00:22:54,570
所以当我们调用this.x1，它的
要查找的寻找

424
00:22:54,570 --> 00:22:56,450
和能够打印的值出去。

425
00:22:56,450 --> 00:22:58,700
所以，这只是一个例子
那种疯狂的事情

426
00:22:58,700 --> 00:23:01,190
您可以在JavaScript对象做。

427
00:23:01,190 --> 00:23:03,870

428
00:23:03,870 --> 00:23:07,560
>> 因此，该版本是
通用版，意义

429
00:23:07,560 --> 00:23:13,780
我们已经创建了使用该对象
括号notation--括号符号，

430
00:23:13,780 --> 00:23:16,880
rather--这就是
如果我们只是想方便

431
00:23:16,880 --> 00:23:21,440
特定对象的一个​​实例，但
如果我们希望有一个以上的是什么

432
00:23:21,440 --> 00:23:22,210
的同一种？

433
00:23:22,210 --> 00:23:24,440
和这个问题的答案
问题是，有事情

434
00:23:24,440 --> 00:23:26,760
所谓的类在JavaScript中也是如此。

435
00:23:26,760 --> 00:23:31,470

436
00:23:31,470 --> 00:23:36,420
我们可以创建一个函数，
做某种形式的初始化

437
00:23:36,420 --> 00:23:41,690
为异物，
我们会说，喜欢，

438
00:23:41,690 --> 00:23:44,550
我的分类 - 这样的名字
可重复使用的object--的

439
00:23:44,550 --> 00:23:47,100
等于功能设置起来。

440
00:23:47,100 --> 00:23:52,280
那么，这将是等同
要创造一个对象，

441
00:23:52,280 --> 00:23:55,930
将只是喜欢，
大括号，STR，结肠，

442
00:23:55,930 --> 00:23:59,630
这是一个字符串，
分号，大括号。

443
00:23:59,630 --> 00:24:01,880
这将是通用
我们初始化对象，

444
00:24:01,880 --> 00:24:06,380
与一个区别在于对
下一行，我们创建了一个原型，这

445
00:24:06,380 --> 00:24:11,190
意味着它是一个默认的键
我们加入到我们的对象，

446
00:24:11,190 --> 00:24:13,970
在这里有列出的值。

447
00:24:13,970 --> 00:24:20,570
意思是说，当我创建一个新的
此MyClass的实例对象，

448
00:24:20,570 --> 00:24:27,440
这将有预建的内
它的值称为海峡和另一个值

449
00:24:27,440 --> 00:24:32,418
叫myPrint，这是
将是一个函数。

450
00:24:32,418 --> 00:24:32,918
真棒。

451
00:24:32,918 --> 00:24:37,410

452
00:24:37,410 --> 00:24:37,990
>> 大。

453
00:24:37,990 --> 00:24:40,710
因此，最后一件事
说关于JavaScript

454
00:24:40,710 --> 00:24:46,430
是，它是什么真正有用的
被称为异步操作。

455
00:24:46,430 --> 00:24:52,500
异步意味着我们
可以等待一些操作

456
00:24:52,500 --> 00:24:57,870
完成之前，我们将
，但在我们等待继续前进

457
00:24:57,870 --> 00:24:59,690
再有事情发生以后。

458
00:24:59,690 --> 00:25:03,480
而我的意思是，你
可以想象的情况下

459
00:25:03,480 --> 00:25:06,850
你发送一个请求
某些网络服务器的地方，

460
00:25:06,850 --> 00:25:09,670
并且它会送你回
一些数据大块，对不对？

461
00:25:09,670 --> 00:25:13,320
并且用户可以等待在
同时要做到这一点，

462
00:25:13,320 --> 00:25:15,200
并没有什么可以
事情在那个时候。

463
00:25:15,200 --> 00:25:18,110
但是，这不是一个伟大的设计，对吧？

464
00:25:18,110 --> 00:25:20,214
你不想在网页冻结。

465
00:25:20,214 --> 00:25:22,380
如果什么用户想要
点击下拉菜单？

466
00:25:22,380 --> 00:25:24,870
这是不是一个伟大的设计模式。

467
00:25:24,870 --> 00:25:29,290
相反，基本上是什么
JavaScript本身是说，

468
00:25:29,290 --> 00:25:31,870
OK，异步执行此操作。

469
00:25:31,870 --> 00:25:36,520
于是想，等的背景下，
然后当操作完成后，

470
00:25:36,520 --> 00:25:39,420
调用回调function--
调用一些功能，

471
00:25:39,420 --> 00:25:43,800
做一些action--信号的
操作我们在等待结束

472
00:25:43,800 --> 00:25:45,520
结束了。

473
00:25:45,520 --> 00:25:51,240
这就是超级强大的理由是，
我们可以做一些事情，传递参数，

474
00:25:51,240 --> 00:25:54,440
做一些事情，然后等待
事情发生。

475
00:25:54,440 --> 00:25:58,970
然后，一旦某事
完成后，我们可以调用一个回调。

476
00:25:58,970 --> 00:26:03,300
这是非常方便的，因为它可以让
我们做的事情与网络音频API，

477
00:26:03,300 --> 00:26:07,490
例如，像负载的
从远程服务器的音频文件

478
00:26:07,490 --> 00:26:11,660
而不必等待
整个音频文件被加载，

479
00:26:11,660 --> 00:26:14,440
这将是真的
糟糕的用户体验。

480
00:26:14,440 --> 00:26:17,080
凉。

481
00:26:17,080 --> 00:26:19,460
>> 最后夫妇注意到有关
调试，因为这

482
00:26:19,460 --> 00:26:23,682
是你不得不做的事
作为项目的一部分，有保证。

483
00:26:23,682 --> 00:26:25,140
我提到的JavaScript控制台。

484
00:26:25,140 --> 00:26:27,550
这是一个非常有用的功能
所有现代浏览器，

485
00:26:27,550 --> 00:26:30,300
我们真的希望您积极地
舒适的使用您的控制台，

486
00:26:30,300 --> 00:26:33,660
如果你想获得擅长的JavaScript。

487
00:26:33,660 --> 00:26:36,320
这是超级方便的
调试，但它也

488
00:26:36,320 --> 00:26:39,440
为搞清楚真正有用
如何使用API​​。

489
00:26:39,440 --> 00:26:41,950
它允许真
简单的实验

490
00:26:41,950 --> 00:26:45,910
无需键入一些
代码，然后编译它。

491
00:26:45,910 --> 00:26:47,500
你不必做的所有这些步骤。

492
00:26:47,500 --> 00:26:49,619
你可以只写
一些代码成一条线，

493
00:26:49,619 --> 00:26:52,410
然后得到即时反馈
不论该行代码

494
00:26:52,410 --> 00:26:55,230
worked--非常方便。

495
00:26:55,230 --> 00:26:59,760
>> 而且，只是一个技术note--
JavaScript控制台是一个例子

496
00:26:59,760 --> 00:27:05,680
一个REPL--所以这是R-E-P-L，REPL的，
它代表读，评估，

497
00:27:05,680 --> 00:27:06,180
打印循环。

498
00:27:06,180 --> 00:27:09,100

499
00:27:09,100 --> 00:27:12,120
你要输入一些东西
在，它会读取你键入的，

500
00:27:12,120 --> 00:27:17,280
它会评估它，它会打印
输出，然后它会重新开始。

501
00:27:17,280 --> 00:27:22,056
这可以让你快速进入
圈迭代，这是真的很酷。

502
00:27:22,056 --> 00:27:25,150

503
00:27:25,150 --> 00:27:28,930
>> 我想真正的最后note--这
是实际的最后一个音符，是的。

504
00:27:28,930 --> 00:27:30,780
我们如何真正使用JavaScript？

505
00:27:30,780 --> 00:27:34,040
因此，首先，我们可以导入
使用脚本标记它

506
00:27:34,040 --> 00:27:39,500
在一个HTML的顶部或底部file--
HTML文件的内的任意位置，

507
00:27:39,500 --> 00:27:40,440
真。

508
00:27:40,440 --> 00:27:47,390
而script标签内，也有
两个子方式进口的JavaScript。

509
00:27:47,390 --> 00:27:51,370
第一个是由具有
独立的JavaScript文件

510
00:27:51,370 --> 00:27:58,010
我们进口的全部内容，或
由具有像脚本代码的区域

511
00:27:58,010 --> 00:28:00,290
开始，然后
反斜线脚本结束。

512
00:28:00,290 --> 00:28:02,620
然后，我们只是写
JavaScript的HTML文件中。

513
00:28:02,620 --> 00:28:03,790
这些都是两种方式。

514
00:28:03,790 --> 00:28:05,165
你不能HTML里面有它。

515
00:28:05,165 --> 00:28:06,502

516
00:28:06,502 --> 00:28:08,126
听众：是其中一个比另一个更好呢？

517
00:28:08,126 --> 00:28:10,542
SAM格林：问题是，
比其它更好。

518
00:28:10,542 --> 00:28:18,306
所以，是的，作为一个编码风格的做法，
而且它像一个设计实践。

519
00:28:18,306 --> 00:28:20,180
有两个原因
为什么它可能会更好。

520
00:28:20,180 --> 00:28:23,934
第一个是，它使你的代码
很多更具可读性，如果所有的HTML的

521
00:28:23,934 --> 00:28:27,100
是在一个地方，所有的CSS是在
另外一个地方，所有的JavaScript

522
00:28:27,100 --> 00:28:28,420
处于第三位。

523
00:28:28,420 --> 00:28:28,920
对？

524
00:28:28,920 --> 00:28:32,370
我认为，我们应该已经讲过
关于它在sections--像CSS--什么

525
00:28:32,370 --> 00:28:35,220
这is--和它去
常在另一个文件。

526
00:28:35,220 --> 00:28:37,090
因此，相似类型的概念在这里。

527
00:28:37,090 --> 00:28:42,410
你也可以想像的JavaScript
将在一个以上的重复使用

528
00:28:42,410 --> 00:28:47,350
HTML页，或者一个
许多HTML页面，

529
00:28:47,350 --> 00:28:49,340
并具有JavaScript的
重构为一个

530
00:28:49,340 --> 00:28:51,950
文件可以导入
一成多的地方

531
00:28:51,950 --> 00:28:54,570
允许代码是
这样更易于维护。

532
00:28:54,570 --> 00:28:57,930
你可以想象使一个
改变给JavaScript

533
00:28:57,930 --> 00:29:00,070
而不必更改它
在100种不同的文件。

534
00:29:00,070 --> 00:29:04,070
相反，我们可以直接改变它
在一个，这是道路更加强大。

535
00:29:04,070 --> 00:29:05,420
难道我回答你的问题？

536
00:29:05,420 --> 00:29:07,950
凉。

537
00:29:07,950 --> 00:29:10,830
>> 我们还可以输入到调音台，
正如我们之前提到过。

538
00:29:10,830 --> 00:29:15,070
再次，最后一个note--
网络音频是内置的，

539
00:29:15,070 --> 00:29:16,978
不需要加载任何东西。

540
00:29:16,978 --> 00:29:17,478
凉。

541
00:29:17,478 --> 00:29:20,519
是否有任何问题，你有没有
关于JavaScript的任何问题，

542
00:29:20,519 --> 00:29:21,930
之前，我们继续前进？

543
00:29:21,930 --> 00:29:24,286
>> 听众：[听不清]

544
00:29:24,286 --> 00:29:25,410
SAM格林：好吧，冷静。

545
00:29:25,410 --> 00:29:27,200
所以，现在他要谈的API。

546
00:29:27,200 --> 00:29:28,490
>> 休·扎布里斯基：酷。

547
00:29:28,490 --> 00:29:28,990
谢谢，山姆。

548
00:29:28,990 --> 00:29:30,184
>> SAM格林：当然。

549
00:29:30,184 --> 00:29:32,600
休·扎布里斯基：真棒，所以
我们将通过JavaScript前进。

550
00:29:32,600 --> 00:29:35,350
因此，我们已经谈了一些
JavaScript的要领，

551
00:29:35,350 --> 00:29:41,105
而这些都是变量，函数，
对象，函数变量，

552
00:29:41,105 --> 00:29:41,980
异步加载。

553
00:29:41,980 --> 00:29:46,100
这些都是所有的东西，你会
看，所使用的网络音频。

554
00:29:46,100 --> 00:29:49,230
因此，我们要好好谈谈
关于它首先在一个较高的水平。

555
00:29:49,230 --> 00:29:52,120
>> 这是一个API，所以它的东西
这是内置，如山姆说，

556
00:29:52,120 --> 00:29:57,010
对进入的JavaScript
您在控制台中使用。

557
00:29:57,010 --> 00:30:01,020
它实际上就像C ++代码
这是真的内置Chrome浏览器

558
00:30:01,020 --> 00:30:04,470
和Firefox，而所有这些浏览器。

559
00:30:04,470 --> 00:30:07,060
因此，与网络的主要思路
音频是，你有

560
00:30:07,060 --> 00:30:09,440
这种管道音频的，对不对？

561
00:30:09,440 --> 00:30:13,670
所以你的音频数据
进来以某种形式。

562
00:30:13,670 --> 00:30:16,690
>> 有一种三个主要forms--
你有振荡器，它

563
00:30:16,690 --> 00:30:21,340
创建一个正弦波，余弦波，
我们将看到如何工作的。

564
00:30:21,340 --> 00:30:23,890
另一种非常常见的一种，
当然，是一个MP3。

565
00:30:23,890 --> 00:30:25,810
因此，也许你开始
一首歌曲，然后你

566
00:30:25,810 --> 00:30:28,320
想要做一些过滤
该输出

567
00:30:28,320 --> 00:30:30,605
that--这可能是一个可能来源。

568
00:30:30,605 --> 00:30:32,480
然后一个非常酷
一个是麦克风。

569
00:30:32,480 --> 00:30:37,230
所以，你可以使用一些很
在JavaScript的基本通话费

570
00:30:37,230 --> 00:30:39,440
以访问的
麦克风，并且因此，如果您

571
00:30:39,440 --> 00:30:42,870
想使一个应用程序
就像一个音调检测，

572
00:30:42,870 --> 00:30:45,290
例如，取入
你的声音和数字出

573
00:30:45,290 --> 00:30:47,740
在pitch--非常简单的方法来表示。

574
00:30:47,740 --> 00:30:50,730
只是一种可以读取它
在，计算出的频率，

575
00:30:50,730 --> 00:30:52,250
然后输出一个数字。

576
00:30:52,250 --> 00:30:56,080
所以我们会看到如何工作的，以及。

577
00:30:56,080 --> 00:30:59,430
>> 目的地是基本上
其中音频数据被输出。

578
00:30:59,430 --> 00:31:02,890
因此，总的来说，这是像
您的笔记本音箱。

579
00:31:02,890 --> 00:31:05,610
其他选项都喜欢
一个ScriptProcessorNode--

580
00:31:05,610 --> 00:31:07,990
我们会在一个节点
second--但基本上，

581
00:31:07,990 --> 00:31:11,939
要么你把声音了
通过计算机通过扬声器，

582
00:31:11,939 --> 00:31:14,730
或者你是那种记录，所以
你存储为音频数据。

583
00:31:14,730 --> 00:31:18,980
因此，如果有人创建也许
音乐在你的应用程序，然后

584
00:31:18,980 --> 00:31:22,410
你想记录这一点，也许像
它出口到SoundCloud，为example--

585
00:31:22,410 --> 00:31:25,281
这将是做到这一点的方法之一。

586
00:31:25,281 --> 00:31:27,030
所有的有趣的东西，
我们将谈论，

587
00:31:27,030 --> 00:31:29,950
这两个点之间发生，
其中我们在音乐加载

588
00:31:29,950 --> 00:31:31,410
然后输出它。

589
00:31:31,410 --> 00:31:36,660
>> 所以，我要谈的五个
音频制作的第二阶段。

590
00:31:36,660 --> 00:31:38,950
我们有这个东西叫做
一个AudioContext，这

591
00:31:38,950 --> 00:31:41,580
这是我们在这里看到的小包装。

592
00:31:41,580 --> 00:31:49,980
基本上什么AudioContext is--如果我们
去JavaScript控制台现在，

593
00:31:49,980 --> 00:31:52,740
我们可以立即创建一个。

594
00:31:52,740 --> 00:31:54,040
REPL的只是一个例子，对不对？

595
00:31:54,040 --> 00:31:57,880
我们正在看，
评估和它打印。

596
00:31:57,880 --> 00:32:00,260
>> AudioContext是一个全球性的状态。

597
00:32:00,260 --> 00:32:05,500
这是一个结构，它是一个对象
在这里，它使信息

598
00:32:05,500 --> 00:32:09,960
的事情，是怎么回事
有关音频屏幕。

599
00:32:09,960 --> 00:32:15,220
一个例子是当前时间。

600
00:32:15,220 --> 00:32:18,910
这告诉你的号码
几秒钟，非常精确，

601
00:32:18,910 --> 00:32:20,890
由于网页加载。

602
00:32:20,890 --> 00:32:24,110
所以这是一个非常有用的
小属性，您可以使用。

603
00:32:24,110 --> 00:32:27,898
它的读取only--我觉得其实
你可以尝试设置一个值。

604
00:32:27,898 --> 00:32:29,856
它会告诉你设置它，
然后，如果你打印出来

605
00:32:29,856 --> 00:32:31,439
again--它其实并没有那么回事。

606
00:32:31,439 --> 00:32:34,472
所以有只读
性能在JavaScript中。

607
00:32:34,472 --> 00:32:36,430
这是，如果真的有用
有种你同步

608
00:32:36,430 --> 00:32:38,610
很多不同的
信息，当你

609
00:32:38,610 --> 00:32:41,280
种播放不同的声音。

610
00:32:41,280 --> 00:32:43,630
>> 另一种真正有用的
是上下文目的地。

611
00:32:43,630 --> 00:32:46,587

612
00:32:46,587 --> 00:32:49,670
肯定地说，如果你有兴趣，可以
在你自己的控制台右侧尝试这种

613
00:32:49,670 --> 00:32:50,980
现在。

614
00:32:50,980 --> 00:32:53,150
所以这是一个AudioDestinationNode。

615
00:32:53,150 --> 00:32:56,480
基本上，这是什么说的是，
哪里是输出去？

616
00:32:56,480 --> 00:32:59,590
因此，这里有两个真正的选择。

617
00:32:59,590 --> 00:33:01,940
通常默认
只是你的音箱，

618
00:33:01,940 --> 00:33:05,150
所以AudioDestinationNode
基本上只是说：

619
00:33:05,150 --> 00:33:09,240
有零输出到声音
进来，发送到扬声器。

620
00:33:09,240 --> 00:33:12,050
所以一般情况下，你不
有与玩。

621
00:33:12,050 --> 00:33:15,720
如果你有兴趣在实际使用
的ScriptProcessorNode用于记录，

622
00:33:15,720 --> 00:33:16,990
肯定拍我的
电子邮件后来因为这是

623
00:33:16,990 --> 00:33:18,330
稍微复杂一点。

624
00:33:18,330 --> 00:33:21,590
但是总体来说，你只是种
的输出声音以某种形式。

625
00:33:21,590 --> 00:33:24,347
太酷了，我们跳回到这里。

626
00:33:24,347 --> 00:33:25,180
听众：我很抱歉。

627
00:33:25,180 --> 00:33:26,054
休·扎布里斯基：是的。

628
00:33:26,054 --> 00:33:28,770
听众：我知道你说说话
你以后有关记录。

629
00:33:28,770 --> 00:33:31,550
你能接口与Pro Tools？

630
00:33:31,550 --> 00:33:33,120
>> 休·扎布里斯基：与Pro Tools？

631
00:33:33,120 --> 00:33:35,260
让我们来看看。

632
00:33:35,260 --> 00:33:37,220
我不认为如此。

633
00:33:37,220 --> 00:33:41,670
因此，客户端之间去，
这是JavaScript

634
00:33:41,670 --> 00:33:44,310
控制台和您的实际
计算机，一般是

635
00:33:44,310 --> 00:33:46,490
东西是一种
的禁区，如果你

636
00:33:46,490 --> 00:33:52,320
会的，实物的the--性质
它是一种设计的东西，

637
00:33:52,320 --> 00:33:57,770
但你尽量保持浏览器的独立
从用户的实际的计算机。

638
00:33:57,770 --> 00:34:02,310
一般情况下，唯一你能
访问是麦克风或照相机。

639
00:34:02,310 --> 00:34:04,730
你不能够，我
不要以为，使用专业工具。

640
00:34:04,730 --> 00:34:07,480
但是，如果您创建
在Pro Tools轨道，

641
00:34:07,480 --> 00:34:12,710
出口，您还可以加载
在这里，过滤它，例如，

642
00:34:12,710 --> 00:34:16,820
过程，并记录到一个
音频Destination--或no--一球

643
00:34:16,820 --> 00:34:17,870
处理器节点。

644
00:34:17,870 --> 00:34:20,730
然后从那里，你可以
导出到SoundCloud，你

645
00:34:20,730 --> 00:34:25,320
可以通过电子邮件发送，或
无论你想从那里。

646
00:34:25,320 --> 00:34:31,159
>> 但有一种轻微的障碍
让音乐在您的计算机上的

647
00:34:31,159 --> 00:34:33,050
，使在线音乐。

648
00:34:33,050 --> 00:34:37,940
>> SAM格林：这就是
不是唯一的，以此API。

649
00:34:37,940 --> 00:34:44,060
这是Chrome浏览器的安全功能，和
我认为，所有其他现代的浏览器。

650
00:34:44,060 --> 00:34:45,860
浏览器是自包含的。

651
00:34:45,860 --> 00:34:50,980
因此，例如，一个网页不能
使用JavaScript把声音

652
00:34:50,980 --> 00:34:54,190
关于您的扬声器，例如。

653
00:34:54,190 --> 00:34:58,120
或者无法关闭计算机。

654
00:34:58,120 --> 00:35:01,530
而且没有中间点
这两件事情之间，正确的，

655
00:35:01,530 --> 00:35:05,960
所以要么你有一个
完全抽象，

656
00:35:05,960 --> 00:35:10,050
或者你打开
让安全漏洞

657
00:35:10,050 --> 00:35:14,440
心怀不轨程序员做
任何他们想要与你的笔记本电脑。

658
00:35:14,440 --> 00:35:18,104
这就是为什么Chrome是自包含的。

659
00:35:18,104 --> 00:35:19,310
>> 休·扎布里斯基：是的。

660
00:35:19,310 --> 00:35:20,840
那有意义吗？

661
00:35:20,840 --> 00:35:21,369
冷静，冷静。

662
00:35:21,369 --> 00:35:23,160
我正要
示出的一个的例​​子。

663
00:35:23,160 --> 00:35:25,118
这是相当多的
至于你，无论从

664
00:35:25,118 --> 00:35:26,950
的访问用户的计算机。

665
00:35:26,950 --> 00:35:30,180
如果您有一个USB键盘插上，
你可以使用一种叫做网络

666
00:35:30,180 --> 00:35:32,180
MIDI API，我们不会哪
真正谈论在这里，

667
00:35:32,180 --> 00:35:36,330
但是这又是一个API，它是
再建成至少Chrome--，

668
00:35:36,330 --> 00:35:41,570
这就是为什么我们爱Chrome--
我认为Firefox或Safari浏览器，

669
00:35:41,570 --> 00:35:44,300
这是一件容易的事情
google--不同的浏览器有

670
00:35:44,300 --> 00:35:46,917
针对这不同的支持
API的他们已经实施。

671
00:35:46,917 --> 00:35:49,875
但是，如果你想在键盘插头
并与信息化工作，

672
00:35:49,875 --> 00:35:52,850
那种送键盘
转移到计算机的信息

673
00:35:52,850 --> 00:35:57,620
然后使用该网络，这个API
在这里你会工作的。

674
00:35:57,620 --> 00:35:58,150
>> 凉。

675
00:35:58,150 --> 00:35:58,710
好。

676
00:35:58,710 --> 00:36:01,320
因此，快速移动就在这里。

677
00:36:01,320 --> 00:36:03,310
我们如何做的时间呢？

678
00:36:03,310 --> 00:36:04,210
>> 扬声器1：约15。

679
00:36:04,210 --> 00:36:05,543
>> 休·扎布里斯基：15分钟离开？

680
00:36:05,543 --> 00:36:06,160
嗯不错。

681
00:36:06,160 --> 00:36:08,170
因此，我们将在这里跑在前面。

682
00:36:08,170 --> 00:36:13,500
>> 所以基本上，主要点
这一思想作为管道

683
00:36:13,500 --> 00:36:16,430
的是，在管道中的每个步骤
是一系列的音频节点。

684
00:36:16,430 --> 00:36:19,284

685
00:36:19,284 --> 00:36:20,950
我们的源代码，让我们说，是一个振荡器。

686
00:36:20,950 --> 00:36:23,380
我们需要创建一个振荡器节点。

687
00:36:23,380 --> 00:36:25,690
而这仅仅是一种
小function--的

688
00:36:25,690 --> 00:36:30,460
而且它们都基于了
这里的音频上下文。

689
00:36:30,460 --> 00:36:32,885
>> 听众：当它说
振荡器，意味着什么

690
00:36:32,885 --> 00:36:37,250
它实际上是从字面上去
两个不同的磁极来回？

691
00:36:37,250 --> 00:36:41,170
>> 休·扎布里斯基：不，这就像
的数字表示。

692
00:36:41,170 --> 00:36:42,740
它实际上是用C ++实现的。

693
00:36:42,740 --> 00:36:46,460
我居然不知道规格
它是如何实际上实现的，

694
00:36:46,460 --> 00:36:48,500
但是这一切正在为二进制数据。

695
00:36:48,500 --> 00:36:51,260

696
00:36:51,260 --> 00:36:52,370
事实上，是的。

697
00:36:52,370 --> 00:36:53,950
这将是说，我可以
实际上，如果你有兴趣，

698
00:36:53,950 --> 00:36:56,533
我可以给你多一点
有关如何波形信息

699
00:36:56,533 --> 00:37:00,181
被保持具有数字格式。

700
00:37:00,181 --> 00:37:00,680
嗯不错。

701
00:37:00,680 --> 00:37:03,120
>> 因此，我们产生像正弦波音调
波浪或类似的东西，也许

702
00:37:03,120 --> 00:37:04,190
440赫兹。

703
00:37:04,190 --> 00:37:05,830
我们创建了一个振荡器。

704
00:37:05,830 --> 00:37:09,180
如果我们要设置音量，我们
连接任何一个GainNode，

705
00:37:09,180 --> 00:37:12,500
这是我们可以做.creategain。

706
00:37:12,500 --> 00:37:14,250
这台音量。

707
00:37:14,250 --> 00:37:17,820
您可以传递到任何
其他选项 - 好，

708
00:37:17,820 --> 00:37:20,300
所以音频缓冲器源
节点下，您可能

709
00:37:20,300 --> 00:37:23,660
存储你已经装入了一个MP3。

710
00:37:23,660 --> 00:37:27,670
>> 双二阶滤波器进行滤波，如果
要采取一切的基础出

711
00:37:27,670 --> 00:37:29,630
一首歌，或者类似的东西。

712
00:37:29,630 --> 00:37:32,450
上帝保佑你想利用
基地出一首歌。

713
00:37:32,450 --> 00:37:36,980
和AudioDestination节点是，再次，
喜欢在那里我们的定稿是。

714
00:37:36,980 --> 00:37:39,980
如果你在看到曾经兴趣
所有不同的可能的选项，

715
00:37:39,980 --> 00:37:45,190
刚去的标签，让
自动完成上来。

716
00:37:45,190 --> 00:37:48,690
而如果你创建，你会看到所有的
不同的东西，你可以创建。

717
00:37:48,690 --> 00:37:50,398
您可以创建动态
脚本处理器，

718
00:37:50,398 --> 00:37:52,940
我甚至不知道那是什么
是，用于混合通道的合并

719
00:37:52,940 --> 00:37:55,930
和信道分离器和所有。

720
00:37:55,930 --> 00:37:56,430
凉。

721
00:37:56,430 --> 00:37:59,560

722
00:37:59,560 --> 00:38:01,390
>> 所以，这只是一个
例如一个管道。

723
00:38:01,390 --> 00:38:03,580
因此，我们有三个来源进入。

724
00:38:03,580 --> 00:38:06,830
也许这些都是波形，
也许这些都是MP3格式。

725
00:38:06,830 --> 00:38:08,740
一个人的经历
过滤器，另一个人的

726
00:38:08,740 --> 00:38:12,404
越来越扭曲的另一个
一个人的平移左右。

727
00:38:12,404 --> 00:38:15,320
你可以做各种各样的事情，
他们都获得混合在了一起，

728
00:38:15,320 --> 00:38:18,880
然后走出来的声音
在最后，作为目标。

729
00:38:18,880 --> 00:38:22,720
这是什么更多的例子
复杂的网络音频代码如下所示。

730
00:38:22,720 --> 00:38:26,720
你创造的所有这些
不同的对象右这里 - 

731
00:38:26,720 --> 00:38:27,706
我不知道这一点。

732
00:38:27,706 --> 00:38:29,120
不，它不进行放大。

733
00:38:29,120 --> 00:38:29,620
好。

734
00:38:29,620 --> 00:38:31,257
>> SAM格林：你做控制，向上卷动。

735
00:38:31,257 --> 00:38:32,590
休·扎布里斯基：控制Scroll--

736
00:38:32,590 --> 00:38:33,000
SAM格林：不，不。

737
00:38:33,000 --> 00:38:33,500
控制 - 

738
00:38:33,500 --> 00:38:36,540

739
00:38:36,540 --> 00:38:38,140
>> 休·扎布里斯基：哦，控制，滚动？

740
00:38:38,140 --> 00:38:38,780
哦，疑难杂症。

741
00:38:38,780 --> 00:38:41,480
是啊。

742
00:38:41,480 --> 00:38:42,240
哇，没了，没了。

743
00:38:42,240 --> 00:38:42,740
好。

744
00:38:42,740 --> 00:38:46,090
我不会那么做的。

745
00:38:46,090 --> 00:38:48,300
>> 所以是的，在这第一
在此部分中，您将看到

746
00:38:48,300 --> 00:38:52,720
我们正在创建所有这些不同的
结出的背景下。

747
00:38:52,720 --> 00:38:54,980
我们只是拼凑他们
一起在第二部分

748
00:38:54,980 --> 00:38:56,980
通过该功能被称为连接。

749
00:38:56,980 --> 00:38:58,830
这是一个非常关键的
功能的网络音频。

750
00:38:58,830 --> 00:39:01,930
它只是意味着一旦你做到
一些与在一个节点的声音，

751
00:39:01,930 --> 00:39:03,705
其传递到下一个节点。

752
00:39:03,705 --> 00:39:05,830
因此，我们有源，它
连接到分析装置，

753
00:39:05,830 --> 00:39:09,140
分析仪做一些事吧，
它去失真，等等，

754
00:39:09,140 --> 00:39:12,725
及到目的地
底部就在这里。

755
00:39:12,725 --> 00:39:13,225
凉。

756
00:39:13,225 --> 00:39:14,640
好了，我们会继续前进。

757
00:39:14,640 --> 00:39:17,180
>> 再次pipeline--，这些
是最常见的管道，

758
00:39:17,180 --> 00:39:21,300
所以我们谈论这些事情像
失真，平移，这一切的东西。

759
00:39:21,300 --> 00:39:24,280
如果你真的有兴趣
在使用的东西Pro Tools中，

760
00:39:24,280 --> 00:39:25,820
这些可能是你的兴趣。

761
00:39:25,820 --> 00:39:27,740
如果没有，也许你只是
要播放的声音，

762
00:39:27,740 --> 00:39:29,990
或者你只是想
上设置声音的音量。

763
00:39:29,990 --> 00:39:35,270
这些都是最常见的两种排序
在音频制作流程。

764
00:39:35,270 --> 00:39:38,640
>> 此外，该方法可以把它
作为一个oscillator--所以，让我们

765
00:39:38,640 --> 00:39:42,460
做的是，试玩就在这里。

766
00:39:42,460 --> 00:39:47,090

767
00:39:47,090 --> 00:39:52,225
因此，我们要创建一个
在这里简单的音频范围内，

768
00:39:52,225 --> 00:39:54,350
从我们要去
打造我们的振荡器。

769
00:39:54,350 --> 00:39:58,620
所以这是，再次，我们只是
要调用Create振荡器。

770
00:39:58,620 --> 00:40:07,030
我们将在设定的频率
即，440赫兹，大家的喜爱。

771
00:40:07,030 --> 00:40:13,290
然后，我们连接的目的地
point--这是扬声器，所以

772
00:40:13,290 --> 00:40:15,750
上下文目的地。

773
00:40:15,750 --> 00:40:21,400
最后，我们只是说，开始零
从现在开始秒，我们有健全的？

774
00:40:21,400 --> 00:40:22,400
>> [铃声]

775
00:40:22,400 --> 00:40:24,980
>> 休·扎布里斯基：在这里，我们走了。

776
00:40:24,980 --> 00:40:25,940
这只是一个正弦波。

777
00:40:25,940 --> 00:40:26,440
嗯不错。

778
00:40:26,440 --> 00:40:28,274
然后我们就会停止。

779
00:40:28,274 --> 00:40:30,520
>> 听众：哪里做
这些反馈信息从何而来？

780
00:40:30,520 --> 00:40:31,250
>> 休·扎布里斯基：反馈？

781
00:40:31,250 --> 00:40:32,458
呵呵，可能是我们的话筒。

782
00:40:32,458 --> 00:40:34,221

783
00:40:34,221 --> 00:40:35,470
所以啊，这是你怎么做。

784
00:40:35,470 --> 00:40:37,261
而实际上，如果我有
不停地运行它，你

785
00:40:37,261 --> 00:40:39,540
可以有频率
价值，因为它的运行，

786
00:40:39,540 --> 00:40:43,320
所以这是一个有趣的事情打转转。

787
00:40:43,320 --> 00:40:44,930
凉。

788
00:40:44,930 --> 00:40:46,600
这始终是一个可爱的人提出。

789
00:40:46,600 --> 00:40:48,792
>> SAM格林：我们没有
想想，我们什么？

790
00:40:48,792 --> 00:40:50,500
休·扎布里斯基：是啊，
这是一个讨厌的。

791
00:40:50,500 --> 00:40:53,249
因此，缓冲loading--我将展示一个
例的，在最后。

792
00:40:53,249 --> 00:40:55,090
这是加载MP3。

793
00:40:55,090 --> 00:40:58,880
和麦克风，你只使用一个函数
所谓Navigator.getUserMedia（）

794
00:40:58,880 --> 00:41:03,240
请求访问的用户的
麦克风的信息。

795
00:41:03,240 --> 00:41:05,610
>> 这里的筛选，我会
只要继续从这个活动。

796
00:41:05,610 --> 00:41:08,600
这是一个相当高的水平，
但过滤器只是让你

797
00:41:08,600 --> 00:41:16,154
>> [哔哔]

798
00:41:16,154 --> 00:41:18,320
过滤还允许你
创建像粉红色

799
00:41:18,320 --> 00:41:20,050
噪声，褐色噪声，白噪声。

800
00:41:20,050 --> 00:41:24,330
如果你想创建纯噪音，这
有些人喜欢摆弄，

801
00:41:24,330 --> 00:41:27,490
您可以使用网络音频
过滤做到这一点。

802
00:41:27,490 --> 00:41:30,039
>> 音频Panning--所以想象
如果你正在写一个游戏

803
00:41:30,039 --> 00:41:32,330
和你想要的声音
听起来像它的到来一样，

804
00:41:32,330 --> 00:41:36,090
在屏幕上拍摄的，你
可以使用音频的声像

805
00:41:36,090 --> 00:41:39,770
造成这种锥形的，
这like--它很mathy，

806
00:41:39,770 --> 00:41:41,850
但实际上它是真的
冷静，如果你得到它的工作，

807
00:41:41,850 --> 00:41:44,500
并有一些好
它的教程，我可以送你。

808
00:41:44,500 --> 00:41:46,400
基本上，你可以种
中创建的声音

809
00:41:46,400 --> 00:41:50,480
的东西在一个3D的方式去用。

810
00:41:50,480 --> 00:41:57,350
如果你有一个DJ的兴趣，你可以
启动混合和交叉淡入淡出的歌曲。

811
00:41:57,350 --> 00:42:01,260
>> 这仅仅是一些非常基本的
代码，基本上是我以前那样。

812
00:42:01,260 --> 00:42:06,140
此设置的音量
振荡器，所以我们创建了振荡器

813
00:42:06,140 --> 00:42:07,380
它创建波形。

814
00:42:07,380 --> 00:42:09,940
我们创建了GainNode，
我们设定频率，

815
00:42:09,940 --> 00:42:14,170
然后连接振荡器到
GainNode，然后基本上改变

816
00:42:14,170 --> 00:42:16,760
多少信号被允许通过。

817
00:42:16,760 --> 00:42:20,467
但实际上，它是一个数字
的东西，所以它更just--呀。

818
00:42:20,467 --> 00:42:23,550
这不是实际发生，
但是这是在现实生活中发生的事情

819
00:42:23,550 --> 00:42:24,393
有增益。

820
00:42:24,393 --> 00:42:27,258
>> 听众：--quantization
体积参数？

821
00:42:27,258 --> 00:42:28,174
休·扎布里斯基：对不起？

822
00:42:28,174 --> 00:42:30,360
听众：它是一个
量化量参数？

823
00:42:30,360 --> 00:42:31,840
休·扎布里斯基：是的。

824
00:42:31,840 --> 00:42:34,620
这是一件事我真的很
在我的知识短少的，

825
00:42:34,620 --> 00:42:38,010
如何获得工作在一个数字化水平。

826
00:42:38,010 --> 00:42:40,140
我知道实际
信号，它基本上

827
00:42:40,140 --> 00:42:45,120
控制多少你
放大信号。

828
00:42:45,120 --> 00:42:47,017
所以，是的。

829
00:42:47,017 --> 00:42:50,100
我给你的更多信息
，因为我很好奇竟

830
00:42:50,100 --> 00:42:51,099
更多地了解这一点。

831
00:42:51,099 --> 00:42:54,090
但基本参数
是，一个是fold--

832
00:42:54,090 --> 00:42:59,690
响亮signal--和零是没有
信号，否则你将听不到任何声音。

833
00:42:59,690 --> 00:43:03,150
我们将跳过演示时间，由于
这基本上是我以前那样。

834
00:43:03,150 --> 00:43:07,630
再次，Context.Destination
是音频目标节点。

835
00:43:07,630 --> 00:43:08,360
真棒，确定。

836
00:43:08,360 --> 00:43:10,470
>> 所以我打算做一个快速的两张demo。

837
00:43:10,470 --> 00:43:11,760
我们如何做的时间呢？

838
00:43:11,760 --> 00:43:12,640
>> 扬声器1：约10分钟。

839
00:43:12,640 --> 00:43:13,130
>> 休·扎布里斯基：10分钟？

840
00:43:13,130 --> 00:43:13,630
大！

841
00:43:13,630 --> 00:43:14,320
真棒。

842
00:43:14,320 --> 00:43:19,010
>> 所以第一个我要去
确实，这就是所谓的我最喜爱的歌曲。

843
00:43:19,010 --> 00:43:22,410
所以，这只是一个
小HTML的JavaScript。

844
00:43:22,410 --> 00:43:25,510
我们将有两个按钮
在页面上播放我最喜欢的歌

845
00:43:25,510 --> 00:43:29,192
并停止我最喜爱的歌曲。

846
00:43:29,192 --> 00:43:30,180
我会改变这一点。

847
00:43:30,180 --> 00:43:32,110
>> 听众：盖你的麦克风。

848
00:43:32,110 --> 00:43:33,430
>> 休·扎布里斯基：是的。

849
00:43:33,430 --> 00:43:36,300
而我在这里已经加载
这basically--脚本

850
00:43:36,300 --> 00:43:38,520
这是真正有用的
加载一个MP3，

851
00:43:38,520 --> 00:43:41,820
所以这只是让
加载速度更快MP3音乐的方式。

852
00:43:41,820 --> 00:43:44,180
这基本上只是一个包装。

853
00:43:44,180 --> 00:43:48,737
它只是使的过程
载入中的MP3快得多，

854
00:43:48,737 --> 00:43:51,570
否则，你使用的HTTP请求，
有点像我们在做什么

855
00:43:51,570 --> 00:43:53,950
在当前件套服务器。

856
00:43:53,950 --> 00:43:55,950
这真是难看，你
不想做。

857
00:43:55,950 --> 00:44:04,110
>> 原来这家伙，鲍里斯的SMU，写了一个非常
有用的小工具，称为BufferLoader。

858
00:44:04,110 --> 00:44:08,780
你所要做的只是把它传递的
情况下，你传递一个列表中 - 

859
00:44:08,780 --> 00:44:11,327
或者，是的，它是在JavaScript中的列表？

860
00:44:11,327 --> 00:44:12,160
SAM格林：数组。

861
00:44:12,160 --> 00:44:14,201
休·扎布里斯基：哦，这是
一个数组，这是正确的。

862
00:44:14,201 --> 00:44:18,660
这是路径的数组
不同的文件。

863
00:44:18,660 --> 00:44:21,990
然后你将它传递的功能。

864
00:44:21,990 --> 00:44:25,530
这是我们在谈论回调
有关与异步加载。

865
00:44:25,530 --> 00:44:28,720
这将被称为
一旦加载的文件。

866
00:44:28,720 --> 00:44:33,780
而该函数被调用时，
该文件的装载需要作为外围

867
00:44:33,780 --> 00:44:35,840
加载缓冲器阵列。

868
00:44:35,840 --> 00:44:37,990
因此，发生在这里。

869
00:44:37,990 --> 00:44:41,180
基本上，BufferList是
将是1 value--

870
00:44:41,180 --> 00:44:46,380
或者这将是一个数组
长度之一，即具有在其在索引

871
00:44:46,380 --> 00:44:51,320
零，MP3的整个加载的文件。

872
00:44:51,320 --> 00:44:53,320
所以，当我完成我做什么
加载，我只是

873
00:44:53,320 --> 00:44:57,430
创建一个缓冲源，它
是音频缓冲器源节点。

874
00:44:57,430 --> 00:45:03,410
下一步骤是我在加载
source.buffer为满载缓冲区

875
00:45:03,410 --> 00:45:06,740
从BufferList--
它的很多buffers--的

876
00:45:06,740 --> 00:45:10,255
然后您连接音频
缓冲到目的地。

877
00:45:10,255 --> 00:45:12,380
那么它会做
只是简单地把MP3

878
00:45:12,380 --> 00:45:15,260
直通到输出，
并立即开始它

879
00:45:15,260 --> 00:45:18,010
在得到这个电话。

880
00:45:18,010 --> 00:45:21,660
>> 酷，让我们看看
这一点在行动。

881
00:45:21,660 --> 00:45:24,490
我的[听不清]在这里，让我们来看看。

882
00:45:24,490 --> 00:45:26,430
所以我只是要
启动一个基本的服务器。

883
00:45:26,430 --> 00:45:28,660
在这个时候，
你需要做的，如果你

884
00:45:28,660 --> 00:45:32,490
使加载文件的请求。

885
00:45:32,490 --> 00:45:34,140
我要开始一个基本的服务器。

886
00:45:34,140 --> 00:45:38,200
这基本上是整个
PSET现在在同一行，

887
00:45:38,200 --> 00:45:43,930
但它只是开始
在端口80/80的服务器。

888
00:45:43,930 --> 00:45:47,300
所以，我们去在这里，我们
要装载80/80，

889
00:45:47,300 --> 00:45:49,110
我们要去我最喜爱的歌曲。

890
00:45:49,110 --> 00:45:51,660
所以，如果我打“玩我
最喜欢的歌“现在，

891
00:45:51,660 --> 00:45:53,964
这将载入我
最喜欢的歌曲，玩它 - 

892
00:45:53,964 --> 00:45:55,880
[MUSIC  - 老鹰，“生活在快
 车道”]

893
00:45:55,880 --> 00:46:00,490
可呈现恰好是“生活
快车道“由老鹰。

894
00:46:00,490 --> 00:46:06,346
现在，我可以打“阻止我
最喜欢的歌“和重播。

895
00:46:06,346 --> 00:46:09,160
>> [MUSIC  - 老鹰，“生活在快
 车道”]

896
00:46:09,160 --> 00:46:18,340
>> 如果我走了过来安慰，因为
我在这里用了一个全局变量

897
00:46:18,340 --> 00:46:23,390
保持这个值的轨道，它实际上
在控制台现在被认可。

898
00:46:23,390 --> 00:46:25,160
因此，它自动创建了我。

899
00:46:25,160 --> 00:46:29,991
所以，这就是在玩，现在，
我可以简单地调用source.stop（）

900
00:46:29,991 --> 00:46:30,490
在这一点。

901
00:46:30,490 --> 00:46:34,930

902
00:46:34,930 --> 00:46:35,860
那么，你知道吗？

903
00:46:35,860 --> 00:46:39,760
只是让你们听说过这个
song--你可能会认识到这首歌。

904
00:46:39,760 --> 00:46:41,801
>> [MUSIC  -  RICK ASTLEY，“从未去放弃
 您“]

905
00:46:41,801 --> 00:46:42,299

906
00:46:42,299 --> 00:46:44,215
[MUSIC  - 老鹰，“生活在快
 车道”]

907
00:46:44,215 --> 00:46:46,195
现在，我们已经全部被Rickrolled。

908
00:46:46,195 --> 00:46:50,155
OK，伟大的，继续前进。

909
00:46:50,155 --> 00:46:51,160
凉。

910
00:46:51,160 --> 00:46:54,554
因此，这基本上是一个例子
只是你怎么可以加载一个MP3 file--

911
00:46:54,554 --> 00:46:56,470
[MUSIC  - 老鹰，“生活在快
 车道”]

912
00:46:56,470 --> 00:46:59,590
 - 并且播放，停止和启动它。

913
00:46:59,590 --> 00:47:03,008
我可以做了很多[听不清]

914
00:47:03,008 --> 00:47:07,570
>> 最后一个，我会做的是，
我会告诉你一个[听不清]。

915
00:47:07,570 --> 00:47:18,070
>> [音乐播放]

916
00:47:18,070 --> 00:47:21,800
>> 这就像，ogg.wave.mp3。

917
00:47:21,800 --> 00:47:26,450
我想，如果我没有记错，
我碰到的一些问题。M4A，

918
00:47:26,450 --> 00:47:27,721
但我不知道这一点。

919
00:47:27,721 --> 00:47:28,470
我想mp3.wave--

920
00:47:28,470 --> 00:47:28,930

921
00:47:28,930 --> 00:47:30,971
>> [MUSIC  -  RICK ASTLEY，“从未去放弃
 您“]

922
00:47:30,971 --> 00:47:35,930

923
00:47:35,930 --> 00:47:36,500
>> 太好了。

924
00:47:36,500 --> 00:47:37,625
我不应该说。

925
00:47:37,625 --> 00:47:40,570
总之，你好。

926
00:47:40,570 --> 00:47:43,430

927
00:47:43,430 --> 00:47:45,490
因此，我们有这个开放。

928
00:47:45,490 --> 00:47:52,320
所以，现在我要做的就是，我基本上创造
一个基本的语法创建的音乐。

929
00:47:52,320 --> 00:47:57,610
所以，如果我做这样的事情，加上G4
1 2，这是什么意思的是，

930
00:47:57,610 --> 00:48:00,950
加上钢琴音符，G4，
这是第四ģ

931
00:48:00,950 --> 00:48:02,680
上从底部钢琴。

932
00:48:02,680 --> 00:48:05,930
因此，这是一种MIDI讲，
因此，对于那些谁是音乐的基础，

933
00:48:05,930 --> 00:48:07,860
这仅仅是MIDI音符。

934
00:48:07,860 --> 00:48:10,090
>> 听众：这是对G
中部C，对不对？

935
00:48:10,090 --> 00:48:11,840
>> 休扎布里斯基：这是对G
中C，这是正确的。

936
00:48:11,840 --> 00:48:12,470
>> 听众：中部以上C.

937
00:48:12,470 --> 00:48:13,345
>> 休·扎布里斯基：是的。

938
00:48:13,345 --> 00:48:14,340
事实上，是的。

939
00:48:14,340 --> 00:48:16,131
我想我曾作过
它酮[听不清]

940
00:48:16,131 --> 00:48:18,860
所以这可能是上面一个八度。

941
00:48:18,860 --> 00:48:20,070
所以，让我们来看看。

942
00:48:20,070 --> 00:48:21,152
如果我打Play--

943
00:48:21,152 --> 00:48:22,110
[重复性PIANO注]

944
00:48:22,110 --> 00:48:23,200
--we're会听到的。

945
00:48:23,200 --> 00:48:25,700
这个想法是，它的运作
就像一个命令行会，

946
00:48:25,700 --> 00:48:27,510
所以，如果我有涨有跌
我的键盘上，你

947
00:48:27,510 --> 00:48:31,550
可以回到以前的
命令，这是非常有用的。

948
00:48:31,550 --> 00:48:35,136
而下面是我的曲目列表，
这是在环路中的所有运行。

949
00:48:35,136 --> 00:48:38,260
>> 听众：你假设
88键的键盘上，对吧？

950
00:48:38,260 --> 00:48:41,051
>> 休·扎布里斯基：问题是，
我会假设一个88键的键盘，

951
00:48:41,051 --> 00:48:41,990
是的，我是。

952
00:48:41,990 --> 00:48:45,030
我所做的是我
基本上花了88个样本

953
00:48:45,030 --> 00:48:46,970
的钢琴，一个用于每个音符。

954
00:48:46,970 --> 00:48:49,180
所以每次时间
听到一记从现在开始，

955
00:48:49,180 --> 00:48:57,550
这实际上是一个循环，看起来
like--这是越来越演奏循环，

956
00:48:57,550 --> 00:49:00,120
所以对于每一个音符，这是在运行。

957
00:49:00,120 --> 00:49:02,860
会发生什么事是，我
再创建一个缓冲区，

958
00:49:02,860 --> 00:49:06,010
我创建了一个增益节点设置音量。

959
00:49:06,010 --> 00:49:08,240
这只是一个非常
的说我复杂的方法

960
00:49:08,240 --> 00:49:10,550
存储在source.buffer缓冲区。

961
00:49:10,550 --> 00:49:13,160
我给它的增益，我
它连接到增益，

962
00:49:13,160 --> 00:49:15,576
增益被连接到
输出，然后我玩。

963
00:49:15,576 --> 00:49:20,735
所以这是一种过程
采取在缓冲源。

964
00:49:20,735 --> 00:49:24,820
>> 听众：你能采取实际的
燥声，使之湿润[听不清]？

965
00:49:24,820 --> 00:49:26,260
>> 休·扎布里斯基：可以，是的。

966
00:49:26,260 --> 00:49:29,260
有再动词，有
延时，失真。

967
00:49:29,260 --> 00:49:33,260
你基本上可以把任何东西在
之间的夹层of--好，

968
00:49:33,260 --> 00:49:37,660
管道是一个更好的比喻，
但你可以添加任何东西。

969
00:49:37,660 --> 00:49:38,200
凉。

970
00:49:38,200 --> 00:49:40,280
>> 所以，我会完成演示
在这里给你的感觉

971
00:49:40,280 --> 00:49:46,390
时代的只是数量之多，你
可以运行功能的一次。

972
00:49:46,390 --> 00:49:49,280
所以，我要删除此。

973
00:49:49,280 --> 00:49:59,110
我要创造一个发电机that--
基本上是什么does--这是真的

974
00:49:59,110 --> 00:50:04,220
一种复杂syntax--，但它的
要在飞行中产生的笔记，

975
00:50:04,220 --> 00:50:06,601
和刚开始玩
他们，因为它评估它们。

976
00:50:06,601 --> 00:50:07,392
[插入PIANO]

977
00:50:07,392 --> 00:50:10,990

978
00:50:10,990 --> 00:50:12,817
>> 因此，我们可以只是做一个小的音乐在这里。

979
00:50:12,817 --> 00:50:13,608
[插入PIANO]

980
00:50:13,608 --> 00:50:39,570

981
00:50:39,570 --> 00:50:41,470
>> 那么这个命令
确实，例如，是

982
00:50:41,470 --> 00:50:46,910
它需要这三个音符为
钢琴，然后把他们的B3。

983
00:50:46,910 --> 00:50:48,660
这个语法可能使
多一点意义

984
00:50:48,660 --> 00:50:50,590
那些谁拥有
背景音乐在这里。

985
00:50:50,590 --> 00:50:55,180

986
00:50:55,180 --> 00:50:56,551
>> 我可以添加一个大鼓。

987
00:50:56,551 --> 00:50:57,050
我可以 - 

988
00:50:57,050 --> 00:50:58,048
>> [插入仪器]

989
00:50:58,048 --> 00:50:59,256
>> --just玩弄了。

990
00:50:59,256 --> 00:51:12,519

991
00:51:12,519 --> 00:51:13,474
>> 所以，你可以make--

992
00:51:13,474 --> 00:51:14,515
[插入仪器]

993
00:51:14,515 --> 00:51:15,513
一个人的多一点讨厌。

994
00:51:15,513 --> 00:51:16,554
[插入仪器]

995
00:51:16,554 --> 00:51:26,491

996
00:51:26,491 --> 00:51:30,981
>> 因此，它随机增加了一个干钹
在每16个音符，用16％

997
00:51:30,981 --> 00:51:31,481
[听不清]。

998
00:51:31,481 --> 00:51:32,522
>> [插入仪器]

999
00:51:32,522 --> 00:51:40,962

1000
00:51:40,962 --> 00:51:50,400
>> 是啊，所以这个方法
works--它总是在4：4。

1001
00:51:50,400 --> 00:51:51,441
[插入仪器]

1002
00:51:51,441 --> 00:52:06,910

1003
00:52:06,910 --> 00:52:10,902
>> 是啊，所以四季度和16/8。

1004
00:52:10,902 --> 00:52:14,851

1005
00:52:14,851 --> 00:52:15,892
[插入仪器]

1006
00:52:15,892 --> 00:52:27,970

1007
00:52:27,970 --> 00:52:33,780
>> 所以平均起来，你会得到60％
命中的16分音符。

1008
00:52:33,780 --> 00:52:35,990
>> 不管怎么说，这只是
那种炫耀

1009
00:52:35,990 --> 00:52:39,780
有些事情可以
建立与网络音频API。

1010
00:52:39,780 --> 00:52:43,840
这真是强大，它的真快，
你可以做很多很酷的事情

1011
00:52:43,840 --> 00:52:44,340
用它。

1012
00:52:44,340 --> 00:52:51,260
如此反复，您有任何疑问，
电子邮件myself-- Hugh--或山姆，

1013
00:52:51,260 --> 00:52:55,869
和诚实，谷歌
一吨的良好资源。

1014
00:52:55,869 --> 00:52:56,660
最后还有什么问题？

1015
00:52:56,660 --> 00:52:57,970
是啊。

1016
00:52:57,970 --> 00:53:00,790
>> 听众：所以，你可以访问
内置麦克风。

1017
00:53:00,790 --> 00:53:03,089
如果你想什么
使用更好的麦克风？

1018
00:53:03,089 --> 00:53:05,380
休·扎布里斯基：如果你想
使用更好的麦克风？

1019
00:53:05,380 --> 00:53:11,320
如此反复，这是部分
Chrome浏览器之间的抽象

1020
00:53:11,320 --> 00:53:12,950
和计算机的其余部分。

1021
00:53:12,950 --> 00:53:18,950
除非它是可以通过
一个API，如Web MIDI API，

1022
00:53:18,950 --> 00:53:22,030
你也许可以找到一些黑客，
但一般不是切实可行的。

1023
00:53:22,030 --> 00:53:25,300
>> SAM格林：您可以also--
所有的浏览器都知道

1024
00:53:25,300 --> 00:53:28,820
是你的默认麦克风
是，并且它访问。

1025
00:53:28,820 --> 00:53:33,410
所以，如果你有一个麦克风，你可以
设置为计算机的默认麦克风，

1026
00:53:33,410 --> 00:53:35,990
您可以访问这种方式
它可能会工作。

1027
00:53:35,990 --> 00:53:37,490
休·扎布里斯基：这是一个很好的点。

1028
00:53:37,490 --> 00:53:39,656
我从来没有尝试过，但
你也许可以来样

1029
00:53:39,656 --> 00:53:45,700
of--如果您重定向输入扬声器，
你也许可以做到这一点，是的。

1030
00:53:45,700 --> 00:53:48,360
>> 最后还有什么问题？

1031
00:53:48,360 --> 00:53:49,340
凉。

1032
00:53:49,340 --> 00:53:51,680
好感谢你们
这么多的收看。

1033
00:53:51,680 --> 00:53:52,199
我休。

1034
00:53:52,199 --> 00:53:52,990
SAM格林：我是萨姆。

1035
00:53:52,990 --> 00:53:55,410
休·扎布里斯基：这是CS50。

1036
00:53:55,410 --> 00:53:56,767