javascript - una - interfaz en typescript

En Typecript, ¿cuál es la diferencia entre tipo e interfaz?

Question

¿Cuáles son las diferencias entre los siguientes?

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

Answer 1

Además, se puede implementar una interfaz.

Answer 2

Es incorrecto decir "Las interfaces se pueden implementar" ya que los tipos también se pueden implementar

type A = { a: string };


class Test implements A {

    a: string;
}

Aunque puede hacer esto, no puede implementar un tipo que sea una Unión de tipos, lo que tiene mucho sentido honestamente :)

Answer 3

Las diferencias entre estos también ya están en este hilo.

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

Aquí, type Foo y la interface Foo ve casi similar, por lo que es confuso.

interface es el contrato de que las siguientes propiedades (aquí foo:string ) deben estar allí en un objeto. interface no es de class . Se utiliza cuando el idioma no admite herencia múltiple. Entonces la interface puede ser una estructura común entre diferentes clases.

class Bar implements Foo {
    foo: string;
}

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

Pero el type y la interface se usan en contextos muy diferentes.

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

Aquí el type de foo es Foo y today es Date . Es como una declinación variable que contiene la información del tipo de otra variable. type es como un superconjunto de interfaces, clases, firma de funciones, otros tipos o incluso valores (como type mood = ''Good'' | ''Bad'' ). Al final, el type describe la posible estructura o valor de una variable.

Answer 4

Las interfaces pueden extenderse

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

y también aumentada

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

Sin embargo, los alias de tipo pueden representar algunas cosas que las interfaces no pueden

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

Entonces, en general, si solo tiene un tipo de objeto simple, como se muestra en su pregunta, una interfaz suele ser un mejor enfoque. Si te encuentras con ganas de escribir algo que no se puede escribir como una interfaz, o simplemente quieres darle un nombre diferente a algo, un alias de tipo es mejor.

Answer 5

Tipos es algo así como Interfaces y viceversa: ambos pueden ser implementados por una clase. pero hay algunas diferencias importantes: 1. cuando el Tipo es implementado por una clase, las propiedades que pertenecen al Tipo deben inicializarse dentro de la clase, mientras que con la Interfaz deben declararse. 2. como mencionó @ryan: la interfaz puede extender otra interfaz. Los tipos no pueden.

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