QCM Javascript – Partie 36

QCM sur Javascript avec des réponses pour la préparation des tests techniques, des tests en ligne, aux examens et aux certifications. Ces questions et réponses sont tirés d’un vrai entretien écrit et certaines parties sont en direct.
 
 

1. Quel est le résultat du code ES6 suivant ?
let [a, b] = [1, 2];
console.log(a);

A 1

B 2

C [1, 2]

D undefined

A
Le code utilise la décomposition de tableau pour affecter les valeurs du tableau aux variables a et b (affectation par décomposition). La sortie est la valeur de a, qui est 1.

 

2. Quel est le résultat du code ES6 suivant ?
function multiplication(a, b = 2) {
   return a * b;
}
console.log(multiplication(3));

A 3

B 6

C undefined

D NaN

B
La fonction multiplication prend deux arguments, le deuxième ayant une valeur par défaut de 2. Lorsqu’elle est appelée avec un seul argument, elle multiplie 3 par 2, ce qui donne 6.

 

3. Trouvez l’erreur dans ce code ES6:
let obj = {a : 1, b : 2, a : 3};
console.log(obj.a);

A Nom de propriété répété dans l’objet

B Erreur de syntaxe dans la déclaration d’objet

C Erreur dans l’instruction console.log

D Pas d’erreur

A
Dans l’objet, la propriété a est déclarée deux fois. La deuxième déclaration écrase la première, ce qui fait que obj.a est 3.

 

 
 

4. Repérez l’erreur dans l’utilisation de ce callback:
function getData(callback) {
  if (error) {
     callback(error);
  } 
  return callback(null, data);
}

A Le callback est appelé deux fois

B Les données sont renvoyées avant que le callback ne soit appelé

C L’erreur n’est pas gérée correctement

D Il n’y a pas d’erreur

A
Dans ce code, le callback peut être appelé deux fois en cas d’erreur: une fois avec l’erreur et une fois avec les données. Cela peut entraîner un comportement inattendu.

 

5. Qu’est-ce qu’une promesse en JavaScript ?

A Une fonction qui s’exécute de manière asynchrone

B Une fonction callback qui s’exécute immédiatement

C Un objet représentant l’achèvement ou l’échec éventuel d’une opération asynchrone

D Une structure de données permettant de stocker plusieurs callbacks

C
En JavaScript, une promesse est un objet représentant l’achèvement ou l’échec éventuel d’une opération asynchrone. Elle permet d’écrire du code asynchrone d’une manière plus facile à gérer.

 

6. Comment fonctionne l’enchaînement de promesses en JavaScript ?

A En retournant une nouvelle promesse à partir du callback d’une autre promesse

B En exécutant plusieurs callbacks en parallèle

C En appelant plusieurs fois la même promesse

D En rejetant automatiquement une promesse après un délai déterminé

A
Le chaînage de promesses fonctionne en renvoyant une nouvelle promesse à partir du callback d’une promesse précédente. Cela permet d’effectuer des tâches asynchrones de manière séquentielle.

 

 
 

7. Que se passe-t-il si une promesse est rejetée et qu’il n’y a pas de bloc .catch() ?

A L’erreur est ignorée silencieusement

B La promesse est remplie avec une valeur undefined

C Une TypeError est déclenchée

D « unhandled promise rejection » se produit

D
Si une promesse est rejetée et qu’il n’y a pas de bloc .catch() pour gérer l’erreur, il en résulte un rejet de promesse non gérée (unhandled promise rejection), qui peut être signalé ou affiché par les environnements JavaScript.

 

8. Que fait le code suivant ?
new Promise((resolve, reject) => {
   setTimeout(() => resolve('result'), 2000);
}).then(result => console.log(result));

A Exécute une fonction après 2 secondes

B Affiche immédiatement le « result » dans le journal

C Crée une promesse qui se termine par « result » après 2 secondes, puis l’affiche.

D Affiche de manière répétée « result » toutes les 2 secondes

C
Ce code crée une nouvelle promesse qui se termine par la chaîne de caractères « result » après 2 secondes. Une fois résolu, le résultat est affiché dans la console.

 

9. Quel sera le résultat ?
new Promise((resolve, reject) => {
   throw new Error('Erreur');
})
.catch(error => console.log(error.message))
.then(() => console.log('Terminé')); 

A ‘Erreur’ puis ‘Terminé’.

B Seulement ‘Erreur’.

C Juste ‘Terminé’

D Une erreur d’exécution

A
La promesse est immédiatement rejetée en raison de l’erreur déclenchée. Le bloc .catch() capture et affiche le message d’erreur, puis le bloc .then() s’exécute et affiche « Terminé ».

 

 
 

10. Quel est le résultat de cette chaîne de promesses ?
Promise.resolve(1)
.then((x) => x + 1)
.then((x) => {
   throw new Error('Erreur');
})
.catch(() => console.log('Capturé'))
.then(() => console.log('Terminé'));

A ‘Capturé’ puis ‘Terminé’

B ‘Erreur’ puis ‘Terminé’

C Juste ‘Capturé’

D Juste ‘Terminé’

A
La chaîne de promesses se termine avec 1, l’incrémente, puis lève une erreur. Le bloc .catch() capture cette erreur, en affichant « Capturé », et le bloc final .then() affiche « Terminé ».

 

 

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *