10 questions d'entretien JavaScript fréquemment posées par les développeurs (avec analyse des réponses)

Cet article présente les 10 questions d'entretien JavaScript les plus fréquemment posées par les débutants. Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer. J'espère qu'il sera utile aux débutants.

Dans cet article, j'ai rassemblé les 10 questions les plus fréquemment posées sur Javascript et leurs réponses.

La plupart de ces 10 questions concernent les bases de Javascript, donc si vous commencez tout juste à apprendre JS, il est préférable de les comprendre et de les maîtriser.

Ces 10 questions impliquent la fermeture, la promesse, la promotion variable, la classe, etc. en JS. Même si ces questions ne sont pas très difficiles à apprendre, il est bon de connaître les réponses, car certaines d'entre elles sont souvent posées lors des entretiens. [Apprentissage recommandé : Tutoriel avancé Javascript]

Qu'est-ce que la fermeture en Javascript ?

Une fermeture est une combinaison de fonctions enfermées ensemble, où la fonction interne peut accéder à ses variables et aux variables de la fonction externe.

La façon la plus simple de l'expliquer est l'exemple ci-dessus :

function outer() {
  var name = 'Maria';
  function inner() {
    console.log(name);
  }
  inner();
}
outer();
// 'Maria'

Dans le code ci-dessus, vous pouvez voir que la fonction inner() peut accéder à sa variable de fonction parent name. Donc si la fonction outer() est appelée, alors le inner() de la fonction console.log() renverra la valeur name de Maria.

Les fonctions internes peuvent accéder aux objets paramètres de fonction externes, mais les paramètres de fonction internes sont les mêmes que les paramètres externes, donc l'objet paramètre interne écrasera l'objet paramètre externe. Cela ressemble à ceci :

function outer(a, b) {
  const inner = (a, b) => console.log(a, b);
  inner(1, 2);
}
outer('Alice', 'Mark');
// returns 1, 2

La principale raison pour laquelle nous utilisons des fermetures est de renvoyer des fonctions qui peuvent renvoyer d'autres fonctions.

Qu'est-ce que DOM en Javascript

DOM est le modèle objet de document, qui est une représentation orientée objet du site Web et peut être modifié à l'aide de Javascript.

Utilisez JS pour manipuler les éléments du DOM, tels que la couleur, la position, la taille. Pour sélectionner des éléments spécifiques de la page, Javascript propose quelques méthodes :

• getElementById() - Sélectionnez un élément via l'attribut id
• getElementsByName () - sélectionne un élément via l'attribut name
• getElementsByTagName() - sélectionne tous les éléments de la balise sélectionnée,
• getElementsbyClassName () - Sélectionnez tous les éléments avec un nom de classe spécifique

*　querySelector() - Sélectionnez les éléments via des sélecteurs CSS.

Javascript fournit également d'autres méthodes de manipulation d'éléments, pas seulement pour obtenir des éléments, comme appendChild() ou innerHTML().

Qu'est-ce que la promesse de Javascript ?

Promise est une solution de programmation asynchrone qui peut remplacer les solutions traditionnelles - fonctions de rappel et événements. ES6 unifie l'utilisation et fournit l'objet Promise de manière native. En tant qu'objet, Promise présente les deux caractéristiques suivantes : (1) L'état de l'objet n'est pas affecté par le monde extérieur. (2) Une fois que l'état change, il ne changera pas, c'est-à-dire que Promise n'a qu'un seul état à la fois.

La promesse a trois états, à savoir : En attente (en cours), Résolue (terminée), Rejetée (échouée). La promesse part de l'état Pending. Si elle réussit, elle passe à l'état de réussite et exécute la fonction de rappel resolve ; si elle échoue, elle passe à l'état d'échec et exécute la fonction de rappel reject.

Si la promesse est résolue, nous pouvons appeler la méthode then() et utiliser la valeur de retour pour effectuer l'opération. En cas de rejet, nous pouvons utiliser la méthode catch() pour gérer l'erreur.

D'autres façons de gérer la programmation asynchrone sont async/await et callbacks.

Qu'est-ce que le prototype en Javascript ?

Le prototype fait généralement référence aux deux objets prototypes prototype et __proto__, dont le premier est appelé le prototype explicite Objet,Ce dernier est appelé objet prototype implicite.

Les objets Javascript héritent des méthodes et propriétés du prototype, tandis que Object.prototype se situe au sommet de la chaîne d'héritage. Le mot-clé prototype Javascript peut également être utilisé pour ajouter de nouvelles valeurs et méthodes au constructeur.

