1
00:00:03,980 --> 00:00:08,700
Acabamos de saber sobre o Callback Hell e

2
00:00:08,700 --> 00:00:13,455
como as promessas podem nos permitir superar esse problema.

3
00:00:13,455 --> 00:00:19,575
Sabemos que o driver do nó MongoDB suporta nativamente promessas.

4
00:00:19,575 --> 00:00:22,485
Então, se você não especificar um retorno de chamada,

5
00:00:22,485 --> 00:00:26,385
as chamadas para suas funções retornarão promessas.

6
00:00:26,385 --> 00:00:31,445
Então, vamos atualizar nosso aplicativo para fazer uso de promessas para

7
00:00:31,445 --> 00:00:38,005
evitar a questão do inferno callback que acabamos de aprender na palestra anterior.

8
00:00:38,005 --> 00:00:40,644
Voltando ao nosso aplicativo,

9
00:00:40,644 --> 00:00:48,035
novamente dando mais uma olhada na razão pela qual o inferno de retorno se desenvolveu em nosso código.

10
00:00:48,035 --> 00:00:52,520
Note que aqui quando implementamos as operações,

11
00:00:52,520 --> 00:00:56,899
temos uma operação e, em seguida, dentro do callback dessa operação,

12
00:00:56,899 --> 00:01:00,770
então precisamos iniciar a próxima operação e dentro

13
00:01:00,770 --> 00:01:04,910
do callback dessa operação estamos iniciando a próxima operação e assim por diante.

14
00:01:04,910 --> 00:01:10,040
Então você está terminando com esta pirâmide como estrutura aqui.

15
00:01:10,040 --> 00:01:14,290
Uma operação dentro do retorno de chamada de outra e dentro do callback.

16
00:01:14,290 --> 00:01:21,240
Agora, este código logo vai ficar difícil e complicado de entender.

17
00:01:21,240 --> 00:01:24,760
Então é por isso que queremos transformar este código usando

18
00:01:24,760 --> 00:01:29,380
o suporte de promessa que Mongo DB Driver já

19
00:01:29,380 --> 00:01:33,205
nos fornece para que possamos usar promessas em vez de

20
00:01:33,205 --> 00:01:37,735
usar as funções de retorno de chamada como fizemos neste exercício.

21
00:01:37,735 --> 00:01:42,760
Claro, eu fiz a versão anterior apenas para ilustrar para vocês como podemos

22
00:01:42,760 --> 00:01:48,595
pousar com o inferno callback e como podemos usar promessas para superar esse problema.

23
00:01:48,595 --> 00:01:53,560
Então, antes de atualizar o arquivo index.js,

24
00:01:53,560 --> 00:01:59,989
deixe-me ir para o arquivo operations.jsfile e, em seguida, vamos atualizar isso primeiro.

25
00:01:59,989 --> 00:02:06,950
Então aqui, você vai notar que quando estamos chamando esta função aqui,

26
00:02:06,950 --> 00:02:14,630
estamos passando no segundo parâmetro que é uma função de retorno de chamada aqui.

27
00:02:14,630 --> 00:02:18,210
Então, porque vamos usar promessas aqui.

28
00:02:18,210 --> 00:02:21,545
Então eu vou apenas excluir essa função de retorno de chamada e, em seguida,

29
00:02:21,545 --> 00:02:25,744
uma vez que esta chamada para a inserção vai de qualquer maneira retornar promessas,

30
00:02:25,744 --> 00:02:29,710
eu só vou retornar a promessa desta função.

31
00:02:29,710 --> 00:02:33,605
Então, observe como o código ficou simplificado.

32
00:02:33,605 --> 00:02:36,090
Da mesma forma para o segundo,

33
00:02:36,090 --> 00:02:42,740
vou simplesmente remover essa função de retorno de chamada e,

34
00:02:42,740 --> 00:02:47,900
em seguida, retornar a promessa que está

35
00:02:47,900 --> 00:02:55,580
sendo retornada por isso e, em seguida, vamos lidar com isso no código em index.js.

