Introducción al curso

1

¡Alto! Tenemos una nueva versión de este curso para ti

2

Bienvenidos al Curso de Fundamentos de JavaScript

3

Repositorio de este curso de fundamentos de JS

Primeros pasos en JavaScript

4

Variables

5

Variables: Strings

6

Variables: Números

7

Funciones

8

El alcance de las funciones

9

Objetos

10

Desestructurar objetos

11

Parámetros como referencia o como valor

12

Comparaciones en JavaScript

Estructuras de Control y Funciones

13

Condicionales

14

Funciones que retornan valores

15

Arrow functions

16

Estructuras repetitivas: for

17

Estructuras repetitivas: while

18

Estructuras repetitivas: do-while

19

Condicional múltiple: switch

Arrays

20

Introducción a arrays

21

Filtrar un array

22

Transformar un array

23

Reducir un array a un valor

Programación Orientada a Objetos en JavaScript

24

Cómo funcionan las clases en JavaScript

25

Modificando un prototipo

26

El contexto de las funciones: quién es this

27

La verdad oculta sobre las clases en JavaScript

28

Clases en JavaScript

Asincronismo

29

Funciones como parámetros

30

Cómo funciona el asincronismo en JavaScript

31

Cómo funciona el tiempo en JavaScript

32

¿Qué pasó con swapi.co?

33

Callbacks

34

Haciendo múltiples requests

35

Manejando el Orden y el Asincronismo en JavaScript

36

Manejo de errores con callbacks

37

Promesas

38

Promesas Encadenadas

39

Múltiples promesas en paralelo

40

Async-await: lo último en asincronismo

Juego de HTML

41

Comenzando el juego

42

Generando una secuencia de números

43

Iluminando la secuencia de colores

44

Obteniendo el input del usuario

45

Agregando la verificación del color elegido

46

Agregando los estados finales del juego

47

Conclusiones del curso

Complementos

48

Diferencias entre var, let y const

49

Memoización: ahorrando cómputo

50

¿Hace cuántos días naciste?

51

Funciones recursivas

52

Entiende los closures de JavaScript

53

Estructuras de datos inmutables

54

Cambiando de contexto al llamar a una función

55

¿Cuándo hace falta poner el punto y coma al final de la línea?

No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Clases en JavaScript

28/55
Recursos

Las clases de JavaScript son introducidas en el ECMAScript 2015 y son una mejora en la sintaxis sobre la herencia basada en prototipos de JavaScript.

La palabra clave extends se usa en declaraciones de clase o expresiones de clase para crear una clase que es hija de otra clase.

El método constructor es un método especial para crear e inicializar un objeto creado a partir de una clase.

Aportes 430

Preguntas 77

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

APORTE

No es necesario agregar el constructor a la clase Desarrollador para utilizar el constructor de la clase Persona, el constructor de la clase Persona también se hereda y puedes ejecutar sus atributos en la clase Desarrollador como si estuvieras en la clase Persona.

EJEMPLO:

class Persona{

    constructor(nombre, apellido, estatura){
        this.nombre = nombre;
        this.apellido = apellido;
        this.estatura = estatura;
    }

    saludar(){
        console.log(`Hola mi nombre es ${this.nombre} ${this.apellido} y mi estatura es de ${this.estatura}m.`);
    }

    soyAlto(){
        returnthis.estatura>1.8;
    }
}

class Desarrollador extends Persona{

    saludar(){
        console.log(`Hola mi nombre es ${this.nombre} ${this.apellido}, mi estatura es de ${this.estatura}m y soy desarrollador.`);
    }

}

var persona = new Persona('Enrique','Nieto',1.81); // Aquí soy persona
var desarrollador = new Desarrollador('Enrique','Nieto',1.81); // Aquí soy desarrollador


persona.saludar();
desarrollador.saludar();

Utilizaría el constructor en la clase Desarrollador solo para hacer algunas modificaciones o agregar atributos nuevos.

EJEMPLO:

class Persona{

constructor(nombre, apellido, estatura){
    this.nombre = nombre;
    this.apellido = apellido;
    this.estatura = estatura;
}

saludar(){
    console.log(`Hola me llamo ${this.nombre} ${this.apellido} y mi estatura es de ${this.estatura}`);
}

soyAlto(){
    returnthis.estatura>1.8;
}
}

class Desarrollador extends Persona{

constructor(nombre, apellido, estatura, tiempo){

    super(nombre,apellido,estatura);

    this.nombre_desarrollador = nombre; // Atributo heredado nombre guardado en un atributo nuevo.
    this.apellido_desarrollador  = apellido; // Atributo heredado apellido guardado en un atributo nuevo.
    this.estatura_desarrollador  = estatura; // Atributo heredado estatura guardado en un atributo nuevo.

    this.tiempo_de_desarrollador = tiempo; // Nuevo atributo
}

saludar(){
    console.log(`Hola me llamo ${this.nombre_desarrollador} ${this.apellido_desarrollador}, mi estatura es de ${this.estatura_desarrollador}m, soy desarrollador y tengo ${this.tiempo_de_desarrollador} años de desarrollador`);
}

}

var persona = new Persona('Enrique','Nieto',1.81); // Aquí soy persona
var desarrollador = new Desarrollador('Enrique','Nieto',1.81,10);; // Aquí soy desarrollador


persona.saludar();
desarrollador.saludar();

Sorry por repetir tanto las palabras pero es para que se entienda más fácil y claro.

Excelente clase y curso. ES6 nos facilito las cosas pero me encantó que nos hubieran explicado antes cómo funcionan realmente las cosas por debajo. Gracias equipo Platzi

Vaya esto si que es bonito no que la otra cochinada de prototipos xd

Un pequeño resumen de este tema :
Las clases en JavaScript son introducidas en el ECMASCRIPT 2015

Aquí hay que resaltar que por más que se ponga la palabra class por detrás de todo esto siempre se tratará de prototipos

En este ejemplo se creará la clase y en la misma irá el constructor, lo que anteriormente estaba en una función personas va de la siguiente manera

class Persona{
  constructor(nombre, apellido, altura) {
  this.nombre = nombre;
  this.apellido = apellido;
  this.altura = altura;
  }
}

Luego se crea la clase Desarrollador que va a heredar de la principal Persona, en este caso se utilizará la palabra extends

class Desarrollador extends Persona {
  constructor(nombre, apellido, altura) {
    this.nombre = nombre;
    this.apellido = apellido;
    this.altura = altura;
  }
  saludar() {
    console.log(
      `Hola, me llamo ${this.nombre} ${this.apellido} y soy desarrollador`
    );
  }
}

Sin embargo aquí nos generará un error y es que para heredar de forma correcta se debe utilizar la palabra super quedando así

class Desarrollador extends Persona {
  constructor(nombre, apellido, altura) {
    super(nombre, apellido, altura);
  }
  saludar() {
    console.log(
      `Hola, me llamo ${this.nombre} ${this.apellido} y soy desarrollador`
    );
  }
}

Super Apuntes:
![](

Una vez más dejo mis aportes aquí:

Excelente clase!
5 Fredys 👨‍🏫👨‍🏫👨‍🏫👨‍🏫👨‍🏫

Uy que descanso!!! La clase anterior fue confusa pero !!!Gracias ES6 por llegar¡¡¡*

En la clase pasada me asusté pero ya estoy bien jaja saludos x2

Que hermoso! es bueno ser desarrollador justo cuando ya existen estas nuevas features

En la clase pasada me asusté, pero ya estoy bien x2 😄

CLASES EN JAVASCRIPT
A partir del año 2015 JavaScript se fue actualizando año tras año, por eso vamos a encontrar diferentes versiones con ecmaScript 2015, ecma script 2016,2017,2018 y próximamente 2019 que es esto de ecma script, es el standard en el que se basa javascript para conformarse como lenguaje quiere decir que son todas las funcionalidades que trae el lenguaje, por ende esta nueva facilidad del lenguaje nos trae lo mismo que hicimos las clases pasadas pero de una manera distinta y mas simple, lo que no debemos olvidar es que por debajo siguen siendo todos prototipos, por más que utilizamos la palabra class que hace referencia a clase, por debajo todo es un prototipo.
Dicho esto, tomaremos el ejemplo de la clase pasada y borraremos la función que creamos como puente, ya no la vamos a necesitar y la function “persona” la vamos a escribir de otra manera;

class persona {
    constructor persona(nombre,apellido,altura) {
        this.nombre = nombre
        this.apellido = apellido
        this.altura = altura
       }
}

De esta manera estamos diciendo que va a existir la clase persona y que va a tener un método llamado constructor que es el que se va a ejecutar cuando creemos objetos de esta clase, además podemos añadirle las funciones que queremos que posea esta clase dentro de la misma, de la siguiente manera;

class persona {
    constructor(nombre,apellido,altura) {
        this.nombre = nombre
        this.apellido = apellido
        this.altura = altura
       }

saludar() {
    console.log(`Hola, me llamo ${this.nombre} ${this.apellido}`)
}

soyAlto() {
    return this.altura >= 1.80
}
}

Con esto lo que hacemos es encerrar las funciones que teníamos antes en una clase, de una manera mas sencilla y menos confusa al momento de hacer un código extenso, queda mas prolijo, probamos en la consola, creamos un objeto y con la clase persona y probamos las funciones, verificamos que estas mismas sirvan y verificado esto, psamos a lo siguiente, que seria crear la otra clase que va a heredar de esta, es decir la clase hija.
De manera que:

class Desarrollador extends persona {
constructor(nombre, apellido, altura) {
    this.nombre = nombre
    this.apellido = apellido
    this.altura = altura
}
    saludar(){
        console.log(`Hola, me llamo ${this.nombre} ${this.apellido} y soy desarrollador`)
    }

}

Observemos bien este código, con el creamos la clase “Desarrollador” ¿Qué hacemos para que este tenga herencia de la clase persona? Fijarte bien en la palabra “extends” al colocarla, le estamos indicando a la clase, que va a ser una extencion de la clase que le nombremos siguiente “extends” en este caso, “persona”, agregamos el constructor y agregamos las funciones, para luego pasar a la consola.
¿Qué pasa aca? Pues al fijarnos en la consola, nos da un error, esto es debido a que esta extensión aun no posee acceso a “this” y es por lo siguiente:

class Desarrollador extends persona {
constructor(nombre, apellido, altura) {
    super(nombre,apellido,altura)
}
    saludar(){
        console.log(`Hola, me llamo ${this.nombre} ${this.apellido} y soy desarrollador`)
    }

}

La función debe ser escrita de la siguiente manera porque no podemos utilizar “this” hasta llamar al constructor de la clase padre y para hacer esto debemos utilizar la palabra super y le pasamos, el nombre, apellido y la altura y nos olvidamos de ponerlo abajo, y ese constructor no hará más nada, podría hacer otra cosa si quisiéramos, pero no lo hace porque no se le hemos dicho. Ahora si podemos acceder a “this”, grabamos y probamos en la consola creando los objetos y usamos las funciones de la manera en la que lo hicimos las clases pasadas y probamos hacerlo con sus respectivos nombres de clases y probar sus funciones.
Cabe destacar que podemos analizar el objeto en la consola y al igual que anteriormente nos dirá quien es el constructor, cuales son las clases superiores, y las funciones que posee y las que puede heredar.

una clase súper importante, dejo por acá mi aporte, agregando un if else si es mujer o hombre.

class Persona{
    constructor(nombre, apellido, sexo, estatura){
    this.n = nombre;
    this.a = apellido;
    this.s = sexo;
    this.e = estatura;
}
    saludar(){
        console.log(`Hola, mi nombre es ${this.n} ${this.a} y mi estatura es de ${this.e} metros`);
    }
    soyAlto(){
        return this.e >= 1.70;
    }
}

class desarrollador extends Persona {
    constructor (nombre, apellido, sexo, estatura){
        super(nombre, apellido, sexo, estatura)
    }
    saludar(){
        if(this.s === mujer){
            console.log(`Hola, mi nombre es ${this.n} ${this.a}, y soy desarrolladora`);
        }
        else if(this.s === hombre){
            console.log(`Hola, mi nombre es ${this.n} ${this.a}, y soy desarrollador`);
        }
    }
}

var hombre = "Hombre";
var mujer = "Mujer";

var alex = new Persona ("Alex","Rubio", "Hombre", 1.80);
var eliza = new Persona ("Elizabeth","Nureña", "Mujer", 1.70);

var Alex = new desarrollador ("Alex","Rubio", "Hombre", 1.80);
var Eliza = new desarrollador ("Elizabeth","Nureña", "Mujer", 1.70);

Resumen de la clase
Class

A partir del 2015 el lenguaje de javascript se fue actualizando año tras año.
Hay varias versiones ECMA-Script2015, ECMA-Script2016, ECMA-Script2017, etc.
ECMA-Script es el standar en el que se basa javascript para conformarse como lenguaje.
Esta nueva actualización del lenguaje trae una actualización para hacer lo que hicimos (herencia prototipal) de una forma mucho más sencilla.
Usaremos el keyword ‘class’ pero no dejan de ser prototipos.

Definimos la variable persona de acuerdo a ECMA-Script 2015 entonces:

class Persona {
	constructor(nombre, apellido, altura, genero){
		this.nombre = nombre
		this.apellido = apellido
		this.altura = altura
		this.genero = genero
	}
	saludar(){
		console.log(`Hola me llamo ${this.nombre} ${this.apellido}`)
	}
	soyAltX(){
		var altX = this.genero == 'masculino' ? 'alto' : 'alta'
		var string = this.altura >= 1.8 ? `Soy ${this.nombre} ${this.apellido} y definitivamente soy ${altX}.` 
										: `Soy ${this.nombre} ${this.apellido} y no, no soy ${altX}.`
		console.log(string)
	}
}

Y definimos el prototipo ‘Desarrollador’ con su ‘herencia’:

class Desarrollador extends Persona {
	constructor(nombre, apellido, altura){
		super(nombre, apellido, altura) // super llama los atributos del padre
	}
	saludar(){
		console.log(`Hola, me llamo ${this.nombre} ${this.apellido} y soy desarrollader.`)
	}
}

Le faltó explicar que las clases que heredan, no solo heredan los constructores, tambien heredan los metodos y pueden probarlo asi:

class Desarrollador extends Persona {

constructor(nombre,apellido,altura,peso){
    super(nombre,apellido,altura) //super llama al constructor de la clase padre
    this.peso=peso;//atributo adicionado a la clase desarrollador
}

}

var persona3 = new Desarrollador(‘Shiina’,‘Mashiro’,1.8,45.5);

persona3.saludar(); //utilizando metodo creado en la clase padre

Para que se entienda mejor la utilidad de “super”, os puedo pasar este ejemplo de como se puede utilizar para inicializar el constructor de Desarrollador, pero añadiendo un parámetro extra:

class Desarrollador extends Persona{

    constructor(nombre,apellido,altura,lenguaje){
        super(nombre,apellido,altura);
        this.lenguaje = lenguaje;
    }
    saludar(){
        console.log(`Hola, soy ${this.nombre} ${this.apellido} y soy desarrollador`);
    }
}

Como verán puse un nuevo parámetro llamado “lenguaje” en el que por ejemplo puedo poner el lenguaje en el que se especializa el desarrollador, en el constructor como quiero definir ese atributo nuevo llamado “lenguaje” sin volver a crear un constructor para los parámetros que hereda “Desarrollador” entonces uso “super” para reciclar el constructor de Persona, pero luego uso:

this.lenguaje = lenguaje;

Para añadir el nuevo atributo a desarrollador, luego cuando cree a la persona sacha como un objeto “Desarrollador”, le puedo poner los atributos anteriores (nombre, apellido, altura) y el nuevo atributo “lenguaje” dentro de los parámetros:

var sacha = new Desarrollador("Sacha","Lifszyc",1.85,"Javascript");

ECMAScript 2015, también conocida como ECMAScript 6 es la versión en la cual se incluyeron las clases en el lenguaje.
Hay actualizaciones en los años 2016, 2017, 2018 y la última 2019 es la versión 10.

Llevaba aplazando este curso mucho tiempo. Quizá por el miedo y asco que me dejo la programación en la Universidad. Platzi me ha cambiado y salvado la vida.

Ahora sí parece un poco a Java

WAOOOOO!!, entender las ‘clases’ de JS fue mucho mas sencillo que aprender el ‘prototype’, en verdad entiendo de que debemos como desarrolladores de JS entender de donde provienen las cosas y como funcionan; pero en verdad me gusto conocer lo anterior antes de venir a las ‘clases’, creo que de una u otra manera se me hizo sencillo entenderlas. GRACIAS PLATZI y SACHA.

Les dejo un artículo con todo lo nuevo en ECMAScript 2016, 2017 y 2018.

Que gran diferencia a la clase pasada jajaj no había entendido bien. Pero con esta clase todo me quedo más claro

Pos en esta si entendí. No deberían enredarnos con la anterior clase… jajajajaja…
He programado clases en Java y en C#, y algo había visto con Javascript, por eso estaba tan perdido y no me creía que sería tan difícil en Javascript.

Para los que se pregunten que hace “super”, super llama al constructor de la clase extendida, en este caso el constructor de la clase Persona. Es por eso que como parámetros recibe el nombre, apellido y altura, ya que son los parámetros que se necesitan para crear un objeto de clase Persona.

Me encanta el curso!!!
Aquí pongo mi codino, lo escribo con un caso diferente para practicar, además agregue una nueva propiedad y un nuevo método a la segunda clase que hereda de la primera para hacer pruebas y todo perfecto.
Muchas gracias por todo lo que estoy aprendiendo con vosotros!!!

const miSeries = ["Power Rangers", "Lady Bag"];
const misPeliculas = ["tadeo Jones", "Hotel Transilvania"];
const miColegio = {
  nombre: "Hispano Ingles",
  ciudad: "Santa Cruz de Tenerife",
  tipo: "Conecrtado"
};

class Alum {
  constructor(nombre, edad, series, peliculas, colegio) {
    this.nombre= nombre;
    this.edad = edad;
    this.series = series;
    this.peliculas = peliculas;
    this.colegio = colegio;
  } 

  saludar() {
    return `Hola, soy ${this.nombre}`
  }

  miColegio() {
    return `Soy ${this.nombre} y mi colegio es el ${this.colegio.nombre} en ${this.colegio.ciudad}`
  }
}

class AlumConComedor extends Alum {
  constructor(nombre, edad, series, peliculas, colegio, vegetariano) {
    super(nombre, edad, series, peliculas, colegio);
    this.vegetariano = vegetariano;
  }

  saludar() {
    return `Hola, soy ${this.nombre} y tengo el comedor incluido`
  }

  queComiHoy() {
    return `Soy ${this.nombre} y hoy comi de todo!`
  }
}

const alumno = new Alum("Juanito", 5, miSeries, misPeliculas, miColegio);
const alumnoConComedor = new AlumConComedor("Angel", 5, miSeries, misPeliculas, miColegio, "No");```

Mucho más sencillo que el método de la clase anterior.

Mejor que la antigua forma!!!

Para qué crea de nuevo una clase Desarrollador con los mismos parámetros del constructor Persona se supone que deberíamos heredarlos de Persona?
No queda más limpio el código así:

class Persona {
  constructor(nombre, apellido, altura) {
    this.nombre = nombre
    this.apellido = apellido
    this.altura = altura
  }
  saludar() {
    console.log(`Hola, me llamo ${this.nombre} ${this.apellido}`)
  }
  soyAlto() {
    return this.altura > 1.8
  }
}

class Desarrollador extends Persona {
  saludar() {
    console.log(`Hola, me llamo ${this.nombre} ${this.apellido} y soy desarrollador/a`)
  }
}

Yo solo necesito un método que me salude un desarrollador ahora si quiero implementar mi propio constructor (lenguajes, años de experiencia, etc…) en mi clase Desarrollador Ahí si utilizo super pero de resto creo que sería innecesario.

en el lenguaje de java existe el “polimorfismo” que es que un metodo (o funcion) actue de manera distintas dependiendo del objeto que la llame…no se comento en el video pero es lo que se aprecia con el metodo “saludar()”, si lo invoca una persona pasa algo y si lo invoca un desarrollador pasa otra cosa

No maaaanches! No me imagino la vida cruel de los que no tenían ES6

Esto es lo que vivimos haciendo cuando creamos un componente en React js

En la clase pasada me asuste pero ya estoy bien jaja saludos xD

Es importante que en las clases siempre vayan en mayúscula en la primera letra para así poder diferenciarlas de las funciones

RESUMEN:

El siguiente resumen corresponde al modulo 5 de POO-JS, posee notas personales y ejercicios adaptados de clases vistas.

Adjunto el código y las notas. Y también postearé una pregunta en la sección a quien pueda asistirme. Gracias


//______________________________Clases______________________________________//
//Objetos son prototipos y no tanto clases. En las clases de JS no existen la herencia. 
// En esta clase verems comos e mofician las clases de herencias. JS funciona con una estructura orientada a objeto y cada bjeto tiene una propiedad privada que mantiene un enlace a otro objeto llamado prototipo.
// Es importanten entender dónde o en qué parte del código se colocan las funciones modificadas del prototipo.
//Es importante poner todas las funcioens del prototipo juntas. al prnicpio para que todas las funciones estén accesiles a los objetos que vayamos creando.



function identidad (nombre,apellido,altura){
    this.nombre=nombre
    this.apellido=apellido
    this.altura=altura
}

function desarrollador (nombre,apellido,altura){
    this.nombre=nombre
    this.apellido=apellido
    this.altura=altura
}

///La verdad oculta sobre las clases en JavaScript
//Los objetos en JavaScript son “contenedores” dinámicos de propiedades. Estos objetos poseen un enlace a un objeto prototipo. Cuando intentamos acceder a la propiedad de un objeto, la propiedad no sólo se busca en el propio objeto sino también en el prototipo del objeto, en el prototipo del prototipo, y así sucesivamente hasta que se encuentre una propiedad que coincida con el nombre o se alcance el final de la cadena de prototipos.
// La forma apra que la herencia prototipal se de es la siguiente:/Se escribe una propia.

function heredaDe (prototipoHijo, prototipoPadre){
    var fn = function(){} //Función dummy, anínima, o función noop, que no hacen nada.
    fn.prototype ; prototipoPadre.prototype// Esa función la volvemos un objeto fn cuyo prototype lo llamamos como padre. prototype.
    prototipoHijo.prototype = new fn // Finalmente creamos un nuevo objeto de fn, para que así herede protipoHijo.
    //Asignamos constructora funcion
    prototipoHijo.prototype.constructor =prototipoHijo

}

//JS no soporta la herencia no hay clases hay prototipos que son objetos que les agregamos métodos  que reciben funciones, saben quien es this y saben como ejecutarlas.
//Existe la herencia prototipal. Se crea un prototipo "hijo" n subtipo de persona.
// Le decimos este prototipo hijo que entienda algo, si no lo encuentra en sí, va a ir a padre, y así.. escalando hasta object,  sin olo encuentra JS dice que no se peude ejectuar este método.


heredaDe(desarrollador,identidad)

//PROTOTIPOS_PADRE

identidad.prototype.saludar =function() {
    console.log( `Hola, me llamo ${this.nombre} ${this.apellido}`)
}

// Estas funciones se peucdel volver arrow Function.

identidad.prototype.soyAlto =function(){
   
    return console.log(this.altura >79)

} 

//PROTOTIPO_HIJO
desarrollador.prototype.saluda = function () {
    console.log(`Mi nombre es ${this.nombre} y soy científico de datos`)
}
    
//Errores comunes, this no es quien dice ServiceUIFrameContext, suele ser window.saludar
//El this dentro de la función apunta al objeto. This en el espacio global apunta a wundow, el navegador.

//----->identidad.prototype.soyAlto =()=> this.altura > 79 // Esto me arroja un error. Ya que  al ser nombrado por fuera de manera global no es reconocido.

var etrx =new identidad ('Etrx' ,'123',78)
var menfis =new identidad ('Menfis' ,'543',80)
var alejandro =new identidad ('Alejandro' ,'5056',89)
var pepe =new desarrollador ('Etrx' ,'Develop',78)


etrx.saludar()
alejandro.soyAlto()
etrx.saludar()
pepe.saluda()


/////////Clases en JavaScript////////////
//Las clases de JavaScript son introducidas en el ECMAScript 2015 y son una mejora en la sintaxis sobre la herencia basada en prototipos de JavaScript.La palabra clave extends se usa en declaraciones de clase o expresiones de clase para crear una clase que es hija de otra clase.El método constructor es un método especial para crear e inicializar un objeto creado a partir de una clase. Por debajo todo es un prototipo.

class elemento { // Se ejectua cuando creemos objetos de esta clase.
    constructor (nombre, masa_atomica, electronegatividad){
        this.nombre =nombre
        this.masa_atomica =masa_atomica
        this.electronegatividad=electronegatividad
    }
    crear(){
        console.log(`Estoy juntando protones para crear al ${this.nombre}`)
    }

    electro(){
        console.log(`Estoy midiendo su electronegatividad: ${this.electronegatividad}`)
    }

    
}

class formaCristalina extends elemento { // asi se herdan las clases.
    constructor (nombre, masa_atomica, electronegatividad){ // Hay que llamar al constructor de la clase padre para poder usarse
        super(nombre, masa_atomica, electronegatividad)
        
    }
    moldear(){
        console.log(`Estoy moldeando la materia para ${this.nombreCristalina}`)
    }

}
var manganeso =new elemento('Manganeso','No registra','No se sabe')
var manganeso =new formaCristalina('Pirita','Centrado en las caras')
 

del cielo a la tierra la clase anterior a esta, excelente clase

Tome notas de las clases de POO hasta este punto, están por Ramas, por si a alguién le interesa. (Tome esta sección de nuevo haciendo notas y el código para entenderlo mejor)

Link Github

Se entiende mas la herencia con clases.

Haciendo la prueba me doy cuenta que no es necesario enviarle todos los argumentos a la función super(). Si mi clase Desarrollador no tiene los mismo atributos que mi clase Persona, de igual manera funciona, sin embargo, si en mis métodos de la clase necesito uno de esos parámetros el valor va a ser undefined.

El mejor invento del 2015 del Team Js. ¡Graciaasssssss!

Super() es una función que hace referencia al constructor de la clase padre, en este caso “Persona”.

5. Clases en JavaScript

He quedado maravillado, puede ser sintax sugar, sin embargo, la legibilidad para mí es un 1500% más fácil de entender si lo escribo con class, constructor y extend. Esto de usar prototype tal vez de más liberdad, pero a la vez hace mucho más complejo el código.

Les comparto el código de la clase:

//Esta es la función constructora para una clase en JS
class Persona {
    constructor(nombre, apellido, altura) {
        this.nombre = nombre;
        this.apellido = apellido;
        this.altura = altura;
    }
    saludar() {
        console.log(`Hola, me llamo ${this.nombre} ${this.apellido}.`);
    }
    soyAlto() {
        return this.altura > 1.8;
    }
}
class Desarrollador extends Persona {
    constructor(nombre, apellido, altura) {
        super(nombre, apellido, altura);
    }
    saludar() {
        console.log(`Hola, me llamo ${this.nombre} ${this.apellido} y soy Desarrollador`);
    }
}

//Aquí creamos un nuevo objeto con el prototipo de "persona",
//la cual es una función constructora
// var sacha = new Persona('Sacha', 'Lifszyc', 1.72);
// var erika = new Persona('Erika', 'Luna', 1.85);
// var arturo = new Persona('Arturo', 'Martinez', 1.69);
// sacha.saludar();
// erika.saludar();
// arturo.saludar();

// sacha.soyAlto();
// erika.soyAlto();
// arturo.soyAlto();

Y sí, dejo el momo porque en el fondo, sé que son lo mismo:

Si yo quiero, agregar otro constructor a parte del que ya extiende de Persona, se hace asi:

class Desarrollador extends Persona {
        constructor(nombre, apellido, altura, genero) {
      super(nombre, apellido, altura);
      this.genero = genero
        }
        saludar() {
          console.log(
            `Hola, me llamo ${this.nombre} ${this.apellido} mi genero es ${this.genero} y soy desarrollador`
          );
        }
      }

las funciones prototipo se convierten en clases

 class Persona{}

Y la herencia se genera usando la palabra reservada extends

class Desarrollador extends Persona{}

Lo importante es que al crear la herencia, el constructor hijo debe llamar al constructor superior es decir usar la función super() pasandole los parámetros que sean necesarios para la clase padre.

class Desarrollador extends Persona{
	constructor(nombre,apellido,altura)
	super(nombre,apellido,altura)
}

Las funciones ahora van dentro de la clase y no llevan la palabra clave function

 class Persona{
	//constructor

	saludar(){
		//console.log("hola")
	}
}

Creo que son los puntos mas esenciales que se explicaron en la clase

No puedo creer lo sencillo que es utilizar clases comparado con los prototipos naturales de la clase anterior.

Así recordaba la herencia 😅

es casi igual que las clases en java… y aquí rompiéndome la cabeza con el anterior video xD

aaaah que alivio, menos mal se apiadaron de nosotros y redefinieron el lenguaje para clases porque esto de los prototypes ya me estaba comenzando a dar ganas de llorar jajajaja.

Posiblemente no tenga mucho que ver con el curso, pero qué base de datos es recomendable usar si se desea implementar javascript?

Olviden el otro video, este es mas claro y actualizado.

En el minuto 6:20:

Si no vamos a agregar ningún nuevo atributo a nuestra clase Desarrollador, ¿es necesario de todos modos volver a llamar al constructor?

Me percate que si solo dejamos la declaración de la clase asÍ de todos modos hereda los atributos y se puede pisar la función

class Developer extends Person {
    greet () {
        console.log(`Hi, my name is ${this.name} ${this.lastname} and I'm a developer`)
    }
}

Excelente clase.

Por fin sintaxis familiar ❤❤

?Muy parecido a la herencia en Java.

Genial!! Al fin todo entendido!

Al provenir de Java esta sintaxis es un alivio, pero no hay que olvidar que en js no existen las clases como tal. corrijan si me equivoco, pero los objetos en js no son mas prototipos

Modifiqué el ejercicio anterior y adicionalmente le agregué un parametro adicional al desarrollador en su constructor, para realizar una diferencia del super.

Esta sintaxis! 👌

Comparacion entre las dos forma de poder escribir la “clase” persona.

//Dos formas de crear clases (prototipos) en js

// Forma 1

function persona(nombre, edad,altura){ //............................Aqui se crea el prototipo
    this.nombre = nombre                  
    this.edad = edad                     
    this.altura = altura               
}

persona.prototype.saludar = function(){ //   ........................Aqui creamos el metodo saludar
    console.log(`Hola mi nombre es ${this.nombre}`)
}

var raul = new persona('raul','22','1.80')//.......................Aqui creamos un nuevo objeto persona, donde
//                                                        le pasamos los parametros de nombre, edad y altura


// Forma 2

class persona { // .......................Aqui se crea la clase persona en realidad prototipo
    constructor(nombre,edad,altura){ //.....................Se crea el constructor
        this.nombre = nombre                                              
        this.edad = edad                                               
        this.altura = altura                                           
    }                                                          
     saludar(){ //.........................................Se crea el método saludar
         console.log(`Hola mi nombre es ${this.nombre}`)            
     }                                                             
}

