1
00:00:00,000 --> 00:00:03,840
>> [音樂播放]

2
00:00:03,840 --> 00:00:05,770

3
00:00:05,770 --> 00:00:08,690
>> 道格·勞埃德：所以現在我們老了
專業人士在網絡編程，對不對？

4
00:00:08,690 --> 00:00:12,140
我們已經介紹了幾個
語言在各個視頻。

5
00:00:12,140 --> 00:00:14,690
現在，讓我們做一個，JavaScript的。

6
00:00:14,690 --> 00:00:17,370
>> 首先是好消息，JavaScript的
是一個現代的編程

7
00:00:17,370 --> 00:00:21,410
語言，就像PHP的
語法是從C派生，

8
00:00:21,410 --> 00:00:22,830
所以這是一個良好的開端。

9
00:00:22,830 --> 00:00:25,880
這是關於老的PHP，以及，
已經存在了大約20年。

10
00:00:25,880 --> 00:00:28,600
有人發明了各地
同時為PHP。

11
00:00:28,600 --> 00:00:32,240
和JavaScript實際上非常
基本用戶體驗

12
00:00:32,240 --> 00:00:32,740
幅材。

13
00:00:32,740 --> 00:00:34,448
實際上，有
三種語言，我

14
00:00:34,448 --> 00:00:38,480
會說那種補
交互的用戶體驗

15
00:00:38,480 --> 00:00:42,650
與網站，HTML，
CSS和JavaScript。

16
00:00:42,650 --> 00:00:46,030
所以，現在讓我們討論
關於JavaScript點點。

17
00:00:46,030 --> 00:00:50,301
>> 壞消息，雖然與JavaScript是
它設置了大量的規則本身，

18
00:00:50,301 --> 00:00:51,300
然後它打破它們。

19
00:00:51,300 --> 00:00:54,010
和JavaScript實際上可以
一種具有挑戰性的學習，

20
00:00:54,010 --> 00:00:57,000
因為它不像C和
PHP，這是非常結構化

21
00:00:57,000 --> 00:01:00,270
並有非常嚴格的規則
對於事情如何工作的。

22
00:01:00,270 --> 00:01:03,690
JavaScript有樣
中變得如此靈活

23
00:01:03,690 --> 00:01:06,650
也許事情不會
工作我們希望他們的方式，

24
00:01:06,650 --> 00:01:09,830
也許我們真的不能學
我們的第一個編程語言

25
00:01:09,830 --> 00:01:10,769
作為一個JavaScript。

26
00:01:10,769 --> 00:01:12,810
因此，也許因為它不
為自己設定任何規則，

27
00:01:12,810 --> 00:01:15,754
它並沒有真正
強制良好的編碼習慣。

28
00:01:15,754 --> 00:01:18,170
但是，現在我們已經希望開發
一些良好的編碼習慣，

29
00:01:18,170 --> 00:01:21,470
所以我們可以開始掠奪
成JavaScript一點點。

30
00:01:21,470 --> 00:01:25,750
>> 編寫JavaScript，類似於開放
與點C擴展C文件

31
00:01:25,750 --> 00:01:29,770
或用點PHP擴展的PHP文件，
我們需要做的就是打開一個文件

32
00:01:29,770 --> 00:01:31,764
用點js文件擴展名。

33
00:01:31,764 --> 00:01:34,430
我們不需要有任何特別的
像我們做的分隔符在PHP中。

34
00:01:34,430 --> 00:01:36,750
那種角度
支架問號PHP

35
00:01:36,750 --> 00:01:40,300
我們已經習慣了從的樣子，
我們告訴我們的瀏覽器，我們所擁有的

36
00:01:40,300 --> 00:01:43,502
JavaScript是由包括
在一個HTML標籤，

37
00:01:43,502 --> 00:01:46,210
我們會看到一點點
如何做到這一點在短短的時刻。

38
00:01:46,210 --> 00:01:48,210
>> 其他的東西，它使
JavaScript的不同，

39
00:01:48,210 --> 00:01:50,580
雖然，是它運行客戶端。

40
00:01:50,580 --> 00:01:53,430
綜上所述，使用PHP回顧
我們永遠無法真正看到

41
00:01:53,430 --> 00:01:57,041
這強調了網站的PHP。

42
00:01:57,041 --> 00:01:59,040
如果我們曾經看到的
網頁源代碼，我們只能

43
00:01:59,040 --> 00:02:02,830
看到是HTML
由PHP產生。

44
00:02:02,830 --> 00:02:04,900
但JavaScript的運行客戶端。

45
00:02:04,900 --> 00:02:06,710
您的JavaScript運行在您的計算機上。

46
00:02:06,710 --> 00:02:09,050
這就是為什麼你可以做
東西隨意添加阻滯劑。

47
00:02:09,050 --> 00:02:09,550
對？

48
00:02:09,550 --> 00:02:12,704
廣告阻塞通常是由完成
殺死所有的JavaScript

49
00:02:12,704 --> 00:02:14,370
即在一個特定的網站上運行。

50
00:02:14,370 --> 00:02:19,000
而且因為它必須
運行在您的計算機客戶端，

51
00:02:19,000 --> 00:02:21,910
你可以停止
JavaScript來完全運行。

52
00:02:21,910 --> 00:02:27,030
這也意味著，當你使用
一個網站，包括了JavaScript，

53
00:02:27,030 --> 00:02:32,450
你必須發送JavaScript源
代碼作為你的HTTP響應的一部分

54
00:02:32,450 --> 00:02:34,159
給客戶端時，他們提出要求。

55
00:02:34,159 --> 00:02:35,950
所以你可能不
要使用JavaScript

56
00:02:35,950 --> 00:02:38,395
做真正敏感的事情
像傳遞信息

57
00:02:38,395 --> 00:02:41,020
有關用戶的密碼備份和
第四，因為他們實際上是

58
00:02:41,020 --> 00:02:45,610
將要接收所有的源代碼，
不只是生成的HTML，

59
00:02:45,610 --> 00:02:49,030
如將與發言權PHP的情況。

60
00:02:49,030 --> 00:02:51,620
>> 那麼，如何才能包含JavaScript
在我們的HTML開始嗎？

61
00:02:51,620 --> 00:02:54,520
好了，類似CSS，實際上，
是那種我們在這裡是如何做到這一點。

62
00:02:54,520 --> 00:02:56,190
使用CSS我們的風格標籤。

63
00:02:56,190 --> 00:03:00,760
而那些風格標籤內，
我們可以定義一個CSS樣式表。

64
00:03:00,760 --> 00:03:03,450
同樣使用JavaScript
我們可以打開腳本標記，

65
00:03:03,450 --> 00:03:06,660
另一個HTML標記我們沒
在我們的HTML視頻講，

66
00:03:06,660 --> 00:03:09,720
和JavaScript寫的
這些腳本標記之間。

67
00:03:09,720 --> 00:03:13,960
此外，雖然，如CSS，我們
可能CSS文件外鏈接

