Tapuscrit: Interfaces vs Types

Quelle est la différence entre ces états (interface vs type)?

interface X {
    a: number
    b: string
}

type X = {
    a: number
    b: string
};
InformationsquelleAutor | 2016-05-15
  1. 420

    Que par la Tapuscrit Langage De Spécification:

    Contrairement à une déclaration d'interface, qui introduit un nom de type d'objet, un alias de type de déclaration peut introduire un nom pour n'importe quel genre de type, y compris primitive, union et intersection types.

    La spécification cite:

    Types d'Interface ont de nombreuses similitudes avec le type d'alias pour le type d'objet
    les littéraux, mais depuis l'interface de types offrent plus de capacités qu'ils sont
    généralement préférées aux types d'alias. Par exemple, le type d'interface

    interface Point {
    x: number;
    y: number;
}

    peut être écrit comme alias de type

    type Point = {
    x: number;
    y: number;
};

    Cependant, ce faisant, les fonctionnalités suivantes sont perdus:

    • Une interface peut être nommé dans un prolonge ou met en œuvre la clause, mais un alias de type pour un type d'objet littéral ne peut pas N'est plus vrai depuis TS 2.7.
    • Une interface peut avoir plusieurs fusionné déclarations, mais un alias de type pour un type d'objet littéral ne peut pas.
    • Que signifie "plusieurs fusionné déclarations" dans la deuxième différence?
    • Je pense que le augmentée scénario ce fil les réponses à vos question
    • si vous définissez l'interface de deux fois, tapuscrit les fusionne en une seule.
    • si vous définissez le type de deux fois, la machine vous donne erreur
    • Point { x: number; } Point d'interface { y: nombre; }
    • Je crois que le premier point extends or implements n'est plus le cas. Le Type peut être étendu et mis en œuvre par un class. Voici un exemple typescriptlang.org/play/...
    • ps.: Vous pouvez quazi "étendre" types trop. Considérez les points suivants: type PartialPerson = { firstName: string; }; type Person = PartialPerson & { lastName: string; }; ...bien, je ne le recommanderais pas. : )
    • n'aide pas beaucoup sans exemple.
    • Cette réponse doit être mis à jour en raison des nouvelles Tapuscrit changements de 2,7+, voir medium.com/@martin_hotell/...
    • Ce type de l'union de l'interface qui ne fournit pas ?
    • Cette réponse est obsolète.

    InformationsquelleAutor Binary Birch Tree
  2. 310

    2019 mise à Jour

    Le courant des réponses et la la documentation officielle sont obsolètes. Et pour ceux qui sont nouveaux à la Machine, la terminologie utilisée n'est pas clair sans exemples. Ci-dessous est une liste à jour des différences.

    1. Objets /Fonctions

    À la fois peut être utilisé pour décrire la forme d'un objet ou d'une fonction de signature. Mais la syntaxe diffère.

    Interface

    interface Point {
  x: number;
  y: number;
}

interface SetPoint {
  (x: number, y: number): void;
}

    Alias de Type

    type Point = {
  x: number;
  y: number;
};

type SetPoint = (x: number, y: number) => void;

    2. D'Autres Types De

    Contrairement à une interface, le type d'alias peut également être utilisé pour d'autres types tels que les primitives, les syndicats, et les tuples.

    //primitive
type Name = string;

//object
type PartialPointX = { x: number; };
type PartialPointY = { y: number; };

//union
type PartialPoint = PartialPointX | PartialPointY;

//tuple
type Data = [number, string];

    3. Étendre

    À la fois peut être étendue, mais encore une fois, la syntaxe est différente. En outre, notez que l'interface et le type d'alias ne sont pas mutuellement exclusives. Une interface peut étendre un type d'alias, et vice versa.

    Interface étend l'interface

    interface PartialPointX { x: number; }
interface Point extends PartialPointX { y: number; }

    Alias de Type étend alias de type

    type PartialPointX = { x: number; };
type Point = PartialPointX & { y: number; };

    Interface étend alias de type

    type PartialPointX = { x: number; };
interface Point extends PartialPointX { y: number; }

    Alias de Type étend l'interface

    interface PartialPointX { x: number; }
type Point = PartialPointX & { y: number; };

    4. Met en œuvre

    Une classe peut implémenter une interface ou un alias de type, à la fois de la même manière exacte. À noter toutefois qu'une classe et d'interface sont considérées comme statique des modèles. Par conséquent, ils ne peuvent pas mettre en œuvre /étendre un type alias de noms un type d'union.

    interface Point {
  x: number;
  y: number;
}

class SomePoint implements Point {
  x: 1;
  y: 2;
}

