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

Cómo funcionan las clases en JavaScript

24/55
Recursos

Las clases son funciones cuya sintaxis tiene dos componentes:

  • expresiones
  • declaraciones

En esta clase veremos el uso de this. Dentro de una función, el valor de this depende de cómo es llamada ésta.

Reto: agrega el atributo altura y la función soyAlto.

Aportes 1607

Preguntas 90

Ordenar por:

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

Una corrección: los valores que se le da al constuctor a la hora de crear un objeto (en la línea del new), se le conoce como argumentos; mientras que los valores que se le da al constructor a la hora de definirlo (en la línea del function), se le conoce como parámetros.

Los parámetros vendrían a ser como una especie de esqueleto, en la cual da a entender qué valores se le puede dar a la hora de ponerlos en los argumentos.

notas curso: Fundamentos de JavaScript - Un saludo compañeros de Platzi

¿Quieres tener unos apuntes organizados para repasar en un futuro lo que estás aprendiendo en este curso? Práctica mucho, porque los apuntes ya los he hecho.

Aquí mis aportes y mi reto completado👍😁

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

persona.prototype.saludar = function(){
    if(this.altura >= 1.80){
        console.log(`Hola, me llamo ${this.nombre} ${this.apellido}, tengo ${this.edad} años y mi altura es ${this.altura} y soy alto`)
    }
    else{
        console.log(`Hola, me llamo ${this.nombre} ${this.apellido}, tengo ${this.edad} años y mi altura es ${this.altura} y no soy alto`)
    }
}

var sacha = new persona('Sacha', 'Lifszyc', 28, 1.80)
var sebastian = new persona('Sebastián', 'Mera', 17, 1.76)
var carolina = new persona('Carolina', 'Bonilla', 17, 1.74)

    sacha.saludar()
    sebastian.saludar()
    carolina.saludar()

Tambien podemos declarar las funciones directamente en el “constructor” del prototipo:

function Persona( nombre, apellido, altura){
    this.nombre = nombre,
    this.apellido = apellido,
    this.altura = altura
    this.esAlto = function () {
        if (this.altura >= 1.8) {
            console.log(`${this.nombre} es alto`)
        } else {
            console.log(`${this.nombre} no crecio lo suficiente`)
        }
    }
}```

Además del reto le añadí un condicional para cambiar el genero gramatical de la palabra dependiendo del sexo

function Persona(nombre, apellido, edad, sexo, alt) {
    this.nombre = nombre;
    this.apellido = apellido;
    this.edad = edad;
    this.sexo = sexo;
    this.altura = alt
}

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

Persona.prototype.soyAlto = function() {
    wordAlto = (this.sexo === "femenino") ? "alta" : "alto";
    wordBajito = (this.sexo === "femenino") ? "bajita" : "bajito";
    if(this.altura > 1.79) {
        console.log(`Soy ${wordAlto}! mido ${this.altura}.`);
    } else {
        console.log(`Soy ${wordBajito}! mido ${this.altura}.`);
    }

}

let naza = new Persona("Nazareno", "Altamiranda", 22, "masculino", 1.97);
let ceci = new Persona("Cecilia", "Ocampo", 19, "femenino", 1.69);
let guille = new Persona("Guillermo", "Estevez", 25, "masculino", 1.79); 

naza.saludar();
naza.soyAlto();
ceci.saludar();
ceci.soyAlto();
guille.saludar();
guille.soyAlto();

Aqui esta mi solucion al reto, me gusta usar la toma de decisiones con ? :

function Persona(nombre, apellido, altura) {
  this.nombre = nombre;
  this.apellido = apellido;
  this.altura = altura;
}
Persona.prototype.esAlto = function() {
  this.altura >= 1.8
    ? console.log(`Hola me llamo ${this.nombre} ${this.apellido}, y soy alto`)
    : console.log(
        `Hola me llamo ${this.nombre} ${this.apellido}, y NO soy alto`
      );
};

var omar = new Persona("omar", "hernandez", "1.8");
omar.esAlto();```

Muy bien, lo de Persona() sería el objeto o modelo del cual se crean:

  • Los this.parametro -> Atributos del objeto (el this es porque nombre = nombre crearía conflicto).
  • Persona.prototype -> Métodos del objeto

Al que le haya gustado que aprenda Programación Orientada a Objetos (POO)

Mi solucion al reto:

function Persona(nombre, apellido, altura) {
  this.nombre = nombre;
  this.apellido = apellido;
  this.altura = altura;
  return this;
}

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

Persona.prototype.soyAlto = function() {
  if (this.altura >= 1.8) {
    return console.log(`Soy ${this.nombre} y soy de estatura alta`);
  } else {
    return console.log(`Soy ${this.nombre} y soy de estatura baja`);
  }
};

var erick = new Persona("Erick", "Vicentin", 1.69);
var melisa = new Persona("Melisa", "Medina", 1.53);
var santiago = new Persona("Santiago", "Duarte", 1.86);
var franco = new Persona("Franco", "Lago", 1.84);

erick.soyAlto();
function Persona(nombre, apellido, altura) {
    this.nombre = nombre
    this.apellido = apellido
    this.altura = altura
}

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

const alturaSuficiente = ({ altura }) => altura > 1.80

Persona.prototype.soyAlto = function() {
    if(alturaSuficiente(this)) {
        console.log(`Mido ${this.altura} por eso soy alto`)
    } else {
        console.log(`Mis ${this.altura} no son suficientes para ser alto`)
    }
}

Trataré de explicar un poco lo comprendido en esta clase sobre las clases.

Funcionan más como prototipo que como clases.
En las nuevas versiones existen las clases , pero no son como tal porque no constan de herencia y todo las características que vemos en otros lenguajes

Su declaración es así

function Persona (nombre,apellido)
{
    this.nombre=nombre
    this.apellido=apellido

}
Aquí retorna **this** pero no es necesario poner la palabra return porque ya está implícita 

this Almacena lo que se le envía a la hora de instanciar el prototipo

var elvis = new Persona('Elvis', 'Moreira')

Al poner la palabra new Se crea un nuevo objeto y se asigna al prototipo que se ejecuta es decir a Persona

Podemos también crear una función que dependa del prototipo persona en este caso que la persona salude

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

Persona.prototype.saludar = function () {
    console.log(`Hola, me llamo ${this.nombre} ${this.apellido} y ${this.soyAlto()} soy alto`)
}

Persona.prototype.soyAlto = function () {    
     return this.altura > 170 ? 'si' : 'no'
}

var vince = new Persona('Pedro', 'Pérez', 160)
var erika = new Persona('Erika', 'Loaiza', 175)
var juan = new Persona('Juan', 'Ramírez', 174)

