【JS】411- JS 进阶系列问题(47问)
本文截取自来自Lydia Hallie 小姐姐的 javascript-questions,从基础到进阶,测试你有多了解 JavaScript,刷新你的知识,或者帮助你的 coding 面试!
答案在问题下方。祝你好运!
1. 输出是什么?
function sayHi() {
console.log(name)
console.log(age)
var name = 'Lydia'
let age = 21
}
sayHi()
A:
Lydia
和undefined
B:
Lydia
和ReferenceError
C:
ReferenceError
和21
D:
undefined
和ReferenceError
答案: D
在函数内部,我们首先通过 var
关键字声明了 name
变量。这意味着变量被提升了(内存空间在创建阶段就被设置好了),直到程序运行到定义变量位置之前默认值都是 undefined
。因为当我们打印 name
变量时还没有执行到定义变量的位置,因此变量的值保持为 undefined
。
通过 let
和 const
关键字声明的变量也会提升,但是和 var
不同,它们不会被初始化。在我们声明(初始化)之前是不能访问它们的。这个行为被称之为暂时性死区。当我们试图在声明之前访问它们时,JavaScript 将会抛出一个 ReferenceError
错误。
2. 输出是什么?
for (var i = 0; i < 3; i++) {
setTimeout(() => console.log(i), 1)
}
for (let i = 0; i < 3; i++) {
setTimeout(() => console.log(i), 1)
}
A:
0 1 2
和0 1 2
B:
0 1 2
和3 3 3
C:
3 3 3
和0 1 2
答案: C
由于 JavaScript 的事件循环,setTimeout
回调会在遍历结束后才执行。因为在第一个遍历中遍历 i
是通过 var
关键字声明的,所以这个值是全局作用域下的。在遍历过程中,我们通过一元操作符 ++
来每次递增 i
的值。当 setTimeout
回调执行的时候,i
的值等于 3。
在第二个遍历中,遍历 i
是通过 let
关键字声明的:通过 let
和 const
关键字声明的变量是拥有块级作用域(指的是任何在 {} 中的内容)。在每次的遍历过程中,i
都有一个新值,并且每个值都在循环内的作用域中。
3. 输出是什么?
const shape = {
radius: 10,
diameter() {
return this.radius * 2
},
perimeter: () => 2 * Math.PI * this.radius
}
shape.diameter()
shape.perimeter()
A:
20
and62.83185307179586
B:
20
andNaN
C:
20
and63
D:
NaN
and63
答案: B
注意 diameter
的值是一个常规函数,但是 perimeter
的值是一个箭头函数。
对于箭头函数,this
关键字指向的是它当前周围作用域(简单来说是包含箭头函数的常规函数,如果没有常规函数的话就是全局对象),这个行为和常规函数不同。这意味着当我们调用 perimeter
时,this
不是指向 shape
对象,而是它的周围作用域(在例子中是 window
)。
在 window
中没有 radius
这个属性,因此返回 undefined
。
4. 输出是什么?
+true;
!"Lydia";
A:
1
andfalse
B:
false
andNaN
C:
false
andfalse
答案: A
一元操作符加号尝试将 bool 转为 number。true
转换为 number 的话为 1
,false
为 0
。
字符串 'Lydia'
是一个真值,真值取反那么就返回 false
。
5. 输出是什么?
const numbers = [1, 2, 3, 4, 5];
const [y] = numbers;
console.log(y);
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
.
6. 输出是什么?
const user = { name: "Lydia", age: 21 };
const admin = { admin: true, ...user };
console.log(admin);
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 }
.
7. 输出是什么?
const person = { name: "Lydia" };
Object.defineProperty(person, "age", { value: 21 });
console.log(person);
console.log(Object.keys(person));
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
方法添加的属性有了更多的控制权。
8. 输出是什么?
const settings = {
username: "lydiahallie",
level: 19,
health: 90
};
const data = JSON.stringify(settings, ["level", "health"]);
console.log(data);
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)是个 函数,这个函数将被对象的每个属性都调用一遍。undefined
,则该属性会被排除在外。
9. 输出是什么?
let num = 10;
const increaseNumber = () => num++;
const increasePassedNumber = number => number++;
const num1 = increaseNumber();
const num2 = increasePassedNumber(num1);
console.log(num1);
console.log(num2);
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
.
10. 输出什么?
const value = { number: 10 };
const multiply = (x = { ...value }) => {
console.log(x.number *= 2);
};
multiply();
multiply();
multiply(value);
multiply(value);
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
。
11. 输出什么?
[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
被打印出。
12. 使用哪个构造函数可以成功继承`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将引发一个引用错误。
使用super
关键字,需要用给定的参数来调用父类的构造函数。父类的构造函数接收name
参数,因此我们需要将name
传递给super
。
Labrador
类接收两个参数,name
参数是由于它继承了Dog
,size
作为Labrador
类的额外属性,它们都需要传递给Labrador
的构造函数,因此使用构造函数2正确完成。
13. 输出什么?
// 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
命令是编译阶段执行的,在代码运行之前。因此这意味着被导入的模块会先运行,而导入模块的文件会后执行。
这是CommonJS中require()
和import
之间的区别。使用require()
,您可以在运行代码时根据需要加载依赖项。如果我们使用require
而不是import
,running index.js
,running sum.js
,3
会被依次打印。
14. 输出什么?
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
的参数只是给Symbol
的一个描述。Symbol
的值不依赖于传递的参数。当我们测试相等时,我们创建了两个全新的符号:第一个Symbol('foo')
,第二个Symbol('foo')
, 这两个值是唯一的,彼此不相等,因此返回false
。
15. 输出什么?
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
方法,我们可以在字符串的开头添加填充。传递给此方法的参数是字符串的总长度(包含填充)。字符串Lydia Hallie
的长度为12
, 因此name.padStart(13)
在字符串的开头只会插入1(13 - 12 = 1
)个空格。
如果传递给padStart
方法的参数小于字符串的长度,则不会添加填充。
16. 输出什么?
console.log("🥑" + "💻");
A:
"🥑💻"
B:
257548
C: A string containing their code points
D: Error
答案: A
使用+
运算符,您可以连接字符串。上述情况,我们将字符串“🥑”
与字符串”💻“
连接起来,产生”🥑💻“
。
17. 如何能打印出`console.log`语句后注释掉的值?
function* startGame() {
const answer = yield "Do you love JavaScript?";
if (answer !== "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
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
, 这意味着此时变量 answer
为undefined
next
方法可以带一个参数,该参数会被当作上一个 yield
表达式的返回值。当我们调用game.next("Yes").value
时,先前的 yield
的返回值将被替换为传递给next()
函数的参数"Yes"
。此时变量 answer
被赋值为 "Yes"
,if
语句返回false
,所以JavaScript loves you back ❤️
被打印。
18. 输出什么?
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`
String.raw`${path}`
这将导致:
"C:DocumentsProjects able.html"
直接使用String.raw
String.raw`C:\Documents\Projects\table.html`
它会忽略转义字符并打印:C:\Documents\Projects\table.html
上述情况,字符串是Hello\nworld
被打印出。
19. 输出什么?
async function getData() {
return await Promise.resolve("I made it!");
}
const data = getData();
console.log(data);
A:
"I made it!"
B:
Promise {: "I made it!"}
C:
Promise {}
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!"
20. 输出什么?
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()
方法返回新数组的长度。一开始,数组包含一个元素(字符串"banana"
),长度为1。在数组中添加字符串"apple"
后,长度变为2,并将从addToList
函数返回。
push
方法修改原始数组,如果你想从函数返回数组而不是数组长度,那么应该在push item
之后返回list
。
21. 输出什么?
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
使得无法添加、删除或修改对象的属性(除非属性的值是另一个对象)。
当我们创建变量shape
并将其设置为等于冻结对象box
时,shape
指向的也是冻结对象。你可以使用Object.isFrozen
检查一个对象是否被冻结,上述情况,Object.isFrozen(shape)
将返回true
。
由于shape
被冻结,并且x
的值不是对象,所以我们不能修改属性x
。x
仍然等于10
,{x:10,y:20}
被打印。
注意,上述例子我们对属性x
进行修改,可能会导致抛出TypeError异常(最常见但不仅限于严格模式下时)。
22. 输出什么?
const { name: myName } = { name: "Lydia" };
console.log(name);
A:
"Lydia"
B:
"myName"
C:
undefined
D:
ReferenceError
答案: D
当我们从右侧的对象解构属性name
时,我们将其值Lydia
分配给名为myName
的变量。
使用{name:myName}
,我们是在告诉JavaScript我们要创建一个名为myName
的新变量,并且其值是右侧对象的name
属性的值。
当我们尝试打印name
,一个未定义的变量时,就会引发ReferenceError
。
23. 以下是个纯函数么?
function sum(a, b) {
return a + b;
}
A: Yes
B: No
答案: A
纯函数一种若输入参数相同,则永远会得到相同输出的函数。
sum
函数总是返回相同的结果。如果我们传递1
和2
,它将总是返回3
而没有副作用。如果我们传递5
和10
,它将总是返回15
,依此类推,这是纯函数的定义。
24. 输出什么?
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! 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
被打印。
25. 输出什么?
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:
"☕"
"💻"
"🍷"
"🍫"
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
, 因此“☕”
,“💻“
,”🍷”
,“🍫“
被打印。
26. 输出什么?
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
数组元素可以包含任何值。数字,字符串,布尔值,对象,数组,null
,undeifned
, 以及其他表达式,如日期,函数和计算。
元素将等于返回的值。1 + 2
返回3
,1 * 2
返回'2,'1 / 2
返回0.5
。
27. 输出什么?
function sayHi(name) {
return `Hi there, ${name}`
}
console.log(sayHi())
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
28. 输出什么?
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
关键字的指向取决于使用它的位置。在函数中,比如getStatus
,this
指向的是调用它的对象,上述例子中data
对象调用了getStatus
,因此this
指向的就是data
对象。当我们打印this.status
时,data
对象的status
属性被打印,即"🥑"
。
使用call
方法,可以更改this
指向的对象。data.getStatus.call(this)
是将this
的指向由data
对象更改为全局对象。在全局对象上,有一个名为status
的变量,其值为”😎“
。因此打印this.status
时,会打印“😎”
。
29. 输出什么?
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
对象时,会返回未修改的对象。
30. 输出什么?
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
。
31. 什么样的信息将被打印?
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
中的回调函数返回的值。你可以像这样继续链接.then
,将值传递给下一个处理程序。
32. 哪个选项是将`hasName`设置为`true`的方法,前提是不能将`true`作为参数传递?
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
函数的值,而不是布尔值true
。
new Boolean(true)
返回一个对象包装器,而不是布尔值本身。
name.length
返回传递的参数的长度,而不是布尔值true
。
33. 输出什么?
console.log("I want pizza"[0])
A:
"""
B:
"I"
C:
SyntaxError
D:
undefined
答案: B
可以使用方括号表示法获取字符串中特定索引的字符,字符串中的第一个字符具有索引0,依此类推。在这种情况下,我们想要得到索引为0的元素,字符'I'
被记录。
请注意,IE7及更低版本不支持此方法。在这种情况下,应该使用.charAt()
34. 输出什么?
function sum(num1, num2 = num1) {
console.log(num1 + num2)
}
sum(10)
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) {
console.log(m, n)
}
test() // Uncaught ReferenceError: Cannot access 'n' before initialization
test(3) // 3 2
test(3, 4) // 3 4
35. 输出什么?
// 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
文件中,并且创建了一个名为data
的新对象。在module.js
文件中,有两个导出:默认导出和命名导出。默认导出是一个返回字符串“Hello World”的函数,命名导出是一个名为name
的变量,其值为字符串“Lydia”
。
data
对象具有默认导出的default
属性,其他属性具有指定exports的名称及其对应的值。
36. 输出什么?
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
类是构造函数的语法糖,如果用构造函数的方式来重写Person
类则将是:
function Person() {
this.name = name
}
通过new
来调用构造函数,将会生成构造函数Person
的实例,对实例执行typeof
关键字将返回"object"
,上述情况打印出"object"
。
37. 输出什么?
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
方法返回数组的长度,而不是数组本身!通过将newList
设置为[1,2,3].push(4)
,实际上newList
等于数组的新长度:4
。
然后,尝试在newList
上使用.push
方法。由于newList
是数值4
,抛出TypeError。
38. 输出什么?
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
常规函数,例如giveLydiaPizza
函数,有一个prototype
属性,它是一个带有constructor
属性的对象(原型对象)。然而,箭头函数,例如giveLydiaChocolate
函数,没有这个prototype
属性。尝试使用giveLydiaChocolate.prototype
访问prototype
属性时会返回undefined
。
39. 输出什么?
const person = {
name: "Lydia",
age: 21
}
for (const [x, y] of Object.entries(person)) {
console.log(x, y)
}
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
。
40. 输出什么?
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
是剩余参数,剩余参数的值是一个包含所有剩余参数的数组,并且只能作为最后一个参数。上述示例中,剩余参数是第二个参数,这是不可能的,并会抛出语法错误。
function getItems(fruitList, favoriteFruit, ...args) {
return [...fruitList, ...args, favoriteFruit]
}
getItems(["banana", "apple"], "pear", "orange")
上述例子是有效的,将会返回数组:[ 'banana', 'apple', 'orange', 'pear' ]
41. 输出什么?
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
,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
这意味着永远不会到达a + b
,因为函数在return
关键字之后停止运行。如果没有返回值,就像这里,函数返回undefined
。注意,在if/else
语句之后没有自动插入!
42. 输出什么?
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
我们可以将类设置为等于其他类/函数构造函数。在这种情况下,我们将Person
设置为AnotherPerson
。这个构造函数的名字是Sarah
,所以新的Person
实例member
上的name属性是Sarah
。
43. 输出什么?
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
类型是不可见的,并返回一个空数组。记录整个对象时,所有属性都是可见的,甚至是不可枚举的属性。
这是Symbol
的众多特性之一:除了表示完全唯一的值(防止对象意外名称冲突,例如当使用2个想要向同一对象添加属性的库时),您还可以隐藏
这种方式对象的属性(尽管不完全。你仍然可以使用Object.getOwnPropertySymbols()
方法访问 Symbol
。
44. 输出什么?
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]]
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
。
45. 输出什么?
const name = "Lydia"
console.log(name())
A:
SyntaxError
B:
ReferenceError
C:
TypeError
D:
undefined
答案: C
变量name
保存字符串的值,该字符串不是函数,因此无法调用。
当值不是预期类型时,会抛出TypeErrors
。JavaScript期望name
是一个函数,因为我们试图调用它。但它是一个字符串,因此抛出TypeError
:name is not a function
当你编写了一些非有效的JavaScript时,会抛出语法错误,例如当你把return
这个词写成retrun
时。ReferenceErrors
。
46. 输出什么?
// 🎉✨ 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
不会被退回。
47.输出什么?
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
使用||
运算符,我们可以返回第一个真值。如果所有值都是假值,则返回最后一个值。
(false || {} || null)
:空对象{}
是一个真值。这是第一个(也是唯一的)真值,它将被返回。one
等于{}
。
(null || false ||“”)
:所有值都是假值。这意味着返回传递的值""
。two
等于""
。
([] || 0 ||“”)
:空数组[]
是一个真值。这是第一个返回的真值。three
等于[]
。
回复“加群”与大佬们一起交流学习~