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

Promise.reject()

[_] [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]

Promise.reject(reason)

  

Przykłady:

function resolved(result) {
 console.log(result);
}

function rejected(result) {
 console.error(result);
}

Promise.reject(new Error('Błąd!')).then(resolved, rejected);
Promise.resolve("OK!").then(resolved, rejected);
// Error: Błąd!
// "OK!"

  

Promise.reject(new Error("Błąd!")).then(
 () => {
 // bez reakcji
 },
 (error) => {
 console.error(error); // Error: Błąd!
 },
);

 

const mojaPromise = new Promise((resolve, reject) => {
   if (OperacjePozytywnie) {
      resolve("wiadomość pozytywna"); // Promise fulfilled
   } else {
      reject("wiadomość negatywna"); // Promise rejected
   }
});

 

const dane = Promise.resolve(10);
const rejected = Promise.reject(dane);
console.log(rejected); // [object Promise]
console.log(dane); // [object Promise]
console.log(rejected === dane); // false
rejected.catch((value) => {
 console.log(value); // [object Promise]
 console.log(dane); // [object Promise]
 console.log(value === dane); // true
});

 

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(); 

 

function mojaPromiseA() {
   return new Promise((resolve, reject) => {
      setTimeout(() => {resolve("Zadanie A"); }, 500)
   });
}

const mojaPromiseB = new Promise((resolve, reject) => {
   setTimeout(() => {resolve("Zadanie B"); }, 400)
});

function mojaPromiseC() {
   return new Promise((resolve, reject) => {
    setTimeout(() => {resolve("Zadanie C"); }, 300)
   });
}

function mojaPromiseD() {
   return new Promise((resolve, reject) => {
      reject(new Error("reject"));
    });
}

Promise.all([
   mojaPromiseA(),
   mojaPromiseB,
   mojaPromiseC(),
   mojaPromiseD()
])
.then(resolve => {
   console.log(resolve);
})
.catch((error) => {
   console.error(error.message);
});

 

const promiseA = new Promise((resolve, reject) => {
 resolve("Gotowe!");
});

promiseA.then((value) => {
 console.log(value); // Gotowe!
 return Promise.reject("błąd");
})
 .catch((e) => {
 console.error(e); // błąd
 })
 .then(
 () => console.log("wiadomość to koniec"),
 );

 

class praca {
 constructor(zadanie) {
 zadanie(
 (value) => console.log("Resolved", value),
 (reason) => console.log("Rejected", reason),
 );
 }
}

Promise.reject.call(praca, "Błąd!"); // "Rejected" "Błąd!"
Promise.resolve.call(praca, "OK!"); // "Resolved" "OK!"

  

Opis:
Metoda Promise.reject() statyczna zwraca Promise obiekt, który został odrzucony z podanego powodu. Parametry reason - powód Promise odrzucenia. Wartość zwracana Promise, który zostaje odrzucony z podanego powodu. Funkcja statyczna Promise.reject zwraca wartość Promise, która została odrzucona. Do celów debugowania i selektywnego wychwytywania błędów przydatne jest utworzenie reason pliku instanceof Error. Promise.reject() jest ogólny i obsługuje podklasy, co oznacza, że ​​można go wywołać w podklasach Promise, a wynikiem będzie obietnica typu podklasy. Aby to zrobić, konstruktor podklasy musi zaimplementować tę samą sygnaturę co Promise() konstruktor akceptując pojedynczą executor funkcję, którą można wywołać za pomocą wywołań zwrotnych resolve i reject jako parametr. Promise.reject() jest zasadniczo skrótem od new Promise((resolve, reject) => reject(reason)). W przeciwieństwie do Promise.resolve(), Promise.reject() zawsze zwraca reason nowy Promise obiekt, nawet jeśli reason jest już obiektem Promise.

Linki: