将对象的 Observable 转换为 Observables 的对象

Question

我正在尝试创建一个函数，将 Observable 的对象（它本身是 observable 的集合）转换为 Observables 的对象
当前的实现如下所示：

type Inputs = {[inputName: string]: Observable<unknown>}

export const transform = <Inp extends Inputs, Keys extends keyof Inputs>(
  inputs$: Observable<Inp>,
  inputNames: Keys[],
) => {
  const cachedSinks$ = inputs$.pipe(share())

  return inputNames.reduce((result, inpName) => {
    result[inpName] = cachedSinks$
      .pipe(switchMap(sinks => sinks[inpName]))
    return result
  },
  {} as {[K in Keys]: Inp[Keys]})
}

但是，我在 result[inpName] = cachedSinks$ 和 TS2322: Type 'Observable >' is not assignable to type 'Inp[Keys]'. 行出现错误，我不明白为什么会发生这种情况，因为 Inp[Keys] 也是一个 Observable

Answer 1

T[K] 必须扩展一个类型的事实并不意味着在泛型函数内部我们可以为它分配任何值，约束只是告诉我们该值的最低要求是什么，我们还不知道完整的合同 T[K] 要求。 (Titian Cernicova-Dragomir's post)

假设我们将transform 传递给以下Intersection 类型的实例：

type ExtendedInputs = Inputs & {
    age: number
}

将 Observble 分配给 result[inpName] 并不安全，因为 result[inpName] 可能是一个数字。

考虑到这一点，请考虑修改 tranform 函数以直接使用 Input 而不是使用泛型（因为在这种情况下似乎没有必要），如下所示：

export const transform = <K extends keyof Inputs>(
    inputs$: Observable<Inputs>,
    inputNames: K[],
) => {
    const cachedSinks$ = inputs$.pipe(share())

    return inputNames.reduce((result, inpName) => {
        result[inpName] = cachedSinks$.pipe(switchMap(sinks => sinks[inpName]))

        return result
    }, {} as Inputs })
}

更新
如果您确定该值可分配给T[K]，则可以使用type assertion 保持其通用性

export const transform = <T extends Inputs, K extends keyof T>
  (inputs$: Observable<T>, inputNames: K[]) => {
  const cachedSinks$ = inputs$.pipe(share())


  return inputNames.reduce((result, inpName) => {

    result[inpName] = cachedSinks$.pipe(switchMap(sinks => sinks[inpName])) as T[K]

    return result

  }, {} as T)

}

可选（同样，仅当您确定该值可分配给 T[K] 时才使用此选项）

 export const transform = <T extends Inputs, K extends keyof T>
   (inputs$: Observable<T>, inputNames: K[]) => {
   const cachedSinks$ = inputs$.pipe(share())
 
   return inputNames
     .reduce((result, inpName) => ({ ...result, [inpName]: cachedSinks$.pipe(switchMap(sinks => sinks[inpName])) }), {})
 }

Answer 2

我在类型定义中犯了 2 个错误，现在它可以正常工作了
1 个错误：{} as {[K in Keys]: Inp[Keys]}) 应该是 {} as {[K in Keys]: Inp[K]})
2个错误：<Inp extends Inputs, Keys extends keyof Inputs>应该是<Inp extends Inputs, Keys extends keyof Inp>

Answer 3

type Inputs = {[inputName: string]: Observable<unknown>}

export const transform = <Inp extends Inputs, Keys extends keyof Inputs>(
  inputs$: Observable<Inp>,
  inputNames: Keys[],
)

这里的关键部分是Keys extends keyof Inputs。 Inputs 是一种类型，您不知道任何特定的键。我相信你的意思是 Inp，它是提供给函数的类型。试试

type Inputs = {[inputName: string]: Observable<unknown>}

export const transform = <Inp extends Inputs, Keys extends keyof Inp>(
  inputs$: Observable<Inp>,
  inputNames: Keys[],
)