No tienes acceso a esta clase

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

Playgrounds: Manejo de clases

8/20

Aportes 129

Preguntas 3

Ordenar por:

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

Lo corro en mi VS y todo correcto, pero acá ni siquiera ejecuta. Incluso copié el código del otro compañero a ver si el error era mío pero tampoco compila nada

class Banda {
  constructor({
    nombre,
    generos = [],
  }) {
    this.nombre = nombre;
    this.generos = generos;
    this.integrantes = [];
  }
  agregarIntegrante(integranteNuevo) {
    if (this.integrantes.every(i => i.instrumento !== 'Bateria')) {
      this.integrantes.push(integranteNuevo);
    } else { 
      console.log("Nel Prro");
    }

  }
}

//Crear clase Integrante
class Integrante {
  constructor(
    {
      nombre,
      instrumento
    }
  ) {
    this.nombre = nombre;
    this.instrumento = instrumento;
  }


}




export {
  Banda,
  Integrante,
}


Manejo de Clases


 

En este reto, se nos pide limitar la cantidad de bateristas de la banda, realizo comprobación del arreglo integrantes con el método some() para comprobar si contábamos o no con el baterista, mientras la variable baterista = false la banda no cuenta con el baterista así que quien llegue puede tocar con nosotros hasta que alguien no cumpla el condicional if (baterista === false) , porque tenemos ya al baterista.

 

un, dos, un dos tres y …

 

class Banda {
    constructor({
      nombre,
      generos = [],
    }) {
      this.nombre = nombre;
      this.generos = generos;
      this.integrantes = [];
    }
    agregarIntegrante(integranteNuevo) {  
      let baterista = this.integrantes.some(integrante => 
          integrante.instrumento === "Bateria"
      ); 

      if(baterista === false){
        this.integrantes.push(integranteNuevo)
      }
    }
  }
  
  class Integrante {
    constructor({
        nombre, 
        instrumento,
    }) {
        this.nombre = nombre; 
        this.instrumento = instrumento;
    }
  }
  
  export {
    Banda,
    Integrante,
  }

IMPORTANTE: no vea este mensaje a menos que haya intentado hacer el desafio, no quiero molestar con mi código.
pero si crees que te pueda servir de alguna manera, entonces aqui lo dejo 😄

class Banda {
    constructor({
      nombre,
      generos = [],
    }) {
      this.nombre = nombre;
      this.generos = generos;
      this.integrantes = [];
    }
    agregarIntegrante(integranteNuevo) {
        if(this.integrantes.some(obj=>obj.instrumento==='Bateria')){
            console.log('ya hay un baterista')
        }else{
            this.integrantes.push(integranteNuevo)
        }     
    }
  }
  
  class Integrante {
    constructor({
        nombre,
        instrumento,
    }){
        this.nombre=nombre;
        this.instrumento=instrumento;
    }
  }
  
  
  export {
    Banda,
    Integrante,
  }

Como me costo hacer este ejercicio, me vi tentado a ver la solución de los demas, pero al final no lo hice y lo resolví 🥹

class Banda {
  constructor({ nombre, generos = [] }) {
    this.nombre = nombre;
    this.generos = generos;
    this.integrantes = [];
  }
  agregarIntegrante(integranteNuevo) {
    // Tu código aquí 👈
    if (
      this.integrantes.find((element) => element.instrumento === 'Bateria')
    ) {
      console.log('La banda ya tiene un baterista');
    } else {
      this.integrantes.push(integranteNuevo);
    }
  }
}

//Crear clase Integrante
class Integrante {
  // Tu código aquí 👈
  constructor({ nombre, instrumento }) {
    this.nombre = nombre;
    this.instrumento = instrumento;
  }
}

const data = {
  nombre: 'Los Jacks',
  generos: ['rock', 'pop', 'post-punk'],
  integrantes: [],
};
const banda = new Banda(data);
banda.agregarIntegrante(
  new Integrante({ nombre: 'Erik', instrumento: 'Guitarra' })
);
banda.agregarIntegrante(
  new Integrante({ nombre: 'Paul', instrumento: 'Bateria' })
);

banda.agregarIntegrante(
  new Integrante({ nombre: 'Paul', instrumento: 'Bateria' })
);


export {
  Banda,
  Integrante,
}

Mi codigo tambien funciona en el VSC pero no en el modulo de pruebas de Platzi:

class Banda {
    constructor({
        nombre,
        generos = [],
        }) {
        this.nombre = nombre;
        this.generos = generos;
        this.integrantes = [];
        }
        agregarIntegrante(integranteNuevo) {
        const find = this.integrantes.find(integrante => integrante.instrumento === integranteNuevo.instrumento);
        if (find) {
            console.error('Ya existe un' , integranteNuevo.instrumento , 'en la banda');
        } else {
            this.integrantes.push(integranteNuevo);
        }
    
        }
    }
    
    //Crear clase Integrante
    class Integrante {
        constructor(name,instrumento) {
        this.name = name;
        this.instrumento = instrumento;
    }
}  

const erik = new Integrante("Erik","Baterista");

const aerosmith = new Banda({
    nombre:"aerosmith"
})

aerosmith.agregarIntegrante(erik);

const juan = new Integrante('fABIO',"Baterista");

aerosmith.agregarIntegrante(juan);

Retorna:

Si alguien mira donde me equivoque le agradezco la retroalimentacion.

Aqui mi resultado :

class Banda {
  constructor({
    nombre,
    generos = [],
  }) {
    this.nombre = nombre;
    this.generos = generos;
    this.integrantes = [];
  }
  agregarIntegrante(integranteNuevo) {
    // Tu código aquí 👈
    if (!this.integrantes.find(integrante => integrante.instrumento === 'Bateria'))
      this.integrantes.push(integranteNuevo);

  }
}

//Crear clase Integrante
class Integrante {
  // Tu código aquí 👈
  constructor({
    nombre,
    instrumento
  }) {
    this.nombre = nombre;
    this.instrumento = instrumento;
  }

}


export {
  Banda,
  Integrante,
}

Mi aporte, veo en las respuestas que muchos obviaron el hecho de que el ejercicio pedía que solo no dejara agregar más de un baterista, otros instrumentos sí podían ser más de uno

class Banda {
  constructor({
    nombre,
    generos = [],
  }) {
    this.nombre = nombre;
    this.generos = generos;
    this.integrantes = [];
  }
  agregarIntegrante(integranteNuevo) {    
    if ((this.integrantes.every(i => i.instrumento !== "Bateria")) || integranteNuevo.instrumento !== "Bateria") 
      this.integrantes.push(integranteNuevo);     
    

  }
}

//Crear clase Integrante
class Integrante {
  constructor({
    nombre,
    instrumento,
  }) {
    this.nombre = nombre;
    this.instrumento = instrumento;
    
  }

}


export {
  Banda,
  Integrante,
}

Bueno les dejo mi solución.

Por cierto para el análisis del baterista lo que hago es verificar si no es baterista el nuevo integrante para agregarlos al array de integrantes y en el caso de que si sea baterista busco si lo encuentro en el array de integrantes, en caso que si me devuelve un indice diferente a -1. Y solo si es -1 lo agrego al array de integrantes.

class Banda {
  constructor({
    nombre,
    generos = [],
  }) {
    this.nombre = nombre;
    this.generos = generos;
    this.integrantes = [];
  }
  agregarIntegrante(integranteNuevo) {
    if (integranteNuevo.instrumento !== 'Bateria') {
      this.integrantes.push(integranteNuevo)
    }
    else {
      const pos = this.integrantes.findIndex(integrante => integrante.instrumento === 'Bateria')
      if (pos === -1) this.integrantes.push(integranteNuevo)
    }
  }
}

//Crear clase Integrante
class Integrante {
  constructor({ nombre, instrumento }) {
    this.nombre = nombre;
    this.instrumento = instrumento
  }
}


export {
  Banda,
  Integrante,
}

class Banda {
  constructor({
    nombre,
    generos = [],
  }) {
    this.nombre = nombre;
    this.generos = generos;
    this.integrantes = [];
  }
  agregarIntegrante(integranteNuevo) {
    // Tu código aquí 👈
    let instrumentExists = this.integrantes.filter((el) => el.instrumento === integranteNuevo.instrumento)
    instrumentExists.length ? console.log('ya existe') : this.integrantes.push(integranteNuevo)
  }
}

//Crear clase Integrante
class Integrante {
  // Tu código aquí 👈
  constructor({
    nombre,
    instrumento
  }) {
      this.nombre = nombre;
      this.instrumento = instrumento;
  }
}


export {
  Banda,
  Integrante,
}

Me dice que está mal el 4to punto (debe agregar nuevos integrantes), pero a mí me funciona en la consola del navegador:

class Banda {
  constructor({ nombre, generos = [], integrantes = [] }) {
    this.nombre = nombre;
    this.generos = generos;
    this.integrantes = integrantes;
  }
  agregarIntegrante(integranteNuevo) {
    // Tu código aquí 👈
    const isBassPlayer = this.integrantes.some(
      (integrante) => integrante.instrument == "Bateria"
    );

    if (!isBassPlayer) {
      this.integrantes.push(integranteNuevo);
    } else if (isBassPlayer && integranteNuevo.instrument !== "Bateria") {
      this.integrantes.push(integranteNuevo);
    } else {
      return;
    }
  }
}

//Crear clase Integrante
class Integrante {
  // Tu código aquí 👈
  constructor({ name, instrument }) {
    this.name = name;
    this.instrument = instrument;
  }
}

const banda = new Banda({
  nombre: "Caracas Jazz",
  generos: ["Jazz", "Blues", "Funk"],
  integrantes: [
    new Integrante({
      name: "Oscar",
      instrument: "Bajo",
    }),
    new Integrante({
      name: "Natali",
      instrument: "Guitarra",
    }),
    new Integrante({
      name: "Abelardo",
      instrument: "Bateria",
    }),
  ],
});

banda.agregarIntegrante(
  new Integrante({
    name: "Heriberto",
    instrument: "Banjo",
  })
);

banda.agregarIntegrante(
  new Integrante({
    name: "Paul",
    instrument: "Bateria",
  })
);

Mi Solucion 😎

class Banda {
  constructor({
    nombre,
    generos = [],
  }) {
    this.nombre = nombre;
    this.generos = generos;
    this.integrantes = [];
  }
  agregarIntegrante({ nombre, instrumento }) {
    // Tu código aquí 👈
    (!this.integrantes.some(({ instrumento }) => instrumento === 'Bateria')) ? this.integrantes.push(new Integrante({ nombre, instrumento })) : console.log()
  }
}

//Crear clase Integrante
class Integrante {
  // Tu código aquí 👈
  constructor({
    nombre,
    instrumento,
  }) {
    this.nombre = nombre;
    this.instrumento = instrumento;
  }
}

SPOILER: no veas este mensaje a menos que hayas intentado hacer el desafio, no quiero molestar con mi código.
pero si crees que te pueda servir de alguna manera, entonces aqui lo dejo 😄

Hay que validar en una variable si se repite y luego ejecutar un condicional, lo hice como lo haciamos en el taller práctico de JS: cre tu videojuego, me parece la forma más óptima.

class Banda {
  constructor({nombre,generos = [],}) {
    this.nombre = nombre;
    this.generos = generos;
    this.integrantes = [];
  }
  agregarIntegrante(newIntegrante) {
    // Tu código aquí 👈
    const repeat = this.integrantes.find(element => {
      const finded = element.instrumento == newIntegrante.instrumento;
      return finded;
    })
    if (!repeat) {
      this.integrantes.push(newIntegrante)
    }
  }
}

//Crear clase Integrante
class Integrante {
  // Tu código aquí 👈
  constructor({nombre, instrumento}) {
    this.nombre = nombre;
    this.instrumento = instrumento;
  }
}


export {
  Banda,
  Integrante,
}

Mi solucion…

