JavaScript 技能的测验问答

朱雀 2020-06-29 14:20 577阅读 0赞

刷题是我们提高自己技术的一种好方法。下面的问题很有挑战性和“指导性”。如果你知道该怎样回答，那意味着自己的水平很好，但是如果你发现自己答错了，并能够搞清楚**为什么**错，我认为那会更好！

**1. 数组排序比较**

看以下数组，在各种排序操作后都下输出什么？

```javascript
const arr1 = ['a', 'b', 'c'];
const arr2 = ['b', 'c', 'a'];
 
console.log(
  arr1.sort() === arr1,
  arr2.sort() == arr2,
  arr1.sort() === arr2.sort()
);
```

**答案和解析**

**答案：** true, true, false

这里有几个概念在起作用。首先，array 的 `sort` 方法对原始数组进行排序，并返回对该数组的引用。这意味着当你调用 `arr2.sort()` 时，`arr2` 数组内的对象将会被排序。

当你比较对象时，数组的排序顺序并不重要。由于 `arr1.sort()` 和 `arr1` 指向内存中的同一对象，因此第一个相等测试返回 `true`。第二个比较也是如此：`arr2.sort()` 和 arr2 指向内存中的同一对象。

在第三个测试中，`arr1.sort()` 和 `arr2.sort()` 的排序顺序相同；但是，它们指向内存中的不同对象。因此，第三个测试的评估结果为 `false`。

**2. set 的对象**

把下面的 `Set` 对象转成一个新的数组，最后输出什么？

```javascript
const mySet = new Set([{ a: 1 }, { a: 1 }]);
const result = [...mySet];
console.log(result);
```

**答案和解析**

**答案：** `[{a: 1}, {a: 1}]`

尽管 Set 对象确实会删除重复项，但是我们用 Set 创建的两个值是对内存中不同对象的引用，尽管它们有相同的键值对。这与 `{ a: 1 } === { a: 1 }` 的结果为 `false` 的原因相同。

如果集合是用对象变量创建的，例如 `obj = {a: 1}`，`new Set([obj，obj])` 将会只有一个元素，因为数组中的两个元素都引用了内存中的同一对象。

**3. 深层对象的可变性**

下面的对象代表用户 Joe 和他的狗 Buttercup。我们用 `Object.freeze` 保存对象，然后尝试更改 Buttercup 的 name。最后会输出什么？

```javascript
const user = {
  name: 'Joe',
  age: 25,
  pet: {
    type: 'dog',
    name: 'Buttercup',
  },
};
 
Object.freeze(user);
 
user.pet.name = 'Daffodil';
 
console.log(user.pet.name);
```

**答案和解析**

**答案：**Daffodil

`Object.freeze` 将会使对象浅冻结，但不会保护深层属性不被修改。在这个例子中，不能对 `user.age` 进行修改，但是对 `user.pet.name` 进行修改却没有问题。如果我们觉得需要保护一个对象，避免其“从头到尾”发生改变，则可以递归地应用 `Object.freeze` 或使用现有的“深度冻结”库。

**4. 原型继承**

在下面的代码中，有一个 `Dog` 构造函数。我们的 dog 显然有 speak 这个操作。当我们调用 Pogo 的 speak 时，会输出什么？

```javascript
function Dog(name) {
  this.name = name;
  this.speak = function() {
    return 'woof';
  };
}
 
const dog = new Dog('Pogo');
 
Dog.prototype.speak = function() {
  return 'arf';
};
 
console.log(dog.speak());
```

**答案和解析**

**答案：**woof

每次创建一个新的 `Dog` 实例时，我们都会将该实例的 `speak` 属性设置为返回字符串 `woof` 的函数。由于每次我们创建一个新的`Dog`实例时都要设置该值，因此解释器不会沿着原型链去找 `speak` 属性。结果就不会使用 `Dog.prototype.speak` 上的 `speak` 方法。

**5. Promise.all 的解决顺序**

在这个问题中，我们有一个 `timer` 函数，它返回一个 `Promise` ，该 Promise 在随机时间后解析。我们用`Promise.all` 解析一系列的 `timer`。最后的输出是什么，是随机的吗？

```javascript
const timer = a => {
  return new Promise(res =>
    setTimeout(() => {
      res(a);
    }, Math.random() * 100)
  );
};
 
const all = Promise.all([timer('first'), timer('second')]).then(data =>
  console.log(data)
);
```

**答案和解析**

**答案：** `["first", "second"]`

Promise 解决的顺序与 Promise.all 无关。我们能够可靠地依靠它们按照数组参数中提供的相同顺序返回。

**6. Reduce 数学**

数学时间！输出什么？

```javascript
const arr = [x => x * 1, x => x * 2, x => x * 3, x => x * 4];
 
console.log(arr.reduce((agg, el) => agg + el(agg), 1));
```

**答案和解析**

**答案：** 120

使用 `Array#reduce` 时，聚合器的初始值（在此称为 `agg`）在第二个参数中给出。在这种情况下，该值为`1`。然后可以如下迭代函数：

1 + 1 * 1 = 2（下一次迭代中聚合器的值）

2 + 2 * 2 = 6（下一次迭代中聚合器的值）

6 + 6 * 3 = 24（下一次迭代中聚合器的值）

24 + 24 * 4 = 120（最终值）

因此它是 120。

**7. 短路通知（Short-Circuit Notification(s)）**

让我们向用户显示一些通知。以下代码段输出了什么？

```javascript
const notifications = 1;
 
console.log(
  `You have ${notifications} notification${notifications !== 1 && 's'}`
);
```

**答案和解析**

**答案：**“You have 1 notificationfalse”

不幸的是，我们的短路评估将无法按预期工作： `notifications !== 1 && 's'` 评估为 `false`，这意味着我们实际上将会输出 `You have 1 notificationfalse`。如果希望代码段正常工作，则可以考虑条件运算符：`${notifications === 1 ? '' : 's'}`。

**8. 展开操作和重命名**

查看以下代码中有单个对象的数组。当我们扩展该数组并更改 0 索引对象上的 `firstname` 属性时会发生什么？

```javascript
const arr1 = [{ firstName: 'James' }];
const arr2 = [...arr1];
arr2[0].firstName = 'Jonah';
 
console.log(arr1);
```

**答案和解析**

**答案：** `[{ firstName: "Jonah" }]`

展开操作符会创建数组的浅表副本，这意味着 `arr2` 中包含的对象与 `arr1` 所指向的对象相同。所以在一个数组中修改对象的 `firstName` 属性，也将会在另一个数组中更改。

**9. 数组方法绑定**

在以下情况下会输出什么？

```javascript
const map = ['a', 'b', 'c'].map.bind([1, 2, 3]);
map(el => console.log(el));
```

**答案和解析**

**答案：** 1 2 3

当 `['a', 'b', 'c'].map` 被调用时，将会调用 `this'` 值为 `'['a'，'b'，'c']` 的 `Array.prototype.map`。但是当用作 `引用` 时， `Array.prototype.map` 的引用。