68
00:03:13,960 --> 00:03:15,900
拉他們到我們的節目的方式。

69
00:03:15,900 --> 00:03:18,280
使用CSS，我們也可以，
請問，使用JavaScript

70
00:03:18,280 --> 00:03:23,240
我們也可以指定源
script標籤的屬性

71
00:03:23,240 --> 00:03:25,720
在JavaScript鏈接
另外，讓你不

72
00:03:25,720 --> 00:03:27,680
必須在寫
腳本標記之間，我們

73
00:03:27,680 --> 00:03:29,600
可以使用鏈接它
該腳本標籤。

74
00:03:29,600 --> 00:03:33,230
而且，就像使用CSS那裡的情況下，
我們建議它可能是

75
00:03:33,230 --> 00:03:36,090
你最感興趣寫
在的情況下一個單獨的文件你的CSS

76
00:03:36,090 --> 00:03:38,500
你需要去改變它，
同樣做我們推薦

77
00:03:38,500 --> 00:03:40,720
你寫你的
的JavaScript在不同的文件

78
00:03:40,720 --> 00:03:45,460
並使用腳本標記源
屬性，以配合您的JavaScript

79
00:03:45,460 --> 00:03:49,520
到HTML，你的網頁。

80
00:03:49,520 --> 00:03:52,610
>> 所以JavaScript變量，我們將
開始談論的語法在這裡。

81
00:03:52,610 --> 00:03:53,600
而我們將通過
這種快速，

82
00:03:53,600 --> 00:03:56,640
因為我們已經在PHP中做到了這一點，所以
這應該都非常熟悉。

83
00:03:56,640 --> 00:03:59,490
因此，在JavaScript中的變量
非常類似於PHP變量。

84
00:03:59,490 --> 00:04:03,270
有沒有類型說明符，和
當你引入一個變量，

85
00:04:03,270 --> 00:04:05,070
你用var關鍵字前綴它。

86
00:04:05,070 --> 00:04:07,750
在PHP中，我們會做一些
這樣，美元符號的X.

87
00:04:07,750 --> 00:04:09,950
這就是我們指示
一個變量，但是沒有，我們

88
00:04:09,950 --> 00:04:12,060
不提的類型
變量的在所有。

89
00:04:12,060 --> 00:04:15,124
我們會說，像
美元符號x等於44 PHP。

90
00:04:15,124 --> 00:04:17,040
如果我們在做
在JavaScript中同樣的事情，

91
00:04:17,040 --> 00:04:19,589
我們會說無功x等於44。

92
00:04:19,589 --> 00:04:22,780
所以，VAR是那種我們的方式
的引入的變量。

93
00:04:22,780 --> 00:04:26,850
這或許更直觀一點
不僅僅是美元符號的變量。

94
00:04:26,850 --> 00:04:29,080
>> 同樣，由於沒有
數據類型，我們可以這樣做

95
00:04:29,080 --> 00:04:34,490
與任何數據類型，字符串，
別的都將是無功。

96
00:04:34,490 --> 00:04:37,260
條件語句，我們所有的
從C和PHP老朋友

97
00:04:37,260 --> 00:04:41,640
仍然可用，所以我們有如果，
否則，如果，否則，開關和問題

98
00:04:41,640 --> 00:04:42,240
標誌結腸。

99
00:04:42,240 --> 00:04:45,890
交換機剩餘靈活，因為它
在PHP，但所有這些你

100
00:04:45,890 --> 00:04:46,930
熟悉現在。

101
00:04:46,930 --> 00:04:49,900
而同樣與環路
的，而老歌，

102
00:04:49,900 --> 00:04:52,700
做一段時間，並仍然提供給我們。

103
00:04:52,700 --> 00:04:55,880
因此，我們已經知道了很多的
基本面基本的JavaScript類

104
00:04:55,880 --> 00:05:01,800
僅僅憑藉具有相當多的
現在關於C和PHP知識。

105
00:05:01,800 --> 00:05:03,670
>> 那麼在JavaScript的功能呢？

106
00:05:03,670 --> 00:05:08,199
那麼，類似PHP每個功能
引入的功能關鍵字。

107
00:05:08,199 --> 00:05:10,740
你說的功能，然後
開始定義功能。

108
00:05:10,740 --> 00:05:12,531
什麼是有一點不同
關於JavaScript的，

109
00:05:12,531 --> 00:05:15,700
雖然是有能力
什麼叫做匿名函數。

110
00:05:15,700 --> 00:05:18,880
所以，你可以定義函數
不具有一個名字。

111
00:05:18,880 --> 00:05:21,222
這是我們
還真沒見過。

112
00:05:21,222 --> 00:05:23,430
我們將真正使用的概念
匿名函數的

113
00:05:23,430 --> 00:05:27,880
在這個待會兒
視頻，因為它會

114
00:05:27,880 --> 00:05:31,530
使背景下多一點意義
當我們看到它在特定情況下

115
00:05:31,530 --> 00:05:33,120
我已經在這裡製作。

116
00:05:33,120 --> 00:05:35,710
但是，我們只是看看
在什麼是簡單的JavaScript

117
00:05:35,710 --> 00:05:37,850
函數可能看起來像。

118
00:05:37,850 --> 00:05:40,610
>> 所以，我已經先行一步，並
打開了我的CS50的IDE

119
00:05:40,610 --> 00:05:43,690
我已經運行的Apache
開始我的服務器上運行。

120
00:05:43,690 --> 00:05:46,800
我有這個文件
打開名為Home.html中。

121
00:05:46,800 --> 00:05:48,330
我會在一點點放大這裡。

122
00:05:48,330 --> 00:05:52,090
基本上，你可以看到
Home.html中只是一堆按鈕。

123
00:05:52,090 --> 00:05:55,291
而我在上面聲稱在這裡
這是JavaScript部分

124
00:05:55,291 --> 00:05:55,790
材料。

125
00:05:55,790 --> 00:05:59,490
因此，有一堆按鈕在這裡，
但做這些按鈕實際上呢？

126
00:05:59,490 --> 00:06:03,662
>> 好了，我們會去到我的IED，
而我的Home.html在這裡打開。

127
00:06:03,662 --> 00:06:05,620
在一開始，
這裡的地方我鏈接

128
00:06:05,620 --> 00:06:07,500
在我所有的JavaScript源文件。

129
00:06:07,500 --> 00:06:08,000
對？

130
00:06:08,000 --> 00:06:12,440
所以我有anonymous.js，clock.js，
我使用源屬性

131
00:06:12,440 --> 00:06:14,440
腳本標記的文件鏈接。

132
00:06:14,440 --> 00:06:18,660
所以，我沒有寫任何
JavaScript的直接進入這個文件，

133
00:06:18,660 --> 00:06:21,790
但我已經將所有的
JavaScript的我分開寫。

134
00:06:21,790 --> 00:06:24,540
如果我們這裡，這個向下滾動
應該都是看起來有點熟悉

