Menguasai Jenis Rekursif dalam TypeScript: Mengendalikan Had Kedalaman Dengan Anggun

pengenalan

Apabila bekerja dengan struktur data bersarang dalam dalam TypeScript, mencipta jenis utiliti untuk mengubah struktur ini adalah tugas biasa. Walau bagaimanapun, jenis rekursif, walaupun berkuasa, datang dengan set cabaran mereka sendiri.

Satu cabaran sedemikian ialah mengawal kedalaman rekursi dengan berkesan untuk mengelakkan pengiraan jenis daripada melebihi keupayaan TypeScript. Artikel ini akan meneroka pendekatan biasa untuk menambah dan mengurangkan nombor peringkat jenis, mengenal pasti batasannya dan membentangkan penyelesaian yang teguh untuk mengurus kedalaman rekursi menggunakan jenis Penambahan dan Pengurangan yang betul.

? Masalah dengan Operasi Nombor Tahap Jenis Asas

Untuk lebih memahami batasan, mari lihat pendekatan naif yang sering digunakan apabila menambah atau mengurangkan nombor pada tahap jenis:

type Prev = [never, 0, 1, 2, 3, 4];
type Next = [1, 2, 3, 4, 5, 6];

type MinusOne = Prev[5]; // ? 4
type PlusOne = Next[5];  // ? 6

? Senario Masalah: Sifat Pilihan Sangat Bersarang

Andaikan anda mempunyai jenis objek yang sangat bersarang dan ingin membuat semua
sifat pilihan sehingga tahap tertentu:

type DeepObject = {
  a: number;
  b: {
    c: string;
    d: {
      e: boolean;
      f: {
        g: string;
        h: {
          i: number;
          j: {
            k: string;
          };
        };
      };
    };
  };
};

Dengan pendekatan yang naif dan berkod keras, mengurus kedalaman sifat menjadi pilihan akan kelihatan seperti ini:

type Prev = [never, 0, 1, 2, 3, 4];

type DeepOptional<
  T,
  Limit extends number = 1
> = Limit extends never
  ? never
  : {
      [K in keyof T]?: T[K] extends object
        ? DeepOptional<T[K], Prev[Limit]>
        : T[K];
    };

Penjelasan:

• DeepOptional menjadikan sifat pilihan sehingga Had.
• Had akan digunakan untuk mendapatkan nilai yang dikurangkan daripada tupel statik.

Contoh Penggunaan:

type NewDeepObject = DeepOptional<DeepObject, 3>;

// Result:
// {
//   a?: number;
//   b?: {
//     c?: string;
//     d?: {
//       e?: boolean;
//       f?: {
//         g: string;
//         h: {
//           i: number;
//           j: {
//             k: string;
//           };
//         };
//       };
//     };
//   };
// };

type NewDeepObject = DeepOptional<DeepObject, 1>;

// Result:
// {
//   a?: number;
//   b?: {
//     c: string;
//     d: {
//       e: boolean;
//       f: {
//         g: string;
//         h: {
//           i: number;
//           j: {
//             k: string;
//           };
//         };
//       };
//     };
//   };
// };

✋ Isu dengan Pendekatan Ini

• Julat Terhad: Pendekatan ini hanya fleksibel seperti tatasusunan yang dipratentukan Sebelum dan Seterusnya. Jika anda perlu menambah atau mengurangkan nombor melebihi panjang tatasusunan ini, anda perlu memanjangkannya secara manual, yang menyusahkan dan mudah ralat.
• Skalabiliti: Apabila keperluan anda berkembang, mengurus tatasusunan ini menjadi semakin kompleks, menjadikan pendekatan ini tidak praktikal untuk operasi jenis berskala lebih besar.

? Penyelesaian yang Lebih Teguh: Jenis Kenaikan dan Penurunan Berasaskan Tuple

Untuk mengatasi had tatasusunan yang dipratentukan, kami boleh menggunakan manipulasi tuple untuk mencipta operasi Penambahan dan Pengurangan jenis selamat yang berskala secara dinamik.

