Quiero implementar una llamada en serie recursiva al método de promesa times , devolviendo el resultado de la función fn de llamar N veces a la matriz.
Actualmente, agregué un atributo adicional de results a la función de times para guardar los resultados de cada llamada fn .
Tampoco quiero usar variables de ámbito de módulo para guardar los resultados. O guarde los resultados pasando parámetros adicionales como times(fn, n, results) , romperá la firma de la función.
La sintaxis async/await no está permitida.
¿Hay alguna forma de usar solo variables locales de función para guardar el resultado?
const times = Object.assign( (fn: (...args: any) => Promise<any>, n: number = 1) => { if (n === 0) return times.results; return fn().then((res) => { times.results.push(res); return times(fn, --n); }); }, { results: [] as any[] }, );Uso:
const createPromise = (args: any) => new Promise((resolve) => { setTimeout(() => { console.log(`[${new Date().toISOString()}]args: `, args); resolve(args); }, 1000); }); async function test() { const actual = await times(() => asyncFn('data'), 3); console.log(actual); // output: [ 'data', 'data', 'data' ] }No hay ninguna razón para usar una variable de result con estado en absoluto. Simplemente invierta la dirección de recursión:
function times<T>(fn: () => Promise<T>, n: number = 1): Promise<T[]> { if (n === 0) return Promise.resolve([]); else return times(fn, n-1).then(results => fn().then(res => { results.push(res); return results; }) }); }Pero si insiste en crear promesas de manera más gradual, deberá usar un parámetro acumulador:
function times<T>(fn: () => Promise<T>, n: number = 1, results: T[] = []): Promise<T[]> { if (n === 0) return Promise.resolve(results); else return fn().then(res => { results.push(res); return times(fn, n-1, results); }); }Si no le gusta tener ese parámetro opcional adicional en su firma, use una función auxiliar local que haga la recursividad:
function times<T>(fn: () => Promise<T>, n: number = 1): Promise<T[]> { function recurse(n: number, results: T[]): Promise<T[]> { if (n === 0) return Promise.resolve(results); else return fn().then(res => { results.push(res); return recurse(n-1, results); }); } return recurse(n, []); } // or more ugly (stateful): function times<T>(fn: () => Promise<T>, n: number = 1): Promise<T[]> { let results: T[] = []; function recurse(): Promise<T[]> { if (n-- === 0) return Promise.resolve(results); else return fn().then(res => { results.push(res); return recurse(); }); } return recurse(); }Lo que está tratando de lograr es tener un patrón secuencial y recursivo. Puedes lograrlo de la siguiente manera
finalPromise : Promesa a ser devuelta desde la funciónpromise : Promesa que será creada por pasar fnfinalPromise , copie la referencia de la función de resolución y guárdela para una llamada manual, diga resolverFnresult variable para almacenar valores. Esto debería ser del tipo any[]promise.then ,resulttimes será resolverFn si n === 1 . Asegúrese de vincular el result antes de pasar o hacer () => resolverFn(result)fninnerPromise y luego, llame a resolverFn con result