135
00:06:24,540 --> 00:06:27,090
隨著新的語法一點點。

136
00:06:27,090 --> 00:06:32,655
我們在這裡頭標記
函數，然後一個按鈕。

137
00:06:32,655 --> 00:06:35,530
我有一個輸入，這是一個類型的按鈕，
顯然，當我點擊它，

138
00:06:35,530 --> 00:06:38,130
我要調用一些
功能警報的日期。

139
00:06:38,130 --> 00:06:41,792
這是那種我們如何可以混合起來
JavaScript和HTML一點點。

140
00:06:41,792 --> 00:06:44,500
實際上，他們發揮得很好
在一起，所以很明顯，當

141
00:06:44,500 --> 00:06:48,730
我點擊這個按鈕，我要去
要調用一些功能警報的日期。

142
00:06:48,730 --> 00:06:53,660
而同樣是我所定義的行為
對於所有的其它按鈕，

143
00:06:53,660 --> 00:06:56,440
是home.html的頁面上，
我們將回頭率

144
00:06:56,440 --> 00:06:59,172
這個視頻的過程中。

145
00:06:59,172 --> 00:07:00,880
但是，讓我們回去了
這裡就來看看

146
00:07:00,880 --> 00:07:03,850
在clock.js，這是
JavaScript文件，我

147
00:07:03,850 --> 00:07:07,370
寫有這首功能
我們要看一看。

148
00:07:07,370 --> 00:07:11,630
正如你所看到的，我開始我的JavaScript
用關鍵字功能功能，

149
00:07:11,630 --> 00:07:14,560
我已經給這一個
的名字，這就是所謂的警報的日期。

150
00:07:14,560 --> 00:07:18,710
裡面還有，我顯然是創建一個
所謂的當前日期新的局部變量。

151
00:07:18,710 --> 00:07:21,500
而我要去分配
一個等於一個新的日期。

152
00:07:21,500 --> 00:07:24,430
而且，我們可以進入很多
具體以什麼日期是，

153
00:07:24,430 --> 00:07:27,060
真正的JavaScript是這樣
大不大，說我們不可能

154
00:07:27,060 --> 00:07:28,330
面面俱到的一個視頻。

155
00:07:28,330 --> 00:07:32,220
但我只想說，這是怎麼回事
回到我的數據項

156
00:07:32,220 --> 00:07:35,470
封裝當前日期和時間。

157
00:07:35,470 --> 00:07:39,100
我存儲在我是一個變量
顯然要提醒當前日期。

158
00:07:39,100 --> 00:07:41,300
>> 那麼，什麼警報
當前日期是什麼樣子？

159
00:07:41,300 --> 00:07:46,460
讓我們來看看文件本身
備份過在瀏覽器窗口。

160
00:07:46,460 --> 00:07:49,551
如此反复，這是按鈕，我
已經綁，這個命名功能。

161
00:07:49,551 --> 00:07:51,800
我點擊它，並
看看它的所作所為，它提醒。

162
00:07:51,800 --> 00:07:56,140
它突然出現了這樣的框，告訴
我的當前時間為，顯然

163
00:07:56,140 --> 00:07:59,370
這是11月4日
10時43分43秒在上午。

164
00:07:59,370 --> 00:08:02,345
如果我再次點擊它，現在
這是一個幾秒鐘後，對不對？

165
00:08:02,345 --> 00:08:03,720
所以，這就是這個函數。

166
00:08:03,720 --> 00:08:07,670
當我點擊這個按鈕，它
彈出一個警告信息給我。

167
00:08:07,670 --> 00:08:13,806

168
00:08:13,806 --> 00:08:15,690
所以真的沒有
太多的功能

169
00:08:15,690 --> 00:08:19,110
這是從PHP不同，
新的語法，只是一點點

170
00:08:19,110 --> 00:08:22,500
隨使用JavaScript。

171
00:08:22,500 --> 00:08:24,650
>> 在JavaScript中數組是
很簡單。

172
00:08:24,650 --> 00:08:27,200
要聲明一個數組，可以使用
方括號語法

173
00:08:27,200 --> 00:08:30,090
我們很熟悉的PHP。

174
00:08:30,090 --> 00:08:33,432
而類似PHP，我們
也可以混合數據類型。

175
00:08:33,432 --> 00:08:35,140
所以這個數組，無論是
這些陣列的將

176
00:08:35,140 --> 00:08:36,960
是完全合法的JavaScript。

177
00:08:36,960 --> 00:08:42,500
一說是所有的整數，而另一個
混合起來不同的數據類型。

178
00:08:42,500 --> 00:08:45,020
>> 什麼是非常不同的東西
在JavaScript中，有關係嗎？

179
00:08:45,020 --> 00:08:47,020
這是一個對象的概念。

180
00:08:47,020 --> 00:08:50,240
因此，也許你聽說過
面向對象編程。

181
00:08:50,240 --> 00:08:53,370
我們不會做很多它的CS50，
但我們會做一點點

182
00:08:53,370 --> 00:08:55,670
這裡在JavaScript的上下文。

183
00:08:55,670 --> 00:08:59,100
現在的JavaScript有能力
表現為一個面向對象的程序設計

184
00:08:59,100 --> 00:09:02,615
語言，但它本身不是
完全面向對象的

185
00:09:02,615 --> 00:09:03,490
編程語言。

186
00:09:03,490 --> 00:09:05,281
而這又涉及
回到為什麼我說，這

187
00:09:05,281 --> 00:09:10,610
是非常具有挑戰性的學習
JavaScript作為你的第一個程序

188
00:09:10,610 --> 00:09:13,890
語言，因為它不
真正適合某個特定的模式。

189
00:09:13,890 --> 00:09:16,430
>> C對另一方面是一個
函數式編程語言。

190
00:09:16,430 --> 00:09:22,270
如果我們想，功能
那種大老闆的人吧？

191
00:09:22,270 --> 00:09:24,410
他們決定什麼
發生一切。

192
00:09:24,410 --> 00:09:26,600
我們要改變的變量，
我們調用函數。

193
00:09:26,600 --> 00:09:28,220
我們做事的功能。

194
00:09:28,220 --> 00:09:31,250
對象，而不是在一個
面向對象的語言，

195
00:09:31,250 --> 00:09:35,937
對對象進行排序成為明星，
功能成為那種次要的。

196
00:09:35,937 --> 00:09:38,270
但是，什麼是對象，什麼
是一個對象的這個概念？

197
00:09:38,270 --> 00:09:40,880
那麼，如果有幫助，認為
它在第一個排序

198
00:09:40,880 --> 00:09:44,540
像C結構或結構
我們已經了解了。

199
00:09:44,540 --> 00:09:47,430
在C語言中，一個結構包含
多個字段，

200
00:09:47,430 --> 00:09:51,174
也許我們現在可能會開始
把這些字段屬性。

201
00:09:51,174 --> 00:09:53,590
但性能從來沒有真正
站在自己的，對不對？

202
00:09:53,590 --> 00:09:56,410
如果我定義了一個結構，汽車
像這樣有以下兩個

203
00:09:56,410 --> 00:10:00,750
字段或屬性，一個一個
對於汽車的年整

204
00:10:00,750 --> 00:10:04,290
和另外10個字符
串為汽車的型號，

205
00:10:04,290 --> 00:10:07,150
我可以說這樣的事情，
我可以聲明一個新變量

206
00:10:07,150 --> 00:10:10,080
類型結構的車赫比。

207
00:10:10,080 --> 00:10:13,730
然後，我能說些什麼
像herbie.year等於1963，

208
00:10:13,730 --> 00:10:15,850
和herbie.model等於甲殼蟲。

209
00:10:15,850 --> 00:10:17,000
沒關係。

210
00:10:17,000 --> 00:10:19,680
我使用的領域
結構的範圍內，

211
00:10:19,680 --> 00:10:22,290
但我永遠只是
說這句話。

212
00:10:22,290 --> 00:10:22,790
對？

213
00:10:22,790 --> 00:10:26,836
我不能使用字段名
獨立結構。

214
00:10:26,836 --> 00:10:28,210
這有點一個根本的東西。

215
00:10:28,210 --> 00:10:32,990
>> 所以場是
根本，以C結構

216
00:10:32,990 --> 00:10:39,050
非常相似的屬性是
根本的JavaScript對象。

217
00:10:39,050 --> 00:10:42,080
但是，是什麼讓他們
特別有趣

218
00:10:42,080 --> 00:10:46,230
是，對象也可以具有什麼
被稱為方法，這是真正

219
00:10:46,230 --> 00:10:50,730
只是一個花哨的詞的功能，
是固有的對象為好。

220
00:10:50,730 --> 00:10:55,340
所以這是一個函數，它只能是
所謂在對象的上下文中。

221
00:10:55,340 --> 00:10:59,200
唯一定義一個對象
此函數將其內部，

222
00:10:59,200 --> 00:11:02,020
如果你想想
結構，功能

223
00:11:02,020 --> 00:11:05,720
這些內部定義的定義
結構的大括號內。

224
00:11:05,720 --> 00:11:07,980
因此，它只能意味著什麼
到的結構。

225
00:11:07,980 --> 00:11:10,960
這就是那種我們正在做的
這裡的對象和方法。

226
00:11:10,960 --> 00:11:13,580
這基本上就像我們
定義一個函數，它

227
00:11:13,580 --> 00:11:16,670
不僅使上感
特定的對象，因此我們

228
00:11:16,670 --> 00:11:19,440
調用該對象的方法。

229
00:11:19,440 --> 00:11:23,180
我們永遠不能稱之為
功能獨立的對象，

230
00:11:23,180 --> 00:11:29,260
就像我們不能說一年或模型
獨立於C.結構體

231
00:11:29,260 --> 00:11:32,300
>> 因此，函數式編程
範式是這個樣子。

232
00:11:32,300 --> 00:11:35,450
功能，當你通過，則
在對象作為參數。

233
00:11:35,450 --> 00:11:38,650
在面向對象的編程
語言類的這種變

234
00:11:38,650 --> 00:11:43,464
翻轉，我們會考慮
像這樣，object.function。

235
00:11:43,464 --> 00:11:45,380
因此，那種圓點
運營商再次暗示

236
00:11:45,380 --> 00:11:49,540
它的某種屬性
或對象本身的屬性。

237
00:11:49,540 --> 00:11:53,240
但是，這是一個對象
面向對象編程語言

238
00:11:53,240 --> 00:11:57,150
可能會做，使功能
調用的方法，再一次，這

239
00:11:57,150 --> 00:12:00,260
僅僅是一個特殊的詞功能
所固有的對象。

240
00:12:00,260 --> 00:12:03,440
這是什麼
語法可能是什麼樣子。

241
00:12:03,440 --> 00:12:09,360
因此，我們將開始看到一些
這在JavaScript的上下文。

242
00:12:09,360 --> 00:12:12,470
>> 你也可以考慮的對象
有點像一個關聯數組，

243
00:12:12,470 --> 00:12:14,160
這是我們很熟悉的PHP。

244
00:12:14,160 --> 00:12:17,720
請記住一個關聯數組允許
我們有鍵值對，而不是

245
00:12:17,720 --> 00:12:23,040
具有索引0，一個，兩個，三個，
所以像我們從C使用

246
00:12:23,040 --> 00:12:23,940
陣列。

247
00:12:23,940 --> 00:12:27,472
關聯數組可以映射
即，如在PHP視頻，

248
00:12:27,472 --> 00:12:29,180
我們談論
比薩餅的澆頭。

249
00:12:29,180 --> 00:12:31,180
因此，我們有一個數組
所謂的比薩餅，和我們

250
00:12:31,180 --> 00:12:36,670
有奶酪是一個關鍵和​​$ 8.99是
值，然後香腸是一個關鍵的，

251
00:12:36,670 --> 00:12:39,190
$ 9.99加入是一個值，並依此類推。

252
00:12:39,190 --> 00:12:43,300
因此，我們也可以思考的一個
對象排序的類似締

253
00:12:43,300 --> 00:12:43,840
數組。

254
00:12:43,840 --> 00:12:47,020
所以這個語法在這裡
將創建一個新的對象

255
00:12:47,020 --> 00:12:50,950
叫赫比兩個
它裡面的屬性。

256
00:12:50,950 --> 00:12:57,310
年，其中被賦值為1963年，
和模型，其被分配的串

257
00:12:57,310 --> 00:12:58,140
甲蟲。

258
00:12:58,140 --> 00:13:01,770
>> 並注意在這裡，我使用
單引號中的JavaScript。

259
00:13:01,770 --> 00:13:05,570
您可以使用單或雙引號
當你在談論的字符串。

260
00:13:05,570 --> 00:13:07,772
這只是傳統
的情況下，大多數倍

261
00:13:07,772 --> 00:13:10,230
當你編寫JavaScript，
你只需要使用單引號。

262
00:13:10,230 --> 00:13:15,050
但是，我可以在這裡使用雙引號，和
這將是完美的罰款以及。

263
00:13:15,050 --> 00:13:17,470
>> 所以，記得在
PHP，我們有這個想法

264
00:13:17,470 --> 00:13:22,730
的每個迴路，使我們
遍歷所有鍵值

265
00:13:22,730 --> 00:13:25,270
對關聯的
陣列，因為我們

266
00:13:25,270 --> 00:13:29,050
沒有這種能力來遍歷
通過0，一，二，三，四，

267
00:13:29,050 --> 00:13:30,710
等等？

268
00:13:30,710 --> 00:13:35,010
JavaScript有非常類似的東西，
但它不叫for each循環，

269
00:13:35,010 --> 00:13:38,960
它被稱為在循環。

270
00:13:38,960 --> 00:13:42,890
所以，如果我對我說喜歡
這一點，在對象VAR鍵，

271
00:13:42,890 --> 00:13:48,670
這就是那種類似說法
對每個東西的東西。

272
00:13:48,670 --> 00:13:53,850
但是，所有我在這裡做的是迭代
通過我的所有對象的鍵。

273
00:13:53,850 --> 00:13:56,070
而捲曲的內
牙套那裡，我會

274
00:13:56,070 --> 00:14:03,410
使用對象的方括號鍵指
以在該鍵位置的值。

275
00:14:03,410 --> 00:14:05,400
>> 可替代地，有
即使是另一種方法。

276
00:14:05,400 --> 00:14:10,880
如果我只關心
值，我可以說對象的關鍵，

277
00:14:10,880 --> 00:14:12,360
和剛內使用密鑰。

278
00:14:12,360 --> 00:14:17,240
因此，對於在對象VAR鍵，我有
使用對象的方括號

279
00:14:17,240 --> 00:14:19,340
關鍵的內循環。

280
00:14:19,340 --> 00:14:24,580
對於對象的VAR鑰匙，我可以
只使用鍵循環內，

281
00:14:24,580 --> 00:14:29,040
因為我只是專
說起那裡的價值。

282
00:14:29,040 --> 00:14:32,630
>> 因此，讓我們也許需要
看差

283
00:14:32,630 --> 00:14:35,670
只是為了迅速告訴你
4之間的差

284
00:14:35,670 --> 00:14:40,730
在和用於治療與一個非常具體的
陣，我們這裡有，週陣列。

285
00:14:40,730 --> 00:14:43,616
所以，我必須找到一個新的數組
我充滿了七弦，

286
00:14:43,616 --> 00:14:46,240
星期一星期二星期三，
週四，週五，週六，週日。

287
00:14:46,240 --> 00:14:50,530
我想現在迭代
在這個數組中，

288
00:14:50,530 --> 00:14:53,090
打印出的某些信息。

289
00:14:53,090 --> 00:14:58,780
如果我使用一個在循環
打印出的信息，

290
00:14:58,780 --> 00:15:00,710
你覺得我會得到什麼？

291
00:15:00,710 --> 00:15:01,710
好吧，讓我們一起來看看。

292
00:15:01,710 --> 00:15:05,300
而之前我們跳過去
我的瀏覽器窗口，

293
00:15:05,300 --> 00:15:08,090
只知道
的console.log幾分之一

294
00:15:08,090 --> 00:15:10,630
這樣做在JavaScript中打印的F方式。

295
00:15:10,630 --> 00:15:12,040
但是，什麼是控制台？

296
00:15:12,040 --> 00:15:14,940
好了，這就是我們要去
去看看現在。

297
00:15:14,940 --> 00:15:16,850
>> 好了，我們又回到這裡
在我的瀏覽器窗口，

298
00:15:16,850 --> 00:15:19,410
我要去開
我的開發工具。

299
00:15:19,410 --> 00:15:22,290
再次，我只是打F12
開放的開發工具。

300
00:15:22,290 --> 00:15:25,670
並注意在此間舉行的
上面我選擇控制台。

301
00:15:25,670 --> 00:15:28,480
因此，這是概念
開發者控制台，

302
00:15:28,480 --> 00:15:30,500
它將使我們能夠
打印出來的信息，

303
00:15:30,500 --> 00:15:33,000
有點像終端，但
因為你會看到一個小後，

304
00:15:33,000 --> 00:15:37,720
我們也可以在輸入信息
與我們的網頁交互。

305
00:15:37,720 --> 00:15:42,320
我會在一點點放大這裡，
而我要現在在測試點擊的。

306
00:15:42,320 --> 00:15:45,230
而四test--我不會
告訴你它的代碼，現在，

307
00:15:45,230 --> 00:15:47,479
但你會得到它，如果你
下載源代碼

308
00:15:47,479 --> 00:15:50,380
與此相關聯的video--
只是，對於在循環

309
00:15:50,380 --> 00:15:52,610
我們看到的只是一個
第二以前的幻燈片。

310
00:15:52,610 --> 00:15:54,810
>> 所以，我要點擊那
按鈕，在這裡，

311
00:15:54,810 --> 00:15:58,440
這裡就是已經打印出來了
控制台，0，一，二，三，四，五，

312
00:15:58,440 --> 00:15:58,940
六。

313
00:15:58,940 --> 00:16:02,490
我沒有打印出的信息
這些陣列單元內，

314
00:16:02,490 --> 00:16:05,180
因為我用在循環中。

315
00:16:05,180 --> 00:16:10,670
和循環的身體內部，我
剛剛打印出來的關鍵不反對鍵。

316
00:16:10,670 --> 00:16:18,600
但是，如果我現在很清楚我的控制台，我
切換到用於測試的，和四個測試的

317
00:16:18,600 --> 00:16:22,500
我說我使用的循環
而不是打印出來的關鍵，

318
00:16:22,500 --> 00:16:28,079
如果我點擊了，現在我得到的
我的對象裡面實際元素

319
00:16:28,079 --> 00:16:29,120
還是我在這種情況下陣。

320
00:16:29,120 --> 00:16:31,760
我的工作日陣列。

321
00:16:31,760 --> 00:16:33,480
我打印出來週一，
週二週三。

322
00:16:33,480 --> 00:16:36,930
所以這之間的差
一個在循環，打印出

323
00:16:36,930 --> 00:16:43,410
只是，如果你只需要使用鑰匙的鑰匙
所述循環體的內部，

324
00:16:43,410 --> 00:16:46,850
和一個for循環，其中打印
出來的數值，如果你只使用

325
00:16:46,850 --> 00:16:48,870
關鍵的循環體內部。

326
00:16:48,870 --> 00:16:52,380
>> 好吧，我們現在怎麼辦開始
連接字符串，也許混淆

327
00:16:52,380 --> 00:16:57,220
插值一些變量
就像我們能夠做到在PHP？

328
00:16:57,220 --> 00:16:59,410
好了，我們非常熟悉的
這個從PHP。

329
00:16:59,410 --> 00:17:04,109
這是我們如何使用做
點運算符來連接字符串。

330
00:17:04,109 --> 00:17:06,260
在JavaScript中，不過，
我們實際使用的東西

331
00:17:06,260 --> 00:17:09,290
所謂的加號，這
也許是更多的哪怕是一點點

332
00:17:09,290 --> 00:17:10,470
直觀的，對不對？

333
00:17:10,470 --> 00:17:12,609
我們加入一些
串在一起。

334
00:17:12,609 --> 00:17:14,520
因此，讓我們頭回
過去看看這是什麼

335
00:17:14,520 --> 00:17:18,693
將打印，如果我們想要打印出來
所有在一周陣列的信息。

336
00:17:18,693 --> 00:17:20,859
好了，所以在這裡
在字符串連接，

337
00:17:20,859 --> 00:17:24,822
我有兩個選擇，串樓
V1，然後串建設V2。

338
00:17:24,822 --> 00:17:26,530
我們會看到為什麼我們
需要在第二V 2。

339
00:17:26,530 --> 00:17:28,610
但是，我要請點擊
串建築V1，這

340
00:17:28,610 --> 00:17:30,360
是我們的代碼
只是走一看，

341
00:17:30,360 --> 00:17:32,980
在與console.log的所有優點之一。

342
00:17:32,980 --> 00:17:35,910
如果讓這種打印的看
出我們所期望的。

343
00:17:35,910 --> 00:17:39,939
>> 星期一是一周中的天數01，
週二的一周的日數11。

344
00:17:39,939 --> 00:17:41,730
好吧，我試圖
這樣做有獲得

345
00:17:41,730 --> 00:17:46,280
它打印出週一的日數
之一，週二當天排名第二。

346
00:17:46,280 --> 00:17:50,140
但似乎像我
總是打印出的。

347
00:17:50,140 --> 00:17:51,260
好了，這是為什麼？

348
00:17:51,260 --> 00:17:55,600
嗯，事實證明，再看看
在這個代碼小片段在這裡。

349
00:17:55,600 --> 00:18:00,160
請注意，我們使用了加
操作者在兩個不同的上下文。

350
00:18:00,160 --> 00:18:03,221
>> 所以這裡的地方也許事情
我們已經那種一直在說，

351
00:18:03,221 --> 00:18:03,970
哦，它是如此之大。

352
00:18:03,970 --> 00:18:05,910
我們不與數據類型的處理了。

353
00:18:05,910 --> 00:18:08,220
但是，這裡的地方的事實
我們失去的數據類型

354
00:18:08,220 --> 00:18:10,960
實際上有點
對我們的一個問題。

355
00:18:10,960 --> 00:18:16,260
現在，再加上運營商是用來
連接字符串，並添加號碼

356
00:18:16,260 --> 00:18:19,550
同時，JavaScript有
盡最大的猜測

357
00:18:19,550 --> 00:18:22,030
至於什麼我希望它為我做。

358
00:18:22,030 --> 00:18:23,900
在這種情況下，它猜錯了。

359
00:18:23,900 --> 00:18:29,340
它只是級聯天，這將是
0個，一個，兩個，三個，四個，五個，或六個，

360
00:18:29,340 --> 00:18:32,060
然後它只是串聯
這一點，然後再連接到之一。

361
00:18:32,060 --> 00:18:35,020
它實際上並沒有把它們相加。

362
00:18:35,020 --> 00:18:37,320
所以這些語言，
PHP和JavaScript，

363
00:18:37,320 --> 00:18:39,196
這抽離
這個概念的類型，

364
00:18:39,196 --> 00:18:40,820
你沒有對付它了。

365
00:18:40,820 --> 00:18:43,600
他們還有引擎蓋下的類型。

366
00:18:43,600 --> 00:18:46,780
我們可以在情況
這樣，充分利用了這一事實

367
00:18:46,780 --> 00:18:49,240
說什麼
像這也許，這

368
00:18:49,240 --> 00:18:53,210
告訴JavaScript中，由
這樣，把它當作一個整數，

369
00:18:53,210 --> 00:18:57,100
不把它作為一個字符串，即使
雖然我們串混合在一起

370
00:18:57,100 --> 00:18:58,940
和整數這裡。

371
00:18:58,940 --> 00:19:02,204
>> 這只是其中的一件事情
它看起來如此之大的情況下

372
00:19:02,204 --> 00:19:04,120
我們不必
處理類型了，

373
00:19:04,120 --> 00:19:05,828
但有時你會
碰到這種情況

374
00:19:05,828 --> 00:19:09,110
完全一樣，其中的事實是
你沒有超過類型的控制

375
00:19:09,110 --> 00:19:11,220
可以對你適得其反
如果你不小心。

376
00:19:11,220 --> 00:19:18,285
所以，如果我們彈回過來IDE，我
又要清除我的控制台，

377
00:19:18,285 --> 00:19:20,660
我要去點擊字符串
建設二版，這

378
00:19:20,660 --> 00:19:23,052
在這裡我使用的解析INT功能。

379
00:19:23,052 --> 00:19:25,260
現在，它的打印出
我很期待的信息。

380
00:19:25,260 --> 00:19:29,330
週一的天數之一，星期二
是日數二，依此類推。

381
00:19:29,330 --> 00:19:31,170
>> 因此，讓我們來談談功能了。

382
00:19:31,170 --> 00:19:34,790
我答應大家會談論匿名
功能，現在的上下文為該

383
00:19:34,790 --> 00:19:36,360
終於到了。

384
00:19:36,360 --> 00:19:39,980
因此，在這樣做之前，我們再談
有關數組只是第二次。

385
00:19:39,980 --> 00:19:42,120
所以陣列是一個特殊的
情況下，對象的。

386
00:19:42,120 --> 00:19:45,180
事實上，一切都在
JavaScript是實際上的對象。

387
00:19:45,180 --> 00:19:47,190
因此，功能是
對象的特殊情況，

388
00:19:47,190 --> 00:19:49,770
整數是一個特殊的
情況下，對象的，

389
00:19:49,770 --> 00:19:52,152
但陣列專
有許多方法。

390
00:19:52,152 --> 00:19:55,110
請記住，因為他們的對象，
它們可以有屬性和方法。

391
00:19:55,110 --> 00:19:58,600
它們具有許多方法，這些方法
可以應用到那些對象。

392
00:19:58,600 --> 00:20:01,197
有一個叫方法
大小，array.size，

393
00:20:01,197 --> 00:20:03,030
這將返回到
你，你可能期望

394
00:20:03,030 --> 00:20:05,120
在您的陣列元素的數量。

395
00:20:05,120 --> 00:20:08,480
排序array.pop，像
我們突然離開的想法

396
00:20:08,480 --> 00:20:11,110
一摞，如果你還記得
從我們的堆棧視頻，

397
00:20:11,110 --> 00:20:13,810
刪除該數組中的最後一個元素。

398
00:20:13,810 --> 00:20:17,110
Array.push將一個新元素
到數組的末尾。

399
00:20:17,110 --> 00:20:20,910
array.shift是有點
喜歡DQ，它拼接出

400
00:20:20,910 --> 00:20:23,610
數組的第一個元素。

401
00:20:23,610 --> 00:20:27,549
>> 但也有另一種特殊
陣列的方法稱為地圖。

402
00:20:27,549 --> 00:20:29,340
這是排序的
有趣的概念。

403
00:20:29,340 --> 00:20:30,930
那麼，什麼是地圖的想法？

404
00:20:30,930 --> 00:20:33,880
你會真切地看到這
在其他幾種語言，

405
00:20:33,880 --> 00:20:38,550
我們不是在談論一個
排序製圖師繪製在這裡，

406
00:20:38,550 --> 00:20:41,480
我們談論的是一個映射功能。

407
00:20:41,480 --> 00:20:44,110
在上下文我們
這裡講的，地圖

408
00:20:44,110 --> 00:20:47,950
是一種特殊的操作，我們
可以在陣列上執行

409
00:20:47,950 --> 00:20:51,630
以應用的特定功能
該數組的每個元素。

410
00:20:51,630 --> 00:20:55,190
所以我們會說
這種情況下，也許array.map，

411
00:20:55,190 --> 00:21:00,330
而在它的內部，我們傳遞
進入地圖，我們希望有一個功能

412
00:21:00,330 --> 00:21:02,430
要施加到每一個元素。

413
00:21:02,430 --> 00:21:07,299
所以，這有點類似於使用
一個循環的每個元素遍歷

414
00:21:07,299 --> 00:21:09,340
和應用特定
功能是每一個元素，

415
00:21:09,340 --> 00:21:14,830
只是JavaScript的有這個建於
概念可以應用的映射。

416
00:21:14,830 --> 00:21:19,700
這是一個很大的背景下
談論一個匿名函數。

417
00:21:19,700 --> 00:21:22,370
>> 所以我們可以說，我們有
這個整數數組。

418
00:21:22,370 --> 00:21:25,370
這就是所謂的NUMS，並且它有5
東西在裡面，一，二，三，四，

419
00:21:25,370 --> 00:21:26,410
五。

420
00:21:26,410 --> 00:21:30,620
現在，我要地圖的一些
功能上這個數組。

421
00:21:30,620 --> 00:21:34,337
我想有一個函數應用
到陣列的每個元素。

422
00:21:34,337 --> 00:21:37,420
好吧，讓我們說，我想
要做的只是加倍的所有元素。

423
00:21:37,420 --> 00:21:42,520
我能做的只是使用一個循環
為變種我等於0，I小於

424
00:21:42,520 --> 00:21:47,390
或等於4，我加，再加上，並
再翻一番每一個號碼。

425
00:21:47,390 --> 00:21:49,580
但我也可以做這樣的事情。

426
00:21:49,580 --> 00:21:53,420
我可以說NUMS前身
一二三四五，

427
00:21:53,420 --> 00:21:58,310
不過，現在，我想你
應用映射到這個數組

428
00:21:58,310 --> 00:22:00,400
在這裡我想你
翻番每一個數字。

429
00:22:00,400 --> 00:22:02,540
而這正是
這裡發生了什麼。

430
00:22:02,540 --> 00:22:06,870
但是請注意什麼，我路過
在作為參數映射。

431
00:22:06,870 --> 00:22:09,080
這是一個匿名函數。

432
00:22:09,080 --> 00:22:11,140
並注意我沒有給
此函數的名稱，

433
00:22:11,140 --> 00:22:13,290
我只給它一個參數列表。

434
00:22:13,290 --> 00:22:16,370
所以這是一個例子
一個匿名函數。

435
00:22:16,370 --> 00:22:21,270
>> 我們通常將永遠不會調用此
地圖的上下文之外的功能。

436
00:22:21,270 --> 00:22:24,110
我們將其定義為一個參數
映射，所以我們真的不

437
00:22:24,110 --> 00:22:27,910
需要有一個名字為它，如果
在乎唯一的事情就是地圖

438
00:22:27,910 --> 00:22:30,339
和它的正確定義
地圖在裡面。

439
00:22:30,339 --> 00:22:31,880
所以這是一個匿名函數。

440
00:22:31,880 --> 00:22:34,680
我們一直沒能
預先這樣做。

441
00:22:34,680 --> 00:22:38,400
地圖部分功能
接受一個參數，NUM，

442
00:22:38,400 --> 00:22:41,890
而該函數的作用是什麼
在返回NUM的2倍。

443
00:22:41,890 --> 00:22:45,330
所以在此之後
測繪中得到應用，

444
00:22:45,330 --> 00:22:50,090
這是現在什麼NUMS長相
像，二，四，六，八，十。

445
00:22:50,090 --> 00:22:52,090
我們會突然到我
瀏覽器窗口和公正

446
00:22:52,090 --> 00:22:55,240
看看這個
真的很快為好。

447
00:22:55,240 --> 00:22:58,000
>> 所以，我在這裡有另一個按鈕
在我的主頁稱為雙。

448
00:22:58,000 --> 00:23:03,570
當我點擊加倍，它告訴
我之前是一，二，三，四，

449
00:23:03,570 --> 00:23:07,250
後五二，四，六，八，10。

450
00:23:07,250 --> 00:23:11,930
如果我回去，然後單擊雙
再次，二，四，六，八，十。

451
00:23:11,930 --> 00:23:17,400
再經過，四個，
8，12，16，然後20。

452
00:23:17,400 --> 00:23:20,440
而我是什麼在這個功能做什麼？

453
00:23:20,440 --> 00:23:25,210
那麼，如果我們只是彈出交給IDE和
我拉起我的匿名函數，在這裡

454
00:23:25,210 --> 00:23:28,780
在七號線到13，我
做一點點花哨的工作在這裡，

455
00:23:28,780 --> 00:23:32,240
但我只是打印出
什麼是當前的數組中開始。

456
00:23:32,240 --> 00:23:36,580
然後在線路16，17，
18，還有我的地圖。

457
00:23:36,580 --> 00:23:40,930
這是我在應用此增加一倍
功能到每一個元素。

458
00:23:40,930 --> 00:23:43,530
再遠一點下來，
我只是在做同樣的事情

459
00:23:43,530 --> 00:23:46,640
我在做之前，但現在我
打印出數組的內容

460
00:23:46,640 --> 00:23:48,167
之後。

461
00:23:48,167 --> 00:23:50,500
但是，所有我所做的是
只需使用一個匿名函數

462
00:23:50,500 --> 00:23:53,640
到在整個陣列映射。

463
00:23:53,640 --> 00:23:58,466
>> 因此，多一個很大的話題談談
JavaScript是一個事件的概念。

464
00:23:58,466 --> 00:24:01,590
事件是什麼，正好
當用戶與您的網絡交互

465
00:24:01,590 --> 00:24:04,715
頁面，所以也許他們點擊的東西，
或者在頁面加載完成，

466
00:24:04,715 --> 00:24:07,200
或者他們已經感動
他們的鼠標的東西，

467
00:24:07,200 --> 00:24:09,290
或者他們已經輸入的東西
在輸入字段。

468
00:24:09,290 --> 00:24:14,260
所有這些事情都是事件
這是發生在我們的網頁上。

469
00:24:14,260 --> 00:24:17,460
和JavaScript有
功能支持的時候

470
00:24:17,460 --> 00:24:21,760
調用的事件處理程序，
是一個回調函數

471
00:24:21,760 --> 00:24:23,329
響應的HTML事件。

472
00:24:23,329 --> 00:24:24,620
什麼是一個回調函數？

473
00:24:24,620 --> 00:24:27,328
那麼，它通常只是一個
名匿名函數。

474
00:24:27,328 --> 00:24:30,170
這是一個函數，
響應一個事件。

