Préparation d'entretien 100% Gratuit angularforall.com

Entretien JavaScript Débutant : variables et syntaxe

Javascript Debutant Quiz-Javascript-Debutant Javascript-Variables Javascript-Types Javascript-Fonctions Entretien-Javascript Questions-Javascript Qcm-Javascript Apprendre-Javascript Revision-Javascript Es6 Fondamentaux-Js Front-End
Débutant 🔀 Mixte 20 questions ⏱ 15 min
📝

Entretien JavaScript Débutant : variables et syntaxe

20 questions sur les bases JavaScript : var/let/const, types primitifs, opérateurs, fonctions, tableaux et syntaxe ES6 pour un premier entretien dev web.

20 questions ⏱ ~15 min Niveau Débutant

Partager

Banque de révision : les 40 questions corrigées

Voici l'intégralité des 40 questions de « Entretien JavaScript Débutant : variables et syntaxe », chacune avec sa bonne réponse et son explication. Le quiz interactif ci-dessus en tire une sélection aléatoire à chaque tentative — utilisez cette liste complète pour réviser.

  • "text"
  • "string"
  • "char"
  • "word"
Explication : typeof retourne le type primitif sous forme de chaîne. Pour une chaîne de caractères, JS retourne toujours "string". Les autres types : "number", "boolean", "undefined", "symbol", "bigint", et "function" pour les fonctions.

  • 5
  • "23"
  • NaN
  • Error
Explication : En JavaScript, l'opérateur + avec une chaîne effectue une concaténation, pas une addition. Le nombre 3 est converti en chaîne "3", d'où "23". Pour forcer l'addition : Number("2") + 3 ou +"2" + 3.

  • var PI = 3.14
  • let PI = 3.14
  • const PI = 3.14
  • static PI = 3.14
Explication : const déclare une variable dont la référence ne peut pas être réassignée. Attention : pour un objet ou tableau const, son contenu reste modifiable (les propriétés peuvent changer). Seule la réassignation de la variable est interdite.

  • var est plus performant que let
  • let a une portée de bloc ({}), var a une portée de fonction
  • var ne peut pas être utilisé en dehors des fonctions
  • let peut être redéclaré dans le même bloc
Explication : let respecte la portée de bloc : une variable let dans un if ou for n'est accessible que dans ce bloc. var ignore les blocs et remonte à la portée de la fonction englobante. var est aussi hoistée et initialisée à undefined.
Recommandation d'entretien : préfère toujours const par défaut, let quand la réassignation est nécessaire, et évite var (source de bugs classiques à cause du hoisting et de la portée large).

  • arr[1]
  • arr.first()
  • arr[0]
  • arr.get(0)
Explication : En JavaScript, les indices des tableaux commencent à 0. arr[0] = premier élément, arr[1] = deuxième, etc. arr.first() et arr.get(0) n'existent pas nativement en JS vanilla.

  • "false"
  • [] (tableau vide)
  • {} (objet vide)
  • 0
Explication : Les valeurs falsy sont : false, 0, -0, 0n, "" (chaîne vide), null, undefined, NaN. La chaîne "false" est truthy (chaîne non vide). Les tableaux [] et objets {} vides sont aussi truthy.

  • true
  • null
  • false
  • undefined
Explication : null fait partie des valeurs falsy de JavaScript. Boolean(null) retourne donc false. Cette conversion booléenne est implicite dans les conditions : if (null) → bloc non exécuté.

  • Un type de boucle pour itérer des valeurs
  • Une collection non ordonnée de paires clé-valeur
  • Une fonction avec plusieurs paramètres
  • Un tableau de valeurs indexées numériquement
Explication : Un objet JS est une collection de propriétés (paires clé-valeur) où les clés sont des chaînes (ou symboles). Syntaxe littérale : { nom: "Alice", age: 30 }. Les tableaux ([]) et fonctions sont aussi des objets en JS.
En entretien, mentionne que les fonctions sont des objets de première classe (first-class citizens) : elles peuvent être passées comme arguments, retournées par d'autres fonctions, et stockées dans des variables.

  • Une boucle conditionnelle
  • Une fonction anonyme
  • Un if/else condensé en une expression
  • Un switch/case à 2 branches
