JavaScript?進(jìn)階問題列表(各種js代碼段66-107)

更新時間：2024年11月03日 12:19:00 投稿：mdxy-dxy

從基礎(chǔ)到進(jìn)階,測試你有多了解?JavaScript,刷新你的知識,或者幫助你的?coding?面試！?:muscle:?:rocket:?我每周都會在這個倉庫下更新新的問題,

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

從基礎(chǔ)到進(jìn)階，測試你有多了解 JavaScript，刷新你的知識，或者幫助你的 coding 面試！ :muscle: :rocket: 我每周都會在這個倉庫下更新新的問題。

答案在問題下方的折疊部分，點(diǎn)擊即可展開問題。祝你好運(yùn)

66. 使用哪個構(gòu)造函數(shù)可以成功繼承`Dog`類？

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

class Labrador extends Dog {
  // 1 
  constructor(name, size) {
    this.size = size;
  }
  // 2
  constructor(name, size) {
    super(name);
    this.size = size;
  }
  // 3
  constructor(size) {
    super(name);
    this.size = size;
  }
  // 4 
  constructor(name, size) {
    this.name = name;
    this.size = size;
  }

};

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

答案

答案：B

在子類中，在調(diào)用super之前不能訪問到this關(guān)鍵字。如果這樣做，它將拋出一個ReferenceError：1 和 4 將引發(fā)一個引用錯誤。

使用super關(guān)鍵字，需要用給定的參數(shù)來調(diào)用父類的構(gòu)造函數(shù)。父類的構(gòu)造函數(shù)接收name參數(shù)，因此我們需要將name傳遞給super。

Labrador類接收兩個參數(shù)，name參數(shù)是由于它繼承了Dog，size作為Labrador類的額外屬性，它們都需要傳遞給Labrador的構(gòu)造函數(shù)，因此使用構(gòu)造函數(shù) 2 正確完成。

67. 輸出什么？

// index.js
console.log('running index.js');
import { sum } from './sum.js';
console.log(sum(1, 2));

// sum.js
console.log('running sum.js');
export const sum = (a, b) =&gt; a + b;

A: running index.js, running sum.js, 3
B: running sum.js, running index.js, 3
C: running sum.js, 3, running index.js
D: running index.js, undefined, running sum.js

答案

答案：B

import命令是編譯階段執(zhí)行的，在代碼運(yùn)行之前。因此這意味著被導(dǎo)入的模塊會先運(yùn)行，而導(dǎo)入模塊的文件會后執(zhí)行。

這是 CommonJS 中require（）和import之間的區(qū)別。使用require()，您可以在運(yùn)行代碼時根據(jù)需要加載依賴項(xiàng)。如果我們使用require而不是import，running index.js，running sum.js，3會被依次打印。

68. 輸出什么？

console.log(Number(2) === Number(2))
console.log(Boolean(false) === Boolean(false))
console.log(Symbol('foo') === Symbol('foo'))

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

答案

答案：A

每個Symbol都是完全唯一的。傳遞給Symbol的參數(shù)只是給Symbol的一個描述。Symbol的值不依賴于傳遞的參數(shù)。當(dāng)我們測試相等時，我們創(chuàng)建了兩個全新的符號：第一個Symbol（'foo'），第二個Symbol（'foo'），這兩個值是唯一的，彼此不相等，因此返回false。

69. 輸出什么？

const name = "Lydia Hallie"
console.log(name.padStart(13))
console.log(name.padStart(2))

A: "Lydia Hallie", "Lydia Hallie"
B: " Lydia Hallie", " Lydia Hallie" ("[13x whitespace]Lydia Hallie", "[2x whitespace]Lydia Hallie")
C: " Lydia Hallie", "Lydia Hallie" ("[1x whitespace]Lydia Hallie", "Lydia Hallie")
D: "Lydia Hallie", "Lyd"

答案

答案：C

使用padStart方法，我們可以在字符串的開頭添加填充。傳遞給此方法的參數(shù)是字符串的總長度（包含填充）。字符串Lydia Hallie的長度為12，因此name.padStart（13）在字符串的開頭只會插入 1（13 - 12 = 1）個空格。

如果傳遞給padStart方法的參數(shù)小于字符串的長度，則不會添加填充。

70. 輸出什么？

console.log("??" + "??");

A: "????"
B: 257548
C: A string containing their code points
D: Error

答案

答案：A

使用+運(yùn)算符，您可以連接字符串。上述情況，我們將字符串“??”與字符串”??“連接起來，產(chǎn)生”????“。

71. 如何能打印出`console.log`語句后注釋掉的值？

function* startGame() {
  const 答案 = yield "Do you love JavaScript?";
  if (答案 !== "Yes") {
    return "Oh wow... Guess we're gone here";
  }
  return "JavaScript loves you back ??";
}

const game = startGame();
console.log(/* 1 */); // Do you love JavaScript?
console.log(/* 2 */); // JavaScript loves you back ??

A: game.next("Yes").value and game.next().value
B: game.next.value("Yes") and game.next.value()
C: game.next().value and game.next("Yes").value
D: game.next.value() and game.next.value("Yes")

