Brutal mucho mas POO!!
Por eso es mejor usar interface
Introducción
¿Ya tomaste el Curso de Fundamentos de TypeScript?
Configuración del proyecto con ts-node
New Types
Tuples
Enums
Unknown type
Never type
Funciones
Parámetros opcionales y nullish-coalescing
Parámetros por defecto
Parámetros rest
Sobrecarga de funciones: el problema
Sobrecarga de funciones: la solución
Interfaces
Interfaces
Estructuras complejas
Extender interfaces
Propiedades de solo lectura
Proyecto
Ejemplo de CRUD
Omit y Pick Type
Partial y Required Type
Readonly Type
Acceder al tipado por indice
ReadonlyArray
Próximos pasos
Toma el Curso de Programación Orientada a Objetos con TypeScript
No tienes acceso a esta clase
¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera
Si ya tienes una cuenta,
No se trata de lo que quieres comprar, sino de quién quieres ser. Invierte en tu educación con el precio especial
Antes: $249
$209
Paga en 4 cuotas sin intereses
Termina en:
12 Días
14 Hrs
57 Min
5 Seg
Extender interfaces
14/22Recursos
En TypeScript, la herencia en interfaces permite crear una interfaz nueva basada en otra interfaz existente, heredando sus propiedades y métodos.
Herencia de interfaces en TypeScript
Utilizamos la palabra clave extends para aplicar la herencia en interfaces. Veamos un ejemplo:
interface Animal {
nombre: string;
comer(): void;
}
interface Mascota extends Animal { // 👈 Herencia de interfaces
// Hereda la propiedad `nombre` y el método `comer()` de la interfaz `Animal`
jugar(): void;
}
class Perro implements Mascota {
nombre: string;
constructor(nombre: string) {
this.nombre = nombre;
}
comer() {
console.log(this.nombre + " está comiendo.");
}
jugar() {
console.log(this.nombre + " está jugando.");
}
}
const miPerro = new Perro("Firulais");
miPerro.comer(); // "Firulais está comiendo."
miPerro.jugar(); // "Firulais está jugando."
En el ejemplo, declaramos una interface llamada Animal con un atributo nombre y un método comer(). Después, implementamos otra llamada Mascota que extiende la interfaz Animal y agrega un nuevo método con el nombre jugar(). La clase Perro implementa la interfaz Mascota, por lo que no solo debe implementar el método jugar(), sino también el atributo nombre y el método comer() que fueron heredados de la interfaz Animal en la interfaz Mascota.
Contribución creada por: Martín Álvarez (Platzi Contributor).
Aportes 16
Preguntas 2
Ordenar por:
Les comparto mis apuntes. 😄
¿Qué es extender interfaces?
Es básicamente la herencia como funciona en la programación orientada a objetos.
Diferencia con type
Al usar interfaces podemos aplicar herencia, pero esto no ocurre con type.
Sintaxis
interface InterfaceFather { statements }
interface InterfaceChild extends InterfaceFather { statements }
Pueden usar la crypto.randomUUID() para crear randoms id, es nativo así que no tienen que instalar nada.
const data: Product = {
id: crypto.randomUUID(),
title: "Camisa LaCoste",
stock: 90,
size: "L",
createdAt: new Date(),
updatedAt: new Date(),
category: {
id: crypto.randomUUID(),
name: "Camisa",
createdAt: new Date(),
updatedAt: new Date(),
},
};
Dejo un ejemplo de como extender un type.
Herencia en interfaces
Así como las clases en POO, en las interfaces también podemos hacer uso de la herencia. De esta forma podemos tener una interface base que sea heredada por todas las demás interfaces en la app. Funciona de la siguiente manera
interface BaseModel {
id: string | number;
createdAt: Date;
updatedAt: Date;
}
interface User extends BaseModel {
name: string;
lastName: string;
}
Para no poner la ruta relativa en el import podemos activar la configuración path del tsconfig.json y asignarle alias a las carpetas.
.
Aquí un ejmplo:
tsconfig.json
....
"paths": {
"@app/*": ["./src/app/*.ts"],
"@categories/*": ["./src/app/categories/*"],
"@products/*": ["./src/app/products/*"],
"@users/*": ["./src/app/users/*"],
"@orders/*": ["./src/app/Orders/*"]
},
....
}
Con esa configuración pasamos de importar así:
import { Category } from "./../categories/category.model"
A importar así:
import { Category } from "@categories/category.model"
Que poderoso. Esto lo veo mucho en el código de la empresa en la que trabajo.
no olvidar que podemos usar los parámetros opcionales en las inerfaces para aquellas interfaces que heredan y no necesiten fechas.
No había podido entender bien este concepto cuando lo estudié en Java. Ahora si me quedó mucho más claro
TS es otro nivel, sin duda alguna.
El type también es extensible:
type Tipo01 = {
nom: string,
age: number
}
type Tipo02 = Tipo01 & {
fec: Date;
}
let tipo02: Tipo02 = { nom: “Pedro”, age: 24, fec: new Date() };
BaseModel es un modelo abstracto. Al final este modelo no tendrá una representación en la base de datos, solo servirá como estructura para definir y agrupar aquellas propiedades que se heredarán al modelo que la extiende.
Este curso es espectacular!
Ahora la estructura de carpetas y los archivos se ven mucho más legibles, mantenibles y profesionales.
Que bueno fue ver las clases de fundamentos de Bases de Datos, para entender cada una de las carpetas que crea el profe. Las veo como “Entidades” y digamos que extensiones serían como claves foraneas (o algo parecido). Se que es muy rebuscado pero me ayudo un montón.
Herencia es decir que una clase recibe de otra clase. Quiere decir que una clase X obtiene los mismos métodos y propiedades de la clase Z. Permitiendo de esta forma añadir a las características heredadas de Z las suyas propias.
¿Quieres ver más aportes, preguntas y respuestas de la comunidad?