Los tipos personalizados en TypeScript te permiten crear tus propios tipos de datos personalizados. Son útiles cuando deseas combinar varios tipos de datos en un tipo único y darle un nombre significativo.
Aquí tienes un ejemplo de un tipo personalizado:
// Tipo personalizado para coordenadas
type Coordinate = {
x: number;
y: number;
};
// Función que calcula la distancia entre dos coordenadas
function calculateDistance(pointA: Coordinate, pointB: Coordinate): number {
const dx = pointB.x - pointA.x;
const dy = pointB.y - pointA.y;
return Math.sqrt(dx * dx + dy * dy);
}
// Usando el tipo personalizado Coordinate
const point1: Coordinate = { x: 0, y: 0 };
const point2: Coordinate = { x: 3, y: 4 };
const distance = calculateDistance(point1, point2);
console.log(`Distancia entre los puntos: ${distance}`);
type Coordinate define un tipo personalizado llamado Coordinate que representa una coordenada en el plano cartesiano. Tiene dos propiedades: x y y, ambas del tipo number, que representan las coordenadas horizontal y vertical, respectivamente.function calculateDistance(pointA: Coordinate, pointB: Coordinate): number { ... } es una función que calcula la distancia entre dos coordenadas pointA y pointB pasadas como argumentos. La función utiliza la fórmula de distancia Euclidiana, que es la distancia directa entre dos puntos en un plano cartesiano.const point1: Coordinate = { x: 0, y: 0 }; y const point2: Coordinate = { x: 3, y: 4 }; son declaraciones de variables que usan el tipo personalizado Coordinate para representar coordenadas. point1 representa las coordenadas (0, 0) y point2 representa las coordenadas (3, 4).const distance = calculateDistance(point1, point2); llama a la función calculateDistance con point1 y point2 como argumentos para calcular la distancia entre esos puntos y almacena el resultado en la variable distance.console.log(Distancia entre los puntos: ${distance}); muestra la distancia calculada en la consola.Una interfaz en TypeScript es una forma de definir un contrato o un conjunto de reglas que un objeto debe seguir. Es como un contrato que especifica qué propiedades (campos) y métodos (funciones) debe tener un objeto. Las interfaces se usan comúnmente para definir la forma de los objetos en tu código.
Aquí tienes un ejemplo de una interfaz simple:
// Interfaz para representar un coche
interface Car {
brand: string;
model: string;
year: number;
startEngine: () => void;
}
// Función que recibe un objeto del tipo Car
function drive(car: Car): void {
console.log(`Conduciendo ${car.brand} ${car.model} - ${car.year}`);
car.startEngine();
}
// Implementación de la interfaz Car
const myCar: Car = {
brand: "Toyota",
model: "Corolla",
year: 2022,
startEngine() {
console.log("¡Motor encendido!");
}
};
// Llamada a la función drive con el objeto myCar
drive(myCar);
interface Car { ... }: Define una interfaz llamada Car que describe la estructura esperada de un objeto que representa un coche. Tiene cuatro propiedades: brand (marca), model (modelo), year (año) y startEngine (una función que no recibe argumentos y no retorna nada).function drive(car: Car): void { ... }: Declara una función llamada drive que recibe un parámetro llamado car del tipo Car. Esta función no retorna nada (void). Muestra en la consola información sobre el coche, incluyendo la marca, el modelo y el año, y luego llama a la función startEngine del objeto car para arrancar el motor.const myCar: Car = { ... }: Crea un objeto myCar que implementa la interfaz Car. Contiene valores para las propiedades brand, model, year, y la función startEngine. Este objeto representa un coche específico, en este caso, un Toyota Corolla de 2022.drive(myCar);: Llama a la función drive con el objeto myCar como argumento. Esto resulta en la visualización de la información del coche en la consola y la llamada a la función startEngine del objeto myCar.