不要使用任何，使用泛型

// bad
const _getKeyValue = (key: string) => (obj: object) => obj[key];
    
// better
const _getKeyValue_ = (key: string) => (obj: Record<string, any>) => obj[key];
    
// best
const getKeyValue = <T extends object, U extends keyof T>(key: U) => (obj: T) =>
      obj[key];

坏-错误的原因是对象类型默认为空对象。因此，不可能使用字符串类型来索引{}。

更好的是，错误消失的原因是因为现在我们告诉编译器obj参数将是字符串/值(string/any)对的集合。然而，我们正在使用任何类型，所以我们可以做得更好。

Best - T扩展空对象。U扩展了T的键，所以U在T上永远存在，所以它可以作为一个查找值。

下面是一个完整的例子:

我已经切换了泛型的顺序(U extends keyof T现在出现在T extends object之前)，以突出泛型的顺序并不重要，你应该选择一个对你的函数最有意义的顺序。

const getKeyValue = <U extends keyof T, T extends object>(key: U) => (obj: T) =>
  obj[key];

interface User {
  name: string;
  age: number;
}

const user: User = {
  name: "John Smith",
  age: 20
};

const getUserName = getKeyValue<keyof User, User>("name")(user);

// => 'John Smith'

替代语法

const getKeyValue = <T, K extends keyof T>(obj: T, key: K): T[K] => obj[key];

下面是数组对象的泛型类型的函数示例

const trimArrayObject = <T>(items: T[]) => {

  items.forEach(function (o) {

    for (let [key, value] of Object.entries(o)) {

      const keyName = <keyof typeof o>key;

      if (Array.isArray(value)) {

        trimArrayObject(value);

      } else if (typeof o[keyName] === "string") {

        o[keyName] = value.trim();

      }

    }

  });

};

不要使用任何，使用泛型

// bad
const _getKeyValue = (key: string) => (obj: object) => obj[key];
    
// better
const _getKeyValue_ = (key: string) => (obj: Record<string, any>) => obj[key];
    
// best
const getKeyValue = <T extends object, U extends keyof T>(key: U) => (obj: T) =>
      obj[key];

坏-错误的原因是对象类型默认为空对象。因此，不可能使用字符串类型来索引{}。

更好的是，错误消失的原因是因为现在我们告诉编译器obj参数将是字符串/值(string/any)对的集合。然而，我们正在使用任何类型，所以我们可以做得更好。

Best - T扩展空对象。U扩展了T的键，所以U在T上永远存在，所以它可以作为一个查找值。

下面是一个完整的例子:

我已经切换了泛型的顺序(U extends keyof T现在出现在T extends object之前)，以突出泛型的顺序并不重要，你应该选择一个对你的函数最有意义的顺序。

const getKeyValue = <U extends keyof T, T extends object>(key: U) => (obj: T) =>
  obj[key];

interface User {
  name: string;
  age: number;
}

const user: User = {
  name: "John Smith",
  age: 20
};

const getUserName = getKeyValue<keyof User, User>("name")(user);

// => 'John Smith'

替代语法

const getKeyValue = <T, K extends keyof T>(obj: T, key: K): T[K] => obj[key];

你有两个选择使用简单和惯用的Typescript:

使用索引类型

DNATranscriber: { [char: string]: string } = {
  G: "C",
  C: "G",
  T: "A",
  A: "U",
};

这是错误消息谈论的索引签名。参考

输入每个属性:

DNATranscriber: { G: string; C: string; T: string; A: string } = {
  G: "C",
  C: "G",
  T: "A",
  A: "U",
};

在你的参数中，你必须定义keyOf对象。

interface User {
    name: string
    age: number 
}

const user: User = {
    name: "someone",
    age: 20
}

function getValue(key: keyof User) {
    return user[key]
}

我摆弄了一段时间。这是我的设想:

我有两个类型，metrics1和metrics2，每个类型都有不同的属性:

type metrics1 = {
    a: number;
    b: number;
    c: number;
}

type metrics2 = {
    d: number;
    e: number;
    f: number;
}

在我的代码中，我创建了一个对象，它是这两种类型的交集，因为这个对象将拥有它们的所有属性:

const myMetrics: metrics1 & metrics2 = {
    a: 10,
    b: 20,
    c: 30,
    d: 40,
    e: 50,
    f: 60
};

现在，我需要动态引用该对象的属性。这就是我们遇到索引签名错误的地方。部分问题可以根据编译时检查和运行时检查进行分解。如果我使用const引用对象，我将不会看到这个错误，因为TypeScript可以在编译时检查该属性是否存在:

const myKey = 'a';
console.log(myMetrics[myKey]); // No issues, TypeScript has validated it exists

然而，如果我使用的是动态变量(例如let)，那么TypeScript将无法在编译时检查该属性是否存在，并将在运行时需要额外的帮助。这就是下面的typeguard的用武之地:

function isValidMetric(prop: string, obj: metrics1 & metrics2): prop is keyof (metrics1 & metrics2) {
    return prop in obj;
}

它的意思是:“如果obj有prop属性，那么让TypeScript知道prop存在于metrics1和metrics2的交集中。”注意:确保将metrics1和metrics2括在如上所示的keyof后面的括号中，否则你将得到metrics1的键和metrics2的类型之间的交集(而不是它的键)。

现在，我可以使用typeguard并在运行时安全地访问我的对象:

let myKey:string = '';
myKey = 'a';
if (isValidMetric(myKey, myMetrics)) {
    console.log(myMetrics[myKey]);
}