Dans Typescript, quelle est la différence entre le type et l'interface?

Quelles sont les différences entre les éléments suivants?

type Foo = { 
    foo: string 
};
interface Foo {
   foo: string;
}

Les interfaces peuvent être étendues

interface A {
  x: number;
}
interface B extends A {
  y: string;
}

et aussi augmenté

interface C {
  m: boolean;
}
// ... later ...
interface C {
  n: number;
}

Les alias de type, cependant, peuvent représenter certaines choses que les interfaces ne peuvent pas

type NumOrStr = number | string;
type NeatAndCool = Neat & Cool;
type JustSomeOtherName = SomeType;

Donc, en général, si vous n'avez qu'un type d'objet simple, comme indiqué dans votre question, une interface est généralement une meilleure approche. Si vous avez envie d'écrire quelque chose qui ne peut pas être écrit en tant qu'interface, ou si vous voulez simplement donner à quelque chose un nom différent, un alias de type est préférable.

En outre, une interface peut être implémentée .

Les types sont un peu comme les interfaces et vice versa: les deux peuvent être implémentés par une classe. mais il y a quelques différences importantes: 1. lorsque Type est implémenté par une classe, les propriétés qui appartiennent au Type doivent être initialisées à l'intérieur de la classe, alors qu'avec Interface, elles doivent être déclarées. 2. comme @ryan l'a mentionné: l'interface peut étendre une autre interface. Les types ne peuvent pas.

type Person = {
    name:string;
    age:number;
}

// must initialize all props - unlike interface
class Manager implements Person {
    name: string = 'John';
    age: number = 55;

    // can add props and methods
    size:string = 'm';
}

const jane : Person = {
    name :'Jane',
    age:46,

    // cannot add more proprs or methods
    //size:'s'
}

Les différences entre ces derniers sont également déjà dans ce fil.

type Foo = {
    foo: string
};
interface Foo {
    foo: string;
}

Ici type Fooet interface Foosemble presque similaire, donc c'est déroutant.

interfaceest le contrat que les propriétés suivantes (ici foo:string) doivent être présentes dans un objet. interfacen'est pas class. Il est utilisé lorsque la langue ne prend pas en charge l'héritage multiple. Il interfacepeut donc y avoir une structure commune entre différentes classes.

class Bar implements Foo {
    foo: string;
}

let p: Foo = { foo: 'a string' };

Mais typeet interfacesont utilisés dans un contexte très différent.

let foo: Foo;
let today: Date = new Date();

Ici typede fooest Fooet todayest Date. C'est comme une déclinaison de variable qui contient les informations de type d'une autre variable. typeest comme un sur-ensemble d'interfaces, de classes, de signature de fonction, d'autres types ou même de valeurs (comme type mood = 'Good' | 'Bad'). À la fin, typedécrit la structure ou la valeur possible d'une variable.

Il est faux de dire "les interfaces peuvent être implémentées" car les types peuvent également être implémentés

type A = { a: string };


class Test implements A {

    a: string;
}

Bien que vous puissiez le faire, vous ne pouvez pas implémenter un type qui est une union de types, ce qui est tout à fait logique honnêtement :)

type dans le dactylographie est utilisé pour référencer des types déjà existants . Il ne peut pas être prolongé comme interface. Exemples de type:

type Money = number;
type FormElem = React.FormEvent<HTMLFormElement>;
type Person = [string, number, number];

vous pouvez utiliser Rest and Spread dans les types:

type Scores = [string, ...number[]];
let ganeshScore = ["Ganesh", 10, 20, 30]
let binodScore = ["Binod", 10, 20, 30, 40]

L'interface, d'autre part, vous permet de créer un NOUVEAU TYPE.

interface Person{
  name: string,
  age: number, 
}

Interface can be extended with extends keyword.
interface Todo{
  text: string;
  complete: boolean;
}

type Tags = [string, string, string]

interface TaggedTodo extends Todo{
 tags: Tags
}