Partagez 10 questions et réponses de quiz pour améliorer vos compétences JavaScript

Les questions d'emballage sont pour nous un bon moyen d'améliorer nos compétences. Les questions ci-dessous sont stimulantes et constituent des « conseils ». Si vous savez comment y répondre, cela signifie que vous êtes plutôt bon, mais si vous vous trompez et que vous pouvez comprendre pourquoi c'est faux, je pense que c'est encore mieux !

Apprentissage recommandé : Tutoriel vidéo JavaScript , Tutoriel js (image et texte)

1 . Comparaison du tri des tableaux

Regardez le tableau suivant, quel est le résultat après diverses opérations de tri ?

const arr1 = ['a', 'b', 'c'];
const arr2 = ['b', 'c', 'a'];

console.log(
  arr1.sort() === arr1,
  arr2.sort() == arr2,
  arr1.sort() === arr2.sort()
);

Réponse et analyse

Réponse : vrai, vrai, faux

Plusieurs concepts sont en jeu ici. Tout d'abord, la méthode sort du tableau trie le tableau d'origine et renvoie une référence au tableau. Cela signifie que lorsque vous appelez arr2.sort(), les objets du tableau arr2 seront triés.

Lorsque vous comparez des objets, l'ordre de tri des tableaux n'a pas d'importance. Puisque arr1.sort() et arr1 pointent vers le même objet en mémoire, le premier test d'égalité renvoie true. Il en va de même pour la deuxième comparaison : arr2.sort() et arr2 pointent vers le même objet en mémoire.

Dans le troisième test, l'ordre de tri de arr1.sort() et arr2.sort() est le même ; cependant, ils pointent vers des objets différents en mémoire. Par conséquent, le résultat de l'évaluation du troisième test est false.

2. Définir l'objet

Convertissez l'objet Set suivant en un nouveau tableau, quel est le résultat final ?

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

Réponse et analyse

Réponse : [{a: 1}, {a: 1}]

Bien que les objets Set suppriment les doublons, les deux valeurs que nous créons avec Set sont des références à différents objets en mémoire, même si elles ont la même paire clé-valeur. C'est la même raison pour laquelle { a: 1 } === { a: 1 } donne false.

Si la collection est créée avec une variable objet, telle que obj = {a: 1}, new Set([obj，obj]) n'aura qu'un seul élément car les deux éléments du tableau font référence au même objet en mémoire.

3. Mutabilité des objets profonds

Les objets ci-dessous représentent l'utilisateur Joe et son chien Buttercup. Nous sauvegardons l'objet avec Object.freeze puis essayons de changer le nom de Buttercup. Quel sera le résultat final ?

const user = {
  name: 'Joe',
  age: 25,
  pet: {
    type: 'dog',
    name: 'Buttercup',
  },
};

Object.freeze(user);

user.pet.name = 'Daffodil';

console.log(user.pet.name);

Réponse et analyse

Réponse : Jonquille

Object.freeze Gèlera superficiellement l'objet, mais ne protégera pas les propriétés profondes contre la modification. Dans cet exemple, user.age ne peut pas être modifié, mais user.pet.name peut être modifié sans problème. Si nous pensons que nous devons protéger un objet contre toute modification "de haut en bas", nous pouvons appliquer Object.freeze de manière récursive ou utiliser une bibliothèque "deep freeze" existante.

4. Héritage prototypique

Dans le code ci-dessous, il y a un constructeur Dog. Notre chien a évidemment l'opération de parole. Quel est le résultat lorsque nous appelons le discours de Pogo ?

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());

Réponse et analyse

Réponse : woof

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

5. Promise.all 的解决顺序

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

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 数学

数学时间！输出什么？

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)）

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

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 属性时会发生什么？

const arr1 = [{ firstName: 'James' }];
const arr2 = [...arr1];
arr2[0].firstName = 'Jonah';

console.log(arr1);

答案和解析

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

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

9. 数组方法绑定

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

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 的引用。

Function.prototype.bind 会将函数的 this 绑定到第一个参数（在本例中为 [1, 2, 3]），用 this 调用Array.prototype.map 将会导致这些项目被迭代并输出。

10. set 的唯一性和顺序

在下面的代码中，我们用 set 对象和扩展语法创建了一个新数组，最后会输出什么？

const arr = [...new Set([3, 1, 2, 3, 4])];
console.log(arr.length, arr[2]);

答案和解析

答案： 4  2

set 对象会强制里面的元素唯一（集合中已经存在的重复元素将会被忽略），但是不会改变顺序。所以 arr 数组的内容是 [3，1，2，4]， arr.length 为 4，且 arr[2]（数组的第三个元素）为 2。

英文原文地址：https://typeofnan.dev/10-javascript-quiz-questions-and-answers/

作者：Nick Scialli

想要获取炫酷的页面特效，可访问：js代码特效 栏目！！

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!