¡Te damos la bienvenida a este reto!

1

¡Bienvenido al mundo de JavaScript!

Día 1

2

Variables, funciones y sintaxis básica

3

Tipos de datos

4

Playground - Retorna el tipo

5

Tipos de datos - pt 2

Día 2

6

Operadores

7

Hoisting y coerción

8

Playground - Calcula la propina

9

Alcance de las variables

Día 3

10

Condicionales

11

Playground - Calcula años bisiestos

12

Switch

13

Playground - Obten información de mascotas según su tipo

14

Ciclos

15

Playground - Dibuja un triangulo

Día 4

16

Arrays

17

Playground - Encuentra al michi mas famoso

18

Objetos

19

Playground - Obten el promedio de los estudiantes

Día 5 - Checkpoint

20

Playground - encuentra el palindromo más grande

Día 6

21

Reasignación y redeclaración

22

Modo estricto

Día 7

23

Debugging y manejo de errores

24

Programación funcional

Quiz: Día 7

Día 8

25

Closures

26

Playground - Crea una calculadora con closures

27

Higher order functions

28

Playground - Crea tu propio método map

Día 9

29

ECMAScript

30

TC39

Quiz: Día 9

Día 10 - Checkpoint

31

ES6

32

ES7

33

Playground - Task planner

Día 11

34

Asincronismo

35

Playground - Promesas

36

Manejando el asincronismo

37

Playground - Resuelve el callback hell usando promesas

38

Playground - Resuelve el callback hell usando async/await

Día 12

39

Arrays a profundidad

40

Métodos de arrays: Every, Find y findIndex

41

Playground - Válida el formulario

Día 13

42

Métodos de arrays: Includes, Join y concat

43

Playground - agrupa los productos

44

Métodos de arrays: Flat y FlatMap

45

Playground - Encuentra la ubicación del valor buscado

Día 14

46

Mutable functions

47

Playground - Modifica una lista de compras

48

Métodos de arrays: sort

49

Playground - Ordena los productos

Día 15 - Checkpoint

50

Playground - Sistema de reservaciones de un hotel

Día 16

51

Programación orientada a objetos en JavaScript

52

Objetos literales

53

Playground - Congela el objeto recursivamente

Día 17

54

Prototipos en JavaScript

55

Playground - Modifica el prototype de los arrays

56

Playground - Crea un auto usando clases

Día 18

57

Abstracción en JavaScript

58

Playground - Sistema de carrito de compras

59

Encapsulamiento en JavaScript

60

Playground - Encapsula datos de los usuarios

Día 19

61

Herencia en JavaScript

62

Playground - Jerarquía de animales

63

Polimorfismo en JavaScript

64

Playground - Sistema de pagos

Día 20 - Checkpoint

65

Playground - Agenda de vuelos

Día 21

66

Patrones de diseño

67

Sinlgeton y Factory pattern en JavaScript

68

Playground - Implementa singleton en un chat

Día 22

69

Adapter y Decorator pattern en JavaScript

70

Playground - Personaliza productos de una tienda

71

Builder y Protype pattern en JavaScript

72

Playground - Mejora el código usando builder pattern

Día 23

73

Facade y proxy pattern en JavaScript

74

Playground - Proxy en servicio de mensajería

75

Chain of responsability y Observer pattern en JavaScript

76

Playground - Implementación de Observador en Newsletter

Día 24 - Checkpoint

77

Playground - Crea un task manager con patrones de diseño

Día 25

78

Estructuras de datos en JavaScript

79

Playground - Crea tu propia implementación de un array

80

Hash tables en JavaScript

81

Playground - Implementación de una HashTable para Contactos

Día 26

82

Set en JavaScript

83

Playground - Remueve duplicados de una lista

84

Maps en JavaScript

85

Playground - Crea un organizador de tareas

Día 27

86

Singly Linked List en JavaScript

87

Playground - Agrega métodos a la singly linked list

88

Playground - Implementación de una singly linked list

Día 28

89

Stacks en JavaScript

90

Playground - Crea un stack para una playlist

Día 29

91

Queues en JavaScript

92

Playground - Crea una cola de emails

Día 30

93

¡Lo lograste!

Live Class

94

30 días de JS con Juan DC

95

30 días de JS con Nicobytes

96

30 días de JS con GNDX

97

30 días de JS con LeoCode

98

30 días de JS con Teffcode

99

Sesión: Cierre de los 30 días de JavaScript

No tienes acceso a esta clase

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

Quedan menos de 24 hrs para aprender Inglés, AI y más a precio especial.

Antes: $249

Currency
$209
Suscríbete

Termina en:

0 Días
9 Hrs
15 Min
16 Seg

Playground - Jerarquía de animales

62/99

Aportes 42

Preguntas 0

Ordenar por:

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

SPOILERS


.
.

.
.
.

.
.
.
.
.

.
.

Este ejercicio ha sido el mas "raro"
Primero un error de tipeo creo en decir:

La clase base será Animal con las propiedades name, age y species y un método getInfo

cuando en los ejemplos y test esta “especie”

{
  name: "pepe",
  age: 1,
  specie: "bird",
}

