TypeScript Duck类型

什么是Duck 类型

首先，我们要知道什么是Duck类型。根据程序员的说法，一个对象的类型是由其行为决定的，比如方法和属性，而不是其类别，这种情况被称为 “Duck类型”。

TypeScript中的Duck类型

TypeScript中接口的使用使Duck类型成为可能。接口是指描述一个对象必须具备的方法和特性的集合，以归入该类型。

例如，如果一个接口定义了函数，任何具有名为 “myFunc() “的方法的对象都可以被视为属于一个特定的类型，无论其类别如何。当两个对象具有相同的行为并且可以互换使用时，更大的代码灵活性是可能的。

Duck类型强调通过考虑对象的方法和属性而不是其实际类型来评估对象对任务的适合性。一个接口解释了一个对象必须具备的属性和方法的集合，以便被认为是 “Duck类型 “用于一个特定的目的。

Duck类型的好处

Duck类型的主要好处之一是使代码更加灵活和可重复使用。代码可以与任何具有所需方法和属性的对象一起使用，而不仅仅是特定类型的对象，并且可以在各种情况下使用而不需要修改。Duck类型也提高了代码的重用性，使不同类型的对象在一个代码库中可以互换使用。

TypeScript中的Duck类型的例子

下面是一个如何在TypeScript中使用Duck类型的例子 —

定义一个接口，代表你希望一个对象拥有的行为。比如说

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关键字在运行时检查对象的类型，以及该对象是否具有预期的方法或属性。

例子

在这个例子中，鸟类和飞机类实现了Flyable接口，这需要一个fly()方法。这两种 “Duck类型 “在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"

On compiling, it will generate the following JavaScript code −

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

例子

总的来说，Duck类型化是一个强大的编程概念，通过允许不同类型的对象互换使用，只要它们具有相同的方法和属性，就可以在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"

On compiling, it will generate the following JavaScript code −

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"