21:I[82591,["8500","static/chunks/8500-01a63dafd809e317.js","9304","static/chunks/9304-8d5d436fe7c94e16.js","7019","static/chunks/7019-14927e506b89eb47.js","8976","static/chunks/8976-2e6983735a6edc4e.js","3265","static/chunks/3265-fd4eae634e948c4f.js","1750","static/chunks/1750-fbdecb7fdfbedc02.js","2623","static/chunks/2623-eea13fee2ab568aa.js","8437","static/chunks/8437-5e456dd2e7c2468a.js","622","static/chunks/622-42e41432bd6994e0.js","3625","static/chunks/3625-83a937e0a1e501ea.js","3227","static/chunks/3227-5950e934b7cd3931.js","3133","static/chunks/3133-9fb39eaee1e47b4c.js","6495","static/chunks/6495-b9b477b9fdf7b8c8.js","4395","static/chunks/app/(web)/(routes)/(web)/flashcards/%5Btrack%5D/%5Bnode%5D/page-14943b4210c1f7e9.js"],"default"] 22:T9d8,

结论与机制

正确选项是 A，程序最终输出 10。调用 test(a) 时，外部变量 a 当前保存数字 10。数字属于基本类型，实参求值后，该数值被传给函数形参 a。形参与外部变量虽然名称相同，但处于不同作用域，是两个彼此独立的变量绑定。函数体中的 a = a + 10 先读取局部形参的值 10，计算得到 20，再把 20 赋给局部形参；它没有对外层变量进行赋值，所以函数执行结束后，外层的 a 仍为 10。

更准确地说，JavaScript 的参数传递采用按值传递。对于基本类型，传入的是基本值；对于对象，传入的也是值，只不过这个值是指向对象的引用。因此不能简单概括为“基本类型按值、对象按引用”，否则容易在其他题目中产生误判。

选项分析

A 正确：函数内部修改的是局部形参 a，外部 var a = 10 对应的变量未被重新赋值，故 console.log(a) 输出 10。
B 错误：若函数体直接操作外部变量，或者函数返回计算结果后由外部执行 a = test(a)，才可能使外部值变为 20。本题没有这些操作。
C 错误：形参与外部变量同名是合法的作用域遮蔽，不会因此抛出异常；加法和赋值也都是合法操作。
D 错误：函数 test 确实没有显式返回值，调用表达式的结果是 undefined，但题目打印的不是调用结果，而是外部变量 a，所以不会输出 undefined。

易错点

一是要区分形参 a 与全局作用域中的 a，同名不代表同一个变量。二是要区分“函数返回值”和“被打印的变量”：test(a) 的返回值虽为 undefined，却没有被保存或打印。三是不要认为去掉形参就没有区别；如果函数写成 function test(){ a = a + 10 }，其中没有局部声明遮蔽外部变量，那么赋值目标才会变成外层 a，输出也会随之改变。

23:Ta6f,

结论与机制

正确选项是 A，结果为 [, 2, , 3, , 4]。初始数组的长度是 6，但索引 0、2、4 处是空槽，并不是显式存放了 undefined。Array.prototype.map 只会对源数组中实际存在的索引调用回调函数，同时创建一个长度相同的新数组。源数组的空槽不会执行 (i) => ++i，并会在结果数组的相同位置继续保留为空槽；存在的元素 1、2、3 分别经过前置自增后变为 2、3、4。

因此，回调实际只执行三次，而不是六次。前置自增 ++i 修改的是每次回调中的局部参数并返回递增后的数值，它不会直接修改原数组元素；真正形成新结果的是 map 收集每次回调的返回值，并将新数组重新赋给变量 array。

选项分析

A 正确：空槽保持在原索引位置，三个已有数字分别加一，得到 [, 2, , 3, , 4]。
B 错误：只有回调以 undefined 作为参数执行 ++i 时，才可能产生 NaN。但 map 会跳过空槽，所以这些位置没有执行自增，也没有写入 NaN。
C 错误：空槽没有作为数值 0 参与计算，也不会因前置自增自动变成 1。该选项错误地把空槽当成了可计算元素。
D 错误：空槽不是 null，map 也不会自动把空槽填充为 null。某些序列化或展示操作可能让空槽看起来像空值，但不能据此改变数组内部结构。

易错点

空槽、显式的 undefined 和 null 是三种不同情况。例如 [undefined].map(fn) 会执行一次回调，而 [,].map(fn) 不会执行回调。不能笼统地说所有 ES6 数组方法都会把空槽当成 undefined：不同方法的处理行为并不完全一致。本题中的关键行为是 map 跳过空槽并在结果中保留对应空槽。还要注意开发者工具的展示形式可能不同，有的会显示 empty，但数组长度仍为 6，实际存在的索引仍只有 1、3、5。

24:Ta3d,

结论与机制

正确答案是 B，最终输出原数组 [1, 2, 3]。不传参数调用数组的 slice()，等价于从起始位置复制到数组末尾，它会返回一个新的数组对象，不会在原数组上增加或删除元素。因此 b 与 a 是两个不同的数组引用。执行 b.push(4) 时，被修改的是新数组 b，其内容变为 [1, 2, 3, 4]；原数组 a 的长度和元素保持不变，所以打印 a 得到 [1, 2, 3]。

需要精确理解的是，slice() 进行的是浅拷贝，而不是递归意义上的深拷贝。当前数组元素都是数字，数字属于原始值，复制后互不影响，因此本题表现得像完全独立的副本。如果元素是对象，两个数组相应位置仍可能保存同一个对象引用：向 b 推入新元素不会改变 a，但通过 b[0] 修改共享对象的内部属性，则可能从 a[0] 观察到同样变化。

选项判断

A：错误。只有直接执行 a.push(4)，或者让 b 与 a 指向同一数组后再执行 b.push(4)，原数组才会变成 [1, 2, 3, 4]。本题中 slice() 已创建新的外层数组。
B：正确。b.push(4) 只改变 b，所以 console.log(a) 输出 [1, 2, 3]。
C：错误。push(4) 是在 b 原有三个元素之后追加，而不是清空原内容再只保留 4；同时题目打印的是 a，不是 b。
D：错误。代码没有删除首个元素，也没有对 a 进行切片赋值或移动操作，因此不可能输出 [2, 3, 4]。

易错点

“返回新数组”只保证外层容器不是同一个对象，不代表嵌套内容被深度复制。可以用 a === b 验证两者为 false，但若元素是引用类型，a[0] === b[0] 仍可能为 true。另一个易错点是混淆 slice() 与 splice()：前者通常用于非破坏性地提取并返回新数组，后者会直接增删原数组元素。控制台在某些开发工具中还可能延迟展示对象的当前状态，但按程序执行语义，本题输出结论不受影响。

25:Ta69,

结论与机制

错误的是 D。Promise.all() 用于把一组输入聚合成一个新的 Promise：只有所有输入都成功兑现时，返回的 Promise 才会兑现；只要任意一个输入被拒绝，返回的 Promise 就会立即进入拒绝状态。兑现结果一定是一个数组，包含全部输入对应的结果，不能选择只返回其中一部分。结果数组严格保持输入顺序，而不是按照各异步任务完成的先后顺序排列。

需要补充的是，Promise.all(iterable) 的参数在规范意义上是可迭代对象，不仅限于数组；数组只是最常用的传参形式。题目将其表述为数组，应理解为常见使用场景。在此前提下，给定答案 D 成立。输入项也不要求全部已经是 Promise 实例：普通值会按已兑现结果处理，类 Promise 对象也会被同化。

选项判断

A：按本题语境判断为正确。实际调用中通常传入数组，例如由多个异步任务组成的数组。不过更严谨的说法是参数为可迭代对象，数组只是其中一种，因此不能把“必须是数组”理解为完整的规范定义。
B：正确。非空输入中的所有成员都兑现后，聚合结果才会兑现，随后通过 .then() 注册的成功回调才会被安排执行。普通值可视为已经兑现的输入。
C：正确。任何一个输入被拒绝，聚合结果都会以该拒绝原因进入拒绝状态；若调用链使用 .catch() 处理拒绝，就会执行对应回调。其他任务可能仍在运行，Promise.all() 本身不会自动取消它们。
D：错误。成功回调接收的是包含全部结果的数组，不存在由调用者决定只携带部分值的行为。例如三个输入全部兑现后，结果必然对应三个位置，即使某个位置的兑现值是 undefined，该位置仍然存在。

易错点

最容易混淆的是“完成顺序”和“结果顺序”：后发任务即使先完成，也不会改变结果数组的位置。另一个误区是认为一次拒绝会中止其他异步操作；它只会使聚合结果尽快拒绝，不具有取消网络请求、定时器或其他任务的能力。若业务允许部分任务失败并仍需收集全部结果，应考虑 Promise.allSettled()，而不是误以为 Promise.all() 可以只返回成功的部分。

26:T934,## 结论与机制正确答案是 `C`，三次输出依次为 `undefined`、`object`、`false`。字符串字面量 `''` 是原始值，不是开发者创建的字符串对象，但在访问其属性时，语言会进行临时装箱，使属性查找能够按类似对象的方式进行。因此访问 `''.__proto__` 时，可以通过装箱后的字符串包装对象关联到 `String.prototype`；该值是对象，`typeof` 的结果为 `"object"`。 `prototype` 与 `__proto__` 含义不同。`prototype` 通常是可构造函数自身拥有的属性，用来提供由该函数创建的实例所共享的原型对象；并非任意值或任意对象都天然拥有该属性。字符串原始值上没有名为 `prototype` 的可访问属性，其装箱对象及原型链也没有提供这个同名值，所以 `''.prototype` 得到 `undefined`。第三行先分别计算两个 `typeof`：左侧为字符串 `"object"`，右侧为字符串 `"undefined"`，两者严格比较得到 `false`。 ## 选项判断 - `A`：错误。`''.prototype` 不会得到对象，因此第一个结果不是 `object`；第三个比较也不会是 `true`。 - `B`：错误。第一个结果确实是 `undefined`，但 `''.__proto__` 可以取得字符串包装类型的原型对象，所以第二个结果不是 `undefined`，最终比较也不是 `true`。 - `C`：正确。`typeof ''.prototype` 为 `undefined`，`typeof ''.__proto__` 为 `object`，两个类型字符串不相等，因此第三行输出 `false`。 - `D`：错误。它把前两个结果颠倒了。`prototype` 不是字符串实例或原始值的通用属性，而 `__proto__` 在题目所假定的常见现代运行环境中可用于访问其原型关联。 ## 易错点不要把 `prototype` 理解成“所有对象的原型”。函数的 `prototype` 属性与对象的内部原型关联是不同层次的概念。更推荐用 `Object.getPrototypeOf()` 检查对象原型，因为 `__proto__` 是历史性的访问接口，不宜作为新代码操纵原型的首选方式。还要注意 `typeof null` 也会返回 `"object"`，所以仅凭 `typeof` 为 `"object"` 不能断言值一定是普通对象。本题还依赖支持 `__proto__` 访问器的常见运行环境；在极端的自定义环境或原型被修改的情况下，结果可能受影响，但不属于题目通常考查范围。27:Tba9,

