TypeScript - Duck Typing: A Beginner's Guide

Halo sana, masa depan bintang coding! Hari ini, kita akan melihat dunia yang menakjubkan TypeScript dan menjelajahi konsep yang menyenangkan seperti yang Anda dengar - Duck Typing. Jangan khawatir jika Anda baru belajar programming; saya akan memandu Anda dalam perjalanan ini langkah demi langkah, seperti yang saya lakukan untuk ribuan murid selama tahun-tahun mengajar saya. Jadi, mari kita mulai!

Apa Itu Duck Typing?

Imaginasi Anda di sebuah kolam, dan Anda melihat burung berenang. Itu tampak seperti bebek, berbisik seperti bebek, dan berenang seperti bebek. Anda akan menyebutnya apa? Bebek, kan? Itu esensi Duck Typing dalam programming!

Duck Typing adalah konsep yang mengatakan, "Jika dia berjalan seperti bebek dan berbisik seperti bebek, maka dia pasti adalah bebek." Dalam istilah programming, ini berarti jenis atau kelas objek kurang penting daripada metode yang ditentukan atau properti yang dimiliki.

Biarkan saya berbagi cerita pendek dari hari-hari mengajar saya. Pernah saya memiliki murid yang kesulitan memahami jenis dalam programming. Saya meminta dia untuk berpikir tentang kasus pangkalnya. Tidak penting jika itu terbuat dari plastik, logam, atau kain - selama itu bisa menempatkan pensil dan penggarisnya, itu melakukan tugasnya sebagai pangkal pensil. Itu adalah Duck Typing dalam aksi!

Bagaimana Duck Typing Bekerja dalam TypeScript

Dalam TypeScript, Duck Typing memungkinkan kita untuk menggunakan objek sebagai jika itu adalah jenis tertentu, selama itu memiliki semua properti dan metode yang diperlukan jenis itu. Itu seperti mengatakan, "Jika itu memiliki semua fitur yang saya butuhkan, saya tidak peduli apa namanya!"

Mari kita lihat contoh sederhana:

interface Quackable {
quack(): void;
}

function makeItQuack(duck: Quackable) {
duck.quack();
}

let rubberDuck = {
quack: () => console.log("Squeak! Squeak!")
};

let realDuck = {
quack: () => console.log("Quack! Quack!"),
swim: () => console.log("Splash! Splash!")
};

makeItQuack(rubberDuck); // Output: Squeak! Squeak!
makeItQuack(realDuck);   // Output: Quack! Quack!

Dalam contoh ini, kita memiliki Quackable interface yang memerlukan metode quack. Fungsi makeItQuack menerima objek apa pun yang cocok dengan interface ini. Kedua rubberDuck dan realDuck memiliki metode quack, jadi mereka dapat digunakan dengan makeItQuack, meskipun realDuck memiliki metode swim tambahan.

Manfaat Duck Typing

Sekarang kita mengerti apa itu Duck Typing, mari kita jelajahi mengapa itu sangat bagus! Berikut adalah beberapa manfaat utama:

1. Flexibilitas

Duck Typing memungkinkan kode yang lebih fleksibel. Anda tidak perlu membuat hierarki kelas ketat untuk menggunakan objek dalam cara yang sama. Selama objek memiliki metode atau properti yang diperlukan, itu dapat digunakan secara bergantian.

2. Reusabilitas Kode

Dengan Duck Typing, Anda dapat menulis fungsi yang bekerja dengan berbagai objek, selama mereka memiliki properti atau metode yang diperlukan. Ini mendorong penggunaan ulang kode dan dapat membuat basis kode Anda lebih efisien.

3. Lebih Mudah Dalam Tes

Duck Typing membuatnya mudah untuk membuat objek mock untuk tes. Anda hanya perlu mengimplementasikan metode yang benar-benar digunakan dalam tes, bukan membuat implementasi penuh dari kelas.

4. Desain Intuitif

Duck Typing seringkali mengarah ke desain API yang lebih intuitif. Anda fokus pada apa yang bisa dilakukan objek, bukan apa yang dinamainya.

