Comment puis-je empêcher le message d'erreur “l'Indice de signature de type d'objet a implicitement un "tout" type” lors de la compilation de texte dactylographié avec noImplicitAny indicateur activé?

L'ajout d'un index signature permettra à la Machine de savoir de quel type doit être.

Dans votre cas, ce serait [key: string]: string;

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

Cependant, cette applique également à tous les types de propriété correspond à l'index de la signature. Étant donné que toutes les propriétés sont un string il fonctionne.

Tandis que l'indice de signatures sont un moyen puissant pour décrire le tableau et "dictionnaire" modèle, elles aussi faire valoir que toutes les propriétés correspondent à leur type de retour.

Edit:

Si les types ne correspondent pas, un type d'union peuvent être utilisés [key: string]: string|IOtherObject;

Avec les types d'union, c'est mieux si vous laissez la Machine de déduire le type au lieu de le définir.

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

Bien que ce que peut obtenir un peu désordonné si vous avez beaucoup de différents types dans l'index de signatures. L'alternative qui consiste à utiliser any dans la signature. [key: string]: any; Alors vous devez jeter les types comme vous l'avez fait ci-dessus.

OriginalL'auteur thoughtrepo

Tapuscrit 2.1 introduit élégante manière de traiter ce problème.

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

Nous pouvons accéder à toutes les propriété de l'objet de nom lors de la phase de compilation par keyof mot-clé (voir changelog).

Vous avez seulement besoin de remplacer string type de variable avec keyof ISomeObject.
Maintenant compilateur sait key variable est autorisé à contenir que les noms de propriété de ISomeObject.

Exemple complet:

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

De code en direct sur typescriptlang.org (set noImplicitAny option)

Lecture avec plus de keyof usages.

OriginalL'auteur Piotr Lewandowski

Le "keyof' solution mentionnée ci-dessus fonctionne. Mais si la variable est utilisée qu'une seule fois.e.g en boucle par le biais d'un objet, etc, vous pouvez également catalogué.

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

OriginalL'auteur Karna

utilisation keyof typeof

const cat = {
    name: 'tuntun'
}

const key: string = 'name' 

cat[key as keyof typeof cat]

OriginalL'auteur alsotang

Pas indexer? Ensuite, faire votre propre!

J'ai globalement défini cela comme un moyen facile de définir un objet de la signature. T peut être any si nécessaire:

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

Je viens de l'ajouter indexer en tant que membre de la classe.

indexer = this as unknown as Indexer<Fruit>;

Donc je me retrouve avec ceci:

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

Avantage de ceci est que vous obtenez le bon type de retour - de nombreuses solutions qui utilisent <any> perdrez le taper pour vous. Rappelez-vous ce n'effectue pas de vérification runtime. Vous aurez toujours besoin de vérifier si quelque chose existe, si vous ne savez pas qu'il existe.

Si vous souhaitez être trop prudents, et que vous utilisez strict cela peut vous révéler tous les lieux que vous devrez peut-être n'explicite pas défini vérifier:

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

Je n'ai pas l'habitude de trouver ce nécessaire car si j'ai comme une propriété de chaîne à partir de quelque part j'ai l'habitude de savoir qu'il est valide.

J'ai trouvé cette méthode particulièrement utile si j'ai beaucoup de code pour accéder à l'indexeur et le typage peut être changé en un seul lieu.

Note: je suis en utilisant strict mode, et la unknown est certainement nécessaire.

Le code compilé sera juste indexer = this, c'est donc très similaire à lorsque la machine crée _this = this pour vous.

OriginalL'auteur Simon_Weaver

La solution la plus simple que j'ai pu trouver à l'aide de Tapuscrit 3.1 en 3 étapes:

1) Faire une interface

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

2) Faire une copie dactylographiée

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

3) Utiliser n'importe où (JSX inclus)

<input customProp={copy} />

OriginalL'auteur Artokun