Playgrounds: Controlar accesos con get y set

export class Course {
  constructor({
    name,
    classes = [],
  }) {
    this._name = ''; // Inicializa la propiedad privada _name como una cadena vacía
    this.name = name; // Llama al setter de name para validar y actualizar el valor de _name
    this.classes = classes; // Inicializa la propiedad classes con un valor opcional
  }

  get name() {
    return this._name; // Devuelve el valor actual de _name
  }

  set name(newName) {
    if (typeof newName === 'string') { // Comprueba si newName es un string válido
      newName = newName.trim(); // Elimina los espacios en blanco al inicio y al final del string
      if (newName !== '') { // Comprueba si el string resultante no es vacío
        this._name = newName
          .split(' ') // Divide el string en palabras usando un espacio como separador
          .map((word) => word.charAt(0).toUpperCase() + word.slice(1)) // Convierte la primera letra de cada palabra en mayúsculas
          .join(' '); // Vuelve a unir las palabras en un string usando un espacio como separador
      }
    }
    // Si newName no es un string válido o es un string vacío, no se modifica el valor de _name
  }
}

Mi solución, aunque en acá no corre, en Visual Studio Code sí me funcionó 😄

export class Course {
  constructor({
    name,
    classes = [],
  }) {
    this._name = name;
    this.classes = classes;
  }

  get name() {
    return this._name;
  }

  set name(nuevoNombrecito) {
    if (typeof nuevoNombrecito !== "string") {
      console.log("Parce no puedes hacer eso");
    } else {
      this._name = nuevoNombrecito[0].toUpperCase() + nuevoNombrecito.slice(1);
    }
  }
}

Casi no lo entiendo pero de a poco lo fui solucionando.

  constructor({
    name,
    classes = [],
  }) {
    this.name = name;
    this.classes = classes;
  }

  get name() {
    return this._name;
  }

  set name(nuevoNombrecito) {
    if (typeof nuevoNombrecito === "string") {
      nuevoNombrecito = nuevoNombrecito.trim()
      if (nuevoNombrecito.length !== 0) {
        let words = nuevoNombrecito.split(" ")
        let nuevoNombrecitoMayusculas = words.map((word) => {
          if (word.length > 0) return `${word[0].toUpperCase()}${word.slice(1)}`;
        }).join(" ")
        this._name = nuevoNombrecitoMayusculas
      }
    }
  }
}

Aunque fue un poco diferente a la solucion mi codigo lo realice de la siguiente manera

export class Course {
  constructor({
    name,
    classes = [],
  }) {
    this._name = name;
    this.classes = classes;
  }

  get name() {
    // Tu código aquí 👈
    return this._name;
  }

  set name(nuevoNombrecito) {
    // Tu código aquí 👈
    if (typeof nuevoNombrecito === "string") {
      const newName = nuevoNombrecito
      const palabras = newName.split(" ");

      const word = palabras.map((palabra) => {
        return palabra[0].toUpperCase() + palabra.substring(1);
      }).join(" ")
      // console.log(palabras);
      console.log(word);
      this._name = word;
    } else {
      console.error("no se puede cambiar el nombre")
    }
  }
}

const courseName = "curso de programación básica";
const nombreMaysuculas = new Course({
  name: courseName,
})
nombreMaysuculas.name = courseName;

He intentado muchas combinaciones diferentes y aunque en mi VSCode funciona y en la consola del explorador funciona, este playground continua diciendo que tiene fallas. Utilice el codigo de varios compañeros. Hice combinaciones con forEach, ciclos for, map y en todas las ocaciones sigue diciendo que el resultado es erroneo, a pesar que como mencione, en las consolas del explorador y en la de VSC funciona a la perfeccion.

this.name = name; vs this._name = name; 😱🤔

En el constructor al usar this._name = name; no se aplica el set a la primera instancia creada, solo se aplica a las siguientes, pero al usar this.name = name; si se aplica desde la primera instancia.

class Course {
    constructor({
        name,
        classes = [],
    }){
        this.name = name; //this._name = name; 👈👀
        this.classes = classes;
    }
}

La razón por la que la primera instancia de la clase Course creada no se beneficia de la validación en el método setter cuando se utiliza this._name = name; en el constructor, es porque el método setter solo se invoca cuando se establece el valor de la propiedad name después de la creación del objeto. En el constructor, se está estableciendo directamente el valor de la propiedad privada _name sin pasar por el método setter.

Por otro lado, cuando se utiliza this.name = name; en el constructor, se está llamando al método setter directamente, y, por lo tanto, se aplica la validación en el valor de name incluso en la primera instancia creada.

Por ejemplo, si se crea una instancia de la clase Course utilizando this._name = name; en el constructor:

const course_new = 'course one';
const course_one = new Course({ name: course_new });
console.log(course_one.name); // "course one"

En este caso, como se ha establecido directamente el valor de la propiedad privada _name en el constructor, la validación en el método setter no se ha aplicado, y, por lo tanto, el valor de name sigue siendo “course one”.

Por otro lado, si se crea una instancia de la clase Course utilizando this.name = name; en el constructor:

const course_new = 'course one';
const course_one = new Course({ name: course_new });
console.log(course_one.name); // "Course One"

En este caso, al utilizar this.name = name; en el constructor, se llama al método setter directamente y se aplica la validación en el valor de name, por lo que el valor de name se cambia a “Course One” (con la primera letra de cada palabra en mayúscula).

Es importante tener en cuenta que, aunque el método setter no se llama al establecer directamente el valor de la propiedad privada _name en el constructor, el método getter sí se puede utilizar para acceder al valor de la propiedad _name desde fuera de la clase.

Solución

Nota Importante: Yo lo he estaba probando siempre en la pestaña Vista y siempre me daba error RangeError: Maximum call stack size exceeded: y cuando abrí la consola hacia lo que debía hacer cuando usaba el console.log, ejecute las pruebas y funciono.

export class Course {
  constructor({ name, classes = [] }) {
    this.name = name;
    this.classes = classes;
  }

  get name() {
    // Tu código aquí 👈
    return this.name;
  }

  set name(nuevoNombrecito) {
    // Tu código aquí 👈
    if (typeof nuevoNombrecito === "string") {
      nuevoNombrecito = nuevoNombrecito.trim();
      if (nuevoNombrecito.length !== 0) {
        let words = [];
        nuevoNombrecito.split(" ").forEach(function (word) {
          words.push(word[0].toUpperCase() + word.substring(1));
        });
        this._name = words.join(" ");
      } else {
        console.log("Solo tiene permitido string");
      }
    }
  }
}

Para probar que funcionara bien debajo de este bloque de código agregue este para revisar en la consola

const courseName = "curso de programación básica 1";
const nombreMayusculas = new Course({
  name: courseName,
})
nombreMayusculas.name = "curso de programación básica 2";

Y agregue en la clase Course un

console.log(this._name)

después de la línea de código esta

this._name = words.join(" ");

A pesar de error antes comentado que me muestra en la consola si muestre bien el cambio por eso ejecute las pruebas.

Alerta spoiler, aqui va mi solucion:

class Course {
  constructor({ name, classes = [] }) {
    this._name = name
    this.classes = classes
  }

  get name() {
    return this._name
  }

  set name(nuevoNombrecito) {
    // tipo string
    if (typeof nuevoNombrecito !== "string") {
      console.error("debe ser string")
    } else this._name = nuevoNombrecito[0].toUpperCase() + nuevoNombrecito.slice(1)
  }
}

Hay algo extraño aquí. Este es mi código:

export class Course {
  constructor({
    name,
    classes = [],
  }) {
    this.name = name;
    this.classes = classes;
  }

  get name() {
    // Tu código aquí 👈
    return this._name;
  }

  set name(nuevoNombrecito) {
    // Tu código aquí 👈
    if (typeof nuevoNombrecito != 'string' || nuevoNombrecito == ' ') {
      console.log('Web ... no');
      return this._name;
    }

    let palabras = nuevoNombrecito.trim().split(' ');

    const newName = palabras.map(word => word[0].
      toUpperCase() + word.slice(1)).join(' ');

    this._name = newName;
  }
}

Pueden ver que en el constructor no use el guión bajo (_) para nombrar la variable
this.name, pero en el get y set pueden ver que use this._name, cosa que al correr la prueba salió todo en verde, mientras que si usaba en todo this.name no funcioba. THIS IS WEIRD!

Mi solución…este si corre en ambos lados en el vsc y acá…

 if (typeof nuevoNombrecito === 'string' && nuevoNombrecito.trim().length > 0) {
      const palabra = nuevoNombrecito.trim().split(' ');
      console.log(palabra);
      for (let i = 0; i < palabra.length; i++) {
        palabra[i] = palabra[i][0].toUpperCase() + palabra[i].substring(1);

      }
      console.log(palabra);
      // console.log(palabra.join(' '));
      this._name = palabra.join(' ');

    }

…

function cambioMayusculas(nuevoNombrecito){
    if (typeof(nuevoNombrecito)==="string" && nuevoNombrecito.length!==0){
    const cambio=nuevoNombrecito.split(' ');
    const cambio2=cambio.map(item =>item.charAt(0).toUpperCase()+item.slice(1));
    const cambio3=cambio2.join(' ');
    return cambio3;
}else{
    console.warn('el nuevo nombre no es un tipo de dato String ...')
}
}
class Course {
    constructor({name,classes = [],}) {
        this._name = cambioMayusculas(name);
        this.classes = classes;
        }
    
        get name() {
            return this._name;
        }
    
        set name(nuevoNombrecito) {
            if (typeof nuevoNombrecito==="string" && nuevoNombrecito.length!==0) {
                const cambio = nuevoNombrecito.trim();
                const cambio1=cambio.split(' ');
                const cambio2=cambio1.map(item =>item.charAt(0).toUpperCase()+item.slice(1));
                const cambio3=cambio2.join(' ');
                this._name=cambio3;
            }else{
                console.warn('el nuevo nombre no es un tipo de dato String ...')
            }
            
        }
    }

const curso1 = new Course({
    name: 'curso de programación básica',
    
})

console.log(curso1.name);

curso1.name="";
console.log(curso1.name.length);

Me pasa todos las pruebas menos esta:

Alguien sabe por que ?, segun yo ya esta mitigada la parte de string vacio. Agradezco la retroalimentacion. 😁

esta es la solución que dan desde el reto …

export class Course {
  constructor({
    name,
    classes = [],
  }) {
    this.name = name;
    this.classes = classes;
  }

  get name() {
    return this._name;
  }

  set name(nuevoNombrecito) {
    if (typeof nuevoNombrecito === "string") {
      nuevoNombrecito = nuevoNombrecito.trim()
      if (nuevoNombrecito.length !== 0) {
        let words = nuevoNombrecito.split(" ")
        let nuevoNombrecitoMayusculas = words.map((word) => {
          return word[0]?.toUpperCase() + word.substring(1);
        }).join(" ")
        this._name = nuevoNombrecitoMayusculas
      }
    }
  }
}

Mi solución

class Course {
  constructor({ name, classes = [] }) {
    this._name = name;
    this.classes = classes;
  }

  get name() {
    // Tu código aquí 👈
    return this._name;
  }

  set name(nuevoNombrecito) {
    // Tu código aquí 👈
    if (typeof nuevoNombrecito == "string") {
      const words = nuevoNombrecito.split(" ");

      for (let i = 0; i < words.length; i++) {
        words[i] = words[i][0].toUpperCase() + words[i].substring(1);
      }
      this._name = words.join(" ");
    }
  }
}

const courseName = "curso de programación básica";
const nombreMaysuculas = new Course({
  name: courseName,
});
nombreMaysuculas.name = courseName;
console.log(nombreMaysuculas.name);

export class Course {
  constructor({
    name,
    classes = [],
  }) {
    this.name = name;
    this.classes = classes;
  }

  get name() {
    // Tu código aquí 👈
    return this._name;
  }

  set name(nuevoNombrecito) {
    // Tu código aquí 👈
    if (typeof (nuevoNombrecito) !== 'string' || nuevoNombrecito == " ") {
      console.log("error");
    } else {
      const palabras = nuevoNombrecito.trim().split(" ");
      const covertedName = palabras.map(
        palabra => {
          return palabra[0].toUpperCase() + palabra.substring(1);
        }
      ).join(" ");
      this._name = covertedName;
    }
  }
}

esta es mi solucion, corre en VSCode pero aca no, ahi se las dejo.

export class Course {
  constructor({
    name,
    classes = [],
  }) {
    this._name = name;
    this.classes = classes;
  }

  get name() {
    return this._name
  }

  set name(nuevoNombrecito) {
    // Tu código aquí 👈
    if (nuevoNombrecito === "string") {
      this._name = nuevoNombrecito.split(' ').map(x => x.charAt(0).toUpperCase() + x.slice(1)).join(' ')
    } else {
      console.log('error de curso')
    }
  }
}

