Coding Solution

QCM JavaScript : 12 questions corrigées (type CodinGame, SkillValue)

QCMJavaScript12 questionsMis à jour le

Ce QCM s'adresse aux développeurs qui préparent un test technique JavaScript (SkillValue, CodinGame, HackerRank) ou un entretien front-end / Node.js. Chaque question est corrigée avec une explication détaillée du bon choix et des pièges derrière les mauvais.

En bref

Les tests JavaScript de recrutement reposent très peu sur les frameworks et beaucoup sur les mécanismes du langage lui-même. Les thèmes qui reviennent le plus souvent sur SkillValue, CodinGame et HackerRank sont le hoisting de var/let/const, les closures dans les boucles, la valeur de this selon le mode d'appel, la coercion de type avec == et l'ordre d'exécution entre setTimeout, promesses et async/await. Viennent ensuite les méthodes de tableau (map, filter, reduce, sort) et la copie d'objets par référence. La plupart des questions sont de la lecture de code : il faut prédire ce qu'affiche un programme de dix lignes.

Les thèmes qui tombent le plus

Entraînez-vous : 12 questions corrigées

Choisissez une réponse pour voir l'explication.

Qu'affiche ce programme ?
console.log(x);
var x = 5;
console.log(x);

Les déclarations var sont remontées (hoisted) en haut de leur fonction ou du script, mais seulement la déclaration : l'affectation reste à sa place. Au premier console.log, x existe déjà et vaut undefined ; au second, il vaut 5. Il n'y a pas de ReferenceError (ce serait le cas avec let ou const) et null n'est jamais une valeur par défaut en JavaScript.

Qu'affiche ce programme ?
let a = 1;
{
  console.log(a);
  let a = 2;
}

Le bloc déclare sa propre variable a avec let. Cette déclaration est bien connue dès le début du bloc, mais la variable est dans la zone morte temporelle (TDZ) jusqu'à la ligne let a = 2 : y accéder avant lève une ReferenceError. Le a externe valant 1 est masqué par la déclaration interne, donc 1 n'est pas affiché ; undefined serait le comportement de var, pas de let.

Que vaut l'expression suivante ?
1 + "2" - 1

L'évaluation se fait de gauche à droite. 1 + "2" : dès qu'un opérande est une chaîne, + concatène et donne la chaîne "12". Ensuite "12" - 1 : l'opérateur - ne travaille qu'avec des nombres, il convertit "12" en 12 et renvoie le nombre 11. Le résultat est donc un nombre, pas une chaîne, et il n'y a pas de NaN car "12" se convertit sans problème.

Qu'affiche ce programme ?
const nums = [1, 10, 2, 21];
nums.sort();
console.log(nums);

Sans fonction de comparaison, sort() convertit chaque élément en chaîne et compare les chaînes caractère par caractère (ordre UTF-16). "1" < "10" < "2" < "21", donc le tableau est déjà dans l'ordre et ne bouge pas. Pour trier numériquement il faut écrire nums.sort((a, b) => a - b). Le comparateur est optionnel, il n'y a donc pas d'erreur.

Qu'affiche ce programme ?
for (var i = 0; i < 3; i++) {
  setTimeout(() => console.log(i), 0);
}

var a une portée de fonction : il n'existe qu'une seule variable i partagée par les trois callbacks. Les setTimeout s'exécutent après la fin de la boucle, moment où i vaut 3 (la condition i < 3 est devenue fausse), donc chacun affiche 3. Avec let i, chaque itération aurait sa propre variable et on obtiendrait 0 1 2.

Qu'affiche ce programme ?
console.log([] == false, null == undefined, null == 0, NaN == NaN);

[] == false : les deux côtés sont convertis en nombre, [] devient "" puis 0 et false devient 0, d'où true. null == undefined est un cas spécial de la spécification : true. En revanche null n'est égal qu'à null et undefined, jamais à 0 : false. Enfin NaN n'est égal à rien, pas même à lui-même : false. C'est exactement pour éviter ces règles qu'on recommande ===.

Qu'affiche ce programme ?
const words = ["a", "bb", "a", "ccc", "bb", "a"];
const count = words.reduce((acc, w) => {
  acc[w] = (acc[w] || 0) + 1;
  return acc;
}, {});
console.log(count.a, count.bb, Object.keys(count).length);

reduce part de l'objet vide fourni comme valeur initiale et, pour chaque mot, incrémente son compteur (acc[w] || 0 gère le premier passage). Le callback renvoie bien acc à chaque tour, donc l'accumulateur n'est jamais perdu. "a" apparaît 3 fois, "bb" 2 fois, et il y a 3 clés distinctes (a, bb, ccc). La réponse 3 2 6 confond le nombre de clés avec le nombre d'éléments du tableau.

Qu'affiche ce programme ?
const a = { x: 1, nested: { y: 2 } };
const b = { ...a };
b.x = 10;
b.nested.y = 20;
console.log(a.x, a.nested.y);

Le spread crée un nouvel objet et copie les propriétés de premier niveau. x est une valeur primitive, donc b.x = 10 ne touche pas a.x qui reste 1. Mais nested est une référence vers le même objet interne : a.nested et b.nested pointent sur le même { y: 2 }, et modifier b.nested.y change aussi a.nested.y, qui vaut 20. Pour une copie profonde il faut structuredClone ou une copie récursive.

Qu'affiche ce programme ?
class Counter {
  constructor() { this.count = 0; }
  inc = () => { this.count++; return this.count; };
  dec() { this.count--; return this.count; }
}
const c = new Counter();
const inc = c.inc;
const dec = c.dec;
console.log(inc());
console.log(dec());

inc est une propriété de classe définie avec une fonction fléchée : son this est capturé lexicalement au moment de la construction et pointe toujours sur l'instance, même quand on appelle inc() détaché. Il affiche donc 1. dec est une méthode classique : appelée seule, son this vaut undefined (le corps d'une classe est en mode strict), et this.count-- lève une TypeError. C'est exactement pourquoi on utilise des fléchées ou bind pour les gestionnaires d'événements.

Dans quel ordre les lettres sont-elles affichées ?
console.log("A");
setTimeout(() => console.log("B"), 0);
Promise.resolve().then(() => console.log("C"));
(async () => {
  console.log("D");
  await null;
  console.log("E");
})();
console.log("F");

Tout le code synchrone s'exécute d'abord : A, puis D (le début d'une fonction async est synchrone jusqu'au premier await), puis F. La file des microtâches est ensuite vidée dans l'ordre d'inscription : C (then) a été inscrit avant E (reprise après await), donc C puis E. Enfin seulement la macrotâche setTimeout affiche B, même avec un délai de 0 ms. Toute réponse qui place B avant C ou E ignore la priorité des microtâches.

Qu'affiche ce programme ?
async function run() {
  const ids = [1, 2];
  ids.forEach(async (id) => {
    await null;
    console.log("item", id);
  });
  console.log("done");
}
run();

forEach ignore la valeur de retour de son callback : il n'attend pas les promesses renvoyées par les fonctions async. Chaque callback s'exécute jusqu'à son await puis rend la main, forEach se termine, et "done" est affiché immédiatement. Les reprises après await sont des microtâches qui s'exécutent ensuite dans l'ordre : item 1 puis item 2. Pour attendre chaque itération il faut une boucle for...of avec await, ou Promise.all sur un map. Le code est syntaxiquement valide car await est bien dans une fonction async.

Qu'affiche ce programme ?
console.log(typeof NaN, NaN === NaN, Object.is(NaN, NaN), [NaN].includes(NaN), [NaN].indexOf(NaN));

NaN (Not a Number) est paradoxalement de type "number" : c'est une valeur numérique spéciale IEEE 754. NaN === NaN vaut false car NaN n'est égal à rien, y compris lui-même. Object.is a été conçu pour corriger ce cas et renvoie true. includes utilise l'algorithme SameValueZero qui traite NaN comme égal à NaN : true. indexOf utilise === en interne et ne trouve donc jamais NaN : -1. Pour tester NaN, utilisez Number.isNaN.

Le jour du test

  1. Pour toute question « qu'affiche ce programme », tracez l'exécution ligne par ligne sur papier en séparant trois colonnes : synchrone, microtâches, macrotâches. L'ordre final en découle mécaniquement.
  2. Dès que vous voyez var dans une boucle ou une méthode extraite de son objet (const f = obj.method), cherchez le piège : la question porte presque toujours sur la portée ou sur this.
  3. Face à une comparaison avec ==, convertissez les deux côtés en nombre à la main, sauf pour null et undefined qui ne sont égaux qu'entre eux.
  4. Vérifiez systématiquement les méthodes de tableau : sort() sans comparateur, forEach qui ignore les promesses, map qui renvoie un nouveau tableau alors que push modifie l'original. Ce sont trois sources de mauvaises réponses très fréquentes.

S'entraîner avec Coding Solutions

Sur un QCM d'entraînement affiché à l'écran, l'extension Coding Solutions explique la bonne réponse et la règle derrière, dans 29 langages. Pour les exercices de code, voyez aussi nos solutions CodinGame expliquées et les guides par plateforme.

Questions fréquentes

Quel niveau de JavaScript est attendu dans un test de recrutement ?

La majorité des tests visent un niveau intermédiaire : comprendre la portée, les closures, this, les promesses et les méthodes de tableau. Les questions sur les frameworks (React, Vue) sont souvent dans un test séparé. Un junior solide sur ces fondamentaux s'en sort bien.

Les tests portent-ils sur ES6+ ou sur l'ancien JavaScript ?

Les deux. Les plateformes posent volontairement des questions avec var, function et == pour vérifier que vous connaissez les anciens comportements, car ils sont encore présents dans beaucoup de bases de code. Il faut maîtriser let/const, les fléchées, le spread et async/await tout autant que les mécanismes historiques.

Combien de temps dure un QCM JavaScript sur SkillValue ou CodinGame ?

Généralement entre 15 et 30 minutes pour 15 à 25 questions, soit environ une minute par question. Les questions de lecture de code prennent plus de temps : répondez d'abord aux questions théoriques rapides, puis revenez sur les extraits de code.

Comment m'entraîner efficacement avant le test ?

Refaites ce QCM jusqu'à pouvoir justifier chaque réponse sans regarder la correction, puis écrivez vos propres variantes et exécutez-les dans la console du navigateur ou dans Node pour confirmer. Lire la sortie réelle corrige bien mieux les intuitions fausses que la relecture d'un cours.

Autres langages

★ 5,0 · 16 avis · 928 utilisateurs Ajouter à Chrome