结论与机制

正确答案是 C，三次输出依次为 undefined、object、false。字符串字面量 '' 是原始值，不是开发者创建的字符串对象，但在访问其属性时，语言会进行临时装箱，使属性查找能够按类似对象的方式进行。因此访问 ''.__proto__ 时，可以通过装箱后的字符串包装对象关联到 String.prototype；该值是对象，typeof 的结果为 "object"。

prototype 与 __proto__ 含义不同。prototype 通常是可构造函数自身拥有的属性，用来提供由该函数创建的实例所共享的原型对象；并非任意值或任意对象都天然拥有该属性。字符串原始值上没有名为 prototype 的可访问属性，其装箱对象及原型链也没有提供这个同名值，所以 ''.prototype 得到 undefined。第三行先分别计算两个 typeof：左侧为字符串 "object"，右侧为字符串 "undefined"，两者严格比较得到 false。

选项判断

A：错误。''.prototype 不会得到对象，因此第一个结果不是 object；第三个比较也不会是 true。
B：错误。第一个结果确实是 undefined，但 ''.__proto__ 可以取得字符串包装类型的原型对象，所以第二个结果不是 undefined，最终比较也不是 true。
C：正确。typeof ''.prototype 为 undefined，typeof ''.__proto__ 为 object，两个类型字符串不相等，因此第三行输出 false。
D：错误。它把前两个结果颠倒了。prototype 不是字符串实例或原始值的通用属性，而 __proto__ 在题目所假定的常见现代运行环境中可用于访问其原型关联。

易错点

不要把 prototype 理解成“所有对象的原型”。函数的 prototype 属性与对象的内部原型关联是不同层次的概念。更推荐用 Object.getPrototypeOf() 检查对象原型，因为 __proto__ 是历史性的访问接口，不宜作为新代码操纵原型的首选方式。还要注意 typeof null 也会返回 "object"，所以仅凭 typeof 为 "object" 不能断言值一定是普通对象。本题还依赖支持 __proto__ 访问器的常见运行环境；在极端的自定义环境或原型被修改的情况下，结果可能受影响，但不属于题目通常考查范围。

28:T9f4,## 结论与机制正确答案是 `E`，即调用事件对象的 `preventDefault()`。浏览器事件往往同时包含两类行为：一类是开发者注册的事件监听器，另一类是浏览器为某些元素或交互定义的默认操作。例如点击链接通常会触发导航，提交表单通常会发起提交，点击复选框通常会切换选中状态。监听器收到事件对象后调用 `event.preventDefault()`，表示当前事件的默认操作不应执行。阻止默认操作与阻止事件传播是两套彼此独立的机制。`stopPropagation()` 处理的是事件继续沿传播路径进入其他节点的问题，并不必然取消链接跳转或表单提交；`stopImmediatePropagation()` 除阻止后续传播外，还会阻止同一节点上尚未执行的其他监听器。是否能成功取消默认行为，还要看事件本身是否可取消以及监听器配置；可通过事件对象的 `cancelable` 判断。被配置为被动监听的回调中，调用 `preventDefault()` 通常不会产生预期效果。 ## 选项判断 - `A`：错误。`stopDeafault()` 不是标准事件对象方法，而且其中的单词拼写也不正确，调用它通常会得到“不是函数”的运行时错误。 - `B`：错误。`stopPropagation()` 是有效方法，但作用是阻止事件继续捕获或冒泡，不负责取消事件关联的默认操作。因此它不能作为本题答案。 - `C`：错误。`preventPropagation()` 不是标准事件对象接口，名称把“取消默认行为”和“阻止传播”两个概念混合在了一起。 - `D`：错误。`preventDefaultEven()` 不是标准方法；标准名称中没有末尾的 `Even`。实际开发必须使用准确的方法名。 - `E`：正确。`preventDefault()` 专门用于请求取消可取消事件的默认操作，例如在表单校验失败时阻止提交，或在自定义链接交互中阻止导航。 ## 易错点最常见误区是把 `preventDefault()` 与 `stopPropagation()` 当作同义操作：前者针对浏览器默认行为，后者针对事件传播路径，业务需要时可以同时调用。另一个误区是认为任何事件都能被取消；若 `event.cancelable` 为 `false`，调用也不能改变其默认结果。框架事件修饰符通常只是对这些原生机制的封装，不应因此忽略底层差异。此外，在某些旧式处理方式中返回 `false` 可能同时产生额外效果，但在原生 `addEventListener()` 回调中仅返回 `false` 并不能可靠替代 `preventDefault()`。29:Tb62,

结论与机制

正确答案是 E，即调用事件对象的 preventDefault()。浏览器事件往往同时包含两类行为：一类是开发者注册的事件监听器，另一类是浏览器为某些元素或交互定义的默认操作。例如点击链接通常会触发导航，提交表单通常会发起提交，点击复选框通常会切换选中状态。监听器收到事件对象后调用 event.preventDefault()，表示当前事件的默认操作不应执行。

阻止默认操作与阻止事件传播是两套彼此独立的机制。stopPropagation() 处理的是事件继续沿传播路径进入其他节点的问题，并不必然取消链接跳转或表单提交；stopImmediatePropagation() 除阻止后续传播外，还会阻止同一节点上尚未执行的其他监听器。是否能成功取消默认行为，还要看事件本身是否可取消以及监听器配置；可通过事件对象的 cancelable 判断。被配置为被动监听的回调中，调用 preventDefault() 通常不会产生预期效果。

选项判断

A：错误。stopDeafault() 不是标准事件对象方法，而且其中的单词拼写也不正确，调用它通常会得到“不是函数”的运行时错误。
B：错误。stopPropagation() 是有效方法，但作用是阻止事件继续捕获或冒泡，不负责取消事件关联的默认操作。因此它不能作为本题答案。
C：错误。preventPropagation() 不是标准事件对象接口，名称把“取消默认行为”和“阻止传播”两个概念混合在了一起。
D：错误。preventDefaultEven() 不是标准方法；标准名称中没有末尾的 Even。实际开发必须使用准确的方法名。
E：正确。preventDefault() 专门用于请求取消可取消事件的默认操作，例如在表单校验失败时阻止提交，或在自定义链接交互中阻止导航。

易错点

最常见误区是把 preventDefault() 与 stopPropagation() 当作同义操作：前者针对浏览器默认行为，后者针对事件传播路径，业务需要时可以同时调用。另一个误区是认为任何事件都能被取消；若 event.cancelable 为 false，调用也不能改变其默认结果。框架事件修饰符通常只是对这些原生机制的封装，不应因此忽略底层差异。此外，在某些旧式处理方式中返回 false 可能同时产生额外效果，但在原生 addEventListener() 回调中仅返回 false 并不能可靠替代 preventDefault()。

2a:T9a2,## 结论与机制正确答案是 `B`，`concat()` 不会改变调用它的原数组，而是创建并返回一个新数组。数组方法可以按是否直接修改原数组分为两类：`splice()`、`sort()`、`pop()` 等会对原数组内容或长度产生原地修改；`concat()`、`slice()`、`map()`、`filter()` 等通常返回新数组而保留原数组的外层结构。本题要求找出“不能改变自身数组”的方法，因此应选择 `concat()`。例如原数组为 `[1, 2]`，调用 `arr.concat([3])` 后，返回值是 `[1, 2, 3]`，但 `arr` 仍为 `[1, 2]`。这里的“不改变”指该方法本身不会把拼接结果写回原数组；如果开发者执行 `arr = arr.concat([3])`，变量随后指向新数组，看上去内容发生了变化，但这属于重新赋值，不是原数组对象被 `concat()` 原地修改。`concat()` 同样是浅层复制，引用类型元素可能在新旧数组之间共享。 ## 选项判断 - `A`：错误。`splice()` 会直接修改原数组，可以删除、替换或插入元素，并返回由被删除元素组成的新数组。即使只插入而不删除，原数组的内容和长度也会发生变化。 - `B`：正确。`concat()` 将当前数组与传入值合并，返回新的数组对象，调用它的数组本身保持不变。因此它符合题目要求。 - `C`：错误。`sort()` 默认会在原数组上重新排列元素并返回该数组自身的引用。即使排序后的可见顺序碰巧与原来相同，它仍被定义为原地排序方法，不能归入非修改方法。 - `D`：错误。`pop()` 会删除并返回数组最后一个元素，同时通常使原数组长度减一。空数组调用时虽然返回 `undefined` 且内容仍为空，但这不改变该方法总体上属于修改型方法的事实。 ## 易错点不要根据“方法有返回值”判断它是否修改原数组：`splice()`、`sort()` 和 `pop()` 都有返回值，但仍会改变调用对象。也不要把 `concat()` 的浅复制误认为深复制；若数组中包含对象，新数组与原数组可能仍引用同一内部对象，修改该对象的属性会同时被两边观察到。另一个边界是原数组被冻结时，`concat()` 因不需要写入原数组通常仍可生成新数组，而修改型方法可能因无法写入或删除属性而失败。判断方法类别时应关注其标准语义，而不是某个特殊输入下内容是否恰好没有变化。2b:Tb4b,

结论与机制

正确答案是 B，concat() 不会改变调用它的原数组，而是创建并返回一个新数组。数组方法可以按是否直接修改原数组分为两类：splice()、sort()、pop() 等会对原数组内容或长度产生原地修改；concat()、slice()、map()、filter() 等通常返回新数组而保留原数组的外层结构。本题要求找出“不能改变自身数组”的方法，因此应选择 concat()。

例如原数组为 [1, 2]，调用 arr.concat([3]) 后，返回值是 [1, 2, 3]，但 arr 仍为 [1, 2]。这里的“不改变”指该方法本身不会把拼接结果写回原数组；如果开发者执行 arr = arr.concat([3])，变量随后指向新数组，看上去内容发生了变化，但这属于重新赋值，不是原数组对象被 concat() 原地修改。concat() 同样是浅层复制，引用类型元素可能在新旧数组之间共享。

选项判断

A：错误。splice() 会直接修改原数组，可以删除、替换或插入元素，并返回由被删除元素组成的新数组。即使只插入而不删除，原数组的内容和长度也会发生变化。
B：正确。concat() 将当前数组与传入值合并，返回新的数组对象，调用它的数组本身保持不变。因此它符合题目要求。
C：错误。sort() 默认会在原数组上重新排列元素并返回该数组自身的引用。即使排序后的可见顺序碰巧与原来相同，它仍被定义为原地排序方法，不能归入非修改方法。
D：错误。pop() 会删除并返回数组最后一个元素，同时通常使原数组长度减一。空数组调用时虽然返回 undefined 且内容仍为空，但这不改变该方法总体上属于修改型方法的事实。

易错点

不要根据“方法有返回值”判断它是否修改原数组：splice()、sort() 和 pop() 都有返回值，但仍会改变调用对象。也不要把 concat() 的浅复制误认为深复制；若数组中包含对象，新数组与原数组可能仍引用同一内部对象，修改该对象的属性会同时被两边观察到。另一个边界是原数组被冻结时，concat() 因不需要写入原数组通常仍可生成新数组，而修改型方法可能因无法写入或删除属性而失败。判断方法类别时应关注其标准语义，而不是某个特殊输入下内容是否恰好没有变化。

2c:Ta6e,

结论与机制

正确选项是 B。Symbol 是基本数据类型，typeof s1 的结果为字符串 "symbol"，而不是 "object"。每次直接调用 Symbol('a') 都会创建一个全新的、唯一的符号值，括号中的描述文本只用于调试和展示，不会让描述相同的两个符号相等，因此 s1 == s2 为 false。相比之下，Symbol.for('b') 会访问全局符号注册表：第一次调用时创建并登记与键 b 对应的符号，第二次使用相同键时返回已登记的同一个符号，所以 s3 == s4 为 true。

虽然题目使用宽松相等运算符 ==，但这里比较的是两个符号值，不存在能使不同符号变成相同符号的常规类型转换，因此结果与使用严格相等运算符 === 一致。

选项分析

A 错误：①输出的是 "symbol"。符号属于基本数据类型，并不是普通对象，所以不会输出 "Object" 或 "object"。
B 正确：Symbol('a') 的两次调用分别产生两个不同的符号。即使描述都为 a，s1 与 s2 仍不相等，②输出 false。
C 错误：两次 Symbol.for('b') 使用同一个注册键，取得的是同一个符号值，所以③输出 true，不是 false。
D 错误：Symbol 不能作为构造函数通过 new Symbol() 调用，这样会抛出异常。创建符号应直接调用 Symbol()，但它创建的也是符号基本值，而不是所谓的“空对象”。

易错点

首先不要把符号的“描述”当作其身份标识，Symbol('x') === Symbol('x') 仍为 false。其次要区分 Symbol() 与 Symbol.for()：前者每次创建新值，后者按字符串键复用全局注册表中的值。再次，typeof 返回的是小写字符串 "symbol"。符号值虽然在某些场景下可以被包装为对象，但这不代表 Symbol() 本身返回对象，也不意味着可以使用 new。本题只需依据这些机制即可确定唯一正确项为 B。

2d:T457,

var s1 = Symbol('a');
var s2 = Symbol('a');
var s3 = Symbol.for('b');
var s4 = Symbol.for('b');
console.log(typeof s1); ...①
console.log(s1==s2); ...②
console.log(s3==s4); ...③

2e:Ta49,## 结论与机制点击该节点后输出 `true`，因此选择 `A`。 `new test()` 调用构造函数时，构造函数内部的 `this` 指向新创建的实例，并先执行 `this.flag = false`。随后创建箭头函数 `this.change = () => { ... }`。箭头函数没有自己的 `this`，它会词法捕获定义位置外层 `test` 调用中的 `this`，也就是刚刚创建的实例。于是 `button.change` 无论作为对象方法调用，还是作为事件监听器交给 `document.addEventListener()`，其函数体中的 `this` 都保持指向 `button`。点击时执行以下逻辑： ```js this.flag = true; console.log(button.flag); ``` 这里的 `this` 是 `button`，所以第一行把 `button.flag` 从 `false` 改成 `true`，下一行自然输出 `true`。题目描述称 `document` 是文档中的一个节点，但代码实际使用全局 `document` 注册监听器。只要事件能够传播到该监听目标并触发监听器，结论不受这一措辞影响。 ## 选项判断 - `A` 正确：箭头函数捕获构造函数执行时的实例 `this`。点击后执行 `this.flag = true`，实际修改的是 `button.flag`，因此打印 `true`。 - `B` 错误：`false` 只是实例初始化时的值。事件回调执行后，赋值语句先将该值更新为 `true`，打印发生在赋值之后，不会继续输出初始值。 - `C` 错误：`button` 对象在构造过程中已经创建了自有属性 `flag`，其初始值为 `false`。点击后该属性又被设为 `true`，因此不会是 `undefined`。 - `D` 错误：在正常浏览器环境中，`document` 具有 `addEventListener()`，`button.change` 也是可调用函数，事件发生时不会因为 `this` 丢失而报错。题目的执行前提是存在浏览器文档环境；若直接在没有 `document` 的非浏览器运行环境执行，则会出现 `ReferenceError`，但那不属于选项考查的事件回调语义。 ## 易错点最容易混淆的是普通函数事件监听器与箭头函数事件监听器的 `this`。若把回调改为普通函数： ```js this.change = function () { this.flag = true; console.log(button.flag); }; ``` 浏览器调用普通事件监听器时，回调中的 `this` 通常指向注册监听器的当前目标，也就是这里的 `document`。此时修改的是 `document.flag`，而 `button.flag` 仍为 `false`。箭头函数则不会根据调用方式重新绑定 `this`。另一个易错点是误以为 `addEventListener()` 会永久改变传入函数的 `this`；它只决定普通函数被调用时的上下文，无法覆盖箭头函数已经捕获的词法 `this`。2f:Tfe8,

结论与机制

点击该节点后输出 true，因此选择 A。

new test() 调用构造函数时，构造函数内部的 this 指向新创建的实例，并先执行 this.flag = false。随后创建箭头函数 this.change = () => { ... }。箭头函数没有自己的 this，它会词法捕获定义位置外层 test 调用中的 this，也就是刚刚创建的实例。于是 button.change 无论作为对象方法调用，还是作为事件监听器交给 document.addEventListener()，其函数体中的 this 都保持指向 button。

点击时执行以下逻辑：

this.flag = true;
console.log(button.flag);

这里的 this 是 button，所以第一行把 button.flag 从 false 改成 true，下一行自然输出 true。

题目描述称 document 是文档中的一个节点，但代码实际使用全局 document 注册监听器。只要事件能够传播到该监听目标并触发监听器，结论不受这一措辞影响。

选项判断

A 正确：箭头函数捕获构造函数执行时的实例 this。点击后执行 this.flag = true，实际修改的是 button.flag，因此打印 true。
B 错误：false 只是实例初始化时的值。事件回调执行后，赋值语句先将该值更新为 true，打印发生在赋值之后，不会继续输出初始值。
C 错误：button 对象在构造过程中已经创建了自有属性 flag，其初始值为 false。点击后该属性又被设为 true，因此不会是 undefined。
D 错误：在正常浏览器环境中，document 具有 addEventListener()，button.change 也是可调用函数，事件发生时不会因为 this 丢失而报错。题目的执行前提是存在浏览器文档环境；若直接在没有 document 的非浏览器运行环境执行，则会出现 ReferenceError，但那不属于选项考查的事件回调语义。

易错点

最容易混淆的是普通函数事件监听器与箭头函数事件监听器的 this。若把回调改为普通函数：

this.change = function () {
  this.flag = true;
  console.log(button.flag);
};

浏览器调用普通事件监听器时，回调中的 this 通常指向注册监听器的当前目标，也就是这里的 document。此时修改的是 document.flag，而 button.flag 仍为 false。箭头函数则不会根据调用方式重新绑定 this。另一个易错点是误以为 addEventListener() 会永久改变传入函数的 this；它只决定普通函数被调用时的上下文，无法覆盖箭头函数已经捕获的词法 this。

30:T471,

function test() {
  this.flag = false;
  this.change = () => {
    this.flag = true;
    console.log(button.flag);
  };
}
const button = new test();
document.addEventListener("click", button.change);

31:T9cd,## 结论与机制正确答案是 `C`。对象字面量创建的 `brand` 和 `price` 属性默认都是可写、可枚举、可配置的。第一次调用 `Object.defineProperty()` 新建 `id` 时只提供了 `value: 1`；对于通过该方法新建的数据属性，未明确给出的 `writable`、`enumerable`、`configurable` 均默认为 `false`。因此 `id` 存在于对象中，但不能被普通赋值修改、不会出现在枚举结果中，也不能被删除。第二次调用 `Object.defineProperty()` 是修改已经存在的 `price` 属性，并且只把 `configurable` 设为 `false`。未写出的描述符字段不会把原属性全部重置为 `false`，所以 `price` 原有的 `writable: true` 和 `enumerable: true` 得以保留。随后 `obj.price = 999` 能成功修改值，而 `delete obj.price` 因其不可配置而无法删除。在题目所示非严格模式语境中，删除失败静默返回 `false`；严格模式下则会抛出 `TypeError`，这是本题成立的重要执行前提。 ## 选项判断 - `A`：错误。`Object.keys(obj)` 只返回对象自身可枚举的字符串键。`brand` 与 `price` 可枚举，而 `id` 不可枚举，因此长度是 `2`，不是 `3`。 - `B`：错误。`for...in` 枚举对象及其原型链上的可枚举字符串属性。本例没有额外的相关原型属性，且 `id` 的 `enumerable` 为 `false`，所以循环只输出 `华为` 和 `1999`，不会输出 `1`。 - `C`：正确。`price` 仍然可写，所以被更新为 `999`；它不可配置，所以删除失败；`id` 虽不可枚举，但仍是对象自身真实存在的属性。因此从属性集合看，最终对象包含 `brand`、值为 `999` 的 `price` 以及值为 `1` 的 `id`。不同控制台可能弱化显示不可枚举属性，但不影响其存在性。 - `D`：错误。`configurable: false` 阻止删除 `price`，因此最终对象不能只剩 `brand` 和 `id`。 ## 易错点新建属性时描述符缺省值为 `false`，不等于修改已有属性时遗漏字段也会被重置。还要区分“对象中存在”和“能够枚举”：`id` 可由 `obj.id` 或 `Object.getOwnPropertyDescriptor()` 访问，只是不会出现在 `Object.keys()` 与本例的 `for...in` 中。`for...in` 还可能遍历原型链上的可枚举属性，而 `Object.keys()` 只看自身属性。最后，`configurable: false` 主要限制删除和重新配置，并不自动意味着 `writable: false`；本例的 `price` 正是可以改值但不能删除。32:Tccb,