class Banda {
  constructor({
    nombre,
    generos = [],
  }) {
    this.nombre = nombre;
    this.generos = generos;
    this.integrantes = [];
  }
  agregarIntegrante(integranteNuevo) {
    // Tu código aquí 👈
    const agregarInt = this.integrantes.every(
      ({ instrumento }) => instrumento !== integranteNuevo.instrumento)

    agregarInt ? this.integrantes.push(integranteNuevo)
      : new Error(`Ya hay un integrante que toca ${integranteNuevo.instrumento}`)

  }
}

//Crear clase Integrante
class Integrante {
  // Tu código aquí 👈
  constructor({ nombre, instrumento }) {
    this.nombre = nombre;
    this.instrumento = instrumento;
  }

}


export {
  Banda,
  Integrante,
}

Mi código (después de los gatitos antispoiler): ≽^-˕-^≼ ≽^-˕-^≼ ≽^-˕-^≼ ≽^-˕-^≼ ≽^-˕-^≼ ≽^-˕-^≼ ≽^-˕-^≼ ≽^-˕-^≼ ```js class Banda { constructor({ nombre, generos = [], }) { this.nombre = nombre; this.generos = generos; this.integrantes = []; } agregarIntegrante(integranteNuevo) { // Tu código aquí 👈 const bateristas = this.integrantes.filter(member => member.instrumento.toLowerCase() === 'bateria'); const numberoDeBeteristas = bateristas.length; const nuevoInstrumento = integranteNuevo.instrumento.toLowerCase(); if (numberoDeBeteristas > 0 & nuevoInstrumento === 'bateria') { // console.log('Solo se puede tener un baterista a la vez') } else { this.integrantes.push(integranteNuevo) } } } //Crear clase Integrante class Integrante { // Tu código aquí 👈 constructor({ nombre = '', instrumento = '', }) { this.nombre = nombre; this.instrumento = instrumento; } } export { Banda, Integrante, } ```

Lo hice de esta forma, en VS funciona pero en el editor de platzi no corre el código

class Banda {
  constructor({
    nombre,
    generos = [],
  }) {
    this.nombre = nombre;
    this.generos = generos;
    this.integrantes = [];
  }
  agregarIntegrante(integranteNuevo) {
    const res = this.integrantes.find(item => item.instrumento == integranteNuevo.instrumento)
    if (!res) {
      this.integrantes.push(integranteNuevo)
    }
  }
}

//Crear clase Integrante
class Integrante {
  constructor({ nombre, instrumento}) {
    this.nombre = nombre;
    this.instrumento = instrumento;
  }
}

const data = {
  nombre: "Los Jacks",
  generos: ["rock", "pop", "post-punk"],
  integrantes: [],
}
const banda = new Banda(data)
banda.agregarIntegrante(new Integrante({ nombre: "Erik", instrumento: "Guitarra" }))
banda.agregarIntegrante(new Integrante({ nombre: "Paul", instrumento: "Bateria" }))

console.log(banda);


Yo le agregué un atributo booleano que almacena por default en false si hay un baterista. En el momento que se agrega un integrante que toque la batería se establece en true, y ese se usa
para hacer una verificación cada que agregue un integrante.

compañeros acá mi respuesta al ejercicio, recuerda NO verla hasta que lo soluciones! 😃
go go go si puedes 😄

class Banda {
  constructor({
    nombre,
    generos = [],
  }) {
    this.nombre = nombre;
    this.generos = generos;
    this.integrantes = [];
  }
  agregarIntegrante(integranteNuevo) {
    if (integranteNuevo.instrumento === "Bateria") {
      const hayBaterista = this.integrantes.some(integrante => integrante.instrumento === "Bateria")
      if (!hayBaterista) {
        this.integrantes.push(integranteNuevo)
      }
    } else {
      this.integrantes.push(integranteNuevo)
    }
  }
}

//Crear clase Integrante
class Integrante {
  constructor({
    nombre,
    instrumento,
  }) {
    this.nombre = nombre;
    this.instrumento = instrumento;
  }
}


export {
  Banda,
  Integrante,
}

------------------------------------------------------------ .
. 🛡️🛡️🛡️ESCUDO ANTI SPOILER 🛡️🛡️🛡️ .
. ------------------------------------------------------------ .
.
.
.
.
.
.
.
.
.
.

.

.
.

les dejo mi solución

class Banda {
  constructor({
    nombre,
    generos = [],
  }) {
    this.nombre = nombre;
    this.generos = generos;
    this.integrantes = [];
  }
  agregarIntegrante(integranteNuevo) {
    // Tu código aquí 👈
    if (!this.integrantes.find(obj => obj.instrumento === integranteNuevo.instrumento )) {
      this.integrantes.push(integranteNuevo);
    }
  }
}

//Crear clase Integrante
class Integrante {
  // Tu código aquí 👈
  constructor({ nombre, instrumento }) {
    this.nombre = nombre
    this.instrumento = instrumento
  }

}


export {
  Banda,
  Integrante,
}

Mi solución:

class Banda {
  constructor({
    nombre,
    generos = [],
  }) {
    this.nombre = nombre;
    this.generos = generos;
    this.integrantes = [];
  }
  agregarIntegrante(integranteNuevo) {
    // Tu código aquí 👈
    if (integranteNuevo.instrumento != "Bateria") {
      this.integrantes.push(integranteNuevo);
    } else if (!this.integrantes.some(integrante => integrante.instrumento === "Bateria")) {
      this.integrantes.push(integranteNuevo);
    }
  }
}

//Crear clase Integrante
class Integrante {
  // Tu código aquí 👈
  constructor(
    {
      nombre,
      instrumento
    }
  ) {
    this.nombre = nombre;
    this.instrumento = instrumento;
    
  }

}


export {
  Banda,
  Integrante,
}

Mi aporte 😃

class Banda {
    constructor({
      nombre,
      generos = [],
      integrantes = [],
    }) {
      this.nombre = nombre;
      this.generos = generos;
      this.integrantes = integrantes;
    }
    agregarIntegrante(integranteNuevo) {
    /* Pasamos los atributos del objeto integrantes a un array para poder utilizar metodos de array */
    const pasoUno = Object.values(this.integrantes);
    /* Dejamos solo los valores de 'instrumentos' para reducir las iteraciones sobre el array */
    const pasoDos = pasoUno.flatMap(item => item.instrumento);
/*     Si el nuevo integrante a agregar tiene el instrumento de Bateria y ya existe uno con Bateria es FALSE haz esto... */
      if (!pasoDos.some(item => item === 'Bateria' && integranteNuevo.instrumento === 'Bateria')){
        this.integrantes.push(integranteNuevo);
    }
  }
}
  
  //Crear clase Integrante
  class Integrante {
    constructor({
      nombre,
      instrumento,
    }) {
      this.nombre = nombre;
      this.instrumento = instrumento;
    }
  }
class Banda {
  constructor({ nombre, generos = [] }) {
    this.nombre = nombre;
    this.generos = generos;
    this.integrantes = [];
  }

  agregarIntegrante(integrante) {
    // A. Validar si el integrante que se quiere agregar es un baterista
    if (integrante.instrumento === "Bateria") {
      // B. Filtrar los integrantes que sean bateristas
      const bateristas = this.integrantes.filter(
        (i) => i.instrumento === "Bateria"
      );
      // C. Validar si ya hay un baterista en la banda
      if (bateristas.length > 0) {
        console.log("Ya hay un baterista en la banda");
        return;
      }
    }

    // D. Agregar integrante
    this.integrantes.push(integrante);
  }
}

//Crear clase Integrante
class Integrante {
  constructor({ nombre, instrumento }) {
    this.nombre = nombre;
    this.instrumento = instrumento;
  }
}

export { Banda, Integrante };

Mi pequeño aporte

class Banda {
  constructor({
    nombre,
    generos = [],
  }) {
    this.nombre = nombre;
    this.generos = generos;
    this.integrantes = [];
  }
  agregarIntegrante(integranteNuevo) {
    return this.integrantes.find(integrante => integrante.instrumento === 'Bateria') ? console.warn(`El integrante ${integranteNuevo.nombre} ya existe`) : this.integrantes.push(integranteNuevo);
  }
}

//Crear clase Integrante
class Integrante {
  constructor({
    nombre,
    instrumento,
  }) {
    this.nombre = nombre;
    this.instrumento = instrumento;
  }
}


export {
  Banda,
  Integrante,
}

Mi aporte

class Banda {
 constructor({
nombre,
generos = [],
}) {
this.nombre = nombre;
this.generos = generos;
this.integrantes = [];
}
agregarIntegrante(integranteNuevo) {

let flag = false;
for (let i = 0; i < this.integrantes.length; i++){
  if (this.integrantes[i].instrumento == "Bateria") {
    flag = true;
    return console.log("Ya hay un baterista en la banda")
    break;
  }

}

if (!flag) {
  this.integrantes.push(integranteNuevo)
}

}
}

//Crear clase Integrante
class Integrante {
constructor({
nombre,
instrumento,
}) {
this.nombre = nombre;
this.instrumento = instrumento;
}
}

export {
Banda,
Integrante,
}

Mi solución, utilice el método de recorrido de arrays llamado some() el cual devuelve un valor booleano true en caso de que encuentra un elemento que cumple con la condición.

class Banda {
  constructor({
    nombre,
    generos = [],
  }) {
    this.nombre = nombre;
    this.generos = generos;
    this.integrantes = [];
  }
  agregarIntegrante(integranteNuevo) {
    const isThereInstrument = this.integrantes.some((integrante) => {
      return integrante.instrumento == integranteNuevo.instrumento
    })
    if (!isThereInstrument) {
      this.integrantes.push(integranteNuevo)
    } else {
      const message = `Ya existe un integrante que toca ${integranteNuevo.instrumento}`
      return console.log(message)
    }

  }
}

//Crear clase Integrante
class Integrante {
  constructor({nombre,instrumento}) {
    this.nombre = nombre;
    this.instrumento = instrumento;
  }
}

Solución

class Banda {
  constructor({
    nombre,
    generos = [],
  }) {
    this.nombre = nombre;
    this.generos = generos;
    this.integrantes = [];
  }
  agregarIntegrante(integranteNuevo) {
    // Tu código aquí 👈
    let existeBaterista = [];
    if (integranteNuevo.esBaterista()) {
      existeBaterista = this.integrantes.filter(integrante => integrante.instrumento === "Bateria");
    }

    if (existeBaterista.length === 0) {
      this.integrantes.push(integranteNuevo);
    }
  }
}

//Crear clase Integrante
class Integrante {
  // Tu código aquí 👈
  constructor({
    nombre,
    instrumento
  }) {
    this.nombre = nombre;
    this.instrumento = instrumento;
  }
  esBaterista() {
    return this.instrumento === "Bateria" ? true : false;
  }
}

export {
  Banda,
  Integrante,
}
class Banda {
  constructor({
    nombre,
    generos = [],
  }) {
    this.nombre = nombre;
    this.generos = generos;
    this.integrantes = [];
  }
  agregarIntegrante(integranteNuevo) {
    // Tu código aquí 👈
    if (this.integrantes.some(int => int.instrumento === "Bateria")) return;
    this.integrantes.push(integranteNuevo)
  }
}

//Crear clase Integrante
class Integrante {
  // Tu código aquí 👈
  constructor({ nombre, instrumento=[] }) {
    this.nombre = nombre;
    this.instrumento = instrumento;
  }
}


export {
  Banda,
  Integrante,
}

Aqui esta mi solución:
*
*
*
*
*
*
*
*
*
*
*
*
*
*

class Banda {
    constructor({
        nombre,
        generos = [],
    }) {
        this.nombre = nombre;
        this.generos = generos;
        this.integrantes = [];
    }
    agregarIntegrante(integranteNuevo) {
        // Tu código aquí 👈
        if (this.integrantes.length == 0) {
            this.integrantes.push(integranteNuevo);
        }
        else {
            for (let i = 0; i < this.integrantes.length; i++){
            if (integranteNuevo.instrumento == "Bateria" && this.integrantes[i].instrumento == "Bateria") {
                return;
                }
            }
  
            this.integrantes.push(integranteNuevo); 
        }
  
    }
}
  