36
00:02:55,580 --> 00:02:58,495
Da mesma forma para o excluir um também,

37
00:02:58,495 --> 00:03:08,280
eu vou remover o retorno de chamada e, em seguida, retornar esse acidente e também para uptade.

38
00:03:10,600 --> 00:03:16,730
Para atualização, vamos remover o retorno de chamada que demos

39
00:03:16,730 --> 00:03:22,564
aqui e, em seguida, retornar a promessa.

40
00:03:22,564 --> 00:03:25,100
Então, desta forma, todas essas quatro funções vão

41
00:03:25,100 --> 00:03:27,575
ser retornando a promessa que já é retornada

42
00:03:27,575 --> 00:03:33,110
por essas chamadas para as funções do driver MongoDB.

43
00:03:33,110 --> 00:03:34,760
Agora, uma vez que tenhamos concluído isso,

44
00:03:34,760 --> 00:03:38,210
vamos voltar para index.js.

45
00:03:38,210 --> 00:03:44,090
Em index.js, vou atualizar novamente esta função aqui.

46
00:03:44,090 --> 00:03:53,105
Então, usando promessas vai dizer MongoClient.connect (url) e, em seguida,

47
00:03:53,105 --> 00:04:03,470
vamos substituir isso dizendo “então” e isso recebe apenas o banco de dados como seu parâmetro.

48
00:04:03,470 --> 00:04:10,390
E aqui dentro, vamos lidar com o resto e também podemos

49
00:04:10,390 --> 00:04:18,350
fazer notar que esta função particular fecha o “Então” aqui e a promessa,

50
00:04:18,350 --> 00:04:20,505
a segunda parte da promessa,

51
00:04:20,505 --> 00:04:22,845
podemos lidar com o erro.

52
00:04:22,845 --> 00:04:28,055
Podemos dizer consolelog.

53
00:04:28,055 --> 00:04:33,755
Assim, podemos usar a captura da promessa também para capturar os erros.

54
00:04:33,755 --> 00:04:36,275
Então, dessa forma, pegamos os erros.

55
00:04:36,275 --> 00:04:39,815
Agora, vamos melhorar o código aqui dentro.

56
00:04:39,815 --> 00:04:45,530
Então, dentro aqui estamos fazendo DB operação inserir documento,

57
00:04:45,530 --> 00:04:49,685
e em vez de chamar esta função aqui,

58
00:04:49,685 --> 00:04:59,115
o que eu vou fazer é transformar isso no “então” aqui.

59
00:04:59,115 --> 00:05:06,870
Então eu vou fechar isso e dizer. Então resultado.

60
00:05:06,870 --> 00:05:08,800
Então, dentro desses resultados,

61
00:05:08,800 --> 00:05:11,600
vamos imprimir o registro do console e, em seguida,.

62
00:05:11,600 --> 00:05:20,630
Então eu vou fechar isso aqui e então vamos

63
00:05:20,630 --> 00:05:25,505
fechar o “então” aqui e então

64
00:05:25,505 --> 00:05:31,950
isso será anexado novamente a um “então” aqui.

65
00:05:32,600 --> 00:05:36,640
Então você vê que eu estou encadeando dois “thens”

66
00:05:36,640 --> 00:05:40,070
um no outro aqui e, em seguida, dentro de nós, então,

67
00:05:40,070 --> 00:05:47,570
vamos fazer um log de console e, em seguida, vamos fazer um retorno da próxima operação.

68
00:05:47,570 --> 00:05:51,390
Mas então, para esta operação,

69
00:05:52,540 --> 00:06:02,070
eu vou fechar isso e fechar isso

70
00:06:02,070 --> 00:06:06,920
então e então essa chamada novamente agora

71
00:06:06,920 --> 00:06:13,320
será tratada dentro de uma função “então” aqui.

72
00:06:13,460 --> 00:06:20,510
Então note como você tem a primeira função e no “então” estamos chamando

73
00:06:20,510 --> 00:06:27,870
o dboper encontrar documentos e que retornará e isso retornará uma promessa.

74
00:06:27,870 --> 00:06:30,410
Essa promessa será cumprida por isso.

75
00:06:30,410 --> 00:06:35,720
Então estamos acorrentando dois thens juntos e então novamente encadeando mais um “então” aqui.

76
00:06:35,720 --> 00:06:47,005
Deixe-me reinventar o código aqui e então vamos retornar isso aqui e

77
00:06:47,005 --> 00:06:57,610
isso novamente vai fechar e fechar que “então”

78
00:06:57,610 --> 00:07:07,850
e então isso fica fechado dentro do próximo “então” e

79
00:07:07,850 --> 00:07:13,280
vamos chamar a próxima função aqui “que

80
00:07:13,280 --> 00:07:21,130
db.dropCollection ('Pratos' e fechar “isso então” e o próximo aqui.

81
00:07:26,660 --> 00:07:31,390
Vamos lidar com o “então” do resultado aqui.

82
00:07:39,650 --> 00:07:48,690
Retornar dbclose e todos

83
00:07:48,690 --> 00:07:56,785
estes aqui podem ser removidos agora porque eles não são mais necessários.

84
00:07:56,785 --> 00:08:04,520
E então, finalmente, se houver um erro vai pegar o erro esta função.

85
00:08:04,520 --> 00:08:12,930
Então eu só vou copiar isso e depois colá-lo aqui. É isso.

86
00:08:12,930 --> 00:08:14,755
Com essa mudança agora,

87
00:08:14,755 --> 00:08:20,220
seu código é muito mais fácil de lidar aqui.

88
00:08:20,220 --> 00:08:21,510
Então, como você pode ver,

89
00:08:21,510 --> 00:08:24,560
você tem o mongoClient.connect que

90
00:08:24,560 --> 00:08:28,040
retorna uma promessa e dentro da manipulação dessa promessa,

91
00:08:28,040 --> 00:08:31,700
eles estão chamando esses métodos e um após o outro eles estão

92
00:08:31,700 --> 00:08:35,490
retornando a promessa e, em seguida, você está encadeando-os usando o.

93
00:08:35,490 --> 00:08:41,635
Esta estrutura de acordes é muito mais fácil de seguir do que o que tínhamos implementado anteriormente.

94
00:08:41,635 --> 00:08:46,280
Então, usando promessas que literalmente virou e, em seguida, evitou

95
00:08:46,280 --> 00:08:51,250
o inferno de retorno de chamada que vimos na versão anterior deste aplicativo.

96
00:08:51,250 --> 00:08:53,590
Então vamos salvar as alterações para ambos

97
00:08:53,590 --> 00:08:58,715
index.jsn.operation.js e, em seguida, dar uma olhada neste aplicativo.

98
00:08:58,715 --> 00:09:00,840
Novamente indo para o terminal,

99
00:09:00,840 --> 00:09:03,105
no prompt digite “npm

100
00:09:03,105 --> 00:09:09,515
start” e você verá que seu aplicativo é executado exatamente como antes,

101
00:09:09,515 --> 00:09:12,200
ele insere o documento, localiza o documento,

102
00:09:12,200 --> 00:09:15,080
atualiza o documento e, em seguida,

103
00:09:15,080 --> 00:09:18,530
localiza o documento atualizado e, em seguida, fecha o banco de dados do ato.

104
00:09:18,530 --> 00:09:23,630
Então, usando promessas nós reestruturamos o código para ser muito mais fácil e

105
00:09:23,630 --> 00:09:29,945
evitamos o inferno de retorno de chamada que vimos na versão anterior deste aplicativo.

106
00:09:29,945 --> 00:09:33,705
Com isso, completamos este exercício.

107
00:09:33,705 --> 00:09:36,470
Neste exercício, vocês viram como podemos fazer uso

108
00:09:36,470 --> 00:09:39,590
de promessas para evitar o inferno callback.

109
00:09:39,590 --> 00:09:42,920
Este é um bom momento para você fazer um git commit com

110
00:09:42,920 --> 00:09:47,950
a mensagem callback inferno e promessa.