Crea una cuenta o inicia sesión

¡Continúa aprendiendo sin ningún costo! Únete y comienza a potenciar tu carrera

Shapes

6/28
Recursos

Cada uno de los tipos tiene una forma o estructura en que es representado, esto es mediante sus propiedades. Dentro de TypeScript si dos variables poseen propiedades idénticas aunque sean de distintas interfaces o clases, estas pueden ser asignadas entre sí.

Aportes 37

Preguntas 2

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesión.

Shapes es una forma de comparar dos clases y saber si tienen las mimas propiedades o si una exíste una relacion hijo-padre entre ellas. Por ejemplo, un pediatra es un médico mas no necesariamente un médico debe ser un pediatra

Personalmente creo que el ejemplo usando herencia de clases no es el mas adecuado para ensenar shapes, bueno al menos no es suficiente, un ejemplo que te hara comprenderlo es este:

interface Mamifero{
    cantidad:number
}

interface Comedor{
    comida:string,
    comer():number
}
class Animal implements Mamifero, Comedor{
    comer(): number {
        throw new Error("Method not implemented.");
    }
    cantidad: number;    
    comida: string;


}

class Perro {
    cantidad:number
    comida: string;
    // comer(): number {
    //     throw new Error("Method not implemented.");
    // }
}

let x = new Animal();
let y = new Perro();
x =y; //Error si NO descomentan el metodo comer, es decir si la clase perro no implementa comer
y = x;//Esta asignacion es posible incluso aunque ambos objetos sean instanciados de clases diferentes

Este ejemplo muestra que shapes no esta vinculado a la herencia

Pequeño resumen:
Shapes: son las propiedades que incluye una clase.
El ejemplo que no dio Alan es que una clase hijo posee las shapes de la clase padre por lo tanto:
clase padre = clase hijo no da error

PERO
La clase padre no posee las mismas propiedades de la clase hijo (si es que se añadió otra propiedad) por lo tanto:
clase hijo = clase padre si da error

Excelente explicación, me gusta como el profesor hace siempre un resumen al final del video.

que extensiones usas en vs code?

A mi esto de las shapes me recuerda al casting en Java

Buenas noches, mi aporte:

type Dni = number;
type Height = number;
type Age = number;
type FirstName = string;
type LastName = string;

interface Person {
    height?: Height; // Parametro Opcional
    age: Age;
    firstName: FirstName;
    lastName: LastName;
    dni: Dni;
}

export class CPerson {


    constructor(
        private _dni: Dni,
        private _age: Age,
        private _lastName: LastName,
        private _firstName: FirstName,
        private _height?: Height,
    ) { }


}

class CStudent extends CPerson {
    constructor(dni: Dni, age: Age, firstName: FirstName, lastName: LastName, private _enrollment: string) {
        super(dni, age, lastName, firstName);
    }
}


const person: CPerson = new CPerson(123, 29, 'Alver', 'Grisales');
const student: CStudent = new CStudent(123, 29, 'Alver', 'Grisales', '456');

Creo shapes es la forma de identificar las clasew o interfaces de nuestro sistema y que al mismo tiempo nos permite hacer comparaciones entre objectos para validar si son del mismo tipo.

Yo lo noté como una característica para validar las relaciones que pueden tener las clases... Pero no sobraría un ejemplo un poco más práctico...

Esto lo estoy asociando al Polimorfismo que da cabida a utilizar el principio de Sustitución de Liskov del principio SOLID de la POO.

Utilizaría TS solo para aplicar la programación orientada a objetos

me gustó la clase, muy dinámica y agradable

Otra de las cosas que me di cuenta

Es que me tiraba error al crear la clase con el nombre “Persona” porque ya existe una plantilla con el mismo nombre en el mismo directorio, que es el “interface” que fue creado en la clase anterior. Cabe destacar que los archivos tiene distintos nombres.

Entonces mi conclusión es que TypeScript no se basa tanto en los nombres si no las estructuras.

Aquí podrán encontrar una breve explicación sobre shapes si es que no les quedo muy claro.

https://medium.com/netscape/typescript-its-all-about-the-shape-4142906a881f

Otro ejemplo:

class Persona {

    private nombre: string;
    private dni: string;    
}


class Alumno extends Persona {

    private matricula: string;
}


class Docente extends Alumno {

    private cedula: string;
}


let persona: Persona = new Persona();
let alumno: Alumno = new Alumno();
let docente: Docente = new Docente();


persona = alumno;
persona = docente;

alumno = persona; // Error: Property 'matricula' is missing in type 'Persona' but required in type 'Alumno'
alumno = docente;

docente = persona; // Error: Type 'Persona' is missing the following properties from type 'Docente': cedula, matricula
docente = alumno; // Error: Property 'cedula' is missing in type 'Alumno' but required in type 'Docente'.

Definitivamente saber conceptos es muy fundamental a la hora de programar.

Buenas tardes, si alguien entendió cual es la utilidad de las Shapes y como podriamos usarlas para resolver alguna problema les agradezco su comentario. Entiendo que es una regla de TypeScript para evitar que cometamos el erro de asignar un objeto tipo Persona a Alumno.
Help me please.

En que casos se debería usar shapes ? no creo que solo para una comparación.

Este es el código de la clase.

<code>
class people {
    private edad: number;
    private altura: number;
    private dni: string;

    constructor(edad: number,altura: number, dni:string){
        this.edad = edad;
        this.altura = altura;
        this.dni = dni;
    }
}

