打字稿多泛型对象声明

Question

我正在努力输入具有这种行为的函数： 给定一个对象conf，其键数未定义，每个键是一个具有value 和type 属性的对象，该函数应返回一个具有相同属性的对象，并且只有value 与value 相同。

所以要清楚，这是一个函数输入的例子：

{
  foo: {value: 1, type: 'number'},
  bar: {value: 'hello', type: 'string'}
}

以及相应的输出：

{
  foo: 1,
  bar: 'hello'
}

这是我目前所写的：

type TypeWithName<T extends string> = 
  T extends 'number' ? number :
  T extends 'boolean' ? boolean : 
  T extends 'undefined' ? undefined :
  T extends 'array' ? string[] :
  string

declare function f<T extends string>(conf: {
  [key: string]: { default: TypeWithName<T>; type: T }
}): { [P in keyof typeof conf]: TypeWithName<T> }

这显然是不正确的，因为：

1. T 一次只能采用一种类型（上面的示例将在属性bar 上抛出错误）
2. 返回类型具有未定义数量的键，而不是输入对象中存在的全部且唯一的键。

但我有点迷路了，不知道该去哪里看，也不知道这是否可能。

Answer 1

我的方法是使用从type 属性字符串到value 类型而不是条件类型的映射接口；您可能可以在此处使用条件类型，但在类型系统中使用接口更容易：

interface TypeMap {
  number: number;
  boolean: boolean;
  undefined: undefined;
  string: string;
  object: object | null;
}

我假设您希望 "string" 映射到 string，我添加了 "object"。如果你想让 "array" 映射到 string[] 你可以这样做，我猜。

然后我想使用TypeMap 来创建一个名为Config 的联合类型，表示value 和type 之间的约束，如下所示：

type Config = {
  [K in keyof TypeMap]: { value: TypeMap[K]; type: K }
}[keyof TypeMap];

如果你检查它，它相当于：

type Config = {
    value: number;
    type: "number";
} | {
    value: boolean;
    type: "boolean";
} | {
    value: undefined;
    type: "undefined";
} | {
    value: string;
    type: "string";
} | {
    value: object | null;
    type: "object";
}

现在f 函数在T 中是通用的，这是一种对象类型，其键是任意的，其属性是Config，由约束Record<keyof T, Config> 表示。输入类型为T，输出类型为mapsT中的每个属性为其value属性：

declare function f<T extends Record<keyof T, Config>>(
  t: T
): { [K in keyof T]: T[K]["value"] };

让我们看看它是否有效：

const output = f({
  foo: { value: 1, type: "number" },
  bar: { value: "hello", type: "string" }
}); 
// const output: { foo: number;  bar: string; }

我认为这是您期望的输出类型，对吧？如果您需要更窄的类型（例如，foo 是 type 1 而不是 number），您可以在输入中使用 const assertion：

const outputNarrower = f({
  foo: { value: 1, type: "number" },
  bar: { value: "hello", type: "string" }
} as const); 
// const outputNarrower: { foo: 1; bar: "hello"; }

最后，您可以看到f() 的输入受到限制，因此您不能给出不匹配的value/type 对：

f({
  chicken: { value: 123, type: "string" }, // error!
  cow: { value: "abc", type: "string" }
});

好的，希望对您有所帮助；祝你好运！

Link to code

Answer 2

您可以尝试以下方法：

const conf = {
  foo: { value: 1, type: "number" },
  bar: { value: "hello", type: "string" }
};

type Input = {
  [key: string]: { value: any; type: string };
};

type Output<U extends Input> = { [Key in keyof U]: U[Key]["value"] };

function f<T extends Input>(input: T): Output<T> {
  // Details...
}

const returned = f(conf);

returned.foo // number
returned.bar // string

TypeScript playground

Answer 3

我认为这应该足够了..... key is using 'any'

function change(x:any) {
  let y:any={};
  for(let c in x){
    console.log(c)
    y[c] = x[c].value;
  }
  return y;
}

let x={
  'foo': {value: 1, type: 'number'},
  'bar': {value: 'hello', type: 'string'}
};

console.log(change(x));