日韩无码专区无码一级三级片|91人人爱网站中日韩无码电影|厨房大战丰满熟妇|AV高清无码在线免费观看|另类AV日韩少妇熟女|中文日本大黄一级黄色片|色情在线视频免费|亚洲成人特黄a片|黄片wwwav色图欧美|欧亚乱色一区二区三区

我在我的 Instagram 上每天都會發(fā)布 JavaScript 的選擇題，并且同時也會在這個倉庫中發(fā)布。

創(chuàng)新互聯(lián)專業(yè)為企業(yè)提供獨山子網站建設、獨山子做網站、獨山子網站設計、獨山子網站制作等企業(yè)網站建設、網頁設計與制作、獨山子企業(yè)網站模板建站服務，10余年獨山子做網站經驗，不只是建網站，更提供有價值的思路和整體網絡服務。

從基礎到進階，測試你有多了解 JavaScript，刷新你的知識，或者幫助你的 coding 面試！

muscle rocket 我每周都會在這個倉庫下更新新的問題。

答案在問題的下方。祝你好運 heart

1. 輸出是什么？ 

 
 
 
 

  
  
  
  
function sayHi() {  
  
  
  
  
  console.log(name)  
  
  
  
  
  console.log(age)  
  
  
  
  
  var name = 'Lydia'  
  
  
  
  
  let age = 21  
  
  
  
  
}  
  
  
  
  
sayHi() 
 
 
 
 

•  A: Lydia 和 undefined
•  B: Lydia 和 ReferenceError
•  C: ReferenceError 和 21
•  D: undefined 和 ReferenceError

答案: D

在函數(shù)內部，我們首先通過 var 關鍵字聲明了 name 變量。這意味著變量被提升了（內存空間在創(chuàng)建階段就被設置好了），直到程序運行到定義變量位置之前默認值都是 undefined。因為當我們打印 name 變量時還沒有執(zhí)行到定義變量的位置，因此變量的值保持為 undefined。

通過 let 和 const 關鍵字聲明的變量也會提升，但是和 var 不同，它們不會被初始化。在我們聲明（初始化）之前是不能訪問它們的。這個行為被稱之為暫時性死區(qū)。當我們試圖在聲明之前訪問它們時，JavaScript 將會拋出一個 ReferenceError 錯誤。

2. 輸出是什么？ 

 
 
 
 

  
  
  
  
for (var i = 0; i < 3; i++) {  
  
  
  
  
  setTimeout(() => console.log(i), 1)  
  
  
  
  
}  
  
  
  
  
for (let i = 0; i < 3; i++) {  
  
  
  
  
  setTimeout(() => console.log(i), 1)  
  
  
  
  
} 
 
 
 
 

•  A: 0 1 2 和 0 1 2
•  B: 0 1 2 和 3 3 3
•  C: 3 3 3 和 0 1 2

答案: C

由于 JavaScript 的事件循環(huán)，setTimeout 回調會在遍歷結束后才執(zhí)行。因為在第一個遍歷中遍歷 i 是通過 var 關鍵字聲明的，所以這個值是全局作用域下的。在遍歷過程中，我們通過一元操作符 ++ 來每次遞增 i 的值。當 setTimeout 回調執(zhí)行的時候，i 的值等于 3。

在第二個遍歷中，遍歷 i 是通過 let 關鍵字聲明的：通過 let 和 const 關鍵字聲明的變量是擁有塊級作用域（指的是任何在 {} 中的內容）。在每次的遍歷過程中，i 都有一個新值，并且每個值都在循環(huán)內的作用域中。

3. 輸出是什么？ 

 
 
 
 

  
  
  
  
const shape = {  
  
  
  
  
  radius: 10,  
  
  
  
  
  diameter() {  
  
  
  
  
    return this.radius * 2  
  
  
  
  
  },  
  
  
  
  
  perimeter: () => 2 * Math.PI * this.radius  
  
  
  
  
}  
  
  
  
  
shape.diameter()  
  
  
  
  
shape.perimeter() 
 
 
 
 

•  A: 20 和 62.83185307179586
•  B: 20 和 NaN
•  C: 20 和 63
•  D: NaN 和 63

答案: B

注意 diameter 的值是一個常規(guī)函數(shù)，但是 perimeter 的值是一個箭頭函數(shù)。

對于箭頭函數(shù)，this 關鍵字指向的是它當前周圍作用域（簡單來說是包含箭頭函數(shù)的常規(guī)函數(shù)，如果沒有常規(guī)函數(shù)的話就是全局對象），這個行為和常規(guī)函數(shù)不同。這意味著當我們調用 perimeter 時，this 不是指向 shape 對象，而是它的周圍作用域（在例子中是 window）。

在 window 中沒有 radius 這個屬性，因此返回 undefined。

4. 輸出是什么？ 

 
 
 
 

  
  
  
  
+true;  
  
  
  
  
!"Lydia"; 
 
 
 
 

•  A: 1 和 false
•  B: false 和 NaN
•  C: false 和 false

答案: A

一元操作符加號嘗試將 bool 轉為 number。true 轉換為 number 的話為 1，false 為 0。

字符串 'Lydia' 是一個真值，真值取反那么就返回 false。

5. 哪一個是無效的？ 

 
 
 
 

  
  
  
  
const bird = {  
  
  
  
  
  size: 'small'  
  
  
  
  
}  
  
  
  
  
const mouse = {  
  
  
  
  
  name: 'Mickey',  
  
  
  
  
  small: true  
  
  
  
  
} 
 
 
 
 

•  A: mouse.bird.size
•  B: mouse[bird.size]
•  C: mouse[bird["size"]]
•  D: 全部有效

答案: A

在 JavaScript 中，所有對象的 keys 都是字符串（除非對象是 Symbol）。盡管我們可能不會定義它們?yōu)樽址?，但它們在底層總會被轉換為字符串。

當我們使用括號語法時（[]），JavaScript 會解釋（或者 unboxes）語句。它首先看到第一個開始括號 [ 并繼續(xù)前進直到找到結束括號 ]。只有這樣，它才會計算語句的值。

mouse[bird.size]：首先計算 bird.size，這會得到 small。mouse["small"] 返回 true。

然后使用點語法的話，上面這一切都不會發(fā)生。mouse 沒有 bird 這個 key，這也就意味著 mouse.bird 是 undefined。然后當我們使用點語法 mouse.bird.size 時，因為 mouse.bird 是 undefined，這也就變成了 undefined.size。這個行為是無效的，并且會拋出一個錯誤類似 Cannot read property "size" of undefined。

6. 輸出是什么？ 

 
 
 
 

  
  
  
  
let c = { greeting: 'Hey!' }  
  
  
  
  
let d  
  
  
  
  
d = c  
  
  
  
  
c.greeting = 'Hello'  
  
  
  
  
console.log(d.greeting) 
 
 
 
 

•  A: Hello
•  B: undefined
•  C: ReferenceError
•  D: TypeError

答案: A

在 JavaScript 中，當設置兩個對象彼此相等時，它們會通過引用進行交互。

首先，變量 c 的值是一個對象。接下來，我們給 d 分配了一個和 c 對象相同的引用。

因此當我們改變其中一個對象時，其實是改變了所有的對象。

7. 輸出是什么？ 

 
 
 
 

  
  
  
  
let a = 3  
  
  
  
  
let b = new Number(3)  
  
  
  
  
let c = 3  
  
  
  
  
console.log(a == b)  
  
  
  
  
console.log(a === b)  
  
  
  
  
console.log(b === c) 
 
 
 
 

•  A: true false true
•  B: false false true
•  C: true false false
•  D: false true true

答案: C

new Number() 是一個內建的函數(shù)構造器。雖然它看著像是一個 number，但它實際上并不是一個真實的 number：它有一堆額外的功能并且它是一個對象。

當我們使用 == 操作符時，它只會檢查兩者是否擁有相同的值。因為它們的值都是 3，因此返回 true。

然后，當我們使用 === 操作符時，兩者的值以及類型都應該是相同的。new Number() 是一個對象而不是 number，因此返回 false。

8. 輸出是什么？ 

 
 
 
 

  
  
  
  
class Chameleon {  
  
  
  
  
  static colorChange(newColor) {  
  
  
  
  
    this.newColor = newColor  
  
  
  
  
    return this.newColor  
  
  
  
  
  }  
  
  
  
  
  constructor({ newColor = 'green' } = {}) {  
  
  
  
  
    this.newColor = newColor  
  
  
  
  
  }  
  
  
  
  
}  
  
  
  
  
const freddie = new Chameleon({ newColor: 'purple' })  
  
  
  
  
freddie.colorChange('orange') 
 
 
 
 

•  A: orange
•  B: purple
•  C: green
•  D: TypeError

答案: D

colorChange 是一個靜態(tài)方法。靜態(tài)方法被設計為只能被創(chuàng)建它們的構造器使用（也就是 Chameleon），并且不能傳遞給實例。因為 freddie 是一個實例，靜態(tài)方法不能被實例使用，因此拋出了 TypeError 錯誤。

9. 輸出是什么？ 

 
 
 
 

  
  
  
  
let greeting  
  
  
  
  
greetign = {} // Typo!  
  
  
  
  
console.log(greetign) 
 
 
 
 

•  A: {}
•  B: ReferenceError: greetign is not defined
•  C: undefined

答案: A

代碼打印出了一個對象，這是因為我們在全局對象上創(chuàng)建了一個空對象！當我們將 greeting 寫錯成 greetign 時，JS 解釋器實際在上瀏覽器中將它視為 global.greetign = {} （或者 window.greetign = {}）。

為了避免這個為題，我們可以使用 "use strict"。這能確保當你聲明變量時必須賦值。

10. 當我們這么做時，會發(fā)生什么？ 

 
 
 
 

  
  
  
  
function bark() {  
  
  
  
  
  console.log('Woof!')  
  
  
  
  
}  
  
  
  
  
bark.animal = 'dog' 
 
 
 
 

•  A: 正常運行!
•  B: SyntaxError. 你不能通過這種方式給函數(shù)增加屬性。
•  C: undefined
•  D: ReferenceError

答案: A

這在 JavaScript 中是可以的，因為函數(shù)是對象?。ǔ嘶绢愋椭馄渌际菍ο螅?/p>

函數(shù)是一個特殊的對象。你寫的這個代碼其實不是一個實際的函數(shù)。函數(shù)是一個擁有屬性的對象，并且屬性也可被調用。

11. 輸出是什么？ 

 
 
 
 

  
  
  
  
function Person(firstName, lastName) {  
  
  
  
  
  this.firstName = firstName;  
  
  
  
  
  this.lastName = lastName;  
  
  
  
  
}  
  
  
  
  
const member = new Person("Lydia", "Hallie");  
  
  
  
  
Person.getFullName = function () {  
  
  
  
  
  return `${this.firstName} ${this.lastName}`;  
  
  
  
  
}  
  
  
  
  
console.log(member.getFullName()); 
 
 
 
 

•  A: TypeError
•  B: SyntaxError
•  C: Lydia Hallie
•  D: undefined undefined

答案: A

你不能像常規(guī)對象那樣，給構造函數(shù)添加屬性。如果你想一次性給所有實例添加特性，你應該使用原型。因此本例中，使用如下方式： 

 
 
 
 

  
  
  
  
Person.prototype.getFullName = function () {  
  
  
  
  
  return `${this.firstName} ${this.lastName}`;  
  
  
  
  
} 
 
 
 
 

這才會使 member.getFullName() 起作用。為什么這么做有益的？假設我們將這個方法添加到構造函數(shù)本身里。也許不是每個 Person 實例都需要這個方法。這將浪費大量內存空間，因為它們仍然具有該屬性，這將占用每個實例的內存空間。相反，如果我們只將它添加到原型中，那么它只存在于內存中的一個位置，但是所有實例都可以訪問它！

12. 輸出是什么？ 

 
 
 
 

  
  
  
  
function Person(firstName, lastName) {  
  
  
  
  
  this.firstName = firstName  
  
  
  
  
  this.lastName = lastName  
  
  
  
  
}  
  
  
  
  
const lydia = new Person('Lydia', 'Hallie')  
  
  
  
  
const sarah = Person('Sarah', 'Smith')  
  
  
  
  
console.log(lydia)  
  
  
  
  
console.log(sarah) 
 
 
 
 

•  A: Person {firstName: "Lydia", lastName: "Hallie"} 和 undefined
•  B: Person {firstName: "Lydia", lastName: "Hallie"} 和 Person {firstName: "Sarah", lastName: "Smith"}
•  C: Person {firstName: "Lydia", lastName: "Hallie"} 和 {}
•  D:Person {firstName: "Lydia", lastName: "Hallie"} 和 ReferenceError

答案: A