vince.saludar();
erika.saludar();
juan.saludar();

Esta es la solución al problema planteado en la clase:

function Persona(nombre, apellido, altura) {
  this.nombre = nombre;
  this.apellido = apellido;
  this.altura = altura;
  return this;
}

Persona.prototype.saludar = function () {
  if (this.altura > 1.8) {
    console.log( `Hola me llamo ${this.nombre} ${this.apellido} y soy alto`);
  } else {
    console.log( `Hola me llamo ${this.nombre} ${this.apellido} y soy bajito`);
  }
};

var sacha = new Persona('Sacha', 'Lifszyc', 1.82);
var erika = new Persona('Ericka', 'Luna', 1.64);
var arturo = new Persona('Arutro', 'Gimenez', 1.73);

Cómo podría hacerse que al crear un nuevo objeto este se agregue automáticamente a un array?

Solución al desafío:

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

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

Persona.prototype.soyAlto = function(){
    this.altura > 1.8 ? console.log('Soy alto') : console.log('Soy bajo')
}

var victor = new Persona('Víctor', 'Vázquez',1.7)
victor.saludar()

El reto 😃

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

var alturaMinima= 1.8
Persona.prototype.soyAlto = function(){
    if(this.altura >= alturaMinima){
        console.log(`${this.nombre} ${this.apellido} es alto`)
    } else{
        console.log(`${this.nombre} ${this.apellido} no es alto`)
    }
}

var emmanuel = new Persona('Emmanuel','López', 1.85)
var erica = new Persona('Erica', 'Luna', 1.67)
var sacha = new Persona('Sacha', 'Lifszyc', 1.82)
var arturo = new Persona('Arturo', 'Martinez', 1.79)

emmanuel.soyAlto()
erica.soyAlto()
sacha.soyAlto()
arturo.soyAlto()
const ALTURA_PROMEDIO = 1.80;

function Persona (nombre, apellido, altura) {
    this.nombre = nombre;
    this.apellido = apellido;
    this.altura = altura;
    return this;
}

Persona.prototype.saludar = function () {
    console.log(`Te saluda ${this.nombre} ${this.apellido}`);
}

Persona.prototype.soyAlto = function () {
    console.log(`Hola, soy ${this.nombre} ${this.apellido} y soy ${ this.altura >= ALTURA_PROMEDIO? 'alto' : 'bajo' }`);
}

var oscar = new Persona('Oscar', 'Perez', 1.75);
oscar.saludar();
oscar.soyAlto();

var oscar = new Persona('Sara', 'Perez', 1.85);
oscar.saludar();
oscar.soyAlto();
<code>
const ES_ALTO = 1.80
    
function Persona (nombre, apellido, estatura)
{
    this.nombre = nombre
    this.apellido = apellido
    this.estatura = estatura
}

var soyAlto = ({estatura}) => estatura >= ES_ALTO
Persona.prototype.validaEstatura = function() {
    if(soyAlto(this))
        console.log(`Mi nombre es ${this.nombre} y soy alt@`)    
    else 
        console.log(`Mi nombre es ${this.nombre} y no soy alt@`)
}

var sacha = new Persona ('Sacha', 'Ramos', 1.80 )
var ana = new Persona ('ana', 'Ramos', 1.60 )

// Creamos nuestro prototipo de persona.(Se conoce como función constructora)
function person(name,last_name,height){
    this.name = name
    this.last_name = last_name
    this.height = height
}


// Añadimos o agregamos nuevos objetos a nuestro prototipo
var first_person= new person("Wilmer", "Diaz",1.75)
var second_person= new person("Yuri", "Martinez",1.83)
var third_person= new person("Ammy", "Diaz",1.10)


