Question

我有一个函数，它使用非常具体的规则将对象转换为另一个对象。我想以下函数可以作为一个例子：

interface SomethingWithAValue<T> {
  value: T;
}

function transform(obj) {
  let value = {};
  for(let key in obj) {
    value[key] = obj[key].value;
  }
  return { value };
}

这基本上转换了类型（伪代码）

的对象

{
  [key 1]: SomethingWithAValue<type 1>,
  [key 2]: SomethingWithAValue<type 2>,
  ...
  [key n]: SomethingWithAValue<type n>
}

进入一个新的类型对象（再次伪代码）

SomethingWithAValue<{
  [key 1]: type 1,
  [key 2]: type 2,
  ...
  [key n]: type n
}>

我仍然需要向transform添加适当的类型声明，那么这里最好的方法是什么？

Answer 1

啊，你需要mapped types和inference from mapped types。

以下是使用映射类型表示从常规对象到SomethingWithAValue<>中包含所有属性值的映射的方式：

type SomethingMapper<T> = {
  [K in keyof T]: SomethingWithAValue<T[K]>
}

type Example = {
  a: string,
  b: number
}
type SomethingMappedExample = SomethingMapper<Example>;
// { 
//   a: SomethingWithAValue<string>; 
//   b: SomethingWithAValue<number>; 
// }

以下是如何使用映射类型的推断来键入解包的函数：

function transform<T>(obj: SomethingMapper<T>): T {
  // implementation
}
declare let mappedExample: SomethingMappedExample;
const unwrapped: Example = transform(mappedExample); // okay

希望有所帮助。祝你好运！

保持对象的类型结构

1 个答案: