Como evito o erro "A assinatura do índice do tipo de objeto tem implicitamente um tipo 'qualquer'" ao compilar texto datilografado com o sinalizador noImplicitAny ativado?

Eu sempre compilei o Typecript com a flag --noImplicitAny. Isso faz sentido, pois quero que minha verificação de tipo seja o mais rígida possível.

Meu problema é que, com o seguinte código, recebo o erro Index signature of object type implicitly has an 'any' type:

interface ISomeObject {
    firstKey:   string;
    secondKey:  string;
    thirdKey:   string;
}

let someObject: ISomeObject = {
    firstKey:   'firstValue',
    secondKey:  'secondValue',
    thirdKey:   'thirdValue'
};

let key: string = 'secondKey';

let secondValue: string = someObject[key];

Importante notar é que a ideia é que a variável chave venha de algum outro lugar no aplicativo e possa ser qualquer uma das chaves no objeto.

Eu tentei converter explicitamente o tipo por:

let secondValue: string = <string>someObject[key];

Ou o meu cenário simplesmente não é possível --noImplicitAny?

Adicionar uma assinatura de índice permitirá que o TypeScript saiba qual deve ser o tipo.

No seu caso, isso seria [key: string]: string;

interface ISomeObject {
    firstKey:      string;
    secondKey:     string;
    thirdKey:      string;
    [key: string]: string;
}

No entanto, isso também impõe todos os tipos de propriedades para corresponder à assinatura do índice. Uma vez que todas as propriedades são um, stringele funciona.

Embora as assinaturas de índice sejam uma maneira poderosa de descrever a matriz e o padrão de 'dicionário', elas também impõem que todas as propriedades correspondam ao tipo de retorno.

Editar:

Se os tipos não corresponderem, um tipo de união pode ser usado [key: string]: string|IOtherObject;

Com os tipos de união, é melhor deixar o TypeScript inferir o tipo em vez de defini-lo.

// Type of `secondValue` is `string|IOtherObject`
let secondValue = someObject[key];
// Type of `foo` is `string`
let foo = secondValue + '';

Embora isso possa ficar um pouco confuso se você tiver muitos tipos diferentes nas assinaturas de índice. A alternativa é usar anya assinatura. [key: string]: any;Então você precisaria converter os tipos como você fez acima.

Outra maneira de evitar o erro é usar o elenco assim:

let secondValue: string = (<any>someObject)[key]; (Observe os parênteses)

O único problema é que isso não é mais seguro para o tipo, como você está usando any. Mas você sempre pode voltar ao tipo correto.

ps: Estou usando o texto datilografado 1.7, não tenho certeza sobre as versões anteriores.

O TypeScript 2.1 introduziu uma maneira elegante de lidar com esse problema.

const key: (keyof ISomeObject) = 'secondKey';
const secondValue: string = someObject[key];

Podemos acessar todos os nomes de propriedades de objetos durante a fase de compilação por keyofpalavra-chave (consulte changelog ).

Você só precisa substituir o stringtipo de variável por keyof ISomeObject. Agora, o compilador sabe que a keyvariável pode conter apenas nomes de propriedades ISomeObject.

Exemplo completo:

interface ISomeObject {
    firstKey:   string;
    secondKey:  string;
    thirdKey:   number;
}

const someObject: ISomeObject = {
    firstKey:   'firstValue',
    secondKey:  'secondValue',
    thirdKey:   3
};

const key: (keyof ISomeObject) = 'secondKey';
const secondValue: string = someObject[key];

// You can mix types in interface, keyof will know which types you refer to.
const keyNumber: (keyof ISomeObject) = 'thirdKey';
const numberValue: number = someObject[keyNumber];

Código ativo em typescriptlang.org ( noImplicitAnyopção definida )

Leitura adicional com mais keyofusos .

A seguinte configuração do tsconfig permitirá que você ignore esses erros - defina-o como true.

suppressImplicitAnyIndexErrors

Suprimir erros noImplicitAny para objetos de indexação sem assinaturas de índice.

A solução 'keyof' mencionada acima funciona. Mas se a variável for usada apenas uma vez, por exemplo, percorrendo um objeto, etc, você também poderá convertê-lo.

for (const key in someObject) {
    sampleObject[key] = someObject[key as keyof ISomeObject];
}

usar keyof typeof

const cat = {
    name: 'tuntun'
}

const key: string = 'name' 

cat[key as keyof typeof cat]

Semelhante à resposta de @Piotr Lewandowski, mas dentro de forEach:

const config: MyConfig = { ... };

Object.keys(config)
  .forEach((key: keyof MyConfig) => {
    if (config[key]) {
      // ...
    }
  });

Declare o objeto assim.

export interface Thread {
    id:number;
    messageIds: number[];
    participants: {
        [key:number]: number
    };
}

Nenhum indexador? Então faça o seu!

Eu defini isso globalmente como uma maneira fácil de definir uma assinatura de objeto. Tpode ser, anyse necessário:

type Indexer<T> = { [ key: string ]: T };

Acabei de adicionar indexercomo um membro da classe.

indexer = this as unknown as Indexer<Fruit>;

Então, acabo com isso:

constructor(private breakpointResponsiveService: FeatureBoxBreakpointResponsiveService) {

}

apple: Fruit<string>;
pear: Fruit<string>;

// just a reference to 'this' at runtime
indexer = this as unknown as Indexer<Fruit>;

something() {

    this.indexer['apple'] = ...    // typed as Fruit

O benefício de fazer isso é que você recebe o tipo adequado de volta - muitas soluções usadas <any>perdem a digitação para você. Lembre-se de que isso não realiza nenhuma verificação de tempo de execução. Você ainda precisará verificar se existe algo, se não tiver certeza.

Se você deseja ser excessivamente cauteloso, e está usando, strictvocê pode fazer isso para revelar todos os lugares em que pode ser necessário fazer uma verificação indefinida explícita:

type OptionalIndexed<T> = { [ key: string ]: T | undefined };

Normalmente, não acho isso necessário, pois, se eu tiver uma propriedade string de algum lugar, geralmente sei que é válida.

Achei esse método especialmente útil se tiver muito código que precisa acessar o indexador e a digitação pode ser alterada em apenas um local.

Nota: estou usando o strictmodo, e o unknowné definitivamente necessário.

O código compilado será apenas indexer = this, portanto, é muito semelhante a quando o texto datilografado é criado _this = thispara você.

Crie uma interface para definir a interface 'indexador'

Em seguida, crie seu objeto com esse índice.

Nota: isso ainda terá os mesmos problemas que outras respostas descreveram em relação à imposição do tipo de cada item - mas geralmente é exatamente isso que você deseja.

Você pode criar o parâmetro de tipo genérico do que precisar: ObjectIndexer< Dog | Cat>

// this should be global somewhere, or you may already be 
// using a library that provides such a type
export interface ObjectIndexer<T> {
  [id: string]: T;
}

interface ISomeObject extends ObjectIndexer<string>
{
    firstKey:   string;
    secondKey:  string;
    thirdKey:   string;
}

let someObject: ISomeObject = {
    firstKey:   'firstValue',
    secondKey:  'secondValue',
    thirdKey:   'thirdValue'
};

let key: string = 'secondKey';

let secondValue: string = someObject[key];

Parque de diversões

Você pode até usar isso em uma restrição genérica ao definir um tipo genérico:

export class SmartFormGroup<T extends IndexableObject<any>> extends FormGroup

Então Tdentro da classe pode ser indexado :-)

Declare o tipo em que sua chave é string e o valor pode ser qualquer um e, em seguida, declare o objeto com esse tipo e o fiapo não será exibido

type MyType = {[key: string]: any};

Portanto, seu código será

type ISomeType = {[key: string]: any};

    let someObject: ISomeType = {
        firstKey:   'firstValue',
        secondKey:  'secondValue',
        thirdKey:   'thirdValue'
    };

    let key: string = 'secondKey';

    let secondValue: string = someObject[key];

Atualmente, a melhor solução é declarar tipos. Gostar

enum SomeObjectKeys {
    firstKey = 'firstKey',
    secondKey = 'secondKey',
    thirdKey = 'thirdKey',
}

let someObject: Record<SomeObjectKeys, string> = {
    firstKey:   'firstValue',
    secondKey:  'secondValue',
    thirdKey:   'thirdValue',
};

let key: SomeObjectKeys = 'secondKey';

let secondValue: string = someObject[key];

A solução mais simples que eu encontrei usando o Typescript 3.1 em 3 etapas é:

1) Faça interface

interface IOriginal {
    original: { [key: string]: any }
}

2) Faça uma cópia digitada

let copy: IOriginal = (original as any)[key];

3) Use em qualquer lugar (JSX incluído)

<input customProp={copy} />