1
00:00:03,650 --> 00:00:06,180
No exercício anterior,

2
00:00:06,180 --> 00:00:09,414
aprendemos sobre dois novos aspectos do JavaScript,

3
00:00:09,414 --> 00:00:13,155
seu suporte para funções de primeira classe e fechamentos.

4
00:00:13,155 --> 00:00:20,250
Também vimos como Node lida com o aspecto de programação assíncrona e como Node

5
00:00:20,250 --> 00:00:24,015
suporta execução assíncrona de código com

6
00:00:24,015 --> 00:00:28,365
o uso de retornos de chamada e também manipulação de erros.

7
00:00:28,365 --> 00:00:31,815
Vejamos um exemplo de como fazemos uso disso

8
00:00:31,815 --> 00:00:36,650
dentro do nosso aplicativo Node neste exercício.

9
00:00:36,650 --> 00:00:42,315
Continuando com onde paramos no exercício anterior,

10
00:00:42,315 --> 00:00:48,025
agora vou modificar o módulo Node retângulo, para

11
00:00:48,025 --> 00:00:51,670
que ele possa ter a ajuda de callbacks.

12
00:00:51,670 --> 00:00:55,375
Então eu vou remover essas exportações aqui,

13
00:00:55,375 --> 00:00:59,800
e em vez disso, eles vão modificar essa função.

14
00:00:59,800 --> 00:01:03,190
Vou fazer uso dessas duas funções um pouco mais tarde,

15
00:01:03,190 --> 00:01:05,925
então é por isso que estou salvando-as na parte inferior.

16
00:01:05,925 --> 00:01:07,515
Então deixe-me mantê-los de lado.

17
00:01:07,515 --> 00:01:11,530
E então eu vou modificar este módulo retângulo da seguinte forma.

18
00:01:11,530 --> 00:01:15,270
Então vamos dizer module.exports.

19
00:01:15,270 --> 00:01:20,025
Então estamos usando a maneira padrão que o módulo é tratado.

20
00:01:20,025 --> 00:01:26,185
E isso vai exportar esta função que leva esses três parâmetros,

21
00:01:26,185 --> 00:01:30,565
x e y e callback.

22
00:01:30,565 --> 00:01:37,300
O retorno de chamada é uma função que vai ser fornecida em quando este módulo é chamado.

23
00:01:37,300 --> 00:01:43,825
Então este é o uso das funções de primeira classe que falamos anteriormente.

24
00:01:43,825 --> 00:01:46,775
Então, dentro deste callback,

25
00:01:46,775 --> 00:01:49,940
assim você pode ver que você está recebendo dois parâmetros, x e y.

26
00:01:49,940 --> 00:01:51,965
neste caso, para

27
00:01:51,965 --> 00:01:55,520
o retângulo, o x e y correspondem ao comprimento e largura

28
00:01:55,520 --> 00:02:01,550
do retângulo que está sendo passado como os dois valores.

29
00:02:01,550 --> 00:02:05,090
Então aqui dentro, vamos verificar

30
00:02:05,090 --> 00:02:10,300
se x é menor que ou igual a zero ou y é menor ou igual a zero.

31
00:02:10,300 --> 00:02:13,255
Temos um código como este aqui.

32
00:02:13,255 --> 00:02:17,630
Então eu só vou copiar este código daqui

33
00:02:17,630 --> 00:02:23,330
e depois trazê-lo para aqui e depois vamos editar.

34
00:02:23,330 --> 00:02:26,090
Então, neste caso, isto é se x é

35
00:02:26,090 --> 00:02:30,135
menor que ou igual a zero ou y é menor ou igual a zero.

36
00:02:30,135 --> 00:02:32,810
Neste caso, o que fazemos?

37
00:02:32,810 --> 00:02:35,435
Neste caso, observamos que

38
00:02:35,435 --> 00:02:39,750
as dimensões do retângulo são menores ou iguais a zero.

39
00:02:39,750 --> 00:02:43,775
Então temos que lidar com isso de forma diferente,

40
00:02:43,775 --> 00:02:46,330
e faremos a outra parte.

41
00:02:46,330 --> 00:02:52,790
A outra parte onde lidamos com a situação em que o retângulo é um retângulo válido.

42
00:02:52,790 --> 00:02:54,245
Então, neste caso,

43
00:02:54,245 --> 00:03:04,580
o que vamos fazer é então usar um setTimeout.

