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