[MÚSICA]
Quando estávamos falando de serviços no módulo anterior, eu mencionei
sobre promessas e então prometi que voltarei às promessas neste módulo.
Então, aqui estamos eu vou cumprir minha promessa a você.
Uma computação síncrona está por todo o lado na World Wide Web.
E como a web opera.
Se você está vindo do mundo da programação sequencial,
envolvendo sua cabeça em torno de uma computação síncrona requer um pouco de esforço.
Houve muitas tentativas de tornar a computação assíncrona tão indolor quanto
possível para as pessoas que fazem a transição para ele a partir do livro de computação sequencial.
Uma dessas tentativas é tornar a computação assíncrona
mais fácil de realizar é promessas.
Como percebemos, quando fazemos qualquer solicitação para qualquer serviço
ou para um servidor back-end,
vai levar algum tempo para que os resultados se tornem disponíveis para nós.
Se fizermos tal solicitação enquanto estamos prosseguindo com nosso trabalho,
então há uma alta probabilidade de que nosso cálculo fique preso no ponto,
aguardando os resultados.
Este é um não-não em termos de fazer uma boa experiência de usuário.
Portanto, é importante que sempre que seus resultados vão levar tempo
você deve ser capaz de avançar sem esperar pelas regras.
E é aí que a computação assíncrona vem a sua vantagem.
Em computação assíncrona quando você envia uma solicitação
você está esperando que os resultados voltem mais tarde, e
você deve ser capaz de lidar com o fato, os resultados de base voltar em um momento
muito mais tarde do que onde você estava no momento em que você fez o pedido.
Promessas nos fornecem uma maneira de lidar com isso.
Vejamos as promessas com um pouco mais de detalhes nesta palestra.
E então também veremos o uso de promessas
em nossa aplicação Angular um pouco mais tarde.
Promessas, o conceito geral é uma área muito vasta por si só.
E neste curso, eu não tenho tempo para passar pelos detalhes das promessas.
Isso vai se tornar um curso inteiro em si mesmo.
Eu vou dar-lhe apenas o essencial das promessas que são necessárias para
nós para entender como fazer uso de promessas dentro de nossa aplicação angular.
Eu fornecer-lhe um monte de leads para recursos
adicionais onde você pode ir e examinar promessas com mais detalhes.
Então, descendo a essa questão, o que exatamente é uma promessa?
A promise é um mecanismo que suporta computação assíncrona.
Acabei de dar uma longa explicação de porque a computação assíncrona
é essencial para a web funcionar.
Agora, ao usar uma promessa, a promessa fornece um mecanismo ou
um proxy para um valor que não está disponível no momento em que você solicitar.
Assim, uma promessa retornará uma promessa para você, dizendo que
quando o resultado estiver disponível, ele voltará e entregará os resultados para você.
Assim, uma promessa retorna um objeto proxy para você, e você mantém o objeto proxy.
E esse objeto proxy lhe dará acesso aos resultados quando estiverem disponíveis.
E há um método em como você espera pelos resultados.
Você realmente não suspende seu cálculo nesse ponto, em vez disso, você
configurar uma maneira de aceitar os resultados quando ele voltar dessa promessa.
Para resumir,
promise representa um valor que estará disponível em um momento futuro.
Também pode estar imediatamente disponível,
caso em que a promessa retornará o valor imediatamente.
Mas no caso de ele precisar retornar um valor em uma data futura, então ele lhe dá
a promessa de que esse valor quando ele se tornar disponível será devolvido a você.
Há sempre a possibilidade de que a promessa não possa ser cumprida,
porque os resultados não estão disponíveis por qualquer motivo.
Nesse caso, um erro será entregue a você, ou uma rejeição será entregue
a você, e cabe a você lidar com o fato de que a promessa foi rejeitada.
Olhamos como lidamos com isso no próximo slide.
Como aprendemos anteriormente, uma promessa é um proxy para
algo que iria acontecer no futuro ou pode nunca acontecer no futuro.
Assim, uma promessa quando for dada a você, estará no estado pendente.
Agora, quando a promessa resolver, que é que os resultados se tornam disponíveis e
a promessa é capaz de entregar os resultados para você, então a promessa vai resolver ou
vai cumprir.
E nesse caso, a promessa será movida do estado pendente para a resolução ou
o estado de preenchimento.
Então, nesse ponto, seus resultados estão disponíveis para você.
Há uma pequena chance de que a promessa pode ser rejeitada por causa de um erro,
ou qualquer que seja o motivo.
Nessa circunstância remota,
você receberá uma rejeição e, nesse caso, a promessa será
considerada no estado rejeitado quando a rejeição for entregue.
Então, quando você gera uma promessa, como eu disse,
uma promessa é um objeto proxy que é entregue a você.
Então, quando você entregar uma promessa a alguém, a promessa internamente terá
uma função que lidará com tanto a resolução quanto
as opções de rejeição lá dentro.
Quando você escreve código,
você verá que você vai escrever código como novo Promessa (função (resolver, rejeitar).
Portanto, se ele resolve ou é rejeitado, precisamos ser capazes de enviar
de volta as informações para quem entregamos a promessa.
Como fazemos isso em código?
Vamos dar uma olhada nisso no próximo slide.
Aqui está um exemplo de como a promessa é configurada no código.
Na verdade, este exemplo é derivado do exercício que você fará
um pouco mais tarde.
Então aqui, quando configuramos nosso serviço, podemos fazer com que nosso serviço
retorne uma promessa a um componente que solicita dados do serviço.
Então, quando a promessa é retornada,
então a promessa de retorno está disponível para você como um objeto.
E essa promessa fornece dois métodos, o então e o método catch.
Agora, então, a promessa foi resolvida com sucesso.
Em seguida, a promessa resultará
em chamar uma resolução.
Como você viu, a promessa é construída, e dentro da promessa,
você tem a função, a resolução e rejeição, como os dois parâmetros.
Então, se a promessa é capaz de entregar o resultado com sucesso,
então ele vai chamar o método de resolução e, em seguida, retornar o resultado para você.
Onde o resultado obtém a realidade?
Quando você escreve código esperando por
a promessa, em seguida, você especificaria o que fazer quando a promessa retorna o resultado
na opção então para essa promessa.
Então digamos, por exemplo, você diria getdishes.Then e dentro de então
você forneceria a função que irá lidar com o resultado quando ele vem em.
Se a promessa não for capaz de resolver corretamente, ela rejeitará
com o erro sendo enviado de volta para você.
O erro é um objeto de erro que será enviado de volta para você.
Então, quando a promessa deles for rejeitada, então você lida com
a rejeição usando um catch dentro do seu código.
Então, dentro do catch, você fornecerá uma função que irá lidar com o erro.
Por exemplo, você pode simplesmente enviar a mensagem de erro,
o log do console e lidar com o erro dessa maneira.
Ou você pode ter uma maneira mais elaborada de lidar com o erro.
Isso seria fornecido na opção de captura que você dá para esse código de promessa
do seu lado quando a promessa entrega uma rejeição para você.
Então é assim que os dois lados da moeda lidam com promessas.
De um lado, você é enviado um objeto de promessa, e
quando você recebe o objeto de promessa, com o objeto de promessa, você faria
o então e o catch, então você deveria implementar tanto o então quanto o
as métricas de captura alteradas para esse objeto de promessa.
E então, a partir dessa promessa de lado, se a promessa resultar corretamente,
então a resolução será chamada e, assim, o resultado será entregue
no então método de sua promessa.
Se a promessa for rejeitada,
a chamada de rejeição entregará o erro no seu catch.
Então é assim que você implementaria código usando promessas.
Lidaremos com o exemplo no exercício que se segue a esta palestra.
Agora, obviamente, a pergunta que eu faço é por que promessas?
Mais tarde, quando lidamos com Node JS,
vamos lidar com como podemos construir callbacks.
E eu vou explicar os detalhes de callbacks e a maneira de lidar com
callbacks quando cobrimos o Node JS no último curso desta especialização.
Callbacks têm um problema de criar o que é chamado de callback hell.
Então você tem fortemente aninhado código de retorno
que é muito complicado para ser capaz de descobrir o que ele está tentando fazer.
Promessas fornecem uma maneira de resolver este problema de retorno infernal.
Mas, no momento, estamos concentrados em Angular, vou apenas mencionar este ponto.
E então vamos voltar para lidar com esta questão no último curso.
A outra vantagem de usar promessas é que as promessas podem ser alteradas.
Uma promessa quando ele entrega o resultado no bin,
você pode gerar outra promessa e retorno, e
essa promessa pode ser tratada encadeando outro método, em seguida, para isso e assim por diante.
Então você pode encadear um conjunto de métodos então juntos para lidar com
promessas um atrás do outro.
Se o resultado estiver imediatamente disponível ou se você for rejeitar imediatamente,
então promise fornece um método de retornar imediatamente sem esperar
a promessa de resolver ou rejeitar.
Nesse caso, você simplesmente vai dizer promessa com um P.resolve maiúsculo e
promise.Rejeitar e, em seguida, retornar o resultado ou o erro imediatamente.
No primeiro exercício, vamos lidar com este método de devolver o valor
do nosso serviço aos nossos componentes.
Na segunda parte do exercício, vamos lidar com
a situação em que a promessa será resolvida após um período de tempo.
E também dentro do nosso componente, devemos ser capazes de lidar com o fato de que
os resultados voltam um pouco mais tarde do que quando você pede o resultado.
Com esta rápida compreensão de promessas,
vamos passar para o próximo exercício onde vamos lidar com promessas.
[MÚSICA]