class alumno extends people {
    private matricula : string;

    constructor(edad: number,altura: number, dni:string, matricula: string){
        super(edad,altura, dni);
        this.matricula = matricula;
    }
}
let People: people= new people(27,1.43,'343457865');
let Alumno: alumno= new alumno(27,1.43,'343457865', '123');

// shapes es la funcionalidad propia de tupescript

People = Alumno; // toda people no es un alumno
Alumno = People ; // todo alumno es una persona


Aporte el comentario el profesor en un aporte a otro compañero que resume la clase

En resumen un shape habla de la estructura de un tipo y puedes tener más de un tipo con la misma estructura y diferentes nombres en cada uno y Typescript lo toma como uno solo :)

No presté mucha atención a este punto:
Cada uno de los tipos tiene una forma o estructura en que es representado, esto es mediante sus propiedades. Dentro de TypeScript si dos variables poseen propiedades idénticas aunque sean de distintas interfaces o clases, estas pueden ser asignadas entre sí.

Se puede decir que es una implementación del principio SOLID Liskov Substitution?
Porque la clase hija puede ser representada por la clase padre (la clase que extiende o hereda).

class Persona {
    private edad: number;
    private altura: number;
    private dni: string;

    constructor(edad: number, altura: number, dni: string) {
        this.edad = edad;
        this.altura = altura;
        this.dni = dni;

    }
}

class Alumno extends Persona {
    private matricula: string;

    constructor(edad: number, altura: number, dni: string, matricula: string) {
        super(edad, altura, dni);
        this.matricula = matricula;

    }
}
let persona: Persona = new Persona(27, 1.69, '36601731');
let alumno: Alumno = new Alumno(27, 1.69, '36601731', '123');

Qué usos tiene esta propiedad?

Si es un poco raro, no conocía está funcionalidad

<class Persona {
    private edad: number;
    private altura: number;
    private dpi: string;

    constructor(edad: number, altura: number, dpi: string){
        this.edad = edad;
        this.altura = altura;
        this.dpi = dpi;
    }
}

class Alumno extends Persona{
    private matricula: string;

    constructor(edad: number, altura: number, dpi: string, matricula: string){
        //super para utilizar el constructor del padre
        super(edad, altura, dpi);
        this.matricula = matricula;
    }
}

let persona: Persona = new Persona(36, 1.70, '56454646546');
let alumno: Alumno = new Alumno(36, 1.70, '56454646546','123');

//Shapes es una forma de comparar dos clases y saber si tienen las mismas propiedades o si existe una relacion hijo-padre entre ellas.

//todo alumno es una persona
persona = alumno;
//No todas las personas son alumnos (matricula no esta en persona)
alumno = persona;>

Pueden utilizar un modulo de npm llamado parcel-bundler para ver sus resultados en la consola del navegador: npm i parcel-bundler --save. Este modulo permite que puedas poner archivos ts en tu tag “script” de html:

<script src=“index.ts”></script>```
y luego ejecutan el script: parcel index.html desde consola y veran la magia😁

let persona: Persona = new Persona(‘Christian’, ‘Sánchez’,14702, 1.85);
let alumno: Alumno = new Alumno(‘Christian’, ‘Sánchez’,14702, 1.85, 61711968);

persona = alumno

console.log(‘Todos los alumnos son personas?’, persona === alumno)
// Output: true```

Cada uno de los tipos tiene una forma o estructura en que es representado, esto es mediante sus propiedades. Dentro de TypeScript si dos variables poseen propiedades idénticas aunque sean de distintas interfaces o clases, estas pueden ser asignadas entre sí.

En java el concepto es Boxing y Unboxing

Lo veo como polimorfismo y no tanto como un concepto nuevo (shape)

Pienso que me puede servir en algún proyecto de alta complejidad

Y las shapes en que me podrían ayudar?

shapes es útil a la ora de hacer pruebas de jerarquía rápidas.

las propiedades del padre no calzan con las del hijo.

Muy lógico el porqué de las shapes.

Dentro de TypeScript si dos variables poseen propiedades idénticas aunque sean de distintas interfaces o clases, estas pueden ser asignadas entre sí.

interface figura {
    ancho: number,
    alto: number
}

interface forma {
    ancho: number,
    alto: number
}

class Plano {
    ancho: number;
    alto: number;

    constructor(ancho: number, alto: number) {
        this.alto = alto;
        this.ancho = ancho;
    }
}

let cuadrado: figura = {
    ancho: 10,
    alto: 10,
}

let rectangudo: forma = {
    ancho: 20,
    alto: 10,
}

let cuadradoObjeto = new Plano(10, 10);

cuadrado = rectangudo; // Ok
rectangudo = cuadrado; // Ok
cuadradoObjeto = cuadrado; // Ok
cuadradoObjeto = rectangudo; // Ok
cuadrado = cuadradoObjeto; // Ok
rectangudo = cuadradoObjeto // Ok

polimorfismo?

Interesante, en un principio me decía pues claro que no va a funcionar la variable alumno es de tipo Alumno, pero si la propiedad que los diferencia es agregada a la clase Persona ya no existirá el error, pero no es esto peligroso ?, claro , después de todo para que no envíe ningún error las clases han de ser iguales o por lo pronto similares, pero si le estoy especificando el tipo creo que no debería de permitir esa asignación sin por lo menos algo determinante, quizás una función inbuilt assignShape(ClaseA, ClaseB), que connote y de crédito al proceso …