var raul = new persona('raul','22','1.80') // De igual manera creamos
//																						 un objeto persona, donde
//                                            le pasamos los parametros de nombre,
// edad y altura

//En la forma 2 se crea la clase persona que en realidad sigue siendo un prototipo, se crea el constructor
// con la palabra constructor y dentro de las llaves que abarca persona se crean los metodos ya sin la necesidad
//de escribir la palabra function```

Esta clase me inspiro demasiado. Por tanto, si alguien no logra entender dejo este código debidamente documentado para poder ayudar a la comprensión del tema.

// ES6 trae consigo la definición de clases. Sin embargo, detrás de bambalinas es un wrapper para crear prototipos de JS. Es decir, solo es azucar sintáctico para que los desarrolladores que vienen desde otros lenguajes les sea mas sencillo trabajar el paradigma de orientación a objetos en JS.



// Definicion del cuerpo de la clase Persona
class Persona {
    // Definición del método constructor para inicializar las propiedades de dicha clase
    constructor(nombre, apellidos, altura, edad) {
        // El contexto de this es el propio objeto instanciado de esta clase
        this.nombre = nombre
        this.apellidos = apellidos
        this.altura = altura
        this.edad = edad
        // El estado inicial de un objeto puede declararse de forma dura, es decir, todos los objetos instanciados de esta clase tendrán al inicio el mismo valor para esta propiedad
        this.saldo = 200
    }

    // Definición de metodos (acciones) para esta clase
    saludar() {
        console.log(`Hola, me llamo ${this.nombre} ${this.apellidos}`)
    }

    tieneEstaturaAlta() {
        if (this.altura > 1.8) {
            console.log(`${this.nombre} es de estatura alta`)
        } else {
            console.log(`${this.nombre} es de estatura baja a media`)
        }
    }

    // Ejemplo de metodo setter
    setSaldo(saldo) {
        this.saldo += saldo
        console.log(`${this.nombre}, gracias por tu recarga. Tu saldo ahora es de $ ${this.saldo.toFixed(2)}`)
    }

    consultarSaldo() {
        console.log(`${this.nombre}, tu saldo es de $ ${this.saldo.toFixed(2)}`)
    }
}



// ES6 también trae consigo el concepto de herencia entre clases. Sin embargo, recordar que en JS no existe como tal, siempre se trabaja con prototipos, y la unica herencia que existe es la herencia prototipal.
class Desarrollador extends Persona {
    constructor(nombre, apellidos, altura, edad, titulo, tecnologias) {
        // Una clase que extiende de otra, esta obligada a invocar al constructor de su clase padre con el método super. Así como pasarle los parámetros necesarios para que esta se pueda inicializar
        super(nombre, apellidos, altura, edad)
        // La clase hija puede aumentar su propio estado, es decir, tener otras propiedades sumadas a las que extiende
        this.titulo = titulo
        this.tecnologias = tecnologias
    }

    // Sobre-escritura
    // Funciona igual que en otros lenguajes de programación, basta con redefinir nuevamente alguno de los metodos definidos en la clase padre
    saludar() {
        console.warn(`Hola, soy ${this.nombre} ${this.apellidos} y soy ${this.titulo}`)
    }

    // La clase hija puede definir sus propias acciones o metodos
    mostrarTecnologias() {
        console.log(`${this.nombre} tiene experiencia en las siguientes tecnologías: ${this.tecnologias.join(', ')}`)
    }
}


// Crear un objeto de la clase Persona
var alejandro = new Persona('Alejandro', 'González Reyes', 1.72, 34)
// Crear un objeto de la clase Desarrollador
var daniel = new Desarrollador('Daniel', 'Osorno Medina', 1.87, 39, 'Ingeniero en Sistemas', ['base de datos', 'redes', 'sistemas de gestión empresarial'])


console.log(alejandro)
console.log(daniel)

// El método saludar difiere en ambos casos, ya que se sobre-escribió en la clase Desarrollador
alejandro.saludar()
daniel.saludar()

// los metodos tieneEstaturaAlta se comportan de manera similar. Recordar que la clase Desarrollador hereda este metodo de la clase Persona
alejandro.tieneEstaturaAlta()
daniel.tieneEstaturaAlta()

alejandro.consultarSaldo()
daniel.consultarSaldo()

alejandro.setSaldo(299)
daniel.setSaldo(477.50)

// El objeto daniel es de tipo Desarrollador, por tanto, tiene el metodo mostrarTecnologias.
daniel.mostrarTecnologias()
const ALTURA_ALTA = 1.80;

class Persona {
    constructor(nombre, apellido, altura) {
        this.nombre = nombre;
        this.apellido = apellido;
        this.altura = altura;
    }
    saludar(){
        console.log(`Hola me llamo ${this.nombre} ${this.apellido}`);
    }

    soyAlto() {
        console.log(`${this.altura >= ALTURA_ALTA ? 'Soy Alt@': 'No soy Alt@'}`);
    }
}

class Desarrollador extends Persona {
    constructor(nombre, apellido, altura, alias) { // aqui podemos pasar otros argumentos al constructor
        super(nombre, apellido, altura); // Que pueden no ser parte del constructor de la clase padre
        this.alias = alias; // entonces en esos casos si podemos usar this en el constructor de la clase hija
    }
    saludar() {
        console.log(`Hola me llamo ${this.nombre} ${this.apellido} y soy desarrollador`);
    }
}

var elias = new Persona('Elias', 'Medina', 1.90);
var erika = new Persona('Erika', 'Luna', 1.56);
var arturito = new Desarrollador('Arturo', 'Gil', 2.00, 'Arturito');

elias.saludar();
elias.soyAlto();
erika.saludar();
erika.soyAlto();
arturito.saludar();
arturito.soyAlto();
console.log(arturito.alias);
class Persona {
  constructor(nombre, apellido, altura) {
    this.nombre = nombre;
    this.apellido = apellido;
    this.edad = 20;
    this.altura = altura;
  }

  saludar() {
    console.log(`Hola, me llamo ${this.nombre} ${this.apellido}`);
  }

  shortOrTalllto() {
    if (this.altura >= 1.80) {
      console.log(`${this.nombre} es alto`);
    } else {
      console.log(`${this.nombre} es bajo`);
    }
  }
}

class Desarrollador extends Persona {
  constructor(nombre, apellido, altura) {
    super(nombre, apellido, altura);
  }

  saludar() {
    console.log(`Hola, me llamo ${this.nombre} ${this.apellido} y soy un desarrollador`)
  }
}

let steven = new Desarrollador('Steven', 'Coaila');
let erika = new Persona('Erika', 'Luna', 1.54);
let arturo = new Persona('Arturo', 'Martines', 1.84);

<class Persona{
  constructor(nombre,apellido,altura){
    this.nombre = nombre
    this.apellido = apellido
    this.altura = altura
  }

  saludar(){
    console.log(`Hola, me llamo ${this.nombre} ${this.apellido}`)
  }

  soyAlto(){
    return this.altura > 1.8
  }
}

class Desarrollador extends Persona{
  constructor(nombre,apellido,altura,especialidad){
    super(nombre,apellido,altura)
    this.especialidad = especialidad
  }

  saludar(){
    console.log(`Hola, me llamo ${this.nombre} ${this.apellido} y soy Desarrollador de ${this.especialidad}`)
  }
}

var per1 = new Persona("Juan","Perez",1.72)
var per2 = new Persona("Ana","Matos",1.65)
var per3 = new Persona("Alberto","Nuñez",1.85)
var des1 = new Desarrollador("Daniel","Ramirez",1.83,"Java")
var des2 = new Desarrollador("Katty","Echevarria",1.53,"Python")>
class Person{
    constructor(name){
        this.name = name
    }
    say_hi() {
        console.log(`Hello i am ${this.name}`)
    }
}

class Developer extends Person{
    constructor(name){
        super(name)
    }
    say_hi() {
        console.log(`$(i).am( ${this.name} )`)
    }
}


const a = new Person("cesar");

const b = new Developer("cesar");

a.say_hi();
b.say_hi();```

Genial que en la clase anterior (a pesar de ser confusa) explican lo que hay de fondo sobre este tema en JS pero en esta se enseña una manera mucho más entendible y fácil para aplicarlo.

Gracias a los comentarios, me salté la clase anterior, entendí bien esta, y volví a la anterior. Y la comprendí más facilmente, no sin antes compadecerme de nuestros antepasados lol

class Persona {
  constructor(nombre, apellido, altura) {
    this.nombre = nombre
    this.apellido = apellido
    this.altura = altura
  }

  saludar() => {
    console.log(`Hola, me llamo ${this.nombre} ${this.apellido}.`)
  }

  soyAlto() {
    this.altura >= 1.80
  }
}

class Desarrollador extends Persona {
  constructor(nombre, apellido, altura) {
    super(nombre, apellido, altura)
    /*
    this.nombre = nombre
    this.apellido = apellido
    this.altura = altura

    No se pueder usar el 'this' hasta no haber llamado con 'super' a la clase madre.

    */
  }

  saludar() {
    console.log(`Hola, me llamo ${this.nombre} ${this.apellido} y soy desarrollador/a.`)
  }
}
```le pongo car sasha = new Persona ...............
Y despues sasha.saludar(), y no funciona.

Entonces, las arrow functions no funcionan dentro de la clase?

muy bueno me salio a la primera, pero me pase estudiando el prototipo anterior

Hay que tener en cuenta que cuando heredamos, automáticamente los atributos del padre se convierten en datos indispensables para la construcción del hijo, pero el hijo puede tener atributos propios mas los que se heredan del padre. Por eso en el proceso de construcción de el hijo, los atributos se le pasan a la clase correspondiente, un ejemplo:

class Persona {
    constructor(nombre, apellido, altura){
        this.nombre = nombre;
        this.apellido = apellido;
        this.altura = altura;
    }
    saludar () {
        console.log(`Hola, me llamo ${this.nombre} ${this.apellido}`);
    }
    soyAlto () {
        const ALTURA_MINIMA = 1.8;
        return this.altura > ALTURA_MINIMA;
    }

}
class Desarrollador extends Persona {
    constructor(nombre, apellido, altura, profesion){
        super(nombre, apellido, altura);
        // Este es una tributo propio de la clase hija
        this.profesion = profesion;
    }
    saludar () {
        console.log(`Hola, me llamo ${this.nombre} ${this.apellido} y soy ${this.profesion}`)
    }
}

var desarrollador = new Desarrollador('Daniel', 'Reyes', 1.89, 'Quimico')

Ahora si quedó claro!

console.log(' -- Clases en JavaScript --\n');

