1
00:00:00,000 --> 00:00:04,722
[MÚSICA]

2
00:00:04,722 --> 00:00:10,212
Quando estávamos falando de serviços no módulo anterior, eu mencionei

3
00:00:10,212 --> 00:00:16,070
sobre promessas e então prometi que voltarei às promessas neste módulo.

4
00:00:17,360 --> 00:00:20,360
Então, aqui estamos eu vou cumprir minha promessa a você.

5
00:00:22,090 --> 00:00:28,310
Uma computação síncrona está por todo o lado na World Wide Web.

6
00:00:28,310 --> 00:00:31,410
E como a web opera.

7
00:00:32,880 --> 00:00:35,810
Se você está vindo do mundo da programação sequencial,

8
00:00:37,040 --> 00:00:41,640
envolvendo sua cabeça em torno de uma computação síncrona requer um pouco de esforço.

9
00:00:42,680 --> 00:00:48,570
Houve muitas tentativas de tornar a computação assíncrona tão indolor quanto

10
00:00:48,570 --> 00:00:54,680
possível para as pessoas que fazem a transição para ele a partir do livro de computação sequencial.

11
00:00:56,850 --> 00:01:01,470
Uma dessas tentativas é tornar a computação assíncrona

12
00:01:01,470 --> 00:01:04,790
mais fácil de realizar é promessas.

13
00:01:06,040 --> 00:01:10,304
Como percebemos, quando fazemos qualquer solicitação para qualquer serviço

14
00:01:10,304 --> 00:01:15,220
ou para um servidor back-end,

15
00:01:16,530 --> 00:01:21,180
vai levar algum tempo para que os resultados se tornem disponíveis para nós.

16
00:01:22,550 --> 00:01:30,840
Se fizermos tal solicitação enquanto estamos prosseguindo com nosso trabalho,

17
00:01:30,840 --> 00:01:35,680
então há uma alta probabilidade de que nosso cálculo fique preso no ponto,

18
00:01:35,680 --> 00:01:37,890
aguardando os resultados.

19
00:01:37,890 --> 00:01:44,070
Este é um não-não em termos de fazer uma boa experiência de usuário.

20
00:01:46,090 --> 00:01:52,420
Portanto, é importante que sempre que seus resultados vão levar tempo

21
00:01:52,420 --> 00:01:57,660
você deve ser capaz de avançar sem esperar pelas regras.

22
00:01:57,660 --> 00:02:01,492
E é aí que a computação assíncrona vem a sua vantagem.

23
00:02:01,492 --> 00:02:04,640
Em computação assíncrona quando você envia uma solicitação

24
00:02:04,640 --> 00:02:07,800
você está esperando que os resultados voltem mais tarde, e

25
00:02:07,800 --> 00:02:12,720
você deve ser capaz de lidar com o fato, os resultados de base voltar em um momento

26
00:02:14,490 --> 00:02:20,410
muito mais tarde do que onde você estava no momento em que você fez o pedido.

27
00:02:21,830 --> 00:02:25,710
Promessas nos fornecem uma maneira de lidar com isso.

28
00:02:26,790 --> 00:02:32,540
Vejamos as promessas com um pouco mais de detalhes nesta palestra.

29
00:02:32,540 --> 00:02:35,910
E então também veremos o uso de promessas

30
00:02:35,910 --> 00:02:39,490
em nossa aplicação Angular um pouco mais tarde.

31
00:02:39,490 --> 00:02:44,750
Promessas, o conceito geral é uma área muito vasta por si só.

32
00:02:44,750 --> 00:02:49,030
E neste curso, eu não tenho tempo para passar pelos detalhes das promessas.

33
00:02:49,030 --> 00:02:51,780
Isso vai se tornar um curso inteiro em si mesmo.

34
00:02:51,780 --> 00:02:56,950
Eu vou dar-lhe apenas o essencial das promessas que são necessárias para

35
00:02:56,950 --> 00:03:02,490
nós para entender como fazer uso de promessas dentro de nossa aplicação angular.

36
00:03:02,490 --> 00:03:07,230
Eu fornecer-lhe um monte de leads para recursos

37
00:03:07,230 --> 00:03:11,380
adicionais onde você pode ir e examinar promessas com mais detalhes.

38
00:03:13,110 --> 00:03:17,230
Então, descendo a essa questão, o que exatamente é uma promessa?

39
00:03:17,230 --> 00:03:21,690
A promise é um mecanismo que suporta computação assíncrona.

40
00:03:21,690 --> 00:03:26,580
Acabei de dar uma longa explicação de porque a computação assíncrona

