Jenis Bersyarat

Jenis bersyarat dalam TypeScript membolehkan anda mencipta jenis yang menyesuaikan diri secara dinamik berdasarkan suatu syarat, sekali gus menjadikan kod anda lebih fleksibel dan boleh digunakan semula.

Jenis ini menggunakan sintaks yang serupa dengan operator bersyarat (ternary) JavaScript.

Jenis bersyarat membolehkan anda mentakrifkan jenis yang bergantung pada jenis lain. Sintaks asasnya ialah:

T extends U ? X : Y

Ini bermaksud: Jika T melanjutkan U, jenisnya ialah X; jika tidak, jenisnya ialah Y.

Berikut ialah contoh mudah:

type IsString<T> = T extends string ? 'Yes' : 'No';

// Test cases
type A = IsString<string>; // 'Yes'
type B = IsString<number>; // 'No'

Jenis bersyarat boleh memudahkan lebihan beban fungsi dengan menentukan jenis nilai pulangan secara dinamik:

type ReturnType<T> = T extends (...args: any[]) => infer R ? R : never;

function getData(): string {
  return 'Hello';
}

type DataType = ReturnType<typeof getData>; // string

Apabila jenis bersyarat digunakan pada jenis gabungan, jenis tersebut diagihkan kepada setiap ahli gabungan:

type ToArray<T> = T extends any ? T[] : never;

type A = ToArray<string | number>;
// A = string[] | number[]

Anda boleh menggabungkan jenis bersyarat dengan jenis terpetakan untuk melakukan transformasi jenis yang berkuasa:

type User = {
  id: number;
  name: string;
  isAdmin?: boolean;
};

type MakeRequired<T> = {
  [K in keyof T]-?: T[K] extends undefined ? never : T[K];
};

type RequiredUser = MakeRequired<User>;
// { id: number; name: string; isAdmin: never; }

Jenis bersyarat biasanya digunakan untuk:

• Membuat inferens terhadap jenis nilai pulangan atau parameter.
• Mengubah jenis gabungan dan persilangan.
• Mencipta jenis utiliti seperti Exclude, Extract dan NonNullable.

Cipta jenis bersyarat yang menyemak sama ada sesuatu jenis ialah tatasusunan dan, jika ya, mengembalikan jenis elemennya; jika tidak, jenis itu sendiri dikembalikan.

Anda telah mempelajari cara menggunakan jenis bersyarat untuk mencipta takrifan jenis yang dinamik dan boleh digunakan semula dalam TypeScript. Latih konsep-konsep ini untuk menulis kod TypeScript yang lebih berkuasa dan fleksibel!