Ожидаемый тип в TypeScript

Question

Я часто использую async / await в JavaScript. Теперь я постепенно преобразовываю некоторые части моих баз кода в TypeScript.

В некоторых случаях мои функции принимают функцию, которая будет вызываться и ожидаться. Это означает, что он может либо вернуть обещание, просто синхронное значение. Для этого я определил тип Awaitable.

type Awaitable<T> = T | Promise<T>;

async function increment(getNumber: () => Awaitable<number>): Promise<number> {
  const num = await getNumber();
  return num + 1;
}

Это можно назвать так:

// logs 43
increment(() => 42).then(result => {console.log(result)})

// logs 43
increment(() => Promise.resolve(42)).then(result => {console.log(result)})

Это работает. Однако раздражает необходимость указывать Awaitable для всех моих проектов, использующих async / await и TypeScript.

Я не могу поверить, что такой тип не встроен, но я не смог его найти. Есть ли в TypeScript встроенный ожидаемый тип?

Answer 1

Я думаю, что ответ на этот вопрос: нет, для этого нет встроенного типа.

В lib.es5.d.ts и lib.es2015.promise.d.ts они используют T | PromiseLike<T> для различных мест, в которых ваш Awaitable<T> будет иметь смысл, например:

/**
 * Represents the completion of an asynchronous operation
 */
interface Promise<T> {
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<TResult1 | TResult2>;

    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): Promise<T | TResult>;
}

Нет ничего похожего на ваши Awaitable в lib.es5.d.ts, где они определяют PromiseLike и Promise.

Я думаю, если бы они определили один, они использовали бы его в этих определениях.

Примечание: на основании этих определений, вероятно, имеет смысл использовать PromiseLike вместо Promise в вашем Awaitable:

type Awaitable<T> = T | PromiseLike<T>;

Answer 2

1. async/await всегда приводит к тому, что оператор будет заключен в обещание, поэтому ваша функция всегда будет возвращать обещание.
2. можно ожидать всего, независимо от того, является он асинхронным или нет, поэтому пользовательский тип Awaitable может быть просто избыточным ...

async function test() {
    const foo = await 5;
    console.log(foo);

    const bar = await 'Hello World';
    console.log(bar);

    const foobar = await Promise.resolve('really async');
    console.log(foobar);
}

test();

Ссылка на детскую площадку

Вам не нужно дополнительно набирать imho, поскольку ваша функция всегда будет иметь:

async function foo<T>(task: () => T | Promise<T>): Promise<T> {
  const result = await task();

  return result;
}