In Typescript, qual è la differenza tra tipo e interfaccia?

Quali sono le differenze tra i seguenti?

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

Le interfacce possono essere estese

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

e anche aumentato

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

Gli alias di tipo, tuttavia, possono rappresentare alcune cose che le interfacce non possono

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

Quindi, in generale, se hai solo un semplice tipo di oggetto, come mostrato nella tua domanda, un'interfaccia di solito è un approccio migliore. Se ti accorgi di voler scrivere qualcosa che non può essere scritto come interfaccia, o vuoi semplicemente dare a qualcosa un nome diverso, un alias di tipo è meglio.

Inoltre, è possibile implementare un'interfaccia .

I tipi sono un po 'come le interfacce e viceversa: entrambi possono essere implementati da una classe. ma ci sono alcune differenze importanti: 1. quando Type è implementato da una classe, le proprietà che appartengono al Type devono essere inizializzate all'interno della classe, mentre con Interface devono essere dichiarate. 2. come menzionato da @ryan: l'interfaccia può estendere un'altra interfaccia. I tipi non possono.

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

Anche le differenze tra queste sono già in questo thread.

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

Qui type Fooeinterface Foo sembra quasi simile, quindi è confuso.

interfaceè contratto che le seguenti proprietà (qui foo:string) dovrebbero essere presenti in un oggetto. interfacenon lo è class. Viene utilizzato quando la lingua non supporta l'ereditarietà multipla. Quindi interfacepuò essere una struttura comune tra classi diverse.

class Bar implements Foo {
    foo: string;
}

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

Ma typee interfacesono usati in contesti molto diversi.

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

Qui typedi fooè Fooed todayè Date. È come una declinazione variabile che contiene le informazioni del tipo di altra variabile. typeè come un superset di interfacce, classi, firma di funzioni, altri tipi o persino valori (come type mood = 'Good' | 'Bad'). Alla fine typedescrive la possibile struttura o valore di una variabile.

È sbagliato dire "Le interfacce possono essere implementate" poiché anche i tipi possono essere implementati

type A = { a: string };


class Test implements A {

    a: string;
}

Sebbene tu possa farlo, non puoi implementare un tipo che sia un'unione di tipi, il che ha assolutamente senso, onestamente :)

il tipo nel dattiloscritto viene utilizzato per fare riferimento a tipi già esistenti . Non può essere esteso come interface. Esempi di typesono:

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

puoi usare Riposo e Diffusione nei tipi:

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

L'interfaccia, invece, ti permette di creare un NUOVO TIPO.

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
}