结论与机制

正确答案是 C。对象字面量创建的 brand 和 price 属性默认都是可写、可枚举、可配置的。第一次调用 Object.defineProperty() 新建 id 时只提供了 value: 1；对于通过该方法新建的数据属性，未明确给出的 writable、enumerable、configurable 均默认为 false。因此 id 存在于对象中，但不能被普通赋值修改、不会出现在枚举结果中，也不能被删除。

第二次调用 Object.defineProperty() 是修改已经存在的 price 属性，并且只把 configurable 设为 false。未写出的描述符字段不会把原属性全部重置为 false，所以 price 原有的 writable: true 和 enumerable: true 得以保留。随后 obj.price = 999 能成功修改值，而 delete obj.price 因其不可配置而无法删除。在题目所示非严格模式语境中，删除失败静默返回 false；严格模式下则会抛出 TypeError，这是本题成立的重要执行前提。

选项判断

A：错误。Object.keys(obj) 只返回对象自身可枚举的字符串键。brand 与 price 可枚举，而 id 不可枚举，因此长度是 2，不是 3。
B：错误。for...in 枚举对象及其原型链上的可枚举字符串属性。本例没有额外的相关原型属性，且 id 的 enumerable 为 false，所以循环只输出 华为 和 1999，不会输出 1。
C：正确。price 仍然可写，所以被更新为 999；它不可配置，所以删除失败；id 虽不可枚举，但仍是对象自身真实存在的属性。因此从属性集合看，最终对象包含 brand、值为 999 的 price 以及值为 1 的 id。不同控制台可能弱化显示不可枚举属性，但不影响其存在性。
D：错误。configurable: false 阻止删除 price，因此最终对象不能只剩 brand 和 id。

易错点

新建属性时描述符缺省值为 false，不等于修改已有属性时遗漏字段也会被重置。还要区分“对象中存在”和“能够枚举”：id 可由 obj.id 或 Object.getOwnPropertyDescriptor() 访问，只是不会出现在 Object.keys() 与本例的 for...in 中。for...in 还可能遍历原型链上的可枚举属性，而 Object.keys() 只看自身属性。最后，configurable: false 主要限制删除和重新配置，并不自动意味着 writable: false；本例的 price 正是可以改值但不能删除。

33:T614,

var obj = {brand:'华为',price:1999};
Object.defineProperty(obj,'id',{value:1})
Object.defineProperty(obj,'price',{configurable:false})
console.log(Object.keys(obj).length); ...①
for (var k in obj){
    console.log(obj[k]); ...②
}
obj.price = 999;
delete obj['price']
console.log(obj); ...③

34:Te72,## 核心结论 `JSON` 和 `XML` 都是用于表示、交换或持久化结构化数据的文本格式，但它们的建模方式和适用场景不同。`JSON` 以对象、数组、字符串、数字、布尔值和 `null` 为核心，结构紧凑，与 `JavaScript` 对象字面量的表现形式接近，常用于前后端接口。`XML` 以元素、属性、文本、命名空间等机制描述文档，表达能力更偏向具有层级、混合文本和扩展语义的文档结构。不能简单断言一种格式在所有情况下都更优。选择时应结合数据性质、生态协议、校验要求、可读性、兼容性和安全成本。如果接口主要传递对象与数组，`JSON` 通常更加直接；如果需要命名空间、混合内容、成熟的文档转换或既有行业协议，`XML` 可能更合适。 ## 底层机制 `JSON` 的语法种类较少，解析后通常直接映射为语言中的对象、数组和原始值。例如： ```json { "name": "Ada", "skills": ["JavaScript", "CSS"], "active": true } ``` 在 `JavaScript` 中应使用 `JSON.parse()` 解析文本，使用 `JSON.stringify()` 序列化数据。不要使用 `eval()` 解析不可信内容，因为 `eval()` 会执行代码，而标准 `JSON` 解析器只接受相应的数据语法。 `XML` 通过成对标签、属性和文本节点形成树形文档： ```xml Ada JavaScript CSS ``` 解析后通常得到文档节点树，而不是直接得到普通业务对象。应用需要进一步遍历元素、属性和文本节点，或者通过特定映射规则转换数据。 ## 工程场景 `JSON` 常见于网页接口、配置文件、日志和消息传递，因为其语法简洁，主流语言都有成熟解析库。`XML` 常见于文档格式、构建工具配置、企业集成协议以及需要命名空间的场景。所谓 `XML` 更“重量级”，通常指相同结构下标签重复较多、解析模型更复杂，但具体体积和性能必须结合真实数据、压缩方式、解析器实现与网络环境测量，不能仅凭格式名称下结论。数据校验方面，`XML` 生态拥有成熟的模式描述能力；`JSON` 同样可以借助 `JSON Schema` 描述结构和约束。因此，“`JSON` 无法校验”或“`XML` 一定更具有描述性”都过于绝对。二者是否自描述，也取决于字段名、标签名和协议文档是否清晰。 ## 边界与误区 `JSON` 不支持注释，标准对象键必须使用双引号；它也不能原生保真表示 `Date`、`BigInt`、函数、循环引用或二进制数据，需要额外约定。数字还可能受目标语言精度限制。`XML` 支持属性、命名空间、处理指令和混合内容，但同一业务对象可能存在多种元素与属性映射方案。安全方面，两者都不能因“只是数据”而被盲目信任。解析 `JSON` 后仍需防范字段污染、超大载荷和业务校验缺失；解析不可信 `XML` 时应禁用不必要的外部实体和外部资源解析，以避免实体扩展、文件读取或网络访问等风险。具体能力取决于所用解析器配置。 ## 面试追问常见追问包括：为什么不能用 `eval()` 解析 `JSON`；`JSON.stringify()` 如何处理 `undefined`、函数和循环引用；大整数如何安全传输；`XML` 的元素与属性应该如何选取；命名空间解决什么问题；如何设计统一的接口校验；压缩开启后两者体积差距是否仍然明显。优秀回答不应只背诵“轻量与重量”，而应说明数据模型、工具生态、协议要求和安全边界。35:T1688,

核心结论

JSON 和 XML 都是用于表示、交换或持久化结构化数据的文本格式，但它们的建模方式和适用场景不同。JSON 以对象、数组、字符串、数字、布尔值和 null 为核心，结构紧凑，与 JavaScript 对象字面量的表现形式接近，常用于前后端接口。XML 以元素、属性、文本、命名空间等机制描述文档，表达能力更偏向具有层级、混合文本和扩展语义的文档结构。

不能简单断言一种格式在所有情况下都更优。选择时应结合数据性质、生态协议、校验要求、可读性、兼容性和安全成本。如果接口主要传递对象与数组，JSON 通常更加直接；如果需要命名空间、混合内容、成熟的文档转换或既有行业协议，XML 可能更合适。

底层机制

JSON 的语法种类较少，解析后通常直接映射为语言中的对象、数组和原始值。例如：

{
  "name": "Ada",
  "skills": ["JavaScript", "CSS"],
  "active": true
}

在 JavaScript 中应使用 JSON.parse() 解析文本，使用 JSON.stringify() 序列化数据。不要使用 eval() 解析不可信内容，因为 eval() 会执行代码，而标准 JSON 解析器只接受相应的数据语法。

XML 通过成对标签、属性和文本节点形成树形文档：

<user active="true">
  <name>Ada</name>
  <skills>
    <skill>JavaScript</skill>
    <skill>CSS</skill>
  </skills>
</user>

解析后通常得到文档节点树，而不是直接得到普通业务对象。应用需要进一步遍历元素、属性和文本节点，或者通过特定映射规则转换数据。

工程场景

JSON 常见于网页接口、配置文件、日志和消息传递，因为其语法简洁，主流语言都有成熟解析库。XML 常见于文档格式、构建工具配置、企业集成协议以及需要命名空间的场景。所谓 XML 更“重量级”，通常指相同结构下标签重复较多、解析模型更复杂，但具体体积和性能必须结合真实数据、压缩方式、解析器实现与网络环境测量，不能仅凭格式名称下结论。

数据校验方面，XML 生态拥有成熟的模式描述能力；JSON 同样可以借助 JSON Schema 描述结构和约束。因此，“JSON 无法校验”或“XML 一定更具有描述性”都过于绝对。二者是否自描述，也取决于字段名、标签名和协议文档是否清晰。

边界与误区

JSON 不支持注释，标准对象键必须使用双引号；它也不能原生保真表示 Date、BigInt、函数、循环引用或二进制数据，需要额外约定。数字还可能受目标语言精度限制。XML 支持属性、命名空间、处理指令和混合内容，但同一业务对象可能存在多种元素与属性映射方案。

安全方面，两者都不能因“只是数据”而被盲目信任。解析 JSON 后仍需防范字段污染、超大载荷和业务校验缺失；解析不可信 XML 时应禁用不必要的外部实体和外部资源解析，以避免实体扩展、文件读取或网络访问等风险。具体能力取决于所用解析器配置。

面试追问

常见追问包括：为什么不能用 eval() 解析 JSON；JSON.stringify() 如何处理 undefined、函数和循环引用；大整数如何安全传输；XML 的元素与属性应该如何选取；命名空间解决什么问题；如何设计统一的接口校验；压缩开启后两者体积差距是否仍然明显。优秀回答不应只背诵“轻量与重量”，而应说明数据模型、工具生态、协议要求和安全边界。

