1
00:00:03,920 --> 00:00:08,675
En esta conferencia y el ejercicio que sigue,

2
00:00:08,675 --> 00:00:12,000
hablaremos específicamente de Callback Hell.

3
00:00:12,000 --> 00:00:15,330
El problema que surge cuando se escriben

4
00:00:15,330 --> 00:00:19,980
devoluciones de llamada en el nodo y especialmente las devoluciones de llamada anidadas y el nodo.

5
00:00:19,980 --> 00:00:26,795
También veremos las promesas como una forma de abordar el problema del infierno de devolución de llamada.

6
00:00:26,795 --> 00:00:34,340
Para darle una idea de lo que resultará el típico problema del infierno de devolución de llamada,

7
00:00:34,340 --> 00:00:40,115
volvamos a visitar el archivo index.js del ejercicio anterior.

8
00:00:40,115 --> 00:00:44,020
Como estaba hablando de ello en el ejercicio anterior,

9
00:00:44,020 --> 00:00:47,959
usted nota que para cada una de las operaciones que realizamos,

10
00:00:47,959 --> 00:00:53,990
la operación posterior se incluye dentro de la función de devolución de llamada aquí

11
00:00:53,990 --> 00:01:00,320
y así sucesivamente hasta que se forma una estructura pirámide como ir de nuevo.

12
00:01:00,320 --> 00:01:06,160
Así que ves esta estructura como pirámide surgiendo dentro de tu código.

13
00:01:06,160 --> 00:01:11,540
Ahora imagine que necesita realizar múltiples operaciones anidadas como esta,

14
00:01:11,540 --> 00:01:13,850
su código se volverá muy pronto,

15
00:01:13,850 --> 00:01:18,085
muy complejo y no tan fácil de descifrar.

16
00:01:18,085 --> 00:01:22,240
Ahora bien, esto es a lo que en el mundo node.js,

17
00:01:22,240 --> 00:01:25,830
se refieren como Callback Hell.

18
00:01:25,960 --> 00:01:30,845
Ha habido varias formas de mitigar el problema que se plantea.

19
00:01:30,845 --> 00:01:35,690
Ahora puede evitarlo por completo debido al hecho de

20
00:01:35,690 --> 00:01:38,300
que tiene ciertas operaciones que deben

21
00:01:38,300 --> 00:01:41,480
completarse antes de que se pueda iniciar la siguiente operación,

22
00:01:41,480 --> 00:01:47,765
pero podemos reorganizar el código de una manera que mitigue este problema.

23
00:01:47,765 --> 00:01:52,080
Las promesas son una de esas formas de abordar esto.

24
00:01:52,080 --> 00:01:56,015
Entonces, para resumir lo que acabamos de discutir, el

25
00:01:56,015 --> 00:01:59,435
código de devolución de llamada fuertemente anidado,

26
00:01:59,435 --> 00:02:02,990
causa el problema del infierno de devolución de llamada y

27
00:02:02,990 --> 00:02:07,010
resulta de nuestra tendencia a escribir programas de arriba hacia abajo.

28
00:02:07,010 --> 00:02:11,990
Todavía estamos colgados con nuestra forma secuencial de escribir código y

29
00:02:11,990 --> 00:02:17,420
por lo tanto vemos que es más conveniente escribir código de arriba a abajo,

30
00:02:17,420 --> 00:02:21,145
y mirarlo como si se estuviera ejecutando en ese orden.

31
00:02:21,145 --> 00:02:24,140
Ahora podemos solucionar el problema del infierno de devolución de llamada al

32
00:02:24,140 --> 00:02:27,460
no usar funciones anónimas para las devoluciones de llamada, sino

33
00:02:27,460 --> 00:02:30,870
declarar esas funciones con nombres específicos,

34
00:02:30,870 --> 00:02:35,630
y luego evitar la forma en que escribimos el código como vio aquí.

35
00:02:35,630 --> 00:02:41,190
Ese es uno de los enfoques que la gente toma para lidiar con el problema del infierno de devolución de llamada.

36
00:02:41,190 --> 00:02:44,990
Hay varios otros enfoques que se han sugerido,

37
00:02:44,990 --> 00:02:51,085
los enlaces a un par de artículos a este respecto se proporcionan en los recursos adicionales.

38
00:02:51,085 --> 00:02:53,720
Pero en esta conferencia en particular,

39
00:02:53,720 --> 00:02:56,810
me concentraré en un enfoque particular que

40
00:02:56,810 --> 00:03:00,275
se utiliza para tratar el problema del infierno de devolución de llamada,

41
00:03:00,275 --> 00:03:02,370
que es el uso de promesas.

42
00:03:02,370 --> 00:03:07,345
Así que podemos usar promesas para domar el problema del infierno de devolución de llamada hasta cierto punto.

43
00:03:07,345 --> 00:03:12,200
Vamos a ver cómo las promesas nos ayudan en este sentido y en

44
00:03:12,200 --> 00:03:17,180
el ejercicio veremos cómo debido a que el controlador NODE-MONGO DB ya