Regardons l'exemple :

function Animal(name, kind, age) {
  this.name = name;
  this.kind = kind;
  this.age = age;
}

Animal.prototype.ownerName('Mark');

Comme vous pouvez le voir, en utilisant le prototype, nous pouvons ajouter l'attribut ownerName au constructeur Animal().

Qu'est-ce que le levage de variables en Javascript

Le levage est un mécanisme qui hisse toutes les variables et fonctions déclarées vers leur portée locale Si les variables et les fonctions sont placés dans le périmètre global, ils seront promus au sommet du périmètre global.

En Javascript, vous pouvez déclarer une variable après son utilisation. La

La promotion est utilisée pour éviter les undefined erreurs causées par l'exécution de variables ou de fonctions avant qu'elles ne soient définies.

name = 'Ted';
console.log(name);
var name;
// 'Ted'


var name;
name = 'Ted';
console.log(name);
// 'Ted';

使用 var 声明的变量，如果没有赋值，则默认会被初始化为 undefined, let 和 const 则不会。另外，需要注意的是，在声明const时，必须同时初始化它，因为后面不可在更改它。

Javascript中的对象是什么

对象只是一种特殊的数据。对象拥有属性和方法。JavaScript 中的所有事物都是对象，如:字符串、数值、数组、函数等。

对象的属性：反映该对象某些特定的性质的，如：字符串的长度、图像的长宽等；

对象的方法：能够在对象上执行的动作。例如，表单的“提交”(Submit)，时间的“获取”(getYear)等；

属性只是简单的值，而方法是可以在对象上执行的操作。

var student = {
  firstName: 'Alice',
  lastName: 'Jones',
  age: 21,
  sayHi: () => {
    return 'Hi, I am ' + this.firstName;
  }
}

在上面的代码中，你可以看到Student对象，其中包含三个属性和一个方法。

Javascript 中的函数是什么

在javascript中函数是一段可以被执行或调用任意次数的JavasScript代码,在数据类型中属于"function"。函数也拥有属性和方法，因此函数也是对象。

在Javascript中函数定义函数声明或函数表达式由关键字function开始。在定义函数时，可以在函数名后面的括号中添加一些参数。当我们调用函数时，括号中传递的值称为参数。

function calculate(x, y) {
  return x * y;
}

calculate(2, 5);

Javascript中的纯函数是什么

如果函数的调用参数相同，则永远返回相同的结果。它不依赖于程序执行期间函数外部任何状态或数据的变化，必须只依赖于其输入参数。

顾名思义，纯函数跟我们初中数学的基本函数一样，遵循一定的映射关系，输入决定输出，一个输入只能对应一个输出。不同的输入可以有相同的输出，但是相同的输入不能有不同的输出

一个函数，如果符合以下两个特点，那么它就可以称之为 纯函数：

• 对于相同的输入，永远得到相同的输出
• 没有任何可观察到的副作用

Javascript中的构造函数是什么

构造函数是一种特殊的方法，用于初始化和创建 Javascript 类中的对象。

JavaScript 中的构造函数和其它语言中的构造函数是不同的。 通过 new 关键字方式调用的函数都被认为是构造函数。

在构造函数内部，this 指向新创建的对象 Object。 这个新创建的对象的 prototype 被指向到构造函数的 prototype。

如果被调用的函数没有显式的 return 表达式，则隐式的会返回 this 对象，也就是新创建的对象。

const Person = (name, age) => {
  this.name = name;
  this.age = age;
}

var man = new Person('Mark', 23);
console.log(man);
// { name: 'Mark', age: 23 }

在上面的代码中，我创建了一个Person构造函数，在下面的代码中，创建了一个名为man的新变量，并基于Person构造函数创建了一个新对象。

Javascript类是什么？

自从 ES6 引入以来，我们可以在Javascript中使用类。 类是一种函数，我们使用关键字class代替function 关键字来初始化它。

除此之外，我们还必须在类内部添加constructor()方法，该方法在每次初始化类时都会调用。

在constructor()方法内部，我们添加了类的属性。 要基于现有的类创建另一个类，我们可以使用extends关键字。

在JavaScript中使用类的一个很好的例子是 React 框架，它是类的组件。

总结

在本文中，我收集了开发者经常问的 10 个Javascript问题，并给出答案，答案不是唯一，这里只是自己的一些见解，希望本文能给初学者带来一些帮助。

原文地址：https://dev.to/duomly/10-most-common-javascript-questions-answered-1083

作者：Duomly

更多编程相关知识，请访问：编程视频！！

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!