答案

答案：C

generator函數(shù)在遇到yield關(guān)鍵字時會“暫停”其執(zhí)行。首先，我們需要讓函數(shù)產(chǎn)生字符串Do you love JavaScript?，這可以通過調(diào)用game.next().value來完成。上述函數(shù)的第一行就有一個yield關(guān)鍵字，那么運(yùn)行立即停止了，yield表達(dá)式本身沒有返回值，或者說總是返回undefined，這意味著此時變量 答案 為undefined

next方法可以帶一個參數(shù)，該參數(shù)會被當(dāng)作上一個 yield 表達(dá)式的返回值。當(dāng)我們調(diào)用game.next("Yes").value時，先前的 yield 的返回值將被替換為傳遞給next()函數(shù)的參數(shù)"Yes"。此時變量 答案 被賦值為 "Yes"，if語句返回false，所以JavaScript loves you back ??被打印。

72. 輸出什么？

console.log(String.raw`Hello\nworld`);

A: Hello world!
B: Hello world
C: Hello\nworld
D: Hello\n world

答案

答案：C

String.raw函數(shù)是用來獲取一個模板字符串的原始字符串的，它返回一個字符串，其中忽略了轉(zhuǎn)義符（\n，\v，\t等）。但反斜杠可能造成問題，因?yàn)槟憧赡軙龅较旅孢@種類似情況：

const path = `C:\Documents\Projects\table.html`
String.raw`${path}`

這將導(dǎo)致：

"C:DocumentsProjects able.html"

直接使用String.raw

String.raw`C:\Documents\Projects\table.html`

它會忽略轉(zhuǎn)義字符并打?。?code>C:\Documents\Projects\table.html

上述情況，字符串是Hello\nworld被打印出。

73. 輸出什么？

async function getData() {
  return await Promise.resolve("I made it!");
}

const data = getData();
console.log(data);

A: "I made it!"
B: Promise {<resolved>: "I made it!"}
C: Promise {<pending>}
D: undefined

答案

答案：C

異步函數(shù)始終返回一個 promise。await仍然需要等待 promise 的解決：當(dāng)我們調(diào)用getData()并將其賦值給data，此時data為getData方法返回的一個掛起的 promise，該 promise 并沒有解決。

如果我們想要訪問已解決的值"I made it!"，可以在data上使用.then()方法：

data.then(res => console.log(res))

這樣將打印 "I made it!"

74. 輸出什么？

function addToList(item, list) {
  return list.push(item);
}

const result = addToList("apple", ["banana"]);
console.log(result);

A: ['apple', 'banana']
B: 2
C: true
D: undefined

答案

答案：B

push()方法返回新數(shù)組的長度。一開始，數(shù)組包含一個元素（字符串"banana"），長度為 1。在數(shù)組中添加字符串"apple"后，長度變?yōu)?2，并將從addToList函數(shù)返回。

push方法修改原始數(shù)組，如果你想從函數(shù)返回?cái)?shù)組而不是數(shù)組長度，那么應(yīng)該在 push item之后返回list。

75. 輸出什么？

const box = { x: 10, y: 20 };

Object.freeze(box);

const shape = box;
shape.x = 100;
console.log(shape)

A: { x: 100, y: 20 }
B: { x: 10, y: 20 }
C: { x: 100 }
D: ReferenceError

答案

答案：B

Object.freeze使得無法添加、刪除或修改對象的屬性（除非屬性的值是另一個對象）。

當(dāng)我們創(chuàng)建變量shape并將其設(shè)置為等于凍結(jié)對象box時，shape指向的也是凍結(jié)對象。你可以使用Object.isFrozen檢查一個對象是否被凍結(jié)，上述情況，Object.isFrozen（shape）將返回true。

由于shape被凍結(jié)，并且x的值不是對象，所以我們不能修改屬性x。x仍然等于10，{x：10，y：20}被打印。

注意，上述例子我們對屬性x進(jìn)行修改，可能會導(dǎo)致拋出 TypeError 異常（最常見但不僅限于嚴(yán)格模式下時）。

76. 輸出什么？

const { name: myName } = { name: "Lydia" };

console.log(name);

A: "Lydia"
B: "myName"
C: undefined
D: ReferenceError

答案

答案：D

當(dāng)我們從右側(cè)的對象解構(gòu)屬性name時，我們將其值Lydia分配給名為myName的變量。

使用{name：myName}，我們是在告訴 JavaScript 我們要創(chuàng)建一個名為myName的新變量，并且其值是右側(cè)對象的name屬性的值。

當(dāng)我們嘗試打印name，一個未定義的變量時，就會引發(fā)ReferenceError。

77. 以下是個純函數(shù)么？

function sum(a, b) {
  return a + b;
}

A: Yes
B: No

答案

答案：A

純函數(shù)在相同的輸入值時，需產(chǎn)生相同的輸出，其輸出的結(jié)果，與輸入值以外的其他隱藏信息或狀態(tài)無關(guān)，也和由 I/O 設(shè)備產(chǎn)生的外部輸出無關(guān)。純函數(shù)不會產(chǎn)生副作用。