8:[["$","header",null,{"className":"learn-hero","children":["$","div",null,{"className":"learn-hero-inner mx-auto max-w-[1320px] px-4 sm:px-6","children":[["$","nav",null,{"className":"flex items-center gap-1.5 text-[12.5px]","style":{"color":"var(--learn-text-dim)"},"aria-label":"面包屑","children":[["$","$L1a",null,{"href":"/flashcards","className":"inline-flex items-center gap-1","children":[["$","svg",null,{"ref":"$undefined","xmlns":"http://www.w3.org/2000/svg","width":24,"height":24,"viewBox":"0 0 24 24","fill":"none","stroke":"currentColor","strokeWidth":2,"strokeLinecap":"round","strokeLinejoin":"round","className":"lucide lucide-chevron-left size-3.5","aria-hidden":true,"children":[["$","path","1wnfg3",{"d":"m15 18-6-6 6-6"}],"$undefined"]}],"知识卡片"]}],["$","span",null,{"aria-hidden":true,"children":"/"}],["$","$L1a",null,{"href":"/flashcards/javascript","children":"JavaScript 核心"}]]}],["$","div",null,{"className":"mt-4","children":["$","span",null,{"className":"learn-chip learn-chip-accent","children":[["$","svg",null,{"ref":"$undefined","xmlns":"http://www.w3.org/2000/svg","width":24,"height":24,"viewBox":"0 0 24 24","fill":"none","stroke":"currentColor","strokeWidth":2,"strokeLinecap":"round","strokeLinejoin":"round","className":"lucide lucide-braces size-3.5","aria-hidden":true,"children":[["$","path","ezmyqa",{"d":"M8 3H7a2 2 0 0 0-2 2v5a2 2 0 0 1-2 2 2 2 0 0 1 2 2v5c0 1.1.9 2 2 2h1"}],["$","path","e1hn23",{"d":"M16 21h1a2 2 0 0 0 2-2v-5c0-1.1.9-2 2-2a2 2 0 0 1-2-2V5a2 2 0 0 0-2-2h-1"}],"$undefined"]}],"JavaScript 核心"]}]}],["$","h1",null,{"className":"learn-title-mark mt-4 text-[27px] leading-[1.25] font-semibold tracking-tight sm:text-[34px]","children":"初级 17"}],["$","p",null,{"className":"mt-3 max-w-[640px] pl-4 text-[14.5px] leading-[1.8]","style":{"color":"var(--learn-text-dim)"},"children":"JavaScript 核心初级题库第 17 组，共 12 张卡片。"}],["$","dl",null,{"className":"learn-num mt-5 flex flex-wrap items-center gap-x-6 gap-y-2 text-[13px]","style":{"color":"var(--learn-text-dim)"},"children":[["$","div",null,{"className":"inline-flex items-center gap-1.5","children":[["$","svg",null,{"ref":"$undefined","xmlns":"http://www.w3.org/2000/svg","width":24,"height":24,"viewBox":"0 0 24 24","fill":"none","stroke":"currentColor","strokeWidth":2,"strokeLinecap":"round","strokeLinejoin":"round","className":"lucide lucide-layers size-3.5","aria-hidden":true,"children":[["$","path","zw3jo",{"d":"M12.83 2.18a2 2 0 0 0-1.66 0L2.6 6.08a1 1 0 0 0 0 1.83l8.58 3.91a2 2 0 0 0 1.66 0l8.58-3.9a1 1 0 0 0 0-1.83z"}],["$","path","1wduqc",{"d":"M2 12a1 1 0 0 0 .58.91l8.6 3.91a2 2 0 0 0 1.65 0l8.58-3.9A1 1 0 0 0 22 12"}],["$","path","kqbvx6",{"d":"M2 17a1 1 0 0 0 .58.91l8.6 3.91a2 2 0 0 0 1.65 0l8.58-3.9A1 1 0 0 0 22 17"}],"$undefined"]}],["$","dt",null,{"className":"sr-only","children":"卡片数"}],["$","dd",null,{"children":[12," 张卡"]}]]}],["$","div",null,{"className":"inline-flex items-center gap-1.5","children":[["$","svg",null,{"ref":"$undefined","xmlns":"http://www.w3.org/2000/svg","width":24,"height":24,"viewBox":"0 0 24 24","fill":"none","stroke":"currentColor","strokeWidth":2,"strokeLinecap":"round","strokeLinejoin":"round","className":"lucide lucide-clock3 lucide-clock-3 size-3.5","aria-hidden":true,"children":[["$","path","135r8i",{"d":"M12 6v6h4"}],["$","circle","1mglay",{"cx":"12","cy":"12","r":"10"}],"$undefined"]}],["$","dt",null,{"className":"sr-only","children":"预估时长"}],["$","dd",null,{"children":["约 ",14," 分钟"]}]]}],null]}]]}]}],["$","div",null,{"className":"mx-auto max-w-[1320px] px-4 pt-8 pb-16 sm:px-6","children":["$","div",null,{"className":"grid gap-6 lg:grid-cols-[minmax(0,1fr)_300px]","children":[["$","div",null,{"className":"max-w-[860px] min-w-0","children":[["$","$L21",null,{"node":{"id":"javascript-g1-17","trackKey":"javascript","title":"初级 17","summary":"JavaScript 核心初级题库第 17 组，共 12 张卡片。","prerequisites":[],"cardCount":12,"estimatedMinutes":14,"preview":false,"bankCategory":"JavaScript 核心","sourceType":"bank"},"trackTitle":"JavaScript 核心","cards":[{"id":"bank-6360507662332b4e003457cd5e1c414f","trackKey":"javascript","nodeId":"javascript-g1-17","type":"choice","difficulty":1,"prompt":"执行以下代码，输出结果为（）","promptDetail":"```js\nfunction test(a){\n a=a+10;\n}\nvar a=10;\ntest(a);\nconsole.log(a);\n```","hints":[],"answer":"正确选项是 A，程序最终输出 10。","keyPoints":["结论与机制","选项分析","C 错误：形参与外部变量同名是合法的作用域遮蔽，不会因此抛出异常；加法和赋值也都是合法操作。"],"explanation":"## 结论与机制\n\n正确选项是 **`A`**，程序最终输出 `10`。调用 `test(a)` 时，外部变量 `a` 当前保存数字 `10`。数字属于基本类型，实参求值后，该数值被传给函数形参 `a`。形参与外部变量虽然名称相同，但处于不同作用域，是两个彼此独立的变量绑定。函数体中的 `a = a + 10` 先读取局部形参的值 `10`，计算得到 `20`，再把 `20` 赋给局部形参；它没有对外层变量进行赋值，所以函数执行结束后，外层的 `a` 仍为 `10`。\n\n更准确地说，`JavaScript` 的参数传递采用按值传递。对于基本类型，传入的是基本值；对于对象，传入的也是值，只不过这个值是指向对象的引用。因此不能简单概括为“基本类型按值、对象按引用”，否则容易在其他题目中产生误判。\n\n## 选项分析\n\n- **`A` 正确**：函数内部修改的是局部形参 `a`，外部 `var a = 10` 对应的变量未被重新赋值，故 `console.log(a)` 输出 `10`。\n- **`B` 错误**：若函数体直接操作外部变量，或者函数返回计算结果后由外部执行 `a = test(a)`，才可能使外部值变为 `20`。本题没有这些操作。\n- **`C` 错误**：形参与外部变量同名是合法的作用域遮蔽，不会因此抛出异常；加法和赋值也都是合法操作。\n- **`D` 错误**：函数 `test` 确实没有显式返回值，调用表达式的结果是 `undefined`，但题目打印的不是调用结果，而是外部变量 `a`，所以不会输出 `undefined`。\n\n## 易错点\n\n一是要区分形参 `a` 与全局作用域中的 `a`，同名不代表同一个变量。二是要区分“函数返回值”和“被打印的变量”：`test(a)` 的返回值虽为 `undefined`，却没有被保存或打印。三是不要认为去掉形参就没有区别；如果函数写成 `function test(){ a = a + 10 }`，其中没有局部声明遮蔽外部变量，那么赋值目标才会变成外层 `a`，输出也会随之改变。","tags":["javascript"],"readMore":{"title":"在题库里看这道题","path":"/weapp-interview/6360507662332b4e003457cd5e1c414f"},"sourceType":"bank","sourcePath":"cloudbase://questionList/6360507662332b4e003457cd5e1c414f","sourceAnchor":"","sourceHash":"","generatorVersion":1,"contentVersion":1,"bankQuestionId":"6360507662332b4e003457cd5e1c414f","bankUpdateTime":"2022-03-17T12:36:30.205Z","options":[{"id":"a","text":"10","correct":true},{"id":"b","text":"20","correct":false},{"id":"c","text":"抛出异常","correct":false},{"id":"d","text":"undefined","correct":false}],"explanationHtml":"$22","promptHtml":"执行以下代码，输出结果为（）","promptDetailHtml":"

function test(a){\n    a=a+10;\n}\nvar a=10;\ntest(a);\nconsole.log(a);\n

","answerHtml":"正确选项是 A，程序最终输出 10。","hintsHtml":[],"keyPointsHtml":["结论与机制","选项分析","C 错误：形参与外部变量同名是合法的作用域遮蔽，不会因此抛出异常；加法和赋值也都是合法操作。"],"followUpHtml":"","followUpAnswerHtml":"","optionsHtml":{"a":"10","b":"20","c":"抛出异常","d":"undefined"}},{"id":"bank-6360507662345cb8005827883ac3379d","trackKey":"javascript","nodeId":"javascript-g1-17","type":"choice","difficulty":1,"prompt":"以下代码执行后，array 的结果是？","promptDetail":"```js\nlet array = [,1,,2,,3];\narray = array.map((i) => ++i)\n```","hints":[],"answer":"正确选项是 A，结果为 [, 2, , 3, , 4]。","keyPoints":["结论与机制","选项分析","A 正确：空槽保持在原索引位置，三个已有数字分别加一，得到 [, 2, , 3, , 4]。","C 错误：空槽没有作为数值 0 参与计算，也不会因前置自增自动变成 1。该选项错误地把空槽当成了可计算元素。"],"explanation":"## 结论与机制\n\n正确选项是 **`A`**，结果为 `[, 2, , 3, , 4]`。初始数组的长度是 `6`，但索引 `0`、`2`、`4` 处是空槽，并不是显式存放了 `undefined`。`Array.prototype.map` 只会对源数组中实际存在的索引调用回调函数，同时创建一个长度相同的新数组。源数组的空槽不会执行 `(i) => ++i`，并会在结果数组的相同位置继续保留为空槽；存在的元素 `1`、`2`、`3` 分别经过前置自增后变为 `2`、`3`、`4`。\n\n因此，回调实际只执行三次，而不是六次。前置自增 `++i` 修改的是每次回调中的局部参数并返回递增后的数值，它不会直接修改原数组元素；真正形成新结果的是 `map` 收集每次回调的返回值，并将新数组重新赋给变量 `array`。\n\n## 选项分析\n\n- **`A` 正确**：空槽保持在原索引位置，三个已有数字分别加一，得到 `[, 2, , 3, , 4]`。\n- **`B` 错误**：只有回调以 `undefined` 作为参数执行 `++i` 时，才可能产生 `NaN`。但 `map` 会跳过空槽，所以这些位置没有执行自增，也没有写入 `NaN`。\n- **`C` 错误**：空槽没有作为数值 `0` 参与计算，也不会因前置自增自动变成 `1`。该选项错误地把空槽当成了可计算元素。\n- **`D` 错误**：空槽不是 `null`，`map` 也不会自动把空槽填充为 `null`。某些序列化或展示操作可能让空槽看起来像空值，但不能据此改变数组内部结构。\n\n## 易错点\n\n空槽、显式的 `undefined` 和 `null` 是三种不同情况。例如 `[undefined].map(fn)` 会执行一次回调，而 `[,].map(fn)` 不会执行回调。不能笼统地说所有 `ES6` 数组方法都会把空槽当成 `undefined`：不同方法的处理行为并不完全一致。本题中的关键行为是 `map` 跳过空槽并在结果中保留对应空槽。还要注意开发者工具的展示形式可能不同，有的会显示 `empty`，但数组长度仍为 `6`，实际存在的索引仍只有 `1`、`3`、`5`。","tags":["javascript"],"readMore":{"title":"在题库里看这道题","path":"/weapp-interview/6360507662345cb8005827883ac3379d"},"sourceType":"bank","sourcePath":"cloudbase://questionList/6360507662345cb8005827883ac3379d","sourceAnchor":"","sourceHash":"","generatorVersion":1,"contentVersion":1,"bankQuestionId":"6360507662345cb8005827883ac3379d","bankUpdateTime":"2022-03-19T01:16:09.936Z","options":[{"id":"a","text":"[,2,,3,,4]","correct":true},{"id":"b","text":"[NaN,2,NaN,3,NaN,4]","correct":false},{"id":"c","text":"[1,2,1,3,1,4]","correct":false},{"id":"d","text":"[null,2,null,3,null,4]","correct":false}],"explanationHtml":"$23","promptHtml":"以下代码执行后，array 的结果是？","promptDetailHtml":"

let array = [,1,,2,,3];\narray = array.map((i) => ++i)\n

","answerHtml":"正确选项是 A，结果为 [, 2, , 3, , 4]。","hintsHtml":[],"keyPointsHtml":["结论与机制","选项分析","A 正确：空槽保持在原索引位置，三个已有数字分别加一，得到 [, 2, , 3, , 4]。","C 错误：空槽没有作为数值 0 参与计算，也不会因前置自增自动变成 1。该选项错误地把空槽当成了可计算元素。"],"followUpHtml":"","followUpAnswerHtml":"","optionsHtml":{"a":"[,2,,3,,4]","b":"[NaN,2,NaN,3,NaN,4]","c":"[1,2,1,3,1,4]","d":"[null,2,null,3,null,4]"}},{"id":"bank-63605076623ae5820141674973e048b0","trackKey":"javascript","nodeId":"javascript-g1-17","type":"recall","difficulty":1,"prompt":"promise和 async await 区别","hints":[],"answer":"Promise 是异步编程的一种解决方案，比传统的解决方案——回调函数和事件——更合理和更强大，简单地说，Promise好比容器，里面存放着一些未来才会…","keyPoints":["async await与Promise一样，是非阻塞的。","async await是基于Promise实现的，可以说是改良版的Promise，它不能用于普通的回调函数。"],"explanation":"**Promise** 是异步编程的一种解决方案，比传统的解决方案——回调函数和事件——更合理和更强大，简单地说，Promise好比容器，里面存放着一些未来才会执行完毕（异步）的事件的结果，而这些结果一旦生成是无法改变的\n\n**async await**也是异步编程的一种解决方案，他遵循的是Generator 函数的语法糖，他拥有内置执行器，不需要额外的调用直接会自动执行并输出结果，它返回的是一个Promise对象。\n\n\n\n**两者的区别**\n\n- Promise的出现解决了传统callback函数导致的“地域回调”问题，但它的语法导致了它向纵向发展行成了一个回调链，遇到复杂的业务场景，这样的语法显然也是不美观的。而async await代码看起来会简洁些，使得异步代码看起来像同步代码，await的本质是可以提供等同于”同步效果“的等待异步返回能力的语法糖，只有这一句代码执行完，才会执行下一句。\n- async await与Promise一样，是非阻塞的。\n- async await是基于Promise实现的，可以说是改良版的Promise，它不能用于普通的回调函数。","tags":["javascript"],"readMore":{"title":"在题库里看这道题","path":"/weapp-interview/63605076623ae5820141674973e048b0"},"sourceType":"bank","sourcePath":"cloudbase://questionList/63605076623ae5820141674973e048b0","sourceAnchor":"","sourceHash":"","generatorVersion":1,"contentVersion":1,"bankQuestionId":"63605076623ae5820141674973e048b0","bankUpdateTime":"2022-03-23T09:16:49.851Z","explanationHtml":"

Promise 是异步编程的一种解决方案，比传统的解决方案——回调函数和事件——更合理和更强大，简单地说，Promise好比容器，里面存放着一些未来才会执行完毕（异步）的事件的结果，而这些结果一旦生成是无法改变的

async await也是异步编程的一种解决方案，他遵循的是Generator 函数的语法糖，他拥有内置执行器，不需要额外的调用直接会自动执行并输出结果，它返回的是一个Promise对象。

两者的区别

Promise的出现解决了传统callback函数导致的“地域回调”问题，但它的语法导致了它向纵向发展行成了一个回调链，遇到复杂的业务场景，这样的语法显然也是不美观的。而async await代码看起来会简洁些，使得异步代码看起来像同步代码，await的本质是可以提供等同于”同步效果“的等待异步返回能力的语法糖，只有这一句代码执行完，才会执行下一句。
async await与Promise一样，是非阻塞的。
async await是基于Promise实现的，可以说是改良版的Promise，它不能用于普通的回调函数。

\n","promptHtml":"promise和 async await 区别","promptDetailHtml":"","answerHtml":"Promise 是异步编程的一种解决方案，比传统的解决方案——回调函数和事件——更合理和更强大，简单地说，Promise好比容器，里面存放着一些未来才会…","hintsHtml":[],"keyPointsHtml":["async await与Promise一样，是非阻塞的。","async await是基于Promise实现的，可以说是改良版的Promise，它不能用于普通的回调函数。"],"followUpHtml":"","followUpAnswerHtml":"","optionsHtml":{}},{"id":"bank-807102f6623333d0003bde585bbeeae6","trackKey":"javascript","nodeId":"javascript-g1-17","type":"choice","difficulty":1,"prompt":"执行以下程序，输出结果为（）","promptDetail":"```js\nvar a =[1,2,3];\nvar b = a.slice();\nb.push(4);\nconsole.log(a)\n```","hints":[],"answer":"正确答案是 B，最终输出原数组 [1, 2, 3]。","keyPoints":["结论与机制","选项判断","B：正确。b.push(4) 只改变 b，所以 console.log(a) 输出 [1, 2, 3]。","D：错误。代码没有删除首个元素，也没有对 a 进行切片赋值或移动操作，因此不可能输出 [2, 3, 4]。"],"explanation":"## 结论与机制\n\n正确答案是 `B`，最终输出原数组 `[1, 2, 3]`。不传参数调用数组的 `slice()`，等价于从起始位置复制到数组末尾，它会返回一个新的数组对象，不会在原数组上增加或删除元素。因此 `b` 与 `a` 是两个不同的数组引用。执行 `b.push(4)` 时，被修改的是新数组 `b`，其内容变为 `[1, 2, 3, 4]`；原数组 `a` 的长度和元素保持不变，所以打印 `a` 得到 `[1, 2, 3]`。\n\n需要精确理解的是，`slice()` 进行的是浅拷贝，而不是递归意义上的深拷贝。当前数组元素都是数字，数字属于原始值，复制后互不影响，因此本题表现得像完全独立的副本。如果元素是对象，两个数组相应位置仍可能保存同一个对象引用：向 `b` 推入新元素不会改变 `a`，但通过 `b[0]` 修改共享对象的内部属性，则可能从 `a[0]` 观察到同样变化。\n\n## 选项判断\n\n- `A`：错误。只有直接执行 `a.push(4)`，或者让 `b` 与 `a` 指向同一数组后再执行 `b.push(4)`，原数组才会变成 `[1, 2, 3, 4]`。本题中 `slice()` 已创建新的外层数组。\n- `B`：正确。`b.push(4)` 只改变 `b`，所以 `console.log(a)` 输出 `[1, 2, 3]`。\n- `C`：错误。`push(4)` 是在 `b` 原有三个元素之后追加，而不是清空原内容再只保留 `4`；同时题目打印的是 `a`，不是 `b`。\n- `D`：错误。代码没有删除首个元素，也没有对 `a` 进行切片赋值或移动操作，因此不可能输出 `[2, 3, 4]`。\n\n## 易错点\n\n“返回新数组”只保证外层容器不是同一个对象，不代表嵌套内容被深度复制。可以用 `a === b` 验证两者为 `false`，但若元素是引用类型，`a[0] === b[0]` 仍可能为 `true`。另一个易错点是混淆 `slice()` 与 `splice()`：前者通常用于非破坏性地提取并返回新数组，后者会直接增删原数组元素。控制台在某些开发工具中还可能延迟展示对象的当前状态，但按程序执行语义，本题输出结论不受影响。","tags":["javascript"],"readMore":{"title":"在题库里看这道题","path":"/weapp-interview/807102f6623333d0003bde585bbeeae6"},"sourceType":"bank","sourcePath":"cloudbase://questionList/807102f6623333d0003bde585bbeeae6","sourceAnchor":"","sourceHash":"","generatorVersion":1,"contentVersion":1,"bankQuestionId":"807102f6623333d0003bde585bbeeae6","bankUpdateTime":"2022-03-17T13:12:48.220Z","options":[{"id":"a","text":"[1,2,3,4]","correct":false},{"id":"b","text":"[1,2,3]","correct":true},{"id":"c","text":"[4]","correct":false},{"id":"d","text":"[2,3,4]","correct":false}],"explanationHtml":"$24","promptHtml":"执行以下程序，输出结果为（）","promptDetailHtml":"

var a =[1,2,3];\nvar b = a.slice();\nb.push(4);\nconsole.log(a)\n

","answerHtml":"正确答案是 B，最终输出原数组 [1, 2, 3]。","hintsHtml":[],"keyPointsHtml":["结论与机制","选项判断","B：正确。b.push(4) 只改变 b，所以 console.log(a) 输出 [1, 2, 3]。","D：错误。代码没有删除首个元素，也没有对 a 进行切片赋值或移动操作，因此不可能输出 [2, 3, 4]。"],"followUpHtml":"","followUpAnswerHtml":"","optionsHtml":{"a":"[1,2,3,4]","b":"[1,2,3]","c":"[4]","d":"[2,3,4]"}},{"id":"bank-82afc00a62332e00002983296f569793","trackKey":"javascript","nodeId":"javascript-g1-17","type":"choice","difficulty":1,"prompt":"下面关于Promise的all方法说法错误的是（）","hints":[],"answer":"错误的是 D。","keyPoints":["结论与机制","选项判断"],"explanation":"## 结论与机制\n\n错误的是 `D`。`Promise.all()` 用于把一组输入聚合成一个新的 `Promise`：只有所有输入都成功兑现时，返回的 `Promise` 才会兑现；只要任意一个输入被拒绝，返回的 `Promise` 就会立即进入拒绝状态。兑现结果一定是一个数组，包含全部输入对应的结果，不能选择只返回其中一部分。结果数组严格保持输入顺序，而不是按照各异步任务完成的先后顺序排列。\n\n需要补充的是，`Promise.all(iterable)` 的参数在规范意义上是可迭代对象，不仅限于数组；数组只是最常用的传参形式。题目将其表述为数组，应理解为常见使用场景。在此前提下，给定答案 `D` 成立。输入项也不要求全部已经是 `Promise` 实例：普通值会按已兑现结果处理，类 `Promise` 对象也会被同化。\n\n## 选项判断\n\n- `A`：按本题语境判断为正确。实际调用中通常传入数组，例如由多个异步任务组成的数组。不过更严谨的说法是参数为可迭代对象，数组只是其中一种，因此不能把“必须是数组”理解为完整的规范定义。\n- `B`：正确。非空输入中的所有成员都兑现后，聚合结果才会兑现，随后通过 `.then()` 注册的成功回调才会被安排执行。普通值可视为已经兑现的输入。\n- `C`：正确。任何一个输入被拒绝，聚合结果都会以该拒绝原因进入拒绝状态；若调用链使用 `.catch()` 处理拒绝，就会执行对应回调。其他任务可能仍在运行，`Promise.all()` 本身不会自动取消它们。\n- `D`：错误。成功回调接收的是包含全部结果的数组，不存在由调用者决定只携带部分值的行为。例如三个输入全部兑现后，结果必然对应三个位置，即使某个位置的兑现值是 `undefined`，该位置仍然存在。\n\n## 易错点\n\n最容易混淆的是“完成顺序”和“结果顺序”：后发任务即使先完成，也不会改变结果数组的位置。另一个误区是认为一次拒绝会中止其他异步操作；它只会使聚合结果尽快拒绝，不具有取消网络请求、定时器或其他任务的能力。若业务允许部分任务失败并仍需收集全部结果，应考虑 `Promise.allSettled()`，而不是误以为 `Promise.all()` 可以只返回成功的部分。","tags":["javascript"],"readMore":{"title":"在题库里看这道题","path":"/weapp-interview/82afc00a62332e00002983296f569793"},"sourceType":"bank","sourcePath":"cloudbase://questionList/82afc00a62332e00002983296f569793","sourceAnchor":"","sourceHash":"","generatorVersion":1,"contentVersion":1,"bankQuestionId":"82afc00a62332e00002983296f569793","bankUpdateTime":"2022-03-17T12:48:00.170Z","options":[{"id":"a","text":"promise.all(iterable)，参数是一个数组","correct":false},{"id":"b","text":"只有这个数组中的所有promise实例都resolve之后才会触发其返回的promise实例的then","correct":false},{"id":"c","text":"只要其中有任何一个promise实例被reject，那么最终的promise实例将触发catch","correct":false},{"id":"d","text":"触发then时可以只带上iterable参数中的部分值，也可以带所有值。","correct":true}],"explanationHtml":"$25","promptHtml":"下面关于Promise的all方法说法错误的是（）","promptDetailHtml":"","answerHtml":"错误的是 D。","hintsHtml":[],"keyPointsHtml":["结论与机制","选项判断"],"followUpHtml":"","followUpAnswerHtml":"","optionsHtml":{"a":"promise.all(iterable)，参数是一个数组","b":"只有这个数组中的所有promise实例都resolve之后才会触发其返回的promise实例的then","c":"只要其中有任何一个promise实例被reject，那么最终的promise实例将触发catch","d":"触发then时可以只带上iterable参数中的部分值，也可以带所有值。"}},{"id":"bank-82afc00a62345ad5004677382845cdc7","trackKey":"javascript","nodeId":"javascript-g1-17","type":"choice","difficulty":1,"prompt":"问以下JS代码输出结果是什么？","promptDetail":"```js\nconsole.log(typeof ''.prototype);\nconsole.log(typeof ''.__proto__); \nconsole.log(typeof ''.__proto__ === typeof ''.prototype); \n```","hints":[],"answer":"正确答案是 C，三次输出依次为 undefined、object、false。","keyPoints":["结论与机制","选项判断","A：错误。''.prototype 不会得到对象，因此第一个结果不是 object；第三个比较也不会是 true。"],"explanation":"$26","tags":["javascript"],"readMore":{"title":"在题库里看这道题","path":"/weapp-interview/82afc00a62345ad5004677382845cdc7"},"sourceType":"bank","sourcePath":"cloudbase://questionList/82afc00a62345ad5004677382845cdc7","sourceAnchor":"","sourceHash":"","generatorVersion":1,"contentVersion":1,"bankQuestionId":"82afc00a62345ad5004677382845cdc7","bankUpdateTime":"2022-03-18T10:11:32.809Z","options":[{"id":"a","text":"object、object、true","correct":false},{"id":"b","text":"undefined、undefined、true","correct":false},{"id":"c","text":"undefined、object、false","correct":true},{"id":"d","text":"object、undefined、false","correct":false}],"explanationHtml":"$27","promptHtml":"问以下JS代码输出结果是什么？","promptDetailHtml":"

console.log(typeof ''.prototype);\nconsole.log(typeof ''.__proto__); \nconsole.log(typeof ''.__proto__ === typeof ''.prototype); \n

","answerHtml":"正确答案是 C，三次输出依次为 undefined、object、false。","hintsHtml":[],"keyPointsHtml":["结论与机制","选项判断","A：错误。''.prototype 不会得到对象，因此第一个结果不是 object；第三个比较也不会是 true。"],"followUpHtml":"","followUpAnswerHtml":"","optionsHtml":{"a":"object、object、true","b":"undefined、undefined、true","c":"undefined、object、false","d":"object、undefined、false"}},{"id":"bank-d2fe6f2062332ad7003bb8d2714ed06b","trackKey":"javascript","nodeId":"javascript-g1-17","type":"choice","difficulty":1,"prompt":"在 JavaScript 中，用于阻止默认事件的默认操作的方法是","hints":[],"answer":"正确答案是 E，即调用事件对象的 preventDefault()。","keyPoints":["结论与机制","选项判断"],"explanation":"$28","tags":["javascript"],"readMore":{"title":"在题库里看这道题","path":"/weapp-interview/d2fe6f2062332ad7003bb8d2714ed06b"},"sourceType":"bank","sourcePath":"cloudbase://questionList/d2fe6f2062332ad7003bb8d2714ed06b","sourceAnchor":"","sourceHash":"","generatorVersion":1,"contentVersion":1,"bankQuestionId":"d2fe6f2062332ad7003bb8d2714ed06b","bankUpdateTime":"2022-03-17T12:34:31.638Z","options":[{"id":"a","text":"stopDeafault()","correct":false},{"id":"b","text":"stopPropagation()","correct":false},{"id":"c","text":"preventPropagation()","correct":false},{"id":"d","text":"preventDefaultEven()","correct":false},{"id":"e","text":"preventDefault()","correct":true}],"explanationHtml":"$29","promptHtml":"在 JavaScript 中，用于阻止默认事件的默认操作的方法是","promptDetailHtml":"","answerHtml":"正确答案是 E，即调用事件对象的 preventDefault()。","hintsHtml":[],"keyPointsHtml":["结论与机制","选项判断"],"followUpHtml":"","followUpAnswerHtml":"","optionsHtml":{"a":"stopDeafault()","b":"stopPropagation()","c":"preventPropagation()","d":"preventDefaultEven()","e":"preventDefault()"}},{"id":"bank-d2fe6f2062332cf5003c012b7912599d","trackKey":"javascript","nodeId":"javascript-g1-17","type":"choice","difficulty":1,"prompt":"下列哪个方法不能改变自身数组？","hints":[],"answer":"正确答案是 B，concat() 不会改变调用它的原数组，而是创建并返回一个新数组。","keyPoints":["结论与机制","选项判断","B：正确。concat() 将当前数组与传入值合并，返回新的数组对象，调用它的数组本身保持不变。因此它符合题目要求。"],"explanation":"$2a","tags":["javascript"],"readMore":{"title":"在题库里看这道题","path":"/weapp-interview/d2fe6f2062332cf5003c012b7912599d"},"sourceType":"bank","sourcePath":"cloudbase://questionList/d2fe6f2062332cf5003c012b7912599d","sourceAnchor":"","sourceHash":"","generatorVersion":1,"contentVersion":1,"bankQuestionId":"d2fe6f2062332cf5003c012b7912599d","bankUpdateTime":"2022-03-17T12:43:33.104Z","options":[{"id":"a","text":"splice","correct":false},{"id":"b","text":"concat","correct":true},{"id":"c","text":"sort","correct":false},{"id":"d","text":"pop","correct":false}],"explanationHtml":"$2b","promptHtml":"下列哪个方法不能改变自身数组？","promptDetailHtml":"","answerHtml":"正确答案是 B，concat() 不会改变调用它的原数组，而是创建并返回一个新数组。","hintsHtml":[],"keyPointsHtml":["结论与机制","选项判断","B：正确。concat() 将当前数组与传入值合并，返回新的数组对象，调用它的数组本身保持不变。因此它符合题目要求。"],"followUpHtml":"","followUpAnswerHtml":"","optionsHtml":{"a":"splice","b":"concat","c":"sort","d":"pop"}},{"id":"bank-d4107ab1623329b6003e77e36c4ddf2a","trackKey":"javascript","nodeId":"javascript-g1-17","type":"choice","difficulty":1,"prompt":"执行以下程序，下列选项中，说法正确的是（）","promptDetail":"```js\nvar s1 = Symbol('a');\nvar s2 = Symbol('a');\nvar s3 = Symbol.for('b');\nvar s4 = Symbol.for('b');\nconsole.log(typeof s1); ...①\nconsole.log(s1==s2); ...②\nconsole.log(s3==s4); ...③\n```","hints":[],"answer":"正确选项是 B。","keyPoints":["结论与机制","选项分析"],"explanation":"## 结论与机制\n\n正确选项是 **`B`**。`Symbol` 是基本数据类型，`typeof s1` 的结果为字符串 `\"symbol\"`，而不是 `\"object\"`。每次直接调用 `Symbol('a')` 都会创建一个全新的、唯一的符号值，括号中的描述文本只用于调试和展示，不会让描述相同的两个符号相等，因此 `s1 == s2` 为 `false`。相比之下，`Symbol.for('b')` 会访问全局符号注册表：第一次调用时创建并登记与键 `b` 对应的符号，第二次使用相同键时返回已登记的同一个符号，所以 `s3 == s4` 为 `true`。\n\n虽然题目使用宽松相等运算符 `==`，但这里比较的是两个符号值，不存在能使不同符号变成相同符号的常规类型转换，因此结果与使用严格相等运算符 `===` 一致。\n\n## 选项分析\n\n- **`A` 错误**：①输出的是 `\"symbol\"`。符号属于基本数据类型，并不是普通对象，所以不会输出 `\"Object\"` 或 `\"object\"`。\n- **`B` 正确**：`Symbol('a')` 的两次调用分别产生两个不同的符号。即使描述都为 `a`，`s1` 与 `s2` 仍不相等，②输出 `false`。\n- **`C` 错误**：两次 `Symbol.for('b')` 使用同一个注册键，取得的是同一个符号值，所以③输出 `true`，不是 `false`。\n- **`D` 错误**：`Symbol` 不能作为构造函数通过 `new Symbol()` 调用，这样会抛出异常。创建符号应直接调用 `Symbol()`，但它创建的也是符号基本值，而不是所谓的“空对象”。\n\n## 易错点\n\n首先不要把符号的“描述”当作其身份标识，`Symbol('x') === Symbol('x')` 仍为 `false`。其次要区分 `Symbol()` 与 `Symbol.for()`：前者每次创建新值，后者按字符串键复用全局注册表中的值。再次，`typeof` 返回的是小写字符串 `\"symbol\"`。符号值虽然在某些场景下可以被包装为对象，但这不代表 `Symbol()` 本身返回对象，也不意味着可以使用 `new`。本题只需依据这些机制即可确定唯一正确项为 `B`。","tags":["javascript"],"readMore":{"title":"在题库里看这道题","path":"/weapp-interview/d4107ab1623329b6003e77e36c4ddf2a"},"sourceType":"bank","sourcePath":"cloudbase://questionList/d4107ab1623329b6003e77e36c4ddf2a","sourceAnchor":"","sourceHash":"","generatorVersion":1,"contentVersion":1,"bankQuestionId":"d4107ab1623329b6003e77e36c4ddf2a","bankUpdateTime":"2022-03-17T12:29:41.754Z","options":[{"id":"a","text":"①式输出结果为Object","correct":false},{"id":"b","text":"②式输出结果为false","correct":true},{"id":"c","text":"③式输出结果为false","correct":false},{"id":"d","text":"创建Symbol空对象，可以使用new Symbol()或者Symbol()","correct":false}],"explanationHtml":"$2c","promptHtml":"执行以下程序，下列选项中，说法正确的是（）","promptDetailHtml":"$2d","answerHtml":"正确选项是 B。","hintsHtml":[],"keyPointsHtml":["结论与机制","选项分析"],"followUpHtml":"","followUpAnswerHtml":"","optionsHtml":{"a":"①式输出结果为Object","b":"②式输出结果为false","c":"③式输出结果为false","d":"创建Symbol空对象，可以使用new Symbol()或者Symbol()"}},{"id":"bank-d4107ab1623459b5006ba106481d81e3","trackKey":"javascript","nodeId":"javascript-g1-17","type":"choice","difficulty":1,"prompt":"假设document是HTML文档中的一个节点，点击该节点后会发生什么？","promptDetail":"```js\nfunction test() {\n this.flag = false;\n this.change = () => {\n this.flag = true;\n console.log(button.flag);\n };\n}\nconst button = new test();\ndocument.addEventListener(\"click\", button.change);\n```","hints":[],"answer":"点击该节点后输出 true，因此选择 A。","keyPoints":["结论与机制","选项判断"],"explanation":"$2e","tags":["javascript"],"readMore":{"title":"在题库里看这道题","path":"/weapp-interview/d4107ab1623459b5006ba106481d81e3"},"sourceType":"bank","sourcePath":"cloudbase://questionList/d4107ab1623459b5006ba106481d81e3","sourceAnchor":"","sourceHash":"","generatorVersion":1,"contentVersion":1,"bankQuestionId":"d4107ab1623459b5006ba106481d81e3","bankUpdateTime":"2022-03-18T10:06:45.238Z","options":[{"id":"a","text":"输出true","correct":true},{"id":"b","text":"输出false","correct":false},{"id":"c","text":"输出undefined","correct":false},{"id":"d","text":"报错","correct":false}],"explanationHtml":"$2f","promptHtml":"假设document是HTML文档中的一个节点，点击该节点后会发生什么？","promptDetailHtml":"$30","answerHtml":"点击该节点后输出 true，因此选择 A。","hintsHtml":[],"keyPointsHtml":["结论与机制","选项判断"],"followUpHtml":"","followUpAnswerHtml":"","optionsHtml":{"a":"输出true","b":"输出false","c":"输出undefined","d":"报错"}},{"id":"bank-efbc6d7162332d8d003c24b01797bb33","trackKey":"javascript","nodeId":"javascript-g1-17","type":"choice","difficulty":1,"prompt":"执行以下程序，下列选项中，说法正确的是（）","promptDetail":"```js\nvar obj = {brand:'华为',price:1999};\nObject.defineProperty(obj,'id',{value:1})\nObject.defineProperty(obj,'price',{configurable:false})\nconsole.log(Object.keys(obj).length); ...①\nfor (var k in obj){\n console.log(obj[k]); ...②\n}\nobj.price = 999;\ndelete obj['price']\nconsole.log(obj); ...③\n```","hints":[],"answer":"正确答案是 C。","keyPoints":["结论与机制","选项判断","D：错误。configurable: false 阻止删除 price，因此最终对象不能只剩 brand 和 id。"],"explanation":"$31","tags":["javascript"],"readMore":{"title":"在题库里看这道题","path":"/weapp-interview/efbc6d7162332d8d003c24b01797bb33"},"sourceType":"bank","sourcePath":"cloudbase://questionList/efbc6d7162332d8d003c24b01797bb33","sourceAnchor":"","sourceHash":"","generatorVersion":1,"contentVersion":1,"bankQuestionId":"efbc6d7162332d8d003c24b01797bb33","bankUpdateTime":"2022-10-13 20:31:09","options":[{"id":"a","text":"①式输出结果为3","correct":false},{"id":"b","text":"②式输出结果为华为 1999 1","correct":false},{"id":"c","text":"③式输出结果为{brand: '华为', price: 999, id: 1}","correct":true},{"id":"d","text":"③式输出结果为{brand: '华为', id: 1}","correct":false}],"explanationHtml":"$32","promptHtml":"执行以下程序，下列选项中，说法正确的是（）","promptDetailHtml":"$33","answerHtml":"正确答案是 C。","hintsHtml":[],"keyPointsHtml":["结论与机制","选项判断","D：错误。configurable: false 阻止删除 price，因此最终对象不能只剩 brand 和 id。"],"followUpHtml":"","followUpAnswerHtml":"","optionsHtml":{"a":"①式输出结果为3","b":"②式输出结果为华为 1999 1","c":"③式输出结果为{brand: '华为', price: 999, id: 1}","d":"③式输出结果为{brand: '华为', id: 1}"}},{"id":"bank-efbc6d71623ae147017147297b3eec79","trackKey":"javascript","nodeId":"javascript-g1-17","type":"recall","difficulty":1,"prompt":"json和xml数据的区别","hints":[],"answer":"JSON 和 XML 都是用于表示、交换或持久化结构化数据的文本格式，但它们的建模方式和适用场景不同。","keyPoints":["核心结论","底层机制","工程场景","边界与误区","面试追问"],"explanation":"$34","tags":["javascript"],"readMore":{"title":"在题库里看这道题","path":"/weapp-interview/efbc6d71623ae147017147297b3eec79"},"sourceType":"bank","sourcePath":"cloudbase://questionList/efbc6d71623ae147017147297b3eec79","sourceAnchor":"","sourceHash":"","generatorVersion":1,"contentVersion":1,"bankQuestionId":"efbc6d71623ae147017147297b3eec79","bankUpdateTime":"2022-03-23T08:58:46.742Z","explanationHtml":"$35","promptHtml":"json和xml数据的区别","promptDetailHtml":"","answerHtml":"JSON 和 XML 都是用于表示、交换或持久化结构化数据的文本格式，但它们的建模方式和适用场景不同。","hintsHtml":[],"keyPointsHtml":["核心结论","底层机制","工程场景","边界与误区","面试追问"],"followUpHtml":"","followUpAnswerHtml":"","optionsHtml":{}}]}],"$L36"]}],"$L37"]}]}],"$L38"]

执行以下代码，输出结果为（）

1执行以下代码，输出结果为（）

2以下代码执行后，array 的结果是？

3promise和 async await 区别

4执行以下程序，输出结果为（）

5下面关于Promise的all方法说法错误的是（ ）

6问以下JS代码输出结果是什么？

7在 JavaScript 中，用于阻止默认事件的默认操作的方法是

8下列哪个方法不能改变自身数组？

9执行以下程序，下列选项中，说法正确的是（）

10假设document是HTML文档中的一个节点，点击该节点后会发生什么？

11执行以下程序，下列选项中，说法正确的是（）

12json和xml数据的区别