JavaScript 進階問題列表

時間  2019-12-05
標籤 javascript 進階 問題 列表 欄目 JavaScript 简体版
原文   原文鏈接

原文

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。javascript

經過 let 和 const 關鍵字聲明的變量也會提高，可是和 var 不一樣，它們不會被初始化。在咱們聲明（初始化）以前是不能訪問它們的。這個行爲被稱之爲暫時性死區。當咱們試圖在聲明以前訪問它們時，JavaScript 將會拋出一個 ReferenceError 錯誤。html

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。java

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

3. 輸出是什麼？
const shape = {
  radius: 10,
  diameter() {
    return this.radius * 2
  },
  perimeter: () => 2 * Math.PI * this.radius
}

shape.diameter()
shape.perimeter()
複製代碼
  • A: 20 and 62.83185307179586
  • B: 20 and NaN
  • C: 20 and 63
  • D: NaN and 63
答案

答案: B

注意 diameter 的值是一個常規函數，可是 perimeter 的值是一個箭頭函數。git

對於箭頭函數，this 關鍵字指向的是它當前周圍做用域（簡單來講是包含箭頭函數的常規函數，若是沒有常規函數的話就是全局對象），這個行爲和常規函數不一樣。這意味着當咱們調用 perimeter 時，this 不是指向 shape 對象，而是它的周圍做用域（在例子中是 window）。github

在 window 中沒有 radius 這個屬性，所以返回 undefined。數組

4. 輸出是什麼？
;+true
!'Lydia'
複製代碼
  • A: 1 and false
  • B: false and NaN
  • C: false and false
答案

答案: A

一元操做符加號嘗試將 bool 轉爲 number。true 轉換爲 number 的話爲 1，false 爲 0。瀏覽器

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

5. 哪個是無效的？
const bird = {
  size: 'small'
}

const mouse = {
  name: 'Mickey',
  small: true
}
複製代碼
  • A: mouse.bird.size
  • B: mouse[bird.size]
  • C: mouse[bird["size"]]
  • D: All of them are valid
答案

答案: 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: Nothing, this is totally fine!
  • B: SyntaxError. You cannot add properties to a function this way.
  • 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"} and undefined
  • B: Person {firstName: "Lydia", lastName: "Hallie"} and Person {firstName: "Sarah", lastName: "Smith"}
  • C: Person {firstName: "Lydia", lastName: "Hallie"} and {}
  • D:Person {firstName: "Lydia", lastName: "Hallie"} and 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

一元後自增運算符 ++：

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

一元前自增運算符 ++：

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

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

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: Forever, the data doesn't get lost.
  • B: When the user closes the tab.
  • C: When the user closes the entire browser, not only the tab.
  • D: When the user shuts off their computer.
答案

答案: 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: An array of all nested elements.
答案

答案: C

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

32. 當您單擊該段落時，日誌輸出是什麼？
<div onclick="console.log('div')">
  <p onclick="console.log('p')">
    Click here!
  </p>
</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: All 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: primitive or object
  • B: function or object
  • C: trick question! only objects
  • D: number or object
答案

答案: 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: a unique id
  • B: the amount of milliseconds specified
  • C: the passed function
  • 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 類型是可迭代的。擴展運算符將迭代的每一個字符映射成一個元素。

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程