O modo de programação de promessa também é chamado de time, que pode ser entendido como execução após atraso. Cada promessa tem uma interface exclusiva chamada então e, quando a promessa falha ou é bem -sucedida, ela fará um retorno de chamada. Representa um resultado de operação que pode durar muito tempo e não precisa necessariamente ser concluído. Esse padrão não bloqueia e aguarda a conclusão das operações de longo prazo, mas retorna um objeto que representa o resultado prometido.
Muitas bibliotecas JavaScript atuais (como jQuery e Dojo, AngularJs) adicionam essa abstração chamada Promise. Através dessas bibliotecas, os desenvolvedores podem usar o modo de promessa na programação real.
Abaixo, usaremos o JQuery como exemplo para discutir como as bibliotecas JavaScript usam o modo Promise para lidar com processamento assíncrono, que é realmente para fornecer suporte tolerante a falhas através de retornos de chamada. Quando uma operação é bem -sucedida ou falha ou, em qualquer caso, o retorno de chamada correspondente é executado e tente lidar com quaisquer situações possíveis em uma determinada peça de lógica.
Primeiro, vamos dar uma olhada em como o jQuery geralmente opera:
A cópia do código é a seguinte:
var $ info = $ ("#info");
$ .ajax ({
url: "/eco/json/",
Dados: {json: json.stringify ({"name": "somevalue"})},
Tipo: "post",
Sucesso: função (resposta)
{
$ info.text (resposta.name);
}
});
Neste exemplo, você pode ver que, quando a configuração for bem -sucedida, será especificado um retorno de chamada, que é um bom método de retorno de chamada. Esta não é uma promessa, e a documentação oficial do jQuery não recomenda mais esse método (http://api.jquery.com/jquery.ajax/#jqxhr). Quando a chamada do Ajax é concluída, ele executa a função de sucesso. Dependendo das operações assíncronas usadas pela biblioteca, você pode usar vários retornos de chamada diferentes (ou seja, se a tarefa é bem -sucedida ou não, ela será chamada de volta e responde). Usando o modo de promessa simplifica esse processo, as operações assíncronas exigem apenas devolver uma chamada de objeto. Essa promessa permite chamar um método chamado e, em seguida, permite especificar o número de funções do retorno de chamada.
Vamos dar uma olhada em como o jQuery cria uma promessa:
A cópia do código é a seguinte:
var $ info = $ ("#info");
$ .ajax ({
url: "/eco/json/",
dados: {
json: json.stringify ({
"Nome": "algum valor"
})
},
Tipo: "Post"
})
.then (função (resposta) {
$ info.text (resposta.name);
});
O objeto JQuery Ajax implementa o modo de promessa retornando o objeto XHR, para que possamos chamar o método então. A vantagem de fazer isso é que você pode encadear chamadas e implementar operações independentes, como mostrado abaixo:
A cópia do código é a seguinte:
var $ info = $ ("#info");
$ .ajax ({
url: "/eco/json/",
dados: {
json: json.stringify ({
"Nome": "algum valor"
})
},
Tipo: "Post"
})
.then (função (resposta) {
$ info.text (resposta.name);
})
.then (function () {
$ info.append ("... mais");
})
.DONE (function () {
$ info.append ("... finalmente!");
});
As operações assíncronas tornam -se muito fáceis, pois muitas bibliotecas começam a usar o modo Promise. Mas se você pensa da perspectiva oposta, como seria prometer? Um dos padrões muito importantes é que a função pode aceitar duas funções, uma é um retorno de chamada quando bem -sucedido e a outra é um retorno de chamada quando falha.
A cópia do código é a seguinte:
var $ info = $ ("#info");
$ .ajax ({
// Alterar URL para ver o erro acontecer
url: "/eco/json/",
dados: {
json: json.stringify ({
"Nome": "algum valor"
})
},
Tipo: "Post"
})
.then (função (resposta) {
// sucesso
$ info.text (resposta.name);
},
function () {
// falha
$ info.text ("coisas ruins acontecem com bons desenvolvedores");
})
.always (function () {
$ info.append ("... finalmente");
});
Deve -se notar que, no jQuery, bem -sucedido ou falhado, usaremos uma chamada para especificar o que queremos ligar.
De fato, você também pode escrever isso aqui, que também é o método recomendado no documento oficial da JQuery:
A cópia do código é a seguinte:
var $ info = $ ("#info");
$ .ajax ({
// Alterar URL para ver o erro acontecer
url: "/eco/json/",
dados: {
json: json.stringify ({
"Nome": "algum valor"
})
},
Tipo: "Post"
})
.done (função (resposta) {
// sucesso
$ info.text (resposta.name);
}). Fail (function () {
// falha
$ info.text ("coisas ruins acontecem com bons desenvolvedores");
})
.always (function () {
$ info.append ("... finalmente");
});
Vamos dar uma olhada em como o AngularJS usa o modo de promessa:
A cópia do código é a seguinte:
var m = angular.module ("myApp", []);
M.Factory ("DataService", função ($ Q) {
função _callme () {
var d = $ q.defer ();
setTimeout (function () {
d.Resolve ();
//defer.reject ();
}, 100);
retornar d.promise;
}
retornar {
Callme: _CallMe
};
});
função myctrl ($ SCOPE, DataService) {
$ scope.name = "nenhum";
$ scope.isbusy = true;
DataService.Callme ()
.then (function () {
// Bem-sucedido
$ SCOPE.NAME = "SUCCESSO";
},
function () {
// falha
$ scope.name = "falha";
})
.then (function () {
// como uma cláusula finalmente
$ scope.isbusy = false;
});
}
Você pode experimentar esses exemplos no JSFiddle e ver quais efeitos serão produzidos. Usar promessa para operar assíncrono é uma maneira muito simples e também pode simplificar seu código. É realmente uma boa maneira de matar dois pássaros com uma pedra.
Para mais apresentações e exemplos sobre promessa, você pode acessar o site oficial (http://www.promisejs.org/).