Questions d'entretien technique javascript les plus difficiles et les plus difficiles avec des solutions.

Bonjour ! Je m'appelle Vishal Tiwari et je vais vous proposer quelques questions d'entretien javascript difficiles.

1. Quel sera le résultat du code suivant ?

console.log(typeof null); // Output?

Répondre:

Sortie :objet

Explication : Il s'agit d'une bizarrerie bien connue en JavaScript. L'opérateur typeof renvoie « objet » lorsqu'il est appliqué à null, même si null n'est pas un objet. Ce comportement est dû à la façon dont JavaScript a été implémenté et a été conservé pour des raisons de compatibilité descendante.

---

2. Quel sera le résultat du code suivant ?

console.log(0.1 + 0.2 === 0.3); // Output?

Répondre:

Sortie : faux

Explication : En raison du fonctionnement de l'arithmétique à virgule flottante en JavaScript (et dans de nombreux langages de programmation), 0,1 0,2 n'est pas précisément égal à 0,3. Au lieu de cela, le résultat est 0,30000000000000004, ce qui fait que la comparaison renvoie faux.

---

3. Quel sera le résultat du code suivant ?

const a = {};
const b = { key: 'b' };
const c = { key: 'c' };

a[b] = 123; // What happens here?
console.log(a[b]); // Output?

Répondre:

Sortie : 123

Explication : Lorsque vous essayez de définir une propriété sur un objet en utilisant un autre objet comme clé (a[b]), JavaScript convertit l'objet b en chaîne, ce qui entraîne "[object Object ]". Ainsi, vous définissez essentiellement la propriété "[object Object]" sur 123, et lorsque vous enregistrez a[b], elle renvoie 123.

---

4. Quel sera le résultat du code suivant ?

const arr = [1, 2, 3];
arr[10] = 11;
console.log(arr.length); // Output?

Répondre:

Sortie : 11

Explication : Lorsque vous attribuez une valeur à un index qui est plus grande que la longueur actuelle du tableau (comme arr[10] = 11), JavaScript crée des "emplacements vides" dans le tableau pour le indices de 3 à 9. Cependant, la propriété length du tableau reflète l'indice le plus élevé plus un, qui dans ce cas est 11.

---

5. Quel sera le résultat du code suivant ?

let x = 1;
let y = 2;

const obj = {
    x: 10,
    y: 20,
    sum: function() {
        return this.x + this.y;
    }
};

console.log(obj.sum()); // Output?
console.log(obj.sum.call({ x: 100, y: 200 })); // Output?
console.log(obj.sum.apply({ x: 1000, y: 2000 })); // Output?

Répondre:

Sortie :

• Premier console.log : 30
• Deuxième console.log : 300
• Troisième console.log : 3000

Explication :

• obj.sum() utilise le contexte this d'obj, il ajoute donc 10 et 20, renvoyant 30.
• obj.sum.call({ x : 100, y : 200 }) utilise la méthode d'appel pour changer cela en un nouvel objet avec des valeurs x et y de 100 et 200, respectivement, renvoyant 300.
• obj.sum.apply({ x : 1000, y : 2000 }) fait la même chose avec apply, renvoyant 3000.

---

6. Quel sera le résultat du code suivant ?

console.log(1 + '1'); // Output?
console.log(1 - '1'); // Output?

Répondre:

Sortie :

• Premier console.log : '11'
• Deuxième console.log : 0

Explication :

• Dans 1 '1', JavaScript effectue une coercition de type, convertissant le nombre 1 en chaîne, ce qui donne '11'.
• Dans 1 - '1', JavaScript convertit la chaîne '1' en nombre, ce qui donne 1 - 1, ce qui équivaut à 0.

---

7. Quel sera le résultat du code suivant ?

console.log(typeof null); // Output?

Répondre:

Sortie : La sortie dépendra du contexte dans lequel foo est appelé, mais si c'est dans le contexte global, il enregistrera l'objet global (fenêtre dans les navigateurs ou global dans Node.js).

Explication : Dans les fonctions fléchées, this est lié lexicalement, ce qui signifie qu'il utilise la valeur this du contexte environnant. Si foo est appelé dans la portée globale, cela fera référence à l'objet global.

---

8. Quel sera le résultat du code suivant ?

console.log(0.1 + 0.2 === 0.3); // Output?

Répondre:

Sortie :

• Premier console.log : 1
• Deuxième console.log : 2
• Troisième console.log : 2
• Quatrième console.log : 1
• Cinquième console.log : 1

Explication : La fonction createCounter crée une fermeture qui maintient sa propre variable de comptage. Chaque méthode (incrément, décrément, getCount) accède et modifie la même variable de comptage, offrant un comportement cohérent.

---

9. Quel sera le résultat du code suivant ?

const a = {};
const b = { key: 'b' };
const c = { key: 'c' };

a[b] = 123; // What happens here?
console.log(a[b]); // Output?

Répondre:

Sortie : [99, 2, 3]

Explication : En JavaScript, les tableaux (comme tous les objets) sont des types référence. Lorsque b est affecté à a, les deux variables pointent vers le même tableau en mémoire. Ainsi, modifier b affecte a.

---

10. Quel sera le résultat du code suivant ?

const arr = [1, 2, 3];
arr[10] = 11;
console.log(arr.length); // Output?

Répondre:

Sortie : 3

Explication : Dans cet exemple, la fonction interne a sa propre variable a, qui masque la variable a dans la fonction externe. Lorsque console.log(a) est appelé dans inner, il fait référence au a défini dans inner, qui est 3.

11. Quel sera le résultat du code suivant ?

let x = 1;
let y = 2;

const obj = {
    x: 10,
    y: 20,
    sum: function() {
        return this.x + this.y;
    }
};

console.log(obj.sum()); // Output?
console.log(obj.sum.call({ x: 100, y: 200 })); // Output?
console.log(obj.sum.apply({ x: 1000, y: 2000 })); // Output?

Répondre:

Sortie : { a : 1, b : 3, c : 4 >

Explication : La méthode Object.assign() copie les valeurs de toutes les propriétés énumérables d'un ou plusieurs objets source (obj1 et obj2) vers un objet cible (un objet vide {}). Si la même propriété existe dans plusieurs objets source, la dernière est prioritaire. Par conséquent, b : 3 de obj2 écrase b : 2 de obj1.

---

12. Quel sera le résultat du code suivant ?

console.log(1 + '1'); // Output?
console.log(1 - '1'); // Output?

Répondre:

Sortie : non définie

Explication : JavaScript insère automatiquement un point-virgule après l'instruction return s'il y a un saut de ligne. Par conséquent, il est interprété comme return;, qui renvoie undefined. Pour renvoyer l'objet, vous devez mettre l'accolade ouvrante { sur la même ligne que le mot-clé return.

---

13. Quel sera le résultat du code suivant ?

console.log(typeof null); // Output?

Répondre:

Sortie : non définie

Explication : La variable x à l'intérieur de la fonction foo est hissée mais pas initialisée jusqu'à l'affectation var x = 2;. Ainsi, lorsque console.log(x); s'exécute, le x local est déclaré mais pas encore attribué, donc il génère un résultat indéfini.

---

14. Quel sera le résultat du code suivant ?

console.log(0.1 + 0.2 === 0.3); // Output?

Répondre:

Sortie :99

Explication : a et b font tous deux référence au même tableau en mémoire. Lorsque vous modifiez b[0], vous modifiez également a[0] car ils font tous deux référence au même tableau.

---

15. Quel sera le résultat du code suivant ?

const a = {};
const b = { key: 'b' };
const c = { key: 'c' };

a[b] = 123; // What happens here?
console.log(a[b]); // Output?

Répondre:

• Premier console.log : "123"
• Deuxième console.log : "33"

Explication :

• Dans 1 "2" "3", JavaScript convertit 1 en chaîne et concatène, ce qui donne "12" puis "123".
• Dans 1 2 "3", JavaScript évalue d'abord 1 2, qui est égal à 3 (un nombre), puis concatène "3", ce qui donne "33".

---

16. Quel sera le résultat du code suivant ?

const arr = [1, 2, 3];
arr[10] = 11;
console.log(arr.length); // Output?

Répondre:

Sortie : []

Explication : Définir la propriété length d'un tableau sur 0 efface effectivement le tableau. Par conséquent, arr est maintenant un tableau vide.

---

17. Quel sera le résultat du code suivant ?

let x = 1;
let y = 2;

const obj = {
    x: 10,
    y: 20,
    sum: function() {
        return this.x + this.y;
    }
};

console.log(obj.sum()); // Output?
console.log(obj.sum.call({ x: 100, y: 200 })); // Output?
console.log(obj.sum.apply({ x: 1000, y: 2000 })); // Output?

Répondre:

Sortie :2

Explication : La fonction interne, lorsqu'elle est appelée, a sa propre variable qui est 2. Lorsque vous appelez innerFunc(), elle enregistre 2 puisqu'elle fait référence à la variable locale a dans inner.

---

18. Quel sera le résultat du code suivant ?

console.log(1 + '1'); // Output?
console.log(1 - '1'); // Output?

Répondre:

Sortie : 3

Explication : La méthode c est appelée sur l'obj, donc ceci à l'intérieur de la méthode fait référence à obj. Ainsi, il génère la somme de obj.a et obj.b, qui est 3.

---

19. Quel sera le résultat du code suivant ?

const foo = () => {
    console.log(this);
};

foo(); // Output?

Répondre:

• Premier console.log : faux
• Deuxième console.log : vrai

Explication :

• La première instruction renvoie false en raison de problèmes de précision en virgule flottante (0,1 0,2 est égal à 0,30000000000000004).
• La deuxième instruction arrondit 0,1 0,2 à 0,3 avec toFixed(1) et le reconvertit en nombre, ce qui donne une comparaison de 0,3 === 0,3, ce qui est vrai.

---

20. Quel sera le résultat du code suivant ?

console.log(typeof null); // Output?

Répondre:

Sortie : objet global (ou non défini en mode strict)

Explication : En mode non strict, la valeur de this à l'intérieur d'une fonction appelée dans le contexte global est l'objet global (c'est-à-dire, fenêtre dans les navigateurs ou global dans Node.js). En mode strict, cela ne serait pas défini.

21. Quel sera le résultat du code suivant ?

console.log(0.1 + 0.2 === 0.3); // Output?

Répondre:

• Premier console.log : 2
• Deuxième console.log : 1

Explication :

• Object.assign(obj3, obj2) copie les propriétés de obj2 vers obj3, donc obj3.a devient 2.
• obj3.__proto__ fait référence à obj1, qui a la propriété a avec la valeur 1.

---

22. Quel sera le résultat du code suivant ?

const a = {};
const b = { key: 'b' };
const c = { key: 'c' };

a[b] = 123; // What happens here?
console.log(a[b]); // Output?

Répondre:

Sortie : 3

Explication : Dans la fonction interne, a fait référence à la variable définie dans la fonction externe. Lorsque inner est appelé, a est incrémenté de 2 à 3 et enregistré.

---

23. Quel sera le résultat du code suivant ?

const arr = [1, 2, 3];
arr[10] = 11;
console.log(arr.length); // Output?

Répondre:

Sortie : Bonjour, mon nom n'est pas défini

Explication : Lorsque greet est appelé sans contexte (c'est-à-dire pas en tant que méthode de personne), cela n'est pas lié à la personne. En mode non strict, la valeur par défaut est l'objet global, et comme le nom n'est pas défini sur l'objet global, il n'est pas défini.

---

24. Quel sera le résultat du code suivant ?

let x = 1;
let y = 2;

const obj = {
    x: 10,
    y: 20,
    sum: function() {
        return this.x + this.y;
    }
};

console.log(obj.sum()); // Output?
console.log(obj.sum.call({ x: 100, y: 200 })); // Output?
console.log(obj.sum.apply({ x: 1000, y: 2000 })); // Output?

Répondre:

• Premier console.log : vrai
• Deuxième console.log : vrai

Explication :

• Pour console.log([1] == true), le tableau [1] est converti en un type primitif, ce qui donne 1, et 1 == true est vrai.
• Pour console.log([0] == false), le tableau [0] se convertit en 0, et 0 == false est également vrai.

---

25. Quel sera le résultat du code suivant ?

console.log(1 + '1'); // Output?
console.log(1 - '1'); // Output?

Répondre:

• Premier foo() : 1
• Deuxième foo() : 2
• Troisième foo() : 3

Explication : La fonction foo maintient une fermeture autour de la variable count, qui est incrémentée à chaque fois que foo est appelé, préservant son état à travers les appels.

---

26. Quel sera le résultat du code suivant ?

console.log(typeof null); // Output?

Répondre:

Sortie :

• Premier console.log(a) : 1
• Deuxième console.log(b) : 2
• Troisième console.log(c) : 3

Explication :a est accessible dans la deuxième fonction pour cause de fermeture. b est également accessible tel qu’il est défini en premier. c est local à la seconde, donc les trois variables sont correctement enregistrées.

---

27. Quel sera le résultat du code suivant ?

console.log(0.1 + 0.2 === 0.3); // Output?

Répondre:

Sortie : 3

Explication : La méthode d'appel invoque l'incrément avec newObj comme ceci, donc this.num fait référence à newObj.num. L'opération d'incrémentation change newObj.num de 2 à 3.

---

28. Quel sera le résultat du code suivant ?

const a = {};
const b = { key: 'b' };
const c = { key: 'c' };

a[b] = 123; // What happens here?
console.log(a[b]); // Output?

Répondre:

Sortie :

const arr = [1, 2, 3];
arr[10] = 11;
console.log(arr.length); // Output?

Explication : Les fonctions setTimeout font toutes référence à la même variable i en raison du levage. Lorsque les délais d'attente s'exécutent, i a déjà été incrémenté à 4, ce qui fait que 4 est enregistré trois fois.

---

29. Quel sera le résultat du code suivant ?

let x = 1;
let y = 2;

const obj = {
    x: 10,
    y: 20,
    sum: function() {
        return this.x + this.y;
    }
};

console.log(obj.sum()); // Output?
console.log(obj.sum.call({ x: 100, y: 200 })); // Output?
console.log(obj.sum.apply({ x: 1000, y: 2000 })); // Output?

Répondre:

• tableau : [1, 2, 3]
• nouveauTableau : [2, 3, 4]

Explication : La fonction map crée un nouveau tableau en fonction de la transformation appliquée à chaque élément. Le tableau d'origine reste inchangé, tandis que newArray reflète les incréments.

---

30. Quel sera le résultat du code suivant ?

console.log(1 + '1'); // Output?
console.log(1 - '1'); // Output?

Répondre:

Sortie : La sortie dépendra du contexte dans lequel foo est appelé, mais si c'est dans le contexte global, il enregistrera l'objet global (fenêtre dans les navigateurs ou global dans Node.js).

Explication : Dans les fonctions fléchées, this est lié lexicalement, ce qui signifie qu'il utilise la valeur this du contexte environnant. Si foo est appelé dans la portée globale, cela fera référence à l'objet global.

---

31. Quel sera le résultat du code suivant ?

const foo = () => {
    console.log(this);
};

foo(); // Output?

Répondre:

Sortie : 42

Explication : La fonction interne est une fonction de flèche, qui la lie lexicalement au contexte de la fonction de méthode. Par conséquent, this.value fait référence à obj.value, qui est 42.

---

32. Quel sera le résultat du code suivant ?

function createCounter() {
    let count = 0;
    return {
        increment: function() {
            count++;
            return count;
        },
        decrement: function() {
            count--;
            return count;
        },
        getCount: function() {
            return count;
        }
    };
}

const counter = createCounter();
console.log(counter.increment()); // Output?
console.log(counter.increment()); // Output?
console.log(counter.getCount());  // Output?
console.log(counter.decrement()); // Output?
console.log(counter.getCount());  // Output?

Répondre:

Sortie : ReferenceError

Explication : La variable x est hissée dans myFunction, ce qui signifie qu'elle existe dans la portée de la fonction mais n'est initialisée qu'après le console.log(x). Cela entraîne une ReferenceError car la variable x est accédée avant sa déclaration.

---

33. Quel sera le résultat du code suivant ?

console.log(typeof null); // Output?

Répondre:

Sortie : Bonjour non défini

Explication : Lorsque greet est appelé sans contexte explicite, this ne fait pas référence à obj, donc this.name n'est pas défini.

---

34. Quel sera le résultat du code suivant ?

console.log(0.1 + 0.2 === 0.3); // Output?

Répondre:

Sortie : numéro

Explication : En JavaScript, NaN (Not-a-Number) est considéré comme un type numérique et typeof NaN renvoie "number".

---

35. Quel sera le résultat du code suivant ?

const a = {};
const b = { key: 'b' };
const c = { key: 'c' };

a[b] = 123; // What happens here?
console.log(a[b]); // Output?

Répondre:

Sortie : [1, 2, 3, 4]

Explication : a et b font tous deux référence au même tableau en mémoire. Lorsque vous poussez 4 dans b, cela affecte également a.

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!