44
00:03:04,580 --> 00:03:08,090
Então aqui, eu estou simulando o fato de que o que

45
00:03:08,090 --> 00:03:11,860
está sendo feito neste retângulo vai levar algum tempo.

46
00:03:11,860 --> 00:03:14,375
Então este é o processamento assíncrono.

47
00:03:14,375 --> 00:03:18,710
Agora, uma vez que eu não tenho muito trabalho para fazer em segundo plano,

48
00:03:18,710 --> 00:03:22,530
então eu vou simular isso simplesmente usando

49
00:03:22,530 --> 00:03:24,830
a função setTimeout de JavaScript e, em seguida,

50
00:03:24,830 --> 00:03:28,825
atrasar antes que a função de retorno de chamada seja chamada.

51
00:03:28,825 --> 00:03:32,210
Então, a maneira como eu organizo isso é a seguinte.

52
00:03:32,210 --> 00:03:34,270
Então, dentro do setTimeout,

53
00:03:34,270 --> 00:03:40,445
eu vou chamar essa função lá

54
00:03:40,445 --> 00:03:44,855
e organizar um atraso de

55
00:03:44,855 --> 00:03:50,570
2.000 milissegundos ou dois segundos após o qual esta função vai ser chamada.

56
00:03:50,570 --> 00:03:52,003
Então, se você lembrar,

57
00:03:52,003 --> 00:03:54,890
o setTimeout que é suportado em JavaScript,

58
00:03:54,890 --> 00:03:58,070
ele toma como primeiro parâmetro uma função e

59
00:03:58,070 --> 00:04:03,450
o segundo parâmetro seria o período de tempo para o qual isso vai ser adiado.

60
00:04:03,450 --> 00:04:07,120
Então deixe-me indentar isso.

61
00:04:07,120 --> 00:04:09,255
Agora, eu preciso preencher esta função aqui.

62
00:04:09,255 --> 00:04:11,915
Então eu comecei com a função seta aqui

63
00:04:11,915 --> 00:04:15,575
que não leva parâmetros e, em seguida, quando não é chamado,

64
00:04:15,575 --> 00:04:20,745
eu vou emitir uma chamada para o retorno de chamada.

65
00:04:20,745 --> 00:04:22,880
Este callback é uma função de callback que

66
00:04:22,880 --> 00:04:25,760
vai ser passada como o terceiro parâmetro aqui.

67
00:04:25,760 --> 00:04:33,440
Esta função de retorno de chamada, como você notou, leva dois parâmetros.

68
00:04:33,440 --> 00:04:38,245
O primeiro é o erro e o segundo é o valor de retorno.

69
00:04:38,245 --> 00:04:40,625
Então, neste caso, uma vez que temos um erro,

70
00:04:40,625 --> 00:04:44,750
porque x é menor ou igual a zero e y é menor ou igual a zero,

71
00:04:44,750 --> 00:04:50,820
então o primeiro valor que eu vou passar como novo erro,

72
00:04:50,820 --> 00:05:00,603
e esse erro é exatamente essa string que eu estava usando no console.log então,

73
00:05:00,603 --> 00:05:03,915
e é isso que eu vou passar como o erro aqui.

74
00:05:03,915 --> 00:05:06,160
Deixe-me agora excluir esse console.log,

75
00:05:06,160 --> 00:05:07,625
eu não preciso mais dele.

76
00:05:07,625 --> 00:05:08,890
Então, para o retorno de chamada,

77
00:05:08,890 --> 00:05:13,210
eu vou gerar um novo objeto de erro e,

78
00:05:13,210 --> 00:05:18,850
em seguida, passar isso como o valor de retorno para a função de retorno de chamada, o primeiro parâmetro.

79
00:05:18,850 --> 00:05:23,770
Então eu vou dizer que dimensões retangulares devem ser maiores que zero.

80
00:05:23,770 --> 00:05:28,240
Então vamos dizer l,

81
00:05:28,240 --> 00:05:39,000
este é o x e o valor y que temos como os valores de entrada lá.

82
00:05:39,000 --> 00:05:40,650
Então essa é a chamada de volta.

83
00:05:40,650 --> 00:05:43,890
E a segunda parte deste retorno de chamada,

84
00:05:43,890 --> 00:05:51,290
eu vou passar como nulo porque isso vai retornar um erro.

85
00:05:51,290 --> 00:05:54,345
Então, quando você retornar um erro como o primeiro parâmetro,

86
00:05:54,345 --> 00:05:59,250
o segundo parâmetro será ignorado quando esse callback foi recebido apenas

87
00:05:59,250 --> 00:06:06,510
pelo módulo nó de onde estamos chamando essa função particular lá.

88
00:06:06,510 --> 00:06:09,085
Então, com esse arranjo,

89
00:06:09,085 --> 00:06:10,700
tão menor que zero,

90
00:06:10,700 --> 00:06:18,590
então deixe-me dar algum espaço aqui para que ele seja devidamente recuado aqui.

91
00:06:18,590 --> 00:06:21,650
Então, a maneira que eu estou organizando isso

92
00:06:21,650 --> 00:06:26,135
aqui é que se x é menor que zero e y é menor que zero,

93
00:06:26,135 --> 00:06:30,040
eu vou chamar de volta a função callback que foi passada em,

94
00:06:30,040 --> 00:06:32,424
mas o primeiro parâmetro irá passar em

95
00:06:32,424 --> 00:06:36,307
erro porque aqui nós percebemos que há um erro,

96
00:06:36,307 --> 00:06:38,930
e o segundo parâmetro será nulo.

97
00:06:38,930 --> 00:06:40,940
Se este não for o caso,

98
00:06:40,940 --> 00:06:44,550
então eu vou chamar o mesmo retorno de chamada,

99
00:06:44,550 --> 00:06:46,910
mas com o primeiro parâmetro.

100
00:06:46,910 --> 00:06:51,800
Então deixe-me copiar esse código aqui.

101
00:06:51,800 --> 00:07:05,490
Eu ainda vou usar o SetTimeout aqui.

102
00:07:05,490 --> 00:07:10,727
Mas essa primeira parte não vai ser um erro,

103
00:07:10,727 --> 00:07:13,005
em vez disso, a primeira parte,

104
00:07:13,005 --> 00:07:15,235
neste caso, não há erro.

105
00:07:15,235 --> 00:07:20,455
Então eu vou apenas passar de volta esse valor como nulo.

106
00:07:20,455 --> 00:07:22,950
Então isso significa que o erro é definido como nulo.

107
00:07:22,950 --> 00:07:26,335
Então este é um retângulo válido.

108
00:07:26,335 --> 00:07:29,965
Então podemos calcular os valores para o retângulo.

109
00:07:29,965 --> 00:07:35,165
Mas em vez disso, eu vou simplesmente passar em

110
00:07:35,165 --> 00:07:40,020
um objeto JavaScript contendo as duas funções

111
00:07:40,020 --> 00:07:45,330
como os dois valores dentro deste objeto JavaScript.

112
00:07:45,330 --> 00:07:50,355
Então, aqui eu vou pegar esses dois,

113
00:07:50,355 --> 00:07:54,530
o perímetro e a área,

114
00:07:55,250 --> 00:08:05,639
e então esses dois serão passados como os dois valores aqui,

115
00:08:05,639 --> 00:08:07,807
perímetro e área.

116
00:08:07,807 --> 00:08:12,740
E esses dois, uma vez que eles são um objeto JavaScript,

117
00:08:12,740 --> 00:08:16,544
então perímetro e área serão

118
00:08:16,544 --> 00:08:22,690
as duas propriedades que eu passarei dentro desses objetos JavaScript,

119
00:08:22,690 --> 00:08:25,295
e é isso.

120
00:08:25,295 --> 00:08:28,570
Então aqui, no segundo caso,

121
00:08:28,570 --> 00:08:32,034
o erro é definido como nulo porque não há erro,

122
00:08:32,034 --> 00:08:33,190
mas a segunda parte,

123
00:08:33,190 --> 00:08:37,715
observe que estou passando em um objeto JavaScript contendo duas propriedades,

124
00:08:37,715 --> 00:08:41,530
perímetro e área, que são duas funções aqui.

125
00:08:41,530 --> 00:08:46,060
Assim, as duas funções são a função de perímetro e a função de área.

126
00:08:46,060 --> 00:08:49,390
Portanto, este objeto JavaScript será passado de volta como

127
00:08:49,390 --> 00:08:53,705
o valor de retorno para o callback aqui, o segundo valor.

128
00:08:53,705 --> 00:08:56,035
E novamente, eu vou atrasar isso por

