TypeScript - Duck Typing: A Beginner's Guide

Hai there, bakat pemrograman masa depan! Hari ini, kita akan menyelam ke dalam dunia yang menakjubkan TypeScript dan menjelajahi konsep yang menyenangkan seperti yang terdengar - Duck Typing. Jangan khawatir jika Anda baru dalam pemrograman; 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?

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

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

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

Bagaimana Duck Typing Bekerja di 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 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 apapun yang cocok dengan interface ini. Baik rubberDuck dan realDuck memiliki metode quack, jadi mereka bisa 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 hebat! Berikut adalah beberapa manfaat utama:

1. Kekalikan

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

2. Reusabilitas Kode

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

3. Lebih Mudah Dalam Pemeriksaan

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

4. Desain Intuitif

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

Contoh Duck Typing di TypeScript

mari kita masuk ke beberapa contoh lain untuk memperkuat pemahaman kita tentang Duck Typing di 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, tapi keduanya memiliki metode draw. Fungsi drawShape tidak peduli tentang jenis khusus objek yang diterima; 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 - anjing, kucing, dan bahkan mobil! Mereka semua memiliki metode makeNoise, jadi mereka semua bisa 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 bisa digunakan dengan kedua makeFly dan makeSwim fungsi.

Kesimpulan

Dan itu adalah, teman-teman! Kita telah berenang melalui dasar-dasar Duck Typing di TypeScript. Ingat, kata kunci adalah ini: dalam Duck Typing, kita peduli lebih dengan apa yang bisa dilakukan objek (metode dan propertinya) daripada apa jenisnya (kelasnya).

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

Sekarang Anda teruskan perjalanan pemrograman Anda, cari peluang 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 bisa ditangani seperti satu dalam kode Anda!

Selamat pemrograman, dan semoga kode Anda selalu "quack" ... saya maksud, bekerja sempurna!

Credits: Image by storyset