Exemples de flashcards JavaScript de notre application

Téléchargez notre application depuis l'App Store ou Google Play pour obtenir plus de flashcards gratuites ou abonnez-vous pour accéder à toutes les flashcards.

Qu'est-ce que la portée lexicale en JavaScript ?

La portée lexicale en JavaScript est un principe selon lequel la plage de visibilité d'une variable est déterminée par son emplacement dans le code. Cela signifie que les variables sont accessibles à l'intérieur du bloc dans lequel elles ont été définies, ainsi que dans tous les blocs imbriqués. Cela permet la création de fermetures (closures) et le contrôle de l'accès aux variables. Exemple d'utilisation de la portée lexicale dans le code JavaScript :

function outerFunction() {
  let outerVariable = `Je suis à l'extérieur!`;

  function innerFunction() {
    console.log(outerVariable); // A accès à 'outerVariable'
  }

  innerFunction();
}
outerFunction(); // Affiche `Je suis à l'extérieur!`

La portée lexicale permet à une fonction interne d'accéder aux variables définies dans une fonction externe, même après la fin de la fonction externe. C'est un élément clé dans la création de fermetures en JavaScript, permettant une gestion d'état plus flexible dans les applications.

Qu'est-ce que le hoisting ?

L'élévation est un mécanisme dans les langues JavaScript où les variables et les fonctions sont déplacées vers le haut de leur portée avant que le code ne soit exécuté. En pratique, cela signifie que nous pouvons utiliser des fonctions ou des variables avant qu'elles ne soient réellement déclarées.

Cependant, il convient de noter que l'élévation fonctionne légèrement différemment pour les variables et les fonctions.

Pour les variables déclarées avec les mots-clés var, seule la déclaration est levée, pas l'initialisation. Les variables initialisées avant la déclaration seront renvoyées comme indéfinies.

Un exemple de code d'élévation pour les variables :

console.log(myVar); // undefined
var myVar = 5;
console.log(myVar); // 5

Pour les fonctions, l'élévation déplace à la fois la déclaration et la définition de la fonction vers le haut, ce qui permet l'utilisation de la fonction avant qu'elle ne soit déclarée.

Un exemple de code d'élévation pour les fonctions :

console.log(myFunction()); // "Hello World"

function myFunction() {
  return "Hello World";
}

L'élévation ne se produit pas pour les variables déclarées avec let et const.

Qu'est-ce qu'une fonction fléchée et quels sont ses avantages ?

Une fonction fléchée, également connue sous le nom de fonction fléchée, est un type de fonction introduit dans ECMAScript 6 (ES6). Elles sont appelées fonctions fléchées parce qu'elles utilisent une syntaxe spéciale avec une flèche ( => ) pour définir la fonction.

Pour comparaison, une fonction traditionnelle pourrait ressembler à ceci :

function sum(a, b) {
  return a + b;
}

Son équivalent en tant que fonction fléchée est :

const sum = (a, b) => a + b;

Le principal avantage d'une fonction fléchée est qu'elle ne crée pas son propre contexte d'exécution (liaison à this), qui est souvent une source d'erreurs en JavaScript. Dans les fonctions fléchées, this est hérité du contexte environnant. Un autre avantage est la brièveté de la syntaxe, particulièrement utile lorsque les fonctions sont utilisées comme arguments pour d'autres fonctions, par exemple dans les fonctions d'ordre supérieur.

En revanche, en raison de l'absence de son propre this, les fonctions fléchées ne conviennent pas pour définir des objets constructeurs (créatifs) ou pour créer des méthodes dans des objets prototypes.

Qu'est-ce qu'un objet Promise et comment peut-il être utilisé ?

L'objet Promise en JavaScript est utilisé pour gérer les opérations asynchrones. Une Promise représente une valeur qui peut ne pas être disponible au moment de la création de la Promise, mais qui peut être disponible à l'avenir, ou jamais.

Un objet Promise peut être dans l'un des trois états :
1. En attente - l'opération est toujours en cours, pas terminée soit avec succès, soit avec des erreurs.
2. Accompli - l'opération est terminée avec succès, la Promise a renvoyé une valeur.
3. Rejeté - l'opération est terminée avec une erreur, la Promise a renvoyé la raison de l'erreur.

Une Promise qui a été accomplie ou rejetée est considérée comme "résolue" et son état ne change jamais.

Création d'un objet Promise :

const promise = new Promise((resolve, reject) => {
  const success = true;
  if (success) {
    resolve('Opération réussie.');
  } else {
    reject('Opération échouée.');
  }
});

Utilisation d'un objet Promise :

promise
  .then(result => {
    console.log(result); // Va afficher : 'Opération réussie.'
  })
  .catch(error => {
    console.log(error);
  });

La méthode .then() est exécutée quand la Promise est accomplie, et .catch() quand elle est rejetée. Dans les deux cas, le résultat de l'opération ou la raison du rejet de la Promise est passée en argument.

Qu'est-ce qu'un callback ?

Un callback, également désigné comme une fonction de rappel, est une fonction qui est passée en tant qu'argument à une autre fonction et est ensuite exécutée (rappelée) après l'achèvement de cette fonction. Les fonctions de rappel sont couramment utilisées en JavaScript, en particulier dans les opérations asynchrones telles que les requêtes AJAX ou la gestion des événements.

Les fonctions de rappel reçoivent généralement les résultats d'une certaine opération en tant qu'arguments, elles peuvent donc être utilisées pour traiter ou analyser ces résultats.

L'utilisation d'une telle fonction en pratique peut ressembler à ceci :

function executeAfterTimeout(callback, timeout) {
  setTimeout(() => {
    console.log('Le temps est passé !');
    callback();
  }, timeout);
}

executeAfterTimeout(() => {
  console.log('Ceci est un callback !');
}, 2000);

Dans ce cas, la fonction `executeAfterTimeout` reçoit une fonction `callback` en tant que paramètre, qui sera exécutée après qu'un certain laps de temps est passé. Les fonctions de rappel sont extrêmement utiles pour gérer le flux de contrôle asynchrone en JavaScript.

Qu'est-ce que l'opérateur de coalescence des nuls et comment fonctionne-t-il ?

L'opérateur de coalescence nulle (??) est un opérateur logique qui renvoie le côté droit de l'opération lorsque le côté gauche est nul ou indéfini. En d'autres termes, lorsqu'une variable est vide, l'opérateur de coalescence nulle renvoie la valeur définie comme résultat.

La notation de base est :

let valeur = null ?? 'valeur par défaut';

Dans ce cas, comme le côté gauche (valeur) est nul, le résultat est 'valeur par défaut'. De plus, cet opérateur diffère de l'opérateur OU (||), car la fonction OU renvoie le côté droit lorsque le côté gauche est faux (false, 0, '', null, undefined, NaN), tandis que l'opérateur de coalescence nulle ne renvoie le côté droit que lorsque le côté gauche est nul ou indéfini.

Exemple avec OU :

let valeur1 = 0 || 'par défaut';
console.log(valeur1); // sortie : 'par défaut' car 0 est une valeur fausse

Exemple avec la coalescence nulle :

let valeur2 = 0 ?? 'par défaut';
console.log(valeur2); // sortie : 0 car 0 n'est ni null ni indéfini

Donc, contrairement au OU, l'opérateur de coalescence nulle ne considère pas 0, '' et NaN comme des valeurs "vides".

Qu'est-ce que Symbol et quand doit-il être utilisé ?

Un symbole en JavaScript est un type de données unique et immuable qui est souvent utilisé pour identifier des propriétés uniques d'objets.

Vous pouvez créer un symbole en appelant le constructeur Symbol(), qui crée un symbole unique à chaque fois qu'il est appelé. Même si nous appelons le constructeur Symbol() avec le même argument, chaque symbole créé sera différent.

const symbol1 = Symbol('mySymbol');
const symbol2 = Symbol('mySymbol');
console.log(symbol1 === symbol2); // renvoie false

Symbol est souvent utilisé pour définir des propriétés (uniques) d'objets, surtout lorsque nous voulons que cette propriété soit cachée ou privée. Il couvre également les propriétés qui ne sont pas prises en compte lors de l'itération sur des objets en utilisant for...in ou for...of et qui ne sont pas renvoyées par la méthode Object.keys(). De plus, les symboles permettent de créer des propriétés "pseudo" privées.

let obj = {};
let privateProperty = Symbol('private');

obj[privateProperty] = 'Ceci est privé';

console.log(obj[privateProperty]); // 'Ceci est privé'
console.log(Object.keys(obj)); // []

Il n'y a pas de règle définitive sur quand utiliser Symbol. Ils sont généralement utilisés lorsque nous voulons créer une propriété unique sur un objet qui ne peut pas être facilement vue ou modifiée, ou nous voulons définir des méthodes qui affectent le comportement des objets à un niveau basique.

Que sont WeakMap et WeakSet ?

WeakMap et WeakSet sont des versions spéciales des objets Map et Set de JavaScript qui n'empêchent pas la libération automatique de la mémoire par le Garbage Collector.

WeakMap est une collection de paires clé-valeur où les clés doivent être des objets et les valeurs peuvent être n'importe quoi. La principale différence entre Map et WeakMap est que les clés dans WeakMap sont conservées de manière "faible", ce qui signifie que si il n'y a pas d'autres références à l'objet clé, il sera récupéré par le ramasse-miettes, et son entrée dans WeakMap sera automatiquement supprimée.

Voici un exemple d'utilisation de WeakMap :

let john = { name: "John" };

let weakMap = new WeakMap();
weakMap.set(john, "...");

john = null; // écrase la référence

// john est supprimé de la mémoire !

WeakSet est similaire à ce que WeakMap est à Map. C'est un ensemble d'objets, mais il ne prévient pas la collecte de déchets si l'objet n'est visible nulle part ailleurs. Il manque des méthodes typiques de Set comme `size` et `clear`, et la méthode `add` ne prend que des objets.

Exemple d'utilisation de WeakSet :

let john = { name: "John" };

let weakSet = new WeakSet();
weakSet.add(john);

john = null; // écrase la référence

// john est supprimé de la mémoire !

Tous deux, WeakMap et WeakSet, sont principalement utilisés dans des situations où nous voulons stocker des informations supplémentaires sur des objets qui doivent être supprimés lorsque l'objet lui-même est supprimé.

Flashcards JavaScript