129
00:08:56,035 --> 00:09:02,900
um intervalo de dois segundos antes que o valor seja repassado por esta função.

130
00:09:02,900 --> 00:09:07,075
A razão pela qual eu estou usando o setTimeout é para simular

131
00:09:07,075 --> 00:09:11,780
um atraso antes que o retorno de chamada venha do outro lado.

132
00:09:11,780 --> 00:09:15,280
Então esse tipo de representa situações em que, por exemplo,

133
00:09:15,280 --> 00:09:18,565
você emite uma chamada de banco de dados para o banco de dados,

134
00:09:18,565 --> 00:09:23,300
e o banco de dados precisa ser lido antes que o valor seja passado de volta para você.

135
00:09:23,300 --> 00:09:25,855
Então isso vai levar uma certa quantidade de tempo.

136
00:09:25,855 --> 00:09:32,560
Então eu estou basicamente simulando isso neste momento usando a função setTimeout aqui.

137
00:09:32,560 --> 00:09:37,000
Mais tarde, você verá que quando integrarmos o MongoDB com

138
00:09:37,000 --> 00:09:43,060
nosso Express nos exercícios posteriores,

139
00:09:43,060 --> 00:09:45,580
esse atraso teria que ser simulado,

140
00:09:45,580 --> 00:09:48,670
ele será automaticamente causado pelo fato de que você precisa fazer

141
00:09:48,670 --> 00:09:54,190
operações de banco de dados nos bastidores antes dos dados serem obtidos.

142
00:09:54,190 --> 00:10:00,325
Então aqui, tendo concluído esta atualização de módulos retangulares,

143
00:10:00,325 --> 00:10:03,135
então aqui você vê que o módulo retângulo leva em

144
00:10:03,135 --> 00:10:06,830
três parâmetros como é uma chamada de entrada aqui,

145
00:10:06,830 --> 00:10:08,920
x, y e callback.

146
00:10:08,920 --> 00:10:12,445
E assim, o retorno de chamada é a função de retorno de chamada que está sendo fornecida aqui.

147
00:10:12,445 --> 00:10:16,585
E esta função de retorno de chamada será chamada dentro daqui,

148
00:10:16,585 --> 00:10:18,685
e quando a função de retorno de chamada é chamada,

149
00:10:18,685 --> 00:10:22,495
ou você passa de volta um erro ou você passa de volta

150
00:10:22,495 --> 00:10:28,045
uma função que permite que você calcule o perímetro e a área do retângulo.

151
00:10:28,045 --> 00:10:33,835
Agora, este padrão de chamar e passar em uma função de retorno de

152
00:10:33,835 --> 00:10:40,300
um módulo de nó e, em seguida, o segundo módulo de nó que quando ele for concluído,

153
00:10:40,300 --> 00:10:44,800
irá passar de volta o resultado usando a função de retorno de chamada é

154
00:10:44,800 --> 00:10:50,135
exatamente o padrão que você verá muitas vezes repetido em aplicativos de nó.

155
00:10:50,135 --> 00:10:52,360
Então essa é a razão pela qual eu estou ilustrando isso.

156
00:10:52,360 --> 00:10:58,735
Claro, este é um exemplo inventado que estou ilustrando aqui, mas mostra

157
00:10:58,735 --> 00:11:02,525
todos os padrões padrão que você usará com

158
00:11:02,525 --> 00:11:07,065
funções de nó e callback e também a manipulação de erros.

159
00:11:07,065 --> 00:11:10,955
Agora, nós atualizamos o módulo de retângulo aqui.

160
00:11:10,955 --> 00:11:16,870
Vamos corrigir esse arquivo index.js para que ele possa passar na função de retorno de chamada e, em

161
00:11:16,870 --> 00:11:23,770
seguida, manipular o valor de retorno que é enviado de volta do módulo de retângulo.

162
00:11:23,770 --> 00:11:26,940
Voltando para index.js,

163
00:11:26,940 --> 00:11:31,270
agora vamos atualizar o arquivo index.js da seguinte forma.

164
00:11:31,270 --> 00:11:37,955
Em vez disso, vou remover isso do arquivo index.js.

165
00:11:37,955 --> 00:11:42,430
Aqui, o que vamos acabar fazendo é chamar

166
00:11:42,430 --> 00:11:49,120
este módulo retângulo e

