Duck-Typen in TypeScript

Was ist Duck-Typing?

Zuerst müssen wir wissen, was Duck-Typing ist. Programmierern zufolge wird eine Situation, in der der Typ eines Objekts durch sein Verhalten (z. B. Methoden und Eigenschaften) und nicht durch seine Klasse bestimmt wird, als „Duck Typing“ bezeichnet.

Duck tippt in TypeScript

Die Verwendung von Schnittstellen in TypeScript ermöglicht Duck-Typing. Unter Schnittstelle versteht man eine Reihe von Methoden und Merkmalen, die den Typ beschreiben, zu dem ein Objekt gehören muss.

Wenn beispielsweise eine Schnittstelle Funktionen definiert, kann jedes Objekt mit einer Methode namens „myFunc()“ als von einem bestimmten Typ betrachtet werden, unabhängig von seiner Klasse. Eine größere Codeflexibilität wird erreicht, wenn zwei Objekte dasselbe Verhalten aufweisen und austauschbar verwendet werden können.

Duck Typing legt Wert darauf, die Eignung eines Objekts für eine Aufgabe zu bewerten, indem seine Methoden und Eigenschaften und nicht sein tatsächlicher Typ berücksichtigt werden. Eine Schnittstelle erklärt eine Reihe von Eigenschaften und Methoden, mit denen ein Objekt für einen bestimmten Zweck als „Ententyp“ betrachtet werden muss.

Vorteile des Ententyps

Einer der Hauptvorteile von Duck Typing besteht darin, dass Code flexibler und wiederverwendbar wird. Der Code funktioniert für jedes Objekt mit den erforderlichen Methoden und Eigenschaften, nicht nur für bestimmte Objekttypen, und kann in einer Vielzahl von Situationen ohne Änderungen verwendet werden. Duck-Typing verbessert auch die Wiederverwendung von Code, indem es die austauschbare Verwendung von Objekten unterschiedlichen Typs innerhalb einer einzigen Codebasis ermöglicht.

Beispiel für Duck-Typing ist TypeScript

Hier ist ein Beispiel für die Verwendung von Duck Typing in TypeScript -

Definieren Sie eine Schnittstelle, um das Verhalten darzustellen, das Ihr Objekt haben soll. Zum Beispiel -

interface Duck {
   quack(): void;
}

Erstellen Sie eine Klasse, die die Schnittstelle implementiert. Zum Beispiel -

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

Erstellen Sie eine Instanz der Klasse und verwenden Sie sie als den von der Schnittstelle definierten Typ.

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

Erstellen Sie eine weitere Klasse, die auch die Schnittstelle implementiert -

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

Verwenden Sie die neue Klasseninstanz als denselben Typ, der von der Schnittstelle definiert wird.

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

Wie Sie sehen, implementieren sowohl die MallardDuck- als auch die RubberDuck-Klasse die Duck-Schnittstelle und Duck-Variablen können Instanzen beider Klassen zugewiesen werden. Der Typ wird durch die Schnittstelle und nicht durch das in der Klasse definierte Verhalten (Methoden und Eigenschaften) bestimmt.

Beachten Sie außerdem, dass Sie in TypeScript das Schlüsselwort typeof verwenden können, um den Typ eines Objekts zur Laufzeit zu überprüfen und ob das Objekt über die erwartete Methode oder Eigenschaft verfügt.

Beispiel

In diesem Beispiel implementieren die Klassen Bird und Plane die Flyable-Schnittstelle, die die Fly()-Methode erfordert. Beide „Duck Typing“ können in der Funktion goFly() austauschbar verwendet werden. Der Funktion ist der tatsächliche Typ des an sie übergebenen Objekts egal, solange sie über eine fly()-Methode verfügt, die aufgerufen werden kann.

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"

Beim Kompilieren wird der folgende JavaScript-Code generiert:

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"

Ausgabe

Der obige Code erzeugt die folgende Ausgabe -

Bird is flying
Plane is flying

Beispiel

Insgesamt ist Duck Typing ein leistungsstarkes Programmierkonzept, das die austauschbare Verwendung von Objekten unterschiedlicher Typen ermöglicht, solange sie über dieselben Methoden und Eigenschaften verfügen, und so für mehr Flexibilität und Wiederverwendbarkeit im TypeScript-Code sorgt. In diesem Beispiel zeigen die Klassen „Driveable“ und „Car“ und „Truck“ denselben Inhalt an.

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"

Beim Kompilieren wird der folgende JavaScript-Code generiert:

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"

Ausgabe

Der obige Code erzeugt die folgende Ausgabe -

Car is driving
Truck is driving

Die Hauptidee hinter Duck Typing besteht darin, dass Code so geschrieben werden sollte, dass er mit jedem Objekt funktioniert, das über die erforderlichen Methoden und Eigenschaften verfügt, und nicht so, dass er für die Arbeit mit einem bestimmten Objekt geschrieben wird. Dadurch wird Ihr Code flexibler und wiederverwendbar, sodass Sie verschiedene Objekttypen austauschbar verwenden können, ohne Ihren Code ändern zu müssen.

Das obige ist der detaillierte Inhalt vonDuck-Typen in TypeScript. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!