trabajar - ¿Cuáles son las diferencias entre diferido, promesa y futuro en JavaScript?
promesas javascript platzi (5)
A la luz del aparente disgusto por cómo he intentado responder a la pregunta del OP. La respuesta literal es, una promesa es algo compartido con otros objetos, mientras que un aplazado debe mantenerse privado. Principalmente, un aplazado (que generalmente extiende la Promesa) puede resolverse por sí mismo, mientras que una promesa podría no ser capaz de hacerlo.
Si estás interesado en los detalles, entonces examina Promises/A+ .
Que yo sepa, el propósito general es mejorar la claridad y aflojar el acoplamiento a través de una interfaz estandarizada. Ver msdn.microsoft.com/en-us/magazine/gg723713.aspx de @ jfriend00:
En lugar de pasar directamente las devoluciones de llamada a las funciones, algo que puede llevar a interfaces estrechamente acopladas, el uso de promesas permite separar las preocupaciones por el código que es síncrono o asíncrono.
Personalmente, me ha parecido que el aplazamiento es especialmente útil cuando se trata, por ejemplo, con plantillas que se rellenan con solicitudes asíncronas, se cargan scripts que tienen redes de dependencias y se proporciona información de los usuarios para formar datos de forma no bloqueable.
De hecho, compare la forma de devolución de llamada pura de hacer algo después de cargar CodeMirror en modo JS de forma asíncrona (disculpas, no he usado jQuery por un tiempo ):
/* assume getScript has signature like: function (path, callback, context)
and listens to onload && onreadystatechange */
$(function () {
getScript(''path/to/CodeMirror'', getJSMode);
// onreadystate is not reliable for callback args.
function getJSMode() {
getScript(''path/to/CodeMirror/mode/javascript/javascript.js'',
ourAwesomeScript);
};
function ourAwesomeScript() {
console.log("CodeMirror is awesome, but I''m too impatient.");
};
});
A las promesas de la versión formulada (nuevamente, disculpas, no estoy actualizado en jQuery):
/* Assume getScript returns a promise object */
$(function () {
$.when(
getScript(''path/to/CodeMirror''),
getScript(''path/to/CodeMirror/mode/javascript/javascript.js'')
).then(function () {
console.log("CodeMirror is awesome, but I''m too impatient.");
});
});
Disculpas por el semi-pseudo código, pero espero que la idea central quede algo clara. Básicamente, al devolver una promesa estandarizada, puede pasar la promesa, permitiendo así una agrupación más clara.
¿Cuáles son las diferencias entre los diferidos, las promesas y los futuros?
¿Hay una teoría generalmente aprobada detrás de estos tres?
Estas respuestas, incluida la respuesta seleccionada, son buenas para introducir promesas conceptualmente, pero carecen de detalles específicos de cuáles son exactamente las diferencias en la terminología que surge cuando se usan bibliotecas que las implementan (y existen diferencias importantes).
Dado que todavía es una especificación en evolución , la respuesta en este momento proviene de intentar examinar tanto las referencias (como en.wikipedia.org/wiki/Futures_and_promises ) como las implementaciones (como jQuery ):
Aplazado : Nunca descrito en referencias populares, en.wikipedia.org/wiki/Futures_and_promises Promises/A+ 3 4 pero comúnmente utilizado por las implementaciones como árbitro de resolución de promesas (implementación de
resolveyreject). 5 jQuery 7A veces, los aplazados también son promesas (implementándose
then), otras jQuery veces se considera más puro tener el aplazado solo con capacidad de resolución, y obligar al usuario a acceder a la promesa de usarlo enthen. 7Promesa : la palabra más completa de la estrategia en discusión.
Un objeto proxy que almacena el resultado de una función de destino cuya sincronicidad nos gustaría abstraer, más la exposición de una función que acepta otra función de destino y devuelve una nueva promesa. Promises/A+
Ejemplo de CommonJS :
> asyncComputeTheAnswerToEverything() .then(addTwo) .then(printResult); 44Siempre se describe en referencias populares, aunque nunca se especificó en cuanto a la responsabilidad de la resolución. en.wikipedia.org/wiki/Futures_and_promises Promises/A+ 3 4
Siempre presente en implementaciones populares, y nunca dadas habilidades de resolución. 5 jQuery 7
Futuro : un término aparentemente desaprobado que se encuentra en algunas referencias populares en.wikipedia.org/wiki/Futures_and_promises y al menos una implementación popular, 8 pero aparentemente se está eliminando gradualmente de la discusión con preferencia por el término ''promesa'' 3 y no siempre se menciona en las introducciones populares al tema. 9
Sin embargo, al menos una biblioteca utiliza el término genéricamente para abstraer la sincronicidad y el manejo de errores, mientras que no proporciona funcionalidad. 10 No está claro si evitar el término ''promesa'' fue intencional, pero probablemente sea una buena opción, ya que las promesas se basan en ''cosas''. Promises/A+
Referencias
Mis cosas potencialmente confusas
Diferencia entre Promesas / A y Promesas / A +
(TL; DR, Promises / A + resuelve principalmente ambigüedades en Promises / A)
Lo que realmente hizo que todo hiciera clic para mí fue esta presentación de Domenic Denicola.
En un github gist , él dio la descripción que más me gusta, es muy concisa:
El punto de las promesas es devolvernos la composición funcional y las burbujas de error en el mundo asíncrono.
En otras palabras, las promesas son una forma que nos permite escribir código asíncrono que es casi tan fácil de escribir como si fuera sincrónico .
Considera este ejemplo, con promesas:
getTweetsFor("domenic") // promise-returning async function
.then(function (tweets) {
var shortUrls = parseTweetsForUrls(tweets);
var mostRecentShortUrl = shortUrls[0];
return expandUrlUsingTwitterApi(mostRecentShortUrl); // promise-returning async function
})
.then(doHttpRequest) // promise-returning async function
.then(
function (responseBody) {
console.log("Most recent link text:", responseBody);
},
function (error) {
console.error("Error with the twitterverse:", error);
}
);
Funciona como si estuvieras escribiendo este código síncrono:
try {
var tweets = getTweetsFor("domenic"); // blocking
var shortUrls = parseTweetsForUrls(tweets);
var mostRecentShortUrl = shortUrls[0];
var responseBody = doHttpRequest(expandUrlUsingTwitterApi(mostRecentShortUrl)); // blocking x 2
console.log("Most recent link text:", responseBody);
} catch (error) {
console.error("Error with the twitterverse: ", error);
}
(Si esto todavía suena complicado, mira esa presentación!)
En cuanto a diferido, es una forma de .resolve() o .reject() promesas. En la especificación de Promises/B , se llama .defer() . En jQuery, es $.Deferred() .
Tenga en cuenta que, por lo que sé, la implementación de Promise en jQuery está rota (vea esa información), al menos en jQuery 1.8.2.
Supuestamente, implementa CommonJS , pero no obtiene el manejo correcto de errores que debería, en el sentido de que la funcionalidad completa de "async try / catch" no funcionará. Lo que es una pena, porque tener un "intento / captura" con código asíncrono es absolutamente genial.
Si vas a usar Promesas (¡deberías probarlas con tu propio código!), Usa 7 . La versión jQuery es solo un agregador de devolución de llamada para escribir un código jQuery más limpio, pero pierde el punto.
Con respecto al futuro, no tengo idea, no he visto eso en ninguna API.
Edición: la charla de Domenic Denicola en YouTube sobre Promesas del @Farm de @Farm continuación.
Una cita de Michael Jackson (sí, Michael Jackson ) del video:
Quiero que grabe esta frase en su mente: una promesa es un valor asíncrono .
Esta es una excelente descripción: una promesa es como una variable del futuro: una referencia de primera clase a algo que, en algún momento, existirá (o sucederá).
Una promesa representa un proxy para un valor que no se conoce necesariamente cuando se crea la promesa. Le permite asociar controladores a un valor de éxito eventual de una acción asíncrona o motivo de falla. Esto permite que los métodos asíncronos devuelvan valores como métodos síncronos: en lugar del valor final, el método asíncrono devuelve la promesa de tener un valor en algún momento en el futuro.
https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise
El método deferred.promise() permite que una función asíncrona evite que otro código interfiera con el progreso o el estado de su solicitud interna. La promesa expone solo los métodos diferidos necesarios para adjuntar controladores adicionales o determinar el estado ( luego, hecho, falla, siempre, canalización, progreso, estado y promesa ), pero no los que cambian el estado ( resolver, rechazar, notificar, resolver con, rechazar Con, y notificar Con ).
Si se proporciona el objetivo, deferred.promise() adjuntará los métodos y luego devolverá este objeto en lugar de crear uno nuevo. Esto puede ser útil para adjuntar el comportamiento de Promesa a un objeto que ya existe.
Si está creando un Aplazado, mantenga una referencia al Aplazado para que se pueda resolver o rechazar en algún momento. Devuelva solo el objeto Promise a través de deferred.promise () para que otro código pueda registrar devoluciones de llamada o inspeccionar el estado actual.
Simplemente podemos decir que una Promesa representa un valor que aún no se conoce, donde un Aplazado representa un trabajo que aún no está terminado.
- Una
promiserepresenta un valor que aún no se conoce. - Un trabajo
deferredrepresenta un trabajo que aún no está terminado
Una promesa es un marcador de posición para un resultado que inicialmente se desconoce, mientras que un aplazado representa el cálculo que resulta en el valor.
Referencia