Jenis itik dalam TypeScript

Apa itu menaip itik?

Pertama sekali, kita perlu tahu apa itu menaip itik. Menurut pengaturcara, situasi di mana jenis objek ditentukan oleh kelakuannya (seperti kaedah dan sifat) dan bukannya kelasnya dipanggil "menaip itik."

Itik menaip dalam TypeScript

Penggunaan antara muka dalam TypeScript memungkinkan penaipan itik. Antara muka bermaksud satu set kaedah dan ciri yang menerangkan jenis objek yang mesti dimiliki.

Sebagai contoh, jika antara muka mentakrifkan fungsi, sebarang objek dengan kaedah bernama "myFunc()" boleh dianggap sebagai jenis tertentu, tanpa mengira kelasnya. Fleksibiliti kod yang lebih besar dicapai apabila dua objek berkongsi tingkah laku yang sama dan boleh digunakan secara bergantian.

Penaipan itik menekankan menilai kesesuaian objek untuk tugas dengan mempertimbangkan kaedah dan sifatnya berbanding jenis sebenar. Antara muka menerangkan satu set sifat dan kaedah bahawa objek mesti dianggap "ditaip itik" untuk tujuan tertentu.

Kebaikan Jenis Itik

Salah satu faedah utama menaip itik ialah menjadikan kod lebih fleksibel dan boleh digunakan semula. Kod ini berfungsi untuk mana-mana objek dengan kaedah dan sifat yang diperlukan, bukan hanya jenis objek tertentu, dan boleh digunakan dalam pelbagai situasi tanpa pengubahsuaian. Penaipan itik juga meningkatkan penggunaan semula kod dengan mendayakan penggunaan boleh tukar objek daripada jenis yang berbeza dalam satu pangkalan kod.

Contoh menaip itik ialah TypeScript

Berikut ialah contoh cara menggunakan menaip itik dalam TypeScript -

Tentukan antara muka untuk mewakili gelagat yang anda mahu objek anda miliki. Contohnya -

interface Duck {
   quack(): void;
}

Buat kelas yang melaksanakan antara muka ini. Contohnya -

class MallardDuck implements Duck {
   quack(): void {
      console.log("Quack!");
   }
}

Buat contoh kelas ini dan gunakannya sebagai jenis yang ditakrifkan oleh antara muka.

let duck: Duck = new MallardDuck();
duck.quack(); // Output: "Quack!"

Buat kelas lain yang turut melaksanakan antara muka ini -

class RubberDuck implements Duck {
   quack(): void {
      console.log("Squeak!");
   }
}

Gunakan contoh kelas baharu sebagai jenis yang sama yang ditakrifkan oleh antara muka.

let duck: Duck = new RubberDuck();
duck.quack(); // Output: "Squeak!"

Seperti yang anda lihat, kedua-dua kelas MallardDuck dan RubberDuck melaksanakan antara muka Itik, dan pembolehubah itik boleh diberikan kepada kejadian kedua-dua kelas. Jenis ditentukan oleh antara muka dan bukannya tingkah laku (kaedah dan sifat) yang ditakrifkan dalam kelas.

Juga ambil perhatian bahawa dalam TypeScript anda boleh menggunakan jenis kata kunci untuk menyemak jenis objek pada masa jalan dan sama ada objek itu mempunyai kaedah atau sifat yang diharapkan.

Contoh

Dalam contoh ini, kelas Bird dan Plane melaksanakan antara muka Boleh Terbang, yang memerlukan kaedah Fly(). Kedua-dua "penaipan itik" boleh digunakan secara bergantian dalam fungsi goFly(). Fungsi ini tidak mengambil berat tentang jenis sebenar objek yang dihantar kepadanya, selagi ia mempunyai kaedah fly() yang boleh dipanggil.

interface Flyable {
   fly(): void;
}

class Bird implements Flyable {
   fly(): void {
      console.log("Bird is flying");
   }
}

class Plane implements Flyable {
   fly(): void {
      console.log("Plane is flying");
   }
}

function goFly(flyable: Flyable) {
   flyable.fly();
}

let bird = new Bird();
let plane = new Plane();

goFly(bird); // Prints "Bird is flying"
goFly(plane); // Prints "Plane is flying"

Apabila disusun, ia akan menjana kod JavaScript berikut -

var Bird = /** @class */ (function () {
   function Bird() {
   }
   Bird.prototype.fly = function () {
      console.log("Bird is flying");
   };
   return Bird;
}());
var Plane = /** @class */ (function () {
   function Plane() {
   }
   Plane.prototype.fly = function () {
      console.log("Plane is flying");
   };
   return Plane;
}());
function goFly(flyable) {
   flyable.fly();
}
var bird = new Bird();
var plane = new Plane();
goFly(bird); // Prints "Bird is flying"
goFly(plane); // Prints "Plane is flying"

Output

Kod di atas akan menghasilkan output berikut -

Bird is flying
Plane is flying

Contoh

Secara keseluruhannya, penaipan itik ialah konsep pengaturcaraan yang berkuasa yang membolehkan objek daripada jenis yang berbeza digunakan secara bergantian asalkan ia mempunyai kaedah dan sifat yang sama, sekali gus memberikan fleksibiliti dan kebolehgunaan yang lebih besar dalam kod TypeScript. Dalam contoh ini, antara muka Boleh Pandu, kelas Kereta dan Lori memaparkan kandungan yang sama.

interface Driveable {
  drive(): void;
}

class Car implements Driveable {
  drive(): void {
    console.log("Car is driving");
  }
}

class Truck implements Driveable {
  drive(): void {
    console.log("Truck is driving");
  }
}

function goDrive(driveable: Driveable) {
  driveable.drive();
}

let car = new Car();
let truck = new Truck();

goDrive(car); // Prints "Car is driving"
goDrive(truck); // Prints "Truck is driving"

Apabila disusun, ia akan menjana kod JavaScript berikut -

var Car = /** @class */ (function () {
    function Car() {
    }
    Car.prototype.drive = function () {
        console.log("Car is driving");
    };
    return Car;
}());
var Truck = /** @class */ (function () {
    function Truck() {
    }
    Truck.prototype.drive = function () {
        console.log("Truck is driving");
    };
    return Truck;
}());
function goDrive(driveable) {
    driveable.drive();
}
var car = new Car();
var truck = new Truck();
goDrive(car); // Prints "Car is driving"
goDrive(truck); // Prints "Truck is driving"

Output

Kod di atas akan menghasilkan output berikut -

Car is driving
Truck is driving

Idea utama di sebalik penaipan itik ialah kod harus ditulis untuk berfungsi dengan mana-mana objek yang mempunyai kaedah dan sifat yang diperlukan, dan bukannya ditulis untuk berfungsi dengan objek tertentu. Ini menjadikan kod anda lebih fleksibel dan boleh digunakan semula, membolehkan anda menggunakan pelbagai jenis objek secara bergantian tanpa menukar kod anda.

Atas ialah kandungan terperinci Jenis itik dalam TypeScript. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!