Types de canard en TypeScript

Qu'est-ce que la saisie de canard ?

Tout d’abord, nous devons savoir ce qu’est le typage canard. Selon les programmeurs, une situation dans laquelle le type d'un objet est déterminé par son comportement (comme les méthodes et les propriétés) plutôt que par sa classe est appelée « typage canard ».

Canard tapant en TypeScript

L'utilisation d'interfaces dans TypeScript rend possible la saisie en canard. Interface désigne un ensemble de méthodes et de caractéristiques qui décrivent le type auquel un objet doit appartenir.

Par exemple, si une interface définit des fonctions, tout objet possédant une méthode nommée "myFunc()" peut être considéré comme étant d'un type spécifique, quelle que soit sa classe. Une plus grande flexibilité du code est obtenue lorsque deux objets partagent le même comportement et peuvent être utilisés de manière interchangeable.

Le typage canard met l'accent sur l'évaluation de l'adéquation d'un objet à une tâche en considérant ses méthodes et ses propriétés plutôt que son type réel. Une interface explique un ensemble de propriétés et de méthodes selon lesquelles un objet doit être considéré comme « typé canard » dans un but spécifique.

Avantages du type canard

L'un des principaux avantages du typage canard est de rendre le code plus flexible et réutilisable. Le code fonctionne pour n'importe quel objet doté des méthodes et propriétés requises, pas seulement pour des types d'objets spécifiques, et peut être utilisé dans diverses situations sans modification. Le typage Duck améliore également la réutilisation du code en permettant l'utilisation interchangeable d'objets de différents types au sein d'une seule base de code.

Un exemple de saisie de canard est TypeScript

Voici un exemple d'utilisation de la saisie canard dans TypeScript -

Définissez une interface pour représenter le comportement que vous souhaitez que votre objet ait. Par exemple -

interface Duck {
   quack(): void;
}

Créez une classe qui implémente l'interface. Par exemple -

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

Créez une instance de la classe et utilisez-la comme type défini par l'interface.

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

Créez une autre classe qui implémente également l'interface -

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

Utilisez la nouvelle instance de classe comme le même type défini par l'interface.

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

Comme vous pouvez le voir, les classes MallardDuck et RubberDuck implémentent l'interface Duck, et les variables duck peuvent être attribuées aux instances des deux classes. Le type est déterminé par l'interface plutôt que par le comportement (méthodes et propriétés) défini dans la classe.

Notez également que dans TypeScript, vous pouvez utiliser le mot-clé typeof pour vérifier le type d'un objet au moment de l'exécution et si l'objet possède la méthode ou la propriété attendue.

Exemple

Dans cet exemple, les classes Bird et Plane implémentent l'interface Flyable, qui nécessite la méthode Fly(). Les deux « typage canard » peuvent être utilisés de manière interchangeable dans la fonction goFly(). La fonction ne se soucie pas du type réel de l'objet qui lui est transmis, tant qu'elle dispose d'une méthode fly() qui peut être appelée.

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"

Une fois compilé, il générera le code JavaScript suivant -

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"

Sortie

Le code ci-dessus produira le résultat suivant -

Bird is flying
Plane is flying

Exemple

Dans l'ensemble, le typage canard est un concept de programmation puissant qui permet d'utiliser des objets de différents types de manière interchangeable tant qu'ils ont les mêmes méthodes et propriétés, offrant ainsi une plus grande flexibilité et réutilisabilité dans le code TypeScript. Dans cet exemple, l'interface Driveable, les classes Car et Truck affichent le même contenu.

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"

Une fois compilé, il générera le code JavaScript suivant -

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"

Sortie

Le code ci-dessus produira le résultat suivant -

Car is driving
Truck is driving

L'idée principale derrière le typage de canard est que le code doit être écrit pour fonctionner avec n'importe quel objet possédant les méthodes et propriétés requises, plutôt que d'être écrit pour fonctionner avec un objet spécifique. Cela rend votre code plus flexible et réutilisable, vous permettant d'utiliser différents types d'objets de manière interchangeable sans modifier votre code.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!