Nesta palestra e no exercício que se segue,
vamos falar especificamente sobre Callback Hell.
O problema que surge quando escreve
retornos de chamada no nó e especialmente aninhados callbacks e nó.
Nós também olharemos para as promessas como uma maneira de lidar com o problema do Inferno de Callback.
Para lhe dar uma idéia do que o problema típico do Callback Hell resultará,
vamos revisitar o arquivo index.js do exercício anterior.
Como eu estava falando sobre isso no exercício anterior
você percebe que para cada uma das operações que realizamos,
a operação subsequente é incluída dentro da função callback aqui
e assim por diante até que você formar uma pirâmide como estrutura ir novamente.
Então você vê essa pirâmide como estrutura surgindo dentro de seu código.
Agora imagine que você precisa executar várias operações aninhadas como esta,
seu código se tornará muito em breve,
muito complexo e não tão fácil de decifrar.
Agora isso é o que no mundo node.js,
eles se referem como Callback Hell.
Houve várias maneiras de mitigar o problema que surge.
Agora você pode evitar isso completamente devido ao fato de
que você tem certas operações que precisam ser
concluídas antes que a próxima operação possa ser iniciada,
mas podemos reorganizar o código de forma a mitigar esse problema.
Promessas de ser uma dessas formas de lidar com isso.
Então, para resumir o que acabamos de discutir,
código de retorno de chamada fortemente aninhado,
causa o problema Callback Hell e isso
resulta da nossa tendência de escrever programas de cima para baixo.
Ainda estamos desligados com a nossa maneira sequencial de escrever código e
por isso vemos mais conveniente escrever código de cima para baixo,
e olhá-lo como se ele estivesse sendo executado nessa ordem.
Agora podemos contornar o problema do Callback Hell
não usando funções anônimas para os callbacks, mas em vez disso,
declarando essas funções com nomes específicos,
e, em seguida, evitar a maneira como escrevemos o código como você viu aqui.
Essa é uma das abordagens que as pessoas tomam para lidar com o problema do Callback Hell.
Existem várias outras abordagens que foram sugeridas,
links para alguns artigos a este respeito são fornecidos nos recursos adicionais.
Mas nesta palestra em particular,
vou me concentrar em uma abordagem particular que
é usada para lidar com o problema do Inferno de Callback,
que é o uso de promessas.
Então podemos usar promessas para domar o problema do Inferno de Callback até certo ponto.
Vamos olhar para como promessas nos ajudar a este respeito e
no exercício vamos ver como, porque o driver NODE-MONGO DB já
suporta uma interface proxy, podemos aproveitar isso para reescrever nosso código
para aproveitar o suporte de promessa no driver MONGO DB.
Resumindo brevemente o que é uma promessa.
Uma promessa é um mecanismo que suporta computação assíncrona.
Então, se você tem quantidade de trabalho que precisa ser feito,
a promessa atua como um proxy para um valor que
não é conhecido no momento, mas a promessa é dada a você.
Mas quando o valor ficar disponível,
ele estará disponível no futuro.
Então a promessa representa um espaço reservado para esse valor.
Se o valor resultar corretamente,
então sua promessa resulta corretamente e você pode ter
um pedaço de código executado a fim de lidar com o fato de que a promessa foi resolvida corretamente,
se não, então você lida com o erro nessa situação.
Assim, uma promessa resolverá ou em determinação ou rejeição da promessa.
Uma promessa pendente pode resolver
quando o valor é obtido corretamente, então, nesse caso,
ela será resolvida ou o que chamamos de cumprimento da promessa.
Então, quando a promessa for resolvida,
então você terá um pedaço de código que
lida com o fato de que a promessa foi resolvida.
Se a promessa for rejeitada,
você também deve lidar com essa situação
a rejeição da promessa correspondentemente dentro do seu código.
Portanto, essa é a razão pela qual sempre que você cria uma promessa,
você fornece apenas as opções de resolução e rejeição a partir dela.
A opção de resolução é tipicamente tratada pelo médico, em seguida, opção para a sua promessa.
Então, por que usamos promessas?
As promessas são usadas porque
aborda o problema do inferno de retorno de chamada em grande medida e as promessas podem ser alteradas.
Por exemplo, se você tiver uma promessa que,
por sua vez, aciona uma chamada para outra que retornará uma promessa.
O tratamento da promessa pode ser alterado para o identificador da promessa anterior.
Então você pode ter um monte de,
em seguida, chamadas que irá lidar com o retorno do valor.
Agora vamos ver o uso disso no exercício que segue esta palestra.
Para consumir uma promessa,
você registrará uma função de retorno de chamada apropriada para
quando o consumidor de uma promessa for notificado
do cumprimento ou da rejeição da promessa.
Assim, os retornos de chamada são registrados através do.then () para a promessa.
Você usará o.catch () para detectar os erros dentro da promessa de retorno.
Agora os métodos o.then () podem ser acorrentados
juntos como você verá no exercício que se segue.
Como exemplo, você normalmente lidaria com uma promessa
encadeando.then () e o.catch () ao valor da promessa.