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

Funciones como parámetros

29/55
Recursos

En JavaScript, los parámetros de funciones son por defecto undefined. De todos modos, en algunas situaciones puede ser útil colocar un valor por defecto diferente que lo evalúe como verdadero.

Aportes 275

Preguntas 38

Ordenar por:

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

Resumen de la Clase
Funciones como parámetros

Es posible pasar funciones como parámetros como si fuera cualquier otro tipo de variable.

Cómo se declara?
Como cualquier función.

La siguiente función es una respuesta a la función saludar del código que traemos de las clases anteriores:

function responderSaludo(){
	console.log(`Buen día`)
}

Cómo se implementa al prototipo?
Se agrega un parámetro a la función que la va a disparar dentro del prototipo (‘saludar(fn)’, en este caso) y un if que evalúe si es llamada.

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

Cómo se ejecuta?
Se ejecuta invocando la función sin paréntesis dentro de los paréntesis de la función saludar ya que es una respuesta al saludo:

sacha.saludar(responderSaludo)

Si quiero pasar parámetros?
Los agrego al declarar la función y luego los agrego entre paréntesis a la invocación de la misma dentro de la función que la dispara en el prototipo. Funcionan implícitamente, es decir, no se agregan cuando invoco la función dentro del ‘saludar()’.

En la declaración:
function responderSaludo(_nombre_, _apellido_, _esDev_){
	console.log(`Buen día ${_nombre_} ${_apellido_}.`)
	if (_esDev_) {
		console.log(`Ah mirá, no sabía que eras dev.`)
	}
}

En la función nativa:
	saludar(fn){
		console.log(`Hola me llamo ${this.nombre} ${this.apellido}`)
		if(fn){
			fn(_this.nombre_, _this.apellido_)
		}
	}

Se invoca:

sacha.saludar(responderSaludo)

Para despejar la lectura del código y escribir menos:

	saludar(fn){
		console.log(`Hola me llamo ${this.nombre} ${this.apellido}`)
		if(fn){
			var {nombre, apellido} = this 
			// == var nombre = this.nombre // var apellido = this.apellido
			fn(nombre, apellido)
		}
	}

Hay valores que al ser evaluados dentro de un if dan verdadero y otros falso, en este caso fn dentro del if evalúa si existe la función en la invocación de saludar().

El código completo quedaría así:

class Persona {
	constructor(nombre, apellido, altura, genero){
		this.nombre = nombre
		this.apellido = apellido
		this.altura = altura
		this.genero = genero
	}
	saludar(fn){
		console.log(`Hola me llamo ${this.nombre} ${this.apellido}`)
		if(fn){
			var {nombre, apellido} = this
			fn(nombre, 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)
	}
}

class Desarrollador extends Persona {
	constructor(nombre, apellido, altura){
		super(nombre, apellido, altura)
	}
	saludar(fn){
		console.log(`Hola, me llamo ${this.nombre} ${this.apellido} y soy desarrollader.`)
		if(fn){
			var {nombre, apellido} = this
			fn(nombre, apellido, true)
		}
	}
}

function responderSaludo(nombre, apellido, esDev){
	console.log(`Buen día ${nombre} ${apellido}.`)
	if (esDev) {
		console.log(`Ah mirá, no sabía que eras dev.`)
	}
}

var pablo = new Persona('Pablo', 'Andrés', 1.78, 'masculino')
var joaquin = new Desarrollador('Joaquín', 'Perez', 1.91, 'masculino')
var rosa = new Persona('Rosa', 'Mosqueta', 1.81, 'femenino')
var elis = new Persona('Elis', 'Detta', 1.73, 'femenino')

pablo.saludar()
joaquin.saludar(responderSaludo)
rosa.saludar(responderSaludo)
elis.saludar(responderSaludo)

ah mirá, no sabía que eras desarrollador… eso sono tan argentino 😄

Chicos si logran terminar esta curso de js les aseguro que van a hacer unos maestros en el lenguaje, es uno de los mejores cursos que hay

Clases como esta hace que valga la pena mi suscripción 👍👍

Así funciona la lógica:

  • llamamos a un metodo y le mandamos una funcion por parametro

  • y en el metodo recibimos la funcion y evaluamos si nos mandan la funcion

  • llamara a la funcion y le mandamos parametros

  • y si cuando llamaron al metodo del objeto no mandaron una funcion como parametro no hara nada

MI CODIGO BIEN FINO

// podemos pasar funciones como parametros
class Persona {
    constructor (nombre, apellido, altura) {
        this.nombre = nombre // es un atributo del objeto que se esta creando
        this.apellido = apellido
        this.altura = altura
    }

    // metodos
    saludar(fn) {
        var { nombre, apellido } = this
        console.log(`Hola, Me llamo ${nombre} ${apellido}`)
        if (fn) { // si nos pasan una funcion (cuando llaman al metodo)
            fn(nombre, apellido) //llamamos a la funcion que nos mandan por parametro
        }
    }
    soyAlto() {
        return this.altura >= 1.8
    }
}

// para que una clase herede de otra
class Desarrollador extends Persona {
    constructor (nombre, apellido, altura) {
        super(nombre, apellido, altura) // no podemos usar this hasta que no llamemos al contructor padre | super define los atributos de la clase padre, y los hereda el hijo (desarrollador) le pasa los atributos al padre para que los tenga el hijo
    }
    
    //pisamos el metodo de la clase padre por esto:
    saludar(fn) {
        // var nombre = this.nombre // almacena en nombre el atributo nombre del objeto
        // var apellido = this.apellido
        var { nombre, apellido } = this // es lo mismo que lo de arriba

        console.log(`Hola, Me llamo ${nombre} ${apellido} y soy desarrollador/a`)
        if (fn) { // si nos pasan una funcion (cuando llaman al metodo como parametro)
            fn(nombre, apellido, true) //llamamos a la funcion que nos mandan por parametro
        }
    }
}


function responderSaludo(nombre, apellido, esDev) {
    console.log(`Buen día ${nombre} ${apellido} (respondo al saludo a ${nombre})`)
    if (esDev) { // si es true ejecuta esto
        console.log(`Ah mira, no sabia que eras desarrollador/a`)
    }
}

// instanciamos a los objetos (creamos objetos de diferentes clases)
var sacha = new Persona("Sacha", "Lifszyc", 1.72)
var erika = new Persona("Erika", "Luna", 1.65)
var arturo = new Desarrollador("Arturo", "Martinez", 1.89)

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


// llamamos a un metodo y le mandamos una funcion por parametro 
// y en el metodo recibimos la funcion y evaluamos si nos mandan la funcion
// llamara a la funcion y le mandamos parametros
// y si cuando llamaron al metodo del objeto no mandaron una funcion como parametro no hara nada```

FUNCIONES COMO PARAMETROS
Para ejecutar una función como parámetro, no es muy diferente al como veníamos haciéndolo, hemos pasado textos, nombres, números, apellidos, como parámetros, pero funciones también podemos hacerlo.
Tomaremos el código de las clases y le agregaremos una función para que nos responda el saludo, para ello vamos a hacer lo siguiente;

Primero creamos la función

function responderSaludo (nombre, apellido, esDev){
    console.log(`Buen dia ${nombre} ${apellido}`)

    if(esDev){
        console.log(`ah mira, no sabia que eras desarrollador`)
    }

Esta es creada dentro de la clase desarrollador, y como podemos observar el tercer parámetro es el que verifica si es dev o no y le colocamos una condicional, de que si esDev le dirá “que no sabia que era un desarrollador”, como hacemos que la función verifique esto?, pues sencillo, lo veremos en las siguientes modificaciones, pero ten en mente que vamos a usar algo que ya hemos visto, lo haremos de manera booleana.

Ahora


var angel = new Desarrollador('Angel','Sulbaran', 1.71)
var pepe = new persona('Pepe','Trueno', 1.92)
var thor = new persona('Thor','Torero', 1.71)
var carl = new persona('Carl','Jhonson', 1.81)
var freddie = new persona('Freddie','Vega', 1.85)
var lorenzo = new persona('Lorenzo','VonMatterhorn', 1.76)
var lucas = new persona('Lucas','Posillo', 1.71)

angel.saludar(responderSaludo)
pepe.saludar()
thor.saludar(responderSaludo)
carl.saludar()
freddie.saludar(responderSaludo)
lorenzo.saludar(responderSaludo)

Tomamos a las persona y les colocamos dentro de sus parámetros la función para que al momento de ser llamadas, automáticamente, se ejecute la respuesta al saludo, en los objetos podemos observar que “angel” es el único desarrollador y por lo tanto será el único que tendrá la respuesta de “esDev” mientras que los demás tendrán una repuesta normal, tal como la asignamos.
Luego de esto nos vamos a “saludar” de la clase persona y agregamos lo siguiente a la función

saludar(fn) {
    //var nombre = this.nombre
    //var apellido = this.apellido
    var {nombre, apellido} = this
    console.log(`Hola, me llamo ${nombre} ${apellido}`)
    if (fn){
        fn(nombre, apellido, null)
    }

Como podemos ver aca tenemos una variable un poco mas sencilla sobre lo que es nombre y apellido, de esta manera es igual de equivalente a como la parte que esta comentada, y creamos a parte la condicional “fn” la cual vamos a llamar en la misma como parámetro. ¿Por que? La cosa es que haciendo esto, al momento de llamar la función “responderSaludo” dentro de los parámetros de saludar al llamarla, esta lo va a reconocer como “fn” entonces,

angel.saludar(responderSaludo)

Al hacer esto le damos a fn un valor de true, de que existe un función que estamos pasando por parámetro lo que haría que, nos devuelva nombre, apellido y la booleana que comprobara si somos desarrolladores o no, por lo que al momento de llamar el saludo a un desarrollador nos respondera como tal, lo mismo pasa con el saludo de persona.
Con esto explicado, nuestro código debería quedar asi:

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

saludar(fn) {
    //var nombre = this.nombre
    //var apellido = this.apellido
    var {nombre, apellido} = this
    console.log(`Hola, me llamo ${nombre} ${apellido}`)
    if (fn){
        fn(nombre, apellido, null)
    }
}

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

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

}

function responderSaludo (nombre, apellido, esDev){
    console.log(`Buen dia ${nombre} ${apellido}`)

    if(esDev){
        console.log(`ah mira, no sabia que eras desarrollador`)
    }
}


var angel = new Desarrollador('Angel','Sulbaran', 1.71)
var pepe = new persona('Pepe','Trueno', 1.92)
var thor = new persona('Thor','Torero', 1.71)
var carl = new persona('Carl','Jhonson', 1.81)
var freddie = new persona('Freddie','Vega', 1.85)
var lorenzo = new persona('Lorenzo','VonMatterhorn', 1.76)
var lucas = new persona('Lucas','Posillo', 1.71)

angel.saludar(responderSaludo)
pepe.saludar()
thor.saludar(responderSaludo)
carl.saludar()
freddie.saludar(responderSaludo)
lorenzo.saludar(responderSaludo)

Hola Platzinautas !

Vengo del futuro(unas 5 clases adelante ) y quiero contarte que si has llegado hasta aquí es hora de que repases por completo todos los conceptos sobre funciones, ya que en las clases siguientes estaremos aprendiendo el asincronismo, un tema que pondrá a prueba nuestra capacidad de comprención.

Dejo aquí con mucho cariño un tutorial hecho por mi, espero sea de utilidad.
https://platzi.com/tutoriales/1339-fundamentos-javascript/4253-todo-sobre-funciones/

Null = false
0 = false
Objeto(vacio) = true
Array(vacio) = true
String = true
String (vacio) = false

Me ha costado bastante entender esta clase por el mal uso de nombres en funciones. En mi opinión llamar a la función fn de tal forma fue un desaciero total.

Si en lugar de:

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

Sustituimos fn con el nombre de la funcion a la que vamos a llamar, en este caso responderSaludo
Tenemos:

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

En mi opinión el código se lee infinitamente mejor. Si algo aprendí de Clean Code es la extrema importancia de un buen nombrado.

Vi dos veces la clase para entenderlo. Pero lo hice.

valores que javascript toma como falsos:

false,
0,
0n
" " , ’ ', ``,
null,
undefined,
Nan

Dejo los enlaces de truthy and falsy values

https://developer.mozilla.org/en-US/docs/Glossary/Falsy
https://developer.mozilla.org/en-US/docs/Glossary/Truthy

Valores: Truthy y Falsy

¿Que tipos por default son verdaderos y falsos?

Usamos la función de JS que es Boolean() dentro del paréntesis ponemos el valor y nos dice si el mismo el False o True.

<h3>Falsy</h3>
  • Boolean() —> sin ningun valor es false
  • Boolean(0) —> false
  • Boolean(null) —> false
  • Boolean(NaN) —> false // NaN es Not and Number
  • Boolean(Undefined) —> false
  • Boolean(false) —> false
  • Boolean("") —> false
<h3>Truthy</h3>
  • Boolean(1) —> true //cualquier numero que no sea igual a cero es true
  • Boolean(“a”) —> true
  • Boolean(" ") —> true // siendo un espacio el valor es true
  • Boolean([]) —> true // un array nos da un true
  • Boolean({}) —> true // un objeto nos da el valor de true
  • Boolean(function() {}) —> true //una funcion tambien es true
  • Boolean(true) —> true

Todo esto lo vamos a usar en condiciones esto valida si es verdadero o falso para ejecutar cierta acción.

Referencias:

Les recomiendo que a apartir de aqui aprendan las diferencias de mandar una referencia y un valor, esto tiene que ver si enviamos las funciones como parametros CON o SIN parentesis. 👍✨

Una breve explicación sobre lo expuesto en esta clase
Tenemos que en JavaScript podemos pasar funciones como parámetros
Se crea la función

function responderSaludo(nombre, apellido, esDev) {
  console.log(`Buen día ${nombre} ${apellido}`);
  if (esDev) {
    console.log(`Ah mirá, no sabía que eras desarrollador/a`);
  }
}

Esta función devuelve el saludo es el objetivo a conseguir

luego declaramos los objetos

var elvis = new Persona("ELvis", "Moreira", 1.6);
var eduardo = new Persona("Eduardo", "Moreira", 1.82);
var armando = new Desarrollador("Armando", "Falcones", 1.8);

ejecutaremos la función saludar pero a dos de ellas le vamos a querer que devuelva el saludo

elvis.saludar();
eduardo.saludar(responderSaludo);
armando.saludar(responderSaludo);

En la función saludar el parámetro para que funcione así no le envíemos el parmaetro

if(fn){
      
    }

quedando la función así

saludar(fn) {
    var { nombre, apellido } = this;
    console.log(`Hola, me llamo ${nombre} ${apellido} y soy desarrollador`);
    if (fn) {
      fn(nombre, apellido, true);
    }
  }

Esta función es la de la clase desarrollador por lo tanto en fn se envía el último parámetro true para indicar que es dev

Como detalle final para declarar de forma correcta los valores a enviar en la función de nuestra clase sería así

//var nombre= this.nombre
    //var apellido= this.apellido

Pero podemos declararlo de una mejor manera siendo este el equivalente

var { nombre, apellido } = this;

No me entero de nada con este profesor 😦

No hay nada más satisfactorio que el código funcione!
Aquí les dejo mi codigo para esta clase

// Funciones como parámetros
// En JavaScript, los parámetros de funciones son por defecto undefined. De todos modos, en algunas situaciones puede ser útil colocar un valor por defecto diferente que lo evalúe como verdadero.



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

     saludar(fn){
        //  var nombre = this.nombre
        //  var apellido = this.apellido
        var { nombre, apellido } = this
        console.log(`Hola me llamo ${nombre} ${apellido}`)
        if(fn){
            fn(nombre,apellido)
        }
     }

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

class Desarrollador extends Persona {
   constructor(nombre, apellido, altura){
      super(nombre, apellido, altura)
      
   }// la clase se extiende de persona

   saludar(fn){
       
    //    var nombre = this.nombre
    //    var apellido = this.apellido
    var { nombre, apellido } = this
    console.log(`hola, me llamo ${nombre} ${apellido} y soy desarrollador/a`)
    if (fn) {
        fn(nombre, apellido, true)
    }
   }
}

function responderSaludo(nombre, apellido, esDev){
    console.log(`Buen día ${nombre} ${apellido} `)
    if (esDev){
        console.log(`Ah mirá, no sabía que eras desarrollador/a`)
    }
}

 var sasha = new Persona('Alejandra', 'Flores', 1.52)
 var erika = new Persona('Erika', 'Luna', 1.75)
 var arturo = new Desarrollador('Arturo', 'Martinez', 1.89)

 sasha.saludar()
 erika.saludar(responderSaludo)
 arturo.saludar(responderSaludo)

Clase complicada, pero tras mucho echarle lógica finalmente lo he entendido.

Una pregunta, por qué al llamar a la función respoderSaludo como parámetro en sacha.saludar no se le ponen los paréntesis?

Entendi a la perfeccion esta clase, no se que opinan los demas

Pude captar la información, pero creo que el ejemplo esta mal explicado!

APORTE
Si no entendiste te dejo un ejemplo diferente explicado a detalle.

// Crearemos una función que recorrerá una lista

function recorredorDeListas(functionPasadaPorParametro){

    // Recorremos la lista.
    // Utilizamos la palabra reservada this para referirnos al objeto que es dueño de este método.

    for(var i=0; i<this.length; i++){
        // Ejecutamos la función pasada como parámetro, la cual se le envía el elemento actual.
        functionPasadaPorParametro(this[i]);
    }

}

// Creamos un arreglo con el nombre de varias personas y lo guardamos en una variable que llamaremos personas.
personas = new Array('Martin','Enrique','Fernanda','Maria','Alejandro','Alondra');

// Asignamos la función al método recorredor
personas.recorredor = recorredorDeListas;

FORMA 1 para pasar una función como parámetro.

// Ejecutamos la funcion pasandole una función anonima que crearemos
personas.recorredor(function(elemento){
    console.log(elemento); // Mostramos el elemento actual en consola
});

FORMA 2 para pasar una función como parámetro

// creamos una función la cual enviaremos
function numeroDeSuerte(elemento){
    var numero = Math.round(Math.random() * (100 - 1) + 1); // Generamos un número random del 1 al 100
    console.log("El numero de suerte de: " + elemento + " es: " + numero); // Mostramos el elemento actual en consola
}

personas.recorredor(numeroDeSuerte);

Mi aporte para esta clase es:

const MAYORIA_DE_EDAD = 18

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

    // El método saludar recibe como parámetro una función, la cual se ejecutará en alguna parte según la lógica declarada
    saludar(callback) {
        // this representa este objeto, por tanto, podemos indicar que atributos necesitamos de el y guardarlos en variables
        var {nombre, apellidos} = this

        console.log(`Hola, que tal soy ${nombre} ${apellidos}`)
        
        // El parámetro pasado al metodo saludar es opcional, por tanto verificamos su presencia
        if (callback) {
            // De estar presente la función como parámetro, la invocamos y le pasamos sus parámetros. En este caso al tratarse de una persona, no es considerada como DEV, por tanto el tercer parametro es false
            callback(nombre, apellidos, false)
        }
    }

    esMayorDeEdad() {
        if(this.edad >= MAYORIA_DE_EDAD) {
            console.log(`${this.nombre} es mayor de edad`)
        } else {
            console.error(`${this.nombre} huele a pañal, pues es menor de edad`)
        }
    }
}

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

    saludar(callback) {
        var {nombre, apellidos} = this
        console.warn(`Hola, mi nombre es ${nombre} ${apellidos} y soy desarrollador/a`)

        // Nuevamente verificamos que la función se haya pasado como parámetro a al metodo saludar
        if (callback) {
            // Invocamos la función, indicando que se trata de un DEV, (true)
            callback(nombre, apellidos, true)
        }
    }

}


// Declaración de la función que se enviará como parámetro al método saludar de cada uno de los objetos creados a continuación. Al invocarse la función dentro del metodo saludar, esta se le deben pasar 3 parametros para que pueda trabajar
var responderSaludo = function(nombre, apellidos, esDev) {
    console.log(`Buen día, ${nombre} ${apellidos}`)
    if (esDev) {
        console.log(`Vaya vaya, con que eres desarrollador/a`)
    }
}

var alejandro = new Desarrollador('Alejandro', 'González Reyes', 34)
var ximena = new Persona('Ximena', 'Torres Fuentes', 25)
var beto = new Desarrollador('Beto', 'Molina Prieto', 16)


// JS no nos obliga a que un parámetro sea obligatorio, si no lo encuentra, lanza undefined, que es considerado como false.
// Invoco el metodo saludar de cada uno de mis objetos creados, sin embargo, no estoy obligado a pasar la funcion como parametro para que se responda a mi saludo
alejandro.saludar()
ximena.saludar(responderSaludo)
beto.saludar(responderSaludo)


alejandro.esMayorDeEdad()
ximena.esMayorDeEdad()
beto.esMayorDeEdad()

/** NOTAS
 * 
 * Cuando se pasa una función como parámetro a otra función, no se debe pasar con sus respectivos paréntesis, ya que se estaría invocando en ese mismo lugar.
 * El responsable de invocar la función pasada es el metodo que la recibe, y el decide en que lugar de su cuerpo ha de llamarla.
 * 
 * Si la función recibe parámetros, estos son pasados o proporcionados desde la función que recibe la función como parámetro... (ver metodo saludar)
 */

Funciones como parámetros… esto es lo que se llama volar la cabeza!

Despues de analizar un poco lo entendi, pero hay que ponerlo mas en practica para dominarlo.

A veces me siento mal porque creo que no voy lo suficientemente rápido, luego veo que estamos en la clase 26 y ha sido un buen camino recorrido y me siento mejor :3

Llevo 12 clases seguidas creo que explotare de tanta nueva información jajaja que excelente!

Aquí les dejo una mini simulación de un juego usando todo lo aprendido

//Clase espada
class Sword{
    constructor(name,damage){
        this.name=name;
        this.damage=damage;
    }
}
//Clase jugador
class Player{
    constructor(name,life,damage){
        this.name=name;
        this.life=life;
        this.damage=damage;
    }
    //Metodo de ataque del jugador
    attack(enemy,weapon){
        const {name,life,damage}=this;
        const nameEnemy=enemy.name;
        const lifeEnemy=enemy.life; 
        const nameWeapon=weapon.name;
        const damageWeapon=weapon.damage;

        const damageAttack=calculatedDamage(damage,damageWeapon)

        console.log(`${name}(${life}/200) attack to ${nameEnemy}(${lifeEnemy}/200) with ${nameWeapon}:${damageAttack} damage attack`);

        return calculateLife(damageAttack,lifeEnemy);
    }
}

//Funciones intermedia
function calculatedDamage(damagePlayer,damageWeapon){
   return damagePlayer+damageWeapon;
}

function calculateLife(damageReceived, fileCurrent){
    return fileCurrent-damageReceived
}

//Instanciaciones de las espadas con su nombre, material y ataque
const espadaDeMadera=new Sword('swordWood',25);
const espadaDeMetal=new Sword('swordMetal',50);
const espadaDeDiamante=new Sword('swordDiamond',75);

//Instanciaciones de los jugadores ocn su nombre, vida y ataque
const player1=new Player('Mario',200,15);
const player2=new Player('Luigi',200,15);

//Felizidades ganador!!!!
function congratulations(nameWin){
    console.log(`${nameWin.name} win!`)
}

const turn=0, playerDead=false;

function game(turn,playerDead,congratulation){
    
    do {
        if (turn==0) {
            player2.life=player1.attack(player2, espadaDeMetal);
            turn=1; 
        }else{
            player1.life=player2.attack(player1, espadaDeDiamante);
            turn=0;
        }

        if (player1.life<=0 || player2.life<=0) {
            playerDead=true;
            player1.life>player2.life?congratulation(player1):congratulation(player2);
        }
        
        
    } while (playerDead==false);
}

game(turn,playerDead,congratulations);

Esto me cambió la vida

//Escribir esto
var nombre = this.nombre;
var apellido = this.apellido;
// es igual  a
var { nombre, apellido } = this;

nice…

class persona {
  constructor(nombre, apellido, altura) {
    this.nombre = nombre
    this.apellido = apellido
    this.altura = altura
  }
  saludar(fn) {
    console.log(`hola soy ${this.nombre} ${this.apellido}`)
    if (fn) {
      fn(this.nombre, this.apellido, false)
    }
  }

}

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



function responderSaludo(nombre, apellido, esDev) {
  console.log(`Buen dia ${nombre} ${apellido}`)
  if (esDev) {
    console.log(`Ah mirá, no sabia que eras desarrollador/a`)
  }
}