41
00:03:26,580 --> 00:03:31,340
é essencial para a web funcionar.

42
00:03:31,340 --> 00:03:36,720
Agora, ao usar uma promessa, a promessa fornece um mecanismo ou

43
00:03:36,720 --> 00:03:42,760
um proxy para um valor que não está disponível no momento em que você solicitar.

44
00:03:42,760 --> 00:03:46,050
Assim, uma promessa retornará uma promessa para você, dizendo que

45
00:03:46,050 --> 00:03:51,430
quando o resultado estiver disponível, ele voltará e entregará os resultados para você.

46
00:03:51,430 --> 00:03:56,850
Assim, uma promessa retorna um objeto proxy para você, e você mantém o objeto proxy.

47
00:03:56,850 --> 00:04:02,030
E esse objeto proxy lhe dará acesso aos resultados quando estiverem disponíveis.

48
00:04:02,030 --> 00:04:07,290
E há um método em como você espera pelos resultados.

49
00:04:07,290 --> 00:04:11,560
Você realmente não suspende seu cálculo nesse ponto, em vez disso, você

50
00:04:13,110 --> 00:04:19,948
configurar uma maneira de aceitar os resultados quando ele voltar dessa promessa.

51
00:04:19,948 --> 00:04:23,780
Para resumir,

52
00:04:23,780 --> 00:04:27,960
promise representa um valor que estará disponível em um momento futuro.

53
00:04:27,960 --> 00:04:29,680
Também pode estar imediatamente disponível,

54
00:04:29,680 --> 00:04:32,960
caso em que a promessa retornará o valor imediatamente.

55
00:04:32,960 --> 00:04:37,940
Mas no caso de ele precisar retornar um valor em uma data futura, então ele lhe dá

56
00:04:37,940 --> 00:04:42,040
a promessa de que esse valor quando ele se tornar disponível será devolvido a você.

57
00:04:43,400 --> 00:04:47,820
Há sempre a possibilidade de que a promessa não possa ser cumprida,

58
00:04:47,820 --> 00:04:50,730
porque os resultados não estão disponíveis por qualquer motivo.

59
00:04:51,950 --> 00:04:57,150
Nesse caso, um erro será entregue a você, ou uma rejeição será entregue

60
00:04:57,150 --> 00:05:02,430
a você, e cabe a você lidar com o fato de que a promessa foi rejeitada.

61
00:05:03,930 --> 00:05:06,890
Olhamos como lidamos com isso no próximo slide.

62
00:05:07,950 --> 00:05:11,180
Como aprendemos anteriormente, uma promessa é um proxy para

63
00:05:11,180 --> 00:05:15,080
algo que iria acontecer no futuro ou pode nunca acontecer no futuro.

64
00:05:15,080 --> 00:05:19,745
Assim, uma promessa quando for dada a você, estará no estado pendente.

65
00:05:20,860 --> 00:05:25,130
Agora, quando a promessa resolver, que é que os resultados se tornam disponíveis e

66
00:05:25,130 --> 00:05:30,080
a promessa é capaz de entregar os resultados para você, então a promessa vai resolver ou

67
00:05:30,080 --> 00:05:31,490
vai cumprir.

68
00:05:31,490 --> 00:05:37,130
E nesse caso, a promessa será movida do estado pendente para a resolução ou

69
00:05:37,130 --> 00:05:38,490
o estado de preenchimento.

70
00:05:38,490 --> 00:05:41,220
Então, nesse ponto, seus resultados estão disponíveis para você.

71
00:05:42,540 --> 00:05:48,760
Há uma pequena chance de que a promessa pode ser rejeitada por causa de um erro,

72
00:05:48,760 --> 00:05:50,590
ou qualquer que seja o motivo.

73
00:05:50,590 --> 00:05:53,280
Nessa circunstância remota,

74
00:05:53,280 --> 00:05:57,980
você receberá uma rejeição e, nesse caso, a promessa será

75
00:05:57,980 --> 00:06:02,209
considerada no estado rejeitado quando a rejeição for entregue.

76
00:06:03,380 --> 00:06:06,710
Então, quando você gera uma promessa, como eu disse,

77
00:06:06,710 --> 00:06:10,560
uma promessa é um objeto proxy que é entregue a você.

78
00:06:10,560 --> 00:06:14,580
Então, quando você entregar uma promessa a alguém, a promessa internamente terá

79
00:06:14,580 --> 00:06:17,500
uma função que lidará com tanto a resolução quanto

80
00:06:17,500 --> 00:06:20,310
as opções de rejeição lá dentro.

