1
00:00:02,260 --> 00:00:04,100
No, me aclaré ¿juegas al ajedrez?

2
00:00:04,150 --> 00:00:08,590
Caiga nuevamente porque concluyó que es un módulo de actualización rápida.

3
00:00:09,010 --> 00:00:14,980
Me sumergiré en el concepto de no grabar y así es cómo trabajar con un código síncrono.

4
00:00:15,520 --> 00:00:20,110
Y para eso, primero tenemos que entender qué es el código asincrónico.

5
00:00:20,530 --> 00:00:25,340
Digamos que configuré un temporizador con tiempo de espera establecido, que es una función integrada en el nodo J.

6
00:00:25,350 --> 00:00:26,850
S allí.

7
00:00:27,520 --> 00:00:31,380
Definimos una función que debe ejecutarse después de que un determinado temporizador expire

8
00:00:31,870 --> 00:00:33,580
Aquí, usaré una función de flecha.

9
00:00:33,880 --> 00:00:36,100
Podrías usar una función con nombre, lo que quieras.

10
00:00:37,060 --> 00:00:38,620
El segundo argumento es el temporizador.

11
00:00:38,650 --> 00:00:39,850
Digamos dos segundos.

12
00:00:40,090 --> 00:00:41,710
Lo expresas en milisegundos.

13
00:00:41,830 --> 00:00:46,250
Entonces dos segundos son dos mil milisegundos en su.

14
00:00:47,540 --> 00:00:48,190
Todo simplemente bloqueado.

15
00:00:48,260 --> 00:00:49,710
El temporizador ha terminado.

16
00:00:52,670 --> 00:00:58,490
Si ahora ejecuto este archivo durante dos segundos, no pasa nada y luego vemos que Taimur está listo.

17
00:00:59,360 --> 00:01:05,060
Ahora, este es un código asincrónico porque no termina inmediatamente e incluso sería un código de envío si

18
00:01:05,060 --> 00:01:06,680
tuviéramos un milisegundo allí.

19
00:01:06,770 --> 00:01:12,520
Entonces, si es súper rápido, no sucede de inmediato en nuestro paso de código.

20
00:01:12,520 --> 00:01:15,350
Es como si tuviéramos un bloqueo de consola.

21
00:01:16,590 --> 00:01:17,100
Hola.

22
00:01:19,020 --> 00:01:20,460
Y registro de consola.

23
00:01:22,400 --> 00:01:28,790
Hola, estos dos fragmentos son código Synchronoss porque se ejecutan uno tras otro y, sin embargo, técnicamente,

24
00:01:28,790 --> 00:01:32,120
por supuesto, Noad tardará un tiempo en ejecutarlos.

25
00:01:32,300 --> 00:01:35,750
Pero no hay demora que no sea su hardware.

26
00:01:35,840 --> 00:01:39,020
Por así decirlo, y por lo tanto, hace un código Synchronoss.

27
00:01:39,260 --> 00:01:45,110
Este es un código enfermo, asíncrono porque no se ejecuta o finaliza de inmediato.

28
00:01:45,260 --> 00:01:47,930
Lleva un poco de tiempo, incluso si eso es muy corto.

29
00:01:49,000 --> 00:01:55,340
Y, de hecho, si ejecuto este archivo de esta manera, ves helo y high antes de que veas que Taimur

30
00:01:55,520 --> 00:02:04,580
está hecho, aunque es súper rápido porque no G. S. y JavaScript en general no bloquea la ejecución de su código hasta

31
00:02:04,580 --> 00:02:05,660
que se haga eso.

32
00:02:06,260 --> 00:02:11,630
De hecho, aquí reconocerá esta llamada función de devolución de llamada.

33
00:02:11,990 --> 00:02:13,740
Entonces una función debería ejecutarse.

34
00:02:13,760 --> 00:02:18,120
En el futuro, debería volver a llamar más tarde una vez que haya terminado.

35
00:02:18,140 --> 00:02:24,470
Entonces, una vez que este temporizador expiró aquí, simplemente lo reconocerá y luego pasará inmediatamente a

36
00:02:24,470 --> 00:02:30,740
la siguiente línea y ejecutará todo el código síncrono y luego ejecutará su código asíncrono.

37
00:02:30,800 --> 00:02:36,890
Una vez hecho esto, es por eso que primero vemos cuán bajo y alto, aunque en nuestro código se

38
00:02:36,890 --> 00:02:37,820
imprime primero.

39
00:02:38,270 --> 00:02:43,380
Y ese es un concepto crucial que debes entender en JavaScript y especialmente en el nodo.

40
00:02:43,700 --> 00:02:47,110
Y volveré sobre eso a lo largo del curso porque es muy importante.

41
00:02:48,520 --> 00:02:54,430
Ahora, cuando trabaje con deudas y todo aumente a dos segundos, nuevamente, para hacerlo aún más claro, verá nuevamente

42
00:02:54,430 --> 00:02:56,740
que nuestro código de sincronización se ejecuta.

43
00:02:56,920 --> 00:02:58,990
Y luego, después de dos segundos, se ejecuta este código.

44
00:02:59,650 --> 00:03:05,380
Cuando trabajamos con código asíncrono, obtenemos múltiples técnicas de pozo, manejándolo.

45
00:03:06,280 --> 00:03:12,320
La función de devolución de llamada es una, la más antigua, y la verá bastante, especialmente la nota G. S ..

46
00:03:12,680 --> 00:03:20,350
No tiene nada de malo, pero tendrá un problema si tiene un par de operaciones asíncronas dependientes.

47
00:03:20,980 --> 00:03:22,870
Así que aquí configuramos el temporizador.

48
00:03:23,300 --> 00:03:27,280
Y ahora digamos que creo otra función.

49
00:03:29,920 --> 00:03:32,270
Lo que llamaré Fetch Data.

50
00:03:34,390 --> 00:03:40,390
Y allí, también estableceré un temporizador, porque no quiero configurar alguna base de datos o algo así de donde

51
00:03:40,510 --> 00:03:43,520
obtener datos, haremos todo eso para todo el curso.

52
00:03:43,720 --> 00:03:44,110
Por supuesto.

53
00:03:44,120 --> 00:03:44,620
Sin preocupaciones.

54
00:03:45,250 --> 00:03:51,310
Así que aquí nuevamente, tengo otro temporizador allí que toma como un segundo y medio.

55
00:03:52,940 --> 00:03:59,610
Y ahora aquí en Fetch Data, necesito alguna forma de, bueno, hacer algo.

56
00:03:59,640 --> 00:04:01,250
¿Cuándo termina el temporizador interno?

57
00:04:01,730 --> 00:04:07,190
Entonces, aquí realmente esperaré un argumento que llamaré de nuevo, porque este argumento será una

58
00:04:07,190 --> 00:04:07,820
función.

59
00:04:08,090 --> 00:04:12,740
Eventualmente llamaré a mi función interna aquí una vez que haya terminado con el temporizador.

60
00:04:13,340 --> 00:04:14,360
Y allí puedo pasar.

61
00:04:14,390 --> 00:04:18,320
Hecho como un valor, conociendo el lugar donde se usa la búsqueda de datos.

62
00:04:18,380 --> 00:04:20,490
Digamos que está dentro de este conjunto.

63
00:04:20,510 --> 00:04:20,730
Hora.

64
00:04:20,930 --> 00:04:21,410
Llamada.

65
00:04:22,540 --> 00:04:24,610
Llamo a buscar datos como este allí.

66
00:04:24,760 --> 00:04:27,140
Ahora necesito pasar y nunca volver a llamar.

67
00:04:27,940 --> 00:04:28,540
Y aquí.

68
00:04:29,690 --> 00:04:34,040
Recibiré el texto pasado por la devolución de llamada en mi función cuando se ejecute.

69
00:04:34,550 --> 00:04:38,930
Entonces obtendremos algo de texto aquí y puedo consolarlo.

70
00:04:39,970 --> 00:04:44,890
Ahora, esto puede parecer confuso al final aquí, estoy creando mi propia función, que recibe una

71
00:04:45,160 --> 00:04:50,950
devolución de llamada para poder definir una función que debería ejecutar quiere que este temporizador interno se realice desde otro lugar.

72
00:04:51,010 --> 00:04:55,450
Entonces, desde este lugar, sí, es la función que efectivamente se pasa como devolución de llamada.

73
00:04:55,830 --> 00:04:57,490
Y estoy ejecutando esa función aquí.

74
00:04:58,330 --> 00:05:00,460
Ahora, si guardo eso, corro eso.

75
00:05:01,790 --> 00:05:04,680
Tarda dos segundos, luego se completa este tiempo del temporizador.

76
00:05:04,730 --> 00:05:06,770
Y luego, después de un segundo y medio, veo hecho.

77
00:05:07,460 --> 00:05:15,170
Ahora, si tenemos un par de llamadas asíncronas anidadas, como las tenemos aquí, profundizamos cada vez más desde una perspectiva de devolución

78
00:05:15,170 --> 00:05:15,980
de llamada.

79
00:05:16,790 --> 00:05:21,990
Y es por eso que siempre tenemos una característica llamada Promesas, que podemos usar.

80
00:05:22,010 --> 00:05:22,760
Ninguna posibilidad.

81
00:05:23,570 --> 00:05:27,710
Ahora, a menudo usaremos paquetes de terceros que ya usan promesas para nosotros.

82
00:05:28,400 --> 00:05:32,810
Entonces, la sintaxis que te mostraré ahora es una que rara vez tienes que escribir por tu cuenta.

83
00:05:33,260 --> 00:05:35,840
Eso lo harán los paquetes detrás de escena.

84
00:05:36,350 --> 00:05:39,680
Todavía es bueno saber que creas una promesa.

85
00:05:40,900 --> 00:05:43,450
Dentro de nuestra función de datos recuperados, estás, digamos.

86
00:05:44,800 --> 00:05:50,050
Al almacenarlo en una constante o variable y luego usando la nueva palabra clave, que usa en JavaScript para

87
00:05:50,050 --> 00:05:52,660
crear un nuevo objeto basado en un constructor.

88
00:05:53,110 --> 00:05:56,860
Si las funciones de constructor son algo que no te dice nada.

89
00:05:57,190 --> 00:06:04,030
Consulte algunos recursos básicos de introducción a JavaScript porque las funciones de constructor son una característica central en

90
00:06:04,150 --> 00:06:04,930
JavaScript.

91
00:06:05,680 --> 00:06:11,650
Y aquí usó la función de constructor de promesa, que está integrada en JavaScript y no G. S ..

92
00:06:12,970 --> 00:06:18,660
Y en realidad también recibe una devolución de llamada, que llega a argumentos, resuelve y rechaza.

93
00:06:18,850 --> 00:06:21,640
Podrías nombrarlos como quieras, pero estas son dos funciones.

94
00:06:22,180 --> 00:06:25,360
Y el primero completa la promesa con éxito.

95
00:06:25,450 --> 00:06:27,250
Lo resuelve con éxito.

96
00:06:27,640 --> 00:06:31,170
El segundo lo rechaza, que es como arrojar un error.

97
00:06:32,140 --> 00:06:34,870
Luego toma su código asíncrono y lo mueve allí.

98
00:06:35,170 --> 00:06:37,840
Y de nuevo, rara vez tienes que escribir esto por tu cuenta.

99
00:06:38,110 --> 00:06:43,420
La mayoría de los paquetes ya lo hacen por ti y te dan la promesa completa, que hace toda la magia

100
00:06:43,420 --> 00:06:45,160
detrás de escena escondida de ti.

101
00:06:45,610 --> 00:06:46,690
Aquí lo hacemos manualmente.

102
00:06:47,200 --> 00:06:48,510
Así que ahora y papá vuelve a llamar.

103
00:06:48,520 --> 00:06:51,690
Tenemos nuestro propio conjunto de funciones.

104
00:06:51,710 --> 00:06:55,020
El tiempo de espera no nos da una promesa API, desafortunadamente.

105
00:06:55,030 --> 00:06:56,830
Así que aquí todos tenemos que usar una devolución de llamada.

106
00:06:57,430 --> 00:06:58,300
Pero en su.

107
00:07:00,240 --> 00:07:04,860
Ahora sabemos que ya no usamos ninguna función de devolución de llamada que tenemos.

108
00:07:04,950 --> 00:07:07,190
Aquí no obtengo ningún argumento y busco datos.

109
00:07:07,770 --> 00:07:09,900
En cambio, aquí lo resuelvo.

110
00:07:10,230 --> 00:07:11,160
Listo, digamos.

111
00:07:11,520 --> 00:07:16,670
Así que regresé con éxito para resolver el valor ahora en buscar datos.

112
00:07:17,100 --> 00:07:20,520
Después de definir la promesa, solo tenemos que devolverla.

113
00:07:21,060 --> 00:07:23,910
Y tenga en cuenta que este es un código síncrono.

114
00:07:24,240 --> 00:07:30,480
Entonces, en realidad, esto se devolverá inmediatamente después de que se haya creado la promesa para codificar en la ejecución de

115
00:07:30,480 --> 00:07:35,640
las promesas, lo que sucederá en algún momento más tarde cuando realmente llamemos a esa función.

116
00:07:35,820 --> 00:07:37,590
Y cuando esta vez Odyn completa.

117
00:07:38,250 --> 00:07:40,110
Así que ahora devolvemos esa promesa aquí.

118
00:07:40,590 --> 00:07:45,450
Y en el lugar donde llamamos datos recuperados, ahora ya no pasamos una devolución de llamada.

119
00:07:45,810 --> 00:07:51,900
Pero ahora podemos usarlo, que es exigible en una promesa y devolvemos una promesa.

120
00:07:53,490 --> 00:07:59,880
Y esto simplemente nos permite ahora definir una función llamada llamada, que se ejecutará una vez que se resuelva

121
00:07:59,910 --> 00:08:00,780
la promesa.

122
00:08:04,040 --> 00:08:05,610
Ahora, ¿cuál es la ventaja de eso?

123
00:08:06,420 --> 00:08:08,430
Si tuviéramos múltiples promesas de este tipo.

124
00:08:09,970 --> 00:08:16,540
Entonces, digamos una información de recuperación en frío nuevamente y luego no tengo que usarla así.

125
00:08:17,750 --> 00:08:20,640
Y por lo tanto, terminaría con anidado.

126
00:08:22,110 --> 00:08:23,210
Callbacks de nuevo.

127
00:08:24,280 --> 00:08:30,820
Pero en cambio, dentro de una promesa y luego bloquear es parte de una promesa.

128
00:08:31,180 --> 00:08:39,220
Puedo devolver una nueva promesa y luego agregar la siguiente y luego bloquear después de la anterior.

129
00:08:41,020 --> 00:08:41,650
Me gusta esto.

130
00:08:42,310 --> 00:08:44,740
Entonces ahora tenemos una cadena, luego bloques.

131
00:08:45,160 --> 00:08:50,290
A este se le llama en la primera promesa, luego en el bloque luego devuelvo otra promesa.

132
00:08:50,680 --> 00:08:54,120
E incluso si eso no nos daría un incentivo prometedor.

133
00:08:54,280 --> 00:08:58,780
Luego, bloquear el retorno lo convertiría en una promesa que se resuelve instantáneamente.

134
00:08:59,350 --> 00:09:03,700
Y luego agregamos otro bloque, que ahora se refiere a esta promesa aquí.

135
00:09:04,410 --> 00:09:08,680
Y esto es más legible que tener devoluciones de llamada anidadas infinitamente.

136
00:09:09,460 --> 00:09:11,020
Así que ahora si corro eso lo vemos.

137
00:09:11,050 --> 00:09:11,350
Hola.

138
00:09:11,350 --> 00:09:11,770
Hola.

139
00:09:12,160 --> 00:09:13,150
El temporizador ha terminado.

140
00:09:13,690 --> 00:09:14,410
Terminamos.

141
00:09:14,680 --> 00:09:17,500
Y lo vemos hecho de nuevo porque estoy llamando a recuperar datos dos veces.

142
00:09:18,490 --> 00:09:22,330
Por lo tanto, esto puede ser difícil de entender por primera vez.

143
00:09:22,690 --> 00:09:23,590
Lo reutilizaremos.

144
00:09:23,590 --> 00:09:26,050
Teñido este curso y que se hará más claro.

145
00:09:26,380 --> 00:09:35,140
Una vez más, este código no está escrito principalmente por usted, pero es un concepto crucial que hace que nuestro código asíncrono

146
00:09:35,350 --> 00:09:36,640
sea más manejable.

147
00:09:37,420 --> 00:09:40,420
Siempre hay otra forma de gestionar este asíncrono.

148
00:09:40,460 --> 00:09:46,330
Espere dos palabras clave especiales que puede usar en JavaScript moderno, y tendré una sección separada sobre esto hacia

149
00:09:46,330 --> 00:09:47,830
el final del curso.

150
00:09:48,130 --> 00:09:53,590
Quiero presentarlo aquí porque en realidad puede ser más confuso que esta sintaxis aquí.

151
00:09:53,860 --> 00:09:55,300
Y quiero seguir con este.

152
00:09:55,320 --> 00:09:58,750
No introduzca demasiadas funciones nuevas al mismo tiempo aquí.

153
00:09:59,680 --> 00:10:02,290
Sin embargo, el código asíncrono es algo que debes entender.

154
00:10:02,530 --> 00:10:08,230
Y si no está totalmente claro por ahora, está bien, aunque lo verán por supuesto alterado

155
00:10:08,290 --> 00:10:11,510
un montón, porque tenemos muchos eventos asincrónicos sin posibilidad.

156
00:10:12,130 --> 00:10:14,710
Y lo explicaré varias veces.

157
00:10:14,950 --> 00:10:17,080
También explicaré las promesas nuevamente.

158
00:10:17,380 --> 00:10:23,380
Solo quiero asegurarme de que ya haya visto esto y de que tenga la oportunidad de comprenderlo,

159
00:10:23,380 --> 00:10:25,870
cómo funciona y cómo lo solucionamos.