Pilihan lwn. Tidak Ditakrifkan: Cara Menyemak Sifat Pilihan

Dalam TypeScript, sifat dianggap sebagai pilihan jika ia boleh diabaikan daripada objek, bermakna ia boleh sama ada tidak ditentukan atau tidak disediakan sama sekali. Sifat pilihan dilambangkan menggunakan ? akhiran pada kunci harta. Menentukan sama ada harta adalah pilihan atau ditakrifkan secara eksplisit dengan tidak ditentukan sebagai jenisnya boleh menjadi agak rumit.

Mari kita pertimbangkan contoh berikut dengan lima kemungkinan kombinasi:

type Example = {
    required: number;
    optional?: number;
    requiredAsUndefined: undefined;
    requiredWithUndefined: number | undefined;
    optionalWithUndefined?: number | undefined;
}

Empat sifat terakhir dibenarkan untuk tidak ditentukan, tetapi hanya yang kedua dan kelima sebenarnya adalah pilihan. Menariknya, sifat pilihan, requiredWithUndefined dan optionalWithUndefined semuanya diselesaikan kepada nombor jenis kesatuan yang sama | tidak ditentukan.

Jadi, apa yang kita mahukan ialah jenis yang mengembalikan benar untuk pilihan dan pilihanWithUndefined, dan palsu untuk yang lain. Begini rupa jenis utiliti sedemikian:

type IsOptional<T, K extends keyof T> = undefined extends T[K]
    ? ({} extends Pick<T, K> ? true : false)
    : false;

type Required = IsOptional<Example, 'required'>;  // false
type Optional = IsOptional<Example, 'optional'>;  // true
type RequiredAsUndefined = IsOptional<Example, 'requiredAsUndefined'>;  // false
type RequiredWithUndefined = IsOptional<Example, 'requiredWithUndefined'>;  // false
type OptionalWithUndefined = IsOptional<Example, 'optionalWithUndefined'>;  // true

Terdapat dua kekangan dalam jenis utiliti ini. Kekangan pertama, undefined melanjutkan T[K], menyemak jika undefined boleh menjadi sebahagian daripada jenis yang diakses oleh T[K]. Ia pada asasnya bertanya sama ada jenis T[K] boleh termasuk tidak ditentukan. Kekangan kedua, {} melanjutkan Pick ? true : false, memastikan bahawa jenis {} (objek kosong) boleh diserahkan kepada jenis yang mana sifat K dipilih, membayangkan sifat itu adalah pilihan.

Daripada jenis utiliti ini, kami boleh membina jenis dipetakan baharu yang hanya memilih sifat pilihan. Sifat bukan pilihan akan ditetapkan kepada tidak sekali-kali:

type OptionalProperties<T> = {
    [K in keyof T]: IsOptional<T, K> extends true 
        ? T[K] 
        : never
}

type OnlyOptionals = OptionalProperties<Example>;
// type OnlyOptionals = {
//     required: never;
//     optional?: number;
//     requiredAsUndefined: never;
//     requiredWithUndefined: never;
//     optionalWithUndefined?: number | undefined;
// }

Mempunyai sifat dengan jenis biasanya tidak mencukupi untuk keselamatan jenis, tetapi sekiranya kita benar-benar mahu meninggalkan sifat ini untuk tujuan gaya, kita boleh mengalihkan IsOptional memanjangkan kekangan sebenar ke dalam kurungan segi empat sama. Ini adalah helah kecil yang bagus kerana ia akan menetapkan kunci sifat bukan pilihan kepada tidak pernah, yang kemudiannya akan ditinggalkan oleh TypeScript secara automatik.

type OnlyOptionals<T> = {
    [K in keyof T as IsOptional<T, K> extends true ? K : never]: T[K]
} 
type OnlyOptionals = OnlyOptionals<Example>;
// type OnlyOptionals = {
//    optional?: number;
//    optionalWithUndefined?: number | undefined;
// }

Inilah Taman Permainan untuk mencubanya terus dalam penyemak imbas: TypeScript Playground

Atas ialah kandungan terperinci Pilihan lwn. Tidak Ditakrifkan: Cara Menyemak Sifat Pilihan. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!