//Crear clase Integrante
class Integrante {
    // Tu código aquí 👈
    constructor({
        nombre,
        instrumento
    }) {
        this.nombre = nombre;
        this.instrumento = instrumento;
    }
  
}
  
  
export {
    Banda,
    Integrante,
}

esta es mi solucion usando el operador ternario.
Tuve que recargar la pag porque no queria correr la prueba.

class Banda {
  constructor({
    nombre,
    generos = [],
  }) {
    this.nombre = nombre;
    this.generos = generos;
    this.integrantes = [];
  }
  agregarIntegrante(integranteNuevo) {
   this.integrantes.some(obj => obj.instrumento === 'Bateria') ?  console.log('ya hay un baterista') : this.integrantes.push(integranteNuevo);

  }
}

class Integrante {
  constructor({
    nombre,
    instrumento,
  }) {
    this.nombre = nombre;
    this.instrumento = instrumento;
  }
}

export {
  Banda,
  Integrante,
}

the solution

class Banda {
  constructor({
    nombre,
    generos = [],
  }) {
    this.nombre = nombre;
    this.generos = generos;
    this.integrantes = [];
  }
  agregarIntegrante(integranteNuevo) {
    if(this.integrantes.find(integrante => integrante.instrumento?.toLowerCase() == integranteNuevo.instrumento?.toLowerCase())){
      console.log("Ya existe un integrante con ese instrumento");
    }else {
      this.integrantes.push(integranteNuevo);
    }
  }
}

//Crear clase Integrante
class Integrante {
  constructor({ nombre, instrumento }) {
    this.nombre = nombre;
    this.instrumento = instrumento;
  }
}


const data = {
  nombre: "Los Jacks",
  generos: ["rock", "pop", "post-punk"],    
  integrantes: [],
}
const banda = new Banda(data)
banda.agregarIntegrante(new Integrante({ nombre: "Erik", instrumento: "Guitarra" }))
banda.agregarIntegrante(new Integrante({ nombre: "Paul", instrumento: "Bateria" }))
banda.agregarIntegrante(new Integrante({ nombre: "José", instrumento: "Charango" }))


Mi aporte, la validación la hice usando el método .find propio de los array, cualquier duda o comentario bienvenido 😎

class Banda {
  constructor({
    nombre,
    generos = [],
  }) {
    this.nombre = nombre;
    this.generos = generos;
    this.integrantes = [];
  }
  agregarIntegrante(integranteNuevo) {
    // Tu código aquí 👈
    const hasDrums = this.integrantes.find( ({instrumento}) => instrumento === "Bateria");

    if (hasDrums?.instrumento && integranteNuevo.instrumento === hasDrums?.instrumento) {
      console.log(integranteNuevo.nombre, " no se puede agregar por ya tenemos un integrante con el instruemento: ", integranteNuevo)
    } else {
      this.integrantes.push(integranteNuevo)
    }

  }
}

//Crear clase Integrante
class Integrante {
  // Tu código aquí 👈
  constructor({
    nombre,
    instrumento
  }) {
    this.nombre = nombre;
    this.instrumento = instrumento
  }

}


export {
  Banda,
  Integrante,
}

Mi solución usando el metodo find() para la validación de los bateristas.

class Banda {
  constructor({
    nombre,
    generos = [],
  }) {
    this.nombre = nombre;
    this.generos = generos;
    this.integrantes = [];
  }

  agregarIntegrante(integranteNuevo) {
    // Tu código aquí 👈
    if (this.integrantes.find(i => i.instrumento == 'Bateria')) {
      console.log('No pueden haber 2 Bateristas')
    } else {
      this.integrantes.push(integranteNuevo);
    }
    

  }
}

//Crear clase Integrante
class Integrante {
  // Tu código aquí 👈
  constructor({ nombre, instrumento }) {
    this.nombre = nombre;
    this.instrumento = instrumento;
  }

}


export {
  Banda,
  Integrante,
}

Mi solución:

class Banda {
  constructor({
    nombre,
    generos = [],
  }) {
    this.nombre = nombre;
    this.generos = generos;
    this.integrantes = [];
  }
  agregarIntegrante(integranteNuevo) {
    if (this.integrantes.length > 0) {
      let found = this.integrantes.find(i => i.instrumento.toLowerCase() == 'bateria');

      if (!found) {
        this.integrantes.push(integranteNuevo);
      }
    } else {
      this.integrantes.push(integranteNuevo);
    }
    

  }
}

//Crear clase Integrante
class Integrante {
  constructor({ nombre, instrumento }) {
    this.nombre = nombre;
    this.instrumento = instrumento
  }

}


export {
  Banda,
  Integrante,
}

MI solución:

class Banda {
  constructor({ nombre, generos = [] }) {
    this.nombre = nombre;
    this.generos = generos;
    this.integrantes = [];
  }
  agregarIntegrante(integranteNuevo) {
    if (
      !this.integrantes.some(
        (integrante) => integrante.instrumento === integranteNuevo.instrumento
      )
    ) {
      this.integrantes.push({
        nombre: integranteNuevo.nombre,
        instrumento: integranteNuevo.instrumento,
      });
    } else {
      console.log(
        `Ya se encuentra agregado el instrumento: ${integranteNuevo.instrumento}`
      );
    }
  }
}

//Crear clase Integrante
class Integrante {
  constructor({ nombre, instrumento }) {
    this.nombre = nombre;
    this.instrumento = instrumento;
  }
}

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

class Banda {
  constructor({
    nombre,
    generos = [],
  }) {
    this.nombre = nombre;
    this.generos = generos;
    this.integrantes = [];
  }
  agregarIntegrante(integranteNuevo) {
    // Tu código aquí 👈
    if (integranteNuevo instanceof Integrante) {
      const hasDrummer = this.integrantes.some(item => item.instrumento === 'Bateria');
      if (hasDrummer && integranteNuevo.instrumento === 'Bateria') {
        return false
      } else {
        this.integrantes.push(integranteNuevo);
      }
    }
  }
}

//Crear clase Integrante
class Integrante {
  // Tu código aquí 👈
  constructor({
    nombre,
    instrumento
  }) {
    this.nombre = nombre;
    this.instrumento = instrumento;
  }
}

export {
  Banda,
  Integrante,
}

Comparto mi codigo ultilizando la función Find de los arrays.

class Banda {
  constructor({
    nombre,
    generos = [],
  }) {
    this.nombre = nombre;
    this.generos = generos;
    this.integrantes = [];
  }
  agregarIntegrante(integranteNuevo) {

    if (integranteNuevo.instrumento === 'Bateria')
    {
      const baterista = this.integrantes.find(integrante => integrante.instrumento === 'Bateria');

      if (!baterista)
      {
        this.integrantes.push(integranteNuevo);

      }

    }
    else
    {
      this.integrantes.push(integranteNuevo);
    }
  }
}

//Crear clase Integrante
class Integrante
{
  constructor({
    nombre,
    instrumento
  })
  {
    this.nombre      = nombre;
    this.instrumento = instrumento;
  }

}


export {
  Banda,
  Integrante,
}

Acá les dejo mi solución! No la vean si todavía no la completaron

class Banda {
  constructor({ nombre, generos = []}) {
    this.nombre = nombre;
    this.generos = generos;
    this.integrantes = [];
  }

  agregarIntegrante(integranteNuevo) {
    // Tu código aquí 👈
    const bateristas = this.integrantes.filter(integrante => integrante.instrumento == "Bateria");

    if (integranteNuevo.instrumento == "Bateria" && bateristas.length == 0) {
      this.integrantes.push(integranteNuevo);
    }

    if (integranteNuevo.instrumento != "Bateria") {
      this.integrantes.push(integranteNuevo);
    }
  }
}

//Crear clase Integrante
class Integrante {
  // Tu código aquí 👈
  constructor({ nombre, instrumento = undefined }) {
    (this.nombre = nombre), (this.instrumento = instrumento);
  }
}


export {
  Banda,
  Integrante,
}

Aquí dejo mi solución:

class Banda {
    constructor({
        nombre,
        generos = [],
    }) {
        this.nombre = nombre;
        this.generos = generos;
        this.integrantes = [];
    }
    agregarIntegrante(integranteNuevo) {
        // Tu código aquí 👈
        const exist = this.integrantes.find(integrante => integrante.instrumento === "Bateria")
        if (!exist) {
            return this.integrantes.push(integranteNuevo)
        } else if (exist && integranteNuevo.instrumento === "Bateria") {
            console.log('Ya tenemos bajista!')
        } else {
            this.integrantes.push(integranteNuevo)
        }
    }
}

//Crear clase Integrante
class Integrante {
    // Tu código aquí 👈
    constructor({ nombre, instrumento }) {
        this.nombre = nombre
        this.instrumento = instrumento
    }
}

Mi solución:

'use strict'
class Banda {
  constructor({
    nombre,
    generos = [],
  }) {
    this.nombre = nombre;
    this.generos = generos;
    this.integrantes = [];
  }
  agregarIntegrante(integranteNuevo) {
    let hayBaterista = this.integrantes.some(integrante => integrante.instrumento.toLowerCase() === "bateria");

    if (hayBaterista && integranteNuevo.instrumento.toLowerCase() === "bateria") {
      // throw new Error('No puedes agregar más de un baterista!!')
      console.error('No puedes agregar más de un baterista!!')

    } else {
      this.integrantes.push(integranteNuevo);
    }
  }
}

//Crear clase Integrante
class Integrante {
  constructor({
    nombre,
    instrumento
  }) {
    this.nombre = nombre;
    this.instrumento = instrumento;
  }

}


const data = {
  nombre: "Los Jacks",
  generos: ["rock", "pop", "post-punk"],
  integrantes: [],
}
const banda = new Banda(data)
banda.agregarIntegrante(new Integrante({ nombre: "Erik", instrumento: "Guitarra" }))
banda.agregarIntegrante(new Integrante({ nombre: "Paul", instrumento: "Bateria" }))
banda.agregarIntegrante(new Integrante({ nombre: "Santana", instrumento: "Bateria" }))

<code> 
class Banda {
  constructor({
    nombre,
    generos = [],
  }) {
    this.nombre = nombre;
    this.generos = generos;
    this.integrantes = [];
  }
  agregarIntegrante(integranteNuevo) {
    let prueba = this.integrantes.find(persona => persona.instrumento == "Bateria");
    if (prueba && integranteNuevo.instrumento == "Bateria") {
      console.log("Nei perro");
    } else {
      this.integrantes.push(integranteNuevo);
    }

  }
}

//Crear clase Integrante
class Integrante {
  constructor(
    {
      nombre,
      instrumento
    }
  ) {
    this.nombre = nombre;
    this.instrumento = instrumento;
  }


}

export {
  Banda,
  Integrante,
}

ez buen playgroung

agregarIntegrante(integranteNuevo) {
    let hayBaterista = false;
    this.integrantes.forEach((a) => {
      hayBaterista = a.instrumento == 'Bateria';
    })
    if (!hayBaterista) {
      this.integrantes.push(integranteNuevo);
    }
  }
class Integrante {
  constructor({nombre, instrumento}) {
    this.nombre = nombre;
    this.instrumento = instrumento;
  }
}

Siempre es mejor poner algún texto de primeras para evitar que cuando entres a los Playground te spoilees la respuesta así que dicho ya esto y haber rellenado un poco el espacio para que no se vea el código dejo mi respuesta:

Espero les sirva:

class Banda {
  constructor(
  {
    nombre,
    generos = [],
  }) {
    this.nombre = nombre;
    this.generos = generos;
    this.integrantes = [];
  }
  agregarIntegrante(integranteNuevo) {
    let existe_baterista = this.integrantes.some(function (integrante)
    {
      return integrante.instrumento === "Bateria"
    })
    if (integranteNuevo.instrumento === "Bateria" && existe_baterista === true)
    {
      return;
    } else
    {
      this.integrantes.push(integranteNuevo);
    }
  }
}

