Antes de iniciarmos a introdução formal, queremos ver como é a promessa de JavaScript:
A cópia do código é a seguinte:
var p = nova promessa (função (resolver, rejeitar) {
Resolve ("Hello World");
});
p.hen (função (str) {
alerta (str);
});
1. Então () retorna uma promessa bifurcada
Qual é a diferença entre os dois códigos a seguir?
A cópia do código é a seguinte:
// Anexo a
var p = nova promessa (/*...*/);
p.hen (func1);
p.hen (func2);
// Anexo b
var p = nova promessa (/*...*/);
p. then (func1)
.THEN (func2);
Se você considerar cuidadosamente as duas peças de código acima, as promessas são apenas uma variedade unidimensional de funções de retorno de chamada. No entanto, esse não é o caso. Cada um então () Call retorna uma promessa bifurcada. Portanto, na exposição, se o func1 () lança uma exceção, o func2 () ainda é chamado normalmente.
No ExpostB, se o func1 () lançar um erro, o fun2 () não será chamado porque a primeira chamada retorna uma nova promessa, que será rejeitada no FUNC1 (). O resultado está ignorando o func2 ().
Resumo: As promessas podem ser bifurárias em vários caminhos, semelhantes aos fluxogramas complexos.
2. Retorno de chamada deve passar o resultado
O que receberá um aviso ao executar o código a seguir?
A cópia do código é a seguinte:
var p = nova promessa (função (resolver, rejeitar) {
Resolve ("Hello World");
});
p.hen (função (str) {})
.Then (function (str) {
alerta (str);
});
O alerta no segundo então () não mostra nada. Isso ocorre porque a função de retorno de chamada, no contexto da promessa, não há função de retorno de chamada porque o resultado muda. Promise espera que seu retorno de chamada retorne o mesmo resultado ou um resultado de substituição, que é transmitido para o próximo retorno de chamada.
Semelhante ao uso do Adpater para alterar os resultados, da seguinte forma:
A cópia do código é a seguinte:
var feettomeTres = function (ft) {return ft*12*0,0254};
var p = nova promessa (/*...*/);
p. then (feettomeTres)
.Then (função (metros) {
alerta (metros);
});
3. Apenas exceções da camada anterior podem ser capturadas
Qual é a diferença entre essas duas peças de código?
A cópia do código é a seguinte:
// Anexo a
nova promessa (função (resolver, rejeitar) {
Resolve ("Hello World");
})
.então(
função (str) {
lançar um novo erro ("uh oh");
},
indefinido
)
.então(
indefinido,
função (erro) {
alerta (erro);
}
);
// Anexo b
nova promessa (função (resolver, rejeitar) {
Resolve ("Hello World");
})
.então(
função (str) {
lançar um novo erro ("uh oh");
},
função (erro) {
alerta (erro);
}
);
Na primeira peça de código, a exceção no primeiro então () é lançada e será capturada pelo segundo então (), e o aviso "uh oh" será acionado. Este guia apenas exceções no nível anterior será capturado.
Na segunda parte do código, a função de retorno de chamada e a função de retorno de chamada estão no mesmo nível, o que significa que, quando uma exceção é lançada no retorno de chamada, ela não será capturada. De fato, o retorno de chamada de erro do segundo código só será lançado se a promessa for rejeitada ou se a promessa em si estiver errada.
4. Os erros podem ser restaurados
Em uma função de retorno de chamada de erro, se você não lança novamente o erro, a Promise pressupõe que você se recuperou do erro e invertido para um estado resolvido. No próximo exemplo, "I'm Saved" será exibido porque o retorno de chamada de erro no primeiro então () não re-lança a exceção.
A cópia do código é a seguinte:
var p = nova promessa (função (resolver, rejeitar) {
rejeitar (novo erro ("pebkac"));
});
p. then (
indefinido,
função (erro) {}
)
.então(
função (str) {
alerta ("Estou salvo!");
},
função (erro) {
alerta ("computador ruim!");
}
);
A promessa pode ser vista como uma camada em uma cebola. Cada um então () adiciona outro nível à cebola. Cada nível representa uma atividade processada. Quando a hierarquia terminar, o resultado é considerado fixo e pronto para a próxima hierarquia.
5. As promessas podem ser suspensas
Como você está pronto para executar em um método (), isso não significa que você não pode pausar e executar outros com antecedência. Para pausar a promessa atual ou aguardá -la por outra promessa de concluir, basta retornar outra promessa em então ().
A cópia do código é a seguinte:
var p = nova promessa (/*...*/);
p.hen (função (str) {
if (! loggedin) {
retornar nova promessa (/*...*/);
}
})
.Then (function (str) {
alerta ("feito");
})
No código anterior, o prompt não aparecerá até que a nova promessa seja analisada. Esta é uma maneira conveniente de introduzir mais dependências no caminho de código assíncrono existente. Por exemplo, você pode achar que a sessão do usuário tem tempo limite e pode inicializar o segundo login antes de continuar com o caminho de código anterior.
6. As promessas resolvidas não serão executadas imediatamente
Você receberá uma caixa rápida ao executar o código a seguir?
A cópia do código é a seguinte:
function runme () {
var i = 0;
nova promessa (função (resolve) {
resolver();
})
.then (function () {
i += 2;
});
alerta (i);
}
Como a promessa é analisada imediatamente e depois () o método é executado imediatamente, você pode pensar que o prompt 2 será sondado. No entanto, a definição da promessa exige que todas as chamadas sejam forçadas assíncronas. Portanto, o prompt será gerado antes de ser modificado.