JavaScript?進階問題列表(各種js代碼段66-107)
我在我的 Instagram 上每天都會發(fā)布 JavaScript 的多選問題，并且同時也會在這個倉庫中發(fā)布。
從基礎到進階，測試你有多了解 JavaScript，刷新你的知識，或者幫助你的 coding 面試！ :muscle: :rocket: 我每周都會在這個倉庫下更新新的問題。
答案在問題下方的折疊部分，點擊即可展開問題。祝你好運
66. 使用哪個構造函數(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
在子類中，在調用super之前不能訪問到this關鍵字。如果這樣做，它將拋出一個ReferenceError：1 和 4 將引發(fā)一個引用錯誤。
使用super關鍵字，需要用給定的參數(shù)來調用父類的構造函數(shù)。父類的構造函數(shù)接收name參數(shù)，因此我們需要將name傳遞給super。
Labrador類接收兩個參數(shù)，name參數(shù)是由于它繼承了Dog，size作為Labrador類的額外屬性，它們都需要傳遞給Labrador的構造函數(shù)，因此使用構造函數(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) => 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í)行的，在代碼運行之前。因此這意味著被導入的模塊會先運行，而導入模塊的文件會后執(zhí)行。
這是 CommonJS 中require（）和import之間的區(qū)別。使用require()，您可以在運行代碼時根據需要加載依賴項。如果我們使用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ù)。當我們測試相等時，我們創(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
使用+運算符，您可以連接字符串。上述情況，我們將字符串“??”與字符串”??“連接起來，產生”????“。
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").valueandgame.next().value - B:
game.next.value("Yes")andgame.next.value() - C:
game.next().valueandgame.next("Yes").value - D:
game.next.value()andgame.next.value("Yes")
答案
答案：C
generator函數(shù)在遇到yield關鍵字時會“暫停”其執(zhí)行。首先，我們需要讓函數(shù)產生字符串Do you love JavaScript?，這可以通過調用game.next().value來完成。上述函數(shù)的第一行就有一個yield關鍵字，那么運行立即停止了，yield表達式本身沒有返回值，或者說總是返回undefined，這意味著此時變量 答案 為undefined
next方法可以帶一個參數(shù)，該參數(shù)會被當作上一個 yield 表達式的返回值。當我們調用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:
Helloworld - C:
Hello\nworld - D:
Hello\nworld
答案
答案：C
String.raw函數(shù)是用來獲取一個模板字符串的原始字符串的，它返回一個字符串，其中忽略了轉義符（\n，\v，\t等）。但反斜杠可能造成問題，因為你可能會遇到下面這種類似情況：
const path = `C:\Documents\Projects\table.html`
String.raw`${path}`
這將導致：
"C:DocumentsProjects able.html"
直接使用String.raw
String.raw`C:\Documents\Projects\table.html`
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 的解決：當我們調用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ù)返回數(shù)組而不是數(shù)組長度，那么應該在 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使得無法添加、刪除或修改對象的屬性（除非屬性的值是另一個對象）。
當我們創(chuàng)建變量shape并將其設置為等于凍結對象box時，shape指向的也是凍結對象。你可以使用Object.isFrozen檢查一個對象是否被凍結，上述情況，Object.isFrozen（shape）將返回true。
由于shape被凍結，并且x的值不是對象，所以我們不能修改屬性x。x仍然等于10，{x：10，y：20}被打印。
注意，上述例子我們對屬性x進行修改，可能會導致拋出 TypeError 異常（最常見但不僅限于嚴格模式下時）。
76. 輸出什么？
const { name: myName } = { name: "Lydia" };
console.log(name);- A:
"Lydia" - B:
"myName" - C:
undefined - D:
ReferenceError
答案
答案：D
當我們從右側的對象解構屬性name時，我們將其值Lydia分配給名為myName的變量。
使用{name：myName}，我們是在告訴 JavaScript 我們要創(chuàng)建一個名為myName的新變量，并且其值是右側對象的name屬性的值。
當我們嘗試打印name，一個未定義的變量時，就會引發(fā)ReferenceError。
77. 以下是個純函數(shù)么？
function sum(a, b) {
return a + b;
}- A: Yes
- B: No
答案
答案：A
純函數(shù)在相同的輸入值時，需產生相同的輸出，其輸出的結果，與輸入值以外的其他隱藏信息或狀態(tài)無關，也和由 I/O 設備產生的外部輸出無關。 純函數(shù)不會產生副作用。
純函數(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 = () => {
const cache = {};
return num => {
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! 20Calculated! 20Calculated! 20 - B:
Calculated! 20From cache! 20Calculated! 20 - C:
Calculated! 20From cache! 20From cache! 20 - D:
Calculated! 20From cache! 20Error
答案
答案：C
add函數(shù)是一個記憶函數(shù)。通過記憶化，我們可以緩存函數(shù)的結果，以加快其執(zhí)行速度。上述情況，我們創(chuàng)建一個cache對象，用于存儲先前返回過的值。
如果我們使用相同的參數(shù)多次調用addFunction函數(shù)，它首先檢查緩存中是否已有該值，如果有，則返回緩存值，這將節(jié)省執(zhí)行時間。如果沒有，那么它將計算該值，并存儲在緩存中。
我們用相同的值三次調用了addFunction函數(shù)：
在第一次調用，num等于10時函數(shù)的值尚未緩存，if 語句num in cache返回false，else 塊的代碼被執(zhí)行：Calculated! 20，并且其結果被添加到緩存對象，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:
0123and"?""??""??""??" - B:
"?""??""??""??"and"?""??""??""??" - C:
"?""??""??""??"and0123 - D:
0123and{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等）。當我們迭代數(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，以及其他表達式，如日期，函數(shù)和計算。
元素將等于返回的值。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
默認情況下，如果不給函數(shù)傳參，參數(shù)的值將為undefined。上述情況，我們沒有給參數(shù)name傳值。name等于undefined，并被打印。
在 ES6 中，我們可以使用默認參數(shù)覆蓋此默認的undefined值。例如：
function sayHi (name =“Lydia”){...}
在這種情況下，如果我們沒有傳遞值或者如果我們傳遞undefined，name總是等于字符串Lydia
82. 輸出什么？
var status = "??"
setTimeout(() => {
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關鍵字的指向取決于使用它的位置。在函數(shù)中，比如getStatus，this指向的是調用它的對象，上述例子中data對象調用了getStatus，因此this指向的就是data對象。當我們打印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設置為等于person對象上名為city的屬性的值。這個對象上沒有名為city的屬性，因此變量city的值為undefined。
請注意，我們沒有引用person對象本身，只是將變量city設置為等于person對象上city屬性的當前值。
然后，我們將city設置為等于字符串“Amsterdam”。這不會更改 person 對象：沒有對該對象的引用。
因此打印person對象時，會返回未修改的對象。
84. 輸出什么？
function checkAge(age) {
if (age < 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. 什么樣的信息將被打印？
fetch('https://www.website.com/api/user/1')
.then(res => res.json())
.then(res => console.log(res))- A:
fetch方法的結果 - B: 第二次調用
fetch方法的結果 - C: 前一個
.then()中回調方法返回的結果 - D: 總是
undefined
答案
答案：C
第二個.then中res的值等于前一個.then中的回調函數(shù)返回的值。你可以像這樣繼續(xù)鏈接.then，將值傳遞給下一個處理程序。
86. 哪個選項是將hasName設置為true的方法，前提是不能將true作為參數(shù)傳遞？
function getName(name) {
const hasName = //
}- A:
!!name - B:
name - C:
new Boolean(name) - D:
name.length
答案
答案：A
使用邏輯非運算符!，將返回一個布爾值，使用!! name，我們可以確定name的值是真的還是假的。如果name是真實的，那么!name返回false。!false返回true。
通過將hasName設置為name，可以將hasName設置為等于傳遞給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 及更低版本不支持此方法。在這種情況下，應該使用.charAt（）
88. 輸出什么？
function sum(num1, num2 = num1) {
console.log(num1 + num2)
}
sum(10)- A:
NaN - B:
20 - C:
ReferenceError - D:
undefined
答案
答案：B
您可以將默認參數(shù)的值設置為函數(shù)的另一個參數(shù)，只要另一個參數(shù)定義在其之前即可。我們將值10傳遞給sum函數(shù)。如果sum函數(shù)只接收 1 個參數(shù)，則意味著沒有傳遞num2的值，這種情況下，num1的值等于傳遞的值10。num2的默認值是num1的值，即10。num1 + num2返回20。
如果您嘗試將默認參數(shù)的值設置為后面定義的參數(shù)，則可能導致參數(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 489. 輸出什么？
// module.js export default () => "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導入到index.js文件中，并且創(chuàng)建了一個名為data的新對象。在module.js文件中，有兩個導出：默認導出和命名導出。默認導出是一個返回字符串“Hello World”的函數(shù)，命名導出是一個名為name的變量，其值為字符串“Lydia”。
data對象具有默認導出的default屬性，其他屬性具有指定 exports 的名稱及其對應的值。
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
類是構造函數(shù)的語法糖，如果用構造函數(shù)的方式來重寫Person類則將是：
function Person() {
this.name = name
}
通過new來調用構造函數(shù)，將會生成構造函數(shù)Person的實例，對實例執(zhí)行typeof關鍵字將返回"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方法返回數(shù)組的長度，而不是數(shù)組本身！通過將newList設置為[1,2,3].push(4)，實際上newList等于數(shù)組的新長度：4。
然后，嘗試在newList上使用.push方法。由于newList是數(shù)值4，拋出 TypeError。
92. 輸出什么？
function giveLydiaPizza() {
return "Here is pizza!"
}
const giveLydiaChocolate = () => "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:
nameLydiaandage21 - B:
["name", "Lydia"]and["age", 21] - C:
["name", "age"]andundefined - 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)中解構子數(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")
上述例子是有效的，將會返回數(shù)組：[ 'banana', 'apple', 'orange', 'pear' ]
95. 輸出什么？
function nums(a, b) {
if
(a > 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,6andb is bigger,3 - B:
a is bigger,undefinedandb is bigger,undefined - C:
undefinedandundefined - D:
SyntaxError
答案
答案：B
在 JavaScript 中，我們不必顯式地編寫分號 (;)，但是 JavaScript 引擎仍然在語句之后自動添加分號。這稱為自動分號插入。例如，一個語句可以是變量，或者像throw、return、break這樣的關鍵字。
在這里，我們在新的一行上寫了一個return語句和另一個值a + b 。然而，由于它是一個新行，引擎并不知道它實際上是我們想要返回的值。相反，它會在return后面自動添加分號。你可以這樣看：
return; a + b
這意味著永遠不會到達a + b，因為函數(shù)在return關鍵字之后停止運行。如果沒有返回值，就像這里，函數(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ù)。在這種情況下，我們將Person設置為AnotherPerson。這個構造函數(shù)的名字是Sarah，所以新的Person實例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的眾多特性之一：除了表示完全唯一的值（防止對象意外名稱沖突，例如當使用 2 個想要向同一對象添加屬性的庫時），您還可以隱藏這種方式對象的屬性（盡管不完全。你仍然可以使用Object.getOwnPropertySymbols()方法訪問 Symbol。
98. 輸出什么？
const getList = ([x, ...y]) => [x, y]
const getUser = user => { 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]]andSyntaxError - B:
[1, [2, 3, 4]]and{ name: "Lydia", age: 21 } - C:
[1, 2, 3, 4]and{ name: "Lydia", age: 21 } - D:
Errorand{ name: "Lydia", age: 21 }
答案
答案：A
getList函數(shù)接收一個數(shù)組作為其參數(shù)。在getList函數(shù)的括號之間，我們立即解構這個數(shù)組。您可以將其視為：
[x, ...y] = [1, 2, 3, 4]
使用剩余的參數(shù)... y，我們將所有剩余參數(shù)放在一個數(shù)組中。在這種情況下，其余的參數(shù)是2，3和4。 y的值是一個數(shù)組，包含所有其余參數(shù)。在這種情況下，x的值等于1，所以當我們打印[x，y]時，會打印[1，[2,3,4]]。
getUser函數(shù)接收一個對象。對于箭頭函數(shù)，如果只返回一個值，我們不必編寫花括號。但是，如果您想從一個箭頭函數(shù)返回一個對象，您必須將它寫在圓括號之間，否則兩個花括號之間的所有內容都將被解釋為一個塊語句！在這種情況下，花括號之間的代碼不是有效的 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ù)，因此無法調用。
當值不是預期類型時，會拋出TypeErrors。JavaScript 期望name是一個函數(shù)，因為我們試圖調用它。但它是一個字符串，因此拋出TypeError：name is not a function
當你編寫了一些非有效的 JavaScript 時，會拋出語法錯誤，例如當你把return這個詞寫成retrun時。 當 JavaScript 無法找到您嘗試訪問的值的引用時，拋出ReferenceErrors。
100. 輸出什么？
// ??? This is my 100th question! ???
const output = `${[] && 'Im'}possible!
You should${'' && `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
[]是一個真值。使用&&運算符，如果左側值是真值，則返回右側值。在這種情況下，左側值[]是一個真值，所以返回Im。
""是一個假值。如果左側值是假的，則不返回任何內容。n't不會被退回。
101.輸出什么？
const one = (false || {} || null)
const two = (null || false || "")
const three = ([] || 0 || true)
console.log(one, two, three)- A:
falsenull[] - B:
null""true - C:
{}""[] - D:
nullnulltrue
答案
答案：C
使用||運算符，我們可以返回第一個真值。如果所有值都是假值，則返回最后一個值。
（false || {} || null）：空對象{}是一個真值。這是第一個（也是唯一的）真值，它將被返回。one等于{}。
（null || false ||“”）：所有值都是假值。這意味著返回傳遞的值""。two等于""。
（[] || 0 ||“”）：空數(shù)組[]是一個真值。這是第一個返回的真值。three等于[]。
102. 依次輸出什么？
const myPromise = () => Promise.resolve('I have resolved!')
function firstFunction() {
myPromise().then(res => console.log(res))
console.log('second')
}
async function secondFunction() {
console.log(await myPromise())
console.log('second')
}
firstFunction()
secondFunction()- A:
I have resolved!,secondandI have resolved!,second - B:
second,I have resolved!andsecond,I have resolved! - C:
I have resolved!,secondandsecond,I have resolved! - D:
second,I have resolved!andI have resolved!,second
答案
答案：D
有了 promise，我們通常會說：當我想要調用某個方法，但是由于它可能需要一段時間，因此暫時將它放在一邊。只有當某個值被 resolved/rejected，并且執(zhí)行棧為空時才使用這個值。
我們可以在async函數(shù)中通過.then和await關鍵字獲得該值。盡管我們可以通過.then和await獲得 promise 的價值，但是它們的工作方式有所不同。
在 firstFunction中，當運行到myPromise方法時我們將其放在一邊，即 promise 進入微任務隊列，其他后面的代碼（console.log('second')）照常運行，因此second被打印出，firstFunction方法到此執(zhí)行完畢，執(zhí)行棧中宏任務隊列被清空，此時開始執(zhí)行微任務隊列中的任務，I have resolved被打印出。
在secondFunction方法中，我們通過await關鍵字，暫停了后面代碼的執(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
“+”運算符不僅用于添加數(shù)值，還可以使用它來連接字符串。每當 JavaScript 引擎發(fā)現(xiàn)一個或多個值不是數(shù)字時，就會將數(shù)字強制為字符串。
第一個是數(shù)字 1。1 + 2 返回數(shù)字 3。
但是，第二個是字符串“Lydia”。 “Lydia”是一個字符串，2 是一個數(shù)字：2 被強制轉換為字符串。 “Lydia”和“2”被連接起來，產生字符串“Lydia2”。
{name：“Lydia”}是一個對象。數(shù)字和對象都不是字符串，因此將二者都字符串化。每當我們對常規(guī)對象進行字符串化時，它就會變成[Object object]。與“2”串聯(lián)的“ [Object object]”成為“[Object object]2”。
104. 結果是什么？
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，它將是一個已經 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
對象通過引用傳遞。當我們檢查對象的嚴格相等性（===）時，我們正在比較它們的引用。
我們將“person2”的默認值設置為“person”對象，并將“person”對象作為“person1”的值傳遞。
這意味著兩個值都引用內存中的同一位置，因此它們是相等的。
運行“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 中，我們有兩種訪問對象屬性的方法：括號表示法或點表示法。在此示例中，我們使用點表示法（colorConfig.colors）代替括號表示法（colorConfig [“colors”]）。
使用點表示法，JavaScript 會嘗試使用該確切名稱在對象上查找屬性。在此示例中，JavaScript 嘗試在 colorConfig 對象上找到名為 colors 的屬性。沒有名為“colors”的屬性，因此返回“undefined”。 然后，我們嘗試使用[1]訪問第一個元素的值。我們無法對未定義的值執(zhí)行此操作，因此會拋出Cannot read property '1' of undefined。
JavaScript 解釋（或取消裝箱）語句。當我們使用方括號表示法時，它會看到第一個左方括號[并一直進行下去，直到找到右方括號]。只有這樣，它才會評估該語句。如果我們使用了 colorConfig [colors [1]]，它將返回 colorConfig 對象上 red 屬性的值。
107. 輸出什么？
console.log('??' === '??')- A:
true - B:
false
答案
答案：A
在內部，表情符號是 unicode。heat 表情符號的 unicode 是“U + 2764 U + FE0F”。對于相同的表情符號，它們總是相同的，因此我們將兩個相等的字符串相互比較，這將返回 true。
相關文章
這篇文章主要介紹了微信小程序以ssm做后臺開發(fā)的實現(xiàn)示例，文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值，需要的朋友們下面隨著小編來一起學習學習吧2020-04-04
讓你的博文自動帶上縮址的實現(xiàn)代碼，方便發(fā)到微博客上
添加以下代碼到你的博客中: (呵呵，抄襲至lulu Studio http://s8.hk/0itw)2010-12-12
Flutter 超實用簡單菜單彈出框 PopupMenuButton功能
這篇文章主要介紹了Flutter 超實用簡單菜單彈出框 PopupMenuButton功能，本文通過實例代碼給大家介紹的非常詳細，具有一定的參考借鑒價值,需要的朋友可以參考下2019-08-08
javascript?實現(xiàn)純前端將數(shù)據導出excel兩種方式
這篇文章主要介紹了javascript?實現(xiàn)純前端將數(shù)據導出excel兩種方式，文章圍繞主題展開詳細的內容介紹，具有一定的參考價值，需要的小伙伴可以參一下2022-07-07
這篇文章主要為大家詳細介紹了微信小程序實現(xiàn)時間選擇，文中示例代碼介紹的非常詳細，具有一定的參考價值，感興趣的小伙伴們可以參考一下2022-07-07
這篇文章主要介紹了Java File類的常用方法總結,本文講解了File類的常用方法,并對一些方法給出了代碼示例,需要的朋友可以參考下2015-03-03
這篇文章主要介紹了微信公眾號平臺接口開發(fā) 菜單管理的實現(xiàn),文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值,需要的朋友可以參考下2019-08-08
這篇文章主要給大家介紹了關于javascript中數(shù)組的常用算法的相關資料，文中通過示例代碼介紹的非常詳細，對大家的學習或者使用javascript具有一定的參考學習價值，需要的朋友們下面來一起學習學習吧2019-03-03
這篇文章主要介紹了javascript實現(xiàn)PC網頁里的拖拽效果的相關資料,需要的朋友可以參考下2016-03-03
本文主要介紹了在JavaScript中實現(xiàn)復制圖片的方法,先介紹了實現(xiàn)復制的前置知識,包括傳統(tǒng)的 execCommand 方法及其優(yōu)缺點和 Clipboard API,然后詳細闡述了如何將不同形式的圖片轉化為blob對象并通過Clipboard API實現(xiàn)復制,還提及了兼容性問題及預覽、下載圖片的實現(xiàn)思路2025-03-03