Interfaces

Les interfaces ont un impact JS nul à l’exécution. Il y a beaucoup de puissance dans les interfaces TypeScript pour déclarer la structure des variables.

Les deux suivantes sont des déclarations équivalentes, la première utilise une annotation inline, la seconde utilise une interface :

// Sample A
declare var myPoint: { x: number; y: number; };
// Sample B
interface Point {
 x: number; y: number;
}
declare var myPoint: Point;

Cependant, la beauté de l’échantillon B est que si quelqu’un écrit une bibliothèque qui s’appuie sur la bibliothèque myPoint pour ajouter de nouveaux membres, il peut facilement ajouter à la déclaration existante de myPoint:

// Lib a.d.ts
interface Point {
 x: number; y: number;
}
declare var myPoint: Point;
// Lib b.d.ts
interface Point {
 z: number;
}
// Your code
var myPoint.z; // Allowed!

C’est parce que les interfaces dans TypeScript sont ouvertes. C’est un principe essentiel de TypeScript qui vous permet d’imiter l’extensibilité de JavaScript en utilisant des interfaces.

Les classes peuvent implémenter des interfaces

Si vous voulez utiliser des classes qui doivent suivre une structure d’objet que quelqu’un a déclaré pour vous dans un interface, vous pouvez utiliser le mot-clé implements pour assurer la compatibilité :

interface Point {
 x: number; y: number;
}
class MyPoint implements Point {
 x: number; y: number; // Same as Point
}

Basiquement, en présence de ce implements, tout changement dans cette interface Point externe entraînera une erreur de compilation dans votre base de code, de sorte que vous pouvez facilement la garder synchronisée:

interface Point {
 x: number; y: number;
 z: number; // New member
}
class MyPoint implements Point { // ERROR : missing member `z`
 x: number; y: number;
}

Notez que implements restreint la structure des instances de la classe c’est-à-dire.e.:

var foo: Point = new MyPoint();

Et des trucs comme foo: Point = MyPoint ne sont pas la même chose.

Toutes les interfaces ne sont pas implémentables facilement

Les interfaces sont conçues pour déclarer toute structure arbitrairement folle qui pourrait être présente en JavaScript.

Considérez l’interface suivante où quelque chose est appelable avec new:

interface Crazy {
 new (): {
 hello: number
 };
}

Vous auriez essentiellement quelque chose comme:

class CrazyClass implements Crazy {
 constructor() {
 return { hello: 123 };
 }
}
// Because
const crazy = new CrazyClass(); // crazy would be {hello:123}

Vous pouvez déclarer tout le JS fou là-bas avec des interfaces et même les utiliser en toute sécurité depuis TypeScript. Cela ne signifie pas que vous pouvez utiliser des classes TypeScript pour les mettre en œuvre.