Petunjuk Jenis Lanjutan: Jenis Kesatuan, Jenis Persimpangan, dan `Never`

Jenis Kesatuan (A | B) Benarkan nilai menjadi salah satu daripada beberapa jenis, membolehkan pengendalian fleksibel pelbagai kemungkinan input. 2. Jenis persimpangan (A & B) menggabungkan pelbagai jenis ke dalam satu yang mesti memenuhi semua ahli, berguna untuk mewujudkan bentuk objek kompleks. 3. Jenis yang tidak pernah mewakili keadaan yang tidak dapat dicapai atau mustahil, yang biasa digunakan dalam pemeriksaan dan fungsi yang tidak pernah kembali. Bersama-sama, ciri-ciri typescript lanjutan ini membolehkan kod yang lebih mantap, mendokumentasikan diri, dan jenis-jenis dengan membuat negara-negara yang tidak sah tidak dapat diwujudkan.

Apabila bekerja dengan TypeScript, anotasi jenis asas hanyalah permulaan. Untuk menulis kod yang lebih mantap, ekspresif, dan dikekalkan, anda perlu melampaui string , number , atau boolean dan memanfaatkan jenis jenis canggih seperti jenis kesatuan , jenis persimpangan , dan jenis never ditaip. Alat ini memberi anda kawalan halus ke atas bagaimana nilai dan fungsi berkelakuan dalam senario kompleks.

Mari kita memecahkan setiap konsep ini dengan contoh praktikal dan kes penggunaan.

Jenis Kesatuan: Mengendalikan pelbagai kemungkinan

Jenis kesatuan membolehkan nilai menjadi salah satu daripada beberapa jenis. Anda menentukannya menggunakan bar menegak ( | ).

 Biarkan UserId: String | nombor;
userId = "ABC123"; // ✅
userId = 123; // ✅

Ini amat berguna apabila berurusan dengan API, input pengguna, atau data warisan di mana jenis tidak dijamin.

Contoh praktikal: pengendalian status

 fungsi getStatus (status: "memuatkan" | "kejayaan" | "ralat") {
  // ...
}
getStatus ("memuatkan"); // ✅
getstatus ("menunggu"); // ❌ Argumen tidak boleh diberikan

Anda juga boleh menggunakan kesatuan dengan jenis yang kompleks:

 jenis pengguna = {name: string; Umur: Nombor};
jenis admin = {name: string; Kebenaran: String []};

fungsi printInfo (entiti: pengguna | admin) {
  console.log (entity.name); // ✅ 'nama' wujud pada kedua -duanya
  // console.log (entiti.age); // ❌ Ralat: 'umur' bukan pada pentadbir
}

? Petua : Gunakan pengawal jenis untuk menyempitkan jenis kesatuan semasa runtime.

 jika ("umur" dalam entiti) {
  console.log (entiti.age); // sekarang selamat
}

Jenis Persimpangan: Menggabungkan Jenis

Jenis persimpangan menggabungkan pelbagai jenis ke dalam satu. Ia menggunakan & pengendali dan bermaksud "nilai ini mesti memenuhi semua jenis."

 jenis pengguna = {name: string; E -mel: String};
Taipkan timestamp = {createdAt: date; UPDATEDAT: Tarikh};

Taip UserWithTimeStamp = User & Timestamp;

pengguna const: userWithTimeStamp = {
  Nama: "Alice",
  E -mel: "alice@example.com",
  dibuat: tarikh baru (),
  dikemas kini: tarikh baru (),
};

Kes Penggunaan Dunia Sebenar: Mixin atau Objek Konfigurasi

 taip withId = {id: number};
taipkan name = {name: string};
jenis aktif = {isactive: boolean};

Taipkan akaun = WithId & WithName & Active;

akaun const: akaun = {
  ID: 1,
  Nama: "Pengguna Pro",
  isaktif: benar,
};

⚠️ Berhati -hati dengan persimpangan objek yang mempunyai bidang yang bercanggah :

 taip A = {data: string};
taip b = {data: nombor};
jenis C = A & B;

contoh const: c = {
  Data: ??? // Apa ini boleh? Mesti rentetan & nombor → mustahil → `tidak pernah`
};

Yang membawa kita ke ...

Taip never : mewakili keadaan yang tidak dapat dijangkau