luego en el test de Dog es raro, la parte del constructor, specie, siempre toma un valor unico que es “dog” y luego breed da undefined pero si cambias la posicion de breed en el lugar donde estaba especie,

breed toma el valor q esperan los test, a lo mejor es un error mio de compresion lectora, pero bueno.

mi codigo:

export class Animal {
  constructor(name, age, specie) {
    this.name = name;
    this.age = age;
    this.species = specie;
  }

  getInfo() {
    return {
      "name": this.name,
      "age": this.age,
      "specie": this.species
    }
  }

}

export class Mammal extends Animal {

  constructor(name, age, specie, hasFur) {
    super(name, age, specie);
    this.hasFur = hasFur;
  }

  getInfo() {
    const { name, age, specie } = super.getInfo()
    return { name, age, specie, "hasFur": this.hasFur }
  }

}

export class Dog extends Mammal {

  constructor(name, age, breed, hasFur) {
    super(name, age, "dog", hasFur);
    this.breed = breed;
  }

  getInfo() {
    const { name, age, specie, hasFur } = super.getInfo()
    return { name, age, specie, hasFur, "breed": this.breed }
  }

  bark() {
    return "woof!"
  }

}

Mi aporte:
Sigo insistiendo que el asincrotismo ha sido lo más dificil.
.
.
.
.
.
.
.
.

export class Animal {
  constructor(name, age, specie) {
    this.name = name;
    this.age = age;
    this.specie = specie;
  }
  getInfo() { 
    return this
  }
}

export class Mammal extends Animal{
  constructor(name, age, specie, hasFur) { 
  super(name, age, specie);
  this.hasFur = hasFur;
  }
  getInfo() { 
    return {...this, ...this.hasFur}
  }
}

export class Dog extends Mammal {
  constructor(name, age, breed, hasFur, specie="dog") { 
    super(name, age, specie, hasFur);
    this.breed = breed;
  }
  getInfo() {
    return this
  }
  bark() { 
    return "woof!"
  }
}

Comparto la solución. Hay 2 problemas con el código
 

  1. “species” en realidad es “specie” tengan en cuenta cuando hagan el código
  2. No lo dice en ningún momento, por lo que hay que deducirlo según los ejemplos (muy mal). Pero cuando creamos Dog, “specie” va a ser siempre dog, y breed deberá tomar el lugar de specie, ya que como vemos en el ejemplo, pone la raza del perro en el 3er parámetro
     
     
     
     
     
     
     
export class Animal {
  constructor(name, age, specie) {
    this._name = name
    this._age = age
    this._specie = specie
  }

  getInfo() {
    return {'name':this._name,'age':this._age,'specie':this._specie}
  }
}

export class Mammal extends Animal{
  constructor(name, age, specie, hasFur) {
    super(name, age, specie)
    this._hasFur=hasFur
  }

  getInfo() {
    return Object.assign({},super.getInfo(),{'hasFur':this._hasFur})
  }
}

export class Dog extends Mammal{
  constructor(name, age, breed, hasFur) {
    super(name, age, "dog" ,hasFur)
    this._breed = breed
  }

  getInfo() {
    return Object.assign({}, super.getInfo(), {'breed': this._breed })
  }

  bark() {
    return "woof!"
  }
}

Mi solución
.
.
.
.
.
.
.
.
.
.
.
.
.

export class Animal{
    constructor(name,age,specie){
        this.name=name;
        this.age=age;
        this.specie=specie;
    }
    getInfo(){
        return this;
    }
}

export class Mammal extends Animal{
    constructor(name,age,specie,hasFur){
        super(name,age,specie);
        this.hasFur =hasFur;
    }
    getInfo(){
        return this;
    }

}

export class Dog extends Mammal{
    constructor(name,age,breed,hasFur,specie="dog"){
        super(name,age,specie,hasFur);
        this.breed = breed;
    }
    getInfo(){
        return this;
    }
    bark(){
        return("woof!");
    }

}

🛡️Escudo anti-spoilers🛡️

Mi solucion:

export class Animal {
  constructor(name, age, specie) {
    this.name = name
    this.age = age
    this.specie = specie
  }

  getInfo() {
    return {
      name: this.name,
      age: this.age,
      specie: this.specie,
    }
  }
}

export class Mammal extends Animal {
  constructor(name, age, specie, hasFur) {
    super(name, age, specie)
    this.hasFur = hasFur
  }
  getInfo() {
    const res = super.getInfo()
    return {
      ...res,
      hasFur: this.hasFur
    }
  }
}

export class Dog extends Mammal {
  constructor(name, age, breed, hasFur) {
    super(name, age, "dog", hasFur)
    this.breed = breed
  }
  getInfo() {
    const res = super.getInfo()
    return {
      ...res,
      breed: this.breed,
    }
  }
  bark() {
    return "woof!"
  }
}

Aquí mi solución, y si, tienen razón, este ejercicio muy raro, el constructor de Dog con los parámetros en este orden constructor(name, age, hasFur, breed) no me funcionaba, pero después de cambiar el orden a: constructor(name, age, breed, hasFur), recién funcionó, debo decir que en la consola de Chrome funcionó normal, ¿alguien podría explicar eso?, creo que el Playground de Platzi debe pulirse un poco mas y por supuesto los enunciados, ya que siempre tienen errores.

