TypeScript - Kesesuaian Tipe

Hai teman-teman, para ahli coding masa depan! Hari ini, kita akan memulai perjalanan yang menarik ke dunia TypeScript dan mengeksplorasi konsep yang menarik tentang Kesesuaian Tipe. Jangan khawatir jika Anda baru saja memulai programming – saya akan menjadi panduan teman baik Anda, dan kita akan mengatasi topik ini secara bertahap. Jadi, ambil keyboard Anda (tongkat sihir virtual), dan mari kita buat beberapa mantra TypeScript!

Bagaimana TypeScript Melakukan Pemeriksaan Kesesuaian Tipe?

Imaginasi Anda mencoba memasukkan blok-blok berbentuk berbeda ke lubang. Kesesuaian tipe TypeScript agak mirip dengan itu – tentang apakah satu tipe dapat memasuki yang 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 berkata, "Hey, Pet dan Dog keduanya memiliki properti name bertipe string. Mereka terlihat sama kepadaku, jadi mereka kompatibel!" Itu seperti mengatakan bahwa lubang persegi memasukkan batang persegi, bahkan jika satu disebut "persegi" dan lainnya "blok".

Tipe Angsa

Ada frasa menarik dalam programming: "Jika ia berjalan seperti angsa dan menggak seperti angsa, maka itu pasti adalah angsa." Ini adalah esensi tipe angsa, dan TypeScript mengakui filosofi ini. mari kita lihat dalam praktek:

interface Quacker {
quack(): void;
}

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

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

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 kompatibel dengan Quacker.

Bagaimana Menggunakan Kesesuaian Tipe secara Efektif?

Menggunakan kesesuaian tipe secara efektif adalah seperti menjadi pemecah teka-teki yang mahir. Berikut adalah beberapa tips:

1. Pahami 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 berkata, "Whoa there! Saya meminta Point, tapi Anda memberikan saya sesuatu tambahan (z). Ini tidak diijinkan!" Ini membantu menangkap kesalahan potensial saat Anda mungkin 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 ?), Anda memberitahu TypeScript, "Itu baik jika ini tidak selalu ada."

Fungsi dan Kesesuaian Tipe

Fungsi adalah seperti pisau瑞士 army knife dalam programming – mereka sangat multifungsi. mari kita lihat bagaimana kesesuaian tipe bekerja dengan mereka:

Kesesuaian 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 berkata, "Jika Anda mengharapkan fungsi yang mengambil dua parameter, itu baik untuk memberikan fungsi yang mengambil sedikit. Parameter ekstra hanya akan diabaikan."

Kesesuaian Tipe Return

Tipe return juga perlu kompatibel:

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

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

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

Kelas dan Kesesuaian Tipe

Kelas adalah seperti blueprint untuk objek, dan mereka mengikuti aturan kesesuaian 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 tentang anggota instance. Dia mengatakan, "Kedua-duanya 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 kompatibel

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

Kesimpulan

Dan begitu, para murid coding saya! Kita telah melakukan perjalanan melalui negeri kesesuaian tipe 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 bisa membuang mantra TypeScript seperti seorang pro! Sampaijumpa lagi, coding yang gembira!

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

Credits: Image by storyset