45
00:03:17,180 --> 00:03:21,665
soporta una interfaz proxy podemos aprovechar eso para reescribir nuestro código

46
00:03:21,665 --> 00:03:27,495
para aprovechar el soporte prometido en el controlador MONGO DB.

47
00:03:27,495 --> 00:03:31,455
Resumiendo brevemente lo que es una promesa.

48
00:03:31,455 --> 00:03:35,625
Una promesa es un mecanismo que admite el cálculo asíncrono.

49
00:03:35,625 --> 00:03:39,250
Así que si usted tiene la cantidad de trabajo que debe hacerse,

50
00:03:39,250 --> 00:03:43,550
la promesa actúa como un proxy para un valor que

51
00:03:43,550 --> 00:03:48,100
no se conoce en este momento, pero la promesa es dada a usted.

52
00:03:48,100 --> 00:03:50,270
Pero cuando el valor esté disponible,

53
00:03:50,270 --> 00:03:53,225
estará disponible en el futuro.

54
00:03:53,225 --> 00:03:56,690
Por lo tanto, la promesa representa un marcador de posición para ese valor.

55
00:03:56,690 --> 00:03:58,795
Si el valor resulta correctamente,

56
00:03:58,795 --> 00:04:02,240
entonces su promesa resulta correctamente y puede hacer que se

57
00:04:02,240 --> 00:04:08,735
ejecute un fragmento de código para manejar el hecho de que la promesa se resolvió correctamente,

58
00:04:08,735 --> 00:04:12,950
si no, entonces maneja el error en esa situación.

59
00:04:12,950 --> 00:04:20,060
Por lo tanto, una promesa se resolverá en resolución o en rechazo de la promesa.

60
00:04:20,060 --> 00:04:23,515
Una promesa pendiente podría resolverse

61
00:04:23,515 --> 00:04:27,105
cuando el valor se obtiene correctamente, por lo que en ese caso,

62
00:04:27,105 --> 00:04:31,755
resolverá o lo que llamamos el cumplimiento de la promesa.

63
00:04:31,755 --> 00:04:33,540
Entonces, cuando la promesa se resuelva,

64
00:04:33,540 --> 00:04:35,960
entonces tendrá un fragmento de código que

65
00:04:35,960 --> 00:04:38,760
maneja el hecho de que la promesa se ha resuelto.

66
00:04:38,760 --> 00:04:40,455
Si la promesa es rechazada,

67
00:04:40,455 --> 00:04:43,985
también debe manejar esa situación

68
00:04:43,985 --> 00:04:48,470
el rechazo de la promesa correspondientemente dentro de su código.

69
00:04:48,470 --> 00:04:52,400
Así que esa es la razón por la que cada vez

70
00:04:52,400 --> 00:04:56,680
que crea una promesa, solo proporciona las opciones de resolución y rechazo de ella.

71
00:04:56,680 --> 00:05:02,905
La opción de resolución suele ser manejada por el médico y luego la opción para su promesa.

72
00:05:02,905 --> 00:05:05,960
Entonces, ¿por qué usamos promesas?

73
00:05:05,960 --> 00:05:08,060
Las promesas se usan porque aborda

74
00:05:08,060 --> 00:05:13,130
el problema del infierno de devolución de llamada en gran medida y las promesas se pueden cambiar.

75
00:05:13,130 --> 00:05:15,860
Por ejemplo, si tiene una promesa que a

76
00:05:15,860 --> 00:05:20,690
su vez desencadena una llamada a otra que devolverá una promesa.

77
00:05:20,690 --> 00:05:26,525
El manejo de la promesa se puede cambiar al mango de la promesa anterior.

78
00:05:26,525 --> 00:05:28,315
Por lo tanto, puede tener un montón de,

79
00:05:28,315 --> 00:05:33,635
luego llamadas que manejarán el retorno del valor.

80
00:05:33,635 --> 00:05:39,930
Ahora veremos el uso de esto en el ejercicio que sigue a esta conferencia.

81
00:05:39,930 --> 00:05:42,275
Para consumir una promesa,

82
00:05:42,275 --> 00:05:47,675
registrará una función de devolución

83
00:05:47,675 --> 00:05:50,810
de llamada adecuada para cuando se notifique al consumidor

84
00:05:50,810 --> 00:05:53,750
de una promesa el cumplimiento o el rechazo de la promesa.

85
00:05:53,750 --> 00:05:59,860
Entonces, las devoluciones de llamada se registran a través de.then () a la promesa.

86
00:05:59,860 --> 00:06:07,040
Utilizará el.catch () para detectar los errores dentro de la promesa de devolución.

87
00:06:07,040 --> 00:06:09,845
Ahora los métodos.then () se pueden

88
00:06:09,845 --> 00:06:15,205
encadenar juntos como verá en el ejercicio que sigue.

89
00:06:15,205 --> 00:06:19,730
Como ejemplo, normalmente manejaría una promesa

90
00:06:19,730 --> 00:06:26,250
encadenando el.then () y el.catch () al valor de promesa.