Mi solucion con array methods:

  get name() {
    return this._name
  }

  set name(nuevoNombrecito) {
    if (typeof nuevoNombrecito === "string") {
      const nombrecitoTemp = nuevoNombrecito.split('')
      const capLetter = nombrecitoTemp.shift().toUpperCase()
      nombrecitoTemp.unshift(capLetter)
      this._name = nombrecitoTemp.join('')
    }
    else{
      console.log("you can't do that");
    }
    
  }

Pues no se, pero a mi me funciona en VS y en el inspector asi:

class Course {
  constructor({ name, classes = [] }) {
    this._name = name;
    this.classes = classes;
  }

  get name() {
    return this._name;
  }

  set name(nuevoNombrecito) {
    if (typeof nuevoNombrecito === "string") {
      this._name = nuevoNombrecito.charAt(0).toUpperCase() + nuevoNombrecito.slice(1);
    } else {
      this._name = nuevoNombrecito;
    }
  }
}

const courseName = "curso de programación básica";
const nombreMaysuculas = new Course({
  name: courseName,
});
nombreMaysuculas.name = courseName;

mmmm done!

export class Course {
  constructor({
    name,
    classes = [],
  }) {
    this.name = validation(name);
    this.classes = classes;
  }

  get name() {
    return this.name;
  }

  set name(nuevoNombrecito) {
    this.name = validation(nuevoNombrecito);
  }

  validation(nuevoNombrecito) {
    if (typeof nuevoNombrecito === 'string') {
      const title = nuevoNombrecito.split(" ");
      return title.map((word) => {
        return word[0].toUpperCase() + word.substring(1);
      }).join(" ");
    } else {
      return this.name;
    }
  }
}

Me encanta que los retos nos lleven a indagar y mejorar!!
Les dejo mi código:

<export class Course {
  constructor({
    name,
    classes = [],
  }) {
    this.name = name;
    this.classes = classes;
  }

  get name() {
    return this._name;
  }

  set name(nuevoNombrecito) {
    if (typeof nuevoNombrecito !== "string" || nuevoNombrecito == " ") {
      console.log("No se puede cambiar el nombre")
    } else {
      const split = nuevoNombrecito.trim().split(" ");
      const newName = split.map((p) => { return p[0].toUpperCase() + p.substring(1); }).join(" ");
      this._name = newName;
    }
  }
}> 

Hola y bienvenidos a los que vengas por el reto de 30 días de JS.

CONSEJOS:

Revisen bien la pestaña de “Pruebas” cuando ejecutan el código, lean bien los errores, ya que se corren un par de test que no están en el enunciado de la “Guía”.

Otra recomendación es no cambien la línea 6 del código.

this.name = name;

Si la cambian por:

this._name = name;

No se ejecuta el setter al instanciar el objeto, por ende no cambiará a mayúsculas con el parámetro instanciado, solo cuando quieran cambiar el valor de “name” una vez creado el objeto.

Les recomiendo que hagan ese ejercicio en su editor.

Ejecuten con _name y con el name y vean la diferencia al crear el objeto, allí entenderán porque el código no les pasa el test.

No me funciono en el playground creo que no pidieron modificar el set name y no el constructor a la hora de cambiar la frase pero lo corri en VSCode y me funciono 🤷

export class Course {
  constructor({ name, classes = [] }) {
    this._name = name;
    this._classes = classes;
  }

  get name() {
    return this._name;
  }

  set name(nuevoNombrecito) {
    if (typeof (nuevoNombrecito) === "string") {
      this._name = changeCapitalizedWord(nuevoNombrecito);
    }
  }
}

function changeCapitalizedWord(str) {
  const words = str.split(" ");

  for (let index = 0; index < words.length; index++) {
    words[index] = words[index].charAt(0).toUpperCase() + words[index].slice(1);
  }

  return words.join(" ");

}

Hice esto, casi no me da:

export class Course {
  constructor({
    name,
    classes = [],
  }) {
    this.name = name;
    this.classes = classes;
  }

  get name() {
    return this._name;
  }

  set name(name) {
    if (typeof name === "string") {
     name = name.trim()
      if (name.length > 0) {
        let words = name.split(" ")
        let text = words.map(word => word[0]?.toUpperCase() + word.substring(1)).join(" ")
        this._name = text
      }
    }
  }
}

Holaa, esta es mi solucion:

set name(nuevoNombrecito) {
    // Tu código aquí 👈
    if (typeof nuevoNombrecito === "string") {
      const array = nuevoNombrecito.split('')
      console.log(array)

      for (let i = 0; i < array.length; i++) {
        let letter = array[i]
        if (i == 0) {
          console.log(letter.toUpperCase())

        } else if (array[i] == ' ') {
          let number = i + 1
          let newLetter = array[number]
          let letterXToMayus = newLetter.toUpperCase()
          console.log(letterXToMayus)
        }
      }
    } else { 
      return false;
    }
  }
}

Aquí dejo mi solución

class Course {
  constructor ({ name, classes = [] }) {
    this.name = name
    this.classes = classes
  }

  get name () {
    return this._name
  }

  set name (nuevoNombrecito) {
    if (typeof nuevoNombrecito === 'string') {
      let nuevoNombrecitoTrimed = nuevoNombrecito.trim()
      if (nuevoNombrecitoTrimed.length !== 0) {
        let words = nuevoNombrecitoTrimed.split(' ')
        let newSentence
        let box = []
        for (let index = 0; index < words.length; index++) {
          newSentence =
            words[index][0].toLocaleUpperCase() + words[index].substring(1)
          box.push(newSentence)
        }
        this._name = box.join(' ')
      }
    } else {
      this._name
    }
  }
}

Mi Solucion 😎

export class Course {
  constructor({
    name,
    classes = [],
  }) {
    this._name = this.capitalize(name);
    this.classes = classes;
  }

  capitalize(name) {
    return name.split(' ').map(palabra => palabra.replace(palabra.charAt(0), palabra.charAt(0).toUpperCase())).join(' ').trim()
  }

  get name() {
    // Tu código aquí 👈
    return this._name;
  }

  set name(nuevoNombrecito) {
    // Tu código aquí 👈
    if (typeof nuevoNombrecito !== "string") { console.error("debe ser string"); return };

    if (nuevoNombrecito === " ") { return nuevoNombrecito }

    this._name = this.capitalize(nuevoNombrecito);
  }
}

