星辰大海」JS自测清单(三)

转载自 javascript-questions(star支持一波)

我们的征途是星辰大海~

答案在问题下方的折叠部分,点击即可展开问题。祝你好运 :heart:

110. 这个函数干了什么?
JSON.parse()
  • A: Parses JSON to a JavaScript value
  • B: Parses a JavaScript object to JSON
  • C: Parses any JavaScript value to JSON
  • D: Parses JSON to a JavaScript object only
答案

答案: A

使用JSON.parse()方法,我们可以将JSON字符串解析为JavaScript值。

// 将数字字符串化为有效的JSON,然后将JSON字符串解析为JavaScript值:
const jsonNumber = JSON.stringify(4) // '4'
JSON.parse(jsonNumber) // 4

// 将数组值字符串化为有效的JSON,然后将JSON字符串解析为JavaScript值:
const jsonArray = JSON.stringify([1, 2, 3]) // '[1, 2, 3]'
JSON.parse(jsonArray) // [1, 2, 3]

// 将对象字符串化为有效的JSON,然后将JSON字符串解析为JavaScript值:
const jsonArray = JSON.stringify({ name: "Lydia" }) // '{"name":"Lydia"}'
JSON.parse(jsonArray) // { name: 'Lydia' }


111. 输出什么?
let name = 'Lydia'

function getName() {
console.log(name)
let name = 'Sarah'
}

getName()
  • A: Lydia
  • B: Sarah
  • C: undefined
  • D: ReferenceError
答案

答案: D

每个函数都有其自己的执行上下文。 getName函数首先在其自身的上下文(范围)内查找,以查看其是否包含我们尝试访问的变量name。 上述情况,getName函数包含其自己的name变量:我们用let关键字和Sarah的值声明变量name

带有let关键字(和const)的变量被提升,但是与var不同,它不会被初始化。 在我们声明(初始化)它们之前,无法访问它们。 这称为“暂时性死区”。 当我们尝试在声明变量之前访问变量时,JavaScript会抛出ReferenceError: Cannot access 'name' before initialization

如果我们不在getName函数中声明name变量,则javascript引擎会查看原型练。会找到其外部作用域有一个名为name的变量,其值为Lydia。 在这种情况下,它将打印Lydia

let name = 'Lydia'

function getName() {
console.log(name)
}

getName() // Lydia


112. 输出什么?
function* generatorOne() {
yield ['a', 'b', 'c'];
}

function* generatorTwo() {
yield* ['a', 'b', 'c'];
}

const one = generatorOne()
const two = generatorTwo()

console.log(one.next().value)
console.log(two.next().value)
  • A: a and a
  • B: a and undefined
  • C: ['a', 'b', 'c'] and a
  • D: a and ['a', 'b', 'c']
答案

答案: C

通过 yield 关键字, 我们在 Generator 函数里执行yield表达式. 通过 yield* 关键字, 我们可以在一个Generator 函数里面执行(yield表达式)另一个 Generator 函数, 或可遍历的对象 (如数组).

在函数 generatorOne 中, 我们通过 yield 关键字 yield 了一个完整的数组 ['a', 'b', 'c']。函数one通过next方法返回的对象的value 属性的值 (one.next().value) 等价于数组 ['a', 'b', 'c'].

console.log(one.next().value) // ['a', 'b', 'c']
console.log(one.next().value) // undefined

在函数 generatorTwo 中, 我们使用 yield* 关键字。就相当于函数two第一个yield的值, 等价于在迭代器中第一个 yield 的值。数组['a', 'b', 'c']就是这个迭代器. 第一个 yield 的值就是 a, 所以我们第一次调用 two.next().value时, 就返回a

console.log(two.next().value) // 'a'
console.log(two.next().value) // 'b'
console.log(two.next().value) // 'c'
console.log(two.next().value) // undefined


