Я повинен передати функцію іншій функції і виконати її як зворотний виклик. Проблема в тому, що інколи ця функція є асинхронною, наприклад:

async function() {
 // Some async actions
}

Тому я хочу виконати await callback()або callback()залежно від типу функції, яку він отримує.

Чи є спосіб дізнатись тип функції ??

Теорія

Власні asyncфункції можуть бути ідентифіковані при перетворенні в рядки :

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

Або за AsyncFunctionконструктором:

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

asyncFn instanceof AsyncFunction === true

Це не буде працювати з вихідними даними Babel / TypeScript, оскільки asyncFnце звичайна функція у перекладеному коді, це екземпляр Functionчи GeneratorFunctionні AsyncFunction. Щоб переконатися, що це не дасть помилкових спрацьовувань для генератора та звичайних функцій у перекладеному коді:

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

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

Оскільки власні asyncфункції були офіційно представлені в Node.js в 2017 році, питання, ймовірно, стосується реалізації asyncфункції Babel , яка покладається на transform-async-to-generatorтранпіляцію asyncдо функцій генератора, а також може використовуватись transform-regeneratorдля транпіляції генератора до звичайних функцій.

Результатом asyncвиклику функції є обіцянка. Відповідно до пропозиції , обіцянка чи не обіцянка може бути передана await, тому await callback()є універсальною.

Є лише кілька випадків, коли це може знадобитися. Наприклад, власні asyncфункції використовують власні обіцянки внутрішньо і не піднімають глобальні, Promiseякщо їх реалізація була змінена:

let NativePromise = Promise;
Promise = CustomPromiseImplementation;

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

Це може вплинути на поведінку функції (це відома проблема реалізації обіцянок Angular та Zone.js ). Навіть тоді переважно виявити, що значення функції, що повертається, не є очікуваним, Promiseзамість того, щоб виявити, що функцією є async, оскільки ця сама проблема застосовна до будь-якої функції, яка використовує альтернативну реалізацію обіцянки, а не тільки async( рішення вказаної проблеми Angular полягає в обгортанні asyncreturn значення з Promise.resolve).

Практика

Зовні asyncфункція - це просто функція, яка безумовно повертає рідну обіцянку, тому до неї слід ставитись як до такої. Навіть якщо функція колись була визначенаasync , вона в якийсь момент може бути перетворена і стати регулярною функцією.

Функція, яка може повернути обіцянку

У ES6 функція, яка потенційно повертає обіцянку, може використовуватися з Promise.resolve(допускає синхронні помилки) або обгорнутим Promiseконструктором (обробляє синхронні помилки):

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

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

У ES2017 це зроблено за допомогою await(так слід писати приклад із запитання):

let result = await fnThatPossiblyReturnsAPromiseOrThrows();
...

Функція, яка повинна повертати обіцянку

Перевірка того, чи є об’єкт обіцянкою, - це питання окремого питання , але, як правило, воно не повинно бути занадто суворим або вільним, щоб охопити кутові справи. instanceof Promiseможе не працювати, якщо глобальний Promiseбув замінений, Promise !== (async () => {})().constructor . Це може статися, коли Angular та non-Angular програми взаємодіють.

asyncСпершу потрібно викликати функцію, яка вимагає бути , тобто завжди повертати обіцянку, потім повертається значення перевіряється як обіцянку:

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: asyncфункції не слід відрізняти від звичайних функцій, які повертають обіцянки. Не існує надійного способу та немає практичних причин для виявлення неприродних перекладених asyncфункцій.

Я віддаю перевагу такому простому способу:

theFunc.constructor.name == 'AsyncFunction'

І @rnd, і @estus правильні.

Але щоб відповісти на запитання фактичним робочим рішенням, ви тут

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

Це дуже слушне запитання, і я засмучений тим, що хтось голосував за нього. Основним варіантом використання цього типу перевірки є бібліотека / фреймворк / декоратори.

Ці перші дні, і ми не повинні downvote VALID питань.

Якщо ви використовуєте NodeJS 10.x або пізнішої версії

Використовуйте рідну функцію util .

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

Майте на увазі всі занепокоєння зверху. Функція, яка просто випадково повертає обіцянку, поверне помилково негативний результат.

І на додачу до цього (з документації):

Зверніть увагу, що це повідомляє лише про те, що бачить механізм JavaScript; зокрема, повернене значення може не збігатися з вихідним вихідним кодом, якщо використовувався інструмент транпіляції.

Але якщо ви використовуєте asyncв NodeJS 10 і ніякої пересадки немає. Це приємне рішення.

TL; DR

Коротка відповідь: Використовуйте instaceofпісля викриття AsyncFunction - див. Нижче.

Довга відповідь: Не робіть цього - дивіться нижче.

Як це зробити

Ви можете визначити, чи була функція оголошена за допомогою async ключовим словом

Коли ви створюєте функцію, вона показує, що це тип Функція:

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

Ви можете перевірити це за допомогою instanceofоператора:

> f1 instanceof Function
true

Коли ви створюєте асинхронну функцію, вона показує, що це тип AsyncFunction:

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

тому можна очікувати, що його можна протестувати instanceofтакож:

> f2 instanceof AsyncFunction
ReferenceError: AsyncFunction is not defined

Чому так? Оскільки AsyncFunction не є глобальним об’єктом. Перегляньте документи:

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

хоча, як бачите, це вказано в Reference/Global_Objects ...

Якщо вам потрібен легкий доступ до AsyncFunctionтоді, ви можете використовувати мій unexposedмодуль:

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

щоб отримати або локальну змінну:

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

або додати глобальний AsyncFunctionпаралельно з іншими глобальними об'єктами:

require('unexposed').addGlobals();

і тепер вищесказане працює, як очікувалося:

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

Чому ви не повинні цього робити

Наведений вище код перевірить, чи функцію було створено за asyncключовим словом, але майте на увазі, що насправді важливо не те, як була створена функція, а повертає чи не обіцянка.

Скрізь, де ви можете використовувати цю функцію "асинхронізація":

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

Ви також можете використовувати це:

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

навіть незважаючи на те, що воно не було створене за asyncключовим словом, і, отже, не буде узгоджуватися instanceofз будь-яким іншим способом, розміщеним в інших відповідях .

Зокрема, розглянемо це:

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

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

Це f2просто f1з жорстко закодованим аргументом, і немає сенсу додавати asyncсюди, хоча результат буде настільки ж "асинхронним", як і f1в усіх відношеннях.

Резюме

Отже, можна перевірити, чи функцію було створено за asyncключовим словом, але використовувати її слід з обережністю, оскільки ви, перевіряючи її, швидше за все робите щось не так.

Здається, це awaitможна використовувати і для звичайних функцій. Я не впевнений, чи можна це вважати "гарною практикою", але ось воно:

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()

Хей,

Ось підхід, запропонований Девідом Уолшем у своєму блозі :

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

На здоров’я!

На початку можна припустити, що зворотний дзвінок є обіцяним:

export async function runSyncOrAsync(callback: Function) {

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

і їх у своєму коді ви можете зробити це:

await runSyncOrAsync(callback)

що вирішить вашу проблему з невідомим типом зворотного дзвінка ....