Esta es mi solución
⬇⬇⬇

export class Course {
  constructor({
    name,
    classes = [],
  }) {
    this.name = name;
    this.classes = classes;
  }

  get name() {
    return this.name
  }

  set name(nuevoNombrecito) {
    if (typeof nuevoNombrecito === "string") {
      nuevoNombrecito.split(" ").map(i => i.charAt(0).toUpperCase() + i.slice(1)).join(" ")
    } else { }
  }
}

Buenas!! Recomiendo que tomen el curso de manipulación de arrays, les ayudará con este ejercicio.

export class Course {
  constructor({
    name,
    classes = [],
  }) {
    this.name = name;
    this.classes = classes;
  }

  get name() {
    // Tu código aquí 👈
    return this.name
  }

  set name(nuevoNombrecito) {
    // Tu código aquí 👈
    if (typeof nuevoNombrecito === "string") {
      nuevoNombrecito.split(" ").map(i => i.charAt(0).toUpperCase() + i.slice(1)).join(" ")
    } else { }
  }
}

despues de tanto intentar e intentar y ver que me salia errores en la playground decidi hacerlo en vscode y ahi si funciono, mi codigo es el siguiente por si a alguien le sirve …

class Course {
    constructor({
      name,
      classes = [],
    }) {
      this.name = name;
      this.classes = classes;
    }
  
    get names() {
      return this.name
    }
  
    set names(nuevoNombrecito) {
      if (typeof(nuevoNombrecito) == 'string') {
        const array = nuevoNombrecito.split(" ");
        const array2 = array.map(element => (element[0]).toUpperCase() + element.slice(1));
        const cadena = array2.reduce((a, b) => a + ' ' + b);
        this.name=cadena;
    } else {
        console.log('debes ingresar un texto');
      }
    }
  }

  const nuevoCurso = new Course({name:'desarrollo web'});
  nuevoCurso.names = 'programacion orientado a objetos en javascript';
  console.log(nuevoCurso);
  

export class Course {
  constructor({
    name,
    classes = [],
  }) {
    this._name = name;
    this.classes = classes;
  }

  get name() {
    // Tu código aquí 👈
    return this._name
  }

  set name(nuevoNombrecito) {
    if (typeof nuevoNombrecito !== 'string') return;
    // Tu código aquí 👈

      this._name = nuevoNombrecito.charAt(0).toLocaleUpperCase() + nuevoNombrecito.slice(1);
  }
}

Mi código quedó un poco largo

class Course {
    constructor({
      courseName,
      classes = [],
    }) {
      this.courseName = courseName;
      this.classes = classes;
    }
  
    get name() {
      return this.courseName;
    }
  
    set name(nuevoNombrecito) {

      if(typeof(nuevoNombrecito) === 'string') {
        let parts = nuevoNombrecito.split(' ')
        let newValue = []
        
        parts.forEach((e) => {
            let eachLetter = e.split('')
            eachLetter[0] = eachLetter[0].toUpperCase()
            newValue.push(eachLetter.join(''))
        })
        

        this.courseName = newValue.join(' ')


      } else {
        console.error('Are you crazy?')
      }
    }
  }
  
const courseName1 = "curso de programación básica"
const nombreMayusculas = new Course({
    courseName: courseName1,
})

/* console.log(nombreMayusculas.name) */
console.log(nombreMayusculas.name);

Tenia la validación como:

const validador =  typeof(nuevoNombrecito) === 'string' && !!nuevoNombrecito.length

pero no me la aceptaba hasta que hice esta:

const validador = typeof (nuevoNombrecito) === 'string' && nuevoNombrecito.length > 1 && nuevoNombrecito !== undefined

Y así quedó:

export class Course {
  constructor({
    name,
    classes = [],
  }) {
    this.name = name;
    this.classes = classes;
  }

  get name() {
    // Tu código aquí 👈
    return this._name;
  }

  set name(nuevoNombrecito) {
    const validador = typeof (nuevoNombrecito) === 'string' && nuevoNombrecito.length > 1 && nuevoNombrecito !== undefined


    if (validador) {
      console.log('entre')
      const nuevoNombre = nuevoNombrecito.trim().split(' ')
        .map(p => p = p[0].toUpperCase() + p.substring(1))
        .join(' ');
      this._name = nuevoNombre
    }
  }
}

Mi solución…
No puedes pasarle solo numeros como nombre al constructor.

class Course {
  _name=undefined;
  constructor({
    name,
    classes = [],
  }) {
    this.name = name;
    this.classes = classes;
  }

  get name() {
    return this._name;
  }

  set name(nuevoNombrecito) {
    let newName;
    if(typeof nuevoNombrecito === "string" && nuevoNombrecito.length > 1){
      newName = nuevoNombrecito.split(" ")
      .map(word => word.charAt(0).toUpperCase() + word.slice(1))
      .join(" ");
      console.log(newName)
      this._name = newName.trimStart().trimEnd();
    } else {
      console.warn("Solo puedes usar texto para nombrar un Curso")
    }
    
  }
}

const courseName = "curso de programación básica"
const nombreMayusculas = new Course({
    name: 100,
})
nombreMayusculas.name = courseName

Esta es un posible solución:

class Course {
    constructor({
      name,
      classes = [],
    }) {
      this._name = name;
      this.classes = classes;
    }
  
    get name() {
      return this._name
    }
  
    set name(nuevoNombrecito) {
     
      if (typeof nuevoNombrecito !== "string") {
        console.error("You are making a mistake");
      } else {
        const withoutSpace = nuevoNombrecito.trim();
        const Mayuscula = withoutSpace[0].toUpperCase() + withoutSpace.slice(1);
        this._name = Mayuscula;
      }
    }
  }
  
const newCourse = new Course({
  name: "curso de programación basica",
}) 

newCourse.name = "     Curso avanzado de programación basica       "
console.log(newCourse);
<code> 

function capitalizeWords(newCourse){
  // Almacena el nuevo nombre del curso con las primeras letras en mayúscula.
  let newName = "";

  // Recorre cada caracter del curso.
  for(let i=0; i<newCourse.length; i++){
    // Concatena la primera letra de cada palabra en mayúscula si es el primer caracter o si el caracter está después de un espacio.
    if((i===0) || (newCourse[i-1] === " ")){
      newName += newCourse[i].toUpperCase();
    }else {
      // Concatena los caracteres sin modificar despúes de cada letras en mayúsculas.
      newName += newCourse[i];
    }
  }

  return newName;
}

