Question

我正在尝试实现一些可能过高但很不错的功能。我想声明两个参数，其中一个代表一个{strong>模型，keyof，另一个代表一个模型中的类型，请参见下面的示例：< / p>

interface Example<T> {
    key: keyof T;
    value: typeof T[key];
}
interface Test {
    first: string;
    second: number;
}

正确的值是：

let test: Example<Test> = {
    key: “first”,
    value: “Hello world!”
};

一个不正确的例子是：

let test: Example<Test> = {
    key: “first”,
    value: 123
};

使用 Typescript 是否可以实现这样的目标？

Answer 1

有多种方法可以执行此操作，具体取决于您要执行的操作。

如果您有一个函数，并且需要在参数上强制执行此操作，则可以使用通用类型参数来做到这一点：

interface Example<T, K extends keyof T> {
    key: K;
    value: T[K];
}
function withProp<T>(){
  return function<K extends keyof T>(value: Example<T, K>) {

  }
}

let test= withProp<Test>()({
    key: "first",
    value: "Hello world!"
});

// Error
let test2 = withProp<Test>()({
    key: "first",
    value: 123
});

Play

如果要对随机变量强制执行此操作，则可以使用映射类型来生成所有可能的键类型组合作为并集：

type Example<T> = {
  [K in keyof T]: {
      key: K;
      value: T[K];
  }
}[keyof T]

let test: Example<Test> = {
    key: "first",
    value: "Hello world!"
};

// Error
let test2: Example<Test> = {
    key: "first",
    value: 123
}

Play

Answer 2

这可能会帮助您（live demo）：

interface Example<T, K extends keyof T> {
  value: T[K];
}
interface Test {
  first: string;
  second: number;
}

var first: Example<Test, "first">;
first.value; // string

var second: Example<Test, "second">;
second.value; // number

Answer 3

这可能足够接近了

interface Example<T, K extends keyof T> {
    key: K;
    value: T[K];
}
interface Test {
    first: string;
    second: number;
}
const ok1 : Example<Test, "first"> = {
    key: "first",
    value: "s",
}
const ok2 : Example<Test, "second"> = {
    key: "second",
    value: 12,
}
const error1 : Example<Test, "first"> = {
    key: "first",
    value: 12,
}

有没有一种方法可以声明一个取决于其同级类型的类型

3 个答案: