Ich muss eine Funktion an eine andere Funktion übergeben und als Rückruf ausführen. Das Problem ist, dass diese Funktion manchmal asynchron ist, wie:

async function() {
 // Some async actions
}

Ich möchte also ausführen await callback()oder callback()abhängig von der Art der Funktion, die es empfängt.

Gibt es eine Möglichkeit, den Typ der Funktion zu kennen?

Theorie

Native asyncFunktionen können bei der Konvertierung in Zeichenfolgen identifiziert werden :

asyncFn[Symbol.toStringTag] === 'AsyncFunction'

Oder vom AsyncFunctionKonstruktor:

const AsyncFunction = (async () => {}).constructor;

asyncFn instanceof AsyncFunction === true

Dies funktioniert nicht mit der Babel / TypeScript-Ausgabe, da asyncFnes sich bei der regulären Funktion im transpilierten Code um eine Instanz von Functionoder GeneratorFunctionnicht handelt AsyncFunction. Um sicherzustellen, dass im transpilierten Code keine Fehlalarme für Generator- und reguläre Funktionen ausgegeben werden:

const AsyncFunction = (async () => {}).constructor;
const GeneratorFunction = (function* () => {}).constructor;

(asyncFn instanceof AsyncFunction && AsyncFunction !== Function && AsyncFunction !== GeneratorFunction) === true

Da native asyncFunktionen 2017 offiziell in Node.js eingeführt wurden, bezieht sich die Frage wahrscheinlich auf die Babel-Implementierung von asyncFunktionen, die sich auf transform-async-to-generatordas Transpilieren asyncin Generatorfunktionen stützen und möglicherweise auch transform-regeneratorzum Transpilieren von Generatoren in reguläre Funktionen verwendet werden.

Das Ergebnis des asyncFunktionsaufrufs ist ein Versprechen. Dem Vorschlag zufolge kann ein Versprechen oder ein Nichtversprechen weitergegeben werden await, await callback()was universell ist.

Es gibt nur wenige Randfälle, in denen dies erforderlich sein kann. Zum Beispiel verwenden native asyncFunktionen native Versprechen intern und greifen nicht global auf, Promisewenn ihre Implementierung geändert wurde:

let NativePromise = Promise;
Promise = CustomPromiseImplementation;

Promise.resolve() instanceof Promise === true
(async () => {})() instanceof Promise === false;
(async () => {})() instanceof NativePromise === true;

Dies kann das Funktionsverhalten beeinflussen (dies ist ein bekanntes Problem für die Implementierung von Angular und Zone.js Versprechen ). Selbst dann ist es vorzuziehen, zu erkennen, dass der Funktionsrückgabewert nicht als PromiseInstanz erwartet wird, anstatt zu erkennen, dass es sich um eine Funktion handelt async, da dasselbe Problem auf jede Funktion anwendbar ist, die eine alternative Versprechenimplementierung verwendet, und nicht nur async( die Lösung für dieses Winkelproblem besteht darin, die asyncRückgabe zu verpacken Wert mit Promise.resolve).

Trainieren

Von außen ist asyncFunktion nur eine Funktion, die bedingungslos native Versprechen zurückgibt, daher sollte sie wie eine behandelt werden. Selbst wenn eine Funktion einmal definiert wurde async, kann sie irgendwann transpiliert werden und zu einer regulären Funktion werden.

Eine Funktion, die ein Versprechen zurückgeben kann

In ES6 kann eine Funktion, die möglicherweise ein Versprechen zurückgibt, mit Promise.resolve(lässt synchrone Fehler) oder einem umschlossenen PromiseKonstruktor (behandelt synchrone Fehler) verwendet werden:

Promise.resolve(fnThatPossiblyReturnsAPromise())
.then(result => ...);

new Promise(resolve => resolve(fnThatPossiblyReturnsAPromiseOrThrows()))
.then(result => ...);

In ES2017 geschieht dies mit await(so soll das Beispiel aus der Frage geschrieben werden):

let result = await fnThatPossiblyReturnsAPromiseOrThrows();
...

Eine Funktion, die ein Versprechen zurückgeben sollte

Die Überprüfung, ob ein Objekt ein Versprechen ist, ist eine separate Frage , sollte jedoch im Allgemeinen nicht zu streng oder locker sein, um Eckfälle abzudecken. instanceof Promisefunktioniert möglicherweise nicht, wenn global Promiseersetzt wurde Promise !== (async () => {})().constructor. Dies kann passieren, wenn Angular- und Nicht-Angular-Anwendungen eine Schnittstelle bilden.

Eine Funktion, die erforderlich ist async, dh immer ein Versprechen zurückzugeben, sollte zuerst aufgerufen werden. Anschließend wird der zurückgegebene Wert als Versprechen überprüft:

let promise = fnThatShouldReturnAPromise();
if (promise && typeof promise.then === 'function' && promise[Symbol.toStringTag] === 'Promise') {
  // is compliant native promise implementation
} else {
  throw new Error('async function expected');
}

TL; DR: asyncFunktionen sollten nicht von regulären Funktionen unterschieden werden, die Versprechen zurückgeben. Es gibt keinen zuverlässigen Weg und keinen praktischen Grund, nicht native transpilierte asyncFunktionen zu erkennen .

Ich bevorzuge diesen einfachen Weg:

theFunc.constructor.name == 'AsyncFunction'

Sowohl @rnd als auch @estus sind korrekt.

Aber um die Frage mit einer tatsächlich funktionierenden Lösung zu beantworten, gehen Sie

function isAsync (func) {
    const string = func.toString().trim();

    return !!(
        // native
        string.match(/^async /) ||
        // babel (this may change, but hey...)
        string.match(/return _ref[^\.]*\.apply/)
        // insert your other dirty transpiler check

        // there are other more complex situations that maybe require you to check the return line for a *promise*
    );
}

Dies ist eine sehr berechtigte Frage, und ich bin verärgert, dass ihn jemand abgelehnt hat. Der Hauptanwendungsfall für diese Art der Überprüfung ist eine Bibliothek / ein Framework / ein Dekorateur.

Dies sind frühe Tage, und wir sollten GÜLTIGE Fragen nicht ablehnen .

Falls Sie NodeJS 10.x oder höher verwenden

Verwenden Sie die native util-Funktion .

   util.types.isAsyncFunction(function foo() {});  // Returns false
   util.types.isAsyncFunction(async function foo() {});  // Returns true

Beachten Sie jedoch alle Bedenken der oben genannten Antworten. Eine Funktion, die nur versehentlich ein Versprechen zurückgibt, gibt ein falsches Negativ zurück.

Und obendrein (aus den Dokumenten):

Beachten Sie, dass dies nur zurückmeldet, was die JavaScript-Engine sieht. Insbesondere stimmt der Rückgabewert möglicherweise nicht mit dem ursprünglichen Quellcode überein, wenn ein Transpilationswerkzeug verwendet wurde.

Aber wenn Sie asyncin NodeJS 10 und keine Transiplation verwenden. Dies ist eine schöne Lösung.

TL; DR

Kurze Antwort: instaceofNach dem Belichten verwenden AsyncFunction - siehe unten.

Lange Antwort: Tu das nicht - siehe unten.

Wie es geht

Sie können feststellen, ob eine Funktion mit dem asyncSchlüsselwort deklariert wurde

Wenn Sie eine Funktion erstellen, wird angezeigt, dass es sich um eine Funktion handelt:

> f1 = function () {};
[Function: f1]

Sie können es mit dem instanceofBediener testen :

> f1 instanceof Function
true

Wenn Sie eine asynchrone Funktion erstellen, wird angezeigt, dass es sich um eine AsyncFunction handelt:

> f2 = async function () {}
[AsyncFunction: f2]

man könnte also erwarten, dass es auch getestet werden kann mit instanceof:

> f2 instanceof AsyncFunction
ReferenceError: AsyncFunction is not defined

Warum das? Weil die AsyncFunction kein globales Objekt ist. Siehe die Dokumente:

• https://developer.mozilla.org/Web/JavaScript/Reference/Global_Objects/AsyncFunction

obwohl, wie Sie sehen können, es unter Reference/Global_Objects...

Wenn Sie einen einfachen Zugang zum benötigen AsyncFunction, können Sie mein unexposedModul verwenden:

• https://www.npmjs.com/package/unexposed

um entweder eine lokale Variable zu erhalten:

const { AsyncFunction } = require('unexposed');

oder um ein globales AsyncFunctionneben anderen globalen Objekten hinzuzufügen :

require('unexposed').addGlobals();

und jetzt funktioniert das oben genannte wie erwartet:

> f2 = async function () {}
[AsyncFunction: f2]
> f2 instanceof AsyncFunction
true

Warum solltest du es nicht tun?

Der obige Code testet, ob die Funktion mit dem asyncSchlüsselwort erstellt wurde. Beachten Sie jedoch, dass es nicht darauf ankommt, wie eine Funktion erstellt wurde, sondern ob eine Funktion ein Versprechen zurückgibt.

Überall, wo Sie diese "asynchrone" Funktion verwenden können:

const f1 = async () => {
  // ...
};

Sie können dies auch verwenden:

const f2 = () => new Promise((resolve, reject) => {
});

obwohl es nicht mit dem asyncSchlüsselwort erstellt wurde und daher nicht mit instanceofoder mit einer anderen Methode übereinstimmt , die in anderen Antworten veröffentlicht wurde .

Beachten Sie insbesondere Folgendes:

const f1 = async (x) => {
  // ...
};

const f2 = () => f1(123);

Das f2ist nur f1mit fest codierten Argumenten und es macht nicht viel Sinn, asynchier hinzuzufügen , obwohl das Ergebnis genauso "asynchron" sein wird wie f1in jeder Hinsicht.

Zusammenfassung

Es ist also möglich zu überprüfen, ob eine Funktion mit dem asyncSchlüsselwort erstellt wurde, aber verwenden Sie sie mit Vorsicht, da Sie beim Überprüfen höchstwahrscheinlich etwas falsch machen.

Es scheint, dass awaitdies auch für normale Funktionen verwendet werden kann. Ich bin nicht sicher, ob es als "gute Praxis" angesehen werden kann, aber hier ist es:

async function asyncFn() {
  // await for some async stuff
  return 'hello from asyncFn' 
}

function syncFn() {
  return 'hello from syncFn'
}

async function run() {
  console.log(await asyncFn()) // 'hello from asyncFn'
  console.log(await syncFn()) // 'hello from syncFn'
}

run()

Hei,

Hier ist ein Ansatz von David Walsh in seinem Blogpost :

const isAsync = myFunction.constructor.name === "AsyncFunction";

Prost!

Sie können zu Beginn davon ausgehen, dass ein Rückruf vielversprechend ist:

export async function runSyncOrAsync(callback: Function) {

  let promisOrValue = callback()
  if (promisOrValue instanceof Promise) {
    promisOrValue = Promise.resolve(promisOrValue)
  }
  return promisOrValue;
}

und sie in Ihrem Code können Sie dies tun:

await runSyncOrAsync(callback)

das wird Ihr Problem mit unwissendem Rückruftyp lösen ....