// Agregando funciones al prototipo creado.
person.prototype.saludar = function(){
    console.log(`Hola me llamo ${this.name} ${this.last_name}`)
}
person.prototype.altura = function(){
    if(this.height > 1.8){
        console.log(`Soy alto`)
    }
    else{
        console.log(`No soy alto`)
    }



//son dos variables distintas, este sera el atributo del objeto (this.nombre) y nombre hara referencia al parametro nombre
function Persona(nombre, apellido, altura){
  this.nombre = nombre;
  this.apellido = apellido;
  this.altura = altura;
}

//dentro del prototipo de persona existira el atributo saldar que sera una funcion
Persona.prototype.saludar = function(){
  console.log(`Hola, me llamo ${this.nombre} ${this.apellido}`);
}

const personaAlta = 1.85;

//funcion que indentifica si la persona es alta
Persona.prototype.validacionAlturaPersona = function(){
  if (this.altura >= personaAlta) {
    console.log(`${this.nombre} es una persona alta`);    
  } else{
    console.log(`${this.nombre} es una persona baja`);
  }
}

//Se crea un nuevo objeto de la clase persona (del prototipo)
var alejandro = new Persona('Alejandro', 'Dubon', 1.85);
var pepe = new Persona('Pepe', 'Ramirez', 1.70);
var andres = new Persona('Andres', 'Iniesta', 1.80);
var zlatan = new Persona('Zlatan', 'Ibrahimovic', 1.98);```

Así quedó el reto:

/* Practica de clase */

//Esta funcion Construye el objeto que sera almacenado en una variable
function Persona(nombre, apellido, altura){
    this.nombre = nombre;
    this.apellido = apellido;
    this.altura = altura;
}

// Invocamos a la funcion que construye el objeto, es necesario new para devolver un objeto
var homer = new Persona('Homer Jay', 'Simpson',1.83); 
var marjorie = new Persona('Marjorie', 'Bouvier',1.72)
var bartholomew = new Persona('Bartholomew Jojo', 'Simpson',1.50)
var lisa = new Persona('Lisa Marie', 'Simpson',1.35)
var margaret = new Persona('Margaret', 'Simpson',0.68)

//Esta es una funcion para cualquier prototipo de la clase persona
Persona.prototype.saludar = function () { 
    console.log(`Hola mi nombre es ${this.nombre}${this.apellido}`)
};

//Esta es una funcion para cualquier prototipo de la clase persona
Persona.prototype.soyAlto = function () { 
    if(this.altura >= 1.7){
        console.log('Soy muy alto para pertenecer a esta familia');
    }else {
        console.log('Soy de la altura promedio de mi familia')
    }
}```
function Persona(nombre, edad, altura){

    this.nombre=nombre
    this.edad=edad
    this.altura=altura
}

Persona.prototype.es_Alto=function(){
    if(this.altura>1.80){
        console.log(`hola me llamo ${this.nombre} y soy alto`)
    }
    else{
        console.log(`hola me llamo ${this.nombre} y no soy alta`)
    }
}

var andres = new Persona("andres",19,1.90)
var mariana= new Persona("mariana",21,1.60)

También podemos crear métodos dentro del prototipo mismo al igual que los atributos:

function Persona(){
	this.saludar = function(){
		console.log(`Hola`);
	}
}

A mi manera se podria decir. Xd

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

persona.prototype.saludar = function(){
    // DE ESTA MANERA DE HACE UN IF EN JS.
    this.altura >= 1.8 ? console.log(`Hola me llamo ${this.nombre} ${this.apellido} y soy alto.`) : //CON ESTOS DOS PUNTO COLOCAMOS EL ELSE.
        console.log(`Hola me llamo ${this.nombre} ${this.apellido} y no soy alto.`);
}```
function Persona (nom, ape, alt) {
	this.nombre = nom
	this.apellido = ape
	this.altura = alt
}

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

Persona.prototype.soyAlto = function () {
  if (this.altura >= 1.80) {
  	console.log("y soy alto") 
  }  else  {
  	 console.log("y soy bajo") 
  }   
}

var rodrigo = new Persona('Rodrigo','Villegas','1.70')

rodrigo.saludar()
rodrigo.soyAlto()
Persona.prototype.esAlto = function () {
    (this.altura >= 1.8) ? console.log('es Alto') : console.log('es bajo');
}

Mi solución al reto:

function Persona(nombre, apellido, altura) {
    //console.log ('Instanciado')
    this.nombre = nombre
    this.apellido = apellido
    this.altura = altura
}

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

Persona.prototype.conAltura = function () {
    if (this.altura > 1.8){
        console.log(`Soy una persona alta`)
    }else{
        console.log(`Soy una persona baja`)
    }
}

var Iraida = new Persona('Iraida','Barreto', 1.50) //crea un nuevo objeto
var Elga = new Persona('Elga','Tito',1.85) //crea un nuevo objeto
Iraida.saludar()
Iraida.conAltura()
Elga.saludar()
Elga.conAltura()

function persona (nombre,apellido,altura){
this.nombre = nombre
this.apellido = apellido
this.altura=altura
}
persona.prototype.soyAlto=function() {

if (this.altura>1.80){
console.log(hola ,me llamo ${this.nombre} ${this.apellido} y soy alto)
}
if (this.altura<=1.80) {
console.log(hola ,me llamo ${this.nombre} ${this.apellido} y soy bajo)
}
}

var sacha = new persona (‘sacha’,‘Liszyc’,1.70)
var erick=new persona(‘erick’, ‘cancino’,1.81)
var uriel=new persona (‘uriel’,‘cancino’,1.68)
erick.soyAlto()
uriel.soyAlto()
sacha.soyAlto()

//el prototipo, se define, definiendo la funcion
//seguido, en los parentesis, se definen los parametros que requieren iniciar una nueva Persona
//luego, lo que esta en el cuerpo de la funcion, es lo que definira a la Persona y es lo que se conoce como CONSTRUCTOR
function Persona(nombre, apellido, altura) {
  this.nombre = nombre //aqui "nombre" es un atributo del objeto que se esta creando
  this.apellido = apellido
  this.altura = altura
}

//esto quiere decir que el prototipo Persona, tiene dentro una funcion llamada saludar y la definimos
Persona.prototype.saludar = function () {
  console.log(`Hola, me llamo ${this.nombre} ${this.apellido} y mido ${this.altura} mts`)
}

//ESTO ES TAREA ------------------------------
Persona.prototype.soyAlto = function () {
  if (this.altura > 1.8) {
  console.log(`Mi nombre es ${this.nombre} y soy alto`)
}//------------------------------------------

//la funcion de arriba se ejecutara cuando creemos nuevas personas:
var lucas = new Persona("Lucas", "Nasich", 1.97)
var erika = new Persona("Erika", "Luna", 1.76)
var arturo = new Persona("Arturo", "Martinez", 1.81 )```
function person(name, lastname, height) {
    this.name = name
    this.lastname = lastname
    this.height = height
}

person.prototype.salute = function() {
    console.log(`Hi, my name is ${this.name} ${this.lastname}`)
}

person.prototype.size = function() {
    if (this.height > 1.80) { 
    console.log('I am tall')
    } else {
        console.log('I am short')
    }
}

let lois = new person('Lois', 'Lane', 1.67)
let liz = new person('Liz', 'Taylor', 1.76)
let george = new person('George', 'Harris', 1.88)

mi pregunta es la siguiente , a la función es alto le pase como parametro this , suponiendo que hace referencia al objeto , el codigo me funciona , mi pregunta es la siguiente , osea que this hace refencia a todo el objeto , yo puedo pasar por parametro un objeto utilizando solo this ?

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

const MEDIA = 1.76

const esAlto = (persona) => persona.altura >= MEDIA

Persona.prototype.esAlto = function(){
    
    if(esAlto(this)){
        console.log(`${this.nombre} es alto`)
    }else{
        console.log(`${this.nombre} es bajo`)
    }

}

var sacha = new Persona('Sacha','Ramirez',1.80)
var miguel = new Persona('Miguel','Echeverry',1.70)
var juan = new Persona('Juan','Echeverry',1.60)


function Persona(nombre, apellido, altura) {
  this.nombre = nombre;
  this.apellido = apellido;
  this.altura = altura
  return this;
}

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

Persona.prototype.soyAlto = function(){
  if(this.altura >= 1.8){
    console.log(`Hola me llamo ${this.nombre} ${this.apellido}, mido ${this.altura}, soy una persona alta`)
  }else{
    console.log(`Hola me llamo ${this.nombre} ${this.apellido}, mido ${this.altura}, soy una persona baja`)
  }

}

var kevin = new Persona('Kevin', 'Acuña', 1.80);
kevin.soyAlto();
function persona(nombre,apellido,altura){
    this.nombre = nombre;
    this.apellido = apellido;
    this.altura = altura;
}

persona.prototype.soyalto = function(){
    if (this.altura >= 1.8){
        console.log(this.nombre + " es alto");
    }
    else {
        console.log(`${this.nombre} no es alto`);
    }
}

var carlos = new persona("Carlos", "Suarez", 1.76);
var pedro = new persona("Pedro", "Villa", 1.82);
var juan = new persona("Juan", "Martín", 1.90);

carlos.soyalto();
pedro.soyalto();
juan.soyalto();
function Persona(nombre, apellido, altura) {
    this.nombre= nombre
    this.apellido= apellido
    this.altura=altura
}

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


Persona.prototype.validarAltura = function(){

    this.altura >179 ? altura=`soy alto`: altura=`soy bajo`
    return altura
}

var alex = new Persona('Alex', 'Moreno', 185)
var ana = new Persona('Ana', 'Leona', 178)
var carlos = new Persona('Carlos', 'Velez', 182)


alex.saludar()
ana.saludar()
carlos.saludar()
function Persona(nombre, apellido, altura) {
  this.nombre = nombre
  this.apellido = apellido
  this.altura = altura
}

Persona.prototype.saludar = function () {
  console.log(`Hola, me llamo ${this.nombre} ${this.apellido}`)
}
Persona.prototype.soyAlto = function () {
  let personaAlta = 1.8;
  if (this.altura >= personaAlta) {
    console.log(`Soy alto/a, mido ${this.altura}`);
  } else {
    console.log(`No soy alto/a, mido ${this.altura}`);
  }
}

var sacha = new Persona('Sacha', 'Lifszyc', 1.70)
var erika = new Persona('Erika', 'Luna', 1.80)
var arturo = new Persona('Arturo', 'Martinez', 1.75)

Mi respuesta al reto:

//(prototype) constructor: persona
function Persona (nombre, apellido, altura) {
  this.altura = altura;
  this.apellido = apellido;
  this.nombre = nombre;
}

Persona.prototype.saludar = function (){ console.log(`Hola, me llamo ${this.nombre} ${this.apellido}`) }
Persona.prototype.soyAlto = function (){ console.log(this.altura >= 170 ? `Me llamo ${this.nombre} ${this.apellido} y soy alto` : `Me llamo ${this.nombre} ${this.apellido} y no soy alto`)};


var Daniel = new Persona('Daniel', 'Vargas', 140);
var Angel = new Persona('Angel', 'Vargas', 170);

Aqui la forma de hacer el reto:

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

Persona.prototype.saludar = function (){
    console.log(`Hola, soy ${this.nombre} ${this.apellido}`)
}

Persona.prototype.soyAlto = function (){
    if(this.altura>=1.8)
        console.log(`Soy Alto, mido ${this.altura}`)
    else
        console.log(`No soy alto, mido ${this.altura}`)
}

var yhonny = new Persona('Yhonny', 'Gil', 1.7)
var pedro = new Persona('Pedro', 'Perez', 1.9)
var jose = new Persona('Jose', 'Gomez', 1.5)

¿Qué es un prototype en JavaScript?
Se trata de un objeto, en JavaScript todos los objetos cuentan con un atributo prototype el cual contiene una referencia hacia otro objeto el cual es un prototipo, en estos prototipos se alberga toda la información común entre todos los objetos que han sido instanciados por este prototipo, de esta manera se evita que cada objeto contenga atributos y métodos redundantes abarcando memoria.

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

Persona.prototype.saludar = function () {
console.log(Hola, me llamo ${this.nombre} ${this.apellido} mido ${this.altura} ${medirAltura(this.altura)})
}

function medirAltura(alt) {
console.log(alt);
if (alt > 1.8) {
return “soy alto”

  }
  return "no soy alto"

}

var sacha = new Persona(‘Sacha’, ‘Lifszyc’, 1.72)
var erika = new Persona(‘Erika’, ‘Luna’, 1.80)
var arturo = new Persona(‘Arturo’, ‘Martinez’, 1.85)

No se pueden declarar las funciones del prototype como arrow functions? Las declare de la sigueinte manera:

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

Persona.prototype.soyAlto = () => this.altura > 1.8

Pero al llamarlas me escribe el mensaje de saludo con nombre y apellido undefined y el soyAlto en falso aunque la condicion se cumpla.

Reto:

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

Persona.prototype.saludar = function () {
  console.log(`Hola, me llamo ${this.nombre} ${this.apellido}`)
}
Persona.prototype.soyAlto = function () {
  console.log(this.altura>1.8?'Soy alto':'Soy bajo')
}

var aaron = new Persona('Aaron', 'Isaacs', 1.65)
var kathe = new Persona('Katherine', 'Benitez', 1.70)
var sacha = new Persona('Sacha', 'Lifzyc', 1.95)

aaron.saludar()
aaron.soyAlto()
kathe.saludar()
kathe.soyAlto()
sacha.saludar()
sacha.soyAlto()

RETO

//Constructor

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

// Metodo para la altura

const esAlto = altura => altura > 1.8

Persona.prototype.height = function(){
    if(esAlto(this.altura)){
        console.log(`Hola, me llamo ${this.nombre}, soy alto`)
    } else {
        console.log(`Hola, me llamo ${this.nombre}, soy baja estatura`)
    }
}

// Creando objetos

var sacha = new Persona('Sacha', 'Lifszyc', 1.82)
var erika = new Persona('Erika', 'Luna', 1,65)
var arturo = new Persona('Arturo', 'Martinez', 1.90)

// Ejecutando métodos

sacha.height()
erika.height()
const SoyAlto = ({altura}) => altura > 1.8?'Soy Alto':'Soy Bajo'

persona.prototype.soyalto = function(){
	console.log(`${SoyAlto(this)}`)
} ```
function Persona(nombre,apellido, altura){
    this.nombre=nombre
    this.apellido=apellido
    this.altura=altura
    return this
}
Persona.prototype.alto=function(){
    if(this.altura>1.80)
        console.log(`Soy ${this.nombre} y soy alto`)
            else console.log(`Soy ${this.nombre} y no soy alto`)
}
var gullermo = new Persona('Guillermo', 'Naranjo',1.70)
var erick= new Persona('Erick', 'Sanchez', 1.81)

Así me quedo el ejercicio

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

Persona.prototype.saludar = function(){
	console.log(`Hola, me llamo ${this.nombre} ${this.apellido}`)
}
Persona.prototype.soyAlto = function() {
	if(this.altura >= 1.80){
       console.log(`Soy una persona alta`)
	}else{
       console.log(`Soy bajo`)
	}
}

var sacha = new Persona('Sacha', 'Lifszyc', 1.80)
var erika = new Persona('Erika', 'Luna', 1.70)
var arturo = new Persona('Arturo', 'Martinez', 1.82)

Propuesta de solución al reto:

// Prototipo de Persona
function Persona(nombre, apellido, altura) {
    this.nombre = nombre
    this.apellido = apellido
    this.altura = altura
}

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

Persona.prototype.soyAlto = function () {
    if (this.altura > 1.8) 
        msg = 'Soy una persona alta!'
    else
        msg = 'Soy una persona baja!'

    return msg
}

var sacha = new Persona('Sacha', 'Lifszyc', 1.9)
var erika = new Persona('Erika', 'Luna', 1.6)
var arturo = new Persona('Arturo', 'Martínez', 1.8)

sacha.saludar()
erika.saludar()
arturo.saludar()

Hola, me paso algo muy curioso.
Al principio tenía

Persona.prototype.estatura = function () {
    if (this.estatura > 1.61) {
        console.log('Soy una persona alta')
    } else {
        console.log('Soy una persona bajita')
    }
}

andrea.estatura()

Y me salía un error que “estatura”, no era una función.
Lo que sucede es que no podemos ponerle el nombre a una función del prototipo que ya sea un atributo.

Que en este caso es this.estatura = estatura

Al final, le deje con otro nombre y ya corre.

Persona.prototype.tamano = function () {
    if (this.estatura > 1.61) {
        console.log('Soy una persona alta')
    } else {
        console.log('Soy una persona bajita')
    }
}```

Aqui les dejo mi aporte sobre la altura.

Persona.prototype.esAlto = function() {
  if(this.altura >= 1.8){
    console.log(`Yo ${this.nombre} ${this.apellido} soy alto`)
  }
  else
  console.log(`Yo ${this.nombre} ${this.apellido} no soy alto`)  
}

var sacha = new Persona('Sacha', 'Lifszyc', 1.8)
var erika = new Persona('Erika', 'Luna', 1.76)
var arturo = new Persona('Arturo', 'Martinez', 1.85)

Así quedó la primera versión del código. Intentaré usar arrays para las variables de autos (Civic, Forte, Fiesta) y hacer el código más corto y eficiente. Si tienen algún comentario de como hacerlo es bien recibido. 😄

function Car (brand, year, model, price){
    this.brand = brand,
    this.year = year,
    this.model = model,
    this.price = price
};

Car.prototype.comparison = function() {
    if (this.price < 200000)
        console.log(`My new car is a ${this.year} ${this.brand} ${this.model} and it's not an expensive car`);
    else {
        console.log(`My new car is a ${this.year} ${this.brand} ${this.model} and it's an expensive car`) ;
    }
}

let civic = new Car ('Honda', 2020, 'civic', 350000);
let forte = new Car ('KIA', 2019, 'Forte', 350000);
let fiesta = new Car ('Ford', 2012, 'Fiesta', 85000);
civic.comparison();
forte.comparison();
fiesta.comparison();
function person (name, lastName, height){
	this.name = name
	this.lastName = lastName
	this.height = height
}

person.prototype.greeting = function () {
	console.log(`Hi, my name is ${this.name} ${this.lastName}`)
}

person.prototype.iAmTall = function(){
	this.height >= 180?console.log(`${this.name} is tall`) : console.log(`${this.name} is not tall`)
}

var daniel = new person('daniel', 'ramos', 175)
var diego = new person('diego', 'perez', 179)
var camilo = new person('camilo', 'ruiz', 188)
function Persona(nombre, apellido, altura){
    this.nombre = nombre
    this.apellido = apellido
    this.altura = altura
}

Persona.prototype.saludar = function (){
 if (this.altura <1.8){
     console.log(`Hola, me llamo ${this.nombre} ${this.apellido}y soy de baja estatura`)
 }else{
    console.log(`Hola, me llamo ${this.nombre} ${this.apellido} y soy de estatura alta`)
 }

}

var sacha = new Persona('sacha', 'lifszyc', 1.76)
var erika = new Persona('erika', 'lifszyc', 1,65)
var raul = new Persona('raul', 'lifszyc', 195)
//Ejercicio
function PersonaEjercicio(nombre, apellido, altura) {
    this.nombre = nombre;
    this.apellido = apellido;
    this.altura = altura;
}

PersonaEjercicio.prototype.controlAltura = function () {
    var midoAltura = this.altura >= 1.8 ? 'más' : 'menos';
    console.log(`Hola, me llamo ${this.nombre} ${this.apellido} y mido ${midoAltura} de 1.8 metros`);
}

var andres = new PersonaEjercicio('Andres', 'Carrasco', 1.77);
var leticia = new PersonaEjercicio('Leticia', 'Guerra', 1.86);
andres.controlAltura();
leticia.controlAltura();

😃

Persona.prototype.soyAlto = function() {
    if(this.altura > 1.80){
       console.log(`Soy una persona alta`)
    }else{
       console.log(`No soy una persona alta`)
    }
}
Persona.prototype.soyAlto = function(){
   console.log(`${this.altura>=1.80 ? 'Soy':'No soy'} una persona alta`)
}

Desafío,

function Persona(nombre, apellido, altura) {
	this.nombre = nombre
	this.apellido = apellido
	this.altura = altura
}
Persona.prototype.soyAlto = function () {
	if(this.altura > 1.8) {
		console.log(`Soy alto, mido ${this.altura}m.`)
	} else {
		console.log(`No soy alto, mido ${this.altura}m.`)
	}
}

var lucia = new Persona('Lucia', 'Garcia', 1.58)

lucia.soyAlto()
function Persona(nombre, apellido, altura) {
    this.nombre = nombre;
    this.apellido = apellido;
    this.altura = altura;
}

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

Persona.prototype.estatura = function () {
    if (this.altura > 1.80) {
        console.log(`Soy de estatura alta`);
    }else{
        console.log(`Soy de estatura baja`);
    }

}

// new : crea un nuevo objeto, se le asigna como prototipo el que se le asigne
var juan = new Persona('Juan', 'Hernandez', 1.83);
var luna = new Persona('Luna', 'Matinez', 1.79);

juan.saludar();
juan.estatura();

luna.saludar();
luna.estatura();```
function Persona(nombre, apellido, altura) {
  this.nombre = nombre
  this.apellido = apellido
  this.altura = altura
}

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

Persona.prototype.soyAlto = function () {
  let altura = 1.8
  let mensaje = (this.altura > altura) ? 'Soy alto' : 'Soy bajo';
  console.log(mensaje);
}
 
let arturo = new Persona('Arturo', 'Enriquez', 1.85)
let jonathan = new Persona('Jonathan', 'Enriquez', 1.5)
function Persona(nombre, apellido, altura) {
    //console.log('Me ejecutaron');
    this.nombre = nombre
    this.apellido = apellido
    this.altura = altura
    //return this está implicito

}

Persona.prototype.saludar = function () {
    if (this.altura >= 1.80) {
        console.log(`Hola, me llamo ${this.nombre} ${this.apellido} y soy alto`)
    } else {
        console.log(`Hola, me llamo ${this.nombre} ${this.apellido} y soy bajo`)
    }
}

let gabriel = new Persona('Gabriel', 'Delgado', 1.66);
let erika = new Persona('Erika', 'Luna', 1.55);
let arturo = new Persona('Arturo', 'Martinez', 1.84);
let test = new Persona(prompt('¿Cual es tu nombre?'), prompt('¿Cual es tu apellido?'), prompt('¿Cuanto mides?'));```

Este es mi desafio:

function Persona (nombre, apellido, altura) {
  this.nombre = nombre
  this.apellido = apellido
  this.altura = altura.toFixed(2)
}

var hector = new Persona ('Hector', 'Lopez', 1.87)
var eder = new Persona ('Eder', 'Ravelo', 1.75)
var pancha = new Persona ('Pancha', 'Gutierrez', 1.55)
var lilo = new Persona ('Liliana', 'Morales', 1.60)

Persona.prototype.saludar = function () {
  console.log(`Hola, soy ${this.nombre} ${this.apellido}`)
}

const esAlto = ({ altura }) => {
  return altura > 1.75
}

Persona.prototype.miAltura = function () {
  if (esAlto(this)) {
  console.log(`Soy alto/a porque mido ${this.altura} metros.`)
  } else {
  console.log(`No soy tan alto/a porque mido ${this.altura} metros. :c`)
  }
}

Hola! Esto es lo que entendí sobre los prototipos, si estoy en algún error sería bueno que me lo hagan saber. Gracias!
.

Prototipos y Clases


Un prototipo de una clase es el constructor del objeto. Contiene los atributos que van a componer un objeto creado.
.
Se declara una variable que contendrá el objeto y luego se llama al prototipo antecedido por la palabra new:

var var_name = new <Prototype_name>()

El prototipo será una función que otorgará los valores a los atributos del objeto. Es importante destacar que el uso de “new” hace que la función haga por defecto un return del objeto creado.

function <Prototype_name>() {
	this.key_1 = value_1
	this.key_2 = value_2
	this.key_n = value_n
}

La siguiente linea permite a la clase tener “acciones”.

this.prototype.<function_name> = function() { }

Por convención las clases se escriben con mayúscula inicial.

Reto!!
![](

En mi solución al reto incorporé el ingreso de datos por parte del usuario con «prompt»:

var usuario = new datosUsuario(prompt(`Ingresa tu nombre`), prompt(`Ingresa tu apellido`), prompt(`Ingresa tu altura`))

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


datosUsuario.prototype.saludar = function () {
    console.log(`Hola. Me llamo ${this.nombre} ${this.apellido} y ${this.altura >= 1.80 ? 'soy alto':'soy bajo'}`)
}

usuario.saludar()```

También pueden declarar la función dentro del “constructor”, sin tener que usar el prototype luego. Seria asi:

function Person(name, lastname) {
    this.name = name;
    this.lastname = lastname;
    this.introduce = function () {
        console.log(`Hi, my name is ${this.name} ${this.lastname}`)
    }
}

const me = new Person("Matias", "Lopez");

me.introduce();

Si, en JavaScript puede haber funciones dentro de funciones.

function Persona (nombre, apellido, edad, altura)
{
    this.nombre = nombre;
    this.apellido = apellido;
    this.edad = edad;
    this.altura = altura
}

Persona.prototype.saludar = function(){
    console.log(`hola me llamo ${this.nombre} ${this.apellido}`)
}

Persona.prototype.esAlta = function() {
    if (this.altura > MINIMO_DE_ALTURA) {
        console.log(`mi nombre es ${ this.nombre } y mido más de 1.8 mts`)    
    }
    else {
        console.log(`mi nombre es ${ this.nombre } y mido menos de 1.8 mts`)   
    }
}

var kevin = new Persona('kevin', 'conde', 29, 1.75)
var arturo = new Persona('arturo', 'martinez', 25, 1.93)
var lina = new Persona('lina', 'rioja', 35 ,1.81)

const MINIMO_DE_ALTURA = 1.8
function Persona(nombre, apellido, edad, altura) {
    this.nombre = nombre
    this.apellido = apellido
    this.edad = edad
    this.altura = altura
}

Persona.prototype.saludar = function() {
    console.log(`Hola, me llamo ${this.nombre} ${this.apellido}`)
}
Persona.prototype.SoyAlto = function(){
    if (this.altura > 1.8) {
        console.log(`Yo, ${this.nombre}, soy alto`)
    } else {
        console.log(`Yo, ${this.nombre}, no soy alto`)
    }
}

Persona.prototype.MiEdad = function (){
    console.log(`Tengo ${this.edad} años`)
}


var miguel = new  Persona (`Miguel`, `Angel`, 29, 1.88)
var juan = new Persona (`Juan`, `Pablo`, 29, 1.75)
var anna = new Persona (`Anna`,`Maria`, 15, 1.66)

miguel.saludar()
miguel.SoyAlto()
miguel.MiEdad()

juan.saludar()
juan.SoyAlto()
juan.MiEdad()

anna.saludar()
anna.SoyAlto()
anna.MiEdad()

Esto me da undefined, alguien sabe por qué?

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

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

Persona.prototype.otro = function () {
  if(this.altura > 1.8){
    console.log(`Soy alto`)}
}


var sacha = new Persona('Sacha', 'Lifszyc', 1.8)
var erika = new Persona('Erika', 'Luna', 1.9)
var arturo = new Persona('Arturo', 'Martinez', 1.6)```

Mini Tutorial

// Reto  -  Necesesitamos realizar una función que diga si es alto
// Tomaremos el código previamente escrito por Sacha
function crearPersona(nombre, apellido, alto) {
  this.nombre = nombre;
  this.apellido = apellido;
  this.alto = alto;
}

var sasha = new crearPersona("Sasha", "Lifszy", 1.8); // Esta es una variable de prueba

// Crearemos una funcion prototype para lanzar el mensaje

crearPersona.prototype.decirAltura = function (){
    var soyAlto = () => this.alto >= 1.8 // Define si eres alto o no
    // Creamos este if statement para lanzar el mensaje si la condición no es verdadera
    if (soyAlto){
        console.log(`Me llamo ${this.nombre} y soy Alto`)
    }
}
function Persona (nombre,apellido,altura){
    this.nombre=nombre
    this.apellido=apellido
    this.altura=altura
}
Persona.prototype.saludar=function(){
    console.log(`Hola, me llamo ${this.nombre} ${this.apellido}`)
}
Persona.prototype.soyAlto=function(){
    if(this.altura>=1.8){
        console.log(`Si, ${this.nombre} es alto`)
    }else{
        console.log(`No, ${this.nombre} no es alto`)
    }
}

Lo hice para altos, medianos y pequeños. Además de clasificar por sexo

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

var ramdhei = new Persona('Ramdhei', 'López Arcila', 1.7, 'M')
var carolina = new Persona('Carolina', 'Arcila Ramírez', 1.61, 'F')
var richy = new Persona('Ricardo', 'Fontecha Arcila', 1.68, 'M')
var barah = new Persona('Juan Felipe', 'Barahona Duque', 1.81, 'M')

Persona.prototype.saludar = function () {

    if(this.sexo === 'M'){
        if (this.altura >= 1.8) {
            console.log(`Hola, me llamo ${this.nombre} ${this.apellido} y soy alto`)
        } else if(this.altura >= 1.65 && this.altura < 1.8){
            console.log(`Hola, me llamo ${this.nombre} ${this.apellido} y soy de mediana estatura`)
        }else{
            console.log(`Hola, me llamo ${this.nombre} ${this.apellido} y soy bajito`)
        }
    } else if(this.sexo === 'F'){
        if (this.altura >= 1.8) {
            console.log(`Hola, me llamo ${this.nombre} ${this.apellido} y soy alta`)
        } else if(this.altura >= 1.65 && this.altura < 1.8){
            console.log(`Hola, me llamo ${this.nombre} ${this.apellido} y soy de mediana estatura`)
        }else{
            console.log(`Hola, me llamo ${this.nombre} ${this.apellido} y soy bajita`)
        }
    }

}

😃

//prototipos

var estatura = 1.80;

//function Persona(parametros) {
function Persona(nombre, apellido, altura) {
    this.nombre = nombre;
    this.apellido = apellido;
    this.altura = altura;
    //return this por defecto envia el this
}
//prototype
Persona.prototype.saludar = function () {
    console.log(`Hola, me llamo ${this.nombre} ${this.apellido}`)
}

Persona.prototype.soyAlto = function (){
    if (this.altura >= estatura){
        console.log(`Mi estatura es ${this.altura.toFixed(2)} y soy alto`)
    } else {
        console.log(`Mi estatura es ${this.altura.toFixed(2)} y soy bajito "hobbit me dicen"`)
    }
}

var sacha = new Persona( 'Sacha', 'Lifszyc', 1.80)
var erika = new Persona('erika', 'Luna', 1.59)
var arturo = new Persona('Arturo', 'Martinez', 1.73)
sacha.saludar()
sacha.soyAlto()```

Soluci{on al reto propuesto…

Reto cumplido

function Persona(nombre, apellido,altura) {
    this.nombre = nombre
    this.apellido = apellido
    this.altura=altura
    // console.log('Me ejecutaron')//Aqui adentro va el constructor
}
Persona.prototype.saludar=function(){
    console.log(`hola me llamo ${this.nombre} ${this.apellido}`)
}
Persona.prototype.soyAlto=function(){
    if(this.altura>1.8){
        console.log(`Hola me llamo ${this.nombre} ${this.apellido} y soy alto`)
    }
}
var persona1 = new Persona('Leidy', 'Daza',1.50) //creamos un nuevo objeto dado un prototypo
var persona2 = new Persona('Stiven ', 'Medina',1.85) //creamos un nuevo objeto dado un prototypo
var persona3 = new Persona('Ana', 'Daza',1.60) //creamos un nuevo objeto dado un prototypo
var persona4 = new Persona('yohana', 'Daza',1.82) //creamos un nuevo objeto dado un prototypo
persona1.saludar()
persona2.soyAlto()

Reto

function Person(firstName, lastName, height) {
    // Attributes
    this.firstName = firstName;
    this.lastName = lastName;
    this.height = height;

    // Methods
    this.greet = () => {
      console.log(`Hi! My name is ${this.firstName} ${this.lastName}`);
    };

    this.isTall = () => this.height >= 1.8;
};

const person = new Person('John', 'Doe', 1.82);

person.greet(); // Hi! My name is John Dow

Podemos escribir las clases de JS de maneras mas simple de esta manera, aca esta junto con el reto:

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

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

    esAlta() {
        if (this.altura > 1.8) {
            console.log('Es una persona alta')
        } else {
            console.log('No es una persona alta')
        }
    }
} 

Heey!! Si sientes que no estas entendiendo mucho, date una vuelta por otros cursos de Javascript, como el básico, el de asincronismo, ve algunos tutoriales en youtube, práctica con desafíos pequeños. Y luego dale una vuelta más a esta clase y todo tendrá mayor sentido te lo aseguro… lo importante es persistir!! 😃

Aquí va mi código. Espero sea entendible y acepto toda crítica
<function Persona(nombre, apellido, altura, sexo){
|
|    this.nombre = nombre
|    this.apellido = apellido
|    this.altura = altura
|    this.sexo = sexo
|    //debugger
|}
 
-var altoSoy = function(alture, sexe)  { //SE ENVÍA PARAMETROS DE ALTURA Y SEXO
|
-    if (sexe == 'hombre'){
2
-        if (alture >= 1.8){
3            return "alto";
3        } else {
3            return "bajo"
3        }
2
2    } else {
-        if (alture >= 1.8){
3            return "alta";
3        } else {
3            return "baja"
3        }
2    }
|}
 
-Persona.prototype.saludar = function (){
|    console.log(`Hola, me llamo ${this.nombre} ${this.apellido} y soy `+          |altoSoy(this.altura, this.sexo))
|}
 
 var jose = new Persona('Jose', 'Vielman', 1.9,'hombre')
 var amanda = new Persona('Amanda', 'Martinez', 1.60,'mujer')
 var juan = new Persona('Juan', 'Rockefele', 1.50,'hombre')>

Para el reto he usado un arrow function, la cual, valida si una persona es alta o baja.

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

const alturaPersona = ({ altura }) => altura > 1.8 ? 'alta' : 'baja'

Persona.prototype.infoAltura = function () {
    console.log(`${this.nombre} es una persona ${alturaPersona(this)}`)
}

var sacha = new Persona('John', 'Doe', 1.85)
sacha.infoAltura()

Si intentaron hacer el ejercicio con una arrow function y no les funciono es porque las arrow functions no se pueden utilizar en métodos ni como funciones constructoras porque las arrow functions no reconocen que es this.

this en javaScript es el equivalente a self en python

//Cuando se habla de Objetos en JS se habla de prototipos y no tanto de clases
//En las nuevas versiones si bien se habla de clases no son como tales porque no existe la herencia como tal
//Para entender bien de qué se trata vamos a comenzar a crear prototipos hasta llegar a las clases de JS

//Primero definimos el prototipo Persona, para definirlo necesitamos primero definir una función
function Persona (nombre, apellido, edad, altura){
	this.nombre = nombre
	this.apellido = apellido
	this.edad = edad
	this.altura = altura
}

//En el this. se pueden asignar valores estáticos
//this.edad = 20

//Si quisieramos que el objeto tenga una función entonces hacemos lo siguiente: Mencionarle al prototipo Persona que tenga esa función
Persona.prototype.saludar = function (){
	console.log(`Hola, soy ${this.nombre} ${this.apellido} y tengo ${this.edad} años`)
}

const ES_ALTO = 1.80

//Función para saber si la persona es alta
Persona.prototype.soyAlto = function(){
	if (this.altura > ES_ALTO){
		console.log(`${this.nombre} ${this.apellido} es alto`)
	}else{
		console.log(`${this.nombre} ${this.apellido} no es alto`)
	}
}

//Para crear nuevos objetos se debe hacer uso de la palabra reservada new
var isay = new Persona('Isay', 'Gonzalez', 28, 1.70);
var armando = new Persona ('Armando', 'Carranza', 29, 1.88)
var monica = new Persona ('Monica', 'Naranjo', 35, 1.64)

//Para hacer que la persona salude debeoms invocar el atributo saludar de la persona de la siguiente manera
isay.saludar()

//Después de haber añadido la función soyAlto mandamos llamar la función con el nombre de la persona (objeto)
isay.soyAlto()
armando.soyAlto()
monica.soyAlto()```
function Persona(nombre, apellido, estatura) {
    this.nombre = nombre;
    this.apellido = apellido;
    this.estatura = estatura;
}

Persona.prototype.esAlto = function() {
    this.estatura >= 1.80 ? console.log(`${this.nombre} ${this.apellido} es alto`): console.log(`${this.nombre} ${this.apellido} no es alto`);
};

var leo = new Persona('Leo', 'Bravo', 1.85);
var erik = new Persona('Erik', 'Gorraez', 1.69);
var aaron = new Persona('Aaron', 'Salazar', 1.75);

Al crear un método dentro del protoype de un objeto al parecer no se puede usar arrow function ya que luego los ‘this.something’ serán undefined. Corríjanme si estoy mal please

En las ultimas versiones de js ya no se usa la palabra Class?? y se declaraba un constructor y eso… ya no se usa?

function Persona(nombre, apellido, altura){
this.name = nombre,
this.lastname = apellido,
this.height = altura
}
Persona.prototype.saludar = function(){
console.log(Tu nombre es: ${this.name} y apellido es: ${this.lastname})
}
Persona.prototype.eresAlto = function () {
if(this.height > 1.8){
return console.log(Eres alto con ${this,this.height})
}else{
return console.log(Eres bajo con ${this,this.height})
}
}
var richard = new Persona (‘Richard’, ‘Gil’,1.9 )
var erika = new Persona (‘Erika’, ‘Luna’, 1.3)
var martha = new Persona (‘Martha’, ‘Burgos’, 1.6)
var sandra = new Persona (‘Sandra’, ‘lee’,1.9 )

ahora vamos con mas enseñanzas de los prototipos

persona.prototype.alto = function (){
    if(this.altura >= 1.8){
        console.log (`Hola, soy ${this.nombre} ${this.apellido} y estoy Alto, mido ${this.altura} mts`)
    }
}

var oscar = new persona ("Oscar", "Ramirez", 1.85);

oscar.alto();```

persona.prototype.alto = function (){
if(this.altura >= 1.8){
console.log (Hola, soy ${this.nombre} ${this.apellido} y estoy Alto, mido ${this.altura} mts)
}
}

var oscar = new persona (“Oscar”, “Ramirez”, 1.85);

oscar.alto();

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

Persona.prototype.saludar = function () {
    console.log(`Hola mi nombre es ${this.nombre} ${this.apellido}`)
}

Persona.prototype.soyAlto = function () {
    if(this.altura >= 1.8){
        console.log(`Soy alto`)
    }else{
        console.log(`Soy bajo`)
    }
}

var fredy = new Persona('Fredy', 'Talero', 1.85)
fredy.saludar()
fredy.soyAlto()

var juan = new Persona('Juan', 'Gomez', 1.79)
juan.saludar()
juan.soyAlto()

Reto cumplido 😃

Persona.prototype.soyAlto = function () {
    this.altura > 1.8 ? console.log(`Soy alto, mido ${this.altura} mts`): console.log(`No soy alto, solo mido ${this.altura} mts`)
}
function persona (nombre, apellido, altura){
    //console.log('Me ejcutaron')// aqui retorna automaticamente o incluida la palabra de retur
    this.nombre = nombre // this hace refrencia a 
    this.apellido = apellido
    this.altura = altura
    
}
persona.prototype.saludar = function () { // dentro del prototipo de persona 
    // existira un atributo saldar que sera una funcion
    console.log(`Hola, me llamo ${this.nombre} ${this.apellido} y ${this.altura >= 1.8? 'soy ': 'no soy '} alto`)

}
var sacha = new persona('sacha', 'Lifszyc', 1.8)// new seguida de un prototipo hace que se cree un nevo objeto
sacha.saludar() // Hola me llamo sacha lifszyc

// de esta manera podemos crear distitntos objetos 
// teniendo en comun el mismo prototipo

var erica = new persona('erica', 'Martina', 1.58)
var Laura = new persona('Laura', 'Vzz', 1.85)
var Martin = new persona('Martin', 'Rocke', 1.90)

Les comparto mi reto,

function Persona(nombre, apellidos, altura) {
    this.nombre = nombre;
    this.apellidos = apellidos;
    this.altura = altura;
};

Persona.prototype.saludar = function () {
    console.log(`Hola, me llamo ${this.nombre} ${this.apellidos}`);
};

Persona.prototype.soyAlto = function () {
    this.altura >= 1.8 ? console.log(`${this.nombre} ${this.apellidos} es Alto`) : console.log(`${this.nombre} ${this.apellidos} NO es Alto`);
};

var sacha = new Persona('Sacha', 'Lifszyc',1.82)
var erika = new Persona('Erika', 'Luna',1.65)
var arturo = new Persona('Arturo', 'Martinez',1.83);

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

Saludos

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

persona.prototype.soyAlto = function () {
  if (this.altura >= 1.8) {
    console.log(`soy ${this.nombre} ${this.apellido} y soy alto`);
  } else {
    console.log(`soy ${this.nombre} ${this.apellido} y soy bajo`);
  }
}

var jeffer = new persona ('jeffer','Hernandez', 1.87)
var daniela = new persona ('daniela','castillo',1.78)

jeffer.soyAlto()
daniela.soyAlto()```