Resolva que a função de retorno de chamada é muito profunda e a lógica paralela deve ser executada em série. Uma promessa representa o resultado final de uma operação assíncrona. A principal maneira de interagir com a promessa é registrar a função de retorno de chamada através do método então () para receber o valor final do resultado da promessa.
Protocolos relacionados à promessa incluem Promisea e Promisea+
Defina uma promessa de classe
Defina a fila da fila de atributos, inicialize a matriz vazia []
Defina o valor da propriedade, inicialize nulo
Defina o status do status da propriedade e inicialize "pendente" (valor padrão)
Defina o método do membro getQueue (), retornar a fila de atributo
Defina o método do membro getStatus (), retorne o status do atributo
Defina o método do membro setStatus (), definir status, PASS parâmetros: status, valor
Determinar que o status é cumprido ou rejeitado,
Defina a propriedade de status this.status = status
Defina a propriedade Value this.value = Value || nulo, se você não passa o valor, é nulo
Defina a variável congelada FreezeObject
Defina o método do membro isfulfilled () para determinar se o estado atual é (concluído)
Defina o método do membro isrejeded () para determinar se o estado atual é (falhou)
Defina o método do membro isPending (), determine que o mestre de status atual é (espera)
Definir o método do membro então (), PASS parâmetros: retorno de chamada bem -sucedido do Onfulfilled, Retorno de chamada com falha OnRejected
Defina duas funções de retorno de chamada: objeto manipulador, atributo atendido, rejeitado
Defina a propriedade diferida do objeto Handler, o objeto diferido
Determine se o estado atual está esperando. Se estiver esperando, coloque o objeto Handler na matriz da fila da fila
Se não for um estado de espera, ligue para o método procedure () do objeto Utils, parâmetro: status,
Return Handler.Deferred.Prome Object
Defina uma classe diferida
Defina a promessa do atributo e inicialize o objeto de promessa
Defina o método do membro resolve (), passe o parâmetro: resultado resultado
Determine o status do objeto de promessa como espera e retorne diretamente
Chame o método getQueue () do objeto Promise para obter a matriz da fila
Array de loop
// TODO chama os utilitários da classe de ferramentas. Método Procedimento (), Parâmetros: "cumprido", elemento, informação de erro
Chame o método setStatus () do objeto Promise, defina o status, parâmetros: 'cumprido', resultado
Definir o método do membro rejeitar, aprovar o parâmetro: errar mensagem de erro
Determine o status do objeto de promessa como espera e retorne diretamente
Chame o método getQueue () do objeto Promise para obter a matriz da fila
Array de loop
// TODO, ligue para os utilitários da classe de ferramentas. Método do Procedimento (), Parâmetros: "Rejeitado", Elemento, Erro Informações
Chame o método setStatus () do objeto Promise, defina o status, parâmetros: 'cumprido', resultado
Defina os utilitários da classe de ferramentas, execute -o imediatamente usando funções anônimas e obtenha um objeto
Retorna o objeto, existe um procedimento de método () no objeto
Definir o método do procedimento (), passe parâmetros: tipo de estado, matriz de processador de manipulador, resultado do resultado
Obtenha a função de processamento func, no manipulador [tipo]
Eu estava tonto quando cheguei aqui. . .
Como usar:
Defina uma função Ajax, passe no parâmetro: caminho da URL
Obtenha o objeto diferido e saia novo
Código do Ajax para solicitar dados, no método de retorno de chamada que retorna dados
Se o método resolve () do objeto diferido for chamado com sucesso, parâmetro: retornar dados
Se o método reject () do objeto diferido for chamado falha, parâmetro: dados retornados
Devolver o objeto diferido.promise
Chame ajax () Método para obter o objeto Promise, parâmetro: url,
Chame o método então () do objeto Promise, parâmetros: função anônima
Chame o método Ajax () para obter o objeto Promise e devolver este objeto
Formar uma chamada de cadeia
Parte do JS:
<Cript> // Promise Code Part (escolhi o cinto de cachorro) Promise = function () {this.queue = []; this.value = null; this.status = 'pendente'; // pendente de rejeição rejeitado}; prometo.prototype.getQueue = function () {return this.queue;}; prometo.prototype.getStatus = function () {return this.status;}; prometo.protype.setStus = FUNCIMEND () {Value). 'rejeitado') {this.status = s; this.value = valor || nulo; this.queue = []; var freezeObject = object.freeze || função(){}; freezeObject (this); // O estado de promessa é irreversível} else {lança um novo erro ({message: "não suporta status:" + s}); }}; Prometo.prototype.isfulFiled = function () {return this.status === 'Fulfilled';}; promeso.prototype.isRejected = function () {return this.status === 'rejeited';} prometo.protype.isping = function () {Return this.styt.stty. function (onfulfilled, onrejected) {var Handler = {'cumprido': onfulfilled, 'rejeitado': onRejected}; Handler.Deferred = new adiFerred (); if (! this.isiscending ()) {// Isso pode alterar o status da promessa primeiro e adicione retornos de chamada utils.procedure (this.status, manipulador, this.value); } else {this.queue.push (manipulador); // pode ser chamado várias vezes na mesma promessa; especificação 2.2.6} retorna manipulador.deferred.promise; // deve retornar uma promessa; especificação 2.2.7}; var utils = (function () {var makenaler = function (diferred, tipo, tipo) {Tipo, function {function {function {function {return {return {retorn {); Procedimento = Função (Tipo, Handler, resultado) {var FUNC = Handler [Type]; newResult.then (function (dados) {// def.resolve (data); //}, function (err) {// def.reject (err); //}); rejeitada. Catch (err) {transição (def, rejeitado ', err); ! } var queue = this.promise.getQueue (); for (var i = 0, len = fileue.length; i <len; i ++) {utils.procedure ('cumprido', fila [i], resultado); } this.promise.SetStatus ('cumprido', resultado);}; } var queue = this.promise.getQueue (); for (var i = 0, len = fileue.length; i <len; i ++) {utils.procedure ('rejeitada', fila [i], err); } this.promise.setStatus ('rejeitado', err);}/******************************************************************************* var xhr = novo xmlHttPrequest (); xhr.onReadyStateChange = function () {if (xhr.readyState === 4) {if ((xhr.status> = 200 && xhr.status <300) || xhr.status === 304) {Def.Resolve (xhr.RestonsEtoTtxt)} Erro ({message: xhr.status})); }}}}}; xhr.open ('get', url, true); xhr.send (nulo); return def.promise;} ajax ('test.php? Act = 1'). Então (function (data1) {console.log (data1); // manipulam dados1 retornar ajax ('test.php? act = 2');}). {console.error (err);}). Então (function (data3) {console.log (data3); alert ('sucesso');}, function (err) {console.error (err);}); </script>PHP:
<? phpif ($ _ get ['Act'] == 1) {echo json_encode (Array ("code" => 200));} else if ($ _ get ['Act'] == 2) {echo json_encode (Array ("code" => 300); JSON_ENCODE (Array ("Code" => 400));}O resumo acima do simples aprendizado e uso da promessa de JavaScript é todo o conteúdo que compartilho com você. Espero que você possa lhe dar uma referência e espero que você possa apoiar mais o wulin.com.