如何在 JavaScript 中检查函数是否异步

作者

在 JavaScript 中检查函数是否异步

How to Check if a Function is Async in JavaScript

要检查函数是否异步，请访问constructor.name函数的属性并检查值是否等于AsyncFunction。

如果比较返回true，则该函数是异步的。

索引.js
const sum = async (a, b) => {
  return a + b;
};

if (sum.constructor.name === 'AsyncFunction') {
  // 👇️ this runs
  console.log('✅ function is async');
} else {
  console.log('⛔️ function is NOT async');
}

在函数上访问时，该constructor属性返回：

JavaScript 中的每个异步函数都是一个AsyncFunction对象。

最后一步是访问name构造函数上的属性并检查AsyncFunction构造函数是否用于创建函数。

如果条件通过，那么我们就有了一个异步函数。

这种方法适用于箭头和命名函数。

name如果我们在非异步函数上
访问该属性，"Function"则会返回该字符串。

索引.js
function example() {}

console.log(example.constructor.name); // 👉️ "Function"

不同的构造函数用于创建异步和非异步函数，因此我们可以很容易地判断一个函数是否是异步的。

如果您必须经常这样做，请定义一个可重用的函数。

索引.js
function isAsyncFunction(func) {
  return func.constructor.name === 'AsyncFunction';
}

const sum = async (a, b) => {
  return a + b;
};

const subtract = (a, b) => {
  return a - b;
};

console.log(isAsyncFunction(sum)); // 👉️ true
console.log(isAsyncFunction(subtract)); // 👉️ false

该函数将另一个函数作为参数，true如果提供的函数是异步的则返回，false否则返回。

非异步函数也可能返回一个 Promise

请记住，非异步函数可能会返回一个承诺。

索引.js
// 👇️ non-async returns Promise
function example() {
  return new Promise(resolve => {
    resolve(100);
  });
}

console.log(example()); // 👉️ Promise {}

console.log(example.constructor.name); // 👉️ "Function"

该示例显示了一个返回承诺的非异步函数。

了解非异步函数是否返回承诺的唯一方法是调用该函数。

在 JavaScript 中检查函数是否返回 Promise

检查函数是否返回 Promise：

  1. 检查函数是否为async.
  2. 或者，调用函数并检查它是否返回承诺。
  3. 如果满足任一条件，该函数将返回一个承诺。
索引.js
// ✅ Promise check
function isPromise(p) {
  if (typeof p === 'object' && typeof p.then === 'function') {
    return true;
  }

  return false;
}

// ✅ Check if a function's return value is a Promise
function returnsPromise(f) {
  if (
    f.constructor.name === 'AsyncFunction' ||
    (typeof f === 'function' && isPromise(f()))
  ) {
    console.log('✅ Function returns promise');
    return true;
  }

  console.log('⛔️ Function does NOT return promise');
  return false;
}

// 👇️ Examples
async function exampleAsync() {}
function example() {}
function examplePromise() {
  return new Promise(resolve => {
    resolve(42);
  });
}

console.log(returnsPromise(exampleAsync)); // 👉️ true
console.log(returnsPromise(example)); // 👉️ false
console.log(returnsPromise(examplePromise)); // 👉️ true

代码示例中的第一个函数检查传入的值是否为 Promise。

索引.js
function isPromise(p) {
  if (typeof p === 'object' && typeof p.then === 'function') {
    return true;
  }

  return false;
}

第二个函数将另一个函数作为参数并检查它的返回值是否是一个 promise。

索引.js
function returnsPromise(f) {
  if (
    f.constructor.name === 'AsyncFunction' ||
    (typeof f === 'function' && isPromise(f()))
  ) {
    console.log('✅ Function returns promise');
    return true;
  }

  console.log('⛔️ Function does NOT return promise');
  return false;
}

语句中的第一个条件if检查函数是否为async。

每个async函数都会返回一个 Promise，因此如果函数是，我们就知道它会返回一个 Promise。 async

Our second condition checks if the passed-in value is a function and invokes it,
passing the result to the isPromise() function.

The only way to check if a non-async function returns a promise is to invoke it. Note that it might not be safe to invoke the function if it mutates state, e.g. writes to a database.

There are two ways to check if a function returns a promise:

  1. Check if the function is async – then it returns a promise 100% of the
    time.
  2. Check if the function’s return value is an object that has a property then
    of type function.

An alternative approach is to not check if the function returns a Promise, but
to use the Promise.resolve() method instead.

Guarantee that the function always returns a Promise #

You can use the Promise.resolve() method to guarantee that the function will
always return a Promise.

index.js
function example() {
  return 42;
}

Promise.resolve(example()).then(value => {
  console.log(value); // 👉️ 42
});

The function doesn’t return a Promise, however, we used the Promise.resolve()
method to wrap the value in a Promise.

The code sample also works if the function returns a Promise.

index.js
async function example() {
  return 42;
}

Promise.resolve(example()).then(value => {
  console.log(value); // 👉️ 42
});

We marked the function as async and async functions always return a Promise.

Either way, our code works as expected.

The
Promise.resolve
method resolves the supplied value to a Promise.

If the provided value is a Promise, then the Promise is returned, otherwise, the
method returns a Promise that is resolved with the supplied value.

If the value is not a Promise, we wrap it in one to be able to use the .then()
method.

如果该值是一个 Promise，它会按原样返回，我们仍然可以使用该.then()方法。