programacion - Programación asincrónica JavaScript: promesas vs generadores

promesas typescript

Question

Las promesas y los generadores le permiten escribir un código asíncrono. No entiendo por qué ambos mecanismos se introducen en la secuencia de comandos ECMA 6. ¿Cuándo es mejor utilizar las promesas y cuándo los generadores?

Answer 1

Las promesas y los generadores son diferentes patrones de software (construcciones):

1. http://en.wikipedia.org/wiki/Futures_and_promises
2. http://en.wikipedia.org/wiki/Generator_(computer_programming)

De hecho, los generadores no son asincrónicos.

Los generadores son útiles cuando necesita obtener una serie de valores no de una vez, sino uno por demanda. El generador devolverá el próximo valor inmediatamente (sincrónicamente) en cada llamada hasta que llegue al final de la secuencia (o interminable en el caso de series infinitas).

Las promesas son útiles cuando necesita "diferir" el valor, que puede no ser computado (o puede no estar disponible) aún. Cuando el valor está disponible, es el valor total (no parte de él), incluso es una matriz u otro valor complejo.

Puedes ver más detalles y ejemplos en artículos de wikipedia.

Answer 2

No hay oposición entre estas dos técnicas. Ellos coexisten juntos completándose agradablemente. Las promesas te dan la capacidad de obtener el resultado de una operación asincrónica que aún no está disponible. Resuelve el problema de Pyramid of Doom . Entonces, en lugar de:

function ourImportantFunction(callback) {
//... some code 1
task1(function(val1) {
//... some code 2
task2(val1, function(val2) {
//... some code 3
task3(val2, callback);
});
});
}

puedes escribir:

function ourImportantFunction() {
return Promise.resolve()
.then(function() {
//... some code 1
return task1(val3)
})
.then(function(val2) {
//... some code 2
return task2(val2)
})
.then(function(val2) {
//... some code 3
return task3(val2);
});
}
ourImportantFunction().then(callback);

Pero incluso con las promesas, debe escribir el código de manera asincrónica: siempre debe pasar devoluciones de llamadas a las funciones. Escribir código asíncrono es mucho más difícil que sincrónico. Incluso con promesas cuando el código es enorme, resulta difícil ver el algoritmo (bueno, es muy subjetivo, alguien puede discutirlo, pero para la mayoría de los programadores, creo que es cierto). Por lo tanto, queremos escribir código asíncrono de forma síncrona. Ahí es donde los generadores vienen a ayudarnos. Entonces, en lugar del código anterior, puedes escribir:

var ourImportantFunction = spawn(function*() {
//... some code 1
var val1 = yield task1();
//... some code 2
var val2 = yield task2(val1);
//... some code 3
var val3 = yield task3(val2);
return val3;
});
ourImportantFunction().then(callback);

donde la realización de spawn más simple posible puede ser algo así como:

function spawn(generator) {
return function() {
var iter = generator.apply(this, arguments);
return Promise.resolve().then(function onValue(lastValue){
var result = iter.next(lastValue);
var done = result.done;
var value = result.value;
if (done) return value; // generator done, resolve promise
return Promise.resolve(value).then(onValue, iter.throw.bind(iter)); // repeat
});
};
}

Como puede ver, el value (resultado de alguna task{N} función asincrónica task{N} ) debe ser una promesa. No puedes hacer esto con devoluciones de llamada.

Lo que queda por hacer es implementar la técnica de spawn en el lenguaje mismo. Así que estamos reemplazando spawn con async y yield con await y estamos llegando a ES7 async / await :

var ourImportantFunction = async function() {
//... some code 1
var val1 = await task1();
//... some code 2
var val2 = await task2(val1);
//... some code 3
var val3 = await task3(val2);
return val3;
}

Te recomiendo que veas este video para entender mejor esta y algunas otras técnicas que vienen. Si el hombre habla demasiado rápido para usted, reduzca la velocidad de reproducción ("ajustes" en la esquina inferior derecha, o simplemente presione [ shift + < ])

¿Qué es lo mejor: solo devoluciones de llamada, promesas o promesas con generadores? Esta es una pregunta muy subjetiva. Callbacks es la solución más rápida posible en este momento (el rendimiento de las promesas nativas es muy malo ahora). Las promesas con generadores le dan la oportunidad de escribir código asíncrono de manera síncrona. Pero por ahora son mucho más lentos que simples devoluciones de llamada.