export class Course{
  constructor({
    name,
  }) {
    this._name = name;
  }

  get name(){
    // Llama a la función capitalizeWords para obtener el nombre con las primeras letras en mayúsculas.
    return capitalizeWords(this._name);
  }

  set name(newCourse){
    // Si el nuevo nombre es una cadena, Convierte las primeras letras a mayúsculas y actualiza el valor de this._name.
    if(typeof newCourse === 'string'){
      this._name = capitalizeWords(newCourse);
    }
  }
}

export class Course {
  constructor({
    name,
    classes = [],
  }) {
    this._name = ''
    this.name = name;
    this.classes = classes;
  }

  get name() {
    return this._name;
  }

  set name(nuevoNombrecito) {
    if (typeof nuevoNombrecito === 'string') {
      nuevoNombrecito = nuevoNombrecito.trim();
      if (nuevoNombrecito) {
        const palabras = nuevoNombrecito.split(" ");
        const letrasPalabras = palabras.map((palabra) => palabra.split(""))
        letrasPalabras.map((letra) => letra.splice(0, 1, letra[0].toUpperCase()))
        const palabraMayuscula = letrasPalabras.map((letra) => letra.join("")).join(" ");
        this._name = palabraMayuscula;
      }
    }
  }
}

Solución

Primer archivo

// Nombres de tipo string
// Primera letra de cada palabra en Mayúscula
// Solo acepta strings

class Course {
  constructor({ name, classes = [] }) {
    this._name = name;
    this.classes = classes;
  }

  get name() {
    return this._name;
  }

  set name(new_name) {
    if (typeof new_name === "string") {
      const format = new_name
        .trim()
        .split(" ")
        .map(word => {
          return (
            word.charAt(0).toUpperCase() +
            word.slice(1)
          );
        });

      this._name = format.join(" ");
    } else {
      console.log("This isn't a string.");
    }
  }
}

export { Course };

Segundo archivo

import { Course } from "./14.playgrounds-get-set.mjs";

const course_one = new Course({
  name: "Course One",
  classes: [
    "Class one",
    "Class two",
    "Class three",
  ],
});

// course_one.name = 123;
course_one.name = " secret course ";

// console.log(course_one.name);
console.log(course_one._name);

Resultado en Consola:

set name(nuevoNombrecito) {
  // Verifica si el nuevo valor es de tipo string
  if (typeof nuevoNombrecito === "string") {
    // Elimina espacios en blanco al principio y al final del string
    nuevoNombrecito = nuevoNombrecito.trim();

    // Verifica que el string no esté vacío después de quitar los espacios en blanco
    if (nuevoNombrecito.length !== 0) {
      // Divide el string en palabras utilizando el espacio como separador
      let words = nuevoNombrecito.split(" ");

      // Convierte la primera letra de cada palabra a mayúscula
      let nuevoNombrecitoMayusculas = words.map((word) => {
        return word[0]?.toUpperCase() + word.substring(1);
      }).join(" ");

      // Asigna el nuevo valor a la propiedad _name
      this._name = nuevoNombrecitoMayusculas;
    }
  }
}

Me pregunto el por qué no pasara este código 🤔

class Course {
  constructor({ name, classes = [] }) {
    this._name = name;
    this.classes = classes;
  }

  get name() {
    return this._name;
  }

  set name(nuevoNombrecito) {
    if (typeof nuevoNombrecito === "string") {
      const removeSpaces = nuevoNombrecito.trim();

      if (removeSpaces.length >= 2) {
        const wordsArray = removeSpaces.split(" ");

        const result = wordsArray.map((word) => {
          console.log(word.length);
          if (word.length >= 2) {
            const firstLetter = word[0].toUpperCase();
            const restOfWord = word.slice(1).toLowerCase();
            const resultWord = firstLetter + restOfWord;
            return resultWord;
          } else {
            return word;
          }
        });

        const joiningWords = result.join(" ");
        this._name = joiningWords;
      }
    }
  }
}

class Course {
constructor({
name,
classes = [],
}) {
this._name = name;
this.classes = classes;
}

get name() {
  // Tu código aquí 👈
  return this._name
}

set name(nuevoNombrecito) {
  // Tu código aquí 👈
  if (typeof nuevoNombrecito === 'string'){
    let palabras = nuevoNombrecito.split(' ')
    for (let i = 0; i < palabras.length; i++) {
        palabras[i] = palabras[i].charAt(0).toUpperCase() + palabras[i].slice(1)
    }
    let unionPalabras = palabras.join(' ');
    this._name = unionPalabras
    console.log(this._name);
  }else{
    console.log('no es un string');
  }
}

}

No entendi muy bien el playgrounds pero esto fue lo que hice