type Point2 = {
  x: number;
  y: number;
};

class SomePoint2 implements Point2 {
  x: 1;
  y: 2;
}

type PartialPoint = { x: number; } | { y: number; };

//FIXME: can not implement a union type
class SomePartialPoint implements PartialPoint {
  x: 1;
  y: 2;
}

    5. Déclaration de la fusion

    Contrairement à un alias de type, une interface peut être défini à plusieurs reprises, et seront traités comme une seule et même interface (avec les membres de toutes les déclarations d'être fusionnées).

    //These two declarations become:
//interface Point { x: number; y: number; }
interface Point { x: number; }
interface Point { y: number; }

const point: Point = { x: 1, y: 2 };
    • Cela offre de meilleures informations détaillées sur la façon d'utiliser le type vs interface.
    • Si la documentation officielle est obsolète, où les informations que vous avez fournies sont-elles confirmées?
    • Basé sur ce post, il semble que le que raison de choisir une interface sur un alias de type est si vous souhaitez utiliser la déclaration de la fusion (point 5) de la fonction d'interfaces. Au-delà, ils sont équivalents (et je dirais que le type alias offre syntaxe plus concise).
    • J'ai toujours l'utilisation d'interfaces pour le type d'objet littéral, sinon à l'aide de types de plus de sens, aussi je pense que la déclaration de la fusion ne doit pas être utilisé dans de toute façon, en fait je ne vais jamais s'attendre à ce que l'interface est déclarée dans un autre fichier du projet avec des propriétés supplémentaires, type de vérification est faite à l'origine pour rendre votre vie plus facile de ne pas rendre plus difficile avec ce ninja-comme interfaces 😀
    • Cela ne peut pas être mis à jour et makred comme la meilleure réponse
    • un autre bon blog de jameshenry.blog/tapuscrit-classes-vs-interfaces

    InformationsquelleAutor jabacchetta
  3. 49

    De la Machine 3.2 (Novembre 2018), la suivante est vraie:

    Tapuscrit: Interfaces vs Types

    • Pourriez-vous fournir plus d'informations sur la façon de la table/l'image que vous avez fourni a été généré? par exemple, le code source ou des liens vers de la documentation
    • Bien sûr! C'est un Abattement de table rendus par GitHub. Vous pouvez trouver la syntaxe ici: help.github.com/articles/organizing-information-with-tables. Si vous êtes intéressé par le contenu lui-même, c'est à partir de mes notes personnelles. Je devrais probablement d'élaborer et de fournir des exemples, mais c'est un très long à lire.
    • oui, je voulais dire la source du contenu, pas de sa présentation.
    • Je ne crois pas un de la classe pouvez étendre soit d'un type ou d'une interface, et je ne vois pas vraiment pourquoi vous voulez??
    • est droit: une classe étend une valeur, pas un type.
    • Je suis sûr que l'OP signifiait que la classe implémente une interface ou d'un type
    • Est-il une source pour cette comparaison? Serait bien d'avoir quelques liens pour en savoir plus.

    InformationsquelleAutor Karol Majewski
  4. 25

    https://www.typescriptlang.org/docs/handbook/advanced-types.html

    Une différence, c'est que les interfaces de créer un nouveau nom qui est utilisé partout. Type d'alias ne pas créer un nouveau nom — par exemple, les messages d'erreur de ne pas utiliser le nom d'alias.

    InformationsquelleAutor nickf
  5. 0

    Exemples de Types:

    //création de l'arborescence de la structure d'un objet. Vous ne pouvez pas faire la même chose avec l'interface en raison de l'absence d'intersection (&)

    type Tree<T> = T & { parent: Tree<T> };

    //type de restreindre une variable à affecter à seulement quelques valeurs. Les Interfaces n'ont pas d'union (|)

    type Choise = "A" | "B" | "C";

    //merci de types, vous pouvez déclarer accepte pas les valeurs null type grâce à un mécanisme conditionnel. 

    type NonNullable<T> = T extends null | undefined ? never : T;

    Exemples de l'Interface:

    //vous pouvez utiliser l'interface pour la programmation orientée objet et utiliser "met en œuvre" pour définir l'objet/classe squelette

    interface IUser {
    user: string;
    password: string;
    login: (user: string, password: string) => boolean;
}

class User implements IUser {
    user = "user1"
    password = "password1"

    login(user: string, password: string) {
        return (user == user && password == password)
    }
}

    //vous pouvez étendre les interfaces avec d'autres interfaces

        interface IMyObject {
        label: string,
    }

    interface IMyObjectWithSize extends IMyObject{
        size?: number
    }
    InformationsquelleAutor Przemek Struciński