javascript - trabajar - Cómo crear promesas desde la biblioteca

promises javascript w3schools

Question

Estoy confundido con esto porque cada tutorial que he encontrado hasta ahora asume que puedo editar el código de la biblioteca, o que la biblioteca solo tiene devolución de llamada o la devolución de llamada como el último parámetro.

La biblioteca que estoy utilizando tiene todas las funciones configuradas como function(successCallBack(result), FailCallBack(error),options)

Entonces en cada instancia, termino usando código como

var options={stuff1:1, stuff2:2};
doStuff(success,failure,options);
function success(result){
//handle, usually with another call to a similar function, chaining callbacks together
};
function failure(error){
//handle error
};

¿Cómo puedo convertir esto en promesas cuando solo tengo el control de la llamada, y el éxito y los fracasos?

Además, como beneficio adicional, las cadenas acceden a variables que están fuera de ellas.

var options={stuff1:1, stuff2:2};
doStuff(success,failure,options);
function success(result){
var options2={stuff1:1, stuff2:2};
doStuff2(function(result2){
processStuff(result1, result2);
},function(error){
//handle error
},options2)
};
function failure(error){
//handle error
};
function processSuff(result1,result2){
//do things to results
}

Gracias

Answer 1

En lugar de llamar a promisificar cada vez que desea usar su función, puede ajustarla una vez y obtener una nueva función que puede usar según sea necesario. La nueva función devolverá una promesa y resolverá / rechazará en lugar de las devoluciones de llamada exitosas y fallidas. Esta versión particular de promisify está codificada específicamente para la convención de llamadas que muestra de fn(successCallback, errorCallback, options) . Si tiene otras funciones con diferentes convenciones de llamadas, puede crear una versión de promisificar diferente para ellas:

// return a promisified function replacement for this specific
// calling convention: fn(successCallback, errorCallback, options)
function promisify1(fn) {
return function(options) {
return new Promise((resolve, reject) => {
fn(resolve, reject, options);
});
}
}

Entonces, usarías esto así:

// do this once, somewhere near where doStuff is imported
let doStuffPromise = promisify1(doStuff);
// then, anytime you would normally use doStuff(), you can just use
// doStuffPromise() instead
doStuffPromise(options).then(results => {
// process results here
}).catch(err => {
// handle error here
});

La ventaja de hacerlo de esta manera es que puede "promisificar" una determinada función de conjunto de funciones una sola vez en su proyecto y luego simplemente usar las nuevas versiones promisificadas.

Supongamos que importó un objeto que tenía un montón de estos tipos de interfaces en él. A continuación, podría hacer una función promisifyObj() que haría una interfaz promisificada para todas las funciones en el objeto.

// a "Promise" version of every method on this object
function promisifyAll(obj) {
let props = Object.keys(obj);
props.forEach(propName => {
// only do this for properties that are functions
let fn = obj[propName];
if (typeof fn === "function") {
obj[propName + "Promise"] = promisify1(fn);
}
});
}

Entonces, si tuviera un objeto llamado myModule que tuviera todos estos métodos con esta interfaz no prometedora, podría promisificar ese módulo en un solo paso:

promisifyAll(myModule);

Y, entonces, puedes usar cualquier método de ese objeto simplemente agregando el sufijo "Promesa" al nombre del método:

myModule.someMethodPromise(options).then(results => {
// process results here
}).catch(err => {
// handle error here
});

Answer 2

Puede usar la siguiente función. Acepta una función para promisificar y opciones, y devuelve una promesa:

let promisify = (fn, opts) => {
return new Promise((resolve, reject) => {
fn(resolve, reject, opts);
});
}

Se podría usar de la siguiente manera:

promisify(doStuff, options)
.then(data => console.log(''Success call'', data))
.catch(err => console.log(''Error'', err));