const courseName = "curso de programación básica"
const nombreMaysuculas = new Course({
    name: courseName,
})
nombreMayusculas.name```

Solucionado. Hay que tomar en cuenta que hay que especificar que no debe tener espacios delante ni atrás de la cadena de texto y que si tiene longitud 0 no hacer cambios.

class Course {
  constructor({
    name,
    classes = [],
  }) {
    this.name = name;
    this.classes = classes;
  }

  get name() {
    // Tu código aquí 👈
    return this._name
  }

  set name(nuevoNombrecito) {
    // Tu código aquí 👈
    function PascalCase(texto) {
      let array = texto.split(" ")
      const totalArray = []
      let totalText = ""
      for (let word of array) {
        totalArray.push(word[0].toUpperCase() + word.slice(1))
      }
      for (let i = 0; i < totalArray.length; i++) {
        totalText += totalArray[i] + " "
      }
      totalText = totalText.substring(0, totalText.length - 1)
      return totalText
    }

    if (typeof nuevoNombrecito === "string") {
      nuevoNombrecito = nuevoNombrecito.trim()
      if (nuevoNombrecito.length !== 0) {
        this._name = PascalCase(nuevoNombrecito)
        return this._name
      }
    } else {
      return this._name
    }
  }
}

Aquí mi solución, algo oldschool, no paso las pruebas a pesar de que en la vista el resultado pareciera ser correcto.

Bueno espero les sea de ayuda, y si alguien nota cual es mi error les agradeceré.

Saludos.

export class Course {
  constructor({
    name,
    classes = [],
  }) {
    this.name = name;
    this.classes = classes;
  }

  get name() {
    return this._name;
  }

  set name(nuevoNombrecito) {
    if (typeof nuevoNombrecito !== "string") {
      console.log("Must be just letters")
    } else {
      let nombre = nuevoNombrecito.split(" ");
      for (let i = 0; i < nombre.length; i++) {
        nombre[i] = nombre[i][0].toUpperCase() + nombre[i].substr(1);
      }
      this._name = nombre.join(" ");
    }
  }
}

Mi solucion por medio de expresiones regulares:

set name(nuevoNombrecito) {
    // Tu código aquí 👈
    if (typeof (nuevoNombrecito) === 'string') {
      nuevoNombrecito.replace(/(^\w{1})|(\s+\w{1})/g, letra => letra.toUpperCase())
    } else {
      console.error("Web... no");
    }
  }

Como a muchos me corre en el navegador y no corre aqui, pero lo que si es que si convierte segun lo solicitado

Aquí os dejo mi solución por si os sirve de algo.
Pasó los tests

function uppercaseFirstWord(nuevoNombrecito) {
  const array = nuevoNombrecito.split(" ");

  const newArray = array.map(
    (word) => word.charAt(0).toUpperCase() + word.slice(1)
  );
  return newArray.join(" ");
}

class Course {
  constructor({ name, classes = [] }) {
    this._name = name;
    this.classes = classes;
  }

  get name() {
    return this._name;
  }

  set name(nuevoNombrecito) {
    if (nuevoNombrecito === " ") {
      return;
    }
    typeof nuevoNombrecito === "string"
      ? (this._name = uppercaseFirstWord(nuevoNombrecito).trim())
      : console.log("The name should be a string");
  }
}

const courseName = "curso de programación básica";
const nombreMaysuculas = new Course({
  name: courseName,
});

Mi solución la cual corrió aquí fue:
mientras probaba en Visual Code me di cuenta que al poner la variable del constructor oculta me quedaba en un bucle infinito por eso deje la variable oculta solo dentro de los métodos get y set.

export class Course {
  constructor({
    name,
    classes = [],
  }) {
    this.name = name;
    this.classes = classes;
  };

  get name() {
    return this._name;
  }

  set name(nuevoNombrecito) {
    if (typeof nuevoNombrecito === 'string') {
      if (nuevoNombrecito.trim() != '') {
        this._name = nuevoNombrecito.trim().split(' ').map(nombre => nombre[0].toUpperCase() + nombre.substring(1,nombre.length)).join(' ');
      } 
    }
  }
}

Probando me di cuenta que la prueba pasa con _name y que también incluye la validación en la inicialización de la clase, así que la añadí también en constructor:

export class Course {
  constructor({
    name,
    classes = [],
  }) {
    if (typeof name == "string") {
      name = name.trim();
      if (name.length > 0) {
        this._name = name.split(" ").map(str => str.charAt(0).toUpperCase() + str.slice(1)).join(" ");
      }
    }
    this.classes = classes;
  }

  get name() {
    return this._name;
  }

  set name(nuevoNombrecito) {
    if (typeof nuevoNombrecito == "string") {
      nuevoNombrecito = nuevoNombrecito.trim();
      if (nuevoNombrecito.length > 0) {
      this._name = nuevoNombrecito.split(" ").map(str => str.charAt(0).toUpperCase() + str.slice(1)).join(" ");
      }
    }
  }
}

Recién ahí sí pasa, creo que deberían especificar eso en la guía.

Mi solución aunque no corre en la consola delplaygroud, si lo prueban en la consola del navegador o vscode seguro que va a servir

class Course {
  constructor({
    name,
    classes = [],
  }) {
    this._name = name;
    this.classes = classes;
  }

  get name() {
    return this._name;
  }

  set name(nuevoNombrecito) {
    if (typeof nuevoNombrecito === 'string') {

      this._name = nuevoNombrecito.toLowerCase()
        .trim()
        .split(' ')
        .map(v => v[0].toUpperCase() + v.substr(1))
        .join(' ');

    }
  }
}

Esta es mi solución pero no corre.

export class Course {
    constructor({
      name,
      classes = [],
    }) {
      this._name = name;
      this.classes = classes;
    }
  
    get name() {
      // Tu código aquí 👈
      if (!this.isString(this._name)) console.error("Formato de valor invalido");
      return this.formatCapitalize(this._name);
  
    }
  
    set name(nuevoNombrecito) {
      // Tu código aquí 👈
      if (!this.isString(this._name)) console.error("Formato de valor invalido");
      return this.formatCapitalize(nuevoNombrecito);
    }
  
    isString(value) {
      return typeof value == "String";
    }
  
    formatCapitalize(text) {
      const textSplit = text.split(' ');

      let textFormat = "";
      for (let index = 0; index < textSplit.length; index++) {
        const element = textSplit[index];
        textFormat += `${element.substring(0, 1).toUpperCase()}${element.substring(1)} `;
      }
      
      console.log(textFormat);
      return textFormat;
    }
  }

const courseName = "curso de programación básica"
const nombreMaysuculas = new Course({
    name: courseName,
})
console.log(nombreMaysuculas.name)

Esta fue mii solución, el editor de código de Platzi no me funcionó esta vez:

class Course {
  constructor({
    name,
    classes = [],
  }) {
    this._name = name;
    this.classes = classes;
  }

  get name() {
    // Tu código aquí 👈
  }

  set name(nuevoNombrecito) {
    const verify = typeof (nuevoNombrecito)

    if (verify == 'string') {
      let words = nuevoNombrecito.split(' ')
      let letter = words.map(item => item[0].toUpperCase() + item.slice(1)).join(' ')
      this._name = letter
    } else {
      console.log('The parameter must be a string');
    }
  }
}

const res = new Course({ name: 'alic mejia' })
res.name = 'alic david'
console.log(res);

Adjunto mi solución después de unos cuantos intentos fallidos jejeje. Quedo abierto a cualquier recomendación ^^

export class Course {
  constructor({
    name,
    classes = [],
  }) {
    this.name = name;
    this.classes = classes;
  }

  get name() {
    return this._name;
  }

  set name(nuevoNombrecito) {
    if (typeof nuevoNombrecito === "string" && nuevoNombrecito !== ' ') {
      nuevoNombrecito = nuevoNombrecito.trim()
      let slicedName = nuevoNombrecito.split(' ');
      nuevoNombrecito = ''
      slicedName.forEach((word) => {
        nuevoNombrecito += (' ' + this.capitalize(word));
      })
      this._name = nuevoNombrecito.slice(1);
    }
  }

  capitalize(word) {
    return word.charAt(0).toUpperCase() + word.slice(1);
  }
}

El método capitalize hace mayúscula la primera letra de cada palabra, estas son concatenadas cómo ka nueva respuesta a través de un for.

Solution

class Course{
    constructor({
        name,
        classes = []
    }){
        this.name = name; //this._name = name;👈👀
        this.classes = classes;
    }

    get name(){
        return this._name;
    }
    set name(new_name){
        if(typeof new_name === 'string'){
            const capital_letters = new_name.split(' ').map(word => word.charAt(0).toUpperCase() + word.slice(1)).join(' ');
            this._name = capital_letters;
        }else{
            console.warn(`${new_name} isn't a string!!`);
        }
    }
}

