No tienes acceso a esta clase

隆Contin煤a aprendiendo! 脷nete y comienza a potenciar tu carrera

Extender interfaces

14/22
Recursos

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 1

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

Brutal mucho mas POO!!

Por eso es mejor usar interface

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 }

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

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(),
  },
};

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

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"

El type tambi茅n es extensible:

type Tipo01 = {
nom: string,
age: number
}
type Tipo02 = Tipo01 & {
fec: Date;
}
let tipo02: Tipo02 = { nom: 鈥淧edro鈥, 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.

TS es otro nivel, sin duda alguna.

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 鈥淓ntidades鈥 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.