TypeScript 中的 Duck 類型

什麼是鴨子打字？

首先，我們要知道什麼是鴨子打字。根據程式設計師的說法，物件的類型由其行為（如方法和屬性）而不是其類別決定的情況稱為「鴨子類型」。

TypeScript 中的鴨子類型

TypeScript 中介面的使用使鴨子打字成為可能。其中介面意味著描述物件必須屬於該類型的一組方法和特徵。

例如，如果介面定義了函數，則任何具有名為「myFunc()」方法的物件都可以被視為屬於特定類型，而不管其類別如何。當兩個物件共享相同的行為並且可以互換使用時，可以實現更大的程式碼彈性。

鴨子類型強調透過考慮物件的方法和屬性而不是其實際類型來評估物件對任務的適用性。介面解釋了出於特定目的，物件必須被視為“鴨子類型”的一組屬性和方法。

鴨子類型的好處

鴨子類型的主要好處之一是使程式碼更加靈活和可重複使用。該程式碼適用於具有所需方法和屬性的任何對象，而不僅僅是特定類型的對象，並且可以在各種情況下使用而無需修改。鴨子類型還透過在單一程式碼庫中實現不同類型的物件的可互換使用來提高程式碼重複使用。

鴨子打字的範例是 TypeScript

以下是如何在 TypeScript 中使用鴨子類型的範例 -

定義一個介面來表示您希望物件具有的行為。例如 -

interface Duck {
   quack(): void;
}

建立一個實作該介面的類別。例如 -

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

建立該類別的實例並將其用作介面定義的類型。

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

建立另一個也實作該介面的類別 -

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

使用新的類別實例作為介面定義的相同類型。

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

正如您所看到的，MallardDuck 和 RubberDuck 類別都實現了 Duck 接口，並且 duck 變數可以分配給這兩個類別的實例。類型由介面而不是類別中定義的行為（方法和屬性）決定。

還需要注意的是，在 TypeScript 中，您可以使用 typeof 關鍵字來檢查運行時物件的​​類型以及該物件是否具有預期的方法或屬性。

範例

在此範例中，Bird 和 Plane 類別實作了 Flyable 接口，該接口需要 Fly() 方法。兩種「鴨子類型」可以在 goFly() 函數中互換使用。該函數並不關心傳遞給它的物件的實際類型，只要它有一個可以呼叫的fly()方法即可。

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"

編譯時，它將產生以下 JavaScript 程式碼 -

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"

輸出

上面的程式碼將產生以下輸出 -

Bird is flying
Plane is flying

範例

總的來說，鴨子類型是一個強大的程式設計概念，它允許不同類型的物件互換使用，只要它們具有相同的方法和屬性，從而在TypeScript 程式碼中提供更大的靈活性和可重複使用性。在此範例中，Driveable 介面、Car 和 Truck 類別顯示相同的內容。

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"

編譯時，它將產生以下 JavaScript 程式碼 -

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"

輸出

上面的程式碼將產生以下輸出 -

Car is driving
Truck is driving

鴨子類型背後的主要想法是，程式碼應該編寫為與任何具有所需方法和屬性的物件一起使用，而不是編寫為與特定物件一起使用。這可以使程式碼更加靈活和可重複使用，讓您在不更改程式碼的情況下互換使用不同類型的物件。

以上是TypeScript 中的 Duck 類型的詳細內容。更多資訊請關注PHP中文網其他相關文章！