167
00:11:49,120 --> 00:11:53,880
, em seguida, passar no l e o b como os dois parâmetros.

168
00:11:53,880 --> 00:12:00,300
E o terceiro parâmetro que vou passar é aquela função de retorno de chamada.

169
00:12:00,300 --> 00:12:10,080
Assim, a função de retorno de chamada tem dois parâmetros, err e retângulo.

170
00:12:10,080 --> 00:12:15,860
E esta função de retorno de chamada é implementada da seguinte forma aqui.

171
00:12:15,860 --> 00:12:19,090
Então aqui, você vê que eu estou chamando

172
00:12:19,090 --> 00:12:23,785
este módulo de nó retangular e eu estou

173
00:12:23,785 --> 00:12:29,050
passando no comprimento e na largura dos dois primeiros parâmetros.

174
00:12:29,050 --> 00:12:31,285
E o terceiro parâmetro é, claro,

175
00:12:31,285 --> 00:12:34,355
uma função de retorno de chamada que estou implementando aqui.

176
00:12:34,355 --> 00:12:38,250
Então, esta é uma função de seta que estou implementando aqui.

177
00:12:38,250 --> 00:12:40,510
Então, dentro desta função de retorno de chamada,

178
00:12:40,510 --> 00:12:43,245
como faço para lidar com o valor de retorno?

179
00:12:43,245 --> 00:12:46,860
Então, aqui eu vou dizer se (err),

180
00:12:46,860 --> 00:12:51,335
então, se o valor do erro for retornado para você,

181
00:12:51,335 --> 00:12:59,500
então eu vou simplesmente fazer console.log e eu vou dizer

182
00:12:59,500 --> 00:13:09,100
“ERROR” e, em seguida, o segundo valor é err.message.

183
00:13:09,100 --> 00:13:11,445
Lembre-se que no retângulo,

184
00:13:11,445 --> 00:13:14,820
nós criamos este novo objeto de erro

185
00:13:14,820 --> 00:13:18,155
e, em seguida, passamos nesta string dentro deste objeto de erro.

186
00:13:18,155 --> 00:13:20,100
Essa string será anexada

187
00:13:20,100 --> 00:13:24,380
ao objeto error para a propriedade message do objeto error aqui.

188
00:13:24,380 --> 00:13:26,830
Então, no arquivo index.js,

189
00:13:26,830 --> 00:13:30,090
então eu estou recuperando a propriedade message do objeto de erro

190
00:13:30,090 --> 00:13:33,755
e, em seguida, imprimindo no meu console aqui.

191
00:13:33,755 --> 00:13:35,310
Então, se ocorrer um erro,

192
00:13:35,310 --> 00:13:39,215
vou imprimir a mensagem de erro usando isso.

193
00:13:39,215 --> 00:13:45,820
E assim, é assim que eu iria lidar com o erro que foi retornado por uma função de retorno de chamada.

194
00:13:45,820 --> 00:13:51,360
Caso contrário, é claro que neste caso,

195
00:13:51,360 --> 00:13:57,450
o módulo de retângulo retornou a função de retângulo,

196
00:13:57,450 --> 00:14:01,620
o objeto que contém o perímetro e as funções de área, para que

197
00:14:01,620 --> 00:14:08,108
eu possa ir em frente e imprimir esse valor.

198
00:14:08,108 --> 00:14:14,175
Então aqui, eu vou dizer a área do retângulo

199
00:14:14,175 --> 00:14:23,030
de dimensões l igual a,

200
00:14:23,140 --> 00:14:28,270
então eu vou dizer,

201
00:14:29,170 --> 00:14:37,155
e b igual a.

202
00:14:37,155 --> 00:14:40,530
A razão pela qual estou a identificá-lo

203
00:14:40,530 --> 00:14:47,340
explicitamente ficará muito clara quando executarmos este exemplo.

204
00:14:47,340 --> 00:15:01,480
Eu digo que é retângulo.area.

205
00:15:01,480 --> 00:15:04,188
Agora, observe que para esta área,

206
00:15:04,188 --> 00:15:09,555
eu não estou enviando nenhum parâmetro aqui porque vai para valores,

207
00:15:09,555 --> 00:15:14,540
o comprimento e a respiração já foram passados aqui no l e b,

208
00:15:14,540 --> 00:15:19,065
e aqueles já estariam disponíveis para este

209
00:15:19,065 --> 00:15:24,245
e aqui por causa do fechamento que JavaScript suporta.