113. 输出什么?
console.log(`${(x => x)('I love')} to program`)
  • A: I love to program
  • B: undefined to program
  • C: ${(x => x)('I love') to program
  • D: TypeError
答案

答案: A

带有模板字面量的表达式首先被执行。相当于字符串会包含表达式,这个立即执行函数 (x => x)('I love') 返回的值. 我们向箭头函数 x => x 传递 'I love' 作为参数。x 等价于返回的 'I love'。这就是结果 I love to program


114. 将会发生什么?
let config = {
alert: setInterval(() => {
console.log('Alert!')
}, 1000)
}

config = null
  • A: setInterval 的回调不会被调用
  • B: setInterval 的回调被调用一次
  • C: setInterval 的回调仍然会被每秒钟调用
  • D: 我们从没调用过 config.alert(), config 为 null
答案

答案: C

一般情况下当我们将对象赋值为 null, 那些对象会被进行 垃圾回收(garbage collected) 因为已经没有对这些对象的引用了。然而,setInterval的参数是一个箭头函数(所以上下文绑定到对象 config 了),回调函数仍然保留着对 config的引用。只要存在引用,对象就不会被垃圾回收。因为没有被垃圾回收,setInterval 的回调每1000ms (1s)会被调用一次。


115. 哪一个方法会返回 'Hello world!'
const myMap = new Map()
const myFunc = () => 'greeting'

myMap.set(myFunc, 'Hello world!')

//1
myMap.get('greeting')
//2
myMap.get(myFunc)
//3
myMap.get(() => 'greeting')
  • A: 1
  • B: 2
  • C: 2 and 3
  • D: All of them
答案

答案: B

当通过 set 方法添加一个键值对,一个传递给 set方法的参数将会是键名,第二个参数将会是值。在这个case里,键名为 函数 () => 'greeting',值为'Hello world'myMap 现在就是 { () => 'greeting' => 'Hello world!' }

1 是错的,因为键名不是 'greeting' 而是 () => 'greeting'
3 是错的,因为我们给get 方法传递了一个新的函数。对象受 引用 影响。函数也是对象,因此两个函数严格上并不等价,尽管他们相同:他们有两个不同的内存引用地址。


116. 输出什么?
const person = {
name: "Lydia",
age: 21
}

const changeAge = (x = { ...person }) => x.age += 1
const changeAgeAndName = (x = { ...person }) => {
x.age += 1
x.name = "Sarah"
}

changeAge(person)
changeAgeAndName()

console.log(person)
  • A: {name: "Sarah", age: 22}
  • B: {name: "Sarah", age: 23}
  • C: {name: "Lydia", age: 22}
  • D: {name: "Lydia", age: 23}
答案

答案: C

函数 changeAge 和函数 changeAgeAndName 有着不同的参数,定义一个 生成的对象 { ...person }。这个对象有着所有 person 对象 中 k/v 值的副本。

首项, 我们调用 changeAge 函数并传递 person 对象作为它的参数。这个函数对 age 属性进行加一操作。person 现在是 { name: "Lydia", age: 22 }

然后,我们调用函数 changeAgeAndName ,然而我们没有传递参数。取而代之,x 的值等价 new 生成的对象: { ...person }。因为它是一个新生成的对象,它并不会对对象 person 造成任何副作用。person 仍然等价于 { name: "Lydia", age: 22 }


117. 下面那个选项将会返回 6?
function sumValues(x, y, z) {
return x + y + z;
}
  • A: sumValues([...1, 2, 3])
  • B: sumValues([...[1, 2, 3]])
  • C: sumValues(...[1, 2, 3])
  • D: sumValues([1, 2, 3])
答案

答案: C

通过展开操作符 ...,我们可以 暂开 单个可迭代的元素。函数 sumValues function 接收三个参数: x, yz...[1, 2, 3] 的执行结果为 1, 2, 3,将会传递给函数 sumValues


118. 输出什么?
let num = 1;
const list = ["🥳", "🤠", "🥰", "🤪"];

console.log(list[(num += 1)]);
  • A: 🤠
  • B: 🥰
  • C: SyntaxError
  • D: ReferenceError
答案

答案: B

通过 += 操作符,我们对值 num 进行加 1 操作。 num 有初始值 1,因此 1 + 1 的执行结果为 2。数组 list 的第二项为 🥰,console.log(list[2]) 输出 🥰.


119. 输出什么?
const person = {
firstName: "Lydia",
lastName: "Hallie",
pet: {
name: "Mara",
breed: "Dutch Tulip Hound"
},
getFullName() {
return `${this.firstName} ${this.lastName}`;
}
};

console.log(person.pet?.name);
console.log(person.pet?.family?.name);
console.log(person.getFullName?.());
console.log(member.getLastName?.());
  • A: undefined undefined undefined undefined
  • B: Mara undefined Lydia Hallie undefined
  • C: Mara null Lydia Hallie null
  • D: null ReferenceError null ReferenceError
答案

答案: B

通过 ES10 或 TS3.7+可选链操作符 ?.,我们不再需要显式检测更深层的嵌套值是否有效。如果我们尝试获取 undefinednull 的值 (nullish),表达将会短路并返回 undefined.

person.pet?.nameperson 有一个名为 pet 的属性: person.pet 不是 nullish。它有个名为 name 的属性,并返回字符串 Mara
person.pet?.family?.nameperson 有一个名为 pet 的属性: person.pet 不是 nullish. pet 并没有 一个名为 family 的属性, person.pet.family 是 nullish。表达式返回 undefined
person.getFullName?.()person 有一个名为 getFullName 的属性: person.getFullName() 不是 nullish 并可以被调用,返回字符串 Lydia Hallie
member.getLastName?.(): member is not defined: member.getLastName() is nullish. The expression returns undefined.


120. 输出什么?
const groceries = ["banana", "apple", "peanuts"];

if (groceries.indexOf("banana")) {
console.log("We have to buy bananas!");
} else {
console.log(`We don't have to buy bananas!`);
}
  • A: We have to buy bananas!
  • B: We don’t have to buy bananas
  • C: undefined
  • D: 1
答案

答案: B

我们传递了一个状态 groceries.indexOf("banana") 给if条件语句。groceries.indexOf("banana") 返回 0, 一个 falsy 的值。因为if条件语句的状态为 falsy,else 块区内的代码执行,并且 We don't have to buy bananas! 被输出.


121. 输出什么?
const config = {
languages: [],
set language(lang) {
return this.languages.push(lang);
}
};

console.log(config.language);
  • A: function language(lang) { this.languages.push(lang }
  • B: 0
  • C: []
  • D: undefined
答案

答案: D

方法 language 是一个 setter。Setters 并不保存一个实际值,它们的使命在于 修改 属性。当调用方法 setter, 返回 undefined


122. 输出什么?
const name = "Lydia Hallie";

console.log(!typeof name === "object");
console.log(!typeof name === "string");
  • A: false true
  • B: true false
  • C: false false
  • D: true true
答案

答案: C

typeof name 返回 "string"。字符串 "string" 是一个 truthy 的值,因此 !typeof name 返回一个布尔值 falsefalse === "object"false === "string" 都返回 false

(如果我们想检测一个值的类型,我们应该用 !== 而不是 !typeof


123. 输出什么?
const add = x => y => z => {
console.log(x, y, z);
return x + y + z;
};

add(4)(5)(6);
  • A: 4 5 6
  • B: 6 5 4
  • C: 4 function function
  • D: undefined undefined 6
答案

答案: A

函数 add 是一个返回 返回箭头函数的箭头函数 的箭头函数(still with me?)。第一个函数接收一个值为 4 的参数 x。我们调用第二个函数,它接收一个值为 5 的参数 y。然后我们调用第三个函数,它接收一个值为 6 的参数 z。当我们尝试在最后一个箭头函数中获取 x, yz 的值,JS 引擎根据作用域链去找 xy 的值。得到 4 5 6.


124. 输出什么?
async function* range(start, end) {
for (let i = start; i <= end; i++) {
yield Promise.resolve(i);
}
}

(async () => {
const gen = range(1, 3);
for await (const item of gen) {
console.log(item);
}
})();
  • A: Promise {1} Promise {2} Promise {3}
  • B: Promise {<pending>} Promise {<pending>} Promise {<pending>}
  • C: 1 2 3
  • D: undefined undefined undefined
答案

答案: C

我们给 函数range 传递: Promise{1}, Promise{2}, Promise{3},Generator 函数 range 返回一个全是 async object promise 数组。我们将 async object 赋值给变量 gen,之后我们使用for await ... of 进行循环遍历。我们将返回的 Promise 实例赋值给 item: 第一个返回 Promise{1}, 第二个返回 Promise{2},之后是 Promise{3}。因为我们正 awaiting item 的值,resolved 状态的 promsie,promise数组的resolved 以此为: 123.


125. 输出什么?
const myFunc = ({ x, y, z }) => {
console.log(x, y, z);
};

myFunc(1, 2, 3);
  • A: 1 2 3
  • B: {1: 1} {2: 2} {3: 3}
  • C: { 1: undefined } undefined undefined
  • D: undefined undefined undefined
答案

答案: D

myFunc 期望接收一个包含 x, yz 属性的对象作为它的参数。因为我们仅仅传递三个单独的数字值 (1, 2, 3) 而不是一个含有 x, yz 属性的对象 ({x: 1, y: 2, z: 3}), x, yz 有着各自的默认值 undefined.


126. 输出什么?
function getFine(speed, amount) {
const formattedSpeed = new Intl.NumberFormat({
'en-US',
{ style: 'unit', unit: 'mile-per-hour' }
}).format(speed)

const formattedAmount = new Intl.NumberFormat({
'en-US',
{ style: 'currency', currency: 'USD' }
}).format(amount)

return `The driver drove ${formattedSpeed} and has to pay ${formattedAmount}`
}

console.log(getFine(130, 300))
  • A: The driver drove 130 and has to pay 300
  • B: The driver drove 130 mph and has to pay $300.00
  • C: The driver drove undefined and has to pay undefined
  • D: The driver drove 130.00 and has to pay 300.00
答案

答案: B

通过方法 Intl.NumberFormat,我们可以格式化任意区域的数字值。我们对数字值 130 进行 mile-per-hour 作为 uniten-US 区域 格式化,结果为 130 mph。对数字值 300 进行 USD 作为 currentcyen-US 区域格式化,结果为 $300.00.


127. 输出什么?
const spookyItems = ["👻", "🎃", "🕸"];
({ item: spookyItems[3] } = { item: "💀" });

console.log(spookyItems);
  • A: ["👻", "🎃", "🕸"]
  • B: ["👻", "🎃", "🕸", "💀"]
  • C: ["👻", "🎃", "🕸", { item: "💀" }]
  • D: ["👻", "🎃", "🕸", "[object Object]"]
答案

答案: B

通过解构对象们,我们可以从右手边的对象中拆出值,并且将拆出的值分配给左手边对象同名的属性。在这种情况下,我们将值 “💀” 分配给 spookyItems[3]。相当于我们正在篡改数组 spookyItems,我们给它添加了值 “💀”。当输出 spookyItems 时,结果为 ["👻", "🎃", "🕸", "💀"]


128. 输出什么?
const name = "Lydia Hallie";
const age = 21;

console.log(Number.isNaN(name));
console.log(Number.isNaN(age));

console.log(isNaN(name));
console.log(isNaN(age));
  • A: true false true false
  • B: true false false false
  • C: false false true false
  • D: false true false true
答案

答案: C

通过方法 Number.isNaN,你可以检测你传递的值是否为 数字值 并且是否等价于 NaNname 不是一个数字值,因此 Number.isNaN(name) 返回 falseage 是一个数字值,但它不等价于 NaN,因此 Number.isNaN(age) 返回 false.

通过方法 isNaN, 你可以检测你传递的值是否一个 number。name 不是一个 number,因此 isNaN(name) 返回 true. age 是一个 number 因此 isNaN(age) 返回 false.


129. 输出什么?
const randomValue = 21;

function getInfo() {
console.log(typeof randomValue);
const randomValue = "Lydia Hallie";
}

getInfo();
  • A: "number"
  • B: "string"
  • C: undefined
  • D: ReferenceError
答案

答案: D

通过 const 关键字声明的变量在被初始化之前不可被引用:这被称之为 _暂时性死区_。在函数 getInfo 中, 变量 randomValue 声明在getInfo 的作用域的此法环境中。在想要对 typeof randomValue 进行log之前,变量 randomValue 仍未被初始化: 错误ReferenceError 被抛出! JS引擎并不会根据作用域链网上寻找该变量,因为我们已经在 getInfo 函数中声明了 randomValue 变量。


130. 输出什么?
const myPromise = Promise.resolve("Woah some cool data");

(async () => {
try {
console.log(await myPromise);
} catch {
throw new Error(`Oops didn't work`);
} finally {
console.log("Oh finally!");
}
})();
  • A: Woah some cool data
  • B: Oh finally!
  • C: Woah some cool data Oh finally!
  • D: Oops didn't work Oh finally!
答案

答案: C

try 块区,我们打印 myPromise 变量的 awaited 值: "Woah some cool data"。因为try 块区没有错误抛出,catch 块区的代码并不执行。finally 块区的代码 总是 执行,"Oh finally!" 被输出。


131. 输出什么?
const emojis = ["🥑", ["✨", "✨", ["🍕", "🍕"]]];

console.log(emojis.flat(1));
  • A: ['🥑', ['✨', '✨', ['🍕', '🍕']]]
  • B: ['🥑', '✨', '✨', ['🍕', '🍕']]
  • C: ['🥑', ['✨', '✨', '🍕', '🍕']]
  • D: ['🥑', '✨', '✨', '🍕', '🍕']
答案

答案: B

通过方法 flat, 我们可以创建一个新的, 已被扁平化的数组。被扁平化的深度取决于我们传递的值。在这个case里,我们传递了值 1 (并不必要,这是默认值),相当于只有第一层的数组才会被连接。即这个 case 里的 ['🥑'] and ['✨', '✨', ['🍕', '🍕']]。连接这两个数组得到结果 ['🥑', '✨', '✨', ['🍕', '🍕']].


132. 输出什么?
class Counter {
constructor() {
this.count = 0;
}

increment() {
this.count++;
}
}

const counterOne = new Counter();
counterOne.increment();
counterOne.increment();

const counterTwo = counterOne;
counterTwo.increment();

console.log(counterOne.count);
  • A: 0
  • B: 1
  • C: 2
  • D: 3
答案

答案: D

counterOne 是类 Counter 的一个实例。类 Counter 包含一个count 属性在它的构造函数里, 和一个 increment 方法。首先,我们通过 counterOne.increment() 调用方法 increment 两次。现在, counterOne.count2.

然后,我们创建一个新的变量 counterTwo 并将 counterOne 的引用地址赋值给它。因为对象受引用地址的影响,我们刚刚创建了一个新的对象,其引用地址和 counterOne 的等价。因此它们指向同一块内存地址,任何对其的副作用都会影响 counterTwo。现在 counterTwo.count2

我们调用 counterTwo.increment()count 的值设为 3。然后,我们打印 counterOne 里的count,结果为 3


133. 输出什么?
const myPromise = Promise.resolve(Promise.resolve("Promise!"));

function funcOne() {
myPromise.then(res => res).then(res => console.log(res));
setTimeout(() => console.log("Timeout!", 0));
console.log("Last line!");
}

async function funcTwo() {
const res = await myPromise;
console.log(await res);
setTimeout(() => console.log("Timeout!", 0));
console.log("Last line!");
}

funcOne();
funcTwo();
  • A: Promise! Last line! Promise! Last line! Last line! Promise!
  • B: Last line! Timeout! Promise! Last line! Timeout! Promise!
  • C: Promise! Last line! Last line! Promise! Timeout! Timeout!
  • D: Last line! Promise! Promise! Last line! Timeout! Timeout!
答案

答案: D

首先,我们调用 funcOne。在函数 funcOne 的第一行,我们调用myPromise promise 异步操作_。当JS引擎在忙于执行 promise,它继续执行函数 funcOne。下一行 _异步操作 setTimeout,其回调函数被 Web API 调用。 (详情请参考我关于event loop的文章.)

promise 和 timeout 都是异步操作,函数继续执行当JS引擎忙于执行promise 和 处理 setTimeout 的回调。相当于 Last line! 首先被输出, 因为它不是异步操作。执行完 funcOne 的最后一行,promise 状态转变为 resolved,Promise! 被打印。然而,因为我们调用了 funcTwo(), 调用栈不为空,setTimeout 的回调仍不能入栈。

我们现在处于 funcTwo,先 awaiting myPromise。通过 await 关键字, 我们暂停了函数的执行直到 promise 状态变为 resolved (或 rejected)。然后,我们输出 res 的 awaited 值(因为 promise 本身返回一个 promise)。 接着输出 Promise!

下一行就是 异步操作 setTimeout,其回调函数被 Web API 调用。

我们执行到函数 funcTwo 的最后一行,输出 Last line!。现在,因为 funcTwo 出栈,调用栈为空。在事件队列中等待的回调函数(() => console.log("Timeout!") from funcOne, and () => console.log("Timeout!") from funcTwo)以此入栈。第一个回调输出 Timeout!,并出栈。然后,第二个回调输出 Timeout!,并出栈。得到结果 Last line! Promise! Promise! Last line! Timeout! Timeout!


134. 我们怎样才能在 index.js 中调用 sum.js? 中的 sum
// sum.js
export default function sum(x) {
return x + x;
}

// index.js
import * as sum from "./sum";
  • A: sum(4)
  • B: sum.sum(4)
  • C: sum.default(4)
  • D: 默认导出不用 * 来导入,只能具名导出
答案

答案: C

使用符号 *,我们引入文件中的所有值,包括默认和具名。如果我们有以下文件:

// info.js
export const name = "Lydia";
export const age = 21;
export default "I love JavaScript";

// index.js
import * as info from "./info";
console.log(info);

将会输出以下内容:

{
default: "I love JavaScript",
name: "Lydia",
age: 21
}

sum 为例,相当于以下形式引入值 sum

{ default: function sum(x) { return x + x } }

我们可以通过调用 sum.default 来调用该函数


135. 输出什么?
const handler = {
set: () => console.log("Added a new property!"),
get: () => console.log("Accessed a property!")
};

const person = new Proxy({}, handler);

person.name = "Lydia";
person.name;
  • A: Added a new property!
  • B: Accessed a property!
  • C: Added a new property! Accessed a property!
  • D: 没有任何输出
答案

答案: C

使用 Proxy 对象,我们可以给一个对象添加自定义行为。在这个 case,我们传递一个包含以下属性的对象 handler : set and get。每当我门 设置 属性值时 set 被调用,每当我们 获取get 被调用。

第一个参数是一个空对象 {},作为 person 的值。对于这个对象,自定义行为被定义在对象 handler。如果我们向对象 person 添加属性,set 将被调用。如果我们获取 person 的属性, get 将被调用。

首先,我们向 proxy 对象(person.name = "Lydia")添加一个属性 nameset 被调用并输出 "Added a new property!"

然后,我们获取 proxy 对象的一个属性,对象 handler 的属性 get 被调用。输出 "Accessed a property!"


136. 以下哪一项会对对象 person 有副作用?
const person = { name: "Lydia Hallie" };

Object.seal(person);
  • A: person.name = "Evan Bacon"
  • B: person.age = 21
  • C: delete person.name
  • D: Object.assign(person, { age: 21 })
答案

答案: A

使用 Object.seal 我们可以防止新属性 被添加_,或者存在属性 _被移除.

然而,你仍然可以对存在属性进行更改。


137. 以下哪一项会对对象 person 有副作用?
const person = {
name: "Lydia Hallie",
address: {
street: "100 Main St"
}
};

Object.freeze(person);
  • A: person.name = "Evan Bacon"
  • B: delete person.address
  • C: person.address.street = "101 Main St"
  • D: person.pet = { name: "Mara" }
答案

答案: C

使用方法 Object.freeze 对一个对象进行 _冻结_。不能对属性进行添加,修改,删除。

然而,它仅 对对象进行 冻结,意味着只有 对象中的 直接 属性被冻结。如果属性是另一个 object,像案例中的 addressaddress 中的属性没有被冻结,仍然可以被修改。


138. 输出什么?
const add = x => x + x;

function myFunc(num = 2, value = add(num)) {
console.log(num, value);
}

myFunc();
myFunc(3);
  • A: 2 4 and 3 6
  • B: 2 NaN and 3 NaN
  • C: 2 Error and 3 6
  • D: 2 4 and 3 Error
答案

答案: A

首先我们不传递任何参数调用 myFunc()。因为我们没有传递参数,numvalue 获取它们各自的默认值:num 为 2, 而 value 为函数 add 的返回值。对于函数 add,我们传递值为2的 num 作为参数。函数 add 返回 4 作为 value 的值。

然后,我们调用 myFunc(3) 并传递值 3 参数 num 的值。我们没有给 value 传递值。因为我们没有给参数 value 传递值,它获取默认值:函数 add 的返回值。对于函数 add,我们传递值为3的 num给它。函数 add 返回 6 作为 value 的值。


139. 输出什么?
class Counter {
#number = 10

increment() {
this.#number++
}

getNum() {
return this.#number
}
}

const counter = new Counter()
counter.increment()

console.log(counter.#number)
  • A: 10
  • B: 11
  • C: undefined
  • D: SyntaxError
答案

答案: D

在 ES2020 中,通过 # 我们可以给 class 添加私有变量。在 class 的外部我们无法获取该值。当我们尝试输出 counter.#number,语法错误被抛出:我们无法在 class Counter 外部获取它!


140. 选择哪一个?
const teams = [
{ name: "Team 1", members: ["Paul", "Lisa"] },
{ name: "Team 2", members: ["Laura", "Tim"] }
];

function* getMembers(members) {
for (let i = 0; i < members.length; i++) {
yield members[i];
}
}

function* getTeams(teams) {
for (let i = 0; i < teams.length; i++) {
// ✨ SOMETHING IS MISSING HERE ✨
}
}

const obj = getTeams(teams);
obj.next(); // { value: "Paul", done: false }
obj.next(); // { value: "Lisa", done: false }
  • A: yield getMembers(teams[i].members)
  • B: yield* getMembers(teams[i].members)
  • C: return getMembers(teams[i].members)
  • D: return yield getMembers(teams[i].members)
答案

答案: B

为了遍历 teams 数组中对象的属性 members 中的每一项,我们需要将 teams[i].members 传递给 Generator 函数 getMembers。Generator 函数返回一个 generator 对象。为了遍历这个 generator 对象中的每一项,我们需要使用 yield*.

如果我们没有写 yieldreturn yield 或者 return,整个 Generator 函数不会第一时间 return 当我们调用 next 方法.


141. 输出什么?
const person = {
name: "Lydia Hallie",
hobbies: ["coding"]
};

function addHobby(hobby, hobbies = person.hobbies) {
hobbies.push(hobby);
return hobbies;
}

addHobby("running", []);
addHobby("dancing");
addHobby("baking", person.hobbies);

console.log(person.hobbies);
  • A: ["coding"]
  • B: ["coding", "dancing"]
  • C: ["coding", "dancing", "baking"]
  • D: ["coding", "running", "dancing", "baking"]
答案

答案: C

函数 addHobby 接受两个参数,hobby 和有着对象 person 中数组 hobbies 默认值的 hobbies

首相,我们调用函数 addHobby,并给 hobby 传递 "running" 以及给 hobbies 传递一个空数组。因为我们给 hobbies 传递了空数组,"running" 被添加到这个空数组。

然后,我们调用函数 addHobby,并给 hobby 传递 "dancing"。我们不向 hobbies 传递值,因此它获取其默认值 —— 对象 person 的 属性 hobbies。我们向数组 person.hobbies push dancing

最后,我们调用函数 addHobby,并向 hobby 传递 值 "bdaking",并且向 hobbies 传递 person.hobbies。我们向数组 person.hobbies push dancing

pushing dancingbaking 之后,person.hobbies 的值为 ["coding", "dancing", "baking"]


142. 输出什么?
class Bird {
constructor() {
console.log("I'm a bird. 🦢");
}
}

class Flamingo extends Bird {
constructor() {
console.log("I'm pink. 🌸");
super();
}
}

const pet = new Flamingo();
  • A: I'm pink. 🌸
  • B: I'm pink. 🌸 I'm a bird. 🦢
  • C: I'm a bird. 🦢 I'm pink. 🌸
  • D: Nothing, we didn’t call any method
答案

答案: B

我们创建了类 Flamingo 的实例 pet。当我们实例化这个实例,Flamingo 中的 constructor 被调用。首相,输出 "I'm pink. 🌸", 之后我们调用super()super() 调用父类的构造函数,BirdBird 的构造函数被调用,并输出 "I'm a bird. 🦢"


143. 哪一个选项会导致报错?
const emojis = ["🎄", "🎅🏼", "🎁", "⭐"];

/* 1 */ emojis.push("🦌");
/* 2 */ emojis.splice(0, 2);
/* 3 */ emojis = [...emojis, "🥂"];
/* 4 */ emojis.length = 0;
  • A: 1
  • B: 1 and 2
  • C: 3 and 4
  • D: 3
答案

答案: D

const 关键字意味着我们不能 重定义 变量中的值,它 _仅可读_。而然,值本身不可修改。数组 emojis 中的值可被修改,如 push 新的值, 拼接,又或者将数组的长度设置为0。


144. 我们需要向对象 person 添加什么,以致执行 [...person] 时获得形如 ["Lydia Hallie", 21] 的输出?
const person = {
name: "Lydia Hallie",
age: 21
}

[...person] // ["Lydia Hallie", 21]
  • A: 不需要,对象默认就是可迭代的
  • B: *[Symbol.iterator]() { for (let x in this) yield* this[x] }
  • C: *[Symbol.iterator]() { for (let x in this) yield* Object.values(this) }
  • D: *[Symbol.iterator]() { for (let x in this) yield this }
答案

答案: C

对象默认并不是可迭代的。如果迭代规则被定义,则一个对象是可迭代的(An iterable is an iterable if the iterator protocol is present)。我们可以通过添加迭代器symbol [Symbol.iterator] 来定义迭代规则,其返回一个 generator 对象,比如说构建一个 generator 函数 *[Symbol.iterator]() {}。如果我们想要返回数组 ["Lydia Hallie", 21]: yield* Object.values(this),这个 generator 函数一定要 yield 对象 personObject.values


145. 输出什么?
let count = 0;
const nums = [0, 1, 2, 3];

nums.forEach(num => {
if (num) count += 1
})

console.log(count)
  • A: 1
  • B: 2
  • C: 3
  • D: 4
    答案

答案: C

forEach 循环内部的 if 会判断 num 的值是truthy或者是falsy。因为 nums 数组的第一个数字是 0,一个falsy值, if 语句代码块不会被执行。count 仅仅在 nums 数组的其他3个数字 123 时加1。因为 count 执行了3次加 1 运算,所以 count 的值为 3


146. 输出是什么?
function getFruit(fruits) {
console.log(fruits?.[1]?.[1])
}

getFruit([['🍊', '🍌'], ['🍍']])
getFruit()
getFruit([['🍍'], ['🍊', '🍌']])
  • A: null, undefined, 🍌
  • B: [], null, 🍌
  • C: [], [], 🍌
  • D: undefined, undefined, 🍌
答案

答案: D

? 允许我们去选择性地访问对象内部更深层的嵌套属性。 我们尝试打印 fruits 数组索引值为 1 的子数组内部的索引值为 1 的元素。 如果在 fruits 数组索引值 为 1 的位置不存在元素,会直接返回 undefined。 如果 fruits 数组在索引值为 1 的位置存在元素,但是子数组在索引值为 1 的位置不存在元素,也会返回 undefined

首先,我们尝试打印 [['🍊', '🍌'], ['🍍']] 的子数组 ['🍍'] 的第2个元素。这个子数组只包含一个元素,也就意味着在索引值为 1 的位置不存在元素,所以返回的是 undefined

其次,我们在没有传入任何参数调用了 getFruits 函数,也就意味着形参 fruits 的默认值为undefined。因为我们选择性地链接了 fruits 在索引值为 1 的元素,因为在索引值为 1 的位置不存在元素,因此返回的是 undefined

最后,我们尝试打印 ['🍍'], ['🍊', '🍌'] 的子数组 ['🍊', '🍌'] 的第2个元素。子数组索引值为 1的位置为 🍌 ,因此它被打印出了。


147. 输出什么?
class Calc {
constructor() {
this.count = 0
}

increase() {
this.count ++
}
}

const calc = new Calc()
new Calc().increase()

console.log(calc.count)
  • A: 0
  • B: 1
  • C: undefined
  • D: ReferenceError
答案

答案: A

我们设置 calc 变量为 Calc 类的一个新实例。 然后,我们初始化一个 Calc 的新实例,而且调用了这个实例的 increase 方法。因为count属性是在 Calc class的constructor内部的,所以count属性不会在 Calc 的原型链上共享出去。这就意味着calc实例的count值不会被更新,count仍然是 0


148. 输出什么?
const user = {
email: "e@mail.com",
password: "12345"
}

const updateUser = ({ email, password }) => {
if (email) {
Object.assign(user, { email })
}

if (password) {
user.password = password
}

return user
}

const updatedUser = updateUser({ email: "new@email.com" })

console.log(updatedUser === user)
  • A: false
  • B: true
  • C: TypeError
  • D: ReferenceError
答案

答案: B

updateUser 函数更新user的 emailpassword 属性的值, 如果它们的值传入函数, 函数返回的就是 user 对象。 updateUser 函数的返回值是 user 对象,意味着updatedUser的值与 user 指向的是同一个 user 对象。updatedUser === usertrue.


149. 输出什么?
const fruit = ['🍌', '🍊', '🍎']

fruit.slice(0, 1)
fruit.splice(0, 1)
fruit.unshift('🍇')

console.log(fruit)
  • A: ['🍌', '🍊', '🍎']
  • B: ['🍊', '🍎']
  • C: ['🍇', '🍊', '🍎']
  • D: ['🍇', '🍌', '🍊', '🍎']
答案

答案: C

首先,我们在fruit数组上调用 slice 方法。 slice方法不会修改原始数组,但是会返回从数组切片下来的值:香蕉emoji。
其次,我们在fruit数组上调用 splice 方法。 splice方法会修改原始数组,也就意味着fruit数组此时为 ['🍊', '🍎']
最后,我们在fruit数组上调用 unshift 方法,通过添加一个值的方式改变了原始数组,添加的是’🍇’,它成为了数组的第一个元素。现在fruit数组的组成为 ['🍇', '🍊', '🍎']


150. 输出什么?
const animals = {};
let dog = { emoji: '🐶' }
let cat = { emoji: '🐈' }

animals[dog] = { ...dog, name: "Mara" }
animals[cat] = { ...cat, name: "Sara" }

console.log(animals[dog])
  • A: { emoji: "🐶", name: "Mara" }
  • B: { emoji: "🐈", name: "Sara" }
  • C: undefined
  • D: ReferenceError
答案

答案: B

对象的键会被转换为字符串。

因为 dog 的值是一个对象, animals[dog] 实际上意味着我们创建了一个叫做 "object Object" 的属性来代表新的对象。 animals["object Object"] 现在等于 { emoji: "🐶", name: "Mara"}

cat 也是一个对象,animals[cat] 实际上意味着我们在用新的cat的属性覆盖 animals[``"``object Object``"``] 的值。

打印 animals[dog],实际上是animals["object Object"],这是因为转化dog对象为一个字符串结果 "object Object" ,所以返回 { emoji: "🐈", name: "Sara" }


151. 输出什么?
const user = {
email: "my@email.com",
updateEmail: email => {
this.email = email
}
}

user.updateEmail("new@email.com")
console.log(user.email)
  • A: my@email.com
  • B: new@email.com
  • C: undefined
  • D: ReferenceError
答案

答案: A

updateEmail 函数是一个箭头函数,它没有和 user 对象绑定。这就意味着 this 关键字不会引用到 user 对象,但是会引用到全局对象。 user 对象内部的 email 的值不会更新。当打印 user.email 的时候, 原始值 my@email.com 被返回。


152. 输出什么?
const promise1 = Promise.resolve('First')
const promise2 = Promise.resolve('Second')
const promise3 = Promise.reject('Third')
const promise4 = Promise.resolve('Fourth')

const runPromises = async () => {
const res1 = await Promise.all([promise1, promise2])
const res2 = await Promise.all([promise3, promise4])
return [res1, res2]
}

runPromises()
.then(res => console.log(res))
.catch(err => console.log(err))
  • A: [['First', 'Second'], ['Fourth']]
  • B: [['First', 'Second'], ['Third', 'Fourth']]
  • C: [['First', 'Second']]
  • D: 'Third'
答案

答案: D

Promise.all 方法可以并行式运行promise。如果其中一个promise失败了,Promise.all 方法会带上被reject的promise的值_rejects_。在这个例子中, promise3 带着 "Third" 值reject。我们在调用 runPromises 时在 runPromises 函数内部的 catch 方法去捕获任意error从而捕获到被reject的值。因为 promise3 带着 "Third" 被reject,所以只有 "Third" 打印。


153. 哪个作为method的值可以打印{ name: "Lydia", age: 22 }?
const keys = ["name", "age"]
const values = ["Lydia", 22]

const method = /* ?? */
Object[method](keys.map((_, i) => {
return [keys[i], values[i]]
})) // { name: "Lydia", age: 22 }
  • A: entries
  • B: values
  • C: fromEntries
  • D: forEach
答案

答案: C

fromEntries 方法可以将二维数组转换为对象。在每个子数组的第一个元素是key,在每个子数组的第二个元素是value。在这个例子中,我们映射了 keys 数组,它返回了一个数组,数组的第一个元素为keys数组当前索引的值,第二个元素为values数组当前索引的值。

这样就创建了一个包含正确keys和values的子数组的数组,因此结果为{ name: "Lydia", age: 22 }


154. 输出什么?
const createMember = ({ email, address = {}}) => {
const validEmail = /.+\@.+\..+/.test(email)
if (!validEmail) throw new Error("Valid email pls")

return {
email,
address: address ? address : null
}
}

const member = createMember({ email: "my@email.com" })
console.log(member)
  • A: { email: "my@email.com", address: null }
  • B: { email: "my@email.com" }
  • C: { email: "my@email.com", address: {} }
  • D: { email: "my@email.com", address: undefined }
答案

答案: C

address 的默认值是一个空对象 {}。当我们设置 member 变量为 createMember 函数返回的对象,我们没有为address参数传值,意味着address的值为默认的空对象 {}。一个空对象是一个truthy值,意味着 address ? address : null 条件会返回 true。address的值为空对象 {}


155. 输出什么?
let randomValue = { name: "Lydia" }
randomValue = 23

if (!typeof randomValue === "string") {
console.log("It's not a string!")
} else {
console.log("Yay it's a string!")
}
  • A: It's not a string!
  • B: Yay it's a string!
  • C: TypeError
  • D: undefined
答案

答案: B

if 语句的条件判断 !typeof randomValue 的值是否等于 "string"! 操作符将这个值转化为一个布尔值。如果值是truthy的话,返回值会是 false,如果值是falsy,返回值会是 true。在这里, typeof randomValue 的返回值是一个truthy值 "number",意味着 !typeof randomValue 的值是一个布尔值 false

!typeof randomValue === "string" 总是返回false,因为我们实际上是在执行 false === "string"。因为条件返回的是 false,所以 else 语句中的代码块会被运行,因此打印 Yay it's a string!