Explication : L'opérateur ternaire condition ? valeurSiVrai : valeurSiFaux est l'équivalent compact d'un if/else qui retourne une valeur. Utile pour les assignations conditionnelles : const label = age >= 18 ? 'adulte' => 'mineur';.

  • Aucune différence, les deux sont identiques
  • === compare uniquement le type des valeurs
  • === compare valeur ET type (égalité stricte)
  • == est plus strict que ===
Explication : == utilise la coercition de type (convertit avant de comparer) : 1 == '1' → true. === est l'égalité stricte (aucune conversion) : 1 === '1' → false. Utilisez toujours === pour éviter les comportements inattendus.
Exemples classiques : 0 == false → true, null == undefined → true, mais 0 === false → false. Règle simple : utilise toujours === sauf cas très spécifiques.

  • 2
  • "11"
  • NaN
  • Error
Explication : L’opérateur + convertit tout en chaîne si l’un des opérandes est une chaîne. 1 + "1" → "1" + "1" → "11".

  • Elle convertit un objet en tableau
  • Elle vérifie si une variable est un tableau
  • Elle crée un nouveau tableau
  • Elle supprime le premier élément d’un tableau
Explication : Array.isArray(variable) retourne true si la variable est un tableau, false sinon. Utile car typeof [] retourne "object".
Préfère Array.isArray() à instanceof Array car il fonctionne même avec des iframes.

  • "null"
  • "undefined"
  • "object"
  • "number"
Explication : Bizarrement, typeof null retourne "object". C’est un bug historique de JavaScript qui n’a jamais été corrigé pour ne pas casser trop de code.
Pour tester si une valeur est null, utilise valeur === null.

  • 3a
  • NaN
  • 0
  • Error
Explication : La multiplication force la conversion en nombre. "a" ne peut pas être converti en nombre → NaN (Not a Number).

  • arr.push(element)
  • arr.unshift(element)
  • arr.pop(element)
  • arr.shift(element)
Explication : push() ajoute un ou plusieurs éléments à la fin d’un tableau et retourne la nouvelle longueur. unshift() ajoute au début.
Pour retirer le dernier élément : pop(). Pour retirer le premier : shift().

  • Null a Number
  • Not a Name
  • Not a Number
  • No a Null
Explication : NaN signifie "Not a Number". Il apparaît quand une opération mathématique échoue (ex: parseInt("abc"), 0/0).
Attention : NaN === NaN retourne false ! Utilise isNaN(valeur) ou Number.isNaN().

  • Aucune différence
  • undefined signifie "valeur non assignée", null signifie "valeur vide intentionnelle"
  • null est un type primitif, undefined non
  • undefined peut être réassigné, null non
Explication : undefined est la valeur par défaut d’une variable déclarée mais non initialisée. null est une valeur assignée volontairement pour signifier "rien" (objet inexistant).
En entretien : typeof undefined → "undefined", typeof null → "object".

  • Elle arrête la fonction et retourne une valeur
  • Elle continue la fonction mais stocke une valeur
  • Elle affiche une valeur dans la console
  • Elle crée une boucle infinie
Explication : return termine immédiatement l’exécution de la fonction et peut renvoyer une valeur. Sans return, la fonction retourne undefined.

  • true
  • false
  • null
  • NaN
Explication : Toute chaîne non vide est truthy. "false" est une chaîne, donc Boolean("false") → true.

  • function double(x) { return x*2 }
  • const double = (x) => { return x*2 }
  • const double = x => x*2
  • Les deux réponses B et C sont correctes
Explication : Les fonctions fléchées peuvent être écrites de plusieurs manières. Si un seul paramètre, les parenthèses sont optionnelles. Si un seul retour sans accolades, le return est implicite.
Fonction fléchée avec retour implicite : const double = x => x * 2.

  • Retourne le nombre d’éléments dans le tableau
  • Supprime le dernier élément
  • Ajoute un élément au tableau
  • Transforme le tableau en chaîne
Explication : La propriété length d’un tableau indique le nombre d’éléments qu’il contient. On peut aussi l’assigner pour tronquer un tableau.

  • "hello"
  • true
  • false
  • undefined
Explication : La double négation !! convertit une valeur en booléen. "hello" est truthy → !true → false → !false → true.
Raccourci pour convertir n’importe quelle valeur en booléen : !!valeur.

  • arr.map()
  • arr.filter()
  • arr.forEach()
  • Les trois