210
00:15:24,245 --> 00:15:27,470
Porque estes x e y vieram como os parâmetros,

211
00:15:27,470 --> 00:15:32,710
então aqueles serão acessíveis ali mesmo nesta função callback.

212
00:15:32,710 --> 00:15:37,315
Então esses x_y estarão automaticamente disponíveis para nós aqui.

213
00:15:37,315 --> 00:15:39,890
Então, como uma questão de fato,

214
00:15:39,890 --> 00:15:43,970
eu não preciso fornecer esses parâmetros x e y aqui em tudo porque

215
00:15:43,970 --> 00:15:49,090
aqueles x e y serão recuperados deste x e y ali mesmo.

216
00:15:49,090 --> 00:15:53,375
Então eu nem preciso passar esses dois valores aqui.

217
00:15:53,375 --> 00:15:55,385
Então é por isso que, ali mesmo,

218
00:15:55,385 --> 00:15:57,905
eu posso chamar retangle.area.

219
00:15:57,905 --> 00:16:03,170
E este cálculo de área irá automaticamente obter o l e b que foram passados

220
00:16:03,170 --> 00:16:09,505
pela chamada retangular para o módulo de nó direto anteriormente.

221
00:16:09,505 --> 00:16:14,980
Então este é o fechamento do JavaScript operando aqui.

222
00:16:14,980 --> 00:16:17,945
Então, esse é o primeiro.

223
00:16:17,945 --> 00:16:23,305
Estou imprimindo a área do retângulo.

224
00:16:23,305 --> 00:16:32,990
A mesma coisa, deixe-me também imprimir os perímetros.

225
00:16:32,990 --> 00:16:34,608
Então, para imprimir os perímetros,

226
00:16:34,608 --> 00:16:36,720
então eu vou dizer console.log.

227
00:16:36,720 --> 00:16:46,560
O perímetro do retângulo será perímetro retangular.

228
00:16:46,560 --> 00:16:53,280
Agora, devo dizer que esse tipo de abordagem para implementação requer um pouco

229
00:16:53,280 --> 00:17:02,335
de esforço para entender e internalizar a capacidade de função assíncrona.

230
00:17:02,335 --> 00:17:06,360
Leva algum tempo para você entender completamente como ele realmente funciona.

231
00:17:06,360 --> 00:17:08,550
Agora, para ilustrar o fato de que

232
00:17:08,550 --> 00:17:14,642
esta chamada de função resultará em uma chamada para o módulo Node,

233
00:17:14,642 --> 00:17:19,280
mas esta parte será executada somente após

234
00:17:19,280 --> 00:17:24,830
um atraso de dois segundos por causa do fato de que estamos usando a marca de tempo definida.

235
00:17:24,830 --> 00:17:28,745
Agora, como estudamos na operação assíncrona,

236
00:17:28,745 --> 00:17:33,155
porque mudamos o processamento para a parte de trás,

237
00:17:33,155 --> 00:17:41,420
deixe-me também introduzir mais um console.log aqui para fazer um ponto.

238
00:17:41,420 --> 00:17:46,175
Então vamos dizer que esta declaração é

239
00:17:46,175 --> 00:17:53,869
depois da chamada para rect.

240
00:17:53,869 --> 00:18:00,210
A razão pela qual estou ilustrando este ponto é que quando você emitir esta chamada,

241
00:18:00,210 --> 00:18:06,130
este código não será executado até depois de um atraso de dois segundos.

242
00:18:06,130 --> 00:18:08,070
Então, enquanto isso,

243
00:18:08,070 --> 00:18:10,360
sua função, principal função aqui,

244
00:18:10,360 --> 00:18:16,340
continuará e, em seguida, executar a próxima linha de código que você vê aqui.

245
00:18:16,340 --> 00:18:19,745
Então esta é a continuação que vocês verão aqui.

246
00:18:19,745 --> 00:18:21,805
Então, com essas alterações,

247
00:18:21,805 --> 00:18:27,815
vamos salvar as alterações e, em seguida, olhar para como este aplicativo é executado agora.

248
00:18:27,815 --> 00:18:29,410
Então guardando as mudanças.

249
00:18:29,410 --> 00:18:35,220
Vamos para o terminal e executar este aplicativo de nó.

250
00:18:35,220 --> 00:18:37,570
Agora, indo para o terminal, adicione o prompt.

