「星辰大海」JS自测清单(二)
星辰大海」JS自测清单(二)
转载自 javascript-questions(star支持一波)
我们的征途是星辰大海~
答案在问题下方的折叠部分,点击即可展开问题。祝你好运 :heart:
56. 输出是什么?
const set = new Set([1, 1, 2, 3, 4]); |
- 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 |
// index.js |
- A:
10
- B:
11
- C:
Error
- D:
NaN
58. 输出是什么?
const name = "Lydia"; |
- 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]; |
- 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 }; |
- 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" }; |
- 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 = { |
- 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; |
- A:
10
,10
- B:
10
,11
- C:
11
,11
- D:
11
,12
答案
答案: A
一元操作符 ++
先返回 操作值, 再累加 操作值。num1
的值是10
, 因为increaseNumber
函数首先返回num
的值,也就是10
,随后再进行 num
的累加。
num2
是10
因为我们将 num1
传入increasePassedNumber
. number
等于10
(num1
的值。同样道理,++
先返回 操作值, 再累加 操作值。) number
是10
,所以num2
也是10
.
64. 输出什么?
const value = { number: 10 }; |
- A:
20
,40
,80
,160
- B:
20
,40
,20
,40
- C:
20
,20
,20
,40
- D:
NaN
,NaN
,20
,40
答案
答案: C
在ES6中,我们可以使用默认值初始化参数。如果没有给函数传参,或者传的参值为 "undefined"
,那么参数的值将是默认值。上述例子中,我们将 value
对象进行了解构并传到一个新对象中,因此 x
的默认值为 {number:10}
。
默认参数在调用时才会进行计算,每次调用函数时,都会创建一个新的对象。我们前两次调用 multiply
函数且不传递值,那么每一次 x
的默认值都为 {number:10}
,因此打印出该数字的乘积值为20
。
第三次调用 multiply
时,我们传递了一个参数,即对象value
。 *=
运算符实际上是x.number = x.number * 2
的简写,我们修改了x.number
的值,并打印出值20
。
第四次,我们再次传递value
对象。 x.number
之前被修改为20
,所以x.number * = 2
打印为40
。
65. 输出什么?
[1, 2, 3, 4].reduce((x, y) => console.log(x, y)); |
- A:
1
2
and3
3
and6
4
- B:
1
2
and2
3
and3
4
- C:
1
undefined
and2
undefined
and3
undefined
and4
undefined
- D:
1
2
andundefined
3
andundefined
4
答案
答案: D
reducer
函数接收4个参数:
- Accumulator (acc) (累计器)
- Current Value (cur) (当前值)
- Current Index (idx) (当前索引)
- Source Array (src) (源数组)
reducer
函数的返回值将会分配给累计器,该返回值在数组的每个迭代中被记住,并最后成为最终的单个结果值。
reducer
函数还有一个可选参数initialValue
, 该参数将作为第一次调用回调函数时的第一个参数的值。如果没有提供initialValue
,则将使用数组中的第一个元素。
在上述例子,reduce
方法接收的第一个参数(Accumulator)是x
, 第二个参数(Current Value)是y
。
在第一次调用时,累加器x
为1
,当前值“y”
为2
,打印出累加器和当前值:1
和2
。
例子中我们的回调函数没有返回任何值,只是打印累加器的值和当前值。如果函数没有返回值,则默认返回undefined
。 在下一次调用时,累加器为undefined
,当前值为“3”, 因此undefined
和3
被打印出。
在第四次调用时,回调函数依然没有返回值。 累加器再次为 undefined
,当前值为“4”。 undefined
和4
被打印出。
66. 使用哪个构造函数可以成功继承Dog
类?
class Dog { |
- A: 1
- B: 2
- C: 3
- D: 4
答案
答案: B
在子类中,在调用super
之前不能访问到this
关键字。 如果这样做,它将抛出一个ReferenceError
:1和4将引发一个引用错误。
使用super
关键字,需要用给定的参数来调用父类的构造函数。 父类的构造函数接收name
参数,因此我们需要将name
传递给super
。
Labrador
类接收两个参数,name
参数是由于它继承了Dog
,size
作为Labrador
类的额外属性,它们都需要传递给Labrador
的构造函数,因此使用构造函数2正确完成。
67. 输出什么?
// index.js |
- 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
命令是编译阶段执行的,在代码运行之前。因此这意味着被导入的模块会先运行,而导入模块的文件会后执行。
这是CommonJS中require()
和import
之间的区别。使用require()
,您可以在运行代码时根据需要加载依赖项。 如果我们使用require
而不是import
,running index.js
,running sum.js
,3
会被依次打印。
68. 输出什么?
console.log(Number(2) === Number(2)) |
- A:
true
,true
,false
- B:
false
,true
,false
- C:
true
,false
,true
- D:
true
,true
,true
答案
答案: A
每个Symbol
都是完全唯一的。传递给Symbol
的参数只是给Symbol
的一个描述。 Symbol
的值不依赖于传递的参数。 当我们测试相等时,我们创建了两个全新的符号:第一个Symbol('foo')
,第二个Symbol('foo')
, 这两个值是唯一的,彼此不相等,因此返回false
。
69. 输出什么?
const name = "Lydia Hallie" |
- 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
方法,我们可以在字符串的开头添加填充。传递给此方法的参数是字符串的总长度(包含填充)。字符串Lydia Hallie
的长度为12
, 因此name.padStart(13)
在字符串的开头只会插入1(13 - 12 = 1
)个空格。
如果传递给padStart
方法的参数小于字符串的长度,则不会添加填充。
70. 输出什么?
console.log("🥑" + "💻"); |
- A:
"🥑💻"
- B:
257548
- C: A string containing their code points
- D: Error
71. 如何能打印出console.log
语句后注释掉的值?
function* startGame() { |
- A:
game.next("Yes").value
andgame.next().value
- B:
game.next.value("Yes")
andgame.next.value()
- C:
game.next().value
andgame.next("Yes").value
- D:
game.next.value()
andgame.next.value("Yes")
答案
答案: C
generator
函数在遇到yield
关键字时会“暂停”其执行。 首先,我们需要让函数产生字符串Do you love JavaScript?
,这可以通过调用game.next().value
来完成。上述函数的第一行就有一个yield
关键字,那么运行立即停止了,yield
表达式本身没有返回值,或者说总是返回undefined
, 这意味着此时变量 答案
为undefined
next
方法可以带一个参数,该参数会被当作上一个 yield
表达式的返回值。当我们调用game.next("Yes").value
时,先前的 yield
的返回值将被替换为传递给next()
函数的参数"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
函数是用来获取一个模板字符串的原始字符串的,它返回一个字符串,其中忽略了转义符(\n
,\v
,\t
等)。但反斜杠可能造成问题,因为你可能会遇到下面这种类似情况:
const path = `C:\Documents\Projects\table.html` |
这将导致:
"C:DocumentsProjects able.html"
直接使用String.raw
String.raw`C:\Documents\Projects\table.html` |
它会忽略转义字符并打印:C:\Documents\Projects\table.html
上述情况,字符串是Hello\nworld
被打印出。
73. 输出什么?
async function getData() { |
- A:
"I made it!"
- B:
Promise {<resolved>: "I made it!"}
- C:
Promise {<pending>}
- D:
undefined
答案
答案: C
异步函数始终返回一个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) { |
- A:
['apple', 'banana']
- B:
2
- C:
true
- D:
undefined
答案
答案: B
push()
方法返回新数组的长度。一开始,数组包含一个元素(字符串"banana"
),长度为1。 在数组中添加字符串"apple"
后,长度变为2,并将从addToList
函数返回。
push
方法修改原始数组,如果你想从函数返回数组而不是数组长度,那么应该在push item
之后返回list
。
75. 输出什么?
const box = { x: 10, y: 20 }; |
- A:
{ x: 100, y: 20 }
- B:
{ x: 10, y: 20 }
- C:
{ x: 100 }
- D:
ReferenceError
答案
答案: B
Object.freeze
使得无法添加、删除或修改对象的属性(除非属性的值是另一个对象)。
当我们创建变量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" }; |
- A:
"Lydia"
- B:
"myName"
- C:
undefined
- D:
ReferenceError
答案
答案: D
当我们从右侧的对象解构属性name
时,我们将其值Lydia
分配给名为myName
的变量。
使用{name:myName}
,我们是在告诉JavaScript我们要创建一个名为myName
的新变量,并且其值是右侧对象的name
属性的值。
当我们尝试打印name
,一个未定义的变量时,就会引发ReferenceError
。
77. 以下是个纯函数么?
function sum(a, b) { |
- A: Yes
- B: No
答案
答案: B
纯函数一种若输入参数相同,则永远会得到相同输出的函数。
在特定情况下,即使输入相同参数,也不能得到相同的返回值:
var a = b = {} a[Symbol.toPrimitive] = b[Symbol.toPrimitive] = () => Math.random() sum(a, b) // Uncertain
所以它不是一个纯函数。
78. 输出什么?
const add = () => { |
- 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
函数是一个记忆函数。 通过记忆化,我们可以缓存函数的结果,以加快其执行速度。上述情况,我们创建一个cache
对象,用于存储先前返回过的值。
如果我们使用相同的参数多次调用addFunction
函数,它首先检查缓存中是否已有该值,如果有,则返回缓存值,这将节省执行时间。如果没有,那么它将计算该值,并存储在缓存中。
我们用相同的值三次调用了addFunction
函数:
在第一次调用,num
等于10
时函数的值尚未缓存,if语句num in cache
返回false
,else块的代码被执行:Calculated! 20
,并且其结果被添加到缓存对象,cache
现在看起来像{10:20}
。
第二次,cache
对象包含10
的返回值。 if语句 num in cache
返回true
,From cache! 20
被打印。
第三次,我们将5 * 2
(值为10)传递给函数。 cache
对象包含10
的返回值。 if语句 num in cache
返回true
,From cache! 20
被打印。
79. 输出什么?
const myLifeSummedUp = ["☕", "💻", "🍷", "🍫"] |
- A:
0
1
2
3
and"☕"
"💻"
"🍷"
"🍫"
- B:
"☕"
"💻"
"🍷"
"🍫"
and"☕"
"💻"
"🍷"
"🍫"
- C:
"☕"
"💻"
"🍷"
"🍫"
and0
1
2
3
- D:
0
1
2
3
and{0: "☕", 1: "💻", 2: "🍷", 3: "🍫"}
答案
答案: A
通过for-in
循环,我们可以遍历一个对象自有的、继承的、可枚举的、非Symbol的属性。 在数组中,可枚举属性是数组元素的“键”, 即它们的索引。 类似于下面这个对象:
{0: "☕", 1: "💻", 2: "🍷", 3: "🍫"}
其中键则是可枚举属性,因此 0
,1
,2
,3
被记录。
通过for-of
循环,我们可以迭代可迭代对象(包括 Array
,Map
,Set
,String
,arguments
等)。当我们迭代数组时,在每次迭代中,不同属性的值将被分配给变量item
, 因此“☕”
,“💻”
,“🍷”
,“🍫”
被打印。
80. 输出什么?
const list = [1 + 2, 1 * 2, 1 / 2] |
- A:
["1 + 2", "1 * 2", "1 / 2"]
- B:
["12", 2, 0.5]
- C:
[3, 2, 0.5]
- D:
[1, 1, 1]
答案
答案: C
数组元素可以包含任何值。 数字,字符串,布尔值,对象,数组,null
,undeifned
, 以及其他表达式,如日期,函数和计算。
元素将等于返回的值。 1 + 2
返回3
,1 * 2
返回’2,'1 / 2
返回0.5
。
81. 输出什么?
function sayHi(name) { |
- A:
Hi there,
- B:
Hi there, undefined
- C:
Hi there, null
- D:
ReferenceError
答案
答案: B
默认情况下,如果不给函数传参,参数的值将为undefined
。 上述情况,我们没有给参数name
传值。 name
等于undefined
,并被打印。
在ES6中,我们可以使用默认参数覆盖此默认的undefined
值。 例如:
function sayHi(name =“Lydia”){...}
在这种情况下,如果我们没有传递值或者如果我们传递undefined
,name
总是等于字符串Lydia
82. 输出什么?
var status = "😎" |
- A:
"🥑"
and"😍"
- B:
"🥑"
and"😎"
- C:
"😍"
and"😎"
- D:
"😎"
and"😎"
答案
答案: B
this
关键字的指向取决于使用它的位置。 在函数中,比如getStatus
,this
指向的是调用它的对象,上述例子中data
对象调用了getStatus
,因此this
指向的就是data
对象。 当我们打印this.status
时,data
对象的status
属性被打印,即"🥑"
。
使用call
方法,可以更改this
指向的对象。data.getStatus.call(this)
是将this
的指向由data
对象更改为全局对象。在全局对象上,有一个名为status
的变量,其值为”😎“
。 因此打印this.status
时,会打印“😎”
。
83. 输出什么?
const 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) { |
- 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') |
- A:
fetch
方法的结果 - B: 第二次调用
fetch
方法的结果 - C: 前一个
.then()
中回调方法返回的结果 - D: 总是
undefined
86. 哪个选项是将hasName
设置为true
的方法,前提是不能将true
作为参数传递?
function getName(name) { |
- A:
!!name
- B:
name
- C:
new Boolean(name)
- D:
name.length
答案
答案: A
使用逻辑非运算符!
,将返回一个布尔值,使用!! name
,我们可以确定name
的值是真的还是假的。 如果name
是真实的,那么!name
返回false
。 !false
返回true
。
通过将hasName
设置为name
,可以将hasName
设置为等于传递给getName
函数的值,而不是布尔值true
。
new Boolean(true)
返回一个对象包装器,而不是布尔值本身。
name.length
返回传递的参数的长度,而不是布尔值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) { |
- A:
NaN
- B:
20
- C:
ReferenceError
- D:
undefined
答案
答案: B
您可以将默认参数的值设置为函数的另一个参数,只要另一个参数定义在其之前即可。 我们将值10
传递给sum
函数。 如果sum
函数只接收1个参数,则意味着没有传递num2
的值,这种情况下,num1
的值等于传递的值10
。 num2
的默认值是num1
的值,即10
。 num1 + num2
返回20
。
如果您尝试将默认参数的值设置为后面定义的参数,则可能导致参数的值尚未初始化,从而引发错误。比如:
function test(m = n, n = 2) { |
89. 输出什么?
// module.js |
- 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
文件中,并且创建了一个名为data
的新对象。 在module.js
文件中,有两个导出:默认导出和命名导出。 默认导出是一个返回字符串“Hello World”的函数,命名导出是一个名为name
的变量,其值为字符串“Lydia”
。
data
对象具有默认导出的default
属性,其他属性具有指定exports的名称及其对应的值。
90. 输出什么?
class Person { |
- A:
"class"
- B:
"function"
- C:
"object"
- D:
"string"
答案
答案: C
类是构造函数的语法糖,如果用构造函数的方式来重写Person
类则将是:
function Person() { |
通过new
来调用构造函数,将会生成构造函数Person
的实例,对实例执行typeof
关键字将返回"object"
,上述情况打印出"object"
。
91. 输出什么?
let newList = [1, 2, 3].push(4) |
- A:
[1, 2, 3, 4, 5]
- B:
[1, 2, 3, 5]
- C:
[1, 2, 3, 4]
- D:
Error
答案
答案: D
.push
方法返回数组的长度,而不是数组本身! 通过将newList
设置为[1,2,3].push(4)
,实际上newList
等于数组的新长度:4
。
然后,尝试在newList
上使用.push
方法。 由于newList
是数值4
,抛出TypeError。
92. 输出什么?
function giveLydiaPizza() { |
- A:
{ constructor: ...}
{ constructor: ...}
- B:
{}
{ constructor: ...}
- C:
{ constructor: ...}
{}
- D:
{ constructor: ...}
undefined
答案
答案: D
常规函数,例如giveLydiaPizza
函数,有一个prototype
属性,它是一个带有constructor
属性的对象(原型对象)。 然而,箭头函数,例如giveLydiaChocolate
函数,没有这个prototype
属性。 尝试使用giveLydiaChocolate.prototype
访问prototype
属性时会返回undefined
。
93. 输出什么?
const person = { |
- A:
name
Lydia
andage
21
- B:
["name", "Lydia"]
and["age", 21]
- C:
["name", "age"]
andundefined
- D:
Error
答案
答案: A
Object.entries()
方法返回一个给定对象自身可枚举属性的键值对数组,上述情况返回一个二维数组,数组每个元素是一个包含键和值的数组:
[['name','Lydia'],['age',21]]
使用for-of
循环,我们可以迭代数组中的每个元素,上述情况是子数组。 我们可以使用const [x,y]
在for-of
循环中解构子数组。 x
等于子数组中的第一个元素,y
等于子数组中的第二个元素。
第一个子阵列是[“name”,“Lydia”]
,其中x
等于name
,而y
等于Lydia
。
第二个子阵列是[“age”,21]
,其中x
等于age
,而y
等于21
。
94. 输出什么?
function getItems(fruitList, ...args, favoriteFruit) { |
- A:
["banana", "apple", "pear", "orange"]
- B:
[["banana", "apple"], "pear", "orange"]
- C:
["banana", "apple", ["pear"], "orange"]
- D:
SyntaxError
答案
答案: D
... args
是剩余参数,剩余参数的值是一个包含所有剩余参数的数组,并且只能作为最后一个参数。上述示例中,剩余参数是第二个参数,这是不可能的,并会抛出语法错误。
function getItems(fruitList, favoriteFruit, ...args) { |
上述例子是有效的,将会返回数组:[ 'banana', 'apple', 'orange', 'pear' ]
95. 输出什么?
function nums(a, b) { |
- A:
a is bigger
,6
andb is bigger
,3
- B:
a is bigger
,undefined
andb is bigger
,undefined
- C:
undefined
andundefined
- D:
SyntaxError
答案
答案: B
在JavaScript中,我们不必显式地编写分号(;
),但是JavaScript引擎仍然在语句之后自动添加分号。这称为自动分号插入。例如,一个语句可以是变量,或者像throw
、return
、break
这样的关键字。
在这里,我们在新的一行上写了一个return
语句和另一个值a + b
。然而,由于它是一个新行,引擎并不知道它实际上是我们想要返回的值。相反,它会在return
后面自动添加分号。你可以这样看:
return; |
这意味着永远不会到达a + b
,因为函数在return
关键字之后停止运行。如果没有返回值,就像这里,函数返回undefined
。注意,在if/else
语句之后没有自动插入!
96. 输出什么?
class Person { |
- A:
"Lydia"
- B:
"Sarah"
- C:
Error: cannot redeclare Person
- D:
SyntaxError
答案
答案: B
我们可以将类设置为等于其他类/函数构造函数。 在这种情况下,我们将Person
设置为AnotherPerson
。 这个构造函数的名字是Sarah
,所以新的Person
实例member
上的name属性是Sarah
。
97. 输出什么?
const 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
类型是不可见的,并返回一个空数组。 记录整个对象时,所有属性都是可见的,甚至是不可枚举的属性。
这是Symbol
的众多特性之一:除了表示完全唯一的值(防止对象意外名称冲突,例如当使用2个想要向同一对象添加属性的库时),您还可以隐藏
这种方式对象的属性(尽管不完全。你仍然可以使用Object.getOwnPropertySymbols()
方法访问 Symbol
。
98. 输出什么?
const getList = ([x, ...y]) => [x, y] |
- A:
[1, [2, 3, 4]]
andundefined
- 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
函数接收一个数组作为其参数。 在getList
函数的括号之间,我们立即解构这个数组。 您可以将其视为:
[x, ...y] = [1, 2, 3, 4]
使用剩余的参数... y
,我们将所有剩余参数放在一个数组中。 在这种情况下,其余的参数是2
,3
和4
。 y
的值是一个数组,包含所有其余参数。 在这种情况下,x
的值等于1
,所以当我们打印[x,y]
时,会打印[1,[2,3,4]]
。
getUser
函数接收一个对象。对于箭头函数,如果只返回一个值,我们不必编写花括号。但是,如果您想从一个箭头函数返回一个对象,您必须在圆括号之间编写它,否则不会返回任何值!下面的函数将返回一个对象:
const getUser = user => ({ name: user.name, age: user.age })
由于在这种情况下不返回任何值,因此该函数返回undefined
。
99. 输出什么?
const name = "Lydia" |
- A:
SyntaxError
- B:
ReferenceError
- C:
TypeError
- D:
undefined
答案
答案: C
变量name
保存字符串的值,该字符串不是函数,因此无法调用。
当值不是预期类型时,会抛出TypeErrors
。 JavaScript期望name
是一个函数,因为我们试图调用它。 但它是一个字符串,因此抛出TypeError
:name is not a function
当你编写了一些非有效的JavaScript时,会抛出语法错误,例如当你把return
这个词写成retrun
时。
当JavaScript无法找到您尝试访问的值的引用时,抛出ReferenceErrors
。
100. 输出什么?
// 🎉✨ This is my 100th question! ✨🎉 |
- 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) |
- A:
false
null
[]
- B:
null
""
true
- C:
{}
""
[]
- D:
null
null
true
答案
答案: C
使用||
运算符,我们可以返回第一个真值。 如果所有值都是假值,则返回最后一个值。
(false || {} || null)
:空对象{}
是一个真值。 这是第一个(也是唯一的)真值,它将被返回。one
等于{}
。
(null || false ||“”)
:所有值都是假值。 这意味着返回传递的值""
。 two
等于""
。
([] || 0 ||“”)
:空数组[]
是一个真值。 这是第一个返回的真值。 three
等于[]
。
102. 依次输出什么?
const myPromise = () => Promise.resolve('I have resolved!') |
- A:
I have resolved!
,second
andI have resolved!
,second
- B:
second
,I have resolved!
andsecond
,I have resolved!
- C:
I have resolved!
,second
andsecond
,I have resolved!
- D:
second
,I have resolved!
andI have resolved!
,second
答案
答案: D
有了promise,我们通常会说:当我想要调用某个方法,但是由于它可能需要一段时间,因此暂时将它放在一边。只有当某个值被resolved/rejected,并且执行栈为空时才使用这个值。
我们可以在async
函数中通过.then
和await
关键字获得该值。 尽管我们可以通过.then
和await
获得promise的价值,但是它们的工作方式有所不同。
在 firstFunction
中,当运行到myPromise
方法时我们将其放在一边,即promise进入微任务队列,其他后面的代码(console.log('second')
)照常运行,因此second
被打印出,firstFunction
方法到此执行完毕,执行栈中宏任务队列被清空,此时开始执行微任务队列中的任务,I have resolved
被打印出。
在secondFunction
方法中,我们通过await
关键字,暂停了后面代码的执行,直到异步函数的值被解析才开始后面代码的执行。这意味着,它会等着直到 myPromise
以值I have resolved
被解决之后,下一行second
才开始执行。
103. 输出什么?
const set = new Set() |
- A:
3
,NaN
,NaN
- B:
3
,7
,NaN
- C:
3
,Lydia2
,[Object object]2
- D:
"12"
,Lydia2
,[Object object]2
答案
答案: C
“+”运算符不仅用于添加数值,还可以使用它来连接字符串。 每当JavaScript引擎发现一个或多个值不是数字时,就会将数字强制为字符串。
第一个是数字1。 1 + 2返回数字3。
但是,第二个是字符串“Lydia”。 “Lydia”是一个字符串,2是一个数字:2被强制转换为字符串。 “Lydia”和“2”被连接起来,产生字符串“Lydia2”。
{name:“ Lydia”}
是一个对象。 数字和对象都不是字符串,因此将二者都字符串化。 每当我们对常规对象进行字符串化时,它就会变成[Object object]
。 与“2”串联的“ [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
(<fulfilled>
)。 如果您传递常规函数,它将是具有常规值的已解决promise
。 如果你通过了promise,它将是一个已经resolved的且带有传的值的promise。
上述情况,我们传了数字5,因此返回一个resolved状态的promise,resolve值为5
105. 输出什么?
function compareMembers(person1, person2 = 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 = { |
- A:
true
- B:
false
- C:
undefined
- D:
TypeError
答案
答案: D
在JavaScript中,我们有两种访问对象属性的方法:括号表示法或点表示法。 在此示例中,我们使用点表示法(colorConfig.colors
)代替括号表示法(colorConfig [“ colors”]
)。
使用点表示法,JavaScript会尝试使用该确切名称在对象上查找属性。 在此示例中,JavaScript尝试在colorconfig对象上找到名为colors的属性。 没有名为“colors”的属性,因此返回“undefined”。
然后,我们尝试使用[1]
访问第一个元素的值。 我们无法对未定义的值执行此操作,因此会抛出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。
108. 哪些方法修改了原数组?
const emojis = ['✨', '🥑', '😍'] |
- A:
All of them
- B:
map
reduce
slice
splice
- C:
map
slice
splice
- D:
splice
答案
答案: D
使用splice
方法,我们通过删除,替换或添加元素来修改原始数组。 在这种情况下,我们从索引1中删除了2个元素(我们删除了'🥑'
和'😍'
),同时添加了✨emoji表情。
map
,filter
和slice
返回一个新数组,find
返回一个元素,而reduce
返回一个减小的值。
109. 输出什么?
const food = ['🍕', '🍫', '🥑', '🍔'] |
- A:
['🍕', '🍫', '🥑', '🍔']
- B:
['🍝', '🍫', '🥑', '🍔']
- C:
['🍝', '🍕', '🍫', '🥑', '🍔']
- D:
ReferenceError
答案
答案: A
我们将info
对象上的favoriteFood
属性的值设置为披萨表情符号“🍕”的字符串。字符串是原始数据类型。在JavaScript中,原始数据类型通过值起作用
在这种情况下,我们将info
对象上的favoriteFood
属性的值设置为等于food
数组中的第一个元素的值,字符串为披萨表情符号('🍕'
)。字符串是原始数据类型,并且通过值进行交互,我们更改info
对象上favoriteFood
属性的值。 food数组没有改变,因为favoriteFood的值只是该数组中第一个元素的值的复制,并且与该元素上的元素没有相同的内存引用食物[0]
。当我们记录食物时,它仍然是原始数组['🍕','🍫','🥑','🍔']
。