var jose = new persona('Jose', 'Perez', 1.8)
var Juan = new persona('Juan', 'Herway', 1.5)
var Maria = new Desarrollador('Maria', 'Luak', 1.6)

jose.saludar()
Juan.saludar(responderSaludo)
Maria.saludar(responderSaludo)

Mi código

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

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

    esAlto(){
        console.log(`${this.altura >= 1.80 ? `${this.nombre} es una persona alta` 
        : `${this.nombre} es una persona baja`}`)
    }
}

class desarrollador extends persona{
    constructor (nombre, apellido, lenguaje){
        super(nombre, apellido)
        this.lenguaje = lenguaje
    }
    
    like_lenguaje(){
        console.log(`Me gusta desarollar en ${this.lenguaje} `)
    }
}

const esDev = (persona) => persona instanceof desarrollador

function responderSaludo (persona) {
    console.log(`Buen día, ${persona.nombre} gusto en saludarte 
    ${esDev(persona) ? "No sabía que era desarrolador" : "¿Cuál es tu profesión?"}`)
}

const sebas = new persona("sebas", "angulo", 10, 1.41)
const nicoll_dev  = new desarrollador("nicoll", "angulo", "Python y Javascript")

sebas.saludar(responderSaludo)
nicoll_dev.saludar(responderSaludo)

Utilicé el operador instanceof para determinar si la instancia del objeto pertenece a Desarrollador y así devolver true o false, según sea el caso.

saludar(fn){
        console.log(`Saludos de  ${this.nombre} como desarrollador`);
        if(fn){
            let nombre = this.nombre;
            let apellido = this.apellido;
            fn(nombre, apellido, (this instanceof Desarrollador))
        }
    }

Bastante interesante la verdad, y sobre todo muy muy útil!

Tip de VISUAL STUDIO CODE
En caso de necesitar hacer scroll con el teclado pueden usar la tecla ctrl + flecha arriba o abajo

Muy complicados algunas cosas pero es parte del aprendizaje!

Okay lo entiendo, la cosa es que es muy enredado. lo entiendo… es ahora… luego no se si lo entienda nuevamente. observen agregue lo siguiente


function responderSaludo(nombre,apellido,esDev,lenguaje) {
    
    console.log(`hola ${nombre} ${apellido}`)
    if(esDev) {
        console.log(`No sabia que eras Desarrollador/a que bien que programes en ${lenguaje}`)
    }
}```

y obtengo est oen cosolja es genial 

Hola soy Pepe hidalgo y soy desarrollador/a y mido 1.2 metros y programo en lenguaje JavaScript
 hola Pepe hidalgo
No sabia que eras Desarrollador/a que bien que programes en JavaScript

No voy a bloquear el event loop lol XD 😉

Excelente el curso. !

Pero me ayudan con una duda.
cuando se crea una funcion como saludar,
y se desestructuran los objetos recibidos en nuevas variables

function saludar (){
var _variable1 = this.attr1;
var _variable2 = this.attr2;
//se realiza algo con las variables.
}

Que pasa en la memoria con estas nuevas variables cuando se ejecutan una y otra vez la funcion saludar.? Me llenan la memoria con nuevas variables llamado tras llamado ? o no deberia preocuparme por eso ? gracias.

Mi código de la clase, agregue la subclase Estudiante, me diverti un poco haciendo que pareciera màs un dialogo

/*
//Funciones como parametros
*/

//Imprimiendo algo en la consola
console.log("inicializando archivo");

/*Declaración de prototipos
=========================================*/



/* Prototipo Persona 
====================================================*/

//clase prototipal
class Persona {

	/*ATRIBUTOS
	============================*/
		constructor(nom, ape, alt) {
		//para guardarlo en la memoria usamos this

		//this.nombre declara el nombre clave del valor
		this.nombre = nom;
		//nom es un valor que va en funcion de los parametros del prototipo
		this.apellido = ape;
		
		this.altura = alt;

		this.alta = 1.70;
	     
		//return this; implicitamente es retornado

	}

	/*METODOS
	============================*/

	//acà no hace falta la palabra function
	saludar(responderSaludo) {

		//desestructurando el objeto para sacar los atributos que me interesa
		var {nombre, apellido} = this;

		// var nombre = this.nombre
		// var apellido = this.apellido

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

		//si se envio algo como parametro este bloque de codigo sera verdadero y se ejecutara
		if (responderSaludo) {
			responderSaludo(nombre, apellido, false)
		}

		/*
		Hay valores que siempre se comportan como verdadero, otros como falso

		ejemplo: un array, un objeto, un string con texto
		ejemplo de no: nada, undefined, null, 0
		*/
	}

	esAlto() {
		return this.altura > this.alta;
	}

	esBajo() {
		return !this.esAlto(); 
	}
}


/*Clase Desarrollador
================================================= */

//para heredar diremos que extiende cosas de personas
class Desarrollador extends Persona {


	/*ATRIBUTOS
	============================*/
	constructor( nom, ape, alt ) {


		//antes de usar this debemos llamar al constructor de la clase padre
		super(nom,ape, alt)
		//estos parametros son los mismo de la clase padre

		//super permite llamar a la clase padre
	}

	/*METODOS
	============================*/
	saludar(responderSaludo) {

		//desestructurando el objeto para sacar los atributos que me interesa
		var {nombre, apellido} = this;

		console.log(`${nombre}: Hola Mundo, me llamo ${nombre} ${apellido} y soy dev.`)

	//si se envio algo como parametro este bloque de codigo sera verdadero y se ejecutara
		if (responderSaludo) {
			responderSaludo(nombre,apellido,true)
		}
	}
	//OUTPUT Ej: Hola Mundo, me llamo Jesùs Fernandez y soy dev.
}

/*Clase Estudiante
================================================= */

class Estudiante extends Persona {

	/*ATRIBUTOS
	============================*/
	constructor( nom,ape,alt ) {

		super( nom,ape,alt )
		//llamando parametros del padre
	}

	/*METODOS
	============================*/
	gritar() { 
		window.alert("MAÑANA TENGO EXAMEN") 
	}

	saludar(responderSaludo) {


		//desestructurando el objeto para sacar los atributos que me interesa
		var {nombre, apellido} = this;

		console.log(`${nombre}: Holii, soy ${nombre} ${apellido} y estudio en el cole jeje`);

		//si se envio algo como parametro este bloque de codigo sera verdadero y se ejecutara
		if (responderSaludo) {
			responderSaludo(nombre,apellido,false, true)
			//false a esDev, true a esEstudiante
		}
	}

	
}


/*Declaración de objetos
=========================================*/

//Un Array donde coleccionare las personas que cree
var personas = [] 

personas.push(  daniel = new Desarrollador("Daniel", "Páez", 1.73) )
personas.push(  mariaV = new Estudiante("Maria", "Victoria", 1.65) )
personas.push(  amanda = new Persona("Amanda", "Páez", 1.62) )
	

/*Declaración de variables y Arrays
=========================================*/
//Null


/*Declaración de funciones
=========================================*/

function responderSaludo(nombre,apellido, esDev, esEstudiante) {
	console.log(`Anfitrión: Buen dia ${nombre} ${apellido}`)

	if(esDev) {
		console.log(`Anfitrión: Ah mirá, no sabía que vos eras Dev.`)
	}
	if (esEstudiante) {
		console.log(`Anfitrión: Oye, ¿Y que tal el colegio?`)
		console.log(`${nombre}: Geniaaaaaaal`)
	}
}


/*Consola y consultas
=========================================*/
//Null


/*Ejecución de funciones y métodos
=========================================*/

for(var persona of personas)
{	

	//filtrando, todos menos una persona en concreto
	if (persona !== amanda) {

	//estoy pasando una funcion como parametro
	persona.saludar(responderSaludo);
	//this is like write this three times amanda.saludar();
	
	}
	
}

Les comparto mi implementación:

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

        saludar (fnRespSaludo) { 
                return `Hola  mi nombre es ${this.nombre} ${this.apellido} 
                                ${fnRespSaludo ? '\n' + fnRespSaludo(this.nombre, this.apellido, false) : ''}`;
        }

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

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

        saludar (fnRespSaludo) { 
                return `Hola  mi nombre es ${this.nombre} ${this.apellido} y soy Desarrollador/a
                                ${fnRespSaludo ? '\n' + fnRespSaludo(this.nombre, this.apellido, true) : ''}`;
        }
}

var responderSaludo = (nombre, apellido, esDev) => 
        `Buen dia, ${nombre} ${apellido} ${esDev ? 'Ah mira, no sabia que eras desarrollador/a': ''}`

Mucha dosis!!!
Las funciones como parámetros

¿En qué momento se declara esDev como verdadero?

Fue fácil entender el tema, muy bien explicado. Gracias

Chequear peso con otra funcion como parametro

class Person {

    constructor(nombre, peso) {
        this.nombre = nombre,
            this.peso = peso
    }

    decirPesoYNombre(fun) {
        console.log(`Me llamo ${this.nombre} y actualmente peso ${this.peso}kg`)
        if (fun) {
            fun(this.peso)
        }
    }

}

function fatCheck(peso) {
    if (peso < 80) {
        console.log(`${peso}kg, hug? No está mal`)
    } else {
        console.log(`Un poco gordo, no? ^_^;`)
    }
}

var jess = new Person('Jess', 70);
var ssuj = new Person('Sujj', 100);

jess.decirPesoYNombre(fatCheck);
ssuj.decirPesoYNombre(fatCheck);

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

    saludar(fn) {
        var { nombre, apellido } = this;

        console.log(`Hi! My name is ${nombre} ${apellido}`);
        if (fn) {
            fn(nombre, apellido);
        }
    }

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


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

    saludar(fn) {
        var { nombre, apellido } = this;

        console.log(`Hi! My name is ${nombre} ${apellido} and I am Developer!!!`);
        if (fn) {
            fn(nombre, apellido, true);
        }
    }
}


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

    saludar(fn) {
        console.log(`Hi! My name is ${this.nombre}${this.apellido} and I am student.`)
        if (fn) {
            fn(this.nombre, this.apellido, true)
        }
    }
}

function responderSaludo(nombre, apellido, esDev) {
    console.log(`Good day ${nombre} ${apellido}`);
    if (esDev) {
        console.log(`Ah mira, no sabia que eras desarrollador/a`);
    }
}

var luis = new Desarrollador('Luis', 'Rangel', 1.75);
var mariana = new Persona('Mariana', 'Obando', 1.65)
var fabio = new Estudiante('Fabito', 'Obando', 1.92)
var andres = new Persona('Jhoan', 'Camilo', 1.72)

luis.saludar(responderSaludo);
mariana.saludar();
fabio.saludar(responderSaludo);
andres.saludar(responderSaludo);

console.log(luis.soyAlto());

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

}
saludar(fn){
var {nombre, apellido} = this
console.log(Hola, me llamo ${nombre} ${apellido})
if (fn) {
fn(nombre, apellido)
}

}

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

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

   }

saludar(fn){
var {nombre, apellido} = this   
console.log(`Hola, me llamo ${nombre} ${apellido} y soy desarrolladora`) 
if(fn){
    fn(nombre, apellido, true)
        
    }
}

}

function responderSaludo(nombre, apellido, esDev) {
console.log(Buen dia ${nombre} ${apellido})
if (esDev){
console.log(‘Ah mira, no sabia que eras desarrolladora’)
}

}

var rina = new persona (‘rina’, ‘plata’, 1.65)
var maria = new desarrollador(‘maria’, ‘lopez’, 1.70)
var miguel = new persona(‘miguel’, ‘teheran’, 1.78)
rina.saludar()
maria.saludar(responderSaludo)
miguel.saludar(responderSaludo)

//podemos pasar funciones como parametros. Vamos a pasar una funcion para que nos responda al saludo del ejemplo

class Persona {
    //metodo constructor de la clase Persona
    constructor(nombre, apellido, altura) {
        //propiedades    
        this.nombre = nombre;
        this.apellido = apellido;
        this.altura = altura;
    }
    //metodos
    saludar(rS) {
        console.log(`Hola! soy ${this.nombre} ${this.apellido}`)
    //si recibe la funcion como parametro, entrara al if y ejecutara lo que haya adentro, en este caso,
    //la funcion responderSaludo.
    if(rS) {
        responderSaludo(this.nombre,this.apellido,false);
    }}
    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(rS) {
    console.log(`Hola, me llamo ${this.nombre} ${this.apellido} y soy desarrollador`)
if(rS) {
    responderSaludo(this.nombre,this.apellido,true);
}
}
}
//generamos una funcion para responder al saludo
function responderSaludo(nombre,apellido,esDev) {
    console.log(`Buen dia ${nombre} ${apellido}`)
    //si recibe la funcion como parametro, entrara al if y ejecutara lo que haya adentro, en este caso,
    //la funcion responderSaludo.
    if (esDev) {
        console.log(`No sabia que eras desarrollador`)
    }
}

var cristian = new Persona('Cristian','Bonomo',1.7);
var alejandro = new Desarrollador('Alejandro','Bonomo',1.6);
//pasamos la funcion para responder saludo de acuerdo a si queremos que nos respondan o no
cristian.saludar();
alejandro.saludar(responderSaludo);

Con Live Server en VS Code es mucho mas cómodo.

class Persona{
    constructor(nombre, apellido, edad, estatura){
        this.nombre = nombre;
        this.apellido = apellido;
        this.edad = edad;
        this.estatura = estatura;
    }
    saludar(fn){
        var {nombre, apellido} = this;
        console.log(`Hola me llamo ${nombre} ${apellido}`)
        if(fn){
             responderSaludo(nombre, apellido, false);
        }else{

        }
    }

    soyAlto(){
        return this.estatura> 1.8;
    }
}

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

    saludar(fn) {
        console.log(`Hola me llamo ${this.nombre} ${this.apellido} y soy desarrollador@`);
        if(fn){
            responderSaludo(this.nombre, this.apellido, true);
       }else{

       }
    }
}

function responderSaludo(nombre, apellido, esDev){
    console.log(`Buen día ${nombre} ${apellido}`);
    if(esDev){
        console.log('ah mirá, no sabia que eras desarrollador/a');
    }
}

var jesus = new Persona('Jesus', 'Castellanos', 29, 1.72);
var erika = new Persona('Erika', 'Luna', 33, 1.65);
//var arturo = new Persona('Arturo', 'Martinez', 85, 1.89);
var arturo = new Desarrollador('Arturo', 'Martinez', 85, 1.89);

jesus.saludar(responderSaludo);
erika.saludar();
arturo.saludar(responderSaludo);

Mi codigo final modificando los if

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

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

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

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

function responderSaludo(nombre, apellido, esDev) {
    console.log(`Buen día ${nombre} ${apellido}`);
    esDev && (console.log('Ah mirá, nosabía que eras desarrollador/a'));
}


const person1 = new Persona('Angie', 'Valencia', 1.60);
const person2 = new Persona('Juancho', 'Pansa', 1.80);
const person3 = new Desarrollador('Alver', 'Grisales', 1.74);

person1.saludar();
person2.saludar(responderSaludo);
person3.saludar(responderSaludo);

Con el debugger se pueden apoyar y revisar como se va ejecutando la lógica

luego pasa al método responderSaludo

const MAX_ALTURA = 1.8;
const MAX_EDAD = 18;
//Aunque se crea como clase es un constructor
class persona {
  constructor(nombre, apellido, edad, altura) {
    this.nombre = nombre;
    this.apellido = apellido;
    this.edad = edad;
    this.altura = altura;
  }
  saludar(fn) {
    console.log(`Hola me llamo ${this.nombre} ${this.apellido}`);
    //Si se manda una funcion como parametro si se manda es true, de lo contrario es undefined -> false
    if (fn) {
      //Para el parametro esDev se puede contestar con false o ser omitido que es equivalente
      fn(this.nombre, this.apellido);
    }
  }
  esAlto() {
    if (this.altura >= MAX_ALTURA) {
      console.log(`Soy alto, mi altura es ${this.altura}`);
    } else {
      console.log(`No soy alto, mi altura es ${this.altura}`);
    }
  }
  esMayorDeEdad() {
    if (this.edad >= MAX_EDAD) {
      console.log(`Soy mayor de edad`);
    } else {
      console.log(`Soy menor de edad`);
    }
  }
}
class desarrollador extends persona {
  //Se heredan los datos de la clase persona
  constructor(nombre, apellido, edad, altura) {
    //Se tiene que mandar llamar a super antes de this.
    super(nombre, apellido, edad, altura);
  }
  saludar(fn) {
    console.log(`Hola mi nombre es ${this.nombre} ${this.apellido} y soy Desarrollador/a`);
    //Si se manda una funcion como parametro si se manda es true, de lo contrario es undefined -> false
    if (fn) {
      fn(this.nombre, this.apellido, true);
    }
  }
}
function responderSaludo(nombre, apellido, esDev) {
  console.log(`Buen día ${nombre} ${apellido}`);
  if (esDev) {
    console.log(`Ah mirá, no sabia que eras desarrollador/a`);
  }
}
//Se llama al constructor, y se crean los nuevos objetos
var joan = new persona('Joan', 'Glaber', 18, 1.72);
var valery = new persona('Valery', 'Smith', 16, 1.57);
var jimmy = new desarrollador('Jimmy', 'Miller', 21, 1.74);
var sophia = new desarrollador('Sophia', 'Jones', 23, 1.75);

joan.saludar(responderSaludo);
valery.saludar(responderSaludo);
jimmy.saludar(responderSaludo);
sophia.saludar(responderSaludo);

Mi código de esta clase:

class Person {
	constructor(name, lastName, age) {
		this.name = name
		this.lastName = lastName
		this.age = age
	}

	greet(fn) {
		console.log(`Hi, my name is ${this.name} ${this.lastName}.`)
		if (fn) {
			fn(this.name, this.lastName, false)
			console.log()
		}
	}

	amAdult() {
		if (this.age < 18) {
			console.log("I'm not adult.")
			return false
		} else {
			console.log("I'm adult.")
			return true
		}
	}
}

class Developer extends Person {
	constructor(name, lastName, age, languages) {
		super(name, lastName, age)
		this.languages = languages
	}

	greet(fn) {
		let languages = ''
		for (let i = 0; i < this.languages.length; i++) {
			i === this.languages.length - 1
				? (languages += 'and ' + this.languages[i] + '.')
				: (languages += this.languages[i] + ', ')
		}
		console.log(
            `Hi I'm ${this.name} ${this.lastName} and I know`
            + `the following languages: ${languages}`
		)
		if (fn) {
			fn(this.name, this.lastName, true)
			console.log()
		}
	}
}