Contoh Duck Typing dalam TypeScript

Mari kita masuk ke beberapa contoh lain untuk memperkokoh pemahaman kita tentang Duck Typing dalam TypeScript.

Contoh 1: The Shape-Shifter

interface Drawable {
draw(): void;
}

class Circle {
draw() {
console.log("Drawing a circle");
}
}

class Square {
draw() {
console.log("Drawing a square");
}
}

function drawShape(shape: Drawable) {
shape.draw();
}

drawShape(new Circle()); // Output: Drawing a circle
drawShape(new Square()); // Output: Drawing a square

Dalam contoh ini, Circle dan Square adalah kelas yang berbeda, tetapi keduanya memiliki metode draw. Fungsi drawShape tidak peduli tentang kelas spesifik objek yang diterima; dia hanya peduli bahwa objek memiliki metode draw.

Contoh 2: The Noise Makers

interface NoiseMaker {
makeNoise(): string;
}

let dog = {
makeNoise: () => "Woof!"
};

let cat = {
makeNoise: () => "Meow!",
purr: () => "Purr..."
};

let car = {
makeNoise: () => "Vroom!",
drive: () => console.log("Driving...")
};

function makeNoise(thing: NoiseMaker) {
console.log(thing.makeNoise());
}

makeNoise(dog); // Output: Woof!
makeNoise(cat); // Output: Meow!
makeNoise(car); // Output: Vroom!

Di sini, kita memiliki berbagai objek - seekor anjing, seekor kucing, dan bahkan mobil! Mereka semua memiliki metode makeNoise, jadi mereka semua dapat digunakan dengan fungsi makeNoise, meskipun mereka sangat berbeda.

Contoh 3: The Fly-Swimmer

interface Flyable {
fly(): void;
}

interface Swimmable {
swim(): void;
}

class Duck implements Flyable, Swimmable {
fly() {
console.log("Duck is flying");
}
swim() {
console.log("Duck is swimming");
}
}

class Airplane implements Flyable {
fly() {
console.log("Airplane is flying");
}
}

class Fish implements Swimmable {
swim() {
console.log("Fish is swimming");
}
}

function makeFly(flyer: Flyable) {
flyer.fly();
}

function makeSwim(swimmer: Swimmable) {
swimmer.swim();
}

let duck = new Duck();
let airplane = new Airplane();
let fish = new Fish();

makeFly(duck);     // Output: Duck is flying
makeFly(airplane); // Output: Airplane is flying
makeSwim(duck);    // Output: Duck is swimming
makeSwim(fish);    // Output: Fish is swimming

Dalam contoh ini, kita memiliki kelas yang berbeda mengimplementasikan interface yang berbeda. Kelas Duck mengimplementasikan kedua Flyable dan Swimmable interface, jadi itu dapat digunakan dengan kedua makeFly dan makeSwim fungsi.

Kesimpulan

Dan itu adalah, teman-teman! Kita telah berjalan melalui dasar-dasar Duck Typing dalam TypeScript. Ingat, esensi utama adalah ini: dalam Duck Typing, kita peduli lebih banyak tentang apa yang bisa dilakukan objek (metode dan propertinya) daripada apa jenisnya (kelas atau jenis).

Duck Typing memungkinkan kita menulis kode yang lebih fleksibel, dapat digunakan ulang, dan intuitif. Itu adalah konsep yang kuat yang dapat membuat kode TypeScript Anda lebih elegan dan efisien.

Sekarang Anda melanjutkan perjalanan programming Anda, tetap mencari kesempatan untuk menerapkan Duck Typing. Dan ingat, jika itu tampak seperti bebek, berenang seperti bebek, dan berbisik seperti bebek, maka itu mungkin adalah bebek... atau setidaknya, itu dapat ditangani seperti itu dalam kode Anda!

Selamat coding, dan may your code always quack... maksud saya, bekerja sempurna!

Method	Description
quack()	Menghasilkan suara bebek
draw()	Menggambar bentuk
makeNoise()	Menghasilkan suara
fly()	Memungkinkan objek terbang
swim()	Memungkinkan objek berenang

Credits: Image by storyset