Bagaimana cara mencegah kesalahan "Tanda tangan indeks dari jenis objek secara implisit memiliki tipe 'apa saja'" ketika mengkompilasi naskah dengan noImplicitAny flag diaktifkan?

Saya selalu mengkompilasi naskah dengan flag --noImplicitAny. Ini masuk akal karena saya ingin memeriksa tipe saya sekencang mungkin.

Masalah saya adalah bahwa dengan kode berikut ini saya mendapatkan kesalahan 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];

Penting untuk dicatat adalah idenya adalah bahwa variabel kunci berasal dari tempat lain dalam aplikasi dan dapat berupa salah satu kunci dalam objek.

Saya sudah mencoba secara eksplisit casting type dengan:

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

Atau skenario saya tidak mungkin dengan --noImplicitAny?

Menambahkan tanda tangan indeks akan membuat TypeScript tahu apa tipe yang seharusnya.

Dalam kasus Anda itu akan menjadi [key: string]: string;

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

Namun, ini juga memberlakukan semua jenis properti agar sesuai dengan tanda tangan indeks. Karena semua properti adalah stringberfungsi.

Sementara tanda tangan indeks adalah cara yang ampuh untuk menggambarkan larik dan pola 'kamus', mereka juga menegaskan bahwa semua properti cocok dengan tipe pengembalian mereka.

Edit:

Jika tipenya tidak cocok, tipe gabungan bisa digunakan [key: string]: string|IOtherObject;

Dengan tipe gabungan, lebih baik jika Anda membiarkan TypeScript menyimpulkan tipe daripada mendefinisikannya.

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

Meskipun itu bisa menjadi sedikit berantakan jika Anda memiliki banyak jenis tanda tangan indeks. Alternatif untuk itu adalah menggunakan anytanda tangan. [key: string]: any;Maka Anda perlu melemparkan jenis seperti yang Anda lakukan di atas.

Cara lain untuk menghindari kesalahan adalah dengan menggunakan para pemain seperti ini:

let secondValue: string = (<any>someObject)[key]; (Perhatikan tanda kurung)

Satu-satunya masalah adalah bahwa ini bukan tipe-aman lagi, karena Anda casting ke any. Tetapi Anda selalu dapat kembali ke jenis yang benar.

ps: Saya menggunakan naskah 1.7, tidak yakin tentang versi sebelumnya.

TypeScript 2.1 memperkenalkan cara yang elegan untuk menangani masalah ini.

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

Kami dapat mengakses semua nama properti objek selama fase kompilasi dengan keyofkata kunci (lihat changelog ).

Anda hanya perlu mengganti stringtipe variabel dengankeyof ISomeObject . Sekarang kompiler tahu keyvariabel diizinkan hanya berisi nama properti dari ISomeObject.

Contoh lengkap:

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

Kode langsung di typescriptlang.org ( noImplicitAnyopsi setel )

Bacaan lebih lanjut dengan lebih banyak keyofpenggunaan .

Berikut pengaturan tsconfig akan memungkinkan Anda untuk mengabaikan kesalahan ini - setel ke true.

suppressImplicitAnyIndexErrors

Menekan kesalahan noImplicitAny untuk objek pengindeksan yang tidak memiliki tanda tangan indeks.

Solusi 'keyof' yang disebutkan di atas berfungsi. Tetapi jika variabel digunakan hanya sekali misalnya perulangan melalui objek dll, Anda juga dapat mengetikkannya.

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

menggunakan keyof typeof

const cat = {
    name: 'tuntun'
}

const key: string = 'name' 

cat[key as keyof typeof cat]

Mirip dengan jawaban @Piotr Lewandowski, tetapi dalam forEach:

const config: MyConfig = { ... };

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

Nyatakan objek seperti ini.

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

Tidak ada pengindeks? Lalu buat sendiri!

Saya secara global mendefinisikan ini sebagai cara mudah untuk mendefinisikan tanda tangan objek. Tbisa anyjika diperlukan:

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

Saya hanya menambahkan indexersebagai anggota kelas.

indexer = this as unknown as Indexer<Fruit>;

Jadi saya berakhir dengan ini:

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

Manfaat melakukan ini adalah Anda mendapatkan kembali tipe yang tepat - banyak solusi yang digunakan <any> akan kehilangan mengetik untuk Anda. Ingat ini tidak melakukan verifikasi runtime. Anda masih perlu memeriksa apakah ada sesuatu jika Anda tidak tahu pasti itu ada.

Jika Anda ingin sangat berhati-hati, dan Anda menggunakan strictAnda dapat melakukan ini untuk mengungkapkan semua tempat Anda mungkin perlu melakukan pemeriksaan yang tidak ditentukan secara eksplisit:

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

Saya biasanya tidak menemukan ini diperlukan karena jika saya memiliki properti string dari suatu tempat saya biasanya tahu bahwa itu valid.

Saya menemukan metode ini sangat berguna jika saya memiliki banyak kode yang perlu mengakses pengindeks, dan pengetikan dapat diubah hanya dalam satu tempat.

Catatan: Saya menggunakan strictmode, dan unknownitu pasti diperlukan.

Kode yang dikompilasi hanya akan indexer = this, jadi sangat mirip dengan saat naskah dibuat _this = thisuntuk Anda.

Buat antarmuka untuk mendefinisikan antarmuka 'pengindeks'

Kemudian buat objek Anda dengan indeks itu.

Catatan: ini akan tetap memiliki masalah yang sama dengan jawaban lain yang dijelaskan sehubungan dengan menegakkan jenis setiap item - tetapi itu sering kali persis seperti yang Anda inginkan.

Anda dapat membuat parameter tipe generik apa pun yang Anda butuhkan: 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];

Taman Bermain Anak

Anda bahkan dapat menggunakan ini dalam batasan generik ketika mendefinisikan tipe generik:

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

Kemudian Tdi dalam kelas dapat diindeks :-)

Nyatakan tipe yang kuncinya adalah string dan nilainya dapat berupa apa saja kemudian mendeklarasikan objek dengan tipe ini dan serat tidak akan muncul

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

Jadi kode Anda akan menjadi

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

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

    let key: string = 'secondKey';

    let secondValue: string = someObject[key];

Saat ini solusi yang lebih baik adalah dengan mendeklarasikan tipe. Suka

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

Solusi paling sederhana yang bisa saya temukan menggunakan TypeScript 3.1 dalam 3 langkah adalah:

1) Buat antarmuka

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

2) Buat salinan yang diketik

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

3) Gunakan di mana saja (termasuk BEJ)

<input customProp={copy} />