Explication : forEach() exécute une fonction sur chaque élément sans retour. map() retourne un nouveau tableau transformé. filter() retourne un tableau filtré. Toutes parcourent le tableau.
Pour une transformation : map(). Pour un effet de bord : forEach().

  • NaN
  • 10
  • "10px"
  • Error
Explication : parseInt() lit les caractères numériques au début de la chaîne jusqu’à rencontrer un caractère non numérique. "10px" → 10.
Attention : parseInt("10px20") → 10 aussi. Pour flottants : parseFloat().

  • # commentaire
  • // commentaire
  • /* commentaire */
Explication : // est le commentaire ligne unique. /* ... */ est le commentaire multi-lignes.

  • true
  • false
  • undefined
  • Error
Explication : L'opérateur && (ET logique) retourne true uniquement si les deux conditions sont vraies. 5 > 3 est true mais 2 < 1 est false → résultat false.
Pour qu'un && soit vrai, toutes les conditions doivent être vraies.

  • true
  • false
  • NaN
  • undefined
Explication : L'opérateur === compare valeur ET type. "10" est une chaîne, 10 est un nombre → types différents → false.
Avec == (égalité faible), "10" == 10 donnerait true car conversion automatique.

  • arr.push()
  • arr.pop()
  • arr.shift()
  • arr.unshift()
Explication : pop() supprime le dernier élément d'un tableau ET le retourne. shift() supprime le premier élément. push() et unshift() ajoutent des éléments.
Exemple : const fruits = ["pomme", "banane", "orange"]; fruits.pop(); → tableau devient ["pomme", "banane"].

  • 1
  • 3
  • 3.33
  • 0
