Inicio Noticias JavaScript Async - Promesas recurrentes

JavaScript Async – Promesas recurrentes

Índice de artículos JavaScript Async – Promesas de devoluciones de Curry

Página 1 de 2

Las promesas son todavía relativamente nuevas y esto significa que hay funciones asincrónicas que no las usan. Esto lleva a la necesidad de prometer código existente y futuro. En este extracto de mi libro sobre JavaScript asíncrono, analizamos algunos de los mecanismos internos de la promesa.

Este es un extracto del recientemente publicado JavaScript Async: eventos de devolución de llamada, promesa y asíncrono / espera.

JavaScript asincrónico

Puedes comprarlo en: Amazon

Contenido

Eventos JavaScript modernos (solo libros), estándar y personalizados La devolución de llamada
extract – La devolución de llamada y el controlador asíncrono personalizado – setTimeout, sendMessage & yield
extracto – Asincrónico personalizado
extraído – Evite el estado con subprocesos de Yield Worker
extracto – Discusiones de trabajadores avanzados de que consumir promesas produce promesas
extracto: modelo de detector del fabricante
extracto – Devolución de promesas *** NUEVO
extraer – Redactar promesas La cola de envío
extracto – Microtask Async y Await
extraído – Asincrónico básico y espera
extracto – DoEvents & Microtasks Fetch, Cache & Service Worker
extraer – Recuperar
extraer – Caché
extracto – Trabajadores de servicios

Después de aprender a usar o consumir Promises en el capítulo anterior, el siguiente paso es agregar soporte para Promises a las funciones asincrónicas y trabajar con ellas para crear nuevas funciones de Promise.

Incluido en el capítulo pero no en este extracto

El problema de las promesas El modelo del constructor de detectores

El mecanismo de la promesa

Cuando creas una Promise estándar, usas su constructor y le pasas una función, el ejecutor, que es inmediatamente ejecutada por el constructor. Esta es la función en la que crea la tarea asincrónica y luego llama a la resolución o al rechazo en consecuencia, generalmente cuando la tarea asincrónica se ha completado.

En otras palabras, este es el código que hace el trabajo.

Por ejemplo, el ejemplo de la función de retardo presentado en el capítulo anterior se puede escribir usando Promesas de JavaScript como:

función delay

Puede ver que tiene la misma estructura básica, la única diferencia es que el código ahora llama a las funciones privadas de resolución y rechazo definidas dentro del constructor. El constructor lo ejecuta inmediatamente, pasándole las funciones privadas de resolución y rechazo, y devuelve la Promesa.

Observe que dentro de la función que pasa al constructor, las llamadas para resolver y rechazar dan como resultado la llamada a todas las funciones onComplete y onError que el consumidor de Promise ha establecido usando el método then del objeto Promise devuelto. Llame a la resolución o al rechazo solo cuando la tarea asincrónica se haya completado y devuelva el valor o el código de error en Resolver y rechazar.

Ahora podemos comprender la prueba de Promesa presentada en el capítulo anterior:

function delay (t, p) {var promise = new Promise (function (resolver, rechazar) {setTimeout (function () {var r = Math.random (); if (r> p) {resolve (r);} else {rechazo (r);}}, t);}); promesa de devolución; }

Puede ver lo que sucede es que creamos un nuevo objeto Promise que se devuelve a la persona que llama casi de inmediato. También usamos setTimeout para colocar una función en la cola de eventos que, cuando se agota el tiempo, llama a la función de resolución o rechazo con la probabilidad especificada de devolver el número aleatorio como valor resuelto.

Coverasync

El problema de los parámetros de esa época

Dado que el retraso devuelve una Promesa, parece obvio que se puede utilizar en cadena (consulte el capítulo anterior). Sin embargo, existe un problema.

Si intentas:

Tome su tiempo (); delay (1000,0). then (getTime). then (delay (1000,0)). then (getTime);

donde getTime es algo como:

getTime () function {var time = new Date (). getTime (); console.log (hora); }

mostrando un recuento de temporizador en milisegundos, lo que encuentra es que parece funcionar, pero si observa de cerca las funciones getTime reportan tiempos con solo unos pocos milisegundos de diferencia, en lugar de 1000 ms.

La razón debería ser fácil de detectar. La función pasada a la función then tiene parámetros:

.entonces (retraso (1000,0))

y esto significa que la función se evalúa inmediatamente y no se pasa para que se active en un momento posterior.

El problema es que no puede pasar un parámetro a una función que usa en un entonces.

Tenga en cuenta que cuando se llama mediante Promise, se puede pasar cualquier número de parámetros a la función dependiendo de cómo se resuelva la Promesa.

Hay varias soluciones al problema, pero ninguna es 100% satisfactoria.

El primero, y el más obvio, es no usar un parámetro en absoluto, pero eso daría como resultado una función de retardo que proporciona un retardo de tiempo fijo y esto generalmente no es lo que desea.

Marc Gomez
Vine a por tabaco y ya me quedé aquí. Cuando no estoy en el sótano de Tecnopasion suelo pasear por las calles de Barcelona.
RELATED ARTICLES