1
00:00:03,680 --> 00:00:07,140
Uma discussão sobre módulos de nó está incompleta

2
00:00:07,140 --> 00:00:10,310
sem falar sobre retornos de chamada e manipulação de erros.

3
00:00:10,310 --> 00:00:14,820
O que são retornos de chamada e por que eles são essenciais para

4
00:00:14,820 --> 00:00:17,250
suportar computação assíncrona que é muito

5
00:00:17,250 --> 00:00:20,610
útil quando escrevemos aplicativos Node.js?

6
00:00:20,610 --> 00:00:25,130
Como o tratamento de erros é feito em aplicativos Node?

7
00:00:25,130 --> 00:00:29,615
Vamos falar brevemente sobre isso nesta palestra.

8
00:00:29,615 --> 00:00:34,305
Antes de prosseguir para falar sobre Node Modules e Callbacks,

9
00:00:34,305 --> 00:00:40,315
precisamos entender duas características salientes sobre a própria linguagem JavaScript.

10
00:00:40,315 --> 00:00:46,295
Em primeiro lugar, JavaScript suporta o que é chamado de funções de primeira classe.

11
00:00:46,295 --> 00:00:48,430
O que queremos dizer com funções de primeira classe?

12
00:00:48,430 --> 00:00:52,838
É que uma função pode ser tratada como qualquer outra variável.

13
00:00:52,838 --> 00:00:55,620
E, portanto, as funções podem ser passadas como

14
00:00:55,620 --> 00:01:00,955
parâmetros dentro de chamadas de função para outras funções.

15
00:01:00,955 --> 00:01:06,630
E isso essencialmente nos permite enviar funções como funções de retorno de chamada que podem ser

16
00:01:06,630 --> 00:01:14,110
chamadas de outro módulo Node, a fim de obter algum trabalho realizado.

17
00:01:14,110 --> 00:01:20,010
Em seguida, veja como isso é muito útil no suporte de retornos de chamada em Node.js.

18
00:01:20,010 --> 00:01:25,107
O segundo aspecto sobre JavaScript é o suporte para Closures.

19
00:01:25,107 --> 00:01:26,835
O que queremos dizer com Closures?

20
00:01:26,835 --> 00:01:31,185
Especialmente, se você estiver familiarizado com linguagens de programação funcionais,

21
00:01:31,185 --> 00:01:33,325
você entende como o fechamento funciona.

22
00:01:33,325 --> 00:01:37,050
Uma função definida dentro de outra função

23
00:01:37,050 --> 00:01:42,955
automaticamente obtém acesso às variáveis que são declaradas na função externa.

24
00:01:42,955 --> 00:01:46,185
Assim, mesmo que a função externa seja concluída

25
00:01:46,185 --> 00:01:51,000
a execução, quando a função interna for executada posteriormente, a função interna ainda terá acesso

26
00:01:51,000 --> 00:01:56,020
aos valores das variáveis dentro dessa função externa.

27
00:01:56,020 --> 00:01:57,465
E isso é novamente,

28
00:01:57,465 --> 00:02:05,244
muito efetivamente usado quando usamos Callbacks em aplicativos Node.

29
00:02:05,244 --> 00:02:08,790
Se você estiver acostumado com a maneira padrão de escrever aplicativos,

30
00:02:08,790 --> 00:02:12,870
então você está familiarizado com a computação síncrona onde você

31
00:02:12,870 --> 00:02:17,918
especifica um cálculo como um conjunto de etapas a serem feitas uma após a outra.

32
00:02:17,918 --> 00:02:21,165
Agora, se você organizar sua computação da seguinte forma,

33
00:02:21,165 --> 00:02:27,885
como mostrado no lado esquerdo do slide aqui,

34
00:02:27,885 --> 00:02:33,260
nós temos computação um, seguido por uma computação de longa duração,

35
00:02:33,260 --> 00:02:36,095
seguido por computação dois, e computação três.