export class Animal {
  constructor(name, age, specie) {
    this.name = name;
    this.age = age;
    this.specie = specie;
  }
  getInfo() {
    return this;
  }
}

export class Mammal extends Animal {
  constructor(name, age, specie, hasFur) {
    super(name, age, specie);
    this.hasFur = hasFur;
  } 
  getInfo() {
    return this;
  }
}

export class Dog extends Mammal {
  constructor(name, age, breed, hasFur) {
    super(name, age, "dog", hasFur);
    this.breed = breed;
  }
  getInfo() {
    return this;
  }
  bark() {
    return "woof!";
  }
}

Comparto mi solución porque el getInfo() lo resolví con una línea de código
.
.
.
.
.
.
.
.
.

export class Animal {
  // Tu código aquí 👈
  constructor(name, age, specie) {
    this.name = name
    this.age = age
    this.specie = specie
  }
  getInfo() {
    return this
  }
}

export class Mammal extends Animal {
  // Tu código aquí 👈
  constructor(name, age, specie, hasFur) {
    super(name, age, specie)
    this.hasFur = hasFur
  }
  getInfo() {
    return this
  }
}

export class Dog extends Mammal{
  // Tu código aquí 👈
  constructor(name, age, breed, hasFur) {
    super(name, age, "dog", hasFur)
    this.breed = breed
  }
  getInfo() {
    return this
  }
  bark() {
    return "woof!"
  }
}

Recomendación con mucho respeto y cariño para nuestro instructor, desde que inicie el curso hay un gran porcentaje de retos con una mala redacción y eso afecta mucho cuando estos ejercicios tienen que pasar por un test, donde lógicamente las respuestas ya están controladas. Este reto fue muy sencillo y se que muchos estarán de acuerdo conmigo, sin embargo, he perdido bastante tiempo en encontrar un error que se esta causando dentro mismo test. Tomen en cuenta que muchos evitamos ver los comentarios cuando estamos haciendo el ejercicio para evitar spoilers… vaya casualidad la mía, encontrarme con un gran numero de comentarios reportando un error en la clase Dog.
Mi comentario lo hago con la intención de mejorar, tomen en cuenta que muchos ya tenemos experiencia en programación y tenemos paciencia cuando un error se presenta, pero puede llegar a ser muy frustrante para alguien nuevo. 😃
Mi comentario es porque no es el único ejercicio que me he encontrado en este curso con typos. Sugerencia -> debe haber alguien adicional que verifique todo antes de publicar el curso. 😃
Bueno nada tanto texto me ayudo para evitar spoilers… aunque siendo sinceros quizás en un caso como este conviene hacer el spoiler .
Solución:

Buenas tardes, comparto mi solución: ```js export class Animal { constructor(name, age, specie) { this.name = name; this.age = age; this.specie = specie; } getInfo() { return this; } } export class Mammal extends Animal { constructor(name, age, specie, hasFur) { super(name, age, specie); this.hasFur = hasFur; } getInfo() { return this; } } export class Dog extends Mammal { constructor(name, age, breed, hasFur, specie = "dog" ) { super(name, age, specie, hasFur); this.breed = breed; } getInfo() { return this; } bark() { return "woof!"; } } ```

Creo que este ejercicio tiene demasiados fallos, me demore demasiado tiempo intentando encontrar la solucion de los errores que habia tenido y resultaba que eran errores sobre como estaba compuesto del ejercicio.

Desafio completado!

🛡️🛡️🛡️Escudo anti spoilers🛡️🛡️🛡️

Jerarquia de animales

export class Animal {
  // Tu código aquí 👈
  constructor(name, age, specie) {
    this.name = name;
    this.age = age;
    this.specie = specie;
  }

  getInfo() {
    return {
      name: this.name,
      age: this.age,
      specie: this.specie,
    };
  }
}

export class Mammal extends Animal {
  // Tu código aquí 👈
  constructor(name, age, specie, hasFur) {
    super(name, age, specie);
    this.hasFur = hasFur;
  }
  getInfo() {
    return { ...super.getInfo(), hasFur: this.hasFur };
  }
}

export class Dog extends Mammal {
  // Tu código aquí 👈
  constructor(name, age, breed, hasFur) {
    super(name, age, "dog", hasFur);
    this.breed = breed;
  }
  getInfo() {
    return { ...super.getInfo(), breed: this.breed };
  }
  bark() {
    return "woof!";
  }
}

