Generik

Jenis Generik

Selamat datang ke pelajaran seterusnya! Dalam pelajaran ini, anda akan mempelajari tentang jenis generik, ciri berkuasa dalam TypeScript yang membolehkan anda mencipta komponen yang boleh diguna semula dan selamat dari segi jenis. Mari mulakan!

Jenis generik membolehkan anda menulis kod yang boleh diguna semula dan berfungsi dengan sebarang jenis. Jenis ini bertindak sebagai ruang letak untuk jenis yang boleh anda tentukan apabila menggunakannya.

Contoh: Fungsi generik:

Tugasan: Tulis fungsi generik yang menerima satu argumen dan mengembalikannya tanpa perubahan.

function identity<T>(value: T): T {
  return value;
}

console.log(identity<string>("Hello")); 
// Output: Hello
console.log(identity<number>(42)); 
// Output: 42

Jenis generik membantu anda:

• Menulis kod yang boleh diguna semula: Fungsi dan kelas boleh berfungsi dengan jenis yang berbeza.
• Memastikan keselamatan jenis: Anda boleh menguatkuasakan jenis tertentu tanpa mengorbankan fleksibiliti.
• Mengurangkan pengulangan: Elakkan menulis versi berasingan bagi fungsi atau kelas yang sama untuk jenis yang berbeza.

Petua: Gunakan jenis generik untuk menulis kod yang lebih fleksibel dan mudah diselenggara.

Anda boleh menggunakan jenis generik untuk mencipta fungsi yang fleksibel. Contoh:

Tugasan: Tulis fungsi generik yang menggabungkan dua objek dan mengembalikan hasilnya.

function merge<T, U>(obj1: T, obj2: U): T & U {
  return { ...obj1, ...obj2 };
}

let merged = merge({ name: "Alice" }, { age: 25 });
console.log(merged); 
// Output: { name: "Alice", age: 25 }

Jenis generik boleh digunakan dalam kelas untuk menjadikannya boleh diguna semula bagi jenis yang berbeza. Contoh:

class Box<T> {
  private contents: T;

  constructor(contents: T) {
    this.contents = contents;
  }

  getContents(): T {
    return this.contents;
  }
}

let stringBox = new Box<string>("Hello");
console.log(stringBox.getContents()); 
// Output: Hello

let numberBox = new Box<number>(42);
console.log(numberBox.getContents()); 
// Output: 42

Antara muka juga boleh menggunakan jenis generik untuk menguatkuasakan struktur bagi jenis yang berbeza. Contoh:

Tugasan: Takrifkan antara muka generik dan cipta objek yang melaksanakannya.

interface Pair<T, U> {
  first: T;
  second: U;
}

let coordinates: Pair<number, number> = { first: 10, second: 20 };
console.log(coordinates); 
// Output: { first: 10, second: 20 }

Anda boleh menambahkan kekangan pada jenis generik untuk memastikan jenis ini hanya berfungsi dengan jenis tertentu. Contoh:

function printLength<T extends { length: number }>(item: T): void {
  console.log(`Length: ${item.length}`);
}

printLength("Hello"); 
// Output: Length: 5
printLength([1, 2, 3]); 
// Output: Length: 3
// printLength(42); 
// Error: Argument of type 'number' is not assignable to parameter of type '{ length: number }'.

Anda boleh menentukan jenis lalai untuk jenis generik jika tiada jenis diberikan. Contoh:

Tugasan: Cipta fungsi generik dengan jenis lalai dan uji dengan jenis yang berbeza.

function wrap<T = string>(value: T): T[] {
  return [value];
}

console.log(wrap("Hello")); // Output: ["Hello"]
console.log(wrap(42)); // Output: [42]

Tahniah! Anda telah mempelajari cara menggunakan jenis generik dalam TypeScript untuk mencipta fungsi, kelas dan antara muka yang boleh diguna semula serta selamat dari segi jenis. Jenis generik ialah alat berkuasa untuk menulis kod yang fleksibel dan boleh diskalakan. Dalam pelajaran seterusnya, kita akan meneroka jenis lanjutan seperti jenis dipetakan dan bersyarat. Mari terus menulis kod!