Jaka jest różnica między typem a interfejsem w programie Typescript?

Jakie są różnice między następującymi?

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

Interfejsy można rozszerzyć

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

a także rozszerzony

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

Aliasy typów mogą jednak oznaczać pewne rzeczy, których interfejsy nie mogą

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

Ogólnie rzecz biorąc, jeśli masz tylko zwykły typ obiektu, jak pokazano w pytaniu, interfejs jest zwykle lepszym podejściem. Jeśli chcesz napisać coś, czego nie można zapisać jako interfejs, lub chcesz po prostu nadać czemuś inną nazwę, alias typu jest lepszy.

Można również zaimplementować interfejs .

Typy są podobne do interfejsów i odwrotnie: oba mogą być implementowane przez klasę. ale jest kilka ważnych różnic: 1. gdy Type jest implementowany przez klasę, właściwości należące do Type muszą być zainicjowane wewnątrz klasy, podczas gdy w przypadku Interface muszą być zadeklarowane. 2. jak wspomniał @ryan: Interfejs może rozszerzyć inny interfejs. Typy nie mogą.

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'
}

Różnice między nimi również są już w tym wątku.

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

Tutaj type Fooi interface Foowygląda prawie podobnie, więc jest zagmatwany.

interfaceto umowa, że foo:stringw obiekcie powinny znajdować się następujące właściwości (tutaj ). interfacenie jest class. Jest używany, gdy język nie obsługuje dziedziczenia wielokrotnego. Więc interfacemoże być wspólna struktura między różnymi klasami.

class Bar implements Foo {
    foo: string;
}

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

Ale typei interfacesą używane w zupełnie innym kontekście.

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

Tutaj typez foojest Fooi todayjest Date. To jak dekleracja zmiennej, która przechowuje informacje o typie innej zmiennej. typejest jak nadzbiór interfejsów, klas, sygnatur funkcji, innych typów, a nawet wartości (takich jak type mood = 'Good' | 'Bad'). Na końcu typeopisuje możliwą strukturę lub wartość zmiennej.

Nie można powiedzieć, że „interfejsy mogą być implementowane”, ponieważ można również implementować typy

type A = { a: string };


class Test implements A {

    a: string;
}

Chociaż możesz to zrobić, nie możesz zaimplementować typu będącego połączeniem typów, co ma całkowity sens :)

type w maszynopisie służy do odwoływania się do już istniejących typów . Nie można go przedłużyć jak interface. Przykładami typesą:

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

możesz używać Odpoczynku i Rozproszenia w typach:

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

Interfejs natomiast pozwala stworzyć NOWY TYP.

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
}