一个快速的解决方法就像下面这样，或者至少我是这样做的:

(obj as { [k in string]: any })[key]

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

通过类型保护验证，下面的类型检查是正确的

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来提高清晰度，并在不改变实现的情况下获得更强的碱基对映射类型。我们使用一个函数，就像原来一样，因为它有意义。这很重要!将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发布说明中阅读更多关于断言签名的信息。

此外，你还可以这样做:

(this.DNATranscriber as any)[character];

编辑。

强烈建议使用正确的类型而不是任意类型强制转换对象。将对象强制转换为any只能帮助你在编译typescript时避免类型错误，但它不能帮助你保持代码的类型安全。

E.g.

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

然后像这样转换:

(this.DNATranscriber as DNA)[character];

我在对象中使用{[x:string]:string}。

const myObj:{[x:string]:string} = {
  'a': 'b'
};

function myFn() {
  const getVal = myObj['a'];
};

我解决了一个类似的问题在我的getClass函数是这样的:

import { ApiGateway } from './api-gateway.class';
import { AppSync } from './app-sync.class';
import { Cognito } from './cognito.class';

export type stackInstances = typeof ApiGateway | typeof  AppSync | typeof Cognito

export const classes = {
  ApiGateway,
  AppSync,
  Cognito
} as {
  [key: string]: stackInstances
};

export function getClass(name: string) {
  return classes[name];
}

用我的联合类型输入我的类const使typescript高兴，这对我来说是有意义的。

对于任何遇到类似情况的人来说

No index signature with a parameter of type 'string' was found on type X

试着把它用在简单的对象上(用作字典)，比如:

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

并尝试从计算的键动态访问值，如:

const key = getFirstType(dnaChain);
const result = DNATranscriber[key];

如果你遇到如上所示的错误，你可以使用keyof操作符并尝试类似的操作

const key = getFirstType(dnaChain) as keyof typeof DNATranscriber;

当然，你需要一个守卫的结果，但如果它似乎比一些自定义类型魔术更直观，这是可以的。