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
var, let, const et hoistingLes déclarations var sont remontées avec la valeur undefined, let et const existent mais sont inaccessibles avant leur ligne (zone morte temporelle). Le piège classique : un console.log placé avant la déclaration, qui donne undefined dans un cas et une ReferenceError dans l'autre.
Closures et bouclesUne fonction créée dans une boucle capture la variable, pas sa valeur. Avec var, tous les callbacks partagent la même variable et voient sa valeur finale ; avec let, chaque itération a sa propre copie.
this et fonctions fléchéesLa valeur de this dépend de la façon dont la fonction est appelée, sauf pour les fonctions fléchées qui l'héritent de leur contexte de définition. Les tests adorent extraire une méthode d'un objet puis l'appeler seule, ou mélanger méthodes classiques et propriétés fléchées dans une classe.
Coercion de type et == vs ===L'opérateur == convertit les opérandes avant de comparer, avec des règles contre-intuitives (null == undefined mais null != 0, [] == false). Le + concatène dès qu'une chaîne est présente alors que - convertit toujours en nombre.
Promesses, async/await et event loopLe code synchrone s'exécute d'abord, puis les microtâches (callbacks de promesses, reprise après await), puis seulement les macrotâches comme setTimeout, même avec un délai de 0. Le piège le plus fréquent : croire qu'un forEach avec un callback async attend chaque itération.
Méthodes de tableau et références d'objetssort() sans comparateur trie en chaînes de caractères, reduce demande un accumulateur initial bien choisi, et le spread {...obj} ne copie que le premier niveau. Les questions vérifient que vous savez ce qui est copié et ce qui reste partagé.
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.
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.
[] == 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 ===.
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.
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 ?
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.
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.
Score0 / 12
Le jour du test
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.
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.
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.
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.
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.