81
00:06:21,480 --> 00:06:22,540
Quando você escreve código,

82
00:06:22,540 --> 00:06:28,190
você verá que você vai escrever código como novo Promessa (função (resolver, rejeitar).

83
00:06:28,190 --> 00:06:33,350
Portanto, se ele resolve ou é rejeitado, precisamos ser capazes de enviar

84
00:06:33,350 --> 00:06:38,290
de volta as informações para quem entregamos a promessa.

85
00:06:39,570 --> 00:06:41,600
Como fazemos isso em código?

86
00:06:41,600 --> 00:06:44,040
Vamos dar uma olhada nisso no próximo slide.

87
00:06:45,280 --> 00:06:50,430
Aqui está um exemplo de como a promessa é configurada no código.

88
00:06:50,430 --> 00:06:53,870
Na verdade, este exemplo é derivado do exercício que você fará

89
00:06:53,870 --> 00:06:55,850
um pouco mais tarde.

90
00:06:55,850 --> 00:07:01,100
Então aqui, quando configuramos nosso serviço, podemos fazer com que nosso serviço

91
00:07:01,100 --> 00:07:06,830
retorne uma promessa a um componente que solicita dados do serviço.

92
00:07:06,830 --> 00:07:08,368
Então, quando a promessa é retornada,

93
00:07:08,368 --> 00:07:13,810
então a promessa de retorno está disponível para você como um objeto.

94
00:07:13,810 --> 00:07:18,190
E essa promessa fornece dois métodos, o então e o método catch.

95
00:07:19,420 --> 00:07:23,416
Agora, então, a promessa foi resolvida com sucesso.

96
00:07:23,416 --> 00:07:28,300
Em seguida, a promessa resultará

97
00:07:28,300 --> 00:07:32,810
em chamar uma resolução.

98
00:07:32,810 --> 00:07:36,960
Como você viu, a promessa é construída, e dentro da promessa,

99
00:07:36,960 --> 00:07:42,170
você tem a função, a resolução e rejeição, como os dois parâmetros.

100
00:07:42,170 --> 00:07:46,820
Então, se a promessa é capaz de entregar o resultado com sucesso,

101
00:07:46,820 --> 00:07:51,680
então ele vai chamar o método de resolução e, em seguida, retornar o resultado para você.

102
00:07:51,680 --> 00:07:53,520
Onde o resultado obtém a realidade?

103
00:07:54,820 --> 00:07:58,820
Quando você escreve código esperando por

104
00:07:58,820 --> 00:08:04,400
a promessa, em seguida, você especificaria o que fazer quando a promessa retorna o resultado

105
00:08:04,400 --> 00:08:09,370
na opção então para essa promessa.

106
00:08:09,370 --> 00:08:14,590
Então digamos, por exemplo, você diria getdishes.Then e dentro de então

107
00:08:14,590 --> 00:08:18,810
você forneceria a função que irá lidar com o resultado quando ele vem em.

108
00:08:20,370 --> 00:08:25,700
Se a promessa não for capaz de resolver corretamente, ela rejeitará

109
00:08:25,700 --> 00:08:28,570
com o erro sendo enviado de volta para você.

110
00:08:28,570 --> 00:08:31,600
O erro é um objeto de erro que será enviado de volta para você.

111
00:08:31,600 --> 00:08:36,560
Então, quando a promessa deles for rejeitada, então você lida com

112
00:08:36,560 --> 00:08:41,020
a rejeição usando um catch dentro do seu código.

113
00:08:41,020 --> 00:08:47,460
Então, dentro do catch, você fornecerá uma função que irá lidar com o erro.

114
00:08:47,460 --> 00:08:51,470
Por exemplo, você pode simplesmente enviar a mensagem de erro,

115
00:08:51,470 --> 00:08:56,770
o log do console e lidar com o erro dessa maneira.

116
00:08:56,770 --> 00:09:01,080
Ou você pode ter uma maneira mais elaborada de lidar com o erro.

117
00:09:01,080 --> 00:09:06,670
Isso seria fornecido na opção de captura que você dá para esse código de promessa

118
00:09:06,670 --> 00:09:12,130
do seu lado quando a promessa entrega uma rejeição para você.

119
00:09:12,130 --> 00:09:17,690
Então é assim que os dois lados da moeda lidam com promessas.

120
00:09:17,690 --> 00:09:21,160
De um lado, você é enviado um objeto de promessa, e

121
00:09:21,160 --> 00:09:24,730
quando você recebe o objeto de promessa, com o objeto de promessa, você faria

122
00:09:24,730 --> 00:09:28,300
o então e o catch, então você deveria implementar tanto o então quanto o

123
00:09:28,300 --> 00:09:33,510
as métricas de captura alteradas para esse objeto de promessa.

124
00:09:34,780 --> 00:09:39,910
E então, a partir dessa promessa de lado, se a promessa resultar corretamente,

125
00:09:39,910 --> 00:09:44,757
então a resolução será chamada e, assim, o resultado será entregue

126
00:09:44,757 --> 00:09:48,770
no então método de sua promessa.

127
00:09:48,770 --> 00:09:51,175
Se a promessa for rejeitada,

128
00:09:51,175 --> 00:09:55,530
a chamada de rejeição entregará o erro no seu catch.

129
00:09:56,760 --> 00:10:01,725
Então é assim que você implementaria código usando promessas.

130
00:10:01,725 --> 00:10:07,375
Lidaremos com o exemplo no exercício que se segue a esta palestra.

131
00:10:07,375 --> 00:10:09,786
Agora, obviamente, a pergunta que eu faço é por que promessas?

132
00:10:11,347 --> 00:10:13,927
Mais tarde, quando lidamos com Node JS,

133
00:10:13,927 --> 00:10:18,237
vamos lidar com como podemos construir callbacks.

134
00:10:18,237 --> 00:10:21,677
E eu vou explicar os detalhes de callbacks e a maneira de lidar com

135
00:10:21,677 --> 00:10:29,920
callbacks quando cobrimos o Node JS no último curso desta especialização.

136
00:10:29,920 --> 00:10:37,400
Callbacks têm um problema de criar o que é chamado de callback hell.

137
00:10:37,400 --> 00:10:40,000
Então você tem fortemente aninhado código de retorno

138
00:10:40,000 --> 00:10:44,650
que é muito complicado para ser capaz de descobrir o que ele está tentando fazer.

139
00:10:44,650 --> 00:10:50,970
Promessas fornecem uma maneira de resolver este problema de retorno infernal.

140
00:10:50,970 --> 00:10:55,270
Mas, no momento, estamos concentrados em Angular, vou apenas mencionar este ponto.

141
00:10:55,270 --> 00:10:59,050
E então vamos voltar para lidar com esta questão no último curso.

142
00:11:00,760 --> 00:11:05,600
A outra vantagem de usar promessas é que as promessas podem ser alteradas.

143
00:11:05,600 --> 00:11:08,780
Uma promessa quando ele entrega o resultado no bin,

144
00:11:08,780 --> 00:11:11,130
você pode gerar outra promessa e retorno, e

145
00:11:11,130 --> 00:11:16,280
essa promessa pode ser tratada encadeando outro método, em seguida, para isso e assim por diante.

146
00:11:16,280 --> 00:11:21,720
Então você pode encadear um conjunto de métodos então juntos para lidar com

147
00:11:21,720 --> 00:11:23,470
promessas um atrás do outro.

148
00:11:25,610 --> 00:11:31,850
Se o resultado estiver imediatamente disponível ou se você for rejeitar imediatamente,

149
00:11:31,850 --> 00:11:37,190
então promise fornece um método de retornar imediatamente sem esperar

150
00:11:37,190 --> 00:11:39,900
a promessa de resolver ou rejeitar.

151
00:11:39,900 --> 00:11:45,766
Nesse caso, você simplesmente vai dizer promessa com um P.resolve maiúsculo e

152
00:11:45,766 --> 00:11:52,243
promise.Rejeitar e, em seguida, retornar o resultado ou o erro imediatamente.

153
00:11:52,243 --> 00:11:57,079
No primeiro exercício, vamos lidar com este método de devolver o valor

154
00:11:57,079 --> 00:11:59,480
do nosso serviço aos nossos componentes.

155
00:12:00,920 --> 00:12:04,010
Na segunda parte do exercício, vamos lidar com

156
00:12:04,010 --> 00:12:09,820
a situação em que a promessa será resolvida após um período de tempo.

157
00:12:09,820 --> 00:12:13,400
E também dentro do nosso componente, devemos ser capazes de lidar com o fato de que

158
00:12:13,400 --> 00:12:20,280
os resultados voltam um pouco mais tarde do que quando você pede o resultado.

159
00:12:22,485 --> 00:12:25,679
Com esta rápida compreensão de promessas,

160
00:12:25,679 --> 00:12:30,393
vamos passar para o próximo exercício onde vamos lidar com promessas.

161
00:12:30,393 --> 00:12:33,769
[MÚSICA]