?️ Blok Bangunan Utama

• Utiliti Panjang: Jenis untuk mendapatkan panjang tuple:

type Prev = [never, 0, 1, 2, 3, 4];
type Next = [1, 2, 3, 4, 5, 6];

type MinusOne = Prev[5]; // ? 4
type PlusOne = Next[5];  // ? 6

• TupleOf: Jenis yang menghasilkan tuple N elemen:

type DeepObject = {
  a: number;
  b: {
    c: string;
    d: {
      e: boolean;
      f: {
        g: string;
        h: {
          i: number;
          j: {
            k: string;
          };
        };
      };
    };
  };
};

• Utiliti Pop: Jenis yang mengalih keluar elemen terakhir tuple:

type Prev = [never, 0, 1, 2, 3, 4];

type DeepOptional<
  T,
  Limit extends number = 1
> = Limit extends never
  ? never
  : {
      [K in keyof T]?: T[K] extends object
        ? DeepOptional<T[K], Prev[Limit]>
        : T[K];
    };

• Kenaikan dan Penurunan:

type NewDeepObject = DeepOptional<DeepObject, 3>;

// Result:
// {
//   a?: number;
//   b?: {
//     c?: string;
//     d?: {
//       e?: boolean;
//       f?: {
//         g: string;
//         h: {
//           i: number;
//           j: {
//             k: string;
//           };
//         };
//       };
//     };
//   };
// };

type NewDeepObject = DeepOptional<DeepObject, 1>;

// Result:
// {
//   a?: number;
//   b?: {
//     c: string;
//     d: {
//       e: boolean;
//       f: {
//         g: string;
//         h: {
//           i: number;
//           j: {
//             k: string;
//           };
//         };
//       };
//     };
//   };
// };

? Menggunakan Kenaikan dan Penurunan: Contoh Praktikal

Mari kita terokai cara jenis utiliti ini boleh digunakan pada masalah dunia sebenar yang lebih kompleks: menjadikan sifat objek sebagai pilihan sehingga kedalaman tertentu.

Senario Masalah: Sifat Pilihan Sangat Bersarang

Andaikan anda mempunyai jenis objek yang sangat bersarang dan ingin membuat semua
sifat pilihan sehingga tahap tertentu:

type Length<T extends any[]> = (T extends { length: number } ? T["length"] : never) & number;

Dengan pendekatan yang naif dan berkod keras, mengurus kedalaman sifat menjadi pilihan akan menjadi rumit. Begini cara utiliti DeepOptional yang selamat jenis boleh menyelesaikan perkara ini:

Melaksanakan DeepOptional

type TupleOf<N extends number, T extends unknown[] = []> = Length<T> extends N
  ? T
  : TupleOf<N, [...T, unknown]>;

Penjelasan:

• DeepOptional menjadikan sifat pilihan sehingga Had.
• Jenis meningkat CurrentLevel secara rekursif sehingga ia sepadan dengan Had, pada ketika itu ia berhenti berulang dan mengembalikan T.
• Kenaikan memastikan rekursi selamat jenis tanpa pemetaan tatasusunan manual.

Contoh Penggunaan:

type Pop<T extends any[]> = T extends [...infer U, unknown] ? U : never;

?️ Kesimpulan

Di medusajs, kami komited untuk mencari penyelesaian yang paling cekap dan inovatif untuk mengatasi cabaran teknikal yang kompleks. Dengan memanfaatkan jenis Increment dan Decrement berasaskan tuple, anda boleh bergerak melangkaui had operasi peringkat jenis asas dan mencipta utiliti yang boleh skala dan selamat jenis. Kaedah ini bukan sahaja memudahkan pengurusan kedalaman rekursi tetapi juga memastikan anda mengekalkan fleksibiliti yang diperlukan untuk operasi jenis rumit tanpa melebihi had penyemakan jenis TypeScript.

Atas ialah kandungan terperinci Menguasai Jenis Rekursif dalam TypeScript: Mengendalikan Had Kedalaman Dengan Anggun. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!