//Crear clase Integrante
class Integrante {
  constructor({
    nombre,
    instrumento,
  }) {
    this.nombre = nombre;
    this.instrumento = instrumento;
  }

}


export {
  Banda,
  Integrante,
}

Esta es mi solución:

class Banda {
    constructor({
      nombre,
      generos = [],
    }) {
      this.nombre = nombre;
      this.generos = generos;
      this.integrantes = [];
    }
    agregarIntegrante(integranteNuevo) {
       

      if(this.integrantes.find(obj=>obj.instrumento === "Bateria")){
        console.log("Ese instrumento ya existe");
      }else{
        this.integrantes.push(integranteNuevo);
      }
        
  
    }
  }
  
  //Crear clase Integrante
  class Integrante {
    
    constructor({
      nombre,
      instrumento
    }){
      this.nombre = nombre;
      this.instrumento = instrumento;
    }

  }

  const zona8 = new Banda({
    nombre: "Zona 8",
    generos: ["Vallenato", "Porro"]
  })
  
  zona8.agregarIntegrante(new Integrante({
    nombre: "Rolando Ochoa",
    instrumento: "Acordeon",

  }));

    
  zona8.agregarIntegrante(new Integrante({
    nombre: "Carlitos",
    instrumento: "Guitarra",

  }));

    zona8.agregarIntegrante(new Integrante({
    nombre: "JuanmaDrum",
    instrumento: "Bateria",

  }));

  zona8.agregarIntegrante(new Integrante({
    nombre: "primito",
    instrumento: "Bateria",

  }));
<code> 

Les comparto mi solución:

class Banda {
  constructor({
    nombre,
    generos = [],
  }) {
    this.nombre = nombre;
    this.generos = generos;
    this.integrantes = [];
  }
  agregarIntegrante(integranteNuevo) {

    let hasDrummer = this.integrantes.find( integrante => integrante.   instrumento === 'Bateria')
    if (!hasDrummer) {
     this.integrantes.push(integranteNuevo)
    }

    if (hasDrummer && integranteNuevo.instrumento !== 'Bateria') {
      this.integrantes.push(integranteNuevo)
    }

    if (hasDrummer && integranteNuevo.instrumento === 'Bateria') {
      console.log('Ya hay un baterista')
    }
  }
}
//Crear clase Integrante
class Integrante {
  constructor({
    nombre,
    instrumento,
  }) {
    this.nombre = nombre
    this.instrumento = instrumento
  }
}

export {
  Banda,
  Integrante,
}

Hola, les dejo mi solución donde incluí por defecto al baterista dentro del constructor de la clase Banda, así se podrían instanciar más objetos de esta clase, 10 bandas un ejemplo y siempre por defecto vendrían sin baterista:

const data = {
    nombre: "Los Jacks",
    generos: ["rock", "pop", "post-punk"],
    integrantes: [],
};
class Banda {
    constructor({ nombre, generos = [] }) {
        this.nombre = nombre;
        this.generos = generos;
        this.integrantes = [];
        this.baterista = false;
    }
    agregarIntegrante(integranteNuevo) {
        if((integranteNuevo.instrumento === "Bateria" && !this.baterista)){
            this.integrantes.push(integranteNuevo);    
            this.baterista = true;
        }
        else if(integranteNuevo.instrumento === "Bateria" && this.baterista){
            console.log("Ya hay un baterista");
            return null;
        }
        else{
            this.integrantes.push(integranteNuevo)
        }
    }
}

class Integrante {
    constructor({ nombre, instrumento }) {
        this.nombre = nombre;
        this.instrumento = instrumento;
    }
}
const banda = new Banda(data);
banda.agregarIntegrante(
    new Integrante({ nombre: "Erik", instrumento: "Guitarra" })
);
banda.agregarIntegrante(
    new Integrante({ nombre: "Paul", instrumento: "Bateria" })
);
banda.agregarIntegrante(
    new Integrante({ nombre: "SegundoBaterista", instrumento: "Bateria" })
);
console.log(banda);

Mi solucion :p

class Banda {
  constructor({ nombre, generos = [] }) {
    this.nombre = nombre;
    this.generos = generos;
    this.integrantes = [];
  }
  agregarIntegrante(integranteNuevo) {
    const newIntegran = integranteNuevo.instrumento === "Bateria";
    const baterista = this.integrantes.some(
      (item) => item.instrumento === "Bateria"
    );
    if (baterista && newIntegran) return console.log('Solo se permite un baterista');

    this.integrantes.push(integranteNuevo);
  }
}

//Crear clase Integrante
class Integrante {
  constructor({ nombre, instrumento }) {
    this.nombre = nombre;
    this.instrumento = instrumento;
  }
}

export { Banda, Integrante };

Me dolió la cabeza hacerlo pero creo que no está íntegro si lo testean bien.

class Banda {
    constructor({
        nombre= '',
        generos = [],
        integrantes = []
    }){
        this.nombre = nombre;
        this.generos = generos;
        this.integrantes = integrantes;
    }

    agregarIntegrante(nuevoIntegrante){

        if(this.integrantes.find(integrante => integrante.instrumento === 'bateria'))
        console.log('solo puede haber un baterista por banda,no podrás agregar otro')
        else
        this.integrantes = [...this.integrantes,nuevoIntegrante]
    }
}

class Integrante{
    constructor({
        nombre= '',
        instrumento = ''
    }){
        this.nombre = nombre;
        this.instrumento = instrumento;
    }
}

const data = {
    nombre:'megadeth',
    generos: ['metal'],
    integrantes: []
}
const banda = new Banda(data)


banda.agregarIntegrante(new Integrante(
    {nombre: 'dave mustaine',
    instrumento:'vocalista y guitarrista'}
))