475
00:24:30,170 --> 00:24:34,130
而這正是我們來到了
結合某些功能的想法

476
00:24:34,130 --> 00:24:38,060
到一個特定的HTML屬性。

477
00:24:38,060 --> 00:24:41,420
大多數HTML元素有
對於屬性的支持

478
00:24:41,420 --> 00:24:45,170
我們沒有談論的HTML
這樣的事情在點擊視頻

479
00:24:45,170 --> 00:24:50,540
或懸停或負載，
所有這些事件

480
00:24:50,540 --> 00:24:53,120
然後你可以寫函數
該處理這些事件

481
00:24:53,120 --> 00:24:56,090
當這些事件
出現在網頁上。

482
00:24:56,090 --> 00:24:59,170
>> 所以，也許你的HTML
看起來是這樣的。

483
00:24:59,170 --> 00:25:02,240
我有兩個按鈕在這裡，
按鈕一個，兩個按鈕，

484
00:25:02,240 --> 00:25:04,620
這裡我有現在
定義什麼都沒有，

485
00:25:04,620 --> 00:25:11,170
但是，這是其中所述屬性
點擊顯然是我的HTML標記的一部分。

486
00:25:11,170 --> 00:25:15,220
所以很明顯，當我定義什麼是
該屬性中的想法，

487
00:25:15,220 --> 00:25:18,590
這將是一些JavaScript
函數，響應該事件

488
00:25:18,590 --> 00:25:24,360
想必點擊的
按鈕一鍵兩種。

489
00:25:24,360 --> 00:25:28,580
>> 有什麼樣的很酷，這是我們
可以寫一個通用的事件處理程序。

490
00:25:28,580 --> 00:25:32,370
而這個事件處理程序將
創建事件對象。

491
00:25:32,370 --> 00:25:37,000
而事件對象會告訴我們
這兩個按鈕被點擊。

492
00:25:37,000 --> 00:25:38,064
現在怎麼運作的？

493
00:25:38,064 --> 00:25:39,730
那麼，它可能會是這個樣子。

494
00:25:39,730 --> 00:25:44,860
因此，我們將首先定義我們的按鈕
不得不回調一個響應

495
00:25:44,860 --> 00:25:47,470
函數將被調用
單擊該按鈕時，

496
00:25:47,470 --> 00:25:49,520
我們稱之為事件警報名。

497
00:25:49,520 --> 00:25:53,320
並注意在這兩種情況下，我們是
通過本次活動參數。

498
00:25:53,320 --> 00:25:55,460
因此，我們調用這個函數
或者這個功能時，

499
00:25:55,460 --> 00:26:00,330
由事件發生觸發，
它會創建這個事件對象

500
00:26:00,330 --> 00:26:03,300
並把它作為一個
參數警報名稱。

501
00:26:03,300 --> 00:26:07,270
而該事件的對象是
要包含的信息

502
00:26:07,270 --> 00:26:09,800
哪個按鈕被點擊。

503
00:26:09,800 --> 00:26:11,580
它是如何做到這一點？

504
00:26:11,580 --> 00:26:13,654
那麼，它可能會是這個樣子。

505
00:26:13,654 --> 00:26:15,570
所以，現在在我的獨立
JavaScript文件，我可能

506
00:26:15,570 --> 00:26:17,420
要找到這個
功能警報名稱，

507
00:26:17,420 --> 00:26:19,500
再次接受事件參數。

508
00:26:19,500 --> 00:26:24,640
然後這裡是我檢測
該按鈕被觸發，

509
00:26:24,640 --> 00:26:28,100
VAR觸發等於事件
點源元素。

510
00:26:28,100 --> 00:26:33,150
那是什麼創建的源
這是通過本次活動的對象？

511
00:26:33,150 --> 00:26:36,390
是不是按鈕一次，抑或是兩個按鈕？

512
00:26:36,390 --> 00:26:40,710
>> 然後，在這裡我做的是
打印出trigger.innerhtml。

513
00:26:40,710 --> 00:26:43,860
那麼，在這種情況下，在該
的背景下，trigger.innerhtml

514
00:26:43,860 --> 00:26:45,940
只是寫了什麼按鈕。

515
00:26:45,940 --> 00:26:48,830
碰巧，如果我們跳
回一秒鐘，那會

516
00:26:48,830 --> 00:26:51,670
是什麼在這些按鈕標記之間。

517
00:26:51,670 --> 00:26:54,150
這將是按鈕的一個或兩個按鈕。

518
00:26:54,150 --> 00:26:57,320
讓我們來看看
如何事件處理程序會

519
00:26:57,320 --> 00:27:01,080
看，如果我們有它運行在實踐中。

520
00:27:01,080 --> 00:27:03,850
>> 所以首先，你
開闢了events.js，

521
00:27:03,850 --> 00:27:06,517
這是JavaScript文件，其中
我已經定義了這個功能。

522
00:27:06,517 --> 00:27:08,558
正如你所看到的，這是
幾乎什麼

523
00:27:08,558 --> 00:27:10,230
我們只是在一秒鐘前看到的幻燈片。

524
00:27:10,230 --> 00:27:14,890
我會去到了
我們一直在使用的主頁。

525
00:27:14,890 --> 00:27:17,660
而我這裡按鈕
一個，兩個按鈕。

526
00:27:17,660 --> 00:27:19,820
我會按一下按鈕之一。

527
00:27:19,820 --> 00:27:23,930
你點擊的按鈕之一，如果你
可以看到這裡的戒備。

528
00:27:23,930 --> 00:27:25,810
好。

529
00:27:25,810 --> 00:27:28,980
點擊兩個按鈕，您
點擊一個按鈕兩種。

530
00:27:28,980 --> 00:27:32,150
>> 因此，這兩個按鈕具有
同樣的函數調用，對不對？

531
00:27:32,150 --> 00:27:35,840
他們都警覺名
事件，但此事件對象

532
00:27:35,840 --> 00:27:41,900
這被創建時，我們點擊
它告訴我們哪個按鈕被點擊。

533
00:27:41,900 --> 00:27:44,650
我們沒有寫兩個獨立
功能或處理有

534
00:27:44,650 --> 00:27:46,470
通過任何其他信息。

535
00:27:46,470 --> 00:27:48,220
我們只是依靠
什麼樣的JavaScript會

536
00:27:48,220 --> 00:27:53,772
做對我們來說，這是創建
排序代表我們的活動對象。

537
00:27:53,772 --> 00:27:56,730
還有很多事情需要JavaScript的比
我們已經討論了在這段視頻中，

538
00:27:56,730 --> 00:27:58,521
但有這些
根本應該讓你

539
00:27:58,521 --> 00:28:00,690
相當長的方式來
學習一切你

540
00:28:00,690 --> 00:28:04,030
需要了解這一
有趣的語言。

541
00:28:04,030 --> 00:28:05,000
我是道格·勞埃德。

542
00:28:05,000 --> 00:28:07,010
這是CS50。

543
00:28:07,010 --> 00:28:09,181