Mi solución 💚 (realmente deberían de cambiar la redacción por los problemas en la varialbe specie y en cómo se define Dog.

.
.
.

export class Animal {
  constructor(name, age, specie) {
    this.name = name;
    this.age = age;
    this.specie = specie;
  }

  getInfo() {
    return {
      name: this.name,
      age: this.age,
      specie: this.specie
    }
  }
}

export class Mammal extends Animal {
  constructor(name, age, species, hasFur) {
    super(name, age, species);
    this.hasFur = hasFur;
  }
  getInfo() {
    return {
      ...super.getInfo(),
      hasFur: this.hasFur
    }
  }
}

export class Dog extends Mammal {
  constructor(name, age, breed, hasFur) {
    super(name, age, "dog", hasFur);
    this.breed = breed;
  }
  getInfo() {
    return {
        ... super.getInfo(),
        breed: this.breed,
    }
  }
  bark() {
    return "woof!"
  }
}
export class Animal {
  constructor(name, age, specie) {
    this.name = name
    this.age = age
    this.specie = specie
  }
  getInfo() {
    return {
      name: this.name,
      age: this.age,
      specie: this.specie
    }
  }
}

export class Mammal extends Animal {
  constructor(name, age, specie, hasFur) {
    super(name, age, specie)
    this.hasFur = hasFur
  }
  getInfo() {
    const obj = super.getInfo()
    return {
      ...obj,
      hasFur: this.hasFur
    }
  }
}

export class Dog extends Mammal {
  constructor(name, age, breed, hasFur) {
    let specie = "dog"
    super(name, age, specie, hasFur)
    this.breed = breed
  }
  getInfo() {
    const obj = super.getInfo()
    return {
      ...obj,
      breed: this.breed
    }
  }
  bark() {
    return "woof!"
  }
}

export class Animal {
  // Tu código aquí 👈
  constructor(name, age, specie) {
    this.name = name;
    this.age = age;
    this.specie = specie;
  }
  getInfo() {
    return this;
  }
}

export class Mammal extends Animal{
  // Tu código aquí 👈
  constructor(name, age, specie, hasFur) {
    super(name, age, specie);
    this.hasFur = hasFur;
  }
  getInfo() {
    return { ...this, ...this.hasFur };
  }
}

export class Dog extends Mammal{
  // Tu código aquí 👈
  constructor(name, age, breed, hasFur, specie = "dog") {
    super(name, age, specie, hasFur);
    this.breed = breed;
  }
  getInfo() {
    return { ...this, ...this.breed };
  }
  bark() {
    return 'woof!';
  }
}

Hola, Comparto la solución al reto.















export class Animal {
  constructor(name, age, specie) {
    this.name = name;
    this.age = age;
    this.specie = specie;

  }

  getInfo() {
    return this;
  }
}

export class Mammal extends Animal {
  constructor(name, age, specie, hasFur) {
    super(name, age, specie);
    this.hasFur = hasFur;
  }

  getInfo() {
    return this;
  }
}

export class Dog extends Mammal {
  constructor(name, age, breed, hasFur) {
    super(name, age, "dog", hasFur);
    this.breed = breed;
  }

  getInfo() {
    return this;
  }

  bark() {
    return "woof!";
  }
}


.
.
.
.
.
.

export class Animal {
  constructor(name, age, specie) {
    this.name = name;
    this.age = age;
    this.specie = specie;
  }

  getInfo() {
    return this;
  }
}

export class Mammal extends Animal {
  constructor(name, age, specie, hasFur) {
    super(name, age, specie);
    this.hasFur = hasFur;
  }
  getInfo() {
    return this;
  }

}

export class Dog extends Mammal {
  constructor(name, age, breed, hasFur, specie = "dog") {
    super(name, age, specie, hasFur);
    this.breed = breed;
  }
  getInfo() {
    return this;
  }
  bark() {
    return ("woof!");
  }
}

Esta es mi solución

export class Animal {
  constructor(name, age, specie) {
    this.name = name;
    this.age = age;
    this.specie = specie;
  }
  getInfo() {
    return { name: this.name, age: this.age, specie: this.specie }
  }
}

export class Mammal extends Animal {
  constructor(name, age, specie, hasFur) {
    super(name, age, specie)
    this.hasFur = hasFur;
  }
  getInfo() {
    return { name: this.name, age: this.age, specie: this.specie, hasFur: this.hasFur }
  }
}

export class Dog extends Mammal {

  constructor(name, age, breed, hasFur) {
    super(name, age, 'dog', hasFur)
    this.breed = breed;

  }

  getInfo() {
    return { name: this.name, age: this.age, specie: this.specie, hasFur: this.hasFur, breed: this.breed }
  }
  bark() {
    return "woof!";
  }
}

🛡️🛡️Escudo anti-spoilers🛡️🛡️

Mi solución al reto:

export class Animal {
  constructor(name, age, specie) {
    this.name = name;
    this.age = age;
    this.specie = specie;
  }
  getInfo() {
    return this
  }
}

export class Mammal extends Animal {
  constructor(name, age, specie, hasFur) {
    super(name, age, specie);
    this.hasFur = hasFur;
  }
  getInfo() {
    return { ...this, ...this.hasFur }
  }
}

export class Dog extends Mammal {
  //! Aqui la guia no ayuda nada bien, las pruebas unitarias estaban mal empleadas cambiando el orden de las propiedades
  constructor(name, age, breed, hasFur, specie = "dog") {
    super(name, age, specie, hasFur);
    this.breed = breed;
  }
  getInfo() {
    return this
  }
  bark() {
    return "woof!"
  }
}

Solucion

class Animal {
  // Tu código aquí 👈
  constructor(name, age, species) {
    this.name = name;
    this.age = age;
    this.species = species;
  }

  getInfo() {
    const info = {
      name: this.name,
      age: this.age,
      species: this.species,
    };
    return info;
  }
}

class Mammal extends Animal{
  // Tu código aquí 👈
  constructor(name, age, species, hasFur) {
    super(name, age, species);
    this.hasFur = hasFur;
  }

  getInfo() {
    const mammalInfo = { ...super.getInfo(), hasFur: this.hasFur };
    return mammalInfo
  }
}

class Dog extends Mammal{
  // Tu código aquí 👈
  constructor(name, age, breed, hasFur) {
    super(name, age, hasFur);
    this.breed = breed
  }

  bark() {
    return "Woof!"
  }
}

.
.
.
.
.
.
.
.
.
.
.
.
.

export class Animal {
  constructor(name, age, species) {
    this.name = name;
    this.age = age;
    this.species = species;
  }

  getInfo() {
    return {
      name: this.name,
      age: this.age,
      specie: this.species,
    };
  }
}

export class Mammal extends Animal {
  constructor(name, age, species, hasFur) {
    super(name, age, species);
    this.hasFur = hasFur;
  }

  getInfo() {
    const animalInfo = super.getInfo();
    animalInfo.hasFur = this.hasFur;
    return animalInfo;
  }
}

export class Dog extends Mammal {
  constructor(name, age, breed, hasFur) {
    super(name, age, "dog", hasFur);
    this.breed = breed;
  }

  getInfo() {
    const mammalInfo = super.getInfo();
    mammalInfo.breed = this.breed;
    return mammalInfo;
  }

  bark() {
    return "woof!";
  }
}

¡Hola, Desafío cumplido 😃!

Mi solución,
Se detalla hasta abajo.⬇






export class Animal {
  constructor(name, age, species) {
    this._name = name;
    this._age = age;
    this._species = species;
  }
  getInfo() {

    return (
      {
        'name': this._name, 'age': this._age,
        'specie': this._species
      });
  }
}
export class Mammal extends Animal {
  constructor(name, age, species, hasFur) {
    super(name, age, species);
    this._hasFur = hasFur;
  }
  getInfo() {
    let details = { 'hasFur': this._hasFur };
    return { ...super.getInfo(), ...details };
  }
}
export class Dog extends Mammal {
  constructor(name, age,breed , hasFur ) {
    super(name, age, 'dog', hasFur);
    this._breed = breed;

  }
  getInfo() {
    let details = { 'breed': this._breed};
    return { ...super.getInfo(), ...details };
  }
  bark() {
    return ('woof!');
  }
}

Solución

Un error en Animal con species cuando debe usarse specie.
Y algo muy raro es el cambio en el constructor de Dog que había que intercambiar el orden de los parámetros hasFur y breed. (La prueba parece que estaba hecha de esa forma)

export class Animal {
  // Tu código aquí 👈
  constructor(name, age, specie) {
    this.name = name;
    this.age = age;
    this.specie = specie;
  }

  getInfo() {
    return {
      name: this.name,
      age: this.age,
      specie: this.specie
    }
  }
}

export class Mammal extends Animal {
  // Tu código aquí 👈
  constructor(name, age, specie, hasFur) {
    super(name, age, specie);
    this.hasFur = hasFur;
  }

  getInfo() {
    return {
      name: this.name,
      age: this.age,
      specie: this.specie,
      hasFur: this.hasFur
    }
  }
}

export class Dog extends Mammal {
  // Tu código aquí 👈
  constructor(name, age, breed, hasFur) {
    super(name, age, "dog", hasFur);
    this.breed = breed;
  }

  getInfo() {
    return {
      name: this.name,
      age: this.age,
      specie: "dog",
      hasFur: this.hasFur,
      breed: this.breed
    }
  }

  bark() {
    return "woof!";
  }
}

Revisar los comentarios de Daniel Sebastian, cosas que estan erradas en el test:

export class Animal {
  // Tu código aquí 👈
  constructor(name, age, specie) {
    this._name = name;
    this._age = age;
    this._specie = specie;
  }
  getInfo() {
    //console.log(this);
    return {
      name: this._name,
      age: this._age,
      specie: this._specie,
    }

  }
}

export class Mammal extends Animal {
  // Tu código aquí 👈
  constructor(name, age, specie, hasFur) {
    super(name, age, specie);
    this._hasFur = hasFur;
  }
  getInfo() {
    return {
      name: this._name,
      age: this._age,
      specie: this._specie,
      hasFur: this._hasFur,
    }
  }

}

export class Dog extends Mammal {
  // Tu código aquí 👈
  constructor(name, age, breed, hasFur, specie = "dog") {
    super(name, age, specie, hasFur);
    this._breed = breed;
  }
  bark() {
    return (`woof!`);
  }
  getInfo() {
    return {
      age: this._age,      
      breed: this._breed,
      hasFur: this._hasFur,            
      name: this._name,
      specie: this._specie,

    }
  }

} 

No puedo con estos test de verdad 😣
le quitan lo divertido a la vida con sus validaciones erroneas

Lo más difícil para mi, son los test, porque no los entiendo… 😃

export class Animal {
  // Tu código aquí 👈
  constructor(name, age, species) {
    this._name = name;
    this._age = age;
    this._specie = species;

  }
  getInfo() {
    return {
      name: this._name,
      age: this._age,
      specie: this._specie
    }
  }
}

export class Mammal extends Animal {
  // Tu código aquí 👈
  constructor(name, age, species, hasFur) {
    super(name, age, species);
    this._hasFur = hasFur;
  }
  getInfo() {
    return {
      name: this._name,
      age: this._age,
      specie: this._specie,
      hasFur: this._hasFur,
    }

  }

}

export class Dog extends Mammal {
  // Tu código aquí 👈
  constructor(name, age, breed, hasFur, species = "dog") {
    super(name, age, species, hasFur);
    this._breed = breed;
  }
  getInfo() {
    return {
      name: this._name,
      age: this._age,
      specie: this._specie,
      hasFur: this._hasFur,
      breed: this._breed
    }
  }
  bark() {
    return "woof!";
  }
}

Mi humilde aporte:
.
.
.
.
.
.
.
.
.
.
.

export class Animal {
  constructor(name, age, species) {
    this.name = name;
    this.age = age;
    this.species = species;
  }

  getInfo() {
    return {
      name: this.name,
      age: this.age,
      specie: this.species
    };
  }
}

export class Mammal extends Animal {
  constructor(name, age, specie, hasFur) {
    super(name, age, specie);
    this.hasFur = hasFur;
  }

  getInfo() {
    return {
      ...super.getInfo(),
      hasFur: this.hasFur
    };
  }

}

export class Dog extends Mammal {
  constructor(name, age, breed, hasFur) {
    super(name, age, "dog", hasFur);
    this.breed = breed;
  }

  getInfo() {
    return {
      ...super.getInfo(),
      breed: this.breed
    };
  }

  bark() {
    return "woof!";
  }
}

Excelente, aquí mi solución:

export class Animal {
  constructor(name, age, species) {
    this.name = name;
    this.age = age;
    this.species = species;
  }
  getInfo() {
    return { name: this.name, age: this.age, specie: this.species };
  }
}
export class Mammal extends Animal {
  constructor(name, age, specie, hasFur) {
    super(name, age, specie);
    this.hasFur = hasFur;
  }
  getInfo() {
    return { name: this.name, age: this.age, specie: this.species, hasFur: this.hasFur };
  }
}
export class Dog extends Mammal {
  constructor(name, age, breed, hasFur) {
    super(name, age, "dog", hasFur);
    this.breed = breed;
  }
  getInfo() {
    return { name: this.name, age: this.age, specie: this.species, hasFur: this.hasFur, breed: this.breed };
  }
  bark() {
    return "woof!"
  }
}

the sol:

export class Animal {
  constructor(name, age, species) {
    this.name = name;
    this.age = age;
    this.species = species; 
  }

  getInfo() {
    return { name: this.name, age: this.age, species: this.species }
  }
}

export class Mammal extends Animal {
  constructor(name, age, species, hasFur) {
    super(name, age, species);
    this.hasFur = hasFur;
  }

  getInfo() {
    return {
      name: this.name,
      age: this.age,
      species: this.species,
      hasFur: this.hasFur
    } 
  }
}

export class Dog extends Mammal{
  constructor(name, age, species, hasFur, breed) {
    super(name, age, species, hasFur)
    this.breed = breed
  }

  getInfo() {
    return {
      name: this.name,
      age: this.age,
      species: this.species,
      hasFur: this.hasFur,
      breed: this.breed,
    } 
  }

  bark() {
    return "woof!";
  }
}

MI SOLUCION 💪
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

export class Animal {
  constructor(name, age, specie) {
    this.name = name;
    this.age = age;
    this.specie = specie;
  }

  getInfo() {
    return this;
  }
}

export class Mammal extends Animal {
  constructor(name, age, specie, hasFur) {
    super(name, age, specie);
    this.hasFur = hasFur;
  }

  getInfo() {
    return this;
  }
}

export class Dog extends Mammal{
  constructor(name, age, breed, hasFur, specie = "dog") {
    super(name, age, specie, hasFur);
    this.breed = breed;
  }

  getInfo() {
    return this;
  }

  bark() {
    return "woof!";
  }
}

Mi solucion:
.
.
.
.
.
.
.
.
.
.
.
.
.
.

export class Animal {
  constructor(name, age, specie) {
    this.name = name;
    this.age = age;
    this.specie = specie;
  }

  getInfo() {
    return this;
  }
}

export class Mammal extends Animal {
  constructor(name, age, specie, hasFur) {
    super(name, age, specie);
    this.hasFur = hasFur;
  }

  getInfo() {
    return this;
  }
}

export class Dog extends Mammal {
  constructor(name, age, breed, hasFur) {
    super(name, age, 'dog', hasFur);
    this.breed = breed;
  }

  getInfo() {
    return this;
  }

  bark() {
    return 'woof!';
  }
}

Hola, dejo mi solucion

🛴✨
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Llegamos 📍

class Animal {
  // Tu código aquí 👈
  constructor(name, age, specie) {
    this.name = name;
    this.age = age;
    this.specie = specie;
  }
  getInfo() {
    return {
      name: this.name,
      age: this.age,
      specie: this.specie
    }
  }
}

class Mammal extends Animal{
  // Tu código aquí 👈
  constructor(name, age, specie, hasFur){
    super(name, age, specie)
    this.hasFur = hasFur;
  }
  getInfo() {
    return {
      ...super.getInfo(),
      hasFur: this.hasFur
    }
  }
}

class Dog extends Mammal{
  // Tu código aquí 👈
  constructor(name, age, breed, hasFur){
    super(name, age, 'dog', hasFur)
    this.breed = breed;
  }
  getInfo() {
    return {
      ...super.getInfo(),
      breed: this.breed
    }
  }
  bark() {
    return "woof!"
  }
}

MI solución:

export class Animal {
  constructor(name, age, specie) {
    this.name = name;
    this.age = age;
    this.specie = specie;
  }
  getInfo() {
    return {
      name: this.name,
      age: this.age,
      specie: this.specie,
    };
  }
}

export class Mammal extends Animal {
  constructor(name, age, specie, hasFur) {
    super(name, age, specie);
    this.hasFur = hasFur;
  }
  getInfo() {
    return this;
  }
  bark() {
    return "woof!";
  }
}

export class Dog extends Mammal {
  constructor(name, age, breed, hasFur, specie = "dog") {
    super(name, age, specie, hasFur);
    this.breed = breed;
  }
  getInfo() {
    return this;
  }
}

Mi solución:
la propiedad species realmente se tiene que llamar specie o si no van a fallar las pruebas
*
*
*
*
*
*

export class Animal {
  constructor(name, age, specie) {
    this.name = name;
    this.age = age;
    this.specie = specie
  }

  getInfo() {
    return {
      name: this.name,
      age: this.age,
      specie: this.specie
    }
  }
}

export class Mammal extends Animal {
  constructor(name, age, specie, hasFur) {
    super(name, age, specie)
    this.hasFur = hasFur
  }

  getInfo() {
    return {
      ...this,
      hasFur: this.hasFur
    }
  }
}

export class Dog extends Mammal {
  constructor(name, age, breed, hasFur, specie = 'dog') {
    super(name, age, specie, hasFur)
    this.breed = breed
  }

  getInfo() {
    return {
      ...this,
      breed: this.breed
    }
  }

  bark() {
    return 'woof!'
  }
}

Solución… 😄
.
Para resolver el ejercicio, se deben implementar las clases con la jerarquía correspondiente.
.
NOTA:

  • En la descripción del ejercicio se maneja el atributo “especies”, pero en la implementación y en los ejemplos se utiliza la propiedad “especie”, sin la ‘s’.
    .

  • En la clase Dog se debe invertir el orden de las propiedades “specie” y “breed” al parecer, para que las pruebas pasen bien. Además que el valor de “specie” para esta clase debe ser “dog”.
    .

export class Animal {
  constructor(name, age, specie) { 
    this.name = name;
    this.age = age;
    this.specie = specie;
  }

  getInfo() { 
    return {
      name: this.name,
      age: this.age,
      specie: this.specie
    };
  }
}

export class Mammal extends Animal {
  constructor(name, age, specie, hasFur) {
    super(name, age, specie);
    this.hasFur = hasFur;
  }

  getInfo() {
    return {
      ...super.getInfo(),
      hasFur: this.hasFur
    };
  }
}

export class Dog extends Mammal {
  constructor(name, age, breed, hasFur, specie) {
    super(name, age, "dog", hasFur);
    this.breed = breed;
  }

  getInfo() {
    return {
      ...super.getInfo(),
      breed: this.breed
    };
  }

  bark() { 
    return "woof!";
  }
}

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

export class Animal {
  // Tu código aquí 👈
  _name;
  _age;
  _specie;
  constructor(name, age, specie) {
    this._age = age;
    this._name = name;
    this._specie = specie;
  }
  getInfo() {
    return {
      name: this._name,
      age: this._age,
      specie: this._specie
    };
  }
}

export class Mammal extends Animal{
  // Tu código aquí 👈
  _hasFur;
  constructor(name, age, specie, hasFur) {
    super(name, age, specie);
    this._hasFur = hasFur;
  }
  getInfo() {
    return {
      name: this._name,
      age: this._age,
      specie: this._specie,
      hasFur: this._hasFur
    };
  }
}

export class Dog extends Mammal{
  // Tu código aquí 👈
  _breed;
  constructor(name, age, breed, hasFur) {
    super(name, age, 'dog', hasFur);
    this._breed = breed;
  }
  getInfo() {
    return {
      name: this._name,
      age: this._age,
      specie: this._specie,
      hasFur: this._hasFur,
      breed: this._breed
    };
  }
  bark() {
    return "woof!";
  }
}

Mi solución:
.
.
.
.
.
.
.

export class Animal {
  constructor(name, age, species) {
    this.name = name
    this.age = age
    this.species = species
  }
  getInfo() {
    return { name: this.name, age: this.age, specie: this.species }
  }
}

export class Mammal extends Animal {
  constructor(name, age, species, hasFur) {
    super(name, age, species)
    this.hasFur = hasFur
  }
  getInfo() {
    const properties = super.getInfo()
    return { ...properties, hasFur: this.hasFur }
  }
}

export class Dog extends Mammal {
  constructor(name, age, breed, hasFur) {
    super(name, age, "dog", hasFur)
    this.breed = breed
  }
  getInfo() {
    const properties = super.getInfo()
    return { ...properties, breed: this.breed }
  }
  bark() { return "woof!" }
}

.
. -----------------------------------------
. ESCUDO ANTI SPOILER
. -----------------------------------------
.
. Este reto si que me hizo sudar.
.
.

.
.
.
.
.
.

.
.
.
.
.
.
.
.
.
.

Mi solución

En base a las salidas que había en las pruebas, hice modificaciones, ya que en el problema dice “species” pero solo es “specie” y las modificaciones para la salida de la clase Dog.

export class Animal {
  constructor(name, age, specie) {
    this.name = name;
    this.age = age;
    this.specie = specie;
  }

  getInfo() {
    return { name: this.name, age: this.age, specie: this.specie };
  }
}
export class Mammal extends Animal {
  constructor(name, age, specie, hasFur) {
    super(name, age, specie);
    this.hasFur = hasFur;
  }
  getInfo() {
    return {
      name: this.name,
      age: this.age,
      specie: this.specie,
      hasFur: this.hasFur
    };
  }
}

export class Dog extends Mammal {
  constructor(name, age, specie, hasFur, breed) {
    super(name, age, specie, hasFur);
    this.breed = breed;
  }
  getInfo() {
    return {
      name: this.name,
      age: this.age,
      hasFur: this.hasFur,
      breed: this.specie,
      specie: 'dog'
    };
  }
  bark() {
    return "woof!";
  }
}

Bueno resolvi el reto y creo que a partir de este punto tienes que revisar bien el output ya que basado en este debes hacer algunos ajustes a tu solución para que pase todos los tests:

Resolución:

.
.
.
.
.
.
.
.
.
.

Para comenzar tuve que cambiar la palabra species a specie y además para la clase Dog tuve que cambiar el orden del constructor además de pasar por defecto el valor de specie por lo mismo menciono que hay que ver ahora el output de lo que se espera por salida abajo mi código:

export class Animal {
  constructor(name, age, specie){
    this.name = name
    this.age = age
    this.specie = specie
  }

  getInfo() {
    return {
      name: this.name,
      age: this.age,
      specie: this.specie
    }
  }
}

export class Mammal extends Animal {
  constructor(name, age, specie, hasFur){
    super(name, age, specie)
    this.hasFur = hasFur
  }

  getInfo() {
    return {
      name: this.name,
      age: this.age,
      specie: this.specie,
      hasFur: this.hasFur
    }
  }
}

export class Dog extends Mammal {
  constructor(name, age, breed, hasFur, specie = 'dog') {
    super(name, age, specie, hasFur)
    this.breed = breed
  }

  getInfo() {
    return {
      name: this.name,
      age: this.age,
      specie: this.specie,
      hasFur: this.hasFur,
      breed: this.breed
    }
  }

  bark() {
    return "woof!"
  }
}

Les paso mi solucion. Quizas lo hice un poco simple pero igual podria mejorarse ya que siempre hice un return del mismo objeto.
.
.
.
.
.
.

export class Animal {
  constructor(name, age, specie) {
    this.name = name;
    this.age = age;
    this.specie = specie;
  }

  getInfo() {
    return this;
  }
}

export class Mammal extends Animal {
  constructor(name, age, specie, hasFur) {
    super(name, age, specie);
    this.hasFur = hasFur;
  }
}

export class Dog extends Mammal {
  constructor(name, age, breed, hasFur) {
    super(name, age, 'dog', hasFur);
    this.breed = breed;
  }

  bark() {
    return 'woof!';
  }
}

export class Animal {
  // Tu código aquí 👈
  constructor(name,age,specie) {
    this._name = name
    this._age = age
    this._specie = specie
  }

  getInfo() {
    return {
      name: this._name,
      age: this._age,
      specie: this._specie,
    }
  }
}

export class Mammal extends Animal {
  // Tu código aquí 👈
  constructor(name,age,specie,hasFur) {
    super(name, age, specie)
    this._hasFur = hasFur
  }

  getInfo() {
    return {
      name: this._name,
      age: this._age,
      specie: this._specie,
      hasFur: this._hasFur
    }
  }
}

export class Dog extends Mammal {
  // Tu código aquí 👈
  constructor(name, age, breed, hasFur) {
    
    super(name,age,"dog",hasFur)
    this._breed = breed
  }

  getInfo() {
    return {
      name: this._name,
      age: this._age,
      specie: this._specie,
      hasFur: this._hasFur,
      breed: this._breed
    }
  }

  bark() {
    return "woof!"
  }


}

undefined