251
00:18:37,570 --> 00:18:43,795
Deixe-me digitar npm start e você notará imediatamente

252
00:18:43,795 --> 00:18:51,790
que a resolução e esta declaração foram impressas anteriormente.

253
00:18:51,790 --> 00:18:54,505
E depois desse certo atraso,

254
00:18:54,505 --> 00:18:57,855
a área e o perímetro foram impressos.

255
00:18:57,855 --> 00:19:02,130
Portanto, esse é um atraso de dois segundos que introduzimos usando o tempo limite estabelecido.

256
00:19:02,130 --> 00:19:05,755
Então, você notou que na versão anterior,

257
00:19:05,755 --> 00:19:10,290
isso foi impresso e imediatamente a área e o perímetro foram impressos logo abaixo disso.

258
00:19:10,290 --> 00:19:15,120
Mas agora, observe que esses valores são impressos um pouco mais tarde.

259
00:19:15,120 --> 00:19:20,460
Então, no meio, suas chamadas de função com os diferentes parâmetros que já foram

260
00:19:20,460 --> 00:19:26,505
dentro e, em seguida, os retornos de chamada são chamados de volta após dois segundos de atraso para cada um deles.

261
00:19:26,505 --> 00:19:32,500
E por causa do fato de que há o fechamento que o JavaScript suporta,

262
00:19:32,500 --> 00:19:35,980
então os valores que são passados são preservados.

263
00:19:35,980 --> 00:19:38,440
E assim, quando a função de retorno de chamada é chamada,

264
00:19:38,440 --> 00:19:40,615
o valor apropriado é impresso.

265
00:19:40,615 --> 00:19:42,730
Então é por isso que você vê que a área e

266
00:19:42,730 --> 00:19:46,330
o perímetro são impressos corretamente e estes dois aqui,

267
00:19:46,330 --> 00:19:48,070
estas duas declarações aqui,

268
00:19:48,070 --> 00:19:51,340
correspondem a esta chamada particular para dirigir

269
00:19:51,340 --> 00:19:55,100
com l é igual a dois e b é igual a quatro.

270
00:19:55,100 --> 00:19:56,605
E então esses dois,

271
00:19:56,605 --> 00:19:58,150
o próximo a dois, é claro,

272
00:19:58,150 --> 00:20:05,000
correspondem a este particular e aos restantes como você vê aqui.

273
00:20:05,000 --> 00:20:10,410
Então, o que eu queria ilustrar é o fato de que quando você faz a computação assíncrona,

274
00:20:10,410 --> 00:20:12,730
a computação assíncrona leva seu próprio tempo

275
00:20:12,730 --> 00:20:16,270
para retornar o valor enquanto sua computação principal

276
00:20:16,270 --> 00:20:22,460
prosseguirá sem esperar que o retorno de chamada seja concluído.

277
00:20:22,460 --> 00:20:25,245
Então, quando você precisa fazer uma certa quantidade de trabalho,

278
00:20:25,245 --> 00:20:29,365
você passou como um retorno de chamada para esse outro módulo.

279
00:20:29,365 --> 00:20:31,375
E quando esse outro módulo concluir seu trabalho,

280
00:20:31,375 --> 00:20:35,010
ele vai chamar de volta e então esse código será executado.

281
00:20:35,010 --> 00:20:40,350
Portanto, esse é o ponto que eu ilustrei usando este exemplo.

282
00:20:40,350 --> 00:20:41,565
Novamente, como eu disse,

283
00:20:41,565 --> 00:20:45,210
isso requer um pouco de imaginação e compreensão

284
00:20:45,210 --> 00:20:48,930
para você internalizar a maneira como isso funciona,

285
00:20:48,930 --> 00:20:55,185
mas você verá que com Node e também Express e quando usamos MongoDB,

286
00:20:55,185 --> 00:21:01,785
você verá esse tipo de padrão repetindo muitas vezes na maneira como escrevemos nosso código.

287
00:21:01,785 --> 00:21:06,210
Assim, com esta ilustração simples de retornos de chamada e manipulação de erros,

288
00:21:06,210 --> 00:21:08,940
concluímos este exercício.

289
00:21:08,940 --> 00:21:13,675
Este é um bom momento para você fazer um comentário get com essa mensagem,

290
00:21:13,675 --> 00:21:17,700
nó, callbacks, e manipulação de erros.