Async: Rückrufversprechen, wenn Rückruf nicht vorgesehen ist?

In der Vergangenheit war async dagegen (siehe #1086).

Mit der neuen async/await -Syntax, dem Node-Hinzufügen von Promise-APIs in der Zukunft und der zunehmenden Unterstützung für Promises wäre ich jedoch bereit, dies noch einmal zu überdenken. Gedanken @aearly @megawac?

Ich habe darüber nachgedacht und ein bisschen damit experimentiert. Die Leute werden await Async.mapLimit(arr, 10, async foo => {...}) wollen. Es könnte sehr gut etwas sein, das wir in 3.0 einbauen.

Außerdem wären einige Async-Methoden mit async/await ziemlich dumm, zB series , waterfall .

Bei der Verwendung von Async bin ich natürlich von der Rückkehr eines Versprechens ausgegangen. Erst bei der Fehlfunktion meines Codes und meinem routinemäßigen rtfm-Moment bemerkte ich die Callback-Struktur. Das Obige wäre sehr willkommen, da es den Code so einheitlich wie möglich für ES7 halten würde.

Ich stimme zu, dass dies nützlich wäre.

In der Zwischenzeit, wenn jemand gerade feststeckt, fand ich diesen Artikel gut, um zu erklären, wie man eine forEach-Schleife mit await schreibt.
https://codeburst.io/javascript-async-await-with-foreach-b6ba62bbf404

Endlich mein altes Experiment ausgegraben: #1526

+1

• In asynchrone Methode konvertieren

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);
  });
}

Beispiel 1:

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

Beispiel2:

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 , Ihre Promisify-Funktion ist Overhead. Es kann einfacher sein:

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);
};