CKTIS / JavaScript
Funções resolve e reject do executor de Promise
O construtor `Promise` entrega duas funções ao executor. A primeira chamada a uma delas fixa o resultado da promessa, mas esta pode continuar pendente.
Versão: ECMAScript 2024 and the current web platform; runtime support varies
Sintaxe
new Promise((resolve, reject) => { /* Call resolve(value) or reject(reason). */ });new Promise(executor) exige uma função e chama-a de forma síncrona, passando primeiro resolve e depois reject. São nomes convencionais dos parâmetros; cada par está associado a uma única promessa acabada de criar. Ambas as funções devolvem undefined e podem ser guardadas para uma chamada posterior, por exemplo numa função de retorno. Já os métodos estáticos Promise.resolve() e Promise.reject() devolvem promessas.
resolve(value) cumpre imediatamente a promessa com o valor se este for primitivo. Passar a promessa à sua própria função resolve rejeita-a com um TypeError. Para qualquer outro objeto, o JavaScript lê a propriedade then de forma síncrona. Se o valor lido não for invocável, a promessa é cumprida de imediato com o próprio objeto, mesmo que este seja outra promessa. Se o valor lido for invocável, o objeto é um thenable: o JavaScript só chama then mais tarde. A promessa adota o resultado do thenable e pode continuar pendente. Uma exceção ao ler then, ou ao chamá-lo antes de ser invocada qualquer uma das funções de retorno que recebe, também causa a rejeição.
reject(reason) rejeita de imediato a promessa com o motivo indicado, sem adotar o seu resultado mesmo que o motivo seja uma promessa. É aceite qualquer valor, mas um objeto Error costuma ser mais útil. Omitir o argumento equivale a usar undefined. Só conta a primeira chamada a uma das duas funções, mesmo se a promessa ainda estiver pendente. O resultado já está fixado (resolved), mas a promessa só fica concluída (settled) quando é cumprida ou rejeitada. As funções de tratamento registadas com then() e catch() são executadas de forma assíncrona.
O construtor ignora o valor devolvido pelo executor. Uma exceção que sai do executor de forma síncrona só rejeita a promessa se ainda não tiver sido chamada nenhuma das funções. Se nenhuma for chamada e o executor não lançar uma exceção, a promessa fica pendente. Evita um executor async: o construtor ignora a promessa que este devolve, pelo que a rejeição dessa promessa não rejeita a promessa exterior.
Exemplos
{
let finish;
const inner = new Promise((resolve) => {
finish = resolve;
});
const outer = new Promise((resolve, reject) => {
console.log("executor");
resolve(inner);
reject(new Error("ignored"));
});
console.log("after constructor");
outer.then((value) => {
console.log(`fulfilled: ${value}`);
return new Promise((resolve, reject) => {
reject(new Error("failed"));
});
}).catch((reason) => {
console.log(`rejected: ${reason.message}`);
});
finish(42);
}Resultado
executor after constructor fulfilled: 42 rejected: failed
`executor` aparece antes de `after constructor` porque o executor corre de forma síncrona. `resolve(inner)` fixa o resultado de `outer` enquanto `inner` ainda está pendente, pelo que `reject(new Error("ignored"))` não tem efeito. `finish(42)` cumpre `inner`; a função de tratamento escreve `fulfilled: 42` e, em seguida, `catch()` trata a rejeição de outra promessa com a mensagem `failed`.
Lições relacionadas
- JavaScript · Lição 14 · Intermédio · Versão: 3
- JavaScript · Lição 15 · Intermédio · Versão: 3