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

Promise.resolve()

[_] [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.resolve(value)

  

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.resolve("OK!").then(
 (value) => {
 console.log(value); // "OK!"
 },
 (reason) => {
 console.error(reason);
 }
);

Promise.reject("Błąd!").then(
 (value) => {
 console.log(value);
 },
 (reason) => {
 console.error(reason); // Błąd!
 }
);

 

const dane = Promise.resolve([5, 10, 15]);
dane.then((value) => {
 console.log(value[1]); // 10
});

 

const daneA = Promise.resolve(10*10);
const daneB = Promise.resolve(daneA);
daneB.then((value) => {
 console.log(`wartość: ${value}`); // "daneA === daneB ? true"
});
console.log(`daneA === daneB ? ${daneA === daneB}`); // "wartość: 100"

 

const daneA = Promise.resolve({
 then(resolved, rejected) {
    resolved("OK!");
 },
});
console.log(daneA instanceof Promise); // true

daneA.then(
 (value) => {
 console.log(value); // "OK!"
 },
 (e) => {
 // 
 },
);


const daneB = Promise.resolve({
 then() {
 throw new TypeError("Błąd!");
 },
});
daneB.then(
 (v) => {
 // 
 },
 (error) => {
 console.error(error); // TypeError: Błąd!
 },
);

 

const zadanie = {
 then(resolvedA, rejectedA) {
 resolvedA({
 then(resolvedB, rejectedB) {
 resolvedB(5*2);
 },
 });
 },
};

Promise.resolve(zadanie).then((value) => {
 console.log(value); // 10
});

 

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

 

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

 

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

 

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!"

 

const mojaPromise = new Promise((resolve, reject) => {
 console.log("StartN"); // StartN
 resolve("StartM");
})

mojaPromise.then((value) => {
 console.log(value); // StartM
 throw new Error("StopN!");
 })
 .catch((e) => {
 console.error(e.message); // StopN!
 })
 .then(() => {
 console.log("Zadanie AAA"); // Zadanie AAA
 });

    

Opis:
Metoda Promise.resolve() statyczna rozwiązuje daną wartość na Promise. Jeśli wartością jest obietnica, ta obietnica jest zwracana; jeśli wartością jest thenable to obiekt posiadający funkcje then(), wywoła Promise.resolve() metodę then() z dwoma przygotowanymi wywołaniami zwrotnymi, w przeciwnym razie zwrócona obietnica zostanie spełniona z wartością. Funkcja ta spłaszcza zagnieżdżone warstwy obiektów podobnych do obietnicy. Parametry value - argument do rozstrzygnięcia w sposób Promise. Wartość zwracana Promise, który jest rozwiązywany z podaną wartością, lub obietnica przekazana jako wartość, jeśli wartość była obiektem obietnicy. Rozwiązana obietnica może znajdować się w dowolnym stanie spełniona, odrzucona lub oczekująca. Na przykład rozwiązanie odrzuconej obietnicy nadal będzie skutkować odrzuceniem obietnicy. Promise.resolve() rozwiązuje obietnicę, co nie jest równoznaczne ze spełnieniem lub odrzuceniem obietnicy. Definicje terminologii znajdziesz w opisie obietnicy. Krótko mówiąc, Promise.resolve() zwraca obietnicę, której ostateczny stan zależy od innej obietnicy, możliwego obiektu lub innej wartości. Promise.resolve() 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 jako parametrów resolve i reject. Promise.resolve() przypadki specjalne, Promise instancje natywne. Jeśli value należy do Promise lub jest podklasą i value.constructor === Promise, to value jest bezpośrednio zwracane przez Promise.resolve(), bez tworzenia nowej Promise instancji. W przeciwnym razie Promise.resolve() jest to zasadniczo skrót od new Promise((resolve) => resolve(value)). Większość logiki rozstrzygającej jest faktycznie implementowana przez funkcję resolve przekazywaną przez Promise() konstruktora. Jeśli zostanie przekazana wartość, która nie jest wówczas możliwa, zwrócona obietnica zostanie już spełniona z tą wartością. Jeżeli zostanie przekazany thenable, zwrócona obietnica przyjmie stan thatable poprzez wywołanie then metody i przekazanie pary funkcji rozstrzygających jako argumentów. Ponieważ natywne obietnice przechodzą bezpośrednio Promise.resolve() bez tworzenia opakowania, then metoda nie jest wywoływana na natywnych obietnicach. Jeśli funkcja resolve otrzyma inny możliwy obiekt, zostanie ona rozwiązana ponownie, tak że ostateczna wartość spełnienia obietnicy nigdy nie będzie możliwa.

Linki:
instanceof -