對于 sarah，我們沒有使用 new 關鍵字。當使用 new 時，this 引用我們創(chuàng)建的空對象。當未使用 new 時，this 引用的是全局對象（global object）。

我們說 this.firstName 等于 "Sarah"，并且 this.lastName 等于 "Smith"。實際上我們做的是，定義了 global.firstName = 'Sarah' 和 global.lastName = 'Smith'。而 sarah 本身是 undefined。

13. 事件傳播的三個階段是什么？

•  A: Target > Capturing > Bubbling
•  B: Bubbling > Target > Capturing
•  C: Target > Bubbling > Capturing
•  D: Capturing > Target > Bubbling

答案: D

在捕獲（capturing）階段中，事件從祖先元素向下傳播到目標元素。當事件達到目標（target）元素后，冒泡（bubbling）才開始。

14. 所有對象都有原型。

•  A: true
•  B: false

答案: B

除了基本對象（base object），所有對象都有原型?；緦ο罂梢栽L問一些方法和屬性，比如 .toString。這就是為什么你可以使用內置的 JavaScript 方法！所有這些方法在原型上都是可用的。雖然 JavaScript 不能直接在對象上找到這些方法，但 JavaScript 會沿著原型鏈找到它們，以便于你使用。

15. 輸出是什么？ 

 
 
 
 

  
  
  
  
function sum(a, b) {  
  
  
  
  
  return a + b  
  
  
  
  
}  
  
  
  
  
sum(1, '2') 
 
 
 
 

•  A: NaN
•  B: TypeError
•  C: "12"
•  D: 3

答案: C

JavaScript 是一種動態(tài)類型語言：我們不指定某些變量的類型。值可以在你不知道的情況下自動轉換成另一種類型，這種類型稱為隱式類型轉換（implicit type coercion）。Coercion 是指將一種類型轉換為另一種類型。

在本例中，JavaScript 將數(shù)字 1 轉換為字符串，以便函數(shù)有意義并返回一個值。在數(shù)字類型（1）和字符串類型（'2'）相加時，該數(shù)字被視為字符串。我們可以連接字符串，比如 "Hello" + "World"，這里發(fā)生的是 "1" + "2"，它返回 "12"。

16. 輸出是什么？ 

 
 
 
 

  
  
  
  
let number = 0  
  
  
  
  
console.log(number++)  
  
  
  
  
console.log(++number)  
  
  
  
  
console.log(number) 
 
 
 
 

•  A: 1 1 2
•  B: 1 2 2
•  C: 0 2 2
•  D: 0 1 2

答案: C

一元后自增運算符 ++：

1.  返回值（返回 0）
2.  值自增（number 現(xiàn)在是 1）

一元前自增運算符 ++：

1.  值自增（number 現(xiàn)在是 2）
2.  返回值（返回 2）

結果是 0 2 2.

17. 輸出是什么？ 

 
 
 
 

  
  
  
  
function getPersonInfo(one, two, three) {  
  
  
  
  
  console.log(one)  
  
  
  
  
  console.log(two)  
  
  
  
  
  console.log(three)  
  
  
  
  
}  
  
  
  
  
const person = 'Lydia'  
  
  
  
  
const age = 21  
  
  
  
  
getPersonInfo`${person} is ${age} years old` 
 
 
 
 

•  A: "Lydia" 21 ["", " is ", " years old"]
•  B: ["", " is ", " years old"] "Lydia" 21
•  C: "Lydia" ["", " is ", " years old"] 21

答案: B

如果使用標記模板字面量，第一個參數(shù)的值總是包含字符串的數(shù)組。其余的參數(shù)獲取的是傳遞的表達式的值！

18. 輸出是什么？ 

 
 
 
 

  
  
  
  
function checkAge(data) {  
  
  
  
  
  if (data === { age: 18 }) {  
  
  
  
  
    console.log('You are an adult!')  
  
  
  
  
  } else if (data == { age: 18 }) {  
  
  
  
  
    console.log('You are still an adult.')  
  
  
  
  
  } else {  
  
  
  
  
    console.log(`Hmm.. You don't have an age I guess`)  
  
  
  
  
  }  
  
  
  
  
}  
  
  
  
  
checkAge({ age: 18 }) 
 
 
 
 

•  A: You are an adult!
•  B: You are still an adult.
•  C: Hmm.. You don't have an age I guess

答案: C

在測試相等性時，基本類型通過它們的值（value）進行比較，而對象通過它們的引用（reference）進行比較。JavaScript 檢查對象是否具有對內存中相同位置的引用。

題目中我們正在比較的兩個對象不是同一個引用：作為參數(shù)傳遞的對象引用的內存位置，與用于判斷相等的對象所引用的內存位置并不同。

這也是 { age: 18 } === { age: 18 } 和 { age: 18 } == { age: 18 } 都返回 false 的原因。

19. 輸出是什么？ 

 
 
 
 

  
  
  
  
function getAge(...args) {  
  
  
  
  
  console.log(typeof args)  
  
  
  
  
}  
  
  
  
  
getAge(21) 
 
 
 
 

•  A: "number"
•  B: "array"
•  C: "object"
•  D: "NaN"

答案: C

擴展運算符（...args）會返回實參組成的數(shù)組。而數(shù)組是對象，因此 typeof args 返回 "object"。

20. 輸出是什么？ 

 
 
 
 

  
  
  
  
function getAge() {  
  
  
  
  
  'use strict'  
  
  
  
  
  age = 21  
  
  
  
  
  console.log(age)  
  
  
  
  
}  
  
  
  
  
getAge() 
 
 
 
 

•  A: 21
•  B: undefined
•  C: ReferenceError
•  D: TypeError

答案: C

使用 "use strict"，你可以確保不會意外地聲明全局變量。我們從來沒有聲明變量 age，因為我們使用 "use strict"，它將拋出一個引用錯誤。如果我們不使用 "use strict"，它就會工作，因為屬性 age 會被添加到全局對象中了。

21. 輸出是什么？ 

 
 
 
 

  
  
  
  
const sum = eval('10*10+5') 
 
 
 
 

•  A: 105
•  B: "105"
•  C: TypeError
•  D: "10*10+5"

答案: A

代碼以字符串形式傳遞進來，eval 對其求值。如果它是一個表達式，就像本例中那樣，它對表達式求值。表達式是 10 * 10 + 5。這將返回數(shù)字 105。

22. cool_secret 可訪問多長時間？ 

 
 
 
 

  
  
  
  
sessionStorage.setItem('cool_secret', 123) 
 
 
 
 

•  A: 永遠，數(shù)據(jù)不會丟失。
•  B: 當用戶關掉標簽頁時。
•  C: 當用戶關掉整個瀏覽器，而不只是關掉標簽頁。
•  D: 當用戶關閉電腦時。

答案: B

關閉 tab 標簽頁 后，sessionStorage 存儲的數(shù)據(jù)才會刪除。

如果使用 localStorage，那么數(shù)據(jù)將永遠在那里，除非調用了 localStorage.clear()。

23. 輸出是什么？ 

 
 
 
 

  
  
  
  
var num = 8    
  
  
  
  
var num = 10   
  
  
  
  
console.log(num) 
 
 
 
 

•  A: 8
•  B: 10
•  C: SyntaxError
•  D: ReferenceError

答案: B

使用 var 關鍵字，你可以用相同的名稱聲明多個變量。然后變量將保存最新的值。

你不能使用 let 或 const 來實現(xiàn)這一點，因為它們是塊作用域的。

24. 輸出是什么？ 

 
 
 
 

  
  
  
  
const obj = { 1: 'a', 2: 'b', 3: 'c' }  
  
  
  
  
const set = new Set([1, 2, 3, 4, 5])  
  
  
  
  
obj.hasOwnProperty('1')  
  
  
  
  
obj.hasOwnProperty(1)  
  
  
  
  
set.has('1')  
  
  
  
  
set.has(1) 
 
 
 
 

•  A: false true false true
•  B: false true true true
•  C: true true false true
•  D: true true true true

答案: C

所有對象的鍵（不包括 Symbol）在底層都是字符串，即使你自己沒有將其作為字符串輸入。這就是為什么 obj.hasOwnProperty('1') 也返回 true。

對于集合，它不是這樣工作的。在我們的集合中沒有 '1'：set.has('1') 返回 false。它有數(shù)字類型為 1，set.has(1) 返回 true。

25. 輸出是什么？ 

 
 
 
 

  
  
  
  
const obj = { a: 'one', b: 'two', a: 'three' }  
  
  
  
  
console.log(obj) 
 
 
 
 

•  A: { a: "one", b: "two" }
•  B: { b: "two", a: "three" }
•  C: { a: "three", b: "two" }
•  D: SyntaxError

答案: C

如果你有兩個名稱相同的鍵，則鍵會被替換掉。它仍然位于第一個鍵出現(xiàn)的位置，但是值是最后出現(xiàn)那個鍵的值。

26. JavaScript 全局執(zhí)行上下文為你做了兩件事：全局對象和 this 關鍵字。

•  A: true
•  B: false
•  C: it depends

答案: A

基本執(zhí)行上下文是全局執(zhí)行上下文：它是代碼中隨處可訪問的內容。

27. 輸出是什么？ 

 
 
 
 

  
  
  
  
for (let i = 1; i < 5; i++) {  
  
  
  
  
  if (i === 3) continue  
  
  
  
  
  console.log(i)  
  
  
  
  
} 
 
 
 
 

•  A: 1 2
•  B: 1 2 3
•  C: 1 2 4
•  D: 1 3 4

答案: C

如果某個條件返回 true，則 continue 語句跳過本次迭代。

28. 輸出是什么？ 

 
 
 
 

  
  
  
  
String.prototype.giveLydiaPizza = () => {  
  
  
  
  
  return 'Just give Lydia pizza already!'  
  
  
  
  
}  
  
  
  
  
const name = 'Lydia'  
  
  
  
  
name.giveLydiaPizza() 
 
 
 
 

•  A: "Just give Lydia pizza already!"
•  B: TypeError: not a function
•  C: SyntaxError
•  D: undefined

答案: A

String 是內置的構造函數(shù)，我們可以向它添加屬性。我只是在它的原型中添加了一個方法?；绢愋妥址蛔詣愚D換為字符串對象，由字符串原型函數(shù)生成。因此，所有 string(string 對象)都可以訪問該方法！

29. 輸出是什么？ 

 
 
 
 

  
  
  
  
const a = {}  
  
  
  
  
const b = { key: 'b' }  
  
  
  
  
const c = { key: 'c' }  
  
  
  
  
a[b] = 123  
  
  
  
  
a[c] = 456  
  
  
  
  
console.log(a[b]) 
 
 
 
 

•  A: 123
•  B: 456
•  C: undefined
•  D: ReferenceError

答案: B

對象的鍵被自動轉換為字符串。我們試圖將一個對象 b 設置為對象 a 的鍵，且相應的值為 123。

然而，當字符串化一個對象時，它會變成 "[object Object]"。因此這里說的是，a["[object Object]"] = 123。然后，我們再一次做了同樣的事情，c 是另外一個對象，這里也有隱式字符串化，于是，a["[object Object]"] = 456。

然后，我們打印 a[b]，也就是 a["[object Object]"]。之前剛設置為 456，因此返回的是 456。

30. 輸出是什么？ 

 
 
 
 

  
  
  
  
const foo = () => console.log('First')  
  
  
  
  
const bar = () => setTimeout(() => console.log('Second'))  
  
  
  
  
const baz = () => console.log('Third')  
  
  
  
  
bar()  
  
  
  
  
foo()  
  
  
  
  
baz() 
 
 
 
 

•  A: First Second Third
•  B: First Third Second
•  C: Second First Third
•  D: Second Third First

答案: B

我們有一個 setTimeout 函數(shù)，并首先調用它。然而，它是最后打印日志的。

這是因為在瀏覽器中，我們不僅有運行時引擎，還有一個叫做 WebAPI 的東西。WebAPI 提供了 setTimeout 函數(shù)，也包含其他的，例如 DOM。

將 callback 推送到 WebAPI 后，setTimeout 函數(shù)本身(但不是回調！)將從棧中彈出。

現(xiàn)在，foo 被調用，打印 "First"。

foo 從棧中彈出，baz 被調用. 打印 "Third"。

WebAPI 不能隨時向棧內添加內容。相反，它將回調函數(shù)推到名為 queue 的地方。

這就是事件循環(huán)開始工作的地方。一個事件循環(huán)查看棧和任務隊列。如果棧是空的，它接受隊列上的第一個元素并將其推入棧。

bar 被調用，打印 "Second"，然后它被棧彈出。

31. 當點擊按鈕時，event.target是什么？

 
 
 
 

  
  
  
  
  
  
  
  
  
    
  
  
  
  
      
  
  
  
  
      Click!