36
00:02:36,095 --> 00:02:38,400
Então, neste arranjo,

37
00:02:38,400 --> 00:02:41,940
vamos supor que a computação dois é dependente

38
00:02:41,940 --> 00:02:45,250
da computação de longa duração completando seu trabalho,

39
00:02:45,250 --> 00:02:48,690
então faz sentido para a computação dois esperar até que

40
00:02:48,690 --> 00:02:53,430
a computação de longa execução seja concluída antes de ser executada.

41
00:02:53,430 --> 00:02:56,670
Agora, nós podemos ter outro pedaço de trabalho a

42
00:02:56,670 --> 00:03:00,435
ser feito que é definido pela computação três.

43
00:03:00,435 --> 00:03:05,055
Cálculo três pode ser de forma alguma dependente da computação dois,

44
00:03:05,055 --> 00:03:11,092
ou a computação de longa duração para ser concluída antes de ser executada.

45
00:03:11,092 --> 00:03:12,420
Então, neste caso,

46
00:03:12,420 --> 00:03:16,635
se fizermos a execução síncrona desta

47
00:03:16,635 --> 00:03:18,825
computação, então a computação três ficará presa,

48
00:03:18,825 --> 00:03:23,895
mesmo que não seja de maneira dependente da conclusão da computação dois,

49
00:03:23,895 --> 00:03:25,800
ou da computação de longa duração.

50
00:03:25,800 --> 00:03:29,310
Assim, a quantidade de trabalho a ser feito pela computação três,

51
00:03:29,310 --> 00:03:35,625
será adiada por nenhuma razão própria, certo?

52
00:03:35,625 --> 00:03:41,725
Em vez disso é adiada por causa de algo que o precede na sequência de computação.

53
00:03:41,725 --> 00:03:45,735
Agora, computação

54
00:03:45,735 --> 00:03:50,265
assíncrona, podemos reorganizar este trabalho de tal forma que o cálculo um, quando ele for concluído,

55
00:03:50,265 --> 00:03:57,350
pode gerar aqueles cálculos de longa execução para ser feito nos bastidores de forma independente,

56
00:03:57,350 --> 00:04:02,706
e uma vez que a computação dois é dependente da computação de longa execução para terminar,

57
00:04:02,706 --> 00:04:09,314
então a computação dois pode ser executada quando a computação de longa duração é concluída.

58
00:04:09,314 --> 00:04:14,265
Agora, isso libera computação três para continuar,

59
00:04:14,265 --> 00:04:16,820
logo após o cálculo um terminar.

60
00:04:16,820 --> 00:04:18,585
Então esta maneira de organizar,

61
00:04:18,585 --> 00:04:22,815
garante que a computação três terminará muito mais rápido do que

62
00:04:22,815 --> 00:04:28,000
ficar preso atrás da computação de longa duração, e computação dois.

63
00:04:28,000 --> 00:04:33,945
Portanto, esta abordagem de reorganizar seu trabalho é muito útil especialmente,

64
00:04:33,945 --> 00:04:37,650
quando você tem um cálculo de longa execução especialmente,

65
00:04:37,650 --> 00:04:40,000
E/S ligado computação a ser feito.

66
00:04:40,000 --> 00:04:43,174
Então, neste caso, você pode gerar fora da computação vinculada de E/S,

67
00:04:43,174 --> 00:04:44,700
e quando isso

68
00:04:44,700 --> 00:04:47,580
for concluído, então o que precisa ser feito depois disso,

69
00:04:47,580 --> 00:04:51,830
pode ser enviado para ele como um retorno de chamada.

70
00:04:51,830 --> 00:04:54,540
Então, a computação dois será transformada em

71
00:04:54,540 --> 00:04:58,490
um Callback e, em seguida, distribuída para a computação de longa duração.

72
00:04:58,490 --> 00:05:01,440
Então, quando isso completar seu trabalho,

73
00:05:01,440 --> 00:05:07,015
então ele vai chamar de volta a função que está dentro do callback.

74
00:05:07,015 --> 00:05:11,020
Então, isso é aproveitado de forma muito eficaz pelo Node.js

75
00:05:11,020 --> 00:05:17,250
em reorganizar a computação dentro de nossos aplicativos Node.

76
00:05:17,250 --> 00:05:20,740
Agora, isso é muito,

77
00:05:20,740 --> 00:05:25,520
muito útil quando olhamos para a maneira como Node.js em si é executado.

78
00:05:25,520 --> 00:05:26,735
Então, como percebemos,

79
00:05:26,735 --> 00:05:31,830
Node.js é organizado em um único loop de eventos de thread.

80
00:05:31,830 --> 00:05:34,690
Este único loop de evento thread basicamente,

81
00:05:34,690 --> 00:05:39,620
pega solicitações como eles entram e executá-lo um após o outro.

82
00:05:39,620 --> 00:05:42,592
Sempre que precisar gerar uma solicitação de E/S,

83
00:05:42,592 --> 00:05:44,650
a solicitação de E/S será gerada

84
00:05:44,650 --> 00:05:48,910
e qualquer trabalho que precise ser feito após a conclusão da solicitação de E/S,

85
00:05:48,910 --> 00:05:51,330
será colocado dentro de um retorno de chamada.

86
00:05:51,330 --> 00:05:52,940
Então, quando a solicitação de E/S for concluída,

87
00:05:52,940 --> 00:05:55,660
ele colocará o retorno de chamada na fila de solicitação,

88
00:05:55,660 --> 00:05:58,510
e o retorno de chamada será tratado posteriormente,

89
00:05:58,510 --> 00:06:00,030
pelo loop de evento.

90
00:06:00,030 --> 00:06:02,890
Então, o loop de eventos é um loop de execução contínua

91
00:06:02,890 --> 00:06:06,595
que basicamente pega solicitações da fila de solicitações

92
00:06:06,595 --> 00:06:09,240
e, em seguida, os serviços um de cada vez.

93
00:06:09,240 --> 00:06:11,470
Então, quando você pensa sobre isso,

94
00:06:11,470 --> 00:06:14,093
você percebe que Node.js é um único thread,

95
00:06:14,093 --> 00:06:15,340
mas ao mesmo tempo,

96
00:06:15,340 --> 00:06:19,645
ele é capaz de alcançar uma taxa muito mais rápida de conclusão do trabalho,

97
00:06:19,645 --> 00:06:24,580
simplesmente por causa do uso judicioso de retornos de chamada

98
00:06:24,580 --> 00:06:29,680
e a execução assíncrona de solicitações de E/S,

99
00:06:29,680 --> 00:06:32,815
como para arquivo acessos ou banco de dados,

100
00:06:32,815 --> 00:06:39,280
ou processamento de longa execução que pode ser feito de forma independente nos bastidores.

101
00:06:39,280 --> 00:06:43,045
Agora, a maneira como o loop de eventos Node.js lida com tudo isso,

102
00:06:43,045 --> 00:06:48,410
é que o loop de eventos é organizado em uma seqüência de fases.

103
00:06:48,410 --> 00:06:51,710
Então, como você vê no diagrama mostrado aqui,

104
00:06:51,710 --> 00:06:55,060
as fases incluem manipulação de temporizador, manipulação de

105
00:06:55,060 --> 00:06:58,390
retorno de chamada de E/S, então você tem ocioso, preparar, em

106
00:06:58,390 --> 00:07:05,800
seguida, a pesquisa onde as solicitações de entrada para conexões ou dados são tratadas,

107
00:07:05,800 --> 00:07:07,585
e, em seguida, a fase de verificação

108
00:07:07,585 --> 00:07:10,290
e, finalmente, a fase de retorno de chamada de fechamento.

109
00:07:10,290 --> 00:07:16,351
Agora, alguns detalhes sobre o que é feito em cada uma dessas fases estão listados no lado direito.

110
00:07:16,351 --> 00:07:17,905
Na fase de temporizador,

111
00:07:17,905 --> 00:07:21,550
o loop de evento manipula qualquer coisa que é acionada pela

112
00:07:21,550 --> 00:07:25,770
função setTimeout () em JavaScript.

113
00:07:25,770 --> 00:07:29,010
Os retornos de chamada de E/S são executados,

114
00:07:29,010 --> 00:07:32,620
quase todos os retornos de chamada que voltam a ser

115
00:07:32,620 --> 00:07:36,795
executados após uma solicitação de E/S serão manipulados pela fila de retornos de chamada de E/S.

116
00:07:36,795 --> 00:07:41,065
Portanto, cada uma dessas fases mantém sua própria fila separada

117
00:07:41,065 --> 00:07:46,053
e o loop de eventos Node.js pega solicitações de cada uma dessas filas e os manipula.

118
00:07:46,053 --> 00:07:52,150
O, ocioso, prepare, destina-se ao uso interno por Node.js.

119
00:07:52,150 --> 00:07:57,910
A pesquisa é onde ele recupera novos eventos de E/S a serem manipulados e, talvez,

120
00:07:57,910 --> 00:08:00,313
as solicitações vindas de fora.

121
00:08:00,313 --> 00:08:08,354
A fase de retorno de chamada próxima lida com quaisquer fechamentos de soquete que precisam ser manuseados, e assim por diante.

122
00:08:08,354 --> 00:08:11,050
Agora, não precisamos nos preocupar muito com

123
00:08:11,050 --> 00:08:15,430
todos esses detalhes se precisarmos realmente escrever um aplicativo Node.js.

124
00:08:15,430 --> 00:08:19,720
Quando necessário, vamos olhar para alguns desses detalhes como e quando

125
00:08:19,720 --> 00:08:25,030
é essencial para entender como nosso aplicativo Node funciona.

126
00:08:25,030 --> 00:08:27,985
Mas, no momento, isso lhe dá uma visão geral

127
00:08:27,985 --> 00:08:31,990
de como o loop de eventos Node.js é manipulado.

128
00:08:31,990 --> 00:08:35,830
Basta dizer que esta é informação suficiente para que possamos

129
00:08:35,830 --> 00:08:40,590
entender os aplicativos Node e como eles funcionam para o momento.

130
00:08:40,590 --> 00:08:42,895
Se você quiser saber mais detalhes,

131
00:08:42,895 --> 00:08:46,810
então eu lhe dei um link para uma descrição detalhada na

132
00:08:46,810 --> 00:08:53,930
documentação Node.js que explica sobre o loop de eventos com mais detalhes.

133
00:08:53,930 --> 00:08:58,615
Com esta compreensão rápida de Node,

134
00:08:58,615 --> 00:09:01,445
Callbacks, e manipulação de erro,

135
00:09:01,445 --> 00:09:03,296
vamos passar para o exercício,

136
00:09:03,296 --> 00:09:09,280
onde vamos olhar para como um aplicativo Node pode escrito com Callbacks,

137
00:09:09,280 --> 00:09:14,110
e como os erros podem ser tratados dentro de um aplicativo Node.

138
00:09:14,110 --> 00:09:18,840
Veremos o uso repetido deste padrão em exercícios subsequentes,

139
00:09:18,840 --> 00:09:21,421
e lições subsequentes especificamente,

140
00:09:21,421 --> 00:09:22,960
quando olharmos para o Express,

141
00:09:22,960 --> 00:09:26,860
e como construímos aplicativos do lado do servidor usando

142
00:09:26,860 --> 00:09:32,720
o Express com mais detalhes na parte posterior deste curso.