如何在打字稿中只返回已解决的承诺，忽略错误？

Question

我已经创建了函数，它应该接受 Promises 数组，并且只返回已解决的 Promises。必须忽略错误。所以，它看起来像 Promise.all 但没有错误。问题是在打字稿中正确编写函数。之前，只使用 JS，我有预期的结果。

function promiseIgnoreErrors<T> (arrayOfPromise: Array<T>)  {
    const isArrayEmpty =
      Array.isArray(arrayOfPromise) && arrayOfPromise.length === 0;
  
    return new Promise((resolve, reject) => {
      if (isArrayEmpty) reject(new Error('Forever pending array'));
  
      let resolvedArray: Array<T> = []
      
      let resolvedCounter: number = 0;
  
      arrayOfPromise.forEach((promise, index) => {
        if (promise instanceof Promise) {
          promise
            .then((data) => {
              resolvedArray[index] = data
              resolvedCounter++;      
              if (arrayOfPromise.length === resolvedCounter) resolve(resolvedArray)   
            })
            .catch(() => {
              resolvedCounter++;
              if (arrayOfPromise.length === resolvedCounter) resolve(resolvedArray)
            })
        } else {
          resolvedArray[index] = promise
          resolvedCounter++;
          if (arrayOfPromise.length === resolvedCounter) resolve(resolvedArray)   
        }
      })
    });
  };

问题的简短介绍。我的变量：

const p1 = new Promise((resolve) => setTimeout(() => resolve('JS'), 500))
const p2 = 22
const p3 = new Promise((reject) => setTimeout(() => reject(new Error('Oops')), 100))
const p4 = new Promise((resolve) => setTimeout(() => resolve('TS'), 200))

当我有变量并将它们作为数组传递时，

promiseIgnoreErrors([p1, p2, p3, Promise.reject(10), p4])

我希望：

Promise {<pending>}
[[PromiseState]]: "fulfilled"
[[PromiseResult]]: Array(3)
// ['JS', 22, 'TS']

现在我有：

Promise {<pending>}
    [[PromiseState]]: "fulfilled"
    [[PromiseResult]]: Array(5)
    // ['JS', 22, Error: 'Oops, ?, 'TS']

您可以在控制台中显示我的问题： Playground

我认为这里的问题是泛型类型，正是这一行：

let resolvedArray: Array<T> = []

因为它表明返回的表必须包含与输入中相同的元素。也许它应该类似于：

let resolvedArray: Array<K> extends T = []

我当然知道上面这行是错的，但也许我应该遵循这个想法.. 或者我的功能不正常？

请任何帮助！

Answer 1

这似乎已经足够了。

这个想法是ERRORED是一个哨兵对象；如果数组中的 promise 抛出，我们会捕获它并将其转换为 ERRORED。

isNotErrored(x) 是一个类型保护函数，它保证 TypeScript 的 x 不是哨兵，所以 results.filter(isNotErrored) 的类型最终是 T[]，而不是 (T | '__ERRORED__')[]。

const ERRORED = '__ERRORED__';
type ErroredType = typeof ERRORED;

function isNotErrored<T>(x: T | ErroredType): x is T {
  return x !== ERRORED;
}

async function promiseIgnoreErrors<T>(promises: Array<Promise<T>>): Promise<Array<T>> {
  const results = await Promise.all(promises.map(p => p.catch(() => ERRORED as ErroredType)));
  return results.filter(isNotErrored);
}

例如

promiseIgnoreErrors([Promise.resolve(8), Promise.reject("oh no"), Promise.resolve(16)]).then(r => {
  console.log(r);
});

日志

[8, 16]

忽略拒绝。

编辑：

对于原始输入

const p1 = new Promise((resolve) => setTimeout(() => resolve('JS'), 500))
const p2 = 22
const p3 = new Promise((reject) => setTimeout(() => reject(new Error('Oops')), 100))
const p4 = new Promise((resolve) => setTimeout(() => resolve('TS'), 200))

这不会进行类型检查，因为并非所有输入都是承诺，恕我直言，这是正确的行为。正如 cmets 中所讨论的，裸值应该用 Promise.resolve() 包装，即

const p2 = Promise.resolve(22)

或者你可以在内部这样做：

function isPromiseLike<T>(x: T | Promise<T>): x is Promise<T> {
  return (x as any).then;  // Checks whether the object has a `then`; should be mostly enough.
}

async function promiseIgnoreErrors2<T>(values: Array<T | Promise<T>>): Promise<Array<T>> {
  const promises = values.map((v) => isPromiseLike(v) ? v : Promise.resolve(v));
  const results = await Promise.all(promises.map(p => p.catch(() => ERRORED as ErroredType)));
  return results.filter(isNotErrored);
}

Answer 2

async function promiseIgnoreErrors<T>(arrayOfPromise: Array<T>) {
  const promises = await Promise.all(arrayOfPromise.map((p) => promisify(p)))
  return promises.filter((v) => v != null)
}

const promisify = <T>(value: T) =>
  Promise.resolve(value)
    .then((v) => (v instanceof Error ? null : v))
    .catch(() => null)


const r = promiseIgnoreErrors([p1, p2, p3, p4, p5])

console.log(r)                // Promise { <pending> }
r.then((x) => console.log(x)) // [ 'JS', 22, 'TS' ]

更新

删除 flatMap 版本以避免混淆