7 questions d'entretien JavaScript pour se débarrasser du faux et conserver le vrai

Les 7 questions d'entretien JavaScript suivantes que vous devriez poser avant l'entretien. Sinon, votre temps sera probablement perdu.
1. Quelles sont les deux manières de créer des objets JavaScript ?
C'est une question très simple si vous avez déjà utilisé JavaScript. Vous devez connaître au moins un moyen. Mais malgré cela, d'après mon expérience, il y a aussi beaucoup de gens qui prétendent être des programmeurs JavaScript et qui disent ne pas savoir comment répondre à cette question.

• Utilisez le mot-clé "new" pour appeler la fonction.

• ouvrir/fermer les accolades.

var o = {};
Vous pouvez également continuer à demander : « Quand le nouveau mot-clé crée-t-il un objet ? Cependant, puisque je veux juste éliminer certaines personnes, J'attendrai donc l'entretien proprement dit pour poser ces questions.

Articles connexes recommandés : La collection la plus complète de questions d'entretien js en 2020 (dernière)

2. Comment créer un tableau ?
C'est le même niveau de question que "comment créer un objet". Cependant, certaines personnes peuvent également répondre à la première question mais ne peuvent pas répondre à celle-ci.
Utilisez le code suivant pour créer un tableau simplement :
var myArray = new Array();
Créer un tableau est un processus très compliqué. Mais j'aimerais entendre les réponses des candidats qui utilisent des crochets.
var myArray = [];
Bien sûr, on peut continuer à se poser d'autres questions, comme comment supprimer efficacement les éléments en double dans les tableaux JavaScript, etc., mais comme il suffit de savoir si le candidat en vaut la peine d'observation plus approfondie, je terminerai ici la question des tableaux.

Parlons de la façon de supprimer efficacement les éléments en double dans les tableaux JavaScript : 5 méthodes pour implémenter la déduplication de tableau dans js.

Introduction à la méthode spécifique :
1). Méthode de parcours de tableau
La méthode la plus simple pour supprimer les doublons : créez un nouveau tableau, parcourez le tableau entrant et ajoutez la valeur si ce n'est pas le cas. dans le nouveau tableau. Dans le nouveau tableau ; Remarque : La méthode "indexOf" pour déterminer si la valeur est dans le tableau est une méthode ECMAScript5. Elle n'est pas prise en charge sous IE8. navigateurs. Le code source est le suivant :

// 最简单数组去重法
function unique1(array){
 var n = []; //一个新的临时数组
 //遍历当前数组
 for(var i = 0; i < array.length; i++){
  //如果当前数组的第i已经保存进了临时数组，那么跳过，
  //否则把当前项push到临时数组里面
  if (n.indexOf(array[i]) == -1) n.push(array[i]);
 }
 return n;
}
// 判断浏览器是否支持indexOf ，indexOf 为ecmaScript5新方法 IE8以下（包括IE8， IE8只支持部分ecma5）不支持
if (!Array.prototype.indexOf){
 // 新增indexOf方法
 Array.prototype.indexOf = function(item){
  var result = -1, a_item = null;
  if (this.length == 0){
   return result;
  }
  for(var i = 0, len = this.length; i < len; i++){
   a_item = this[i];
   if (a_item === item){
    result = i;
    break;
   }
  }
  return result;
 }
}

2) Méthode d'appariement clé-valeur d'objet
Cette méthode s'exécute plus rapidement que toute autre méthode, mais elle prend plus de mémoire en implémentation ; idée : créez un nouvel objet js et un nouveau tableau, et lors du parcours du tableau entrant, jugez si la valeur est la clé de l'objet js, sinon, ajoutez la clé à l'objet et placez-la dans un nouveau tableau. Remarque : lors de la détermination s'il s'agit d'une clé d'objet js, "toString()" sera automatiquement exécuté sur la clé entrante. Différentes clés peuvent être confondues avec la même ; par exemple : a[1], a["1"]. Pour résoudre le problème ci-dessus, vous devez toujours appeler "indexOf".

// 速度最快， 占空间最多（空间换时间）
function unique2(array){
 var n = {}, r = [], len = array.length, val, type;
  for (var i = 0; i < array.length; i++) {
    val = array[i];
    type = typeof val;
    if (!n[val]) {
      n[val] = [type];
      r.push(val);
    } else if (n[val].indexOf(type) < 0) {
      n[val].push(type);
      r.push(val);
    }
  }
  return r;
}

3). La méthode de jugement d'index de tableau
doit encore appeler "indexOf". Les performances sont similaires à la méthode 1. L'idée d'implémentation : si le i-ème élément de. le tableau actuel est dans le tableau actuel. Si la position qui apparaît une fois n'est pas i, cela signifie que le i-ième élément est répété et ignoré. Sinon, stockez le tableau de résultats.

function unique3(array){
 var n = [array[0]]; //结果数组
 //从第二项开始遍历
 for(var i = 1; i < array.length; i++) {
  //如果当前数组的第i项在当前数组中第一次出现的位置不是i，
  //那么表示第i项是重复的，忽略掉。否则存入结果数组
  if (array.indexOf(array[i]) == i) n.push(array[i]);
 }
 return n;
}

4) Méthode de suppression adjacente après tri
Bien que les résultats du tri de la méthode "tri" des tableaux natifs ne soient pas très fiables, il n'y a aucun inconvénient dans la déduplication qui ne le fait pas. attention à la commande. Aucun impact. Idée d'implémentation : triez le tableau entrant de manière à ce que les mêmes valeurs soient adjacentes après le tri, puis lors du parcours, ajoutez uniquement les valeurs qui ne sont pas des doublons de la valeur précédente au nouveau tableau.

// 将相同的值相邻，然后遍历去除重复值
function unique4(array){
 array.sort();
 var re=[array[0]];
 for(var i = 1; i < array.length; i++){
  if( array[i] !== re[re.length-1])
  {
   re.push(array[i]);
  }
 }
 return re;
}

5) La méthode d'optimisation de traversée de tableau
provient d'articles de blog étrangers. Le code d'implémentation de cette méthode est plutôt sympa : obtenez la valeur la plus à droite sans duplication et mettez-la. dans un nouveau tableau. (Lorsque des valeurs en double sont détectées, la boucle actuelle est terminée et le prochain cycle de jugement de la boucle de niveau supérieur est entré)

// 思路：获取没重复的最右一值放入新数组
function unique5(array){
 var r = [];
 for(var i = 0, l = array.length; i < l; i++) {
  for(var j = i + 1; j < l; j++)
   if (array[i] === array[j]) j = ++i;
  r.push(array[i]);
 }
 return r;
}

3.
Cette question est un peu plus difficile, et je n'exige pas que l'autre partie y réponde. Cependant, cette question est un moyen rapide de déterminer les compétences techniques d’un candidat : ​​comprend-il vraiment le langage de programmation aussi bien qu’il le prétend ?
La promotion de variable signifie que peu importe où une variable est déclarée dans une portée, le moteur JavaScript déplacera cette déclaration en haut de la portée. Si vous déclarez une variable au milieu d'une fonction, par exemple en attribuant une variable dans une certaine ligne :

function foo()
{
 // 此处省略若干代码
 var a = "abc";
}

, le code s'exécutera en fait comme ceci :

function foo()
{
 var a;
 // 此处省略若干代码
 a = "abc";
}

4. Quels sont les risques des variables globales et comment puis-je protéger mon code des interférences ?
Le danger avec les variables globales est que quelqu'un d'autre peut créer une variable avec le même nom, puis écraser la variable que vous utilisez. C'est un casse-tête dans n'importe quelle langue.
Il existe de nombreuses façons de l’éviter. La méthode la plus courante consiste à créer une variable globale qui contient toutes les autres variables :
var applicationName = {};
Ensuite, chaque fois que vous avez besoin de créer une variable globale, attachez-la simplement à l'objet.
applicationName.myVariable = "abc";
Une autre méthode consiste à encapsuler tout le code dans une fonction exécutée automatiquement, afin que toutes les variables déclarées soient déclarées dans le cadre de la fonction.

(function(){
 var a = "abc";
})();

在现实中，这两种方法你可能都会用到。
5.如何通过JavaScript对象中的成员变量迭代？

for(var prop in obj){
 // bonus points for hasOwnProperty
 if(obj.hasOwnProperty(prop)){
  // do something here
 }
}

6.什么是闭包（Closure）？
闭包允许一个函数定义在另一个外部函数的作用域内，即便作用域内的其他东西都消失了，它仍可以访问该外部函数内的变量。如果应聘者能够说明，在for/next循环中使用闭包却不声明变量来保存迭代变量当前值的一些风险，那就应该给对方加分。
7.请描述你经历过的JavaScript单元测试。
关于这个问题，其实我们只是想看看应聘人员是否真的做过JavaScript单元测试。这是一个开放式问题，没有特定的正确答案，不过对方至少得能讲述进程中的一些事情。

相关学习推荐：javascript视频教程