Promesse dans Node.js

Node.js est un environnement d'exécution populaire qui permet aux développeurs de créer des applications évolutives et efficaces. L'une des principales fonctionnalités de Node.js est sa capacité à gérer le code asynchrone, ce qui est essentiel pour créer des applications hautes performances. Le code asynchrone peut être difficile à gérer, en particulier lorsqu'il s'agit d'opérations complexes ou de tâches de longue durée. C'est là qu'interviennent les promesses, offrant un moyen simple et efficace de gérer les opérations asynchrones dans Node.js.

Dans cet article, nous allons explorer le concept de promesses dans Node.js et pourquoi elles sont importantes pour créer des applications modernes.

Qu'est-ce qu'une Promesse ?

En termes simples, une promesse est un objet qui représente une valeur qui n'est peut-être pas encore disponible. Les promesses sont utilisées pour gérer les opérations asynchrones en JavaScript, telles que les requêtes réseau ou la lecture de fichiers à partir du disque.

Une promesse a trois états :

• En attente : l'état initial d'une promesse, indiquant que la valeur n'est pas encore disponible.
• Fulfilled : l'état d'une promesse lorsque l'opération est réussie et que la valeur est disponible.
• Rejeté : l'état d'une promesse lorsque l'opération a échoué et qu'une erreur s'est produite.

Créer une promesse dans Node.js

La création d'une promesse dans Node.js est simple. Nous utilisons le constructeur Promise pour créer une nouvelle promesse et transmettre une fonction qui effectue l'opération asynchrone. La fonction prend deux arguments, résoudre et rejeter, qui indiquent si l'opération a réussi ou non.

Voici un exemple qui crée une promesse qui se résout après un délai d'une seconde :

const myPromise = new Promise((resolve, reject) => {
  setTimeout(() => {
    resolve('Operation successful!');
  }, 1000);
});

Gérer les résultats des promesses

Une fois qu'une promesse est créée, nous pouvons utiliser la méthode then pour gérer les résultats. La méthode then prend deux fonctions comme arguments, une pour gérer une opération réussie et une pour gérer une erreur.

Voici un exemple qui utilise la promesse créée ci-dessus pour consigner le résultat dans la console :

myPromise.then((result) => {
  console.log(result);
}).catch((error) => {
  console.error(error);
});

Enchaîner les promesses

L'une des caractéristiques puissantes des promesses est la capacité de les enchaîner. Cela nous permet d'effectuer une série d'opérations asynchrones dans une séquence, sans rappels imbriqués.

Voici un exemple qui enchaîne deux promesses :

const getUser = (id) => {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      const user = { id, name: 'John Doe' };
      resolve(user);
    }, 1000);
  });
};

const getPosts = (user) => {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      const posts = [{ id: 1, title: 'Post 1' }, { id: 2, title: 'Post 2' }];
      resolve({ user, posts });
    }, 1000);
  });
};

getUser(1)
  .then(getPosts)
  .then((result) => {
    console.log(result);
  })
  .catch((error) => {
    console.error(error);
  });

#nodejs #javascript #blockchain #promesse #fullstackdeveloper