promesas - JavaScript asíncrono: devoluciones de llamada frente a diferido/promesa

funciones sincronas javascript

Question

Posible duplicado:
¿Cuáles son las diferencias entre Diferido, Prometido y Futuro en Javascript?

Últimamente he estado haciendo un esfuerzo para mejorar la calidad de mis aplicaciones JavaScript.

Un patrón que he adoptado es usar un objeto de "contexto de datos" separado para cargar datos para mi aplicación (anteriormente lo estaba haciendo directamente en mis modelos de vista)

El siguiente ejemplo devuelve datos que se inicializan en el cliente:

var mockData = (function($, undefined) {

    var fruit = [
        "apple",
        "orange",
        "banana",
        "pear"
        ];

    var getFruit = function() {
        return fruit;
    };

    return {
        getFruit: getFruit
    }
})(jQuery);

En la mayoría de los casos, estaremos cargando datos del servidor, por lo que no podemos devolver una respuesta inmediata. Parece que tengo dos opciones sobre cómo manejamos esto en nuestra API:

1. Utilizando una devolución de llamada
2. Devolviendo una promise .

Anteriormente siempre había utilizado el enfoque de devolución de llamada:

var getFruit = function(onFruitReady) {
    onFruitReady(fruit);
};

// ...

var FruitModel = function(dataContext, $) {
    return {
        render: function() {
            dataContext.getFruit(function(fruit) {
                // do something with fruit
            });
        }
    };
};

Sin embargo, puedo ver cómo es posible terminar en el infierno de devolución de llamada, especialmente cuando se crean aplicaciones complejas de JavaScript.

Luego me encontré con el patrón de diseño de las promesas. En lugar de pedirle a la persona que llama que proporcione una devolución de llamada, en cambio, devuelvo una "promesa" que se puede observar:

var getFruit = function() {
    return $.Deferred().resolve(fruit).promise();
};

// ...
dataContext.getFruit().then(function(fruit) {
    // do something with fruit
});

Puedo ver los beneficios obvios de usar este patrón, especialmente porque puedo wait en varios objetos diferidos, lo que podría ser muy útil al cargar datos de inicialización para una aplicación de una sola página.

Sin embargo, estoy dispuesto a entender los pros y los contras de cada patrón antes de comenzar a usar cualquiera de ellos enojado. También me interesa saber si esta es la dirección en la que van otras bibliotecas. Parece ser el caso de jQuery.

Aquí hay un link al violín que estoy usando para las pruebas.

Answer 1

Al leer los documentos de jQuery a los que se vinculó @Pointy, parece que la diferencia es que la API diferida le permite especificar más de una función para que se llame cuando se complete su solicitud:

A partir de jQuery 1.5, los ganchos de devolución de llamada error (error), éxito (finalizado) y completos (siempre, a partir de jQuery 1.6) son colas administradas de primero en entrar, primero en salir. Esto significa que puede asignar más de una devolución de llamada para cada enlace. Consulte Métodos de objeto diferido, que se implementan internamente para estos $ .ajax () ganchos de devolución de llamada.

Ver también: deferred.then()

Answer 2

Las promesas también se basan en devoluciones de llamada detrás de la escena, por lo que no es realmente una frente a la otra.

El beneficio de las devoluciones de llamada es que son fáciles de implementar con JavaScript simple (por ejemplo, en llamadas ajax).

Las promesas requieren una capa de abstracción adicional, lo que generalmente significa que confiará en una biblioteca (no es un problema en su caso, ya que ya está utilizando jQuery). Son perfectos cuando tratas con múltiples llamadas asíncronas en paralelo.