const course_new = 'course one';
const course_one = new Course({ name: course_new });

course_one.name = 'eccentric course on computer psychology...';
course_one.name

/* 
'eccentric course on computer psychology...'
1. .split(' ') Separamos la oración en un array de palabras
    ['eccentric', 'course', 'on', 'computer', 'psychology...']
2. .map(word => word) Recorremos el array de palabras 
    ['eccentric', 'course', 'on', 'computer', 'psychology...']
3. .charAt(0) Extraemos el primer caracter de cada palabra
    ['e', 'c', 'o', 'c', 'p']
4. .toUpperCase() Convertimos cada caracter en mayúscula
    ['E', 'C', 'O', 'C', 'P']
5. + .slice(1) Extraemos todas las letras de cada palabra a partir del index 1 en adelante, excepto la letra de la posición 0 y las concatenamos con lo anterior la letra mayuscula obtenida con el método anterior. 
    ['Eccentric', 'Course', 'On', 'Computer', 'Psychology...']
6. .join(' ') Unimos el contenido del array usando como separador un espacio
    'Eccentric Course On Computer Psychology...'
*/

Mi solución al reto:

export class Course {
  constructor({
    name,
    classes = [],
  }) {
    this.name = name;
    this.classes = classes;
  }

  get name() {
    return this._name;
  }

  set name(nuevoNombrecito) {
    if (typeof nuevoNombrecito === "string") {

      let words = nuevoNombrecito.split(" ");

      for (let i = 0; i < words.length; i++) {
        let word = words[i];

        let firstLetter = word.charAt(0).toUpperCase();

        let capitalizedWord = firstLetter + word.slice(1);

        words[i] = capitalizedWord;

      }

      let capitalizedSentence = words.join(" ");
      let capitalizedSentenceTrim = capitalizedSentence.trim()
      this._name = capitalizedSentenceTrim;
    } else {
      this._name = nuevoNombrecito
    }

  }
}

const courseName = "curso de programación básica"
const nombreMaysuculas = new Course({
    name: courseName,
})
nombreMayusculas.name

class Course {
  constructor({ name, classes = [] }) {
    this.name = name;
    this.classes = classes;
  }

  get name() {
    return this._name;
  }

  set name(nuevoNombrecito) {
    if (typeof nuevoNombrecito === "string") {
      let nameCapitalized = nuevoNombrecito.split(" ");

      for (let i = 0; i < nameCapitalized.length; i++) {
        nameCapitalized[i] =
          nameCapitalized[i][0].toUpperCase() + nameCapitalized[i].substr(1);
      }

      this._name = nameCapitalized.join(" ");
    } else {
      console.log("Tu nombre debe ser una cadena de texto");
    }
  }
}

const cursoProBasicaName = "curso gratis de programación básica";
const cursoProgBasica = new Course({
  name: cursoProBasicaName,
});

Solución… 😄
.
.
.
.

.
.

export class Course {
  constructor({
    name,
    classes = [],
  }) {
    this.name = name;
    this.classes = classes;
  }

  get name() {
    return this._name;
  }

  set name(nuevoNombrecito) {
    if (typeof nuevoNombrecito === "string") {
      nuevoNombrecito = nuevoNombrecito.trim();
      if (nuevoNombrecito.length !== 0) {
        this._name = nuevoNombrecito
          .split(" ").map(word =>
            word[0]?.toUpperCase() + word.slice(1)
          )
          .join(" ");
      }
    }
  }
}

Deberían ser más especificos en los playground…bueno es la primera vez que me pasa que no corre de ninguna forma el playground pero. ai lgual que los compañeros, en consola y vsCode si corre con normalidad.

Dejo mi solución:

class Course {
    constructor({
        name,
        classes = [],
    }) {
        this.name = name;
        this.classes = classes;
    }

    get Name() {
        return this.name;
    }

    set Name(nuevoNombrecito) {
        let nuevoNombrecitoCapitalize;
        if(typeof(nuevoNombrecito) === "string"){
            let arrayNombrecito = nuevoNombrecito.split(" ");
            for (let i = 0; i < arrayNombrecito.length; i++) {
                arrayNombrecito[i] = arrayNombrecito[i].charAt(0).toUpperCase() + arrayNombrecito[i].slice(1);
            }
            nuevoNombrecitoCapitalize = arrayNombrecito.join(" ");
        }
        this.name = nuevoNombrecitoCapitalize;
    }
}

const courseName = "curso de programación básica";
const nombreMayusculas = new Course({
    name: courseName,
})

console.log(nombreMayusculas.Name);
nombreMayusculas.Name = "curso de programación básica";
console.log(nombreMayusculas.Name);

Ahí va mi solución y como creo que debería ejecutarse el programa (Input y Output). Saludos y espero lo arreglen.
|
|
| Pantalla anti spoiler.
|
|
|
|
|
|
|
|
|
|
|
|
|
|

export class Course {
  constructor({
    classes = [],
  }) {
    this._name;
    this.classes = classes;
  }

  get name() {
    return this._name;
  }

  set name(nuevoNombrecito) {
    if (typeof nuevoNombrecito === 'string') {
    const newArr =  [...nuevoNombrecito].map((e,i,ar)=>{
        if(i==0)
            return e.toUpperCase();
        if(ar[i - 1] === ' ')
            return e.toUpperCase();
        else    
            return e;        
    });
        this._name = newArr.join('');
    }
    else
      this._name = nuevoNombrecito;
  }
}

//Input
const courseName = "curso de programación básica";
const nombreMayusculas = new Course({
});
nombreMayusculas.name = courseName;

console.log(nombreMayusculas.name);


// Output

// 'Curso de Programación Básica'

Además en la ejecución se crea la instancia nombreMaysuculas con la porpiedad name lo cual no tiene sentido si ya se tiene un método set para ello.

