此外，您可以这样做：

(this.DNATranscriber as any)[character];

编辑。

它HIGHLY建议您投的对象，具有正确的类型，而不是any。将对象转换为any只能帮助您在编译typescript时避免类型错误，但不能帮助您保持代码类型安全。

例如

interface DNA {
    G: "C",
    C: "G",
    T: "A",
    A: "U"
}

然后你像这样投射它：

(this.DNATranscriber as DNA)[character];

您可以通过验证您的输入来修复错误，这是您无论如何都应该做的事情。

以下类型检查正确，通过类型保护验证

const DNATranscriber = {
    G: 'C',
    C: 'G',
    T: 'A',
    A: 'U'
};

export default class Transcriptor {
    toRna(dna: string) {
        const codons = [...dna];
        if (!isValidSequence(codons)) {
            throw Error('invalid sequence');
        }
        const transcribedRNA = codons.map(codon => DNATranscriber[codon]);
        return transcribedRNA;
    }
}

function isValidSequence(values: string[]): values is Array<keyof typeof DNATranscriber> {
    return values.every(isValidCodon);
}
function isValidCodon(value: string): value is keyof typeof DNATranscriber {
    return value in DNATranscriber;
}

值得一提的是，您似乎误解了将 JavaScript 转换为 TypeScript 涉及使用类。

在以下更惯用的版本中，我们利用 TypeScript 来提高清晰度并在不更改实现的情况下获得更强大的碱基对映射类型。我们使用 a function，就像原来的一样，因为它是有道理的。这个很重要！将 JavaScript 转换为 TypeScript 与类无关，它与静态类型有关。

const DNATranscriber = {
    G: 'C',
    C: 'G',
    T: 'A',
    A: 'U'
};

export default function toRna(dna: string) {
    const codons = [...dna];
    if (!isValidSequence(codons)) {
        throw Error('invalid sequence');
    }
    const transcribedRNA = codons.map(codon => DNATranscriber[codon]);
    return transcribedRNA;
}

function isValidSequence(values: string[]): values is Array<keyof typeof DNATranscriber> {
    return values.every(isValidCodon);
}
function isValidCodon(value: string): value is keyof typeof DNATranscriber {
    return value in DNATranscriber;
}

更新：

从 TypeScript 3.7 开始，我们可以更富有表现力地编写它，使用断言签名形式化输入验证与其类型隐含之间的对应关系。

const DNATranscriber = {
    G: 'C',
    C: 'G',
    T: 'A',
    A: 'U'
} as const;

type DNACodon = keyof typeof DNATranscriber;
type RNACodon = typeof DNATranscriber[DNACodon];

export default function toRna(dna: string): RNACodon[] {
    const codons = [...dna];
    validateSequence(codons);
    const transcribedRNA = codons.map(codon => DNATranscriber[codon]);
    return transcribedRNA;
}

function validateSequence(values: string[]): asserts values is DNACodon[] {
    if (!values.every(isValidCodon)) {
        throw Error('invalid sequence');    
    }
}
function isValidCodon(value: string): value is DNACodon {
    return value in DNATranscriber;
}

您可以在TypeScript 3.7 发行说明 中阅读有关断言签名的更多信息。

这是我为解决相关问题所做的工作

interface Map {
  [key: string]: string | undefined
}

const HUMAN_MAP: Map = {
  draft: "Draft",
}

export const human = (str: string) => HUMAN_MAP[str] || str

不要使用任何，使用泛型

// 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];

不好 - 错误的原因是object默认情况下类型只是一个空对象。因此，不可能使用string类型来索引{}.

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

最佳 -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 选项：

1. 使用索引类型

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

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

2. 键入每个属性：

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