function greetBack(name, lastName, isDev) {
    console.log()
	console.log(`Hi ${name} ${lastName}, nice to meet you.`)
	if (isDev) {
		console.log("It's nice to meet a developer.")
	}
}

let anthony = new Developer('Anthony', 'Luzquiños', 23, [
	'Python',
	'Java',
	'C',
	'C++',
	'JavaScript',
])

let karolay = new Person('Karolay', 'Tamayo', 20)

anthony.greet(greetBack)
karolay.greet(greetBack)
/*
En JavaScript, los parámetros de funciones son por defecto undefined. 
De todos modos, en algunas situaciones puede ser útil colocar un valor 
por defecto diferente que lo evalúe como verdadero.
*/

class Persona {

    //Constructor
    constructor(nombre, apellido, altura) {

        this.nombre = nombre
        this.apellido = apellido
        this.altura = altura
    }

    //Métodos

    saludar(fn) {

        //Forma más prolija es destructurar al objeto, y así se evita escribir this en el resto del código

        var { nombre, apellido } = this

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

        //Si se envía una función se ejecuta
        //Hay ciertos valores que se comportan como false o como true
        // null, 0, '', function vacía, undefined = false || {}, [], 'asadas', function no vacía = True

        if (fn) {
            //Llamado de la función y se envían parámetros
            fn(nombre, apellido)

        }
    }

    soyAlto() {
        return this.altura > 1.8
    }

}

class Desarrollador extends Persona {

    constructor(nombre, apellido, altura) {

        //Antes de usar this se debe llamar al constructor de la clase padre, se emplea el método Super
        super(nombre, apellido, altura)

    }

    saludar(fn) {

        //Forma más prolija es destructurar al objeto, y así se evita escribir this en el resto del código

        var { nombre, apellido } = this

        //Forma equivalente
        // nombre = this.nombre
        // apellido = this.apellido


        console.log(`Hola, me llamo ${nombre} ${apellido} y soy Desarrollador(a)`)
        if (fn) {
            //Llamado de la función y se envían parámetros
            fn(nombre, apellido, true)

        }
    }
}

function responderSaludo(nombre, apellido, esDev) {

    console.log(`Buen día ${nombre} ${apellido}`)

    if (esDev) {
        console.log(`Ah mirá, no sabía que eras desarrollador(a)`)
    }

}


var sacha = new Desarrollador('Sacha', 'Lifszyc', 1.71)
var alexander = new Desarrollador('Alexander', 'Almengor', 1.75)
var armando = new Desarrollador('Armando', 'Almengor', 1.72)
var anibal = new Persona('Anibal', 'Verbel', 1.82)

sacha.saludar()
alexander.saludar(responderSaludo)
armando.saludar(responderSaludo)
anibal.saludar(responderSaludo)

<clase26.js>
classPersona{
    //Constructor
    constructor(nombre, apellido, altura) {
        this.nombre = nombre
        this.apellido = apellido
        this.altura = altura
    }

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

    soyAlto() {
        returnthis.altura > 1.8
    }
}

classDesarrolladorextendsPersona{
    constructor(nombre, apellido, altura) {
        super(nombre, apellido, altura)

    }

    saludar(fn) {

        var { nombre, apellido } = this
        console.log(`Hola, me llamo ${nombre}${apellido} y soy Desarrollador(a)`)
        if (fn) {
            fn(nombre, apellido, true)
        }
    }
}

functionresponderSaludo(nombre, apellido, esDev) {

    console.log(`Buen día ${nombre}${apellido}`)
      if (esDev) {
    console.log(`Ah mirá, no sabía que eras desarrollador(a)`)
    }

}


var sacha = new Desarrollador('Sacha', 'Lifszyc', 1.71)
var daniel = new Desarrollador('Daniel', 'Dominguez', 1.80)
var arturo = new Desarrollador('arturo', 'tello', 1.70)
var paula = new Persona('paula', 'torres', 1.82)

sacha.saludar()
alexander.saludar(responderSaludo)
armando.saludar(responderSaludo)
anibal.saludar(responderSaludo)

Muy buena explicación 😄

magnifico!
muy buena clase se abren cientos de posibilidades

Recuerden siempre el CLEAN CODE, usar código de programación lo más claro posible.

excelentes las funciones como parámetros siempre estar pendiente al usar el this tambien sufrí el error me gusta probar antes de seguir el curso y vivir los problemas antes de q sean resueltos aca

creo que es necesario volver a hacelo, ya que me parecio confuso.

class Persona {
    constructor(nombre, apellido, altura) {
        this.nombre = nombre
        this.apellido = apellido
        this.altura = altura
    }
    saludar(fn){
        var { nombre, apellido, altura } = this
        console.log(`Hola me llamo ${nombre} ${apellido} mi estatura es: ${altura}`);
        if (fn) {
            fn(nombre, apellido, true)
        }
    }

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

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

    saludar(fn) {
        var { nombre, apellido } = this
        console.log(`hola, me llamo ${nombre} ${apellido} y soy desarrollador@`);
        if (fn) {
            fn(nombre, apellido, true)
        }
    }
}

function responderSaludo(nombre, apellido, esDev) {
    console.log(`Buen dia ${nombre} ${apellido}`)
    if (esDev) {
        console.log(`No sabia que eres desarrollador`)
    }
}

 var fran = new Persona('Francisco', 'Garcia', 1.69);
 var liz = new Persona('Liz', 'Luna', 1.81);
 var juanda = new Desarrollador('Juan David', 'Garcia', 1.83);
 var pao = new Persona('Paola', 'Betancur', 1.60);
//var juanda = new Desarrollador('Juan David', 'Garcia', 1.83);


fran.saludar()
liz.saludar(responderSaludo)
juanda.saludar(responderSaludo)
pao.saludar(responderSaludo)

buena clase, falta practicar mas

despues de darle un par de dias a las clases y prototypes llegue alasincronismo!

Interesante!!!

Hey there! This is a short explanation for those who did not understand correctly:

In a nutshell, what we want to do here in this class is to make a function that answers a greet back.