純函數(shù)與副作用的定義可參考： https://zh.wikipedia.org/wiki/%E5%89%AF%E4%BD%9C%E7%94%A8_(%E8%AE%A1%E7%AE%97%E6%9C%BA%E7%A7%91%E5%AD%A6)

78. 輸出什么？

const add = () =&gt; {
  const cache = {};
  return num =&gt; {
    if (num in cache) {
      return `From cache! ${cache[num]}`;
    } else {
      const result = num + 10;
      cache[num] = result;
      return `Calculated! ${result}`;
    }
  };
};

const addFunction = add();
console.log(addFunction(10));
console.log(addFunction(10));
console.log(addFunction(5 * 2));

A: Calculated! 20 Calculated! 20 Calculated! 20
B: Calculated! 20 From cache! 20 Calculated! 20
C: Calculated! 20 From cache! 20 From cache! 20
D: Calculated! 20 From cache! 20 Error

答案

答案：C

add函數(shù)是一個記憶函數(shù)。通過記憶化，我們可以緩存函數(shù)的結(jié)果，以加快其執(zhí)行速度。上述情況，我們創(chuàng)建一個cache對象，用于存儲先前返回過的值。

如果我們使用相同的參數(shù)多次調(diào)用addFunction函數(shù)，它首先檢查緩存中是否已有該值，如果有，則返回緩存值，這將節(jié)省執(zhí)行時間。如果沒有，那么它將計(jì)算該值，并存儲在緩存中。

我們用相同的值三次調(diào)用了addFunction函數(shù)：

在第一次調(diào)用，num等于10時函數(shù)的值尚未緩存，if 語句num in cache返回false，else 塊的代碼被執(zhí)行：Calculated! 20，并且其結(jié)果被添加到緩存對象，cache現(xiàn)在看起來像{10:20}。

第二次，cache對象包含10的返回值。if 語句 num in cache 返回true，From cache! 20被打印。

第三次，我們將5 * 2(值為 10) 傳遞給函數(shù)。cache對象包含10的返回值。if 語句 num in cache 返回true，From cache! 20被打印。

79. 輸出什么？

const myLifeSummedUp = ["?", "??", "??", "??"]

for (let item in myLifeSummedUp) {
  console.log(item)
}

for (let item of myLifeSummedUp) {
  console.log(item)
}

A: 0 1 2 3 and "?" "??" "??" "??"
B: "?" "??" "??" "??" and "?" "??" "??" "??"
C: "?" "??" "??" "??" and 0 1 2 3
D: 0 1 2 3 and {0: "?", 1: "??", 2: "??", 3: "??"}

答案

答案：A

通過for-in循環(huán)，我們可以遍歷一個對象自有的、繼承的、可枚舉的、非 Symbol 的屬性。在數(shù)組中，可枚舉屬性是數(shù)組元素的“鍵”，即它們的索引。類似于下面這個對象：

{0: "?", 1: "??", 2: "??", 3: "??"}

其中鍵則是可枚舉屬性，因此 0，1，2，3被記錄。

通過for-of循環(huán)，我們可以迭代可迭代對象（包括 Array，Map，Set，String，arguments等）。當(dāng)我們迭代數(shù)組時，在每次迭代中，不同屬性的值將被分配給變量item，因此“?”，“??”，“??”，“??”被打印。

80. 輸出什么？

const list = [1 + 2, 1 * 2, 1 / 2]
console.log(list)

A: ["1 + 2", "1 * 2", "1 / 2"]
B: ["12", 2, 0.5]
C: [3, 2, 0.5]
D: [1, 1, 1]

答案

答案：C

數(shù)組元素可以包含任何值。數(shù)字，字符串，布爾值，對象，數(shù)組，null，undefined，以及其他表達(dá)式，如日期，函數(shù)和計(jì)算。

元素將等于返回的值。1 + 2返回3，1 * 2返回'2，'1 / 2返回0.5。

81. 輸出什么？

function sayHi(name) {
  return `Hi there, ${name}`
}

console.log(sayHi())

A: Hi there,
B: Hi there, undefined
C: Hi there, null
D: ReferenceError

答案

答案：B

默認(rèn)情況下，如果不給函數(shù)傳參，參數(shù)的值將為undefined。上述情況，我們沒有給參數(shù)name傳值。name等于undefined，并被打印。

在 ES6 中，我們可以使用默認(rèn)參數(shù)覆蓋此默認(rèn)的undefined值。例如：

function sayHi (name =“Lydia”){...}

在這種情況下，如果我們沒有傳遞值或者如果我們傳遞undefined，name總是等于字符串Lydia

82. 輸出什么？

var status = "??"

setTimeout(() =&gt; {
  const status = "??"

  const data = {
    status: "??",
    getStatus() {
      return this.status
    }
  }

  console.log(data.getStatus())
  console.log(data.getStatus.call(this))
}, 0)

A: "??" and "??"
B: "??" and "??"
C: "??" and "??"
D: "??" and "??"

答案

答案：B

