Alias de tipos e interfaces

¡Bienvenido a la próxima lección! En esta lección, aprenderá sobre los alias de tipos y las interfaces en TypeScript, incluidas sus diferencias, similitudes y cuándo usar cada uno. ¡Comencemos!

¿Qué son los alias de tipos?

Un alias de tipo permite definir un nombre personalizado para un tipo. Puede representar tipos primitivos, objetos o incluso firmas de funciones.

Ejemplo:

Tarea: Cree un alias de tipo para un objeto que represente un libro y úselo para definir una variable.

type Point = {
  x: number;
  y: number;
};

let point: Point = { x: 10, y: 20 };
console.log(point); 
// Output: { x: 10, y: 20 }

¿Qué son las interfaces?

Una interfaz define la estructura de un objeto, incluidas sus propiedades y métodos. Se suele usar para garantizar la coherencia y la seguridad de tipos de los objetos.

Ejemplo:

Tarea: Cree una interfaz para el perfil de un usuario y úsela para definir una variable.

interface Point {
  x: number;
  y: number;
}

let point: Point = { x: 5, y: 15 };
console.log(point); 
// Output: { x: 5, y: 15 }

Alias de tipos frente a interfaces: similitudes

Los alias de tipos y las interfaces comparten algunas características:

• Ambos pueden describir la forma de un objeto.
• Ambos se pueden usar para definir tipos de funciones.
• Ambos admiten la extensión de otros tipos.

Ejemplo: un tipo de función:

Tarea: Defina un alias de tipo y una interfaz para una función, y úselos.

type Add = (a: number, b: number) => number;
interface Subtract {
  (a: number, b: number): number;
}

let add: Add = (x, y) => x + y;
let subtract: Subtract = (x, y) => x - y;

console.log(add(5, 3)); 
// Output: 8
console.log(subtract(5, 3)); 
// Output: 2

Alias de tipos frente a interfaces: diferencias

Estas son las diferencias principales:

• Interfaces: Se pueden fusionar (fusión de declaraciones).
• Alias de tipos: No se pueden fusionar.
• Alias de tipos: Pueden definir tipos unión e intersección.
• Interfaces: Están diseñadas principalmente para definir estructuras de objetos.

Ejemplo: tipos unión con alias de tipos:

Tarea: Use un alias de tipo para definir un tipo unión y asigne distintos valores a una variable.

type StringOrNumber = string | number;

let value: StringOrNumber = "Hello";
value = 42;
// value = true; 
// Error: Type 'true' is not assignable to type 'StringOrNumber'.

Extensión de tipos e interfaces

Tanto los alias de tipos como las interfaces pueden extender otros tipos:

• Interfaces: Usan la palabra clave extends.
• Alias de tipos: Usan intersecciones (&).

Ejemplo:

Tarea: Extienda un alias de tipo y una interfaz para crear nuevos tipos.

interface Animal {
  name: string;
}

interface Dog extends Animal {
  breed: string;
}

type Bird = Animal & { canFly: boolean };

let myDog: Dog = { name: "Buddy", breed: "Golden Retriever" };
let myBird: Bird = { name: "Parrot", canFly: true };

console.log(myDog, myBird);

Fusión de declaraciones

Las interfaces admiten la fusión de declaraciones, mediante la cual varias declaraciones de interfaz con el mismo nombre se combinan en una sola. Los alias de tipos no admiten esta característica.

Ejemplo:

Tarea: Cree dos declaraciones de interfaz con el mismo nombre y pruebe la fusión de declaraciones.

interface Person {
  name: string;
}

interface Person {
  age: number;
}

let person: Person = { name: "Alice", age: 30 };
console.log(person); 
// Output: { name: "Alice", age: 30 }

Cuándo usar cada uno

Estas son algunas pautas:

• Use interfaces para definir estructuras de objetos y cuando necesite la fusión de declaraciones.
• Use alias de tipos para uniones, intersecciones o para definir tipos de funciones.

Consejo: Use la opción que mejor se adapte a su caso de uso para lograr claridad y coherencia.

¡Excelente trabajo!

¡Felicidades! Ha aprendido las similitudes y diferencias entre los alias de tipos y las interfaces en TypeScript, así como cuándo usar cada uno. En la próxima lección, exploraremos características avanzadas de TypeScript, como los tipos condicionales. ¡Sigamos programando!