banda.agregarIntegrante(new Integrante(
    {nombre: 'dave ellefson',
    instrumento:'bajista'}
))
banda.agregarIntegrante(new Integrante(
    {nombre: 'nick menza',
    instrumento:'bateria'}
))
banda.agregarIntegrante(new Integrante(
    {nombre: 'marty friedman',
    instrumento:'guitarrista'}
))
```js class Banda { constructor({ nombre, generos = [], }) { this.nombre = nombre; this.generos = generos; this.integrantes = []; } agregarIntegrante(integrante) { const integranteBaterista = this.integrantes.some (Baterista => Baterista.instrumento === "Bateria"); if (integranteBaterista && integrante.instrumento === "Bateria"){ console.log ("Ya hay un baterista en la banda"); return; } this.integrantes.push(integrante); } } //Crear clase Integrante class Integrante { constructor({ nombre, instrumento, }) { this.nombre = nombre; this.instrumento = instrumento; } } const Julianita = new Integrante( { nombre: "julianita", instrumento: "Guitarra", } ); const Cely = new Integrante( { nombre: "Cely", instrumento: "Bateria", } ); const Rocky = new Integrante( { nombre: "Rocky", instrumento: "Bateria", } ); const BandaDeJuliana = new Banda ({ nombre: "Empanadas_Queer", generos: "Indie bogotano", }); BandaDeJuliana.agregarIntegrante(Julianita); BandaDeJuliana.agregarIntegrante(Cely); BandaDeJuliana.agregarIntegrante(Rocky); console.log(BandaDeJuliana); ```class Banda {    constructor({        nombre,        generos = \[],    }) {        this.nombre = nombre;        this.generos = generos;        this.integrantes = \[];    }    agregarIntegrante(integrante) {                const integranteBaterista = this.integrantes.some (Baterista => Baterista.instrumento === "Bateria");         if (integranteBaterista && integrante.instrumento === "Bateria"){            console.log ("Ya hay un baterista en la banda");            return;        }         this.integrantes.push(integrante);     }}   //Crear clase Integranteclass Integrante {    constructor({        nombre,        instrumento,    }) {        this.nombre = nombre;        this.instrumento = instrumento;     } } const Julianita = new Integrante(    {        nombre: "julianita",        instrumento: "Guitarra",    }); const Cely = new Integrante(    {        nombre: "Cely",        instrumento: "Bateria",    }); const Rocky = new Integrante(    {        nombre: "Rocky",        instrumento: "Bateria",    }); const BandaDeJuliana = new Banda ({    nombre: "Empanadas\_Queer",    generos: "Indie bogotano",}); BandaDeJuliana.agregarIntegrante(Julianita);BandaDeJuliana.agregarIntegrante(Cely);BandaDeJuliana.agregarIntegrante(Rocky); console.log(BandaDeJuliana);
class Banda {    constructor({        nombre,        generos = \[],    }) {        this.nombre = nombre;        this.generos = generos;        this.integrantes = \[];    }    agregarIntegrante(integrante) {                const integranteBaterista = this.integrantes.some (Baterista => Baterista.instrumento === "Bateria");         if (integranteBaterista && integrante.instrumento === "Bateria"){            console.log ("Ya hay un baterista en la banda");            return;        }         this.integrantes.push(integrante);     }}   //Crear clase Integranteclass Integrante {    constructor({        nombre,        instrumento,    }) {        this.nombre = nombre;        this.instrumento = instrumento;     } } const Julianita = new Integrante(    {        nombre: "julianita",        instrumento: "Guitarra",    }); const Cely = new Integrante(    {        nombre: "Cely",        instrumento: "Bateria",    }); const Rocky = new Integrante(    {        nombre: "Rocky",        instrumento: "Bateria",    }); const BandaDeJuliana = new Banda ({    nombre: "Empanadas\_Queer",    generos: "Indie bogotano",}); BandaDeJuliana.agregarIntegrante(Julianita);BandaDeJuliana.agregarIntegrante(Cely);BandaDeJuliana.agregarIntegrante(Rocky); console.log(BandaDeJuliana);
si que estuvo complicado, revise varios codigos y en la mayoria si el primer instrumento era bateria, no se agregaba los demás.
Dejo por aquí mi solución al reto y por si salva a alguien: 'Bateria', con sus comillas de string, su mayúscula y sin tilde. * Practicamente digo: * 👀 si el instrumento de este integranteNuevo es igual === a 'Bateria' * 👀 👀 y && dentro del array integrantes de esta banda ya hay algún integrante con objeto === 'Bateria' NO HAGAS NADA * En cualquier otro caso 🙂: añade ese integranteNuevo al array de integrantes de esta banda ```js class Banda { constructor({ nombre, generos = [], }) { this.nombre = nombre; this.generos = generos; this.integrantes = []; } agregarIntegrante(integranteNuevo) { if (integranteNuevo.instrumento === 'Bateria' && this.integrantes.some(integrante => integrante.instrumento === 'Bateria')) { return } this.integrantes.push(integranteNuevo) } } //Crear clase Integrante class Integrante { constructor({ nombre, instrumento }) { this.nombre = nombre; this.instrumento = instrumento } } export { Banda, Integrante, } ```
```js class Banda { constructor({ nombre, generos = [], }) { this.nombre = nombre; this.generos = generos; this.integrantes = []; } agregarIntegrante(integranteNuevo) { // Tu código aquí 👈 const existeBaterista = this.integrantes.find( integrante => integrante.instrumento.toLowerCase() == "bateria" ) if (existeBaterista && integranteNuevo.instrumento.toLowerCase() == "bateria") return this.integrantes.push(integranteNuevo) } } //Crear clase Integrante class Integrante { // Tu código aquí 👈 constructor({ nombre, instrumento, }){ this.nombre = nombre, this.instrumento = instrumento } } export { Banda, Integrante, } ```class Banda {  constructor({    nombre,    generos = \[],  }) {    this.nombre = nombre;    this.generos = generos;    this.integrantes = \[];  }  agregarIntegrante(integranteNuevo) {    // Tu código aquí 👈    const existeBaterista =      this.integrantes.find(        integrante =>          integrante.instrumento.toLowerCase() == "bateria"      )    if (existeBaterista && integranteNuevo.instrumento.toLowerCase() == "bateria") return        this.integrantes.push(integranteNuevo)  }} //Crear clase Integranteclass Integrante {  // Tu código aquí 👈  constructor({    nombre,    instrumento,  }){     this.nombre = nombre,    this.instrumento = instrumento  } } export {  Banda,  Integrante,}
Como aun en ninguno de los cursos aprendi a usar las funciones flechas quise intentarlo sin eso, asi quedo por si a alguien le sirveclass Banda {  constructor({    nombre,    generos = \[],  }) {    this.nombre = nombre;    this.generos = generos;    this.integrantes = \[];  }  agregarIntegrante(integranteNuevo) {    // Tu código aquí 👈    let HayBaterista = false;    for (const i of this.integrantes) {      if (integrante.instrumento === "Bateria") {        HayBaterista = true;        break;      }    }    if (!HayBaterista || integranteNuevo.instrumento !== "Bateria") {      this.integrantes.push(integranteNuevo);    } else {      console.log("Ya hay un baterista en la banda. No se puede agregar otro.");    }  }} //Crear clase Integranteclass Integrante {  // Tu código aquí 👈  constructor({    nombre,    instrumento,  }) {    this.nombre = nombre;    this.instrumento = instrumento;  } } export {  Banda,  Integrante,}```js class Banda { constructor({ nombre, generos = [], }) { this.nombre = nombre; this.generos = generos; this.integrantes = []; } agregarIntegrante(integranteNuevo) { // Tu código aquí 👈 let HayBaterista = false; for (const i of this.integrantes) { if (integrante.instrumento === "Bateria") { HayBaterista = true; break; } } if (!HayBaterista || integranteNuevo.instrumento !== "Bateria") { this.integrantes.push(integranteNuevo); } else { console.log("Ya hay un baterista en la banda. No se puede agregar otro."); } } } //Crear clase Integrante class Integrante { // Tu código aquí 👈 constructor({ nombre, instrumento, }) { this.nombre = nombre; this.instrumento = instrumento; } } export { Banda, Integrante, } ```
Mi solución al reto :) ```js class Banda { constructor({ nombre, generos = [], }) { this.nombre = nombre; this.generos = generos; this.integrantes = []; } agregarIntegrante(integranteNuevo) { if (!this.tieneBaterista()) this.integrantes.push(integranteNuevo); } tieneBaterista() { return this.integrantes.some(integrante => integrante.instrumento === "Bateria"); } } class Integrante { constructor({ nombre, instrumento, }) { this.nombre = nombre; this.instrumento = instrumento; } } export { Banda, Integrante, } ```
Mi solución al reto :) ```js class Banda { constructor({ nombre, generos = [], }) { this.nombre = nombre; this.generos = generos; this.integrantes = []; } agregarIntegrante(integranteNuevo) { if (!this.tieneBaterista()) this.integrantes.push(integranteNuevo); } tieneBaterista() { return this.integrantes.some(integrante => integrante.instrumento === "Bateria"); } } class Integrante { constructor({ nombre, instrumento, }) { this.nombre = nombre; this.instrumento = instrumento; } } export { Banda, Integrante, } ```class Banda {  constructor({    nombre,    generos = \[],  }) {    this.nombre = nombre;    this.generos = generos;    this.integrantes = \[];  }   agregarIntegrante(integranteNuevo) {    if (!this.tieneBaterista()) this.integrantes.push(integranteNuevo);  }   tieneBaterista() {    return this.integrantes.some(integrante => integrante.instrumento === "Bateria");  }} class Integrante {  constructor({    nombre,    instrumento,  }) {    this.nombre = nombre;    this.instrumento = instrumento;  }} export {  Banda,  Integrante,}
Intenten primero antes de ver . . . . . . Esta es mi solución ```js class Banda { constructor({ nombre, generos = [], }) { this.nombre = nombre; this.generos = generos; this.integrantes = []; } agregarIntegrante(integranteNuevo) { const baterista = this.integrantes.some(integrante => integrante.instrumento === 'Bateria'); if (!baterista) { this.integrantes.push(integranteNuevo); } else if (baterista) { if (integranteNuevo.instrumento !== 'Bateria') { this.integrantes.push(integranteNuevo); } } } } //Crear clase Integrante class Integrante { constructor({ nombre, instrumento }) { this.nombre = nombre; this.instrumento = instrumento; } } export { Banda, Integrante, } ```class Banda {  constructor({    nombre,    generos = \[],  }) {    this.nombre = nombre;    this.generos = generos;    this.integrantes = \[];  }  agregarIntegrante(integranteNuevo) {    const baterista = this.integrantes.some(integrante => integrante.instrumento === 'Bateria');    if (!baterista) {      this.integrantes.push(integranteNuevo);    } else if (baterista) {      if (integranteNuevo.instrumento !== 'Bateria') {        this.integrantes.push(integranteNuevo);      }    }  }} //Crear clase Integranteclass Integrante {  constructor({ nombre, instrumento }) {    this.nombre = nombre;    this.instrumento = instrumento;  } } export {  Banda,  Integrante,}
Hola, es mi propuesta de solución al reto ```js class Banda { constructor({ nombre, generos = [], }) { this.nombre = nombre; this.generos = generos; this.integrantes = []; } agregarIntegrante(integranteNuevo) { if(integranteNuevo.instrumento === 'Bateria' && bandera == 0){ bandera = 1 this.integrantes.push(integranteNuevo) } if(bandera == 1 && integranteNuevo.instrumento == 'Bateria'){ console.log('La banda ya tiene baterista') }else{ this.integrantes.push(integranteNuevo) } } } //Crear clase Integrante class Integrante { constructor(nombre, instrumento) { this.nombre = nombre this.instrumento = instrumento } } const data = { nombre: "Los Jacks", generos: ["rock", "pop", "post-punk"], integrantes: [] } let bandera = 0 const nuevaBanda = new Banda(data) nuevaBanda.agregarIntegrante (new Integrante(nombre = "Juan Camilo", instrumento = "Bateria")) nuevaBanda.agregarIntegrante (new Integrante(nombre = "Paul", instrumento = "Bateria")) nuevaBanda.agregarIntegrante (new Integrante(nombre = "Erik", instrumento = "Guitarra")) nuevaBanda.agregarIntegrante (new Integrante(nombre = "Katherine", instrumento = "Bateria")) nuevaBanda.agregarIntegrante (new Integrante(nombre = "Juan Pablo", instrumento = "Flaustista")) export { Banda, Integrante, } ```
Hola esta es mi propuesta de solución al reto: ```js class Banda { constructor({ nombre, generos = [], }) { this.nombre = nombre; this.generos = generos; this.integrantes = []; } agregarIntegrante(integranteNuevo) { if(integranteNuevo.instrumento === 'Bateria' && bandera == 0){ bandera = 1 this.integrantes.push(integranteNuevo) } if(bandera == 1 && integranteNuevo.instrumento == 'Bateria'){ console.log('La banda ya tiene baterista') }else{ this.integrantes.push(integranteNuevo) } } } //Crear clase Integrante class Integrante { constructor(nombre, instrumento) { this.nombre = nombre this.instrumento = instrumento } } const data = { nombre: "Los Jacks", generos: ["rock", "pop", "post-punk"], integrantes: [] } let bandera = 0 const nuevaBanda = new Banda(data) nuevaBanda.agregarIntegrante (new Integrante(nombre = "Juan Camilo", instrumento = "Bateria")) nuevaBanda.agregarIntegrante (new Integrante(nombre = "Paul", instrumento = "Bateria")) nuevaBanda.agregarIntegrante (new Integrante(nombre = "Erik", instrumento = "Guitarra")) nuevaBanda.agregarIntegrante (new Integrante(nombre = "Katherine", instrumento = "Bateria")) nuevaBanda.agregarIntegrante (new Integrante(nombre = "Juan Pablo", instrumento = "Flaustista")) export { Banda, Integrante, } ```*class* <u>Banda</u> {    *constructor*({      *nombre*,      *generos* = \[],    }) {      this.nombre = *nombre*;      this.generos = *generos*;      this.integrantes = \[];    }      agregarIntegrante(*integranteNuevo*) {              if(*integranteNuevo*.instrumento === 'Bateria' && bandera == 0){            bandera = 1            this.integrantes.push(*integranteNuevo*)        }         if(bandera == 1 && *integranteNuevo*.instrumento == 'Bateria'){          console.log('La banda ya tiene baterista')        }else{          this.integrantes.push(*integranteNuevo*)        }  }}    //Crear clase Integrante  *class* <u>Integrante</u> {    *constructor*(*nombre*, *instrumento*) {       this.nombre = *nombre*      this.instrumento = *instrumento*    }  }   *const* data = {    nombre: "Los Jacks",    generos: \["rock", "pop", "post-punk"],    integrantes: \[]  }    *let* bandera = 0    *const* nuevaBanda = new <u>Banda</u>(data)    nuevaBanda.agregarIntegrante (new <u>Integrante</u>(nombre = "Juan Camilo", instrumento = "Bateria"))    nuevaBanda.agregarIntegrante (new <u>Integrante</u>(nombre = "Paul", instrumento = "Bateria"))    nuevaBanda.agregarIntegrante (new <u>Integrante</u>(nombre = "Erik", instrumento = "Guitarra"))    nuevaBanda.agregarIntegrante (new <u>Integrante</u>(nombre = "Katherine", instrumento = "Bateria"))    nuevaBanda.agregarIntegrante (new <u>Integrante</u>(nombre = "Juan Pablo", instrumento = "Flaustista"))      export {    <u>Banda</u>,    <u>Integrante</u>,  }
`Esta es mi propuesta de solución:` `class`` ``Banda`` {    ``constructor``({      ``nombre``,      ``generos`` = [],    }) {      this.nombre = ``nombre``;      this.generos = ``generos``;      this.integrantes = [];    }      agregarIntegrante(``integranteNuevo``) {              if(``integranteNuevo``.instrumento === 'Bateria' && bandera == 0){            bandera = 1            this.integrantes.push(``integranteNuevo``)        }` `        if(bandera == 1 && ``integranteNuevo``.instrumento == 'Bateria'){          console.log('La banda ya tiene baterista')        }else{          this.integrantes.push(``integranteNuevo``)        }  }}    //Crear clase Integrante  ``class`` ``Integrante`` {    ``constructor``(``nombre``, ``instrumento``) {       this.nombre = ``nombre``      this.instrumento = ``instrumento``    }  }` `  ``const`` data = {    nombre: "Los Jacks",    generos: ["rock", "pop", "post-punk"],    integrantes: []  }    ``let`` bandera = 0    ``const`` nuevaBanda = new ``Banda``(data)    nuevaBanda.agregarIntegrante (new ``Integrante``(nombre = "Juan Camilo", instrumento = "Bateria"))    nuevaBanda.agregarIntegrante (new ``Integrante``(nombre = "Paul", instrumento = "Bateria"))    nuevaBanda.agregarIntegrante (new ``Integrante``(nombre = "Erik", instrumento = "Guitarra"))    nuevaBanda.agregarIntegrante (new ``Integrante``(nombre = "Katherine", instrumento = "Bateria"))    nuevaBanda.agregarIntegrante (new ``Integrante``(nombre = "Juan Pablo", instrumento = "Flaustista"))   ` `  export {    ``Banda``,    ``Integrante``,  }`
''' class Banda { constructor({ nombre, generos = \[], }) { this.nombre = nombre; this.generos = generos; this.integrantes = \[]; } agregarIntegrante(integranteNuevo) { let indicador = false for (const integrante of this.integrantes) { if (integrante.instrumento === 'Bateria') { indicador = true } } if (indicador) { console.log("no se puede agregar") }else { this.integrantes.push(integranteNuevo) } }} //Crear clase Integranteclass Integrante { constructor({ nombre, instrumento }) { this.nombre = nombre, this.instrumento = instrumento }} export { Banda, Integrante,} '''
```js class Banda { constructor({ nombre, generos = [], }) { this.nombre = nombre; this.generos = generos; this.integrantes = []; } agregarIntegrante(integranteNuevo) { // Tu código aquí 👈 if ( this.integrantes.find((element) => element.instrumento === 'Bateria') ) { console.log('La banda ya tiene un baterista'); } else { this.integrantes.push(integranteNuevo); } } } //Crear clase Integrante class Integrante { // Tu código aquí 👈 constructor({ nombre, instrumento }) { this.nombre = nombre; this.instrumento = instrumento; } } const data = { nombre: 'Los Beatles', generos: ["Skiffle", "Rock and roll", "Pop", "Folk", "Rock psicodélico", "Música clásica india", "Blues"], integrantes: [], }; const banda = new Banda(data); banda.agregarIntegrante( new Integrante({ nombre: 'John Lennon', instrumento: 'Guitarra' }) ); banda.agregarIntegrante( new Integrante({ nombre: 'Paul McCartney', instrumento: 'Bajo' }) ); banda.agregarIntegrante( new Integrante({ nombre: 'George Harrison', instrumento: 'Guitarra' }) ); banda.agregarIntegrante( new Integrante({ nombre: 'Ringo Starr', instrumento: 'Batería' }) ); export { Banda, Integrante, } ```class Banda {  constructor({    nombre,    generos = \[],  }) {    this.nombre = nombre;    this.generos = generos;    this.integrantes = \[];  }  agregarIntegrante(integranteNuevo) {    // Tu código aquí 👈    if (      this.integrantes.find((element) => element.instrumento === 'Bateria')    ) {      console.log('La banda ya tiene un baterista');    } else {      this.integrantes.push(integranteNuevo);    }  }} //Crear clase Integranteclass Integrante {  // Tu código aquí 👈  constructor({ nombre, instrumento }) {    this.nombre = nombre;    this.instrumento = instrumento;  }} const data = {  nombre: 'Los Beatles',  generos: \["Skiffle", "Rock and roll", "Pop", "Folk", "Rock psicodélico", "Música clásica india", "Blues"],  integrantes: \[],}; const banda = new Banda(data); banda.agregarIntegrante(  new Integrante({ nombre: 'John Lennon', instrumento: 'Guitarra' }));banda.agregarIntegrante(  new Integrante({ nombre: 'Paul McCartney', instrumento: 'Bajo' }));banda.agregarIntegrante(  new Integrante({ nombre: 'George Harrison', instrumento: 'Guitarra' }));banda.agregarIntegrante(  new Integrante({ nombre: 'Ringo Starr', instrumento: 'Batería' })); export {  Banda,  Integrante,}
```js class Banda { constructor({ nombre, generos = [], }) { this.nombre = nombre; this.generos = generos; this.integrantes = []; } agregarIntegrante(integranteNuevo) { if (this.integrantes.every(i => i.instrumento !== "Bateria")) { this.integrantes.push(integranteNuevo); } else { console.log("Ya no hay Integrantes"); } } } class Integrante { constructor({nombre, instrumento}) { this.nombre = nombre; this.instrumento = instrumento; } } export { Banda, Integrante, } ```
Comparto mi código, no sin antes decir que me parece frustrante que no se puede escribir esta misma lógica con un ciclo for, no me queda claro por qué. El ciclo for que había escrito es el siguiente: ```js class Banda { constructor({ nombre, generos = [], }) { this.nombre = nombre; this.generos = generos; this.integrantes = []; } agregarIntegrante(integranteNuevo) { if (this.integrantes.length == 0) { this.integrantes.push(integranteNuevo) } else { for (let i = 0; i < banda.integrantes.length; i++) { if (this.integrantes[i].instrumento == "Bateria" || integranteNuevo.instrumento == "Bateria") { console.log("Máximo puedes tener un baterista") }else {banda.integrantes.push(integranteNuevo)} } } } } class Integrante { constructor ({ nombre, instrumento, }) { this.nombre = nombre; this.instrumento = instrumento; } } ```Este código no me funcionó, pero no tengo claro por qué. El código que si me funcionó es el siguiente (lo construí con ayuda de ChatGTP que me indicó la siguiente línea: const hasDrummer = banda.integrantes.some(integrante => integrante.instrumento === "Bateria");). Código que si funcionó: ```js class Banda { constructor({ nombre, generos = [], }) { this.nombre = nombre; this.generos = generos; this.integrantes = []; } agregarIntegrante(integranteNuevo) { const hasDrummer = this.integrantes.some(integrante => integrante.instrumento === "Bateria"); if (this.integrantes.length == 0) { this.integrantes.push(integranteNuevo) } else if (hasDrummer && integranteNuevo.instrumento == "Bateria") { console.log("Máximo puedes tener un baterista") }else {this.integrantes.push(integranteNuevo)} } } class Integrante { constructor ({ nombre, instrumento, }) { this.nombre = nombre; this.instrumento = instrumento; } } ```Como se ve, la línea que indicó ChatGTP reemplaza precisamente el ciclo for. He revisado ambos codigos y sobre todo, el ciclo for, pero no logro entender por qué funciona uno y no el otro.
tengo una duda, el baterista ya esta argegado o lo tienes que agregar tu?. por que si ya esta agregado solo tienes que verificar si se argega otro, pero si no essta argegado, tienes que agregarlo pasando po el metodo integrante, y luego verificar si se repite el intrumento. Lo digo pq vi varios resultados de los estudiantes y todos realizan la logica como si el bateriasta estuviera agregado (osea solo verifican si el integrante nuevo se repitio)
un trabajo honesto xd
Esta es la forma en como lo resolví. `class Banda { constructor({ nombre, generos = [], }) { this.nombre = nombre; this.generos = generos; this.integrantes = []; } agregarIntegrante(integranteNuevo) { if (this.integrantes.filter(a => a.instrumento === "Bateria").length === 0 ) { return this.integrantes.push(integranteNuevo); } else if ((this.integrantes.map(a => a.instrumento).includes("Bateria")!=(integranteNuevo.instrumento==="Bateria"))) { return this.integrantes.push(integranteNuevo); } else {` ` console.log("Ya existe un baterista") }` ` }}` `//Crear clase Integranteclass Integrante { constructor({ nombre, instrumento }) { this.nombre = nombre; this.instrumento = instrumento; }` `}`
Ya se que es POO pero quise modificarlo :) ```js class Banda { constructor({ nombre, generos = [], }) { this.nombre = nombre; this.generos = generos; this.integrantes = []; } agregarIntegrante(integranteNuevo) { // Tu código aquí 👈 const bateristaExiste = this.integrantes.find(int => int.instrumento === 'Bateria') const val = bateristaExiste && integranteNuevo.instrumento ==='Bateria' ? console.log('ya hay un baterista') : this.integrantes.push(integranteNuevo) } } //Crear clase Integrante class Integrante { // Tu código aquí 👈 constructor({ nombre, instrumento, }) { this.nombre = nombre this.instrumento = instrumento } } export { Banda, Integrante, } ```
Esta es mi solución:En el método `agregarIntegrante`, se busca si ya existe un baterista en la banda utilizando el método `find`. ```js class Banda { constructor({ nombre, generos = [], }) { this.nombre = nombre; this.generos = generos; this.integrantes = []; } agregarIntegrante(integranteNuevo) { // Tu código aquí 👈 const bateristaExiste = this.integrantes.find(j => j.instrumento === 'Bateria') if (bateristaExiste && integranteNuevo.instrumento === 'Bateria') { console.log('No se puede') } else { this.integrantes.push(integranteNuevo) } } } //Crear clase Integrante class Integrante { // Tu código aquí 👈 constructor({ nombre, instrumento, }) { this.nombre = nombre this.instrumento = instrumento } } export { Banda, Integrante, } ``` * Si `bateristaExiste` es `true` (es decir, si ya hay un baterista en la banda) y el nuevo integrante también es un baterista (`integranteNuevo.instrumento === 'Bateria'`), se muestra un mensaje indicando que no se puede agregar otro baterista. * Si `bateristaExiste` es `false` o el nuevo integrante no es un baterista, entonces se agrega el nuevo integrante al array `integrantes` de la banda. * En el ejemplo de uso al final, se crea una instancia de la clase `Banda` llamada `banda` con algunos géneros. Luego se intenta agregar a dos integrantes: uno con instrumento "Guitarra" y otro con instrumento "Bateria". Al intentar agregar un segundo baterista ("George"), se mostrará un mensaje indicando que no se puede agregar otro baterista.
```js class Banda { constructor({ nombre, generos = [], }) { this.nombre = nombre; this.generos = generos; this.integrantes = []; } agregarIntegrante(integranteNuevo) { const bateristExist = this.integrantes.some(integrante => integrante.instrumento === "Bateria"); if (bateristExist === false) { this.integrantes.push(integranteNuevo); } } } //Crear clase Integrante class Integrante { constructor({ nombre, instrumento, }){ this.nombre = nombre; this.instrumento = instrumento; } } export { Banda, Integrante, } ```class Banda {  constructor({    nombre,    generos = \[],  }) {    this.nombre = nombre;    this.generos = generos;    this.integrantes = \[];  }  agregarIntegrante(integranteNuevo) {    const bateristExist = this.integrantes.some(integrante => integrante.instrumento === "Bateria");    if (bateristExist === false) {        this.integrantes.push(integranteNuevo);    }   }}  //Crear clase Integranteclass Integrante {  constructor({    nombre,    instrumento,  }){    this.nombre = nombre;    this.instrumento = instrumento;  }}export {  Banda,  Integrante,}
class Banda {  constructor({    nombre,    generos = \[],  }) {    this.nombre = nombre;    this.generos = generos;    this.integrantes = \[];  }  agregarIntegrante(integranteNuevo) {    // Tu código aquí 👈     const result = this.integrantes.find(rest => rest.instrumento === "Bateria");     if (!result) {      this.integrantes.push(integranteNuevo);     }   }} //Crear clase Integranteclass Integrante {  // Tu código aquí 👈  constructor({ nombre, instrumento }) {    this.nombre = nombre;     this.instrumento = instrumento;     } } export {  Banda,  Integrante,}
Me pasa algo curioso, porque el único que no me dio check fue el requisito de no dejar agregar un instrumento repetido, pero cuando lo corro en la consola efectivamente no me deja agregar otra Bateria, si alguno me puede ayudar seria perfecto ```js class Banda { constructor({ nombre, generos = [], integrantes = [], }) { this.nombre = nombre; this.generos = generos; this.integrantes = integrantes; } agregarIntegrante(integranteNuevo) { // Tu código aquí 👈 if (!(this.integrantes.find(integrante => integranteNuevo.instrumento == "Bateria"))) this.integrantes.push(integranteNuevo); } } //Crear clase Integrante class Integrante { // Tu código aquí 👈 constructor({ nombre, instrumento, }) { this.nombre = nombre; this.instrumento = instrumento; } } export { Banda, Integrante, } ```
```js class Banda { constructor({ nombre, generos = [], }) { this.nombre = nombre; this.generos = generos; this.integrantes = []; } agregarIntegrante(integranteNuevo) { let bateristaExistente = false; for (let i = 0; i < this.integrantes.length; i++) { if (this.integrantes[i].instrumento === "Bateria") { bateristaExistente = true; break; } } if (bateristaExistente && integranteNuevo.instrumento === "Bateria") { alert("Ya tenemos un baterista en el grupo"); } else { this.integrantes.push(integranteNuevo); } } } //Crear clase Integrante class Integrante { constructor({ nombre, instrumento, }) { this.nombre = nombre; this.instrumento = instrumento; } } export { Banda, Integrante, } ```
aquí mi solución creando una función que evalúe si algún integrante tiene el instrumento con el método some(): ```js class Banda { constructor({ nombreBanda, generos = [], }) { this.nombreBanda = nombreBanda; this.generos = generos; this.integrantes = []; } agregarIntegrante(integranteNuevo) { this.integrantes.push(integranteNuevo) } tieneBaterista(){ return this.integrantes.some(integrante => integrante.instrumento === 'Drums') } } //Crear clase Integrante class Integrante { constructor({ nombre, instrumento }){ this.nombre = nombre this. instrumento = instrumento } } const dataBand = { nombreBanda: 'Los pitufos', generos: [ 'Infantil', 'Rock', 'Pop' ] } const mainBand = new Banda(dataBand) const integrante1 = new Integrante({ nombre: 'Freddie Mercury', instrumento: 'Guitar' }) const integrante2 = new Integrante({ nombre: 'John Bonhanm', instrumento: 'Drums' }) function registroIntegrante(newIntegrante) { if(!mainBand.tieneBaterista()){ mainBand.agregarIntegrante(newIntegrante) return true } else { return false } } function ingresoIntegrante(newIntegrante){ if(registroIntegrante(newIntegrante)){ console.log(`Se ingreso a ${newIntegrante.nombre}`) } else { console.log(`No fue posible incluir a ${newIntegrante.nombre} porque ya existe baterista en la banda`) } } ```class Banda {    constructor({      nombreBanda,      generos = \[],          }) {      this.nombreBanda = nombreBanda;      this.generos = generos;      this.integrantes = \[];    }    agregarIntegrante(integranteNuevo) {        this.integrantes.push(integranteNuevo)            }    tieneBaterista(){        return this.integrantes.some(integrante => integrante.instrumento === 'Drums')    }  }  //Crear clase Integrante  class Integrante {    constructor({        nombre,        instrumento    }){        this.nombre = nombre        this. instrumento = instrumento    }       } const dataBand = {    nombreBanda: 'Los pitufos',    generos: \[        'Infantil',        'Rock',        'Pop'    ]} const mainBand = new Banda(dataBand) const integrante1 = new Integrante({    nombre: 'Freddie Mercury',    instrumento: 'Guitar'}) const integrante2 = new Integrante({    nombre: 'John Bonhanm',    instrumento: 'Drums'}) function registroIntegrante(newIntegrante) {    if(!mainBand.tieneBaterista()){        mainBand.agregarIntegrante(newIntegrante)        return true    } else {                return false    }      } function ingresoIntegrante(newIntegrante){    if(registroIntegrante(newIntegrante)){        console.log(`Se ingreso a ${newIntegrante.nombre}`)    } else {        console.log(`No fue posible incluir a ${newIntegrante.nombre} porque ya existe baterista en la banda`)    }}
Aquí mi solución funcional: ```js class Banda { constructor({ nombreBanda, generos = [], }) { this.nombreBanda = nombreBanda; this.generos = generos; this.integrantes = []; } agregarIntegrante(integranteNuevo) { this.integrantes.push(integranteNuevo) } } //Crear clase Integrante class Integrante { constructor({ nombre, instrumento }){ this.nombre = nombre this. instrumento = instrumento } } const dataBand = { nombreBanda: 'Los pitufos', generos: [ 'Infantil', 'Rock', 'Pop' ] } const mainBand = new Banda(dataBand) const integrante1 = new Integrante({ nombre: 'Freddie Mercury', instrumento: 'Guitar' }) const integrante2 = new Integrante({ nombre: 'John Bonhanm', instrumento: 'Drums' }) // mainBand.agregarIntegrante(integrante1) function ingresarIntegrante(newIntegrante) { if(mainBand.integrantes.length === 0){ mainBand.agregarIntegrante(newIntegrante) return true } else { for (let i = 0; i < mainBand.integrantes.length; i++) { const validateDrums = mainBand.integrantes[i].instrumento if(validateDrums === 'Drums' && newIntegrante.instrumento === 'Drums'){ return false } } mainBand.agregarIntegrante(newIntegrante) return true } } ```class Banda { constructor({ nombreBanda, generos = \[], }) { this.nombreBanda = nombreBanda; this.generos = generos; this.integrantes = \[]; } agregarIntegrante(integranteNuevo) { this.integrantes.push(integranteNuevo) } } //Crear clase Integrante class Integrante { constructor({ nombre, instrumento }){ this.nombre = nombre this. instrumento = instrumento } } const dataBand = { nombreBanda: 'Los pitufos', generos: \[ 'Infantil', 'Rock', 'Pop' ] } const mainBand = new Banda(dataBand) const integrante1 = new Integrante({ nombre: 'Freddie Mercury', instrumento: 'Guitar' }) const integrante2 = new Integrante({ nombre: 'John Bonhanm', instrumento: 'Drums' }) // mainBand.agregarIntegrante(integrante1) function ingresarIntegrante(newIntegrante) { if(mainBand.integrantes.length === 0){ mainBand.agregarIntegrante(newIntegrante) return true } else { for (let i = 0; i < mainBand.integrantes.length; i++) { const validateDrums = mainBand.integrantes\[i].instrumento if(validateDrums === 'Drums' && newIntegrante.instrumento === 'Drums'){ return false } } mainBand.agregarIntegrante(newIntegrante) return true } }

Despues de casi 10 minutos de intensa búsqueda me di cuenta que me faltaba una “S” en una función. Dejo mi código por si a alguien le sirve para desarrollar el suyo.

class Banda {
  constructor({
    nombre,
    generos = [],
  }) {
    this.nombre = nombre;
    this.generos = generos;
    this.integrantes = [];
  }
  agregarIntegrante(integranteNuevo) {
    if (!this.integrantes.find((integrante) => integrante.instrumento == "Bateria")) {
      this.integrantes.push(integranteNuevo)
    }
  }
}

//Crear clase Integrante
class Integrante {
  constructor({
    nombre,
    instrumento,
  }) {
    this.nombre = nombre;
    this.instrumento = instrumento;
  }

}


export {
  Banda,
  Integrante,
}
```js class Banda { constructor({ nombre, generos = [], }) { this.nombre = nombre; this.generos = generos; this.integrantes = []; } agregarIntegrante(integranteNuevo) { if (integranteNuevo.instrumento === "Baterista") { if (this.integrantes.some((integrante) => { return integrante.instrumento === "Baterista"; })) { console.log("No se pueden agregar dos bateristas"); return; } this.integrantes.push(integranteNuevo); console.log(this.integrantes); console.log("Baterista agregado"); } else { this.integrantes.push(integranteNuevo); } } } //Crear clase Integrante class Integrante { constructor({ name, instrumento, }) { this.name = name; this.instrumento = instrumento; } } const newBanda = new Banda({ nombre: 'Nirvana', generos: ['Rock', 'Pop'], }); const saxofonista = new Integrante({ name: 'Juan C', instrumento: 'Saxofonista', }); const baterista = new Integrante({ name: 'Pedro', instrumento: 'Baterista', }); const baterias2 = new Integrante({ name: 'Jorge', instrumento: 'Baterista', }); const guitarista = new Integrante({ name: 'Ana', instrumento: 'Guitarrista', }); newBanda.agregarIntegrante(saxofonista); newBanda.agregarIntegrante(baterista); newBanda.agregarIntegrante(baterias2); newBanda.agregarIntegrante(guitarista); console.log(newBanda); ```
Hola profe, estaba tratando de realizar el playground, pero no corre las pruebas, demore algo pero la termine y la probe en vs code: class Banda {  constructor({    nombre,    generos = \[],    integrantes = \[],  }) {    this.nombre = nombre;    this.generos = generos;    this.integrantes = integrantes;  }   agregarIntegrante(Integrante) {    if (this.verificarDuplicidadBaterista(Integrante)) {      console.log("No pueden haber dos bateritas")    } else {      this.integrantes.push(Integrante)    }  }   verificarDuplicidadBaterista(Integrante) {    for (let i = 0; i < this.integrantes.length; i++) {      if (this.integrantes\[i].instrumento === Integrante.instrumento) {        return true;      } else {        return false;      }    }  }} //Crear clase Integranteclass Integrante {  // Tu código aquí 👈  constructor({    nombre,    instrumento  }) {    this.nombre = nombre;    this.instrumento = instrumento  }} export {  Banda,  Integrante,} const ciguapa = new Banda({  nombre: "Ciguapa",  generos: \[    "Merengue"  ]}); const kevin = new Integrante({  nombre: "Kevin",  instrumento: "Baterista"}); const vitico = new Integrante({  nombre: "Vitico",  instrumento: "Baterista"}); ciguapa.agregarIntegrante(kevin); ciguapa.agregarIntegrante(vitico);
GG![](https://static.platzi.com/media/user_upload/image-4819e08e-84bd-45e9-99b5-9022f04b39ac.jpg)
class Banda {
  constructor({
    nombre,
    generos = [],
  }) {
    this.nombre = nombre;
    this.generos = generos;
    this.integrantes = [];
  }
  agregarIntegrante(integranteNuevo) {
    // Tu código aquí 👈
    if (this.integrantes.find((elment) =>
      elment.instrumento === 'Bateria')) {
      console.log('No puedes agregar otro baterista')
    } else {
      this.integrantes.push(integranteNuevo);
    }
  }
}

//Crear clase Integrante
class Integrante {
  // Tu código aquí 👈
  constructor({
    nombre,
    instrumento = [
      'Bajo',
      'Guitarra',
      'Bateria'
    ]
  }) {
    this.nombre = nombre;
    this.instrumento = instrumento
  }
}


export {
  Banda,
  Integrante,
}
class Banda {
    constructor({
        nombre,
        generos = [],
    }) {
        this.nombre = nombre;
        this.generos = generos;
        this.integrantes = [];
    }
    agregarIntegrante(integranteNuevo) {
        if (integranteNuevo.instrumento === "Bateria" && this.hayBaterista()) {
            console.log("Ya hay un baterista en la banda");
        } else {
            this.integrantes.push(integranteNuevo);
        }

    }
    hayBaterista() {
        return this.integrantes.some((integrante) => integrante.instrumento === "Bateria");
    }
}
```js class Banda { constructor({ nombre, generos = [], }) { this.nombre = nombre; this.generos = generos; this.quantityOfDrummers = 0; this.integrantes = []; } agregarIntegrante(integranteNuevo) { if (integranteNuevo.instrumento.toLowerCase() === 'bateria') { if (this.quantityOfDrummers === 0) { this.integrantes.push(integranteNuevo) this.quantityOfDrummers++ console.log('Se añadió correctamente') return; } else { console.log('No se pudo agregar, ya existe un baterista en la banda') } } else { this.integrantes.push(integranteNuevo) console.log('Se añadió correctamente') } } } //Crear clase Integrante class Integrante { constructor({ nombre, instrumento }) { this.nombre = nombre this.instrumento = instrumento } } export { Banda, Integrante, } ```
class Banda { constructor({ nombre, generos = \[], }) { this.nombre = nombre; this.generos = generos; this.quantityOfDrummers = 0; this.integrantes = \[]; } agregarIntegrante(integranteNuevo) { if (integranteNuevo.instrumento.toLowerCase() === 'bateria') { if (this.quantityOfDrummers === 0) { this.integrantes.push(integranteNuevo) this.quantityOfDrummers++ console.log('Se añadió correctamente') return; } else { console.log('No se pudo agregar, ya existe un baterista en la banda') } } else { this.integrantes.push(integranteNuevo) console.log('Se añadió correctamente') } } } //Crear clase Integrante class Integrante { constructor({ nombre, instrumento }) { this.nombre = nombre this.instrumento = instrumento } } export { Banda, Integrante, }
```js class Banda { constructor({ nombre, generos = [], }) { this.nombre = nombre; this.generos = generos; this.integrantes = []; } agregarIntegrante(integranteNuevo) { let existe = this.integrantes.some(integrante => integrante.instrumento == integranteNuevo.instrumento) if (!existe) { this.integrantes.push(integranteNuevo) } } } class Integrante { constructor({ nombre, instrumento, }) { this.nombre = nombre; this.instrumento = instrumento; } } ```En mi caso lo que me pareció mas optimo y escalable fue que existiese una variable que me diga si ya hay un integrante en la banda con el instrumento y si ya pues que no haga nada pero si no pues lo agregue a los integrantes. viéndolo así me parece mas legible el código y además no se limita a un solo tipo de instrumento ya que verifica cada integrante su instrumento y al momento que encuentre alguno (some) directamente termina la ejecución y sigue con el siguiente.

reto solucionado

class Banda {
  constructor({
    nombre,
    generos = [],
  }) {
    this.nombre = nombre;
    this.generos = generos;
    this.integrantes = [];
  }
  agregarIntegrante(integranteNuevo) {
    // Tu código aquí 👈
    if (
      this.integrantes.find((persona) => {
        return persona.instrumento === 'Bateria'
      })
    ) {

    } else {
      this.integrantes.push(integranteNuevo)
    }

  }
}

//Crear clase Integrante
class Integrante {
  // Tu código aquí 👈
  constructor({ nombre, instrumento }) {
    this.nombre = nombre
    this.instrumento = instrumento
    
  }

}


export {
  Banda,
  Integrante,
}

Esta es mi solución, pero no pasa las pruebas a menos que cambies el throw new Error(“Only one member can be added”) y lo reemplaces con un console.log 😕

class Banda {
  constructor({
    nombre,
    generos = [],
  }) {
    this.nombre = nombre;
    this.generos = generos;
    this.integrantes = [];
  }
  agregarIntegrante(integranteNuevo) {
    // Tu código aquí 👈
    if (this.integrantes.some((member) => member.instrumento === integranteNuevo.instrumento)) {
      throw new Error("Only one member can be added.")
    } else {
      this.integrantes.push(integranteNuevo)
    }
  }
}

//Crear clase Integrante
class Integrante {
  // Tu código aquí 👈
  constructor({ nombre, instrumento }) {
    this.nombre = nombre;
    this.instrumento = instrumento;
  }

}


export {
  Banda,
  Integrante,
}
Hola compañeros Platzi!!!! Comparto mi código, claramente no lo mires hasta que lo trabajes. Se usó el método some para manipulación... Un gran curso de Manipulación de Arrays del gran NicoBytes```js class Banda { constructor({ nombre, generos = [], }) { this.nombre = nombre; this.generos = generos; this.integrantes = []; } agregarIntegrante(integranteNuevo) { // Tu código aquí 👈 if (this.integrantes.some(element => element.instrumento === integranteNuevo.instrumento)) { console.log('Existe') } else { this.integrantes.push(integranteNuevo) } } } //Crear clase Integrante class Integrante { // Tu código aquí 👈 constructor({ nombre, instrumento }) { this.nombre = nombre; this.instrumento = instrumento; } } export { Banda, Integrante, } ```class Banda { constructor({ nombre, generos = \[], }) { this.nombre = nombre; this.generos = generos; this.integrantes = \[]; } agregarIntegrante(integranteNuevo) { // Tu código aquí 👈 if (this.integrantes.some(element => element.instrumento === integranteNuevo.instrumento)) { console.log('Existe') } else { this.integrantes.push(integranteNuevo) } }} //Crear clase Integranteclass Integrante { // Tu código aquí 👈 constructor({ nombre, instrumento }) { this.nombre = nombre; this.instrumento = instrumento; } } export { Banda, Integrante,}
```js class Banda { constructor({ nombre, generos = [], }) { this.nombre = nombre; this.generos = generos; this.integrantes = []; } agregarIntegrante(integranteNuevo) { // Tu código aquí 👈 let instrumento = integranteNuevo.instrumento.toLowerCase() for (let i = 0; i < this.integrantes.length; i++) { if (instrumento === this.integrantes[i].instrumento.toLowerCase()) { return false } } return this.integrantes.push(new Integrante(integranteNuevo)) } } //Crear clase Integrante class Integrante { // Tu código aquí 👈 constructor({ nombre, instrumento }) { this.nombre = nombre this.instrumento = instrumento } } export { Banda, Integrante, } ``` Esta es mi solución.

Solución

class Banda {
  constructor({
    nombre,
    generos = [],
  }) {
    this.nombre = nombre;
    this.generos = generos;
    this.integrantes = [];
  }
  agregarIntegrante(integranteuevo) {
    const thereAreBaterista = this.integrantes.some(integrante =>
      integrante.instrumento === 'Bateria'
    )
    if (thereAreBaterista) {
      if (integranteuevo.instrumento === 'Bateria') {
        console.log('No puedes agregar mas de un integrante con bateria')
        return
      }
    }
    this.integrantes.push(integranteuevo)

  }
}

//Crear clase Integrante
class Integrante {
  // Tu código aquí 👈
  constructor({
    nombre,
    instrumento
  }) {
    this.nombre = nombre;
    this.instrumento = instrumento;
  }
}


export {
  Banda,
  Integrante,
}

hola como estan aca esta mi aporta asi lo hice yo y me funciono.

class Banda {
constructor({
nombre,
generos = [],
}) {
this.nombre = nombre;
this.generos = generos;
this.integrantes = [];
}
agregarIntegrante(integranteNuevo) {
// Tu código aquí 👈

  if(this.integrantes.length === 0){
    this.integrantes.push(integranteNuevo);
  }else{
    const repetido = this.integrantes.filter((int)=>{
        return int.instrumento === integranteNuevo.instrumento;
    });
    if(repetido.length === 0){
        this.integrantes.push(integranteNuevo);
    }else{
        console.log(`ya hay un ${integranteNuevo.instrumento} en la banda`)
    }
  }
}

}

//Crear clase Integrante
class Integrante {
// Tu código aquí 👈
constructor({
nombre,
instrumento,
}) {
this.nombre = nombre;
this.instrumento = instrumento;
}
}

const banda = new Banda({
nombre:‘Los jacks’,
generos:[“rock”, “pop”, “post-punk”],
integrantes:[],
});

export {
Banda,
Integrante,
}

Mi aporte:

class Banda {
constructor({
nombre,
generos = [],
}) {
this.nombre = nombre;
this.generos = generos;
this.integrantes = [];
}
agregarIntegrante(integranteNuevo) {
if (this.integrantes.some(element => element.instrumento.includes(‘Bateria’))) {
console.log(‘Bateria Repetida’);
} else {
this.integrantes.push(integranteNuevo)
}
}
}

//Crear clase Integrante
class Integrante {
constructor({
nombre,
instrumento,
}) {
this.nombre = nombre;
this.instrumento = instrumento;
}
}

export {
Banda,
Integrante,
}

Buenas! les comparto mi solución 😃

class Banda {
    constructor({
        nombre,
        generos = [],
    }) {
        this.nombre = nombre;
        this.generos = generos;
        this.integrantes = [];
    }
        agregarIntegrante(integranteNuevo) {
        const bateria = this.integrantes.filter(integrante => integrante.instrumento == 'Bateria'); 

        if (integranteNuevo.instrumento == 'Bateria' && bateria.length >= 1) {
        console.log("No pueden haber más de 1 baterista por banda.");
        return;
        }
        
        this.integrantes.push(integranteNuevo)
    }
}

//Crear clase Integrante

class Integrante {
    constructor({
        nombre,
        instrumento
    }) {
        	this.nombre = nombre;
       	  this.instrumento = instrumento;
    }
}

export {
  Banda,
  Integrante,
}

No puedo correr las pruebas, No responde

Dejo mi solución con FOR OF:

class Banda {
  constructor({
    nombre,
    generos = [],
  }) {
    this.nombre = nombre;
    this.generos = generos;
    this.integrantes = [];
  }
  agregarIntegrante(integranteNuevo) {
    let existe = false;
    for (let value of this.integrantes) {
      if (value.instrumento == 'Bateria') {
        existe = true;
        break;
      }
    }
    if (!existe) {
      this.integrantes.push(integranteNuevo);
    }
  }
}

//Crear clase Integrante
class Integrante {
  constructor({
    nombre,
    instrumento,
  }) {
    this.nombre = nombre;
    this.instrumento = instrumento;
  }
}


export {
  Banda,
  Integrante,
}

Comparto mi solución

class Banda {
  constructor({
    nombre,
    generos = [],
  }) {
    this.nombre = nombre;
    this.generos = generos;
    this.integrantes = [];
  }

  agregarIntegrante(integranteNuevo) {
    if (!this.integrantes.some(obj => obj.instrumento === "Bateria")) {
      this.integrantes.push(integranteNuevo);
    }
  }
}

//Crear clase Integrante
class Integrante {
  constructor({nombre, instrumento}) {
    this.nombre = nombre;
    this.instrumento = instrumento;
  }
}

☢️ Este fue mi resultado















class Banda {
    constructor({
      nombre,
      generos = [],
    }) {
      this.nombre = nombre;
      this.generos = generos;
      this.integrantes = [];
    }

    agregarIntegrante(integranteNuevo) {
        const { instrumento } = integranteNuevo
        const existIntrument = this.integrantes.some(({ instrumento }) => instrumento === "Bateria")
        if (instrumento === "Bateria" && existIntrument ) return

        this.integrantes.push( integranteNuevo )
    }
  }
  
  //Crear clase Integrante
  class Integrante {
    constructor({ nombre, instrumento }){
        this.nombre = nombre;
        this.instrumento = instrumento
    }
  }

Aporte ✍🏻

class Banda {
  constructor({ nombre, generos = [] }) {
    this.nombre = nombre;
    this.generos = generos;
    this.integrantes = [];
  }
  agregarIntegrante(integranteNuevo) {
    this.integrantes.find(
      (integrante) => integrante.instrumento === "Bateria"
    )
      ? console.log("El integrante ya existe")
      : this.integrantes.push(integranteNuevo);
  }
}

//Crear clase Integrante
class Integrante {
  constructor({ nombre, instrumento }) {
    this.nombre = nombre;
    this.instrumento = instrumento;
  }
}

export { Banda, Integrante };

class Banda {
  constructor({
    nombre,
    generos = [],
  }) {
    this.nombre = nombre;
    this.generos = generos;
    this.integrantes = [];
  }
  agregarIntegrante(integranteNuevo) {
    const CONTROL = "Bateria"
    if
    (
      integranteNuevo.instrumento == CONTROL
      &&
      this.integrantes.find
        (
          elemento =>
            elemento.instrumento == CONTROL
        )
    )
    {
      return; 
    }

    this.integrantes.push(integranteNuevo);
  }
}

//Crear clase Integrante
class Integrante {
  constructor({ nombre, instrumento })
  {
    this.nombre = nombre;
    this.instrumento = instrumento;
  }
}


export {
  Banda,
  Integrante,
}

Mi solucion.-
En el método ‘agregarIntegrante’, valido si en nuestro array ‘integrantes’ ya haya alguien que toque la bateria y que además se este ingresando a alguien con instrumento ‘bateria’, si los dos es verdad, no se admite a esa persona, pero si una o las dos son falsas, entonces se agrega a ese integrante a la banda, al array ‘integrantes’… 😃

El constructor de ‘Integrante’ tiene un objeto como parámetro, porque en el Output, recibe los argumentos entre llaves.

Verificaba la igualdad del valor de ‘bateria’ en el metodo agregrarIntegrante, supongo que se puede hacer un array para instrumentos que se van agregando elementos por cada integrante nuevo.
acá el codigo.

class Banda {
constructor({
nombre,
generos = [],
}) {
this.nombre = nombre;
this.generos = generos;
this.integrantes = [];
}
agregarIntegrante(integranteNuevo) {
if (this.integrantes.some(i => i.instrumento === ‘Bateria’)) {
console.log(“Este instrumento ya ha sido asignado a otro integrante”);
return;
}
this.integrantes.push(integranteNuevo);

}
}
//Crear clase Integrante
class Integrante {
constructor({ nombre, instrumento }) {
this.nombre = nombre;
this.instrumento = instrumento;
}
}

export {
Banda,
Integrante,
}

Comparto mi humilde código

class Banda {
    constructor({
      nombre,
      generos = [],
    }) {
      this.nombre = nombre;
      this.generos = generos;
      this.integrantes = [];
    };

    agregarIntegrante(integranteNuevo) {
        const exist = this.integrantes.filter(item => item.instrumento == 'Bateria').length > 0;
        if (exist) {
            console.log('Solo se puede registrar un baterista');
        } else {
            this.integrantes.push(integranteNuevo);
        }
    }
  }
  
  //Crear clase Integrante
  class Integrante {
    constructor({
      nombre,
      instrumento,
    }) {
      this.nombre = nombre;
      this.instrumento = instrumento;
    };
  }
  
  export {
    Banda,
    Integrante,
  }
undefined