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!