Playgrounds: Manejo de clases

Clase 8 de 20 • Curso Básico de Programación Orientada a Objetos con JavaScript

Daniel Steven Cano Zapata

student•

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

Daniel Steven Cano Zapata

student•

De hecho, si miran la consola, me responde un 503

Erik Elyager

student•

Hola Daniel, parece que fue un error del momento en nuestros servidores. Vuelve a probar por favor yo copié y probé tú código, funciona 😉

Carlos Daniel Revetti Narvaez

student•

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

Rafael Neftalí Altamirano Guadarrama

student•

Si primero agregas al baterista, ya no se podría agregar al guitarrista.

Carlos Daniel Revetti Narvaez

student•

Manejo de Clases 2.0

En las bandas grupos y/o orquestas sinfónicas se distribuyen en el cual la percusión (Batería pertenece a la familia de la percusión) siempre estará posicionada de ultimo en general (ejecución, panfletos, etc), salvo la ocasión de que se presente como solistas algún percusionista o inclusive la fila entera. Pero basado en que sea este ultimo el caso agregamos else if (integranteNuevo.instrumento !== "Batería") para confirmar que no tocan en esta ocasión la batería.

Input

const data = {
  nombre: "Ensamble de Percusion Venezuela",
  generos: ["Clasico", "Afro-Caribeno", "Latino", "Llanero"],
  integrantes: [],
  }
    
  const banda = new Banda(data)
  banda.agregarIntegrante(new Integrante({ nombre: "Ricardo", instrumento: "Timpani" }))
  banda.agregarIntegrante(new Integrante({ nombre: "Denis", instrumento: "Xilofono" }))
  banda.agregarIntegrante(new Integrante({ nombre: "Maria", instrumento: "Vibraphone" }))
  banda.agregarIntegrante(new Integrante({ nombre: "Gilmer", instrumento: "Bateria" }))
  banda.agregarIntegrante(new Integrante({ nombre: "Jair", instrumento: "Maracas" }))
  banda.agregarIntegrante(new Integrante({ nombre: "Carlos", instrumento: "Bateria" })) // Yo xD
  banda.agregarIntegrante(new Integrante({ nombre: "Cesar", instrumento: "Xilofono" }))
  banda.agregarIntegrante(new Integrante({ nombre: "Victor", instrumento: "Marimba" }))
  banda.agregarIntegrante(new Integrante({ nombre: "Jose", instrumento: "Redolblante" })) // Invitado

Output

{
  nombre: 'Ensamble de Percusion Venezuela',
  generos: [ 'Clasico', 'Afro-Caribeno', 'Latino', 'Llanero' ],
  integrantes: [
    Integrante { nombre: 'Ricardo', instrumento: 'Timpani' },
    Integrante { nombre: 'Denis', instrumento: 'Xilofono' },
    Integrante { nombre: 'Maria', instrumento: 'Vibraphone' },
    Integrante { nombre: 'Gilmer', instrumento: 'Bateria' },
    Integrante { nombre: 'Jair', instrumento: 'Maracas' },
    Integrante { nombre: 'Cesar', instrumento: 'Xilofono' },
    Integrante { nombre: 'Victor', instrumento: 'Marimba' },
    Integrante { nombre: 'Jose', instrumento: 'Redolblante' }
  ]
}

Solucion:

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)
    } else if (integranteNuevo.instrumento !== "Bateria") {
      this.integrantes.push(integranteNuevo)
    }
  }
}

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

export {
  Banda,
  Integrante,
}

YouTube Ensamble de percusión Venezuela - Afta Stuba

JORGE ALEXANDER MÚNERA CANABAL

student•

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 :D

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

Erik Elyager

student•

Genial que compartan sus resultados! y sí claro no vengan a ver los comentarios si aún no lo resuelven 😄

Rafael Neftalí Altamirano Guadarrama

student•

Si desde el inicio agregas un baterista al momento de agregar un segundo integrante te manda el mensaje que ya existe un baterista, lo cual es cierto pero ya no permite agregar otro miembro.

Julio César Hernández Mendoza

student•

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

Natali Rivero

student•

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",
  })
);

John Pinto

student•

No esta correcto porque la validación del isBassplayer siempre va a dar falso, de ahí la importancia de seguir las instrucciones si la prueba se hace con

banda.agregarIntegrante(new Integrante({ nombre: "Paul", instrumento: "Bateria" }

jamas va a encontrar coincidencia con instrument:"Bateria"

Israel Blas

student•

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

Julián Andrés Guzmán Guzmán

student•

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

Sebastián Esteban López Moran

student•

Excelente aporte, tu bien lo dices, la mayoría no tuvo en cuenta que se puede agregar a otros integrantes con otro tipo de instrumentos.

Fredy Gutiérrez Vazquez

student•

Excelente aporte.

Jose Fabio Ortega Estrada

student•

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.

David Aliaga

student•

lo que sucede con tu código : const find = this.integrantes.find(integrante => integrante.instrumento === integranteNuevo.instrumento).

const juan = new Integrante('fABIO',"Bateria"); const erik = new Integrante("Erik","guitara");

En la primera comparación (juan) del método find integrante.instrumento(undefined) por que el arreglo esa vacío y integrantesNuevo.instrumento(te da el instrumento) en otras palabras la comparacion es undefined que tiende a false y este se agrega.En la segunda vez que agregas otro integrante(erik) paso algo similar por que ahora integrante.instrumento("bateria") y el integrantesNuevo.instrumento(guitarra) la comparacion es undefined y tambien agrega pero aqui lo que falla es que al colocar otro integrante que sea guitarrista o baterista no va agregar por que ya ambos estan en el arreglo, vas a poder seguir agregando otros instrumentos, pero ya no los repetidos y aqui el error.

David Aliaga

student•

<code>
class Banda {
  constructor({
    nombre,
    generos = [],
  }) {
    this.nombre = nombre;
    this.generos = generos;
    this.integrantes = [];
  }
  agregarIntegrante(integranteNuevo) {
    // Tu código aquí 👈
    const integrante = integranteNuevo.instrumento === "Bateria"
    if (integrante && this.integrantes.some(el => el.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,
}

Victor Ortiz

student•

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

Horus Sinhue Camacho Avila

student•

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

Cristian Andres Amaya Torrado

student•

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

Sebastián Rodolfo Hernández Rodríguez

student•

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

Daniel Cruz

student•

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

David Rangel

student•

Mi código (después de los gatitos antispoiler):

≽^-˕-^≼

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

Alic David Barandica Mejia

student•

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);

José Rodrigo Álvarez Herrera

student•

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.

Diego Felipe Salamanca Rojas

student•

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

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

Marlón Andrés Cuartas Aguirre

student•

Ricardo Alfonso Chavez Vilcapoma

student•

Pero...viendo tu code...creo que nunca entrará al else luego de que se agregue un solo integrante baterista, por lo que no podrás agregar más.

Jesús Emiliano Alonso López

student•

------------------------------------------------------------ . . 🛡️🛡️🛡️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,
}

Pariksit Erikrsnan Ortiz Flores

student•

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