So the first step we do is to define a function that gives us back the greet and define name, surname, isDev(to validate if the person is a developer or not) as parameters, just like this:

functionanswerGreet(name, surname, isDev){
    console.log(`Good morning ${name}${surname}`)
    if(isDev){
        console.log(`Oh, I didn't know you're a Developer!`)
    }
}

Ok, I bet that you understand everything until here, keep with me.

The second step is very easy, you just have to initialize the variable of the prototype(object), define the greet method, and put the new function(answerGreet) as a parameter:

var sebastian = new developer('Sebastian','Mera',17,1.76)
var caroline = new person('Caroline', 'Cristales',17,1.74)
var robert = new person('Robert','Reven',26,1.77)


sebastian.greet(answerGreet)
caroline.greet(answerGreet)
robert.greet(answerGreet)

Then add the function as a parameter in the greet method inside of the prototypes you have:

class person{
constructor(name, surname, age, tall){
this.name = name
this.surname = surname
this.age = age
this.tall = tall
}
greet(fn){
…
}
class developer extends person {
constructor(name, surname, age, tall){
super(name, surname, age, tall)
}
greet(fn){
…
}

In this case, I added ‘fn’ as a parameter but remember that you can add anything you want because this parameter is copying everything from the parameter in the variable of step two:
sebastian.greet(answerGreet)

Then inside of the greet, we declare a variable as an object that makes this to safe time coding:

var {name, surname, age, tall} = this

and as the last step, we add a conditional that verifies that the function is true, and if it is, it will send it the values of name(this.name), surname(this.surname), isDev(true) as a parameter:

if(fn){
fn(name,surname,false)
}
        var {name, surname, age, tall} = this
        if(this.tall >= 1.80){
            console.log(`Hey, I'm ${name} ${surname}, I'm ${age} years old and I'm ${tall} mts tall and I'm tall`)
            if(fn){
                fn(name,surname,false)
            }
        }
        else{
            console.log(`Hey, I'm ${name} ${surname}, I'm ${age} years old and I'm ${tall} mts tall and I'm not tall`)
            if(fn){
                fn(name,surname, false)
            }
        }
    }

Basically, what we do here is what we already learned with some additional code. We’re just adding real value to the parameters of the function answerGreet(name, surname, isDev) from the prototype with the parameter we put (fn(name, surname, true), in this case) when we make sure the conditional is true.

And that’s it, I really hope you guys have understood this class with this explanation I made and I’m also open to receiving feedback to make my contributions better.

class Persona{
    constructor(nombre, apellido, altura){
        this.nombre = nombre
        this.apellido = apellido
        this.altura = altura 
    }
    saludar(fn){
        var {nombre, apellido} = this
        console.log(`hola, ne llamo ${nombre} ${apellido}`)
        if(fn){
            fn(nombre,apellido)
        }
    }

    soyAlto(){
        return this.altura > 1.8
    } 
}
class Desarrollador extends Persona {
    constructor (nombre, apellido, altura){
        super(nombre,apellido,altura)
    }
    saludar (fn){

        var {nombre,apellido} = this 

        console.log(`hola, me llamo ${nombre} ${apellido} soy desarrollador`)
        if(fn){
            fn(nombre, apellido , true)
        }
    } 
}
 

function responderSaludo(nombre, apellido, esDev){
    console.log(`Buen dia ${nombre} ${apellido}`)

    if (esDev){
        console.log(`Ah mirá, no sabía que eras desarrollador /a`)
        
    }
}

var deyvi = new Persona('deyvi', 'Bustamante', 1.71)
var ruth = new Persona('ruth', 'cardozo', 1.41)
var maciel = new Desarrollador('maciel', 'Bustamante', 0.71)


deyvi.saludar()
ruth.saludar(responderSaludo)
maciel.saludar(responderSaludo)

Ayuda chicos, mi código, desde aqui, no funciona, no encuentro que puedo tener mal, por fa, alguien que me ayude, gracias.

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

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`)
     }
}

function responderSaludo(nombre, apellido, esDev){
    console.log(`Buen día ${nombre} ${apellido}`)
    if (esDev) {
        console.log (`Ah mirá, no sabpia que eras desarrollador /a`)
    }
}

var adriana = new Persona('adriana', 'ardila', 1.50);
var aron = new Persona('aron', 'luna', 1.65);
var andres = new Persona('andres', 'lopez', 1.80); 

adriana.saludar()
aron.saludar()
andres.saludar()```

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

  saludar(fn){
    console.log(`Hola me llamo ${this.nombre} y tengo ${this.edad}`)
    if (fn){
      fn(this.nombre, this.edad)
    }
  }

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

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

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



function responderSaludo(nombre, apellido, esDev){
  console.log(`Buen día ${nombre} `)
  if (esDev){
    console.log(`Ah mirá, no sabía que eras desarrollador/a`)
  }
}

var andres = new Persona("Andres", 32, 1.75)
var viviana = new Persona("Viviana", 29, 1.56)
var arturo = new Desarrollador("Arturo", 31, 1.80)

andres.saludar()
viviana.saludar(responderSaludo)
arturo.saludar(responderSaludo)

class Persona {
    constructor(nombre, apellido, altura) {
        this.nombre = nombre;
        this.apellido = apellido;
        this.altura = altura;
    }
    saludar(fn) {
        /* var nombre = this.nombre;
        var apellido = this.apellido;
        sirve para escribirlo de otra aforma rcortando codigo */
        var { nombre, apellido} = this
        /* esto es equivalente a las variables anteriores */
        console.log(`Hola, me llamo ${nombre} ${apellido}`)
        if (fn) {
            fn(nombre, apellido, false);
        }
        /* como tercer parametro de la funcion responder saludo enviamos un datos que sea interpretado como false */
        /* example false, null. o lo omitimos para que quede como undefined. */
    }
    soyAlto() {
        return this.altura > 1.8
    }
}


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

}

function responderSaludo(nombre, apellido, esDev) {
    console.log(`Buen dia ${nombre} ${apellido}`);
    if (esDev) {
        console.log(`Ah mira, no sabia que eras desarrollador/a`);
    }
}
/* creamos funcion que responde el saludo y si la persona es desarrollador tambien contesta que no sabia esa informacion */
var johan = new Persona("Johan", "Echeverri", 1.81);
var erika = new Persona("Erika", "Popo Ocoro", 1.5);
var elNegro = new Desarrollador("El negro", "Del whats App", 2);

johan.saludar(responderSaludo);
erika.saludar(responderSaludo);
elNegro.saludar(responderSaludo);

Funciones como parametro !

Para hacer lo que Sacha hace en el min 2:10 de triplicar un elemento sin necesidad de copiar y pegar se hace con:

Shift + Alt + Flecha hacia abajo

I hope you like it😎👍

1. Funciones como parámetros

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(fn) {
        // var nombre = this.nombre;
        // var apellido = this.apellido;
        console.log(`Hola, me llamo ${this.nombre} ${this.apellido}.`);
        if(fn) {
            fn(this.nombre, this.apellido);
        }
    }
    soyAlto() {
        return this.altura > 1.8;
    }
}
class Desarrollador extends Persona {
    constructor(nombre, apellido, altura) {
        super(nombre, apellido, altura);
    }
    saludar(fn) {
        console.log(`Hola, me llamo ${this.nombre} ${this.apellido} y soy Desarrollador/a.`);
        if(fn) {
            fn(this.nombre, this.apellido, true);
        }
    }
}
function responderSaludo(nombre, apellido, esDev) {
    console.log(`Buen día ${nombre} ${apellido}`);
    if(esDev) {
        console.log(`Ah mirá, no sabía que eras desarrollador/a.`);
    }
}

//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 Desarrollador('Arturo', 'Martinez', 1.69);
sacha.saludar();
erika.saludar(responderSaludo);
arturo.saludar(responderSaludo);

// sacha.soyAlto();
// erika.soyAlto();
// arturo.soyAlto();
<h4>Funciones como parámetros</h4>

Es posible pasar funciones como parámetros como si fuera cualquier otro tipo de variable.

class Persona {
  constructor(nombre, apellido, altura) {
    this.nombre = nombre;
    this.apellido = apellido;
    this.altura = altura;
  }
  saludar(fn) {
    var {nombre, apellido, altura} = this // Desestructurizamos los parámetros de la clase (Prototipo)
    console.log(`Hola, me llamo ${nombre} ${apellido} y mido ${altura} metros`);
    
		if(fn){ // Si pasamos alguna función como parámetro entonces se ejecutará lo siguiente
      fn(nombre, apellido)
    }
  }
}