Jenis never mewakili nilai yang tidak boleh berlaku . Ia digunakan dalam dua senario utama:

1. Fungsi yang tidak pernah kembali
2. Nilai yang tidak dapat wujud kerana jenis penyempitan

1. Fungsi yang tidak pernah kembali

 fungsi pelempar (mesej: rentetan): tidak pernah {
  membuang ralat baru (mesej);
}

Fungsi ini tidak hanya kembali void - ia tidak pernah kembali. Typescript menggunakan never memodelkannya.

2. Memeriksa kesatuan dalam kesatuan

Penggunaan klasik never memastikan semua kes dikendalikan dalam kesatuan:

 jenis mod = "gelap" | "Cahaya" | "Auto";

fungsi getTheMe (mod: mod) {
  suis (mod) {
    kes "gelap":
      kembali "hitam";
    kes "cahaya":
      kembali "putih";
    Kes "Auto":
      Kembali tetingkap.PrefersDark? "Hitam": "Putih";
    Lalai:
      // Sekiranya semua kes dilindungi, `mod` menjadi` tidak pernah` di sini
      const _ExhaustiveCheck: Never = Mode;
      kembali _ExhaustiveCheck;
  }
}

Jika anda kemudian menambah nilai baru ke Mode tetapi lupa untuk mengendalikannya, baris ini akan membuang ralat jenis , membantu anda menangkap logik yang tidak lengkap.

Bagaimana never berfungsi dalam sistem jenis

• never jenis bawah - ia boleh diberikan kepada mana -mana jenis.
• Tetapi tiada jenis yang boleh diberikan kepada never (kecuali never sendiri).
• Nampaknya semasa jenis penyempitan apabila kemungkinan habis.

 fungsi handlevalue (x: string | nombor) {
  jika (typeof x === "string") {
    // x adalah tali
  } else if (typeof x === "nombor") {
    // x adalah nombor
  } else {
    // x adalah `tidak pernah` - tidak ada kemungkinan lain
    const tidak dijangka: tidak = x;
    membuang ralat baru (`nilai yang tidak dijangka: $ {tak terduga}`);
  }
}

Menggabungkan semuanya

Bayangkan membina sistem pengesahan borang:

 jenis kejayaan = {kejayaan: benar; data: string};
jenis kegagalan = {kejayaan: palsu; Ralat: String};
Hasil jenis = Kejayaan & Kegagalan; // tunggu - apa?

// itu tidak masuk akal. Sebaliknya:
Taip ValidationResult = Kejayaan | Kegagalan;

fungsi isvalid (input: string): validationResult {
  jika (input.length> 0) {
    kembali {kejayaan: benar, data: input};
  } else {
    kembali {kejayaan: palsu, ralat: "input kosong"};
  }
}

// Kemudian, mengendalikan hasilnya dengan selamat:
Fungsi ProcessResult (Res: ValidationResult) {
  jika (res.success) {
    console.log ("Data:", res.data); // ✅ Jenis berjaya
  } else {
    console.log ("Ralat:", res.error); // ✅ Jenis adalah kegagalan
  }
}

Di sini, jenis kesatuan membolehkan menaip bersyarat, dan typescript menyempitkan jenis berdasarkan bidang success .

Ringkasan

• Jenis Kesatuan ( A | B ) : Nilai sama ada A atau B - hebat untuk input fleksibel.
• Jenis Persimpangan ( A & B ) : Nilai mestilah A dan B - berguna untuk menggabungkan ciri -ciri.
• never : mewakili keadaan yang mustahil atau tidak dapat dijangkau - penting untuk pemeriksaan dan fungsi kesilapan.

Ciri -ciri jenis canggih ini membantu anda menulis kod yang lebih selamat dengan membuat negara -negara yang tidak sah tidak dapat diwujudkan . Sebaik sahaja anda selesa dengan mereka, jenis anda tidak hanya ditaip-ia menjadi dokumentasi diri dan menguatkuasakan diri .

Pada asasnya, itulah cara anda menilai dari anotasi asas kepada pemodelan jenis yang benar -benar kuat.

Atas ialah kandungan terperinci Petunjuk Jenis Lanjutan: Jenis Kesatuan, Jenis Persimpangan, dan `Never`. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!