NoImplicitAny bayrağı etkinken daktiloyu derlerken “Nesne türünün dizin imzasının dolaylı olarak 'herhangi bir' türü var” hatasını nasıl önleyebilirim?

Her zaman - --IImplicitAny bayrağı ile Typescript derlemek. Tip kontrolümün olabildiğince sıkı olmasını istediğim için bu mantıklı.

Benim sorunum şu kod ile hatayı alıyorum 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];

Dikkat edilmesi gereken önemli nokta, anahtar değişkenin uygulamada başka bir yerden gelmesi ve nesnedeki anahtarlardan herhangi biri olabilmesidir.

Açıkça tarafından tür döküm denedim:

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

Yoksa benim senaryom mümkün değil --noImplicitAnymi?

Bir dizin imzası eklemek TypeScript'e türün ne olması gerektiğini bildirir.

Senin durumunda [key: string]: string;

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

Ancak bu, tüm özellik türlerinin dizin imzasıyla eşleşmesini sağlar. Tüm özellikler bir stringolduğu için çalışır.

Dizin imzaları diziyi ve 'sözlük' kalıbını tanımlamanın güçlü bir yolu olsa da, tüm özelliklerin dönüş türleriyle eşleşmesini zorunlu kılar.

Düzenle:

Türler eşleşmezse, bir birleşim türü kullanılabilir [key: string]: string|IOtherObject;

Birleştirme türlerinde, TypeScript'in türü tanımlamak yerine çıkarım yapmasına izin vermek daha iyidir.

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

Eğer dizin imzaları çok farklı türleri varsa bu biraz dağınık olabilir. Bunun alternatifi imzada kullanmaktır any. [key: string]: any;O zaman yukarıda yaptığınız gibi türleri dökmeniz gerekir.

Hatayı önlemenin bir başka yolu da oyuncu kadrosunu şu şekilde kullanmaktır:

let secondValue: string = (<any>someObject)[key]; (Parantezlere dikkat edin)

Tek sorun, artık yayınladığınız gibi bu tür bir güvenli değil any. Ancak her zaman doğru türe geri dönebilirsiniz.

ps: typescript 1.7 kullanıyorum, önceki sürümlerden emin değilim.

TypeScript 2.1 , bu sorunu çözmek için zarif bir yol sundu.

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

Derleme aşamasında tüm nesne özellik adlarına keyofanahtar sözcükle erişebiliriz (bkz. Changelog ).

stringDeğişken türünü yalnızca ile değiştirmeniz gerekir keyof ISomeObject. Derleyici key, değişkenin yalnızca özellik adlarını içermesine izin verildiğini biliyor ISomeObject.

Tam örnek:

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

Typescriptlang.org'da canlı kod (ayar noImplicitAnyseçeneği)

Daha fazla keyofkullanımla daha fazla okuma .

Aşağıdaki tsconfig ayarı , bu hataları yok saymanıza olanak tanır - true olarak ayarlayın.

suppressImplicitAnyIndexErrors

Dizin imzaları olmayan nesneleri indekslemek için noImplicitAny hatalarını bastırın.

Yukarıda belirtilen 'anahtar' çözüm işe yarar. Ancak, değişken yalnızca bir kez kullanılırsa, örneğin bir nesne vb. Üzerinden döngü yaparak, bunu da tahmin edebilirsiniz.

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

kullanım keyof typeof

const cat = {
    name: 'tuntun'
}

const key: string = 'name' 

cat[key as keyof typeof cat]

@Piotr Lewandowski'nin cevabına benzer, ancak aşağıdakiler dahilinde forEach:

const config: MyConfig = { ... };

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

Nesneyi böyle ilan edin.

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

Dizin oluşturucu yok mu? Sonra kendiniz yapın!

Küresel olarak bunu bir nesne imzasını tanımlamanın kolay bir yolu olarak tanımladım. gerekirse Tolabilir any:

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

Sadece indexersınıf üyesi olarak ekliyorum .

indexer = this as unknown as Indexer<Fruit>;

Bu yüzden bununla bitirdim:

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

Bunu yapmanın yararı, uygun türü geri almanızdır - kullanılan birçok çözüm <any>yazmayı sizin için kaybeder. Bunun herhangi bir çalışma zamanı doğrulaması yapmadığını unutmayın. Hala olduğundan emin değilseniz, bir şey olup olmadığını kontrol etmeniz gerekir.

Aşırı temkinli olmak istiyorsanız ve kullanıyorsanız strict, açık bir tanımsız denetim yapmanız gerekebilecek tüm yerleri ortaya çıkarmak için bunu yapabilirsiniz:

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

Ben genellikle bir yerde dize özelliği olarak varsa ben genellikle geçerli olduğunu biliyorum çünkü bu gerekli bulamıyorum.

Bu yöntemi özellikle dizinleyici erişmek için gereken bir sürü kod varsa ve yazarak sadece bir yerde değiştirilebilir yararlı buldum.

Not: strictModu kullanıyorum ve unknownkesinlikle gerekli.

Derlenmiş kod sadece olacak indexer = this, bu yüzden patlama yazı tipinin _this = thissizin için oluşturduğu zamana çok benzer .

'Dizin oluşturucu' arayüzünü tanımlamak için bir arayüz oluşturun

Ardından nesnenizi bu dizinle oluşturun.

Not: Bu, her bir öğenin türünü uygulamakla ilgili diğer cevapların açıkladığı sorunlarla aynı olacaktır - ancak genellikle tam olarak istediğiniz şeydir.

Genel tip parametresini istediğiniz her şeyi yapabilirsiniz: 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];

Yazı Bahçesi

Genel bir tür tanımlarken bunu genel bir kısıtlamayla bile kullanabilirsiniz :

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

Sonra Tsınıf içinde dizine alınabilir :-)

Anahtarının dize ve değerin herhangi biri olabileceği tür bildir, daha sonra nesneyi bu türle bildir ve tüy bırakma gösterilmez

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

Yani kodunuz

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

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

    let key: string = 'secondKey';

    let secondValue: string = someObject[key];

Günümüzde daha iyi bir çözüm türleri beyan etmektir. Sevmek

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

3 adımda Typescript 3.1 kullanarak bulabildiğim en basit çözüm :

1) arayüz yapmak

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

2) Yazılan bir kopyasını oluşturun

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

3) Her yerde kullanın (JSX dahil)

<input customProp={copy} />