// Función que será el parámetro
function responderSaludo(nombre, apellido, esDev) {
  console.log(`Buen día ${nombre} ${apellido}`);
  if(esDev){
    console.log(`Ah no sabía que eras desarrollador`);
  }
}

var brandon = new Desarrollador("Brandon Argel", "Verdeja Domínguez", 1.8); // Creamos una instancia de la clase

brandon.saludar(responderSaludo) // Ejecutamos un método de la clase con la instancia que creamos y llamamos a 
// como parámetro otra función
class Person {
    constructor(name, lastname, years, weigth) {
        this.name = name
        this.lastname = lastname
        this.years = years
        this.weigth = weigth
    }

      salute(fn){
    console.log(`Hi my name is ${this.name} ${this.lastname} and I'm ${this.years} years`)
    if (fn) {
      fn(this.name, this.lastname) 
    }
}

      esAlta() {
    return this.weigth >= 1.8 
    }
}

class Developer extends Person {
    constructor(name, lastname, years, weigth) {
        super (name, lastname, years, weigth)   
        }

    salute(fn){
        console.log(`Hi I'm Developer my name is ${this.name} ${this.lastname} and I'm ${this.years} years`)
        if (fn) {
            fn(this.name, this.lastname, true) 
          }
      }
}

function answerGretting(name, lastname, esDev) {
    console.log(`Good Morning ${name} ${lastname}`)
    if (esDev) {
        console.log(`Great, I didn't know you were dev`)
    }
}



var jeffer = new Person("Jeffer", "Nuñez", 22, 1.75)
var lia = new Person("Lia", "Yuanghuan", 18, 1.58)
var jose = new Person("Jose", "Rios", 35, 1.80)
var lisa = new Developer("Lisa", "Roman", 19, 1.65)

jeffer.salute(answerGretting)
lia.salute(answerGretting)
lisa.salute(answerGretting)

La forma en la que logré que el saludo de si es dev o no y se colocara en la misma línea de saludo y no en otra separada fue la siguiente

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

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

}


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

    saludar (fn){
        var {nombre, apellido} = this
        console.log(`Hola, me llamo ${nombre} ${apellido} y soy desarrrolador/a`)
        if (fn){
            fn(nombre, apellido, 'Es Dev')
        }
    }
}

function responderSaludo(nombre, apellido, esDev) {
    if(esDev){
        var esDev = 'desarrollador'
    console.log(`Hola ${nombre} ${apellido}, veo que eres ${esDev}`)
    } else {
        console.log(`Hola ${nombre} ${apellido}`)
    }

}

var gabriel = new persona ('Gabriel', 'Gonzalez');
var julio = new desarrollador ('Julio', 'Quintero');


julio.saludar(responderSaludo);
gabriel.saludar(responderSaludo);

Como siempre, en caso de algún fallo o algúna forma de mejorar, házmelo saber por favor!

Para el desarrollador, es la misma lógica, pero el parámetro a validar esta vez debe ser TRUE.

Buena clase!

Gracias!

a partir de aqui ya me empieza a revolver la cabeza

Viste el video y no entendiste?

Aquí hay algo que os podría ayudar, a mi me sirvió!!

https://www.youtube.com/watch?v=EA94aQwqVsY

Esas funciones que se pasan como parámetro de otra función se llaman “callbacks”, dicho nombre proviene de call - back, o llamada de regreso cuando una función termina de ejecturse, y son muy útiles… cuando no hacemos un callback hell

Functions as parameters


Porque a Erika le devolvió el saludo pero a Sacha no? si ambos eran Persona y no desarrolladores?

Gracias!!!

muy buena clase 😄

Por ejemplo si la funcion responderSaludo tuviera otra funcion seria arturo.saludar(responderSaludo(miOtrafn)) ???

¿Por qué s ele puso al parámetro de la función saludar(), fn? ¿Es alguna convención de la comunidad JS, o qué?

siempre van a ser false{
0;
null;
string vacio
}
siempre va ser true{
objeto {}
array []
function() //si existe
}

class  Persona{
  constructor (nombre,apellido, altura){
    this.nombre=nombre
    this.apellido=apellido
    this.altura=altura
  }
  saludar(rS){
    //var nombre=this.nombre
    //var apellido= this.apellido
    console.log (`hola me llamo ${this.nombre} ${this.apellido}`)
    if(rS){
      rS(this.nombre,this.apellido,false)
    }
  }
  soyAlto(){
    return this.altura>1.70
  }
}

class Desarrollador extends Persona{
  constructor ( nombre,apellido,altura){
    super(nombre,apellido,altura)
  }
  saludar(rS){
    var {nombre,apellido}= this
    console.log(`Hola, me llamo ${nombre} ${apellido} y soy Desarrollador`)
    if(rS){
      rS(nombre,apellido,true)
    }
  }

}
  function responderSaludo(nombre,apellido,esdev){
    console.log(`Buenos dias ${nombre} ${apellido}`)
    if(esdev){
      console.log(`Ha mira, no sabia que eras desarrolador/a`)
    }
  }
var katy=new Persona('katy','jara',1.81)
var raul=new Persona('raul','romero',1.75)
var alexz=new Desarrollador('alexz','turpo',1.74)

katy.saludar(responderSaludo);
raul.saludar(responderSaludo);
alexz.saludar(responderSaludo)```

-genial cuando puso el ejemplo de que eres desarrolladora
😃 Saludos

IDEAS CLAVES

=> Puedo pasar funciones como parametros de otra función
=> Mientras sea legible siempre es bueno limpiar codigo
=>
=>

Aprendi a ejecutar esas funciones que llegan como parametro

simplemente ponemos los parantesis de ejecucion

Control de errores

//Me equivoque con la invoacion inicla de la funcion como parametro porque no coloque el this en el cuerpo de su funcion y la funcion de las clases
//
------------------------------*/

No entiendo en que momento “fn” recibe un valor 😦

Excelente clase!!

de las clases que mas me han gustado , la parte que mas capta mi atencion , es aprender como simplificar el codigo , y escribir un codigo legible y limpio , algo fundamental que debemos aprender los novatos!!!

eso de que si pones fn en el if y si te la mandan da true y si no da false es por que si no te la mandan da: Undifined que es lo mismo que false.

Excelente modo de aprender funciones paramétricas 😃

Muy buena clase.

Good.! Good.! Good.!

Muy importante al invocar la funcion saludar.

sasha.saludar(responder)
           //vs//
sasha.saludar(responder())

Al escribir sasha.saludar( responder() ), los parametros de responder sera undefined. Sin el ‘()’, tomara los parametros DENTRO de la funcion saludar.

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

    saludar(fn) {
        var {nombre, apellido} = this
        console.log(`hola, me llamo ${this.nombre} ${this.apellido} y tengo ${this.altura} años`)
        if (fn){
            fn(nombre, apellido, false)
        }
     }  
      soyalto(){
          return this.altura > 40
      }  
}
   


class desarrollador extends animal {
    constructor(nombre, apellido, altura){ 
        super(nombre, apellido, altura)
     }
     saludar(fn){
         //var nombre = this.nombre
         //var apellido = this.apellido
         var {nombre, apellido} = this
        console.log(`hola, me llamo ${this.nombre} ${this.apellido} y tengo ${this.altura} años soy desarrolladora`)
        if (fn) {
            fn(nombre, apellido, true)
        }
     }

}


    function respondersaludo(nombre, apellido, esdev){
        console.log(`buen dia ${nombre} ${apellido}`)
        if (esdev){
            console.log(`ah no sabia que eras desarrollador@r}`) 
        }

    }

  

var prisila = new animal('prisila', 'ramirez', 26)
var princesa = new desarrollador('princesa', 'luna', 40)
var candy = new animal('candy', 'romana', 50)

prisila.saludar()
princesa.saludar(respondersaludo)
candy.saludar(respondersaludo)>

tengo una duda en una de clases anteriores vimos el prompt pero en mi navegador cuando sale el dialogo aparece esta ¿Cual es tu signo? es A extraña el codigo que estoy ejecutando seria este var signo = prompt(¿Cual es tu signo?)