JavaScript 進階問題列表

時間 2019-11-08

原文原文鏈接

做者：Lydia Halliejavascript

翻譯：瘋狂的技術宅html

原文：github.com/lydiahallie…前端

我在個人 Instagram 上天天都會發布 JavaScript 的選擇題，而且同時也會在這個倉庫中發佈。java

從基礎到進階，測試你有多瞭解 JavaScript，刷新你的知識，或者幫助你的 coding 面試！ :muscle: :rocket: 我每週都會在這個倉庫下更新新的問題。node

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

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

在函數內部，咱們首先經過 var 關鍵字聲明瞭 name 變量。這意味着變量被提高了（內存空間在建立階段就被設置好了），直到程序運行到定義變量位置以前默認值都是 undefined。由於當咱們打印 name 變量時尚未執行到定義變量的位置，所以變量的值保持爲 undefined。github

經過 let 和 const 關鍵字聲明的變量也會提高，可是和 var 不一樣，它們不會被初始化。在咱們聲明（初始化）以前是不能訪問它們的。這個行爲被稱之爲暫時性死區。當咱們試圖在聲明以前訪問它們時，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 的事件循環，setTimeout 回調會在遍歷結束後才執行。由於在第一個遍歷中遍歷 i 是經過 var 關鍵字聲明的，因此這個值是全局做用域下的。在遍歷過程當中，咱們經過一元操做符 ++ 來每次遞增 i 的值。當 setTimeout 回調執行的時候，i 的值等於 3。前端工程化

在第二個遍歷中，遍歷 i 是經過 let 關鍵字聲明的：經過 let 和 const 關鍵字聲明的變量是擁有塊級做用域（指的是任何在 {} 中的內容）。在每次的遍歷過程當中，i 都有一個新值，而且每一個值都在循環內的做用域中。數組

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 的值是一個常規函數，可是 perimeter 的值是一個箭頭函數。

對於箭頭函數，this 關鍵字指向的是它當前周圍做用域（簡單來講是包含箭頭函數的常規函數，若是沒有常規函數的話就是全局對象），這個行爲和常規函數不一樣。這意味着當咱們調用 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）。儘管咱們可能不會定義它們爲字符串，但它們在底層總會被轉換爲字符串。

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

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

而後使用點語法的話，上面這一切都不會發生。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() 是一個內建的函數構造器。雖然它看着像是一個 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 是一個靜態方法。靜態方法被設計爲只能被建立它們的構造器使用（也就是 Chameleon），而且不能傳遞給實例。由於 freddie 是一個實例，靜態方法不能被實例使用，所以拋出了 TypeError 錯誤。

9. 輸出是什麼？

let greeting
greetign = {} // Typo!
console.log(greetign)
複製代碼

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

答案: A

代碼打印出了一個對象，這是由於咱們在全局對象上建立了一個空對象！當咱們將 greeting 寫錯成 greetign 時，JS 解釋器實際在上瀏覽器中將它視爲 global.greetign = {} （或者 window.greetign = {}）。

爲了不這個爲題，咱們可使用 "use strict"。這能確保當你聲明變量時必須賦值。

10. 當咱們這麼作時，會發生什麼？

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

bark.animal = 'dog'
複製代碼

A: 正常運行!
B: SyntaxError. 你不能經過這種方式給函數增長屬性。
C: undefined
D: ReferenceError

答案: A

這在 JavaScript 中是能夠的，由於函數是對象！（除了基本類型以外其餘都是對象）

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

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

你不能像常規對象那樣，給構造函數添加屬性。若是你想一次性給全部實例添加特性，你應該使用原型。所以本例中，使用以下方式：

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

這纔會使 member.getFullName() 起做用。爲何這麼作有益的？假設咱們將這個方法添加到構造函數自己裏。也許不是每一個 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 引用咱們建立的空對象。當未使用 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），全部對象都有原型。基本對象能夠訪問一些方法和屬性，好比 .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 是一種動態類型語言：咱們不指定某些變量的類型。值能夠在你不知道的狀況下自動轉換成另外一種類型，這種類型稱爲隱式類型轉換（implicit type coercion）。Coercion 是指將一種類型轉換爲另外一種類型。

在本例中，JavaScript 將數字 1 轉換爲字符串，以便函數有意義並返回一個值。在數字類型（1）和字符串類型（'2'）相加時，該數字被視爲字符串。咱們能夠鏈接字符串，好比 "Hello" + "World"，這裏發生的是 "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

一元後自增運算符 ++：

返回值（返回 0）
值自增（number 如今是 1）

一元前自增運算符 ++：

值自增（number 如今是 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

若是使用標記模板字面量，第一個參數的值老是包含字符串的數組。其他的參數獲取的是傳遞的表達式的值！

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 檢查對象是否具備對內存中相同位置的引用。

題目中咱們正在比較的兩個對象不是同一個引用：做爲參數傳遞的對象引用的內存位置，與用於判斷相等的對象所引用的內存位置並不一樣。

這也是 { 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）會返回實參組成的數組。而數組是對象，所以 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。這將返回數字 105。

22. cool_secret 可訪問多長時間？

sessionStorage.setItem('cool_secret', 123)
複製代碼

A: 永遠，數據不會丟失。
B: 當用戶關掉標籤頁時。
C: 當用戶關掉整個瀏覽器，而不僅是關掉標籤頁。
D: 當用戶關閉電腦時。

答案: B

關閉 tab 標籤頁 後，sessionStorage 存儲的數據纔會刪除。

若是使用 localStorage，那麼數據將永遠在那裏，除非調用了 localStorage.clear()。

23. 輸出是什麼？

var num = 8
var num = 10

console.log(num)
複製代碼

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

答案: B

使用 var 關鍵字，你能夠用相同的名稱聲明多個變量。而後變量將保存最新的值。

你不能使用 let 或 const 來實現這一點，由於它們是塊做用域的。

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。它有數字類型爲 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

若是你有兩個名稱相同的鍵，則鍵會被替換掉。它仍然位於第一個鍵出現的位置，可是值是最後出現那個鍵的值。

26. JavaScript 全局執行上下文爲你作了兩件事：全局對象和 this 關鍵字。

A: true
B: false
C: it depends

答案: A

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

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 是內置的構造函數，咱們能夠向它添加屬性。我只是在它的原型中添加了一個方法。基本類型字符串被自動轉換爲字符串對象，由字符串原型函數生成。所以，全部 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 函數，並首先調用它。然而，它是最後打印日誌的。

這是由於在瀏覽器中，咱們不只有運行時引擎，還有一個叫作 WebAPI 的東西。WebAPI 提供了 setTimeout 函數，也包含其餘的，例如 DOM。

將 callback 推送到 WebAPI 後，setTimeout 函數自己(但不是回調！)將從棧中彈出。

如今，foo 被調用，打印 "First"。

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

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

這就是事件循環開始工做的地方。一個事件循環查看棧和任務隊列。若是棧是空的，它接受隊列上的第一個元素並將其推入棧。

bar 被調用，打印 "Second"，而後它被棧彈出。

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

<div onclick="console.log('first div')">
  <div onclick="console.log('second div')">
    <button onclick="console.log('button')">
      Click!
    </button>
  </div>
</div>
複製代碼

A: Outer div
B: Inner div
C: button
D: 一個包含全部嵌套元素的數組。

答案: C

致使事件的最深嵌套的元素是事件的 target。你能夠經過 event.stopPropagation 來中止冒泡。

32. 當您單擊該段落時，日誌輸出是什麼？

<div onclick="console.log('div')">
  <p onclick="console.log('p')">
    Click here!
  
</div>
複製代碼

A: p div
B: div p
C: p
D: div

答案: A

若是咱們點擊 p，咱們會看到兩個日誌：p 和 div。在事件傳播期間，有三個階段：捕獲、目標和冒泡。默認狀況下，事件處理程序在冒泡階段執行（除非將 useCapture 設置爲 true）。它從嵌套最深的元素向外傳播。

33. 輸出是什麼？

const person = { name: 'Lydia' }

function sayHi(age) {
  console.log(`${this.name} is ${age}`)
}

sayHi.call(person, 21)
sayHi.bind(person, 21)
複製代碼

A: undefined is 21 Lydia is 21
B: function function
C: Lydia is 21 Lydia is 21
D: Lydia is 21 function

答案: D

使用這兩種方法，咱們均可以傳遞咱們但願 this 關鍵字引用的對象。可是，.call 是當即執行的。

.bind 返回函數的副本，但帶有綁定上下文！它不是當即執行的。

34. 輸出是什麼？

function sayHi() {
  return (() => 0)()
}

typeof sayHi()
複製代碼

A: "object"
B: "number"
C: "function"
D: "undefined"

答案: B

sayHi 方法返回的是當即執行函數(IIFE)的返回值.此當即執行函數的返回值是 0，類型是 number

參考：只有7種內置類型：null，undefined，boolean，number，string，object 和 symbol。 function 不是一種類型，函數是對象，它的類型是object。

35. 下面哪些值是 falsy?

0
new Number(0)
('')
(' ')
new Boolean(false)
undefined
複製代碼

A: 0, '', undefined
B: 0, new Number(0), '', new Boolean(false), undefined
C: 0, '', new Boolean(false), undefined
D: 全都是 of them are falsy

答案: A

只有 6 種 falsy 值:

undefined
null
NaN
0
'' (empty string)
false

Function 構造函數, 好比 new Number 和 new Boolean，是 truthy。

36. 輸出是什麼？

console.log(typeof typeof 1)
複製代碼

A: "number"
B: "string"
C: "object"
D: "undefined"

答案: B

typeof 1 返回 "number"。 typeof "number" 返回 "string"。

37. 輸出是什麼？

const numbers = [1, 2, 3]
numbers[10] = 11
console.log(numbers)
複製代碼

A: [1, 2, 3, 7 x null, 11]
B: [1, 2, 3, 11]
C: [1, 2, 3, 7 x empty, 11]
D: SyntaxError

答案: C

當你爲數組設置超過數組長度的值的時候， JavaScript 會建立名爲 "empty slots" 的東西。它們的值其實是 undefined。你會看到如下場景：

[1, 2, 3, 7 x empty, 11]

這取決於你的運行環境（每一個瀏覽器，以及 node 環境，都有可能不一樣）

38. 輸出是什麼？

(() => {
  let x, y
  try {
    throw new Error()
  } catch (x) {
    (x = 1), (y = 2)
    console.log(x)
  }
  console.log(x)
  console.log(y)
})()
複製代碼

A: 1 undefined 2
B: undefined undefined undefined
C: 1 1 2
D: 1 undefined undefined

答案: A

catch 代碼塊接收參數 x。當咱們傳遞參數時，這與以前定義的變量 x 不一樣。這個 x 是屬於 catch 塊級做用域的。

而後，咱們將塊級做用域中的變量賦值爲 1，同時也設置了變量 y 的值。如今，咱們打印塊級做用域中的變量 x，值爲 1。

catch 塊以外的變量 x 的值仍爲 undefined， y 的值爲 2。當咱們在 catch 塊以外執行 console.log(x) 時，返回 undefined，y 返回 2。

39. JavaScript 中的一切都是？

A: 基本類型與對象
B: 函數與對象
C: 只有對象
D: 數字與對象

答案: A

JavaScript 只有基本類型和對象。

基本類型包括 boolean, null, undefined, bigint, number, string, symbol。

40. 輸出是什麼？

[[0, 1], [2, 3]].reduce(
  (acc, cur) => {
    return acc.concat(cur)
  },
  [1, 2]
)
複製代碼

A: [0, 1, 2, 3, 1, 2]
B: [6, 1, 2]
C: [1, 2, 0, 1, 2, 3]
D: [1, 2, 6]

答案: C

[1, 2]是初始值。初始值將會做爲首次調用時第一個參數 acc 的值。在第一次執行時， acc 的值是 [1, 2]， cur 的值是 [0, 1]。合併它們，結果爲 [1, 2, 0, 1]。第二次執行， acc 的值是 [1, 2, 0, 1]， cur 的值是 [2, 3]。合併它們，最終結果爲 [1, 2, 0, 1, 2, 3]

41. 輸出是什麼？

!!null
!!''
!!1
複製代碼

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

答案: B

null 是 falsy。 !null 的值是 true。 !true 的值是 false。

"" 是 falsy。 !"" 的值是 true。 !true 的值是 false。

1 是 truthy。 !1 的值是 false。 !false 的值是 true。

42. `setInterval` 方法的返回值是什麼？

setInterval(() => console.log('Hi'), 1000)
複製代碼

A: 一個惟一的id
B: 該方法指定的毫秒數
C: 傳遞的函數
D: undefined

答案: A

setInterval 返回一個惟一的 id。此 id 可被用於 clearInterval 函數來取消定時。

43. 輸出是什麼？

[...'Lydia']
複製代碼

A: ["L", "y", "d", "i", "a"]
B: ["Lydia"]
C: [[], "Lydia"]
D: [["L", "y", "d", "i", "a"]]

答案: A

string 類型是可迭代的。擴展運算符將迭代的每一個字符映射成一個元素。

44. 輸出是什麼?

function* generator(i) {
  yield i;
  yield i * 2;
}

const gen = generator(10);

console.log(gen.next().value);
console.log(gen.next().value);
複製代碼

A: [0, 10], [10, 20]
B: 20, 20
C: 10, 20
D: 0, 10 和 10, 20

答案: C

通常的函數在執行以後是不能中途停下的。可是，生成器函數卻能夠中途「停下」，以後能夠再從停下的地方繼續。當生成器遇到yield關鍵字的時候，會生成yield後面的值。注意，生成器在這種狀況下不返回 (return )值，而是生成 (yield)值。

首先，咱們用10做爲參數i來初始化生成器函數。而後使用next()方法一步步執行生成器。第一次執行生成器的時候，i的值爲10，遇到第一個yield關鍵字，它要生成i的值。此時，生成器「暫停」，生成了10。

而後，咱們再執行next()方法。生成器會從剛纔暫停的地方繼續，這個時候i仍是10。因而咱們走到了第二個yield關鍵字處，這時候須要生成的值是i*2，i爲10，那麼此時生成的值即是20。因此這道題的最終結果是10,20。

45. 返回值是什麼?

const firstPromise = new Promise((res, rej) => {
  setTimeout(res, 500, "one");
});

const secondPromise = new Promise((res, rej) => {
  setTimeout(res, 100, "two");
});

Promise.race([firstPromise, secondPromise]).then(res => console.log(res));
複製代碼

A: "one"
B: "two"
C: "two" "one"
D: "one" "two"

答案: B

當咱們向Promise.race方法中傳入多個Promise時，會進行優先解析。在這個例子中，咱們用setTimeout給firstPromise和secondPromise分別設定了500ms和100ms的定時器。這意味着secondPromise會首先解析出字符串two。那麼此時res參數即爲two，是爲輸出結果。

46. 輸出是什麼?

let person = { name: "Lydia" };
const members = [person];
person = null;

console.log(members);
複製代碼

A: null
B: [null]
C: [{}]
D: [{ name: "Lydia" }]

答案: D

首先咱們聲明瞭一個擁有name屬性的對象 person。

而後咱們又聲明瞭一個變量members. 將首個元素賦值爲變量person。當設置兩個對象彼此相等時，它們會經過引用進行交互。可是當你將引用從一個變量分配至另外一個變量時，其實只是執行了一個複製操做。（注意一點，他們的引用 並不相同!）

接下來咱們讓person等於null。

咱們沒有修改數組第一個元素的值，而只是修改了變量person的值,由於元素（複製而來）的引用與person不一樣。members的第一個元素仍然保持着對原始對象的引用。當咱們輸出members數組時，第一個元素會將引用的對象打印出來。

47. 輸出是什麼?

const person = {
  name: "Lydia",
  age: 21
};

for (const item in person) {
  console.log(item);
}
複製代碼

A: { name: "Lydia" }, { age: 21 }
B: "name", "age"
C: "Lydia", 21
D: ["name", "Lydia"], ["age", 21]

答案: B

在for-in循環中,咱們能夠經過對象的key來進行迭代,也就是這裏的name和age。在底層，對象的key都是字符串（若是他們不是Symbol的話）。在每次循環中，咱們將item設定爲當前遍歷到的key.因此一開始，item是name，以後 item輸出的則是age。

48. 輸出是什麼?

console.log(3 + 4 + "5");
複製代碼

A: "345"
B: "75"
C: 12
D: "12"

答案: B

當全部運算符的 優先級 相同時，計算表達式須要肯定運算符的結合順序，即從右到左仍是從左往右。在這個例子中，咱們只有一類運算符+，對於加法來講，結合順序就死從左到右。

3 + 4首先計算，獲得數字7.

因爲類型的強制轉換，7 + '5'的結果是"75". JavaScript將7轉換成了字符串，能夠參考問題15.咱們能夠用+號把兩個字符串鏈接起來。 "7" + "5" 就獲得了"75".

49. `num`的值是什麼?

const num = parseInt("7*6", 10);
複製代碼

A: 42
B: "42"
C: 7
D: NaN

答案: C

只返回了字符串中第一個字母. 設定了進制後 (也就是第二個參數，指定須要解析的數字是什麼進制: 十進制、十六機制、八進制、二進制等等……),parseInt 檢查字符串中的字符是否合法. 一旦遇到一個在指定進制中不合法的字符後，當即中止解析而且忽略後面全部的字符。

*就是不合法的數字字符。因此只解析到"7"，並將其解析爲十進制的7. num的值即爲7.

50. 輸出是什麼?

[1, 2, 3].map(num => {
  if (typeof num === "number") return;
  return num * 2;
});
複製代碼

A: []
B: [null, null, null]
C: [undefined, undefined, undefined]
D: [ 3 x empty ]

答案: C

對數組進行映射的時候,num就是當前循環到的元素. 在這個例子中，全部的映射都是number類型，因此if中的判斷typeof num === "number"結果都是true.map函數建立了新數組而且將函數的返回值插入數組。

可是，沒有任何值返回。當函數沒有返回任何值時，即默認返回undefined.對數組中的每個元素來講，函數塊都獲得了這個返回值，因此結果中每個元素都是undefined.

51. 輸出的是什麼?

function getInfo(member, year) {
  member.name = "Lydia";
  year = "1998";
}

const person = { name: "Sarah" };
const birthYear = "1997";

getInfo(person, birthYear);

console.log(person, birthYear);
複製代碼

A: { name: "Lydia" }, "1997"
B: { name: "Sarah" }, "1998"
C: { name: "Lydia" }, "1998"
D: { name: "Sarah" }, "1997"

答案: A

普通參數都是值傳遞的，而對象則不一樣，是引用傳遞。因此說，birthYear是值傳遞，由於他是個字符串而不是對象。當咱們對參數進行值傳遞時，會建立一份該值的複製。（能夠參考問題46）

變量birthYear有一個對"1997"的引用，而傳入的參數也有一個對"1997"的引用，但兩者的引用並不相同。當咱們經過給 year賦值"1998"來更新year的值的時候咱們只是更新了year（的引用）。此時birthYear仍然是"1997".

而person是個對象。參數member引用與之 相同的 對象。當咱們修改member所引用對象的屬性時,person的相應屬性也被修改了,由於他們引用了相同的對象. person的 name屬性也變成了 "Lydia".

52. 輸出是什麼?

function greeting() {
  throw "Hello world!";
}

function sayHi() {
  try {
    const data = greeting();
    console.log("It worked!", data);
  } catch (e) {
    console.log("Oh no an error!", e);
  }
}

sayHi();
複製代碼

A: "It worked! Hello world!"
B: "Oh no an error: undefined
C: SyntaxError: can only throw Error objects
D: "Oh no an error: Hello world!

答案: D

經過throw語句，我麼能夠建立自定義錯誤。而經過它，咱們能夠拋出異常。異常能夠是一個字符串, 一個數字, 一個 布爾類型 或者是一個對象。在本例中，咱們的異常是字符串'Hello world'.

經過 catch語句，咱們能夠設定當try語句塊中拋出異常後應該作什麼處理。在本例中拋出的異常是字符串'Hello world'. e就是這個字符串，所以被輸出。最終結果就是'Oh an error: Hello world'.

53. 輸出是什麼?

function Car() {
  this.make = "Lamborghini";
  return { make: "Maserati" };
}

const myCar = new Car();
console.log(myCar.make);
複製代碼

A: "Lamborghini"
B: "Maserati"
C: ReferenceError
D: TypeError

答案: B

返回屬性的時候，屬性的值等於 返回的 值，而不是構造函數中設定的值。咱們返回了字符串 "Maserati"，因此 myCar.make等於"Maserati".

54. 輸出是什麼?

(() => {
  let x = (y = 10);
})();

console.log(typeof x);
console.log(typeof y);
複製代碼

A: "undefined", "number"
B: "number", "number"
C: "object", "number"
D: "number", "undefined"

答案: A

let x = y = 10; 是下面這個表達式的縮寫:

y = 10;
let x = y;
複製代碼

咱們設定y等於10時,咱們實際上增長了一個屬性y給全局對象(瀏覽器裏的window, Nodejs裏的global)。在瀏覽器中， window.y等於10.

而後咱們聲明瞭變量x等於y,也是10.但變量是使用 let聲明的，它只做用於 塊級做用域, 僅在聲明它的塊中有效；就是案例中的當即調用表達式(IIFE)。使用typeof操做符時, 操做值 x沒有被定義：由於咱們在x聲明塊的外部，沒法調用它。這就意味着x未定義。未分配或是未聲明的變量類型爲"undefined". console.log(typeof x)返回"undefined".

而咱們建立了全局變量y，而且設定y等於10.這個值在咱們的代碼各處都訪問的到。 y已經被定義了，並且有一個"number"類型的值。 console.log(typeof y)返回"number".

55. 輸出是什麼?

class Dog {
  constructor(name) {
    this.name = name;
  }
}

Dog.prototype.bark = function() {
  console.log(`Woof I am ${this.name}`);
};

const pet = new Dog("Mara");

pet.bark();

delete Dog.prototype.bark;

pet.bark();
複製代碼

A: "Woof I am Mara", TypeError
B: "Woof I am Mara","Woof I am Mara"
C: "Woof I am Mara", undefined
D: TypeError, TypeError

答案: A

咱們能夠用delete關鍵字刪除對象的屬性，對原型也是適用的。刪除了原型的屬性後，該屬性在原型鏈上就不可用了。在本例中，函數bark在執行了delete Dog.prototype.bark後不可用, 然然後面的代碼還在調用它。

當咱們嘗試調用一個不存在的函數時TypeError異常會被拋出。在本例中就是 TypeError: pet.bark is not a function，由於pet.bark是undefined.

56. 輸出是什麼?

const set = new Set([1, 1, 2, 3, 4]);

console.log(set);
複製代碼

A: [1, 1, 2, 3, 4]
B: [1, 2, 3, 4]
C: {1, 1, 2, 3, 4}
D: {1, 2, 3, 4}

答案: D

Set對象手機 獨一無二 的值：也就是說同一個值在其中僅出現一次。

咱們傳入了數組[1, 1, 2, 3, 4]，他有一個重複值1.覺得一個集合裏不能有兩個重複的值，其中一個就被移除了。因此結果是 {1, 2, 3, 4}.

57. 輸出是什麼?

// counter.js
let counter = 10;
export default counter;
複製代碼

// index.js
import myCounter from "./counter";

myCounter += 1;

console.log(myCounter);
複製代碼

A: 10
B: 11
C: Error
D: NaN

答案: C

引入的模塊是只讀的: 你不能修改引入的模塊。只有導出他們的模塊才能修改其值。

當咱們給myCounter增長一個值的時候會拋出一個異常： myCounter是隻讀的，不能被修改。

58. 輸出是什麼?

const name = "Lydia";
age = 21;

console.log(delete name);
console.log(delete age);
複製代碼

A: false, true
B: "Lydia", 21
C: true, true
D: undefined, undefined

答案: A

delete操做符返回一個布爾值： true指刪除成功，不然返回false. 可是經過 var, const 或 let 關鍵字聲明的變量沒法用 delete 操做符來刪除。

name變量由const關鍵字聲明，因此刪除不成功:返回 false. 而咱們設定age等於21時,咱們實際上添加了一個名爲age的屬性給全局對象。對象中的屬性是能夠刪除的，全局對象也是如此，因此delete age返回true.

59. 輸出是什麼?

const numbers = [1, 2, 3, 4, 5];
const [y] = numbers;

console.log(y);
複製代碼

A: [[1, 2, 3, 4, 5]]
B: [1, 2, 3, 4, 5]
C: 1
D: [1]

答案: C

咱們能夠經過解構賦值來解析來自對象的數組或屬性的值，好比說：

[a, b] = [1, 2];
複製代碼

a的值如今是1，b的值如今是2.而在題目中，咱們是這麼作的:

[y] = [1, 2, 3, 4, 5];
複製代碼

也就是說，y等於數組的第一個值就是數字1.咱們輸出y，返回1.

60. 輸出是什麼?

const user = { name: "Lydia", age: 21 };
const admin = { admin: true, ...user };

console.log(admin);
複製代碼

A: { admin: true, user: { name: "Lydia", age: 21 } }
B: { admin: true, name: "Lydia", age: 21 }
C: { admin: true, user: ["Lydia", 21] }
D: { admin: true }

答案: B

擴展運算符...爲對象的組合提供了可能。你能夠複製對象中的鍵值對，而後把它們加到另外一個對象裏去。在本例中，咱們複製了user對象鍵值對，而後把它們加入到admin對象中。admin對象就擁有了這些鍵值對，因此結果爲{ admin: true, name: "Lydia", age: 21 }.

61. 輸出是什麼?

const person = { name: "Lydia" };

Object.defineProperty(person, "age", { value: 21 });

console.log(person);
console.log(Object.keys(person));
複製代碼

A: { name: "Lydia", age: 21 }, ["name", "age"]
B: { name: "Lydia", age: 21 }, ["name"]
C: { name: "Lydia"}, ["name", "age"]
D: { name: "Lydia"}, ["age"]

答案: B

經過defineProperty方法，咱們能夠給對象添加一個新屬性，或者修改已經存在的屬性。而咱們使用defineProperty方法給對象添加了一個屬性以後，屬性默認爲 不可枚舉(not enumerable). Object.keys方法僅返回對象中 可枚舉(enumerable) 的屬性，所以只剩下了"name".

用defineProperty方法添加的屬性默認不可變。你能夠經過writable, configurable 和 enumerable屬性來改變這一行爲。這樣的話，相比於本身添加的屬性，defineProperty方法添加的屬性有了更多的控制權。

62. 輸出是什麼?

const settings = {
  username: "lydiahallie",
  level: 19,
  health: 90
};

const data = JSON.stringify(settings, ["level", "health"]);
console.log(data);
複製代碼

A: "{"level":19, "health":90}"
B: "{"username": "lydiahallie"}"
C: "["level", "health"]"
D: "{"username": "lydiahallie", "level":19, "health":90}"

答案: A

JSON.stringify的第二個參數是 替代者(replacer). 替代者(replacer)能夠是個函數或數組，用以控制哪些值如何被轉換爲字符串。

若是替代者(replacer)是個數組，那麼就只有包含在數組中的屬性將會被轉化爲字符串。在本例中，只有名爲"level" 和 "health" 的屬性被包括進來， "username"則被排除在外。 data 就等於 "{"level":19, "health":90}".

而若是替代者(replacer)是個函數，這個函數將被對象的每一個屬性都調用一遍。函數返回的值會成爲這個屬性的值，最終體如今轉化後的JSON字符串中（譯者注：Chrome下，通過實驗，若是全部屬性均返回同一個值的時候有異常，會直接將返回值做爲結果輸出而不會輸出JSON字符串），而若是返回值爲undefined，則該屬性會被排除在外。

63. 輸出是什麼?

let num = 10;

const increaseNumber = () => num++;
const increasePassedNumber = number => number++;

const num1 = increaseNumber();
const num2 = increasePassedNumber(num1);

console.log(num1);
console.log(num2);
複製代碼

A: 10, 10
B: 10, 11
C: 11, 11
D: 11, 12