Explication : L'opérateur % (modulo) retourne le reste de la division. 10 ÷ 3 = 3 reste 1. Très utile pour tester si un nombre est pair (n % 2 === 0).

  • if (age > 18)
  • if (age >= 18)
  • if (age
  • if (age => 18)
Explication : >= signifie "supérieur ou égal". > serait "strictement supérieur" (ne passerait pas pour 18). => est la syntaxe des fonctions fléchées, pas une comparaison.
Les opérateurs de comparaison : > (supérieur), >= (supérieur ou égal),

  • Le mécanisme par lequel les déclarations de variables et fonctions sont déplacées en haut de leur portée
  • Une technique pour lever des erreurs
  • Une méthode pour optimiser le code
  • Un type de boucle
Explication : Le hoisting fait que les déclarations var et les fonctions déclarées avec function sont "remontées" en haut de leur portée. On peut appeler une fonction avant sa déclaration. let et const sont aussi hoistées mais ne sont pas initialisées (TDZ).
C'est pour cela qu'il est recommandé de déclarer toutes les variables en haut de leur portée.

  • Array.isArray(variable)
  • variable.isArray()
  • typeof variable === "array"
  • variable instanceof [ ]
Explication : Array.isArray() est la méthode fiable pour vérifier si une valeur est un tableau. instanceof Array fonctionne mais peut échouer entre différents contextes d'exécution (iframes).
Ne jamais utiliser typeof pour tester un tableau : typeof [] retourne "object".

  • Elle parcourt les valeurs d'un objet itérable (tableau, chaîne, Map, Set)
  • Elle parcourt les propriétés énumérables d'un objet
  • Elle exécute un bloc tant que la condition est vraie
  • Elle crée une boucle infinie
Explication : for (const element of iterable) { } itère sur les valeurs d'un itérable. Contrairement à for...in qui itère sur les clés/propriétés. Compatible avec tableaux, chaînes, Map, Set, NodeList.
Pour parcourir les propriétés d'un objet littéral, utilisez for...in ou Object.keys(). for...of ne fonctionne pas directement sur les objets.

  • map()
  • filter()
  • forEach()
  • reduce()
Explication : map() crée un nouveau tableau contenant les résultats de l'appel d'une fonction sur chaque élément. filter() filtre selon une condition. forEach() exécute sans retourner. reduce() accumule.
Chaînez les méthodes : array.filter(predicat).map(transform). Cela évite les boucles imbriquées.

  • Une valeur falsy est traitée comme false (0, "", null, undefined, NaN, false) ; tout le reste est truthy
  • Truthy signifie vrai, falsy signifie faux
  • Ce sont des types de variables
  • Truthy est pour les nombres, falsy pour les chaînes
Explication : JavaScript convertit automatiquement les valeurs en booléen dans un contexte conditionnel. Valeurs falsy : false, 0, -0, "", null, undefined, NaN, 0n. Toute autre valeur est truthy (même "false", "0", [], {}).
if (variable) teste si la variable est truthy. Pour vérifier spécifiquement null/undefined, utilisez if (variable != null).

  • array[0]
  • array[1]
  • array.first()
  • array.get(0)
Explication : Les tableaux JavaScript sont indexés à partir de zéro. array[0] est le premier élément, array[array.length - 1] est le dernier. Depuis ES2022, array.at(-1) donne le dernier.
array.at() accepte des indices négatifs : array.at(-1) pour le dernier, array.at(-2) pour l'avant-dernier.

  • Une méthode est une fonction qui est une propriété d'un objet
  • Une fonction retourne une valeur, une méthode non
  • Il n'y a pas de différence
  • Les fonctions sont asynchrones, les méthodes synchrones
Explication : Une méthode est simplement une fonction attachée à un objet comme propriété. obj.maFonction = function() {}. Dans le contexte objet, this fait référence à l'objet propriétaire.
Une méthode est appelée via objet.methode(), une fonction via fonction().

  • &&
  • ||
  • !
  • &
Explication : && (ET logique) retourne true si les deux opérandes sont truthy. || (OU logique), ! (NON logique). Ces opérateurs pratiquent le "court-circuit" : le second opérande n'est évalué que si nécessaire.
&& retourne la première valeur falsy ou la dernière valeur si toutes sont truthy. Très utilisé en React : {isLogged && }.

  • La zone du code où une variable est accessible
  • La valeur actuelle de la variable
  • Le type de la variable
  • La durée de vie de la variable
Explication : La portée détermine où une variable peut être utilisée. Portée globale (partout), de fonction (var - dans la fonction), de bloc (let/const - entre accolades {}).
Préférez la portée la plus réduite possible. Déclarez les variables au plus près de leur utilisation.

  • import { maFonction } from "./fichier.js"
  • require("fichier.js")
  • include "fichier.js"
  • load("./fichier.js")
Explication : Les modules ES6 utilisent import { nom } from "./fichier.js" et export function maFonction() {}. require() est la syntaxe CommonJS (Node.js). import est la syntaxe standard moderne.
N'oubliez pas l'extension .js dans les imports. En TypeScript ou avec bundlers, l'extension est parfois optionnelle.

Voir aussi

Explorer par mot clé

Low-Level Big-Data Comparaison Interactive Mysqldump Favicon Initiales Logo Etat-Global Url-Seo Formcontrol Architecture-Entreprise Html5-Natif Outil En Ligne De Calculatrice De Tva Bootstrap Cards Forms Openai Responsive-Design Securite Mot De Passe Css-Pur Prefers-Color-Scheme Timers Citations-Ia Soar Audience Targeting Youtube Titles Injection De Dependances Pinia-Plugin-Persistedstate Directive-Custom Native-Apps Contenu-Seo Design-Patterns Go-Test Chatgpt Prompts Dto-Typage Api-Tester-Online Using-Declarations Apache-Modules Bullmq Router Requestanimationframe Tableau-Ascii Card Produit Convertir Une Image Hibernate Publicite-Digitale Modele Readme Developpeur Sha 256 En Ligne Impots Fade Slide Bounce Spin Css Jsx Meteo Ville Yeoman Nginx-Ssl Fastcgi Outil De Conversion Dimage Design-Ia Product 3D @Let Modeles-Personnalises Linkedin-Ads Rendering Racine-Carree Favicon Pwa Navigateur Shopping Cart Storage-Api Red-Team Creer Offre Emploi Pdf Veille-Emploi Drapeaux Pipelines Outil En Ligne De Generation De Robots.txt Modules-Terraform Build Optimisation-Seo Securite-Web User Story Agile Ia Image Regression-Visuelle Static-Site-Hosting Renderless-Components Blog-Monetisation Jeux-Html Pagerank Iac Api-Google Accessibilite Web Social Media Content Calendar Enum Angular Mitre-Attack Projet-Web Developpeur-Front-End Gestion Backlog Liens Fail2Ban Ai-Studio Html Css Js Data-Layer Jardin Immer Serveur Scrollbehavior