[ Leksykon ] [ JavaScript ] [ Metody ] [ Promise() ]

Promise.finally()

[_] [A] [B] [C] [D] [E] [F] [G] [H] [I] [J] [K] [L] [M] [N] [O] [P] [Q] [R] [S] [T] [U] [V] [W] [X] [Y] [Z]

promiseInstance.finally(onFinally)

Przykłady:  

function zadanie() {
 return new Promise((resolve, reject) => {
 if (Math.random() > 0.5) {
 resolve('Zrobione');
 } else {
 reject(new Error('Błąd!'));
 }
 });
}

zadanie()
 .then((resolve) => {
 console.log(resolve);
 })
 .catch((error) => {
 console.error(error);
 })
 .finally(() => {
 console.log('Koniec');
 });

const WYBRANY_NR = 5;

 // funkcja jest promise zwraca resolve, reject 
 function pracaA(resolve, reject) {
 // wykonaj prace co 5
 setTimeout(() => {
 const czas = Date.now();
 const reszta = czas % 10;
 console.log(czas);
 console.log(reszta);
 
 if (reszta == WYBRANY_NR) {
 resolve(reszta);
 } 
 else if (reszta < WYBRANY_NR) {
 reject(`Wybrana liczba jest za duża: ${reszta}`);
 } 
 else if (reszta > WYBRANY_NR) {
 resolve(reszta);
 } else {
 reject(`Błąd: NR: $(WYBRANY_NR), RESZTA: ${reszta}`);
 }
 
 //zadanieB();
 
 }, 5000); 
 }

 // sprawdzamy czy liczba jest parzysta
 function pracaB1(reszta) {
 const parzystaNR = reszta % 2 === 1;
 console.log(`B1: ${reszta}`);
 console.log(`B1: ${parzystaNR}`);
 return { reszta, parzystaNR };
 }

 function pracaB2(przyczyna) {
 const err = new Error(`Opis błędu, przyczyna: ${przyczyna}`, {komunikat: przyczyna} );
 console.error(err);
 throw err; // zostanie zatrzymane skok do pierwszego catch bloku
 }

 function pracaC(dane) { // { reszta, parzysta }

 console.log(`C: ${dane.reszta}`);
 console.log(`C: ${dane.parzystaNR}`);
 
 return new Promise((resolve, reject) => {
 const { reszta, parzystaNR } = dane;
 if (reszta == WYBRANY_NR - 1) {
 dane.tekst = parzystaNR ? "nieparzysta" : "parzysta";
 resolve(dane); // { reszta, parzysta, tekst }
 }
 else if (reszta > WYBRANY_NR) {
 dane.tekst = parzystaNR ? "nieparzysta" : "parzysta";
 console.log(`Dane: reszta: ${dane.reszta} nie równa liczbie ${WYBRANY_NR}, reszta jest to liczba: ${dane.tekst}`);
 reject(`Wybrana liczba jest za mała: ${reszta}, reszta: ${dane.tekst}`);
 } else {
 dane.tekst = parzystaNR ? "nieparzysta" : "parzysta";
 resolve(dane);
 }
 });
 }
 
 function zadanieB() {

 new Promise(pracaA)
 .then(pracaB1, pracaB2)
 .then(pracaC)
 .then((dane) => { // 
 console.log(`Dane: reszta: ${dane.reszta} równa liczbie ${WYBRANY_NR} jest to liczba: ${dane.tekst}`);
 return dane;
 })
 .catch((przyczyna) => {
 if (przyczyna.komunikat) {
 console.error("Opis błędu podany wcześniej!");
 } else {
 console.error(`Problem z pracaC(): ${przyczyna}`);
 }
 })
 .finally((dane) => console.log("KONIEC!"));

 }

 zadanieB();

mojaPromise()
.then(function (result) {
     return daneBoxA(result);
   })
   .then(function (drugiResult) {
      return daneBoxB(newResult);
   })
   .then(function (trzeciResult) {
      console.log(`Współrzędne trasy: ${trzeciResult}`);
      return trzeciResult;
 })
 .catch((niepowodzenieAdres) => {
    if (niepowodzenieAdres) {
       console.error("error A");
    } else {
       console.error(`error B: ${niepowodzenieAdres}`);
    }
 })
 .finally((trzeciResult) => console.log("Dodatkowe dane"));

.finally(() => {
   zadanie = false;
});

Opis:
Metoda Promise.finally() instancji Promise planuje wywołanie funkcji po spełnieniu obietnicy spełnieniu lub odrzuceniu. Natychmiast zwraca równoważny Promise obiekt, umożliwiając łączenie wywołań z innymi metodami obietnicy. Pozwala to uniknąć powielania kodu zarówno w obietnicach, then() jak i catch() procedurach obsługi. Parametry onFinally - funkcja do asynchronicznego wykonania, gdy ta obietnica zostanie rozliczona. Wartość zwracana jest ignorowana, chyba że zwrócona wartość jest odrzuconą obietnicą. Funkcja jest wywoływana bez argumentów. Wartość zwracana odpowiednik Promise. Jeśli procedura obsługi zgłosi błąd lub zwróci odrzuconą obietnicę, obietnica zwrócona przez finally() zostanie zamiast tego odrzucona z tą wartością. W przeciwnym razie wartość zwracana przez procedurę obsługi nie ma wpływu na stan pierwotnej obietnicy.

Metoda finally() może być przydatna, jeśli chcesz przeprowadzić przetwarzanie lub czyszczenie po spełnieniu obietnicy, niezależnie od jej wyniku. Metoda finally() jest bardzo podobna do wywołania then (onFinally, onFinally). Istnieje jednak kilka różnic: tworząc funkcję inline, możesz przekazać ją raz, zamiast być zmuszonym do dwukrotnego deklarowania jej lub tworzenia dla niej zmiennej. Wywołanie onFinally zwrotne nie otrzymuje żadnego argumentu. Ten przypadek użycia ma zastosowanie właśnie wtedy, gdy nie interesuje Cię powód odrzucenia ani wartość realizacji, więc nie ma potrzeby ich podawania. Wywołanie finally() jest zwykle przejrzyste i nie zmienia ostatecznego stanu pierwotnej obietnicy. Na przykład:
W przeciwieństwie do Promise.resolve(2).then(() => 11, () => {}), które zwraca obietnicę ostatecznie spełnioną z wartością 11, Promise.resolve(2).finally(() => 11) zwraca obietnicę ostatecznie spełnioną z wartością 2. Podobnie, w przeciwieństwie do Promise.reject(3).then(() => {}, () => 55), które zwraca obietnicę ostatecznie spełnioną z wartością 55, Promise.reject(7).finally(() => 55) zwraca obietnicę ostatecznie odrzuconą z powodem 7.

Linki: