No, me aclaré ¿juegas al ajedrez?
Caiga nuevamente porque concluyó que es un módulo de actualización rápida.
Me sumergiré en el concepto de no grabar y así es cómo trabajar con un código síncrono.
Y para eso, primero tenemos que entender qué es el código asincrónico.
Digamos que configuré un temporizador con tiempo de espera establecido, que es una función integrada en el nodo J.
S allí.
Definimos una función que debe ejecutarse después de que un determinado temporizador expire
Aquí, usaré una función de flecha.
Podrías usar una función con nombre, lo que quieras.
El segundo argumento es el temporizador.
Digamos dos segundos.
Lo expresas en milisegundos.
Entonces dos segundos son dos mil milisegundos en su.
Todo simplemente bloqueado.
El temporizador ha terminado.
Si ahora ejecuto este archivo durante dos segundos, no pasa nada y luego vemos que Taimur está listo.
Ahora, este es un código asincrónico porque no termina inmediatamente e incluso sería un código de envío si
tuviéramos un milisegundo allí.
Entonces, si es súper rápido, no sucede de inmediato en nuestro paso de código.
Es como si tuviéramos un bloqueo de consola.
Hola.
Y registro de consola.
Hola, estos dos fragmentos son código Synchronoss porque se ejecutan uno tras otro y, sin embargo, técnicamente,
por supuesto, Noad tardará un tiempo en ejecutarlos.
Pero no hay demora que no sea su hardware.
Por así decirlo, y por lo tanto, hace un código Synchronoss.
Este es un código enfermo, asíncrono porque no se ejecuta o finaliza de inmediato.
Lleva un poco de tiempo, incluso si eso es muy corto.
Y, de hecho, si ejecuto este archivo de esta manera, ves helo y high antes de que veas que Taimur
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
que se haga eso.
De hecho, aquí reconocerá esta llamada función de devolución de llamada.
Entonces una función debería ejecutarse.
En el futuro, debería volver a llamar más tarde una vez que haya terminado.
Entonces, una vez que este temporizador expiró aquí, simplemente lo reconocerá y luego pasará inmediatamente a
la siguiente línea y ejecutará todo el código síncrono y luego ejecutará su código asíncrono.
Una vez hecho esto, es por eso que primero vemos cuán bajo y alto, aunque en nuestro código se
imprime primero.
Y ese es un concepto crucial que debes entender en JavaScript y especialmente en el nodo.
Y volveré sobre eso a lo largo del curso porque es muy importante.
Ahora, cuando trabaje con deudas y todo aumente a dos segundos, nuevamente, para hacerlo aún más claro, verá nuevamente
que nuestro código de sincronización se ejecuta.
Y luego, después de dos segundos, se ejecuta este código.
Cuando trabajamos con código asíncrono, obtenemos múltiples técnicas de pozo, manejándolo.
La función de devolución de llamada es una, la más antigua, y la verá bastante, especialmente la nota G. S ..
No tiene nada de malo, pero tendrá un problema si tiene un par de operaciones asíncronas dependientes.
Así que aquí configuramos el temporizador.
Y ahora digamos que creo otra función.
Lo que llamaré Fetch Data.
Y allí, también estableceré un temporizador, porque no quiero configurar alguna base de datos o algo así de donde
obtener datos, haremos todo eso para todo el curso.
Por supuesto.
Sin preocupaciones.
Así que aquí nuevamente, tengo otro temporizador allí que toma como un segundo y medio.
Y ahora aquí en Fetch Data, necesito alguna forma de, bueno, hacer algo.
¿Cuándo termina el temporizador interno?
Entonces, aquí realmente esperaré un argumento que llamaré de nuevo, porque este argumento será una
función.
Eventualmente llamaré a mi función interna aquí una vez que haya terminado con el temporizador.
Y allí puedo pasar.
Hecho como un valor, conociendo el lugar donde se usa la búsqueda de datos.
Digamos que está dentro de este conjunto.
Hora.
Llamada.
Llamo a buscar datos como este allí.
Ahora necesito pasar y nunca volver a llamar.
Y aquí.
Recibiré el texto pasado por la devolución de llamada en mi función cuando se ejecute.
Entonces obtendremos algo de texto aquí y puedo consolarlo.
Ahora, esto puede parecer confuso al final aquí, estoy creando mi propia función, que recibe una
devolución de llamada para poder definir una función que debería ejecutar quiere que este temporizador interno se realice desde otro lugar.
Entonces, desde este lugar, sí, es la función que efectivamente se pasa como devolución de llamada.
Y estoy ejecutando esa función aquí.
Ahora, si guardo eso, corro eso.
Tarda dos segundos, luego se completa este tiempo del temporizador.
Y luego, después de un segundo y medio, veo hecho.
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
de llamada.
Y es por eso que siempre tenemos una característica llamada Promesas, que podemos usar.
Ninguna posibilidad.
Ahora, a menudo usaremos paquetes de terceros que ya usan promesas para nosotros.
Entonces, la sintaxis que te mostraré ahora es una que rara vez tienes que escribir por tu cuenta.
Eso lo harán los paquetes detrás de escena.
Todavía es bueno saber que creas una promesa.
Dentro de nuestra función de datos recuperados, estás, digamos.
Al almacenarlo en una constante o variable y luego usando la nueva palabra clave, que usa en JavaScript para
crear un nuevo objeto basado en un constructor.
Si las funciones de constructor son algo que no te dice nada.
Consulte algunos recursos básicos de introducción a JavaScript porque las funciones de constructor son una característica central en
JavaScript.
Y aquí usó la función de constructor de promesa, que está integrada en JavaScript y no G. S ..
Y en realidad también recibe una devolución de llamada, que llega a argumentos, resuelve y rechaza.
Podrías nombrarlos como quieras, pero estas son dos funciones.
Y el primero completa la promesa con éxito.
Lo resuelve con éxito.
El segundo lo rechaza, que es como arrojar un error.
Luego toma su código asíncrono y lo mueve allí.
Y de nuevo, rara vez tienes que escribir esto por tu cuenta.
La mayoría de los paquetes ya lo hacen por ti y te dan la promesa completa, que hace toda la magia
detrás de escena escondida de ti.
Aquí lo hacemos manualmente.
Así que ahora y papá vuelve a llamar.
Tenemos nuestro propio conjunto de funciones.
El tiempo de espera no nos da una promesa API, desafortunadamente.
Así que aquí todos tenemos que usar una devolución de llamada.
Pero en su.
Ahora sabemos que ya no usamos ninguna función de devolución de llamada que tenemos.
Aquí no obtengo ningún argumento y busco datos.
En cambio, aquí lo resuelvo.
Listo, digamos.
Así que regresé con éxito para resolver el valor ahora en buscar datos.
Después de definir la promesa, solo tenemos que devolverla.
Y tenga en cuenta que este es un código síncrono.
Entonces, en realidad, esto se devolverá inmediatamente después de que se haya creado la promesa para codificar en la ejecución de
las promesas, lo que sucederá en algún momento más tarde cuando realmente llamemos a esa función.
Y cuando esta vez Odyn completa.
Así que ahora devolvemos esa promesa aquí.
Y en el lugar donde llamamos datos recuperados, ahora ya no pasamos una devolución de llamada.
Pero ahora podemos usarlo, que es exigible en una promesa y devolvemos una promesa.
Y esto simplemente nos permite ahora definir una función llamada llamada, que se ejecutará una vez que se resuelva
la promesa.
Ahora, ¿cuál es la ventaja de eso?
Si tuviéramos múltiples promesas de este tipo.
Entonces, digamos una información de recuperación en frío nuevamente y luego no tengo que usarla así.
Y por lo tanto, terminaría con anidado.
Callbacks de nuevo.
Pero en cambio, dentro de una promesa y luego bloquear es parte de una promesa.
Puedo devolver una nueva promesa y luego agregar la siguiente y luego bloquear después de la anterior.
Me gusta esto.
Entonces ahora tenemos una cadena, luego bloques.
A este se le llama en la primera promesa, luego en el bloque luego devuelvo otra promesa.
E incluso si eso no nos daría un incentivo prometedor.
Luego, bloquear el retorno lo convertiría en una promesa que se resuelve instantáneamente.
Y luego agregamos otro bloque, que ahora se refiere a esta promesa aquí.
Y esto es más legible que tener devoluciones de llamada anidadas infinitamente.
Así que ahora si corro eso lo vemos.
Hola.
El temporizador ha terminado.
Terminamos.
Y lo vemos hecho de nuevo porque estoy llamando a recuperar datos dos veces.
Por lo tanto, esto puede ser difícil de entender por primera vez.
Lo reutilizaremos.
Teñido este curso y que se hará más claro.
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
sea más manejable.
Siempre hay otra forma de gestionar este asíncrono.
Espere dos palabras clave especiales que puede usar en JavaScript moderno, y tendré una sección separada sobre esto hacia
el final del curso.
Quiero presentarlo aquí porque en realidad puede ser más confuso que esta sintaxis aquí.
Y quiero seguir con este.
No introduzca demasiadas funciones nuevas al mismo tiempo aquí.
Sin embargo, el código asíncrono es algo que debes entender.
Y si no está totalmente claro por ahora, está bien, aunque lo verán por supuesto alterado
un montón, porque tenemos muchos eventos asincrónicos sin posibilidad.
Y lo explicaré varias veces.
También explicaré las promesas nuevamente.
Solo quiero asegurarme de que ya haya visto esto y de que tenga la oportunidad de comprenderlo,
cómo funciona y cómo lo solucionamos.