class Persona{
    constructor(nombre, apellido, altura){
        this.nombre = nombre
        this.apellido = apellido
        this.altura = altura
    }
    saludar(){
        console.log(`Hola, me llamo ${this.nombre} ${this.apellido} y mido ${this.altura}`);
    }
    soyAlto(){
        return this.altura >= 1.70
    }
}
class Desarrollador extends Persona{
    constructor(nombre, apellido, altura){
        super(nombre, apellido, altura)
    }
    saludar(){
        console.log(`Hola, me llamo ${this.nombre} - ${this.nombre} y soy desarrollador.`);
    }
}

buena tarde

me permito compartir mis aportes

class persona {
  constructor(nombre, apellido,altura) {
    this.nombre = nombre
    this.apellido = apellido
    this.altura = altura

    }

    saludar() {
      console.log(`Hola, me llamo ${this.nombre} ${this.apellido}`)
    }

    soyalto() {
      return this.altura>1.8
    }
}

class Desarrollador extends persona {
constructor (nombre,apellido, altura) {
  super(nombre, apellido, altura)
  
}

saludar () {
console.log (`Hola, me llamo ${this.nombre} ${this.apellido} y soy desarrollador/a`)
}

}

Si quisieramos que además de que extienda Desarrollador a Persona, podemos hacer que su constructor tenga más atributos, para ésto podemos acceder a la variable this desde el constructor.

por ejemplo:

class Desarrollador extends Persona{
    constructor(nombre, apellidos, altura, edad, tecnologias) {
        super(nombre, apellidos, altura, edad)
        this.tecnologias = tecnologias
    }
}

Entendido al 100% !!!

año 2015.Bendito

Aunque internamente en el lenguaje son prototipos, la forma de escribirlo como una clase es muy fácil de leer y entender. Sobre todo la herencia.

Hice esta clase yo creo que ayuda a entender un poco el concepto de herencia como podemos heredar funciones pero también atributos y agregar nuevos

class Persona{
    constructor(nombre,apellido,altura){
        this.nombre=nombre
        this.apellido=apellido
        this.altura=altura
     }
     saludar(){
        console.log(`Hola me llamo ${this.nombre} ${this.apellido}`)

     }
     soyalto(){

        return this.altura>1.8

     }
    }

class Desarrollador extends Persona{
    constructor(nombre,apellido,altura){
        super(nombre,apellido,altura)
        this.develop='desarrollador'
     }
     saludar(){
        console.log(`Hola me llamo ${this.nombre} ${this.apellido} y soy ${this.develop}`)

     }
}





var javier = new Desarrollador('Javier','Fuentes',1.64)

Cuando escribes en consola 
imprimira algo como esto
Hola me llamo Javier Fuentes y soy desarrollador

Que alivio que ahora podemos usar clases, ya que en la clase anterior se vió que el metodo antiguo era bastante complejo y enredado.

Quedate en tu casa paparulo 😃

Muchisimo mas claro, excelente explicación.

Dale a me gusta si llegaste aquí buscando entender bien Angular y Typescript , y de repente viste un cachito de un componente 😃

Herencia con ECMAScript

Después de entender y sufrir un poco con la Herencia prototipal a secas, es hora de hacerlo todo mucho más facil con ECMAScript.

  • Crear una clase : es tan sencillo como darle nombre y declarar el constructor
class Jugador {
 constructor(nombre,puntaje){
	this.nombre = nombre
	this.puntaje = puntaje
}
  • crear métodos : dentro de la clase deberán ir todos los metodos que este pueda llegar a necesitar
class Jugardor {
 constructor(nombre,puntaje){
	this.nomber = nombre
  this.puntaje = puntaje
}
saludar() {
 console.log(`Soy ${this.nombre} y saqué ${this.puntaje} pts`)
}
}
  • Extender una clase de otra : Ahora digamos que queremos crear una clase JugadorExperto que tenga los mismos parametros de Jugador, más un abritudo tiempoDeJuego:
class JugadorExperto{
	constructor(nombre,puntaje,tiempoDeJuego){
	super(nombre,puntaje,tiempoDejuego)
}

lo que hace super es superponer el constructor de JugadorExperto por sobre el constructor de la clase original Jugador

  • Pisar métodos de clase padre : es tan simple como declararla con el mismo nombre pero con una funcionalidad distinta
<code>
class JugadorExperto{
	constructor(nombre,puntaje,tiempoDeJuego){
	super(nombre,puntaje,tiempoDejuego)
}
saludar(){
console.log(`Soy ${this.nombre},un Jugador Experto ! `)
}
  • y Listo ! : ya tenemos nuestras dos clases con parametros heredamos y métodos distintos

Excelente clase.

// Herencia ECMASCRIPT
// Crear un subtipo de persona (desarrollador)

class Persona {
  constructor(nombre, apellido, altura) {
    this.nombre = nombre
    this.apellido = apellido
    this.altura = altura
  }

  saludar() {
    console.log(`Hola, me llamo ${this.nombre} ${this.apellido}. ${this.soyAlto()}.`)
  }

  soyAlto() {
    return this.altura > 1.8 ? 'Soy alt@' : 'Soy baj@'
  }
}

class Desarrollador extends Persona {
  constructor(nombre, apellido, altura) {
    super(nombre, apellido, altura)
  }

  saludar() {
    console.log(`Hola, me llamo ${this.nombre} ${this.apellido} y soy desarrollador.`)
  }
}

let sacha = new Persona('Sacha', 'Lifszyc', 1.72)
sacha.saludar()
// Hola, me llamo Sacha Lifszyc. Soy baj@.
let arturo = new Desarrollador('Arturo', 'Martinez', 1.89)
arturo.saludar()
// Hola, me llamo Arturo Martinez y soy desarrollador.

Por acá dejo mi código:


const HEIGHT_LIMIT = 1.8;

class Person {

    constructor (name, lastName, height) {
        this.name = name;
        this.lastName = lastName;
        this.height = height;
    }

    hi () {
        console.log(`Hi, I am ${this.name} ${this.lastName}`);
        this.tall();
    }

    tall () {
        if (HEIGHT_LIMIT < this.height) {
            console.log(`My height is ${this.height} mts, I am tall`);
        } else {
            console.log(`My height is ${this.height} mts, I am small`);
        }
    }
}

class Developer extends Person{

    constructor(name, lastName, height) {
        super(name, lastName, height)
    }

    hi () {
        console.log(`Hi, I am ${this.name} ${this.lastName} and I am a Developer`);
        this.tall();
    }
}

var erika = new Person("Erika", "Luna", 1.65);
var sacha = new Developer("Sacha", "Lifszyc", 1.83);

erika.hi();
sacha.hi();

Muy buena clase la verdad nunca había entendido este concepto hasta ahorita 😄

Muy buena explicación, muchas gracias por facilitar el conocimiento con prácticas sencillas.

woooooo! pero que excelente clase y muy simplificada
Comparto mis notas.

**ECMAScript **: Es el estnadar en el cual se vasa JavaScript para conformarse como lenguaje, es decir que **son todas las funcionalidades que contiene el lenguaje **.

En JavaScript aunquew se utilice la palabra clave _ class_ por debajo sigue siendo un prototipo.

Me es super facil entender esta forma de trabajar con las “clases” y “herencia” en Javascript

La palabra reservada super llama al constructor de la clase padre

Mucho mejor, estaba perdido con la clase anterior, pero con esta explicación entendí mejor

class Persona{
    constructor(nombre, apellido, edad, altura){
        this.nombre = nombre
        this.apellido = apellido
        this.edad = edad
        this.altura = altura
    }
    