this關(guān)鍵字的指向取決于使用它的位置。在函數(shù)中，比如getStatus，this指向的是調(diào)用它的對象，上述例子中data對象調(diào)用了getStatus，因此this指向的就是data對象。當(dāng)我們打印this.status時，data對象的status屬性被打印，即"??"。

使用call方法，可以更改this指向的對象。data.getStatus.call(this)是將this的指向由data對象更改為全局對象。在全局對象上，有一個名為status的變量，其值為”??“。因此打印this.status時，會打印“??”。

83. 輸出什么？

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

let city = person.city
city = "Amsterdam"

console.log(person)

A: { name: "Lydia", age: 21 }
B: { name: "Lydia", age: 21, city: "Amsterdam" }
C: { name: "Lydia", age: 21, city: undefined }
D: "Amsterdam"

答案

答案：A

我們將變量city設(shè)置為等于person對象上名為city的屬性的值。這個對象上沒有名為city的屬性，因此變量city的值為undefined。

請注意，我們沒有引用person對象本身，只是將變量city設(shè)置為等于person對象上city屬性的當(dāng)前值。

然后，我們將city設(shè)置為等于字符串“Amsterdam”。這不會更改 person 對象：沒有對該對象的引用。

因此打印person對象時，會返回未修改的對象。

84. 輸出什么？

function checkAge(age) {
  if (age &lt; 18) {
    const message = "Sorry, you're too young."
  } else {
    const message = "Yay! You're old enough!"
  }

  return message
}

console.log(checkAge(21))

A: "Sorry, you're too young."
B: "Yay! You're old enough!"
C: ReferenceError
D: undefined

答案

答案：C

const和let聲明的變量是具有塊級作用域的，塊是大括號（{}）之間的任何東西，即上述情況if / else語句的花括號。由于塊級作用域，我們無法在聲明的塊之外引用變量，因此拋出ReferenceError。

85. 什么樣的信息將被打?。?/h3>

fetch('https://www.website.com/api/user/1')
  .then(res =&gt; res.json())
  .then(res =&gt; console.log(res))

A: fetch方法的結(jié)果
B: 第二次調(diào)用fetch方法的結(jié)果
C: 前一個.then()中回調(diào)方法返回的結(jié)果
D: 總是undefined

答案

答案：C

第二個.then中res的值等于前一個.then中的回調(diào)函數(shù)返回的值。你可以像這樣繼續(xù)鏈接.then，將值傳遞給下一個處理程序。

86. 哪個選項(xiàng)是將`hasName`設(shè)置為`true`的方法，前提是不能將`true`作為參數(shù)傳遞？

function getName(name) {
  const hasName = //
}

A: !!name
B: name
C: new Boolean(name)
D: name.length

答案

答案：A

使用邏輯非運(yùn)算符!，將返回一個布爾值，使用!! name，我們可以確定name的值是真的還是假的。如果name是真實(shí)的，那么!name返回false。!false返回true。

通過將hasName設(shè)置為name，可以將hasName設(shè)置為等于傳遞給getName函數(shù)的值，而不是布爾值true。

new Boolean（true）返回一個對象包裝器，而不是布爾值本身。

name.length返回傳遞的參數(shù)的長度，而不是布爾值true。

87. 輸出什么？

console.log("I want pizza"[0])