Hay un error de typo en la ejecución del programa aqui

const courseName = "curso de programación básica"
const nombreMaysuculas = new Course({
    name: courseName,
})
nombreMayusculas.name

nombreMaysuculas y nombreMayusculas son diferentes Platzi por favor corregir.

Mi bello código, hecho por google, la comunidad de Platzi y yo… (Pasa prueba) 😃

  constructor({
    name,
    classes = [],
  }) {
    this._name = this.validate(name);
    this.classes = classes;
  }

  get name() {
    // Tu código aquí 👈
    return this._name;
  }

  set name(nuevoNombrecito) {
    // Tu código aquí 👈
    this._name = this.validate(nuevoNombrecito);

  }
  firstUpper(arrString) {
    let length = arrString.length;
    let mapString = arrString.map((item) => item.charAt().toUpperCase() + item.slice(1));
    return mapString.join(" ");
  }
  validate(nuevoNombrecito) {
    if (typeof nuevoNombrecito === "string" && nuevoNombrecito!==" ") {
      let split = nuevoNombrecito.split(" ");
      let strFirst = this.firstUpper(split);
      return strFirst.trim();
    } else {
      return this._name;
    }
  }
}
<code> 

Encontré varias cosas que creo que deberían mejorar:

• Hay que usar _name y creo que no se explicó la razón en clases anteriores. Entiendo que parte de la formación es autónoma, sin embargo considero que haberlo mencionado en clase que esto era necesario, a más de les hubiera funcionado el código.

• Hay que quitar los espacios vacíos al inicio y al principio del nombre y tampoco se explicó en la guía y creo que muchos también fallaron. Por mi parte a partir de este momento, voy a hacer lo que diga la guía y luego mirar los casos de prueba.

Acá está mi solución:

export class Course {
	constructor({ name, classes = [] }) {
		this.name = name;
		this.classes = classes;
	}

	get name() {
		// Tu código aquí 👈
    return this._name;

	}

	set name(nuevoNombrecito) {
		// Tu código aquí 👈
		if (typeof nuevoNombrecito === "string") {
      if (nuevoNombrecito < 1) {
        return
      }
      const arrayName = nuevoNombrecito.trim().split(" ");
			for (let index = 0; index < arrayName.length; index++) {
				arrayName[index] =
					arrayName[index][0].toUpperCase() +
					arrayName[index].slice(1);
			}
			this._name = arrayName.join(" ");
		}
	}
}

En general el Playground ha estado fallando, aquí comparto mi solución:

export class Course {
  constructor({
    name,
    classes = [],
  }) {
    this._name = name;
    this.classes = classes;
  }

  get name() {
    // Tu código aquí 👈
    return this._name;
  }

  set name(nuevoNombrecito) {
    // Tu código aquí 👈
    if (typeof nuevoNombrecito === "string") {
      this._name = nuevoNombrecito.split(" ").map(word => word.length > 2 ? word[0].toUpperCase() + word.slice(1) : word).join(" ");
    }
  }
}

Hola!, he notado que no les corre el codigo en Playground y ami tampoco me corre.
Estuve viendo y el codigo tiene un TYPO en el INPUT, cuando crea la instancia del prototipo Course, la instancia se llama: “nombreMaysuculas”…
Y cuando van a llamar el atributo name colocan “nombreMayusculas”. Espero puedan resolver ese error 😀

Dejo mi codigo funcional para VSCode. Tambien dejo enlace para entender mejor acerca del trabajo que realiza el metodo 🔗substring()

class Course {
  #name;
  constructor({ name, classes = [] }) {
    this.name = name;
    this.classes = classes;
  }

  get name() {
    // Tu código aquí 👈
    return this.#name;
  }

  set name(nuevoNombrecito) {
    // Tu código aquí 👈
    if (typeof nuevoNombrecito === "string") {
      const palabras = nuevoNombrecito.split(" ");

      for (let i = 0; i < palabras.length; i++) {
        palabras[i] = palabras[i][0].toUpperCase() + palabras[i].substring(1);
      }

      console.log(palabras);
    } else {
      console.warn("ingresa un string, intentalo de nuevo!");
    }
  }
}

const nombreMaysuculas = new Course({
  name: "curso de introducción a astro",
  classes: ["introduccion", "astro en landingpage"],
});

MI solucion:

export class Course {

  constructor({
    name,
    classes = [],
  }) {
    this.name = name;
    this.classes = classes;
  }

  get name() {
    return this._name;
  }

  set name(newName) {
    if (typeof newName === "string") {
      newName = newName.trim()
      if (newName.length) {
        this._name = newName.split(" ").map((word) => {
          return word.length &&
            `${word[0].toUpperCase()}${word.slice(1)}`;
        }).join(" ")
      }
    }
  }

}

class Course {
  constructor({ name, classes = [] }) {
    this.name = name;
    this.classes = classes;
  }

  get name() {
    return this._name;
  }

  set name(nuevoNombrecito) {
    if (typeof nuevoNombrecito === "string") {
        const nuevoNombrecitoMayus = nuevoNombrecito.split(" ").map((word) => word[0].toUpperCase() + word.slice(1)).join(" ").trim();
      this._name = nuevoNombrecitoMayus;
    }else{
        console.log("Nombre invalido")
    }
  }
}

No funciona en las pruebas.

export class Course {
  constructor({
    name,
    classes = [],
  }) {
    this._name = name;
    this.classes = classes;
  }

  get name() {
    // Tu código aquí 👈
    return this._name;
  }

  set name(nuevoNombrecito) {
    // Tu código aquí 👈
    if (typeof nuevoNombrecito === "string") { 
      this._name = nuevoNombrecito.toLowerCase().split("").map((ele, index) => { if (index == 0) { return ele.toUpperCase(); } return ele; }).join("");
    }
  }
}

Escribo aquí mi solución por que no quiere correr la prueba

function CapitalizeFirstLetter(nombre) {
  let arrayNames = nombre.split(" ");
  let arrayCapitalizeNames = arrayNames.map(
    word => word[0].toUpperCase() + word.slice(1))
  return arrayCapitalizeNames.join(" ");
}

export class Course {
  constructor({
    name,
    classes = [],
  }) {
    this.name = name;
    this.classes = classes;
  }

  get name() {
    return this.name;
  }

  set name(nuevoNombrecito) {
    if (typeof (nuevoNombrecito) === "string") {
      this.name = CapitalizeFirstLetter(nuevoNombrecito);
    }
  }
}