    Saludar(){
    return console.log('Hola soy ${this.nombre} ${this.apellido} y tengo ${this.edad}')
    }
    
    esAlto(){
        if (this.altura > 1.8) {
            return console.log("${this.nombre} es alto")
        }
        else {
            return console.log("${this.nombre} es bajo")
        }

    }
}
class Desarrollador extends Persona{
    constructor(nombre, apellido, edad, altura){
        super(nombre, apellido, edad, altura)

    }
}
var valeria = new Desarrollador("Valeria", "Blandon", 18, 1.7)
var sebastian = new Persona("Sebastian", "Corrales", 20, 1.8)
sebastian.Saludar()
sebastian.esAlto()

valeria.Saludar()
valeria.esAlto()

syntactic sugar 🧁🧁

Buen código, entendiendo la clase anterior, esta es una forma más simplificada de crear prototipos llamados ahora clases.

Este es el código que el explica mejor sobre la herencia basada en prototipos de JavaScript.

//Herencia prototiparia: es llamada asi debido a que un prototipo llamado hijo
//puede heredar los atributos de un pototipo llamado Padre

// podemos desarrollar una clase (NO OLVIDAR QUE SON PROTOTIPOS)
class persona {
  constructor(nombre, apellido, altura){ //Se ccrea el prototipo
    this.nombre = nombre
    this.apellido = apellido
    this.altura = altura
  }
  saludar(){ // EN LA CLASE SE PUEDE PONER O REALIZAR FUNCIONES DE MANERA MAS CENCILLA
    console.log(`Hola!, me llamo ${this.nombre} ${this.apellido}`)
  }

  soyAlto(){ // EN LA CLASE SE PUEDE PONER O REALIZAR FUNCIONES DE MANERA MAS CENCILLA
    return this.altura >= 1.8
  }
}

//PARA QUE UNA CLASE EREDE DE OTRA CLASE
class desarrollador extends persona {
  constructor(nombre, apellido, altura) {
    super(nombre, apellido, altura) //hereda las atributos de persona
  }

  saludar(){
    console.log(`Hola!, me llamo ${this.nombre} ${this.apellido} y soy desarrollador`)
  }
}

Es casi igual a Java! jaja me encanta!

Muy buena mejora a la herencia prototipal, se ve mucho más legible.

//ECMAScript es el estandar de lenguaje para JS.
/*aunque vamos a usar la palabra class, no debemos olvidar que todo es un prototipo*/

class Persona {
    //metodo constructor de la clase Persona
    constructor(nombre, apellido, altura) {
        //propiedades    
        this.nombre = nombre;
        this.apellido = apellido;
        this.altura = altura;
    }
    //metodos
    saludar() {console.log(`Hola! soy ${this.nombre} ${this.apellido}`)}
    esAlto() { return this.altura > ALTURA;}
}
//definimos la constante de altura para comparar
const ALTURA = 1.8;
//usamos la palabra extends para indicar que Desarrollador hereda de Persona
class Desarrollador extends Persona {
    //metodo constructor de Desarrollador
 constructor(nombre,apellido,altura,edad) {
     //usamos la palabra super para llamar al constructor de la clase padre, y le pasamos los parametros
     super(nombre,apellido,altura);
     //si quiero agregar propiedades que no estan en el padre, las declaro aca con this.
     this.edad = edad;
}
//pisamos el metodo saludar de Persona.
saludar() {console.log(`Hola, me llamo ${this.nombre} ${this.apellido} y soy desarrollador`)};
}

La POO es de lo mejor que le ha pasado a la programación🤐

Un código con advertencia de spoilers para Juego de Tronos:

console.log('ADVERTENCIA: ESTE CODIGO CONTIENE SPOILRES DE JUEGO DE TRONOS')

class Personaje {
  constructor  (nombre, apellido, edad, estatura, dragonesdeOro)
    {
      this.nombre = nombre
      this.apellido = apellido
      this.edad = edad
      this.estatura = estatura
      this.riqueza = dragonesdeOro
    }
  esAltoAlta ()
    {
      if (this.estatura>2.05) console.log('Es gigante')
        else if(this.estatura>1.95) console.log('Es muy alto')
          else if(this.estatura>1.85) console.log('Es alto- alta');
            else if(this.estatura<1.4) console.log('Es enano')
              else if(this.estatura<1.6) console.log('Es bajita')
                else console.log('Normal');
    }
  saluda ()
    {
      if (this.nombre=="Hodor") console.log('Hodor!')
        if(this.nombre=="Sandor") console.log('Yo soy el perro, you f#$&% c#$%, de la casa: do I look like a give a f%$@#');
          else  console.log('Hola, mi nombre es ' + this.nombre + ' de la casa ' + this.apellido);
    }
}

class PersonajeMuerto extends Personaje{
  constructor  (nombre, apellido, edad, estatura, dragonesdeOro, comoMurio, encualTemporada)
    {
      super (nombre, apellido, edad, estatura, dragonesdeOro)
      this.muerte=comoMurio
      this.ultimaTemporada=encualTemporada
    }
    comoMuere ()
      {
          if (this.nombre=="Hodor") console.log('Hodor!')
            else console.log('Yo, '+this.nombre+', muero ' + this.muerte + ', pero alcance a llegar a la '+ this.ultimaTemporada+' temporada');
      }

}

var tyrion =   new Personaje ( "Tyrion",   "Lannister", 49, 1.35,    10000)
var brienne =  new Personaje ( "Brienne",  "de Tarth",  40, 1.91,        5)
var sansa =    new Personaje ( "Sansa",    "Stark",     23, 1.75,   500000)

//ADVERTENCIA, SIGUEN LOS SPOILRES DE JUEGO DE TRONOS

var khaleesi = new PersonajeMuerto  ( "Daenerys", "Targeryen", 32, 1.57, 10000000, 'asesinada por el novio- sobrino','última')
var cersei =   new PersonajeMuerto  ( "Cersei",   "Lannister", 44, 1.68,  1000000, 'en brazos de mi novio- hermano aplastada por las ruinas del palacio','última')
var laMontaña =new PersonajeMuerto  ( "Gregor",   "Clegane",   30, 2.06,        5, 'luchando contra mi hermano al caer del palacio','última')
var elPerro =  new PersonajeMuerto  ( "Sandor",   "Clegane",   50, 1.98,      0.1, 'luchando contra mi hermano- zombi al caer del palacio, you C#&$*','última')
var jaime=     new PersonajeMuerto  ( "Jaime",    "Lannister", 48, 1.87,        0, 'en brazos de mi novia- hermana aplastado por las ruinas del palacio','última')
var hodor =    new PersonajeMuerto  ( "Hodor",    "",          43, 2.13,     0.01, 'Hodor!', 'Hodor!')
var ned =      new PersonajeMuerto  ( "Ned",      "Stark",     60, 1.79,   600000, 'triste e inesperadamente', 'primera')```