Keserasian Jenis di TypeScript

Hai sana, para ahli pengkomputeran masa depan! Hari ini, kita akan melangkah ke dalam dunia TypeScript dan menjelajahi konsep menarik Keserasian Jenis. Jangan khawatir jika anda baru dalam bidang pemrograman – saya akan menjadi panduannya yang ramah, dan kita akan menangani topik ini secara berperingkat. Jadi, pegang keyboard anda (tongkat sihir virtual), dan mari kita melontarkan beberapa mantra TypeScript!

Bagaimana TypeScript Melakukan Pemeriksaan Keserasian Jenis?

Bayangkan anda mencoba menempatkan blok berbentuk berbeda ke dalam lubang. Keserasian jenis di TypeScript sedikit mirip dengan itu – tentang apakah satu jenis dapat masuk ke jenis lain. Tetapi bukan bentuk fisik, melainkan jenis data.

Tipe Struktural

TypeScript menggunakan apa yang kita sebut "tipe struktural". Ini berarti dia lebih peduli tentang bentuk objek daripada namanya. mari kita lihat contoh:

interface Pet {
name: string;
}

class Dog {
name: string;
}

let pet: Pet;
let dog = new Dog();

pet = dog; // Ini baik!

Dalam keadaan ini, TypeScript mengatakan, "Hey, Pet dan Dog keduanya memiliki properti name tipe string. Mereka terlihat sama padanya bagi saya, jadi mereka keserasian!" Itu seperti mengatakan lubang persegi cocok dengan batang persegi, bahkan jika satu disebut "persegi" dan lainnya "blok".

Tipe Duck

Ada frasa menyenangkan dalam pemrograman: "Jika ia berjalan seperti bebek dan kicau seperti bebek, maka ia pasti adalah bebek." Ini esensi dari tipe duck, dan TypeScript mengakui filosofi ini. mari kita lihat dalam tindakan:

interface Quacker {
quack(): void;
}

class Duck {
quack() {
console.log("Quack!");
}
}

class Person {
quack() {
console.log("Saya meniru bebek!");
}
}

let quacker: Quacker = new Duck(); // tentu saja baik
quacker = new Person(); // Ini juga baik!

TypeScript tidak peduli bahwa Person tidak secara eksplisit dideklarasikan sebagai Quacker. Dia hanya peduli bahwa Person memiliki metode quack, sama seperti Quacker memiliki. Jadi keduanya Duck dan Person keserasian dengan Quacker.

Bagaimana Menggunakan Keserasian Jenis secara Efektif?

Menggunakan keserasian jenis secara efektif adalah seperti menjadi penyelesaikan teka-teki berkelasa. Berikut adalah beberapa tips:

1. Mengerti Pemeriksaan Literal Objek

TypeScript lebih ketat dengan literal objek. mari kita lihat mengapa:

interface Point {
x: number;
y: number;
}

let p: Point;

// Ini baik
p = { x: 10, y: 20 };

// Ini akan menyebabkan kesalahan
p = { x: 10, y: 20, z: 30 };

TypeScript mengatakan, "Whoa there! Saya meminta Point, tapi Anda memberikan saya sesuatu ekstra (z). Itu tidak diizinkan!" Ini membantu menangkap kutu yang mungkin terjadi saat Anda menggunakan objek secara salah.

2. Gunakan Properti Opsional

kadang-kadang, Anda ingin lebih fleksibel. Itu di mana properti opsional berguna:

interface Options {
color?: string;
width?: number;
}

function configure(options: Options) {
// ...
}

configure({ color: "red" }); // Baik
configure({ width: 100 }); // Baik
configure({}); // Juga baik!

Dengan membuat properti opsional (dengan tanda ?), Anda memberitahu TypeScript, "Itu baik jika ini tidak selalu ada."

Fungsi dan Keserasian Jenis

Fungsi adalah seperti pisau瑞士 Army knife pemrograman – mereka sangat multifungsi. mari kita lihat bagaimana keserasian jenis bekerja dengan mereka:

Keserasian Parameter

TypeScript sangat lunak dengan parameter fungsi:

let x = (a: number) => 0;
let y = (b: number, s: string) => 0;

y = x; // Baik
x = y; // Kesalahan

Ini mungkin terlihat berlawanan, tapi itu aman. TypeScript mengatakan, "Jika Anda mengharapkan fungsi yang mengambil dua parameter, itu baik untuk memberikan fungsi yang mengambil lebih sedikit. Parameter ekstra hanya akan diabaikan."

Keserasian Tipe Return

Tipe return juga perlu keserasian:

let x = () => ({name: "Alice"});
let y = () => ({name: "Alice", location: "Wonderland"});

x = y; // Baik
y = x; // Kesalahan

Itu baik untuk mengembalikan lebih banyak daripada yang diperkirakan, tapi bukan kurang. Itu seperti memesan pizza dan mendapatkan topping ekstra secara gratis – itu baik! Tetapi jika Anda memesan pizza dengan topping dan mendapatkan hanya crust, Anda akan kecewa.

Kelas dan Keserasian Jenis

Kelas adalah seperti blueprint untuk objek, dan mereka mengikuti aturan keserasian yang sama:

class Animal {
feet: number;
constructor(name: string, numFeet: number) { }
}

class Size {
feet: number;
}

let a: Animal;
let s: Size;

a = s; // Baik
s = a; // Baik

TypeScript hanya peduli dengan anggota instance. Dia mengatakan, "Keduanya memiliki properti feet? cukup untuk saya!"

Anggota Private dan Protected

Namun, saat kelas memiliki anggota private atau protected, hal itu menjadi lebih ketat:

class Animal {
private name: string;
constructor(theName: string) { this.name = theName; }
}

class Rhino extends Animal {
constructor() { super("Rhino"); }
}

class Employee {
private name: string;
constructor(theName: string) { this.name = theName; }
}

let animal = new Animal("Goat");
let rhino = new Rhino();
let employee = new Employee("Bob");

animal = rhino; // Baik
animal = employee; // Kesalahan: 'Animal' dan 'Employee' tidak keserasian

Meskipun Animal dan Employee terlihat sama, TypeScript memperlakukannya berbeda karena anggota private mereka berasal dari deklarasi yang berbeda.

Kesimpulan

Dan itu adalah, para murid pemrograman saya! Kita telah melakukan perjalanan melalui negeri keserasian jenis TypeScript. Ingat, TypeScript disini untuk membantu Anda menulis kode yang lebih baik dan aman. Itu seperti memiliki penyihir ramah yang memantau Anda, memberi nudge kecil saat Anda hampir membuat kesalahan.

Tetap latih, tetap eksperimen, dan segera Anda akan melontarkan mantra TypeScript seperti seorang pro! Sampai jumpa lagi, coding yang menyenangkan!

Metode	Deskripsi
Tipe Struktural	Memeriksa keserasian berdasarkan struktur jenis, bukan namanya
Tipe Duck	Jika memiliki properti/metode yang diperlukan, maka dianggap keserasian
Pemeriksaan Literal Objek	Pemeriksaan ketat untuk literal objek untuk menangkap kesalahan potensial
Properti Opsional	Gunakan ? untuk membuat properti opsional, meningkatkan fleksibilitas
Keserasian Parameter	Fungsi dengan parameter kurang dapat diassign ke fungsi dengan parameter lebih banyak
Keserasian Tipe Return	Fungsi dapat mengembalikan lebih banyak daripada yang diperkirakan, tapi bukan kurang
Keserasian Kelas	Berdasarkan anggota instance, bukan constructor atau anggota static
Anggota Private/Protected	Kelas dengan anggota private/protected hanya keserasian dengan subclass mereka sendiri

Credits: Image by storyset