A: """
B: "I"
C: SyntaxError
D: undefined

答案

答案：B

可以使用方括號表示法獲取字符串中特定索引的字符，字符串中的第一個字符具有索引 0，依此類推。在這種情況下，我們想要得到索引為 0 的元素，字符'I'被記錄。

請注意，IE7 及更低版本不支持此方法。在這種情況下，應(yīng)該使用.charAt（）

88. 輸出什么？

function sum(num1, num2 = num1) {
  console.log(num1 + num2)
}

sum(10)

A: NaN
B: 20
C: ReferenceError
D: undefined

答案

答案：B

您可以將默認(rèn)參數(shù)的值設(shè)置為函數(shù)的另一個參數(shù)，只要另一個參數(shù)定義在其之前即可。我們將值10傳遞給sum函數(shù)。如果sum函數(shù)只接收 1 個參數(shù)，則意味著沒有傳遞num2的值，這種情況下，num1的值等于傳遞的值10。num2的默認(rèn)值是num1的值，即10。num1 + num2返回20。

如果您嘗試將默認(rèn)參數(shù)的值設(shè)置為后面定義的參數(shù)，則可能導(dǎo)致參數(shù)的值尚未初始化，從而引發(fā)錯誤。比如：

function test(m = n, n = 2) {
	console.log(m, n)
}
test() // Uncaught ReferenceError: Cannot access 'n' before initialization
test(3) // 3 2
test(3, 4) // 3 4

89. 輸出什么？

// module.js 
export default () =&gt; "Hello world"
export const name = "Lydia"

// index.js 
import * as data from "./module"

console.log(data)

A: { default: function default(), name: "Lydia" }
B: { default: function default() }
C: { default: "Hello world", name: "Lydia" }
D: Global object of module.js

答案

答案：A

使用import * as name語法，我們將module.js文件中所有export導(dǎo)入到index.js文件中，并且創(chuàng)建了一個名為data的新對象。在module.js文件中，有兩個導(dǎo)出：默認(rèn)導(dǎo)出和命名導(dǎo)出。默認(rèn)導(dǎo)出是一個返回字符串“Hello World”的函數(shù)，命名導(dǎo)出是一個名為name的變量，其值為字符串“Lydia”。

data對象具有默認(rèn)導(dǎo)出的default屬性，其他屬性具有指定 exports 的名稱及其對應(yīng)的值。

90. 輸出什么？

class Person {
  constructor(name) {
    this.name = name
  }
}

const member = new Person("John")
console.log(typeof member)

A: "class"
B: "function"
C: "object"
D: "string"

答案

答案：C

類是構(gòu)造函數(shù)的語法糖，如果用構(gòu)造函數(shù)的方式來重寫Person類則將是：

function Person() {
  this.name = name
}

通過new來調(diào)用構(gòu)造函數(shù)，將會生成構(gòu)造函數(shù)Person的實(shí)例，對實(shí)例執(zhí)行typeof關(guān)鍵字將返回"object"，上述情況打印出"object"。

91. 輸出什么？

let newList = [1, 2, 3].push(4)

console.log(newList.push(5))

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

答案

答案：D

.push方法返回?cái)?shù)組的長度，而不是數(shù)組本身！通過將newList設(shè)置為[1,2,3].push(4)，實(shí)際上newList等于數(shù)組的新長度：4。

然后，嘗試在newList上使用.push方法。由于newList是數(shù)值4，拋出 TypeError。

92. 輸出什么？

function giveLydiaPizza() {
  return "Here is pizza!"
}

const giveLydiaChocolate = () =&gt; "Here's chocolate... now go hit the gym already."

console.log(giveLydiaPizza.prototype)
console.log(giveLydiaChocolate.prototype)

A: { constructor: ...} { constructor: ...}
B: {} { constructor: ...}
C: { constructor: ...} {}
D: { constructor: ...} undefined

答案

答案：D

常規(guī)函數(shù)，例如giveLydiaPizza函數(shù)，有一個prototype屬性，它是一個帶有constructor屬性的對象（原型對象）。然而，箭頭函數(shù)，例如giveLydiaChocolate函數(shù)，沒有這個prototype屬性。嘗試使用giveLydiaChocolate.prototype訪問prototype屬性時會返回undefined。

93. 輸出什么？

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

for (const [x, y] of Object.entries(person)) {
  console.log(x, y)
}

A: name Lydia and age 21
B: ["name", "Lydia"] and ["age", 21]
C: ["name", "age"] and undefined
D: Error

答案

答案：A

Object.entries()方法返回一個給定對象自身可枚舉屬性的鍵值對數(shù)組，上述情況返回一個二維數(shù)組，數(shù)組每個元素是一個包含鍵和值的數(shù)組：

[['name','Lydia'],['age', 21]]

使用for-of循環(huán)，我們可以迭代數(shù)組中的每個元素，上述情況是子數(shù)組。我們可以使用const [x，y]在for-of循環(huán)中解構(gòu)子數(shù)組。x等于子數(shù)組中的第一個元素，y等于子數(shù)組中的第二個元素。

第一個子陣列是[“name”，“Lydia”]，其中x等于name，而y等于Lydia。第二個子陣列是[“age”，21]，其中x等于age，而y等于21。

94. 輸出什么？

function getItems(fruitList, ...args, favoriteFruit) {
  return [...fruitList, ...args, favoriteFruit]
}

getItems(["banana", "apple"], "pear", "orange")

A: ["banana", "apple", "pear", "orange"]
B: [["banana", "apple"], "pear", "orange"]
C: ["banana", "apple", ["pear"], "orange"]
D: SyntaxError

答案

答案：D

... args是剩余參數(shù)，剩余參數(shù)的值是一個包含所有剩余參數(shù)的數(shù)組，并且只能作為最后一個參數(shù)。上述示例中，剩余參數(shù)是第二個參數(shù)，這是不可能的，并會拋出語法錯誤。

function getItems(fruitList, favoriteFruit, ...args) {
  return [...fruitList, ...args, favoriteFruit]
}

getItems(["banana", "apple"], "pear", "orange")

上述例子是有效的，將會返回?cái)?shù)組：[ 'banana', 'apple', 'orange', 'pear' ]

95. 輸出什么？

function nums(a, b) {
  if
  (a &gt; b)
  console.log('a is bigger')
  else 
  console.log('b is bigger')
  return 
  a + b
}

console.log(nums(4, 2))
console.log(nums(1, 2))

A: a is bigger, 6 and b is bigger, 3
B: a is bigger, undefined and b is bigger, undefined
C: undefined and undefined
D: SyntaxError

答案

答案：B

在 JavaScript 中，我們不必顯式地編寫分號 (;)，但是 JavaScript 引擎仍然在語句之后自動添加分號。這稱為自動分號插入。例如，一個語句可以是變量，或者像throw、return、break這樣的關(guān)鍵字。

在這里，我們在新的一行上寫了一個return語句和另一個值a + b 。然而，由于它是一個新行，引擎并不知道它實(shí)際上是我們想要返回的值。相反，它會在return后面自動添加分號。你可以這樣看：

  return;
  a + b

這意味著永遠(yuǎn)不會到達(dá)a + b，因?yàn)楹瘮?shù)在return關(guān)鍵字之后停止運(yùn)行。如果沒有返回值，就像這里，函數(shù)返回undefined。注意，在if/else語句之后沒有自動插入！

96. 輸出什么？

class Person {
  constructor() {
    this.name = "Lydia"
  }
}

Person = class AnotherPerson {
  constructor() {
    this.name = "Sarah"
  }
}

const member = new Person()
console.log(member.name)

A: "Lydia"
B: "Sarah"
C: Error: cannot redeclare Person
D: SyntaxError

答案

答案：B

我們可以將類設(shè)置為等于其他類/函數(shù)構(gòu)造函數(shù)。在這種情況下，我們將Person設(shè)置為AnotherPerson。這個構(gòu)造函數(shù)的名字是Sarah，所以新的Person實(shí)例member上的 name 屬性是Sarah。

97. 輸出什么？

const info = {
  [Symbol('a')]: 'b'
}

console.log(info)
console.log(Object.keys(info))

A: {Symbol('a'): 'b'} and ["{Symbol('a')"]
B: {} and []
C: { a: "b" } and ["a"]
D: {Symbol('a'): 'b'} and []

答案

答案：D

Symbol類型是不可枚舉的。Object.keys方法返回對象上的所有可枚舉的鍵屬性。Symbol類型是不可見的，并返回一個空數(shù)組。記錄整個對象時，所有屬性都是可見的，甚至是不可枚舉的屬性。

這是Symbol的眾多特性之一：除了表示完全唯一的值（防止對象意外名稱沖突，例如當(dāng)使用 2 個想要向同一對象添加屬性的庫時），您還可以隱藏這種方式對象的屬性（盡管不完全。你仍然可以使用Object.getOwnPropertySymbols()方法訪問 Symbol。

98. 輸出什么？

const getList = ([x, ...y]) =&gt; [x, y]
const getUser = user =&gt; { name: user.name, age: user.age }

const list = [1, 2, 3, 4]
const user = { name: "Lydia", age: 21 }

console.log(getList(list))
console.log(getUser(user))

A: [1, [2, 3, 4]] and SyntaxError
B: [1, [2, 3, 4]] and { name: "Lydia", age: 21 }
C: [1, 2, 3, 4] and { name: "Lydia", age: 21 }
D: Error and { name: "Lydia", age: 21 }

答案

答案：A

getList函數(shù)接收一個數(shù)組作為其參數(shù)。在getList函數(shù)的括號之間，我們立即解構(gòu)這個數(shù)組。您可以將其視為：

[x, ...y] = [1, 2, 3, 4]

使用剩余的參數(shù)... y，我們將所有剩余參數(shù)放在一個數(shù)組中。在這種情況下，其余的參數(shù)是2，3和4。 y的值是一個數(shù)組，包含所有其余參數(shù)。在這種情況下，x的值等于1，所以當(dāng)我們打印[x，y]時，會打印[1，[2,3,4]]。

getUser函數(shù)接收一個對象。對于箭頭函數(shù)，如果只返回一個值，我們不必編寫花括號。但是，如果您想從一個箭頭函數(shù)返回一個對象，您必須將它寫在圓括號之間，否則兩個花括號之間的所有內(nèi)容都將被解釋為一個塊語句！在這種情況下，花括號之間的代碼不是有效的 JavaScript 代碼，因此會拋出 SyntaxError。

以下函數(shù)將返回一個對象：

const getUser = user => ({ name: user.name, age: user.age })

99. 輸出什么？

const name = "Lydia"

console.log(name())

A: SyntaxError
B: ReferenceError
C: TypeError
D: undefined

答案

答案：C

變量name保存字符串的值，該字符串不是函數(shù)，因此無法調(diào)用。

當(dāng)值不是預(yù)期類型時，會拋出TypeErrors。JavaScript 期望name是一個函數(shù)，因?yàn)槲覀冊噲D調(diào)用它。但它是一個字符串，因此拋出TypeError：name is not a function

當(dāng)你編寫了一些非有效的 JavaScript 時，會拋出語法錯誤，例如當(dāng)你把return這個詞寫成retrun時。當(dāng) JavaScript 無法找到您嘗試訪問的值的引用時，拋出ReferenceErrors。

100. 輸出什么？

// ??? This is my 100th question! ???

const output = `${[] &amp;&amp; 'Im'}possible!
You should${'' &amp;&amp; `n't`} see a therapist after so much JavaScript lol`

A: possible! You should see a therapist after so much JavaScript lol
B: Impossible! You should see a therapist after so much JavaScript lol
C: possible! You shouldn't see a therapist after so much JavaScript lol
D: Impossible! You shouldn't see a therapist after so much JavaScript lol

答案

答案：B

[]是一個真值。使用&&運(yùn)算符，如果左側(cè)值是真值，則返回右側(cè)值。在這種情況下，左側(cè)值[]是一個真值，所以返回Im。

""是一個假值。如果左側(cè)值是假的，則不返回任何內(nèi)容。n't不會被退回。

101.輸出什么？

const one = (false || {} || null)
const two = (null || false || "")
const three = ([] || 0 || true)

console.log(one, two, three)

A: false null []
B: null "" true
C: {} "" []
D: null null true

答案

答案：C

使用||運(yùn)算符，我們可以返回第一個真值。如果所有值都是假值，則返回最后一個值。

（false || {} || null）：空對象{}是一個真值。這是第一個（也是唯一的）真值，它將被返回。one等于{}。

（null || false ||“”）：所有值都是假值。這意味著返回傳遞的值""。two等于""。

（[] || 0 ||“”）：空數(shù)組[]是一個真值。這是第一個返回的真值。three等于[]。

102. 依次輸出什么？

const myPromise = () =&gt; Promise.resolve('I have resolved!')

function firstFunction() {
  myPromise().then(res =&gt; console.log(res))
  console.log('second')
}

async function secondFunction() {
  console.log(await myPromise())
  console.log('second')
}

firstFunction()
secondFunction()

A: I have resolved!, second and I have resolved!, second
B: second, I have resolved! and second, I have resolved!
C: I have resolved!, second and second, I have resolved!
D: second, I have resolved! and I have resolved!, second

答案

答案：D

有了 promise，我們通常會說：當(dāng)我想要調(diào)用某個方法，但是由于它可能需要一段時間，因此暫時將它放在一邊。只有當(dāng)某個值被 resolved/rejected，并且執(zhí)行棧為空時才使用這個值。

我們可以在async函數(shù)中通過.then和await關(guān)鍵字獲得該值。盡管我們可以通過.then和await獲得 promise 的價(jià)值，但是它們的工作方式有所不同。

在 firstFunction中，當(dāng)運(yùn)行到myPromise方法時我們將其放在一邊，即 promise 進(jìn)入微任務(wù)隊(duì)列，其他后面的代碼（console.log('second')）照常運(yùn)行，因此second被打印出，firstFunction方法到此執(zhí)行完畢，執(zhí)行棧中宏任務(wù)隊(duì)列被清空，此時開始執(zhí)行微任務(wù)隊(duì)列中的任務(wù)，I have resolved被打印出。

在secondFunction方法中，我們通過await關(guān)鍵字，暫停了后面代碼的執(zhí)行，直到異步函數(shù)的值被解析才開始后面代碼的執(zhí)行。這意味著，它會等著直到 myPromise 以值I have resolved被解決之后，下一行second才開始執(zhí)行。

103. 輸出什么？

const set = new Set()

set.add(1)
set.add("Lydia")
set.add({ name: "Lydia" })

for (let item of set) {
  console.log(item + 2)
}

A: 3, NaN, NaN
B: 3, 7, NaN
C: 3, Lydia2, [Object object]2
D: "12", Lydia2, [Object object]2

答案

答案：C

“+”運(yùn)算符不僅用于添加數(shù)值，還可以使用它來連接字符串。每當(dāng) JavaScript 引擎發(fā)現(xiàn)一個或多個值不是數(shù)字時，就會將數(shù)字強(qiáng)制為字符串。

第一個是數(shù)字 1。1 + 2 返回?cái)?shù)字 3。

但是，第二個是字符串“Lydia”。 “Lydia”是一個字符串，2 是一個數(shù)字：2 被強(qiáng)制轉(zhuǎn)換為字符串。 “Lydia”和“2”被連接起來，產(chǎn)生字符串“Lydia2”。

{name：“Lydia”}是一個對象。數(shù)字和對象都不是字符串，因此將二者都字符串化。每當(dāng)我們對常規(guī)對象進(jìn)行字符串化時，它就會變成[Object object]。與“2”串聯(lián)的“ [Object object]”成為“[Object object]2”。

104. 結(jié)果是什么？

Promise.resolve(5)

A: 5
B: Promise {<pending>: 5}
C: Promise {<fulfilled>: 5}
D: Error

答案

答案：C

我們可以將我們想要的任何類型的值傳遞Promise.resolve，無論是否promise。該方法本身返回帶有已解析值的Promise ()。如果您傳遞常規(guī)函數(shù)，它將是具有常規(guī)值的已解決promise。如果你通過了 promise，它將是一個已經(jīng) resolved 的且?guī)в袀鞯闹档?promise。

上述情況，我們傳了數(shù)字 5，因此返回一個 resolved 狀態(tài)的 promise，resolve 值為5

105. 輸出什么？

function compareMembers(person1, person2 = person) {
  if (person1 !== person2) {
    console.log("Not the same!")
  } else {
    console.log("They are the same!")
  }
}

const person = { name: "Lydia" }

compareMembers(person)

A: Not the same!
B: They are the same!
C: ReferenceError
D: SyntaxError

答案

答案：B

對象通過引用傳遞。當(dāng)我們檢查對象的嚴(yán)格相等性（===）時，我們正在比較它們的引用。

我們將“person2”的默認(rèn)值設(shè)置為“person”對象，并將“person”對象作為“person1”的值傳遞。

這意味著兩個值都引用內(nèi)存中的同一位置，因此它們是相等的。

運(yùn)行“else”語句中的代碼塊，并記錄They are the same!。

106. 輸出什么？

const colorConfig = {
  red: true,
  blue: false,
  green: true,
  black: true,
  yellow: false,
}

const colors = ["pink", "red", "blue"]

console.log(colorConfig.colors[1])

A: true
B: false
C: undefined
D: TypeError

答案

答案：D

在 JavaScript 中，我們有兩種訪問對象屬性的方法：括號表示法或點(diǎn)表示法。在此示例中，我們使用點(diǎn)表示法（colorConfig.colors）代替括號表示法（colorConfig [“colors”]）。

使用點(diǎn)表示法，JavaScript 會嘗試使用該確切名稱在對象上查找屬性。在此示例中，JavaScript 嘗試在 colorConfig 對象上找到名為 colors 的屬性。沒有名為“colors”的屬性，因此返回“undefined”。然后，我們嘗試使用[1]訪問第一個元素的值。我們無法對未定義的值執(zhí)行此操作，因此會拋出Cannot read property '1' of undefined。

JavaScript 解釋（或取消裝箱）語句。當(dāng)我們使用方括號表示法時，它會看到第一個左方括號[并一直進(jìn)行下去，直到找到右方括號]。只有這樣，它才會評估該語句。如果我們使用了 colorConfig [colors [1]]，它將返回 colorConfig 對象上 red 屬性的值。

107. 輸出什么？

console.log('??' === '??')

A: true
B: false

答案

答案：A

在內(nèi)部，表情符號是 unicode。heat 表情符號的 unicode 是“U + 2764 U + FE0F”。對于相同的表情符號，它們總是相同的，因此我們將兩個相等的字符串相互比較，這將返回 true。

您可能感興趣的文章:

欧美bbbwbbbw肥妇,免费乱码人妻系列日韩,一级黄片

JavaScript?進(jìn)階問題列表(各種js代碼段66-107)

66. 使用哪個構(gòu)造函數(shù)可以成功繼承Dog類？

答案：B

67. 輸出什么？

答案：B

68. 輸出什么？

答案：A

69. 輸出什么？

答案：C

70. 輸出什么？

答案：A

71. 如何能打印出console.log語句后注釋掉的值？

答案：C

72. 輸出什么？

答案：C

73. 輸出什么？

答案：C

74. 輸出什么？

答案：B

75. 輸出什么？

答案：B

76. 輸出什么？

答案：D

77. 以下是個純函數(shù)么？

答案：A

78. 輸出什么？

答案：C

79. 輸出什么？

答案：A

80. 輸出什么？

答案：C

81. 輸出什么？

答案：B

82. 輸出什么？

答案：B

83. 輸出什么？

答案：A

84. 輸出什么？

答案：C

答案：C

86. 哪個選項(xiàng)是將hasName設(shè)置為true的方法，前提是不能將true作為參數(shù)傳遞？

答案：A

87. 輸出什么？

答案：B

88. 輸出什么？

答案：B

89. 輸出什么？

答案：A

90. 輸出什么？

答案：C

91. 輸出什么？

答案：D

92. 輸出什么？

答案：D

93. 輸出什么？

答案：A

94. 輸出什么？

答案：D

95. 輸出什么？

答案：B

96. 輸出什么？

答案：B

97. 輸出什么？

答案：D

98. 輸出什么？

答案：A

99. 輸出什么？

答案：C

100. 輸出什么？

答案：B

101.輸出什么？

答案：C

102. 依次輸出什么？

答案：D

103. 輸出什么？

答案：C

104. 結(jié)果是什么？

答案：C

105. 輸出什么？

66. 使用哪個構(gòu)造函數(shù)可以成功繼承`Dog`類？

67. 輸出什么？

68. 輸出什么？

69. 輸出什么？

70. 輸出什么？

71. 如何能打印出`console.log`語句后注釋掉的值？

72. 輸出什么？

73. 輸出什么？

75. 輸出什么？

76. 輸出什么？

77. 以下是個純函數(shù)么？

78. 輸出什么？

79. 輸出什么？

80. 輸出什么？

81. 輸出什么？

82. 輸出什么？

83. 輸出什么？

84. 輸出什么？

86. 哪個選項(xiàng)是將`hasName`設(shè)置為`true`的方法，前提是不能將`true`作為參數(shù)傳遞？

87. 輸出什么？

90. 輸出什么？

92. 輸出什么？

93. 輸出什么？

94. 輸出什么？

96. 輸出什么？

97. 輸出什么？

98. 輸出什么？

99. 輸出什么？

101.輸出什么？

102. 依次輸出什么？

103. 輸出什么？

104. 結(jié)果是什么？

105. 輸出什么？

107. 輸出什么？