答案：D

在函数内部，我们首先通过 关键字声明了 变量。这意味着变量被提升了（内存空间在创建阶段就被设置好了），直到程序运行到定义变量位置之前默认值都是 。因为当我们打印 变量时还没有执行到定义变量的位置，因此变量的值保持为 。

通过 和 关键字声明的变量也会提升，但是和 不同，它们不会被初始化。在我们声明（初始化）之前是不能访问它们的。这个行为被称之为暂时性死区。当我们试图在声明之前访问它们时，JavaScript 将会抛出一个 错误。

答案：C

由于 JavaScript 的事件循环， 回调会在遍历结束后才执行。因为在第一个遍历中遍历 是通过 关键字声明的，所以这个值是全局作用域下的。在遍历过程中，我们通过一元操作符 来每次递增 的值。当 回调执行的时候， 的值等于 3。

在第二个遍历中，遍历 是通过 关键字声明的：通过 和 关键字声明的变量是拥有块级作用域（指的是任何在 {} 中的内容）。在每次的遍历过程中， 都有一个新值，并且每个值都在循环内的作用域中。

答案：B

注意 的值是一个常规函数，但是 的值是一个箭头函数。

对于箭头函数， 关键字指向的是它当前周围作用域（简单来说是包含箭头函数的常规函数，如果没有常规函数的话就是全局对象），这个行为和常规函数不同。这意味着当我们调用 时， 不是指向 对象，而是它的周围作用域（在例子中是 ）。

在 中没有 这个属性，因此返回 。

答案：A

一元操作符加号尝试将 bool 转为 number。 转换为 number 的话为 ， 为 。

字符串 是一个真值，真值取反那么就返回 。

答案：A

在 JavaScript 中，所有对象的 keys 都是字符串（除非对象是 Symbol）。尽管我们可能不会定义它们为字符串，但它们在底层总会被转换为字符串。

当我们使用括号语法时（[]），JavaScript 会解释（或者 unboxes）语句。它首先看到第一个开始括号 并继续前进直到找到结束括号 。只有这样，它才会计算语句的值。

：首先计算 ，这会得到 。 返回 。

然后使用点语法的话，上面这一切都不会发生。 没有 这个 key，这也就意味着 是 。然后当我们使用点语法 时，因为 是 ，这也就变成了 。这个行为是无效的，并且会抛出一个错误类似 。

答案：A

在 JavaScript 中，当设置两个对象彼此相等时，它们会通过引用进行交互。

首先，变量 的值是一个对象。接下来，我们给 分配了一个和 对象相同的引用。

讯享网

因此当我们改变其中一个对象时，其实是改变了所有的对象。

答案：C

是一个内建的函数构造器。虽然它看着像是一个 number，但它实际上并不是一个真实的 number：它有一堆额外的功能并且它是一个对象。

当我们使用 操作符时，它只会检查两者是否拥有相同的值。因为它们的值都是 ，因此返回 。

然后，当我们使用 操作符时，两者的值以及类型都应该是相同的。 是一个对象而不是 number，因此返回 。

答案：D

是一个静态方法。静态方法被设计为只能被创建它们的构造器使用（也就是 ），并且不能传递给实例。因为 是一个实例，静态方法不能被实例使用，因此抛出了 错误。

答案：A

代码打印出了一个对象，这是因为我们在全局对象上创建了一个空对象！当我们将 写错成 时，JS 解释器实际在上浏览器中将它视为 （或者 ）。

为了避免这个为题，我们可以使用 `"use strict"。这能确保当你声明变量时必须赋值。

答案：A

这在 JavaScript 中是可以的，因为函数是对象！（除了基本类型之外其他都是对象）

函数是一个特殊的对象。你写的这个代码其实不是一个实际的函数。函数是一个拥有属性的对象，并且属性也可被调用。

答案：A

你不能像常规对象那样，给构造函数添加属性。如果你想一次性给所有实例添加特性，你应该使用原型。因此本例中，使用如下方式：

这才会使 起作用。为什么这么做有益的？假设我们将这个方法添加到构造函数本身里。也许不是每个 实例都需要这个方法。这将浪费大量内存空间，因为它们仍然具有该属性，这将占用每个实例的内存空间。相反，如果我们只将它添加到原型中，那么它只存在于内存中的一个位置，但是所有实例都可以访问它！

答案：A

对于 ，我们没有使用 关键字。当使用 时， 引用我们创建的空对象。当未使用 时， 引用的是全局对象（global object）。

我们说 等于 ，并且 等于 。实际上我们做的是，定义了 和 。而 本身是 。

答案：D

在捕获（capturing）阶段中，事件从祖先元素向下传播到目标元素。当事件达到目标（target）元素后，冒泡（bubbling）才开始。

答案：B

除了基本对象（base object），所有对象都有原型。基本对象可以访问一些方法和属性，比如 。这就是为什么你可以使用内置的 JavaScript 方法！所有这些方法在原型上都是可用的。虽然 JavaScript 不能直接在对象上找到这些方法，但 JavaScript 会沿着原型链找到它们，以便于你使用。

答案：C

JavaScript 是一种动态类型语言：我们不指定某些变量的类型。值可以在你不知道的情况下自动转换成另一种类型，这种类型称为隐式类型转换（implicit type coercion）。Coercion 是指将一种类型转换为另一种类型。

在本例中，JavaScript 将数字 转换为字符串，以便函数有意义并返回一个值。在数字类型（）和字符串类型（）相加时，该数字被视为字符串。我们可以连接字符串，比如 ，这里发生的是 ，它返回 。

答案：C

一元后自增运算符 ：

1. 返回值（返回 ）
2. 值自增（number 现在是 ）

一元前自增运算符 ：

1. 值自增（number 现在是 ）
2. 返回值（返回 ）

结果是 .

答案：B

如果使用标记模板字面量，第一个参数的值总是包含字符串的数组。其余的参数获取的是传递的表达式的值！

答案：C

在测试相等性时，基本类型通过它们的值（value）进行比较，而对象通过它们的引用（reference）进行比较。JavaScript 检查对象是否具有对内存中相同位置的引用。

题目中我们正在比较的两个对象不是同一个引用：作为参数传递的对象引用的内存位置，与用于判断相等的对象所引用的内存位置并不同。

这也是 和 都返回 的原因。

答案：C

扩展运算符（）会返回实参组成的数组。而数组是对象，因此 返回 。

答案：C

使用 ，你可以确保不会意外地声明全局变量。我们从来没有声明变量 ，因为我们使用 ，它将抛出一个引用错误。如果我们不使用 ，它就会工作，因为属性 会被添加到全局对象中了。

答案：A

代码以字符串形式传递进来， 对其求值。如果它是一个表达式，就像本例中那样，它对表达式求值。表达式是 。这将返回数字 。

答案：B

关闭 tab 标签页 后， 存储的数据才会删除。

如果使用 ，那么数据将永远在那里，除非调用了 。

答案：B

使用 关键字，你可以用相同的名称声明多个变量。然后变量将保存最新的值。

你不能使用 或 来实现这一点，因为它们是块作用域的。

答案：C

所有对象的键（不包括 Symbol）在底层都是字符串，即使你自己没有将其作为字符串输入。这就是为什么 也返回 。

对于集合，它不是这样工作的。在我们的集合中没有 ： 返回 。它有数字类型为 ， 返回 。

答案：C

如果你有两个名称相同的键，则键会被替换掉。它仍然位于第一个键出现的位置，但是值是最后出现那个键的值。

答案：A

基本执行上下文是全局执行上下文：它是代码中随处可访问的内容。

答案：C

如果某个条件返回 ，则 语句跳过本次迭代。

答案：A

是内置的构造函数，我们可以向它添加属性。我只是在它的原型中添加了一个方法。基本类型字符串被自动转换为字符串对象，由字符串原型函数生成。因此，所有 string(string 对象) 都可以访问该方法！

答案：B

对象的键被自动转换为字符串。我们试图将一个对象 设置为对象 的键，且相应的值为 。

然而，当字符串化一个对象时，它会变成 。因此这里说的是，。然后，我们再一次做了同样的事情， 是另外一个对象，这里也有隐式字符串化，于是，。

然后，我们打印 ，也就是 。之前刚设置为 ，因此返回的是 。

答案：B

我们有一个 函数，并首先调用它。然而，它是最后打印日志的。

这是因为在浏览器中，我们不仅有运行时引擎，还有一个叫做 的东西。 提供了 函数，也包含其他的，例如 DOM。

将 callback 推送到 WebAPI 后， 函数本身 (但不是回调！) 将从栈中弹出。

现在， 被调用，打印 。

从栈中弹出， 被调用。打印 。

WebAPI 不能随时向栈内添加内容。相反，它将回调函数推到名为 queue 的地方。

这就是事件循环开始工作的地方。一个事件循环查看栈和任务队列。如果栈是空的，它接受队列上的第一个元素并将其推入栈。

被调用，打印 ，然后它被栈弹出。

答案：C

导致事件的最深嵌套的元素是事件的 target。你可以通过 来停止冒泡。

答案：A

如果我们点击 ，我们会看到两个日志： 和 。在事件传播期间，有三个阶段：捕获、目标和冒泡。默认情况下，事件处理程序在冒泡阶段执行（除非将 设置为 ）。它从嵌套最深的元素向外传播。

答案：D

使用这两种方法，我们都可以传递我们希望 关键字引用的对象。但是， 是立即执行的。

返回函数的副本，但带有绑定上下文！它不是立即执行的。

答案：B

方法返回的是立即执行函数 (IIFE) 的返回值。此立即执行函数的返回值是 ，类型是

参考：只有 7 种内置类型：，，，，，, 和 。 不是一种类型，函数是对象，它的类型是。

答案：A

只有 8 种 falsy 值：

• (empty string)
• (BigInt(0))

构造函数，比如 和 ，是 truthy。

答案：B

返回 。 返回 。

答案：C

当你为数组设置超过数组长度的值的时候，JavaScript 会创建名为 "empty slots" 的东西。它们的值实际上是 。你会看到以下场景：

这取决于你的运行环境（每个浏览器，以及 node 环境，都有可能不同）

答案：A

代码块接收参数 。当我们传递参数时，这与之前定义的变量 不同。这个 是属于 块级作用域的。

然后，我们将块级作用域中的变量赋值为 ，同时也设置了变量 的值。现在，我们打印块级作用域中的变量 ，值为 。

块之外的变量 的值仍为 ， 的值为 。当我们在 块之外执行 时，返回 ， 返回 。

答案：A

JavaScript 只有基本类型和对象。

基本类型包括 , , , , , , 。

答案：C

是初始值。初始值将会作为首次调用时第一个参数 的值。在第一次执行时， 的值是 ， 的值是 。合并它们，结果为 。 第二次执行， 的值是 ， 的值是 。合并它们，最终结果为

答案：B

是 falsy。 的值是 。 的值是 。

是 falsy。 的值是 。 的值是 。

是 truthy。 的值是 。 的值是 。

答案：A

返回一个唯一的 id。此 id 可被用于 函数来取消定时。

答案：A

string 类型是可迭代的。扩展运算符将迭代的每个字符映射成一个元素。

答案：C

一般的函数在执行之后是不能中途停下的。但是，生成器函数却可以中途“停下”，之后可以再从停下的地方继续。当生成器遇到关键字的时候，会生成后面的值。注意，生成器在这种情况下不 返回 (return ) 值，而是 生成 (yield) 值。

首先，我们用作为参数来初始化生成器函数。然后使用方法一步步执行生成器。第一次执行生成器的时候，的值为，遇到第一个关键字，它要生成的值。此时，生成器“暂停”，生成了。

然后，我们再执行方法。生成器会从刚才暂停的地方继续，这个时候还是。于是我们走到了第二个关键字处，这时候需要生成的值是，为，那么此时生成的值便是。所以这道题的最终结果是。

答案：B

当我们向方法中传入多个时，会进行 优先 解析。在这个例子中，我们用给和分别设定了 500ms 和 100ms 的定时器。这意味着会首先解析出字符串。那么此时参数即为，是为输出结果。

答案：D

首先我们声明了一个拥有属性的对象 。

然后我们又声明了一个变量. 将首个元素赋值为变量。当设置两个对象彼此相等时，它们会通过 引用 进行交互。但是当你将引用从一个变量分配至另一个变量时，其实只是执行了一个 复制 操作。（注意一点，他们的引用 并不相同!）

接下来我们让等于。

我们没有修改数组第一个元素的值，而只是修改了变量的值，因为元素（复制而来）的引用与不同。的第一个元素仍然保持着对原始对象的引用。当我们输出数组时，第一个元素会将引用的对象打印出来。

答案：B

在循环中，我们可以通过对象的 key 来进行迭代，也就是这里的和。在底层，对象的 key 都是字符串（如果他们不是 Symbol 的话）。在每次循环中，我们将设定为当前遍历到的 key.所以一开始，是，之后 输出的则是。

答案：B

当所有运算符的 优先级 相同时，计算表达式需要确定运算符的结合顺序，即从右到左还是从左往右。在这个例子中，我们只有一类运算符，对于加法来说，结合顺序就是从左到右。

首先计算，得到数字.

由于类型的强制转换，的结果是. JavaScript 将转换成了字符串，可以参考问题 15.我们可以用号把两个字符串连接起来。 就得到了.

答案：C

只返回了字符串中第一个字母。设定了 进制 后 (也就是第二个参数，指定需要解析的数字是什么进制：十进制、十六机制、八进制、二进制等等……), 检查字符串中的字符是否合法。一旦遇到一个在指定进制中不合法的字符后，立即停止解析并且忽略后面所有的字符。

就是不合法的数字字符。所以只解析到，并将其解析为十进制的. 的值即为.

答案：C

对数组进行映射的时候，就是当前循环到的元素。在这个例子中，所有的映射都是 number 类型，所以 if 中的判断结果都是.map 函数创建了新数组并且将函数的返回值插入数组。

但是，没有任何值返回。当函数没有返回任何值时，即默认返回.对数组中的每一个元素来说，函数块都得到了这个返回值，所以结果中每一个元素都是.

答案：A

普通参数都是 值 传递的，而对象则不同，是 引用 传递。所以说，是值传递，因为他是个字符串而不是对象。当我们对参数进行值传递时，会创建一份该值的 复制。（可以参考问题 46）

变量有一个对的引用，而传入的参数也有一个对的引用，但二者的引用并不相同。当我们通过给 赋值来更新的值的时候我们只是更新了（的引用）。此时仍然是.

而是个对象。参数引用与之 相同的 对象。当我们修改所引用对象的属性时，的相应属性也被修改了，因为他们引用了相同的对象。的 属性也变成了 .

答案：D

通过语句，我么可以创建自定义错误。而通过它，我们可以抛出异常。异常可以是一个字符串，一个 数字，一个 布尔类型 或者是一个 对象。在本例中，我们的异常是字符串.

通过 语句，我们可以设定当语句块中抛出异常后应该做什么处理。在本例中抛出的异常是字符串. 就是这个字符串，因此被输出。最终结果就是.

答案：B

返回属性的时候，属性的值等于 返回的 值，而不是构造函数中设定的值。我们返回了字符串 ，所以 等于.

答案：A

是下面这个表达式的缩写：

我们设定等于时，我们实际上增加了一个属性给全局对象 (浏览器里的, Nodejs 里的)。在浏览器中，等于.

然后我们声明了变量等于，也是.但变量是使用 声明的，它只作用于 块级作用域，仅在声明它的块中有效；就是案例中的立即调用表达式 (IIFE)。使用操作符时，操作值 没有被定义：因为我们在声明块的外部，无法调用它。这就意味着未定义。未分配或是未声明的变量类型为. 返回.

而我们创建了全局变量，并且设定等于.这个值在我们的代码各处都访问的到。已经被定义了，而且有一个类型的值。返回.

答案：A

我们可以用关键字删除对象的属性，对原型也是适用的。删除了原型的属性后，该属性在原型链上就不可用了。在本例中，函数在执行了后不可用，然而后面的代码还在调用它。

当我们尝试调用一个不存在的函数时异常会被抛出。在本例中就是 ，因为是.

答案：D

对象是独一无二的值的集合：也就是说同一个值在其中仅出现一次。

我们传入了数组，他有一个重复值.以为一个集合里不能有两个重复的值，其中一个就被移除了。所以结果是 .

答案：C

引入的模块是 只读 的：你不能修改引入的模块。只有导出他们的模块才能修改其值。

当我们给增加一个值的时候会抛出一个异常：是只读的，不能被修改。

答案：A

操作符返回一个布尔值：指删除成功，否则返回. 但是通过 , 或 关键字声明的变量无法用 操作符来删除。

变量由关键字声明，所以删除不成功：返回 . 而我们设定等于时，我们实际上添加了一个名为的属性给全局对象。对象中的属性是可以删除的，全局对象也是如此，所以返回.

答案：C

我们可以通过解构赋值来解析来自对象的数组或属性的值，比如说：

的值现在是，的值现在是.而在题目中，我们是这么做的：

也就是说，等于数组的第一个值就是数字.我们输出，返回.

答案：B

扩展运算符为对象的组合提供了可能。你可以复制对象中的键值对，然后把它们加到另一个对象里去。在本例中，我们复制了对象键值对，然后把它们加入到对象中。对象就拥有了这些键值对，所以结果为.

答案：B

通过方法，我们可以给对象添加一个新属性，或者修改已经存在的属性。而我们使用方法给对象添加了一个属性之后，属性默认为 不可枚举 (not enumerable). 方法仅返回对象中 可枚举 (enumerable) 的属性，因此只剩下了.

用方法添加的属性默认不可变。你可以通过, 和 属性来改变这一行为。这样，方法可以让您更好地控制要添加到对象的属性。

答案：A

的第二个参数是 替代者 (replacer). 替代者 (replacer) 可以是个函数或数组，用以控制哪些值如何被转换为字符串。

如果替代者 (replacer) 是个 数组，那么就只有包含在数组中的属性将会被转化为字符串。在本例中，只有名为 和 的属性被包括进来，则被排除在外。 就等于 .

而如果替代者 (replacer) 是个 函数，这个函数将被对象的每个属性都调用一遍。 函数返回的值会成为这个属性的值，最终体现在转化后的 JSON 字符串中（译者注：Chrome 下，经过实验，如果所有属性均返回同一个值的时候有异常，会直接将返回值作为结果输出而不会输出 JSON 字符串），而如果返回值为，则该属性会被排除在外。

答案：A

一元操作符 先返回 操作值，再累加 操作值。的值是，因为函数首先返回的值，也就是，随后再进行 的累加。

是因为我们将 传入. 等于（的值。同样道理， 先返回 操作值，再累加 操作值。）是，所以也是.

答案：C

在 ES6 中，我们可以使用默认值初始化参数。如果没有给函数传参，或者传的参值为 ，那么参数的值将是默认值。上述例子中，我们将 对象进行了解构并传到一个新对象中，因此 的默认值为 。

默认参数在调用时才会进行计算，每次调用函数时，都会创建一个新的对象。我们前两次调用 函数且不传递值，那么每一次 的默认值都为 ，因此打印出该数字的乘积值为。

第三次调用 时，我们传递了一个参数，即对象。运算符实际上是的简写，我们修改了的值，并打印出值。

第四次，我们再次传递对象。之前被修改为，所以打印为。