Async: ¿Promesa de devolución si no se proporciona devolución de llamada?

Históricamente, async ha estado en contra de esto (ver #1086).

Sin embargo, con la nueva sintaxis async/await , el nodo que agrega API de promesa en el futuro y el aumento del soporte para las promesas, estaría abierto a revisar esto. Pensamientos @aearly @megawac?

He pensado en esto, y experimentado con él un poco. La gente va a querer await Async.mapLimit(arr, 10, async foo => {...}) . Muy bien podría ser algo que incluyamos en 3.0.

Además, algunos métodos Async serían bastante tontos con async/await, por ejemplo, series , waterfall .

Al usar Async, asumí naturalmente el regreso de una Promesa. Fue solo en el desfuncionamiento de mi código y en mi momento de rtfm de rutina que noté la estructura de devolución de llamada. Lo anterior sería muy bienvenido ya que mantendría el código ES7 lo más uniforme posible.

Estoy de acuerdo en que esto sería útil.

Mientras tanto, si alguien está atascado en este momento, encontré este artículo bueno para explicar cómo escribir un bucle forEach con await.
https://codeburst.io/javascript-async-await-with-foreach-b6ba62bbf404

Finalmente desenterré mi viejo experimento: #1526

+1

• Convertir a método asíncrono

function makeAsync() {
  if (arguments.length < 3) return; // wrong params, not run or throw exception here!
  let fixParams = {};
  let paramLength = arguments.length;
  let method = arguments[0];
  for (let i = 1; i < arguments.length; i++) {
    fixParams[(i - 1)] = arguments[i];
  }
  return new Promise((resolve, reject) => {
    const callback = (err, result) => {
      if (err) return reject(err);
      return resolve(result);
    };

    fixParams[paramLength - 1] = callback;
    fixParams.length = paramLength;
    method.apply(null, fixParams);
  });
}

Ejemplo 1:

await makeAsync(async.each, openFiles, async (file) => {
  await asyncOperation(file);
});

ejemplo2:

const foo = async () => {
    const arr = Array.from({ length: 1000 }, (v, i) => i);
    const transformedArr = await makeAsync(async.mapLimit, arr, 100, async (v) => {
        return await Promise.resolve(v * 2);
    });
    console.log(transformedArr);
}

@tritoanst , su función de promesa está sobrecargada. Puede ser más fácil:

function promisify(original) {
    return function (...args) {
        return new Promise((resolve, reject) => {
            args.push((err, result) => {
                if (err) {
                    reject(err);
                } else {
                    resolve(result);
                }
            });

            original.apply(this, args);
        });
    };
}

const foo = async () => {
    const arr = Array.from({ length: 1000 }, (v, i) => i);
    const transformedArr = await promisify(async.mapLimit)(arr, 100, async (v) => {
        return v * 2; // `return await` is redundant
    });
    console.log(transformedArr);
};