Quiero llamar a una función dada de forma asíncrona. La función contenedora tryCallAsync es una forma de hacerlo. Este enfoque funciona. Sin embargo, requiere que la devolución de llamada para setImmediate sea una función asíncrona. Esto parece incorrecto, ya que la devolución de llamada devuelve una Promesa que no se usa. ¿Está mal pasar una función asíncrona a setImmediate para este propósito?
async function tryCallAsync(fn, ...args) { return new Promise((r, j) => { setImmediate(async () => { try { r(await fn(...args)); } catch (e) { j(e); } }) }) } // Using tryCallAsync let resolveAsync = tryCallAsync(()=>{ return new Promise((r,j)=>{ setImmediate(()=>r('resolveAsync')); }); }) resolveAsync.then((resolve)=>console.log(resolve)); let resolve = tryCallAsync(()=>{ return 'resolve'; }); resolve.then((resolve)=>console.log(resolve));Sí, está mal, por múltiples razones:
setImmediate no maneja la promesa devuelta, especialmente no se ocupa de los errores 1 1: E incluso aunque su devolución de llamada particular nunca rechace la promesa devuelta debido a la try / catch , todavía se siente mal
Su función debe escribirse como
async function tryCallAsync(fn, ...args) { await new Promise(resolve => { setImmediate(resolve); }); return fn(...args); }Este enfoque no desperdicia una Promesa, sin embargo, aún así, no es tan eficaz como la forma convencional de hacer esto.
function tryCallAsync(fn, ...args) { return new Promise((r, j) => { setImmediate(() => { (async function () { return await fn(...args); })().then(r).catch(j); }); }); }