javascript - una - interfaz en typescript
En Typecript, ¿cuál es la diferencia entre tipo e interfaz? (5)
¿Cuáles son las diferencias entre los siguientes?
type Foo = {
foo: string
};
interface Foo {
foo: string;
}
Además, se puede implementar una interfaz.
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 :)
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.
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.
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''
}