Obietnica w Node.js

Node.js to popularne środowisko uruchomieniowe, które umożliwia programistom tworzenie skalowalnych i wydajnych aplikacji. Jedną z podstawowych cech Node.js jest możliwość obsługi kodu asynchronicznego, który jest niezbędny do tworzenia aplikacji o wysokiej wydajności. Zarządzanie kodem asynchronicznym może być trudne, zwłaszcza w przypadku złożonych operacji lub długotrwałych zadań. W tym miejscu pojawiają się obietnice, zapewniające prosty i skuteczny sposób obsługi operacji asynchronicznych w Node.js.

W tym artykule przyjrzymy się koncepcji obietnic w Node.js i wyjaśnimy, dlaczego są one ważne przy tworzeniu nowoczesnych aplikacji.

Czym jest Obietnica?

Mówiąc prościej, obietnica to obiekt reprezentujący wartość, która może nie być jeszcze dostępna. Obietnice służą do obsługi operacji asynchronicznych w JavaScript, takich jak wysyłanie żądań sieciowych lub odczytywanie plików z dysku.

Obietnica ma trzy stany:

• Oczekujące: Początkowy stan obietnicy, wskazujący, że wartość nie jest jeszcze dostępna.
• Spełnione: Stan obietnicy, gdy operacja zakończy się pomyślnie, a wartość jest dostępna.
• Odrzucone: Stan obietnicy, w którym operacja się nie powiodła i wystąpił błąd.

Tworzenie obietnicy w Node.js

Tworzenie obietnicy w Node.js jest proste. Używamy konstruktora Promise do tworzenia nowej obietnicy i przekazywania funkcji, która wykonuje operację asynchroniczną. Funkcja przyjmuje dwa argumenty, rozwiąż i odrzuć, które wskazują, czy operacja się powiodła, czy nie.

Oto przykład, który tworzy obietnicę, która jest rozwiązywana po opóźnieniu wynoszącym jedną sekundę:

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

Postępowanie z wynikami obietnicy

Po utworzeniu obietnicy możemy użyć metody then do obsługi wyników. Metoda then przyjmuje dwie funkcje jako argumenty, jedną do obsługi pomyślnej operacji i jedną do obsługi błędu.

Oto przykład, w którym użyto utworzonej powyżej obietnicy do zarejestrowania wyniku w konsoli:

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

Łańcuchowe obietnice

Jedną z potężnych cech obietnic jest możliwość ich łączenia. Dzięki temu możemy wykonać serię operacji asynchronicznych w sekwencji, bez zagnieżdżania wywołań zwrotnych.

Oto przykład, który łączy ze sobą dwie obietnice:

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 #promise #fullstackdeveloper