Análise do uso da promessa de nodejs

JavaScript é caracterizado por assíncrona. JavaScript não pode esperar. Se você implementar algo que precisa ser esperado, não poderá parar por aí e esperar o resultado voltar. Pelo contrário, o ponto principal é usar o retorno de chamada de retorno: você define uma função, que só pode ser chamada até que o resultado esteja disponível.

Esse modelo de retorno de chamada não tem nenhum problema com uma boa organização de código, mas também pode resolver muitos problemas, mudando do retorno de chamada original para prometer. Trate a promessa como um contêiner de dados padrão, que simplificará sua organização de código e se tornará uma arquitetura baseada em promessa.

O que é uma promessa?

Uma promessa é um objeto com o método ".then ()", que representa o resultado de uma operação que ainda não pode ser conhecida. Não importa quem acessa esse objeto, ele pode usar o método ".then ()" para adicionar um retorno de chamada para aguardar um lembrete para aguardar que a operação tenha um resultado ou falha bem -sucedida.

Então, por que os benefícios de fazer isso melhor do que retornos de chamada? O modo de retorno de chamada padrão exige que forneçamos funções de retorno de chamada ao mesmo tempo ao processar solicitações:

 request (url, function (erro, resposta) {// lidera o sucesso ou erro.}); doSomethingElse ();

Infelizmente, esse código significa que essa função de solicitação não sabe quando será concluída por si só e, é claro, não é necessário. Finalmente passamos o resultado através do retorno de chamada. Isso faz com que vários retornos de chamada formem retornos de chamada aninhados ou armadilhas de retorno de chamada.

 QueryThEdAtabase (consulta, função (erro, resultado) {request (url, function (erro, resposta) {doSomethingElse (resposta, função (erro, resultado) {DoanOtherthing (resultado, função (erro, resultado) {request (outra função, e erro, resposta) {...});});

A promessa pode resolver esse problema, permitindo que o código de baixo nível crie uma solicitação e depois retorne um objeto, que representa uma operação inacabada, permitindo que o chamador decidisse quais retornos de chamada devem ser adicionados.

O que é uma promessa?

A promessa é uma abstração da programação assíncrona. É um objeto proxy que retorna um valor ou lança uma exceção. Geralmente, os objetos de promessa têm um método então. Esse método é como obtemos o valor de retorno (o valor do resultado da implementação bem -sucedido da promessa é chamado de cumprimento) ou lançamos uma exceção (o motivo da rejeição da promessa é chamado de rejeição). Em seguida, use dois retornos de chamada opcionais como parâmetros, que podemos chamar de Onfulfilled e OnRejected:

var promessa = doSomethingAync ()

Promise.HETHEN (Onfulfilled, OnRejeded)

Quando essa promessa for resolvida, isto é, após a conclusão do processo assíncrono, será chamado onfulfilled e on -rejetado.

Portanto, uma promessa tem os três estados diferentes:

■ Preparado a ser prometido - estado inicial de promessa

■ Compromisso de implementação cumprido-um compromisso de implementação bem-sucedida Estado

■ Rejeitou a rejeição do compromisso - um estado em que a promessa falhou

Tomando o arquivo de leitura como um caso, o seguinte é o que deve ser feito após a leitura do arquivo usando um retorno de chamada (impressão de saída):

 readfile (function (err, dados) {if (err) retornar console.error (err) console.log (dados)})

Se nossa função ReadFile retornar uma promessa, podemos implementar a mesma lógica da seguinte maneira (impressão de saída):

var promey = readfile ()

Promise.Then (Console.log, Console.error)

Aqui temos uma promessa de valor que representa uma operação assíncrona. Podemos passar esse valor prometido o tempo todo. Qualquer pessoa que acessa esse valor pode usar para consumi -lo. Independentemente de a operação assíncrona representada por esse valor ser concluída ou não concluída, também podemos garantir que o resultado assíncrono não mude, porque a operação assíncrona representada por essa promessa será executada apenas uma vez e o estado será cumprido ou rejeitado.

Compreender a promessa

A promessa pode ser diferente da intuição diária. Para entendê -lo, alguns princípios importantes devem ser lembrados:. Então () sempre retorna uma nova promessa. Conforme mostrado no código a seguir:

var promey = readfile ()

var prometo2 = promessa.then (readanotherfile, console.error)

Aqui, o parâmetro readanotherfile, console.eror representa a ação realizada após a operação assíncrona ser bem -sucedida ou a ação rejeitada após o sucesso da falha. Ou seja, após a execução da função ReadaNotherFile, caso contrário, o registro de impressão falhado está incorreto. Essa implementação só é possível de duas maneiras.

Vejamos o seguinte código:

 var promey = readfile () var promey2 = prometo.then (function (dados) {return readanotherfile () // se readfile for bem -sucedido, execute readanotherfile}, function (err) {console.error (err) // se readFile não for bem -sucedido, grave, mas ainda exteja o readanotherfile readanotherLil) // Execução Resultado da função ReadaNotherFile

Porque então retorna uma promessa, isso significa que a promessa pode ser gasta encadeando a cadeia serial, o que pode evitar o inferno de retorno de chamada:

 readfile () .THEN (readanotherfile). então (Dosomethingelse). então (...)

Existem duas partes da regra da promessa que devem ser separadas:

(1). Então () sempre retorna uma nova promessa. Toda vez que você chama, isso não importa o que o retorno de chamada faz, porque .hen () já oferece uma promessa antes que o retorno de chamada seja chamado. O comportamento do retorno de chamada afeta apenas a implementação da promessa da promessa. Se o retorno de chamada retornar um valor, a promessa usará esse valor. Se esse valor for uma promessa, retorne o valor após a implementação da promessa a esse valor. Se o retorno de chamada lançar um erro, a promessa rejeitará o erro.

(2) A promessa devolvida por .THEN () é uma nova promessa, que é diferente daquelas. A longa cadeia de promessas às vezes esconde o fato de que, não importa o quê, toda chamada. Então () produzirá uma nova promessa. O que você deve observar aqui é que o que você realmente precisa considerar é que sua última chamada. Então () pode representar a falha; portanto, se você não pegar essa falha, é fácil fazer com que sua exceção de erro desapareça.

Algumas pessoas pensam que a chamada de cadeia .hen () é muito semelhante ao estilo fluente, mas a cadeia de promessas longas será confusa e finalmente dividida em funções significativas:

 function gettasks () {return $ http.get ('http://example.com/api/v1/tasks') .then (function (resposta) {return Response.data;});} função getMyTasks () {return getTasks () .Then (function (Tasks) {TaskSasks () });}

Neste exemplo, as duas funções obtêm uma promessa, carregando uma função de retorno de chamada.

Promessa interessante

A mesma promessa pode aceitar qualquer número de retornos de chamada. Quando uma promessa é resolvida e implementada, todas as funções de retorno de chamada serão chamadas. Além disso, uma promessa pode até aceitar um novo retorno de chamada após ser resolvido e implementado. Esses retornos de chamada podem ser chamados de maneira normal, o que nos permite usar retornos de chamada para implementar uma forma simples de cache:

 var tasksPromise; function gettasks () {taskpromise = taskpromise || getTasksFromTheServer (); Retornar a TaskProme;}

Nesse caso, a função getTasks () pode ser chamada de várias vezes, ela sempre retorna a promessa dos dentes de cobre, onde a função GetTasksFromTheServer () é chamada apenas uma vez.

O uso do NodeJS Promise acima é 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.