Aún no tienes acceso a esta clase

Crea una cuenta y continúa viendo este curso

Ventajas de la programación orientada a objetos

7/17
Recursos

Aportes 168

Preguntas 12

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesión.

Todos después de escribir los objetos literales y luego ver como los borra:

class Course {
  constructor({
    id,
    name,
    teacher,
    lessons = [],
  }) {
    this.id = id;
    this.name = name;
    this.teacher = teacher;
    this.lessons = lessons;
  }
}

class LearningPath {
  constructor({
    id,
    name,
    courses = [],
  }) {
    this.id = id;
    this.name = name;
    this.courses = courses;
  }

  addCourse(course) {
    this.courses.push(course);
  }

  replaceCourse(oldCourse, newCourse) {
    const oldCourseIndex = this.courses.findIndex(course => course.id === oldCourse.id);

    if (oldCourseIndex !== -1) {
      this.courses[oldCourseIndex] = newCourse;
    }

    return this.courses;
  }

  deleteCourse(oldCourse) {
    const courseIndex = this.courses.findIndex(course => course.id === oldCourse.id);
    this.courses.splice(courseIndex, 1);

    return this.courses;
  }
}

const reactNativeLearningPath = new LearningPath({
  id: 'react-native',
  name: 'Desarrollo de Apps con React Native',
  courses: [
    new Course({ 
      id: 'basico-javascript', 
      name: 'Curso Básico de JavaScript', 
      teacher: 'Diego De Granda',
    }),
    new Course({
      id: 'ecmascript-6',
      name: 'Curso de ECMAScript 6+',
      teacher: 'Orlando Naipes',
    }),
    // etc...
  ]
})

Para los que no conocen el atajo que uso es: Alt + shift y seleccionar al principio de cada linea.

¿Quién usa Facebook hoy en día? xD el bullying a los de Facebook. Yo dejé de usarlo hace como un año, es una perdedera de tiempo, a menos que sea para marketing 😋


class LearningPath {
  constructor({
    name,
    courses = [],
  }) {
    this.name = name;
    this.courses = courses;
  }
}

const escuelaWeb = new LearningPath({
  name: "Escuela de Desarrollo Web",
  courses: [
    cursoJS,
    cursoReact,
    cursoNextJS,
  ],
});

const escuelaData = new LearningPath({
  name: "Escuela de Data Science",
  courses: [
    cursoPython,
    CursoMatematicas,
    CursoExcel,
  ],
});

Alguno de los atajos de teclado son estos
.
Escribir en varios lados a la vez
alt + click

Mover una línea hacia arriba y abajo
alt + flecha hacia arriba (o flecha hacia abajo)

Copiar una línea hacia arriba o abajo
alt + shift + flecha hacia arriba (o flecha hacia abajo)

Borrar una línea completa a la vez
shift + supr

Como proyecto personal estoy haciendo algo relacionado con Platzi, por lo que quise aprovechar el curso para ir un poco más allá. La clase LearningPath la creé considerando la información que aparece en la presentación de las rutas. Dejo mi código.

class LearningPath {
  constructor({
    id,
    logo,
    name,
    teachers = [],
    blogposts = [],
    glosary = [],
    category,
    description,
    levels = [],
  }) {
    this.id = id;
    this.logo = logo;
    this.name = name;
    this.teachers = teachers;
    this.blogposts = blogposts;
    this.glosary = glosary;
    this.category = category;
    this.description = description;
    this.levels = levels;
  }

  addCourse(level, nameCourse) {
    if (!this.levels[level]) {
      this.levels[level] = [];
    }
    this.levels[level].push(nameCourse);
  }

  addTeacher(teacher){
    this.teachers.push(teacher)
  }

  addBlog(blog){
    this.blogposts.push(blog)
  }

  addConcept(concept){
    this.glosary.push(concept)
  }
} 

Yo usando facebook

Chale, yo uso Facebook por los memes :c

Ventajas de la Programación Orientada a Objetos

Reusabilidad. Cuando hemos diseñado adecuadamente las clases, se pueden usar en distintas partes del programa y en numerosos proyectos.

Mantenibilidad. Debido a las sencillez para abstraer el problema, los programas orientados a objetos son más sencillos de leer y comprender, pues nos permiten ocultar detalles de implementación dejando visibles sólo aquellos detalles más relevantes.

Modificabilidad. La facilidad de añadir, suprimir o modificar nuevos objetos nos permite hacer modificaciones de una forma muy sencilla.

Fiabilidad. Al dividir el problema en partes más pequeñas podemos probarlas de manera independiente y aislar mucho más fácilmente los posibles errores que puedan surgir.

La programación orientada a objetos presenta también algunas desventajas como pueden ser:

Cambio en la forma de pensar de la programación tradicional a la orientada a objetos.

La ejecución de programas orientados a objetos es más lenta.

La necesidad de utilizar bibliotecas de clases obliga a su aprendizaje y entrenamiento.

Pueden hacer un “console.table(Student)” y miren como les explota la cabeza con eso xD

Cuando dicen que nadie usa Facebook…

Hola a todos, les comparto mi aporte:

// cursos
class Courses {
  constructor({ name, teacher, ranking, level }) {
    (this.name = name), (this.teacher = teacher);
    this.ranking = ranking;
    this.level = level;
  }
}

const basicoJS = new Courses({
  name: "Curso Practico de JavaScript",
  teacher: "Juan David Castro",
  ranking: 4.7,
  level: "medium",
});

const practicoJS = new Courses({
  name: "Curso Basico de JavaScript",
  teacher: "Diego De Granda",
  ranking: 4.6,
  level: "medium",
});

const basicoPython = new Courses({
  name: "Curso Basico de Python",
  teacher: "Oscar Manuel",
  ranking: 3.7,
  level: "beginer",
});

const avanzadoPython = new Courses({
  name: "Curso Avanzado de Python",
  teacher: "Freddy Vega",
  ranking: 4.1,
  level: "advanced",
});

// learning paths
class LearningPaths {
  constructor({ name, courses }) {
    this.name = name;
    this.courses = courses;
  }
}

const escuelaJS = new LearningPaths({
  name: "Escuela de JavaScript",
  courses: [basicoJS, practicoJS],
});

const escuelaDataScience = new LearningPaths({
  name: "Escuela de Data Science",
  courses: [basicoPython, avanzadoPython],
});

// students
class Student {
  constructor({
    name,
    email,
    username,
    twitter = undefined,
    instagram = undefined,
    facebook = undefined,
    approvedCourses = [],
    learningPaths = [],
  }) {
    this.name = name;
    this.email = email;
    this.username = username;
    this.socialMedia = {
      twitter,
      instagram,
      facebook,
    };
    this.approvedCourses = approvedCourses;
    this.learningPaths = learningPaths;
  }
}

const juan = new Student({
  name: "JuanDC",
  username: "juandc",
  email: "[email protected]",
  twitter: "fjuandc",
  learningPaths: [escuelaDataScience],
});

const miguel = new Student({
  name: "Miguelito",
  username: "miguelitoFeliz",
  email: "[email protected]",
  instagram: "miguelito_Feliz",
  approvedCourses: [basicoJS, basicoPython],
  learningPaths: [escuelaJS, escuelaDataScience],
});

Ah modo de reto, me propuse separar todas las clases en archivos diferentes, esto con la finalidad de que el codigo sea mas facil de leer y no se sature en un solo archivo… Se los comparto:

  • Cambio 1:
    Primero vamos a tu html y agregas esta propiedad al script para que cargue el js. type="module", quedando de la siguiente manera:
    <script type="module" src="./src/Ventajas/main.js"></script>

  • Paso 2:
    Dividimos el codigo en pedacitos mas pequeños que armaremos, para ello creamos 4 archivos, los cuales seran: Student, LearningPath, Course y main, y su estructura es:

Student,js

export default class Student {
  constructor({
    name,
    username,
    points,
    approvedCourses = [],
    learningPaths = [],
    twitter = undefined,
    facebook = undefined,
    instagram = undefined,
  }) {
    this.name = name;
    this.username = username;
    this.points = points;
    this.approvedCourses = approvedCourses;
    this.learningPaths = learningPaths;
    this.socialMedia = {
      twitter,
      facebook,
      instagram,
    };
  }
}

El siguiente es Course.js:

export default class Student {
  constructor({
    name,
    username,
    points,
    approvedCourses = [],
    learningPaths = [],
    twitter = undefined,
    facebook = undefined,
    instagram = undefined,
  }) {
    this.name = name;
    this.username = username;
    this.points = points;
    this.approvedCourses = approvedCourses;
    this.learningPaths = learningPaths;
    this.socialMedia = {
      twitter,
      facebook,
      instagram,
    };
  }
}

Agregamos a LearningPath.js:

export default class LearningPath {
  constructor({ id, name, description, category, courses = [] }) {
    this.id = id;
    this.name = name;
    this.category = category;
    this.description = description;
    this.courses = courses;
  }
  addCourse(newCourse) {
    this.courses.push(newCourse);
  }
}

Esto lo debemos agregar y trabajar en el main.js:

import Course from "./Course.js";
import LearningPath from "./LearningPath.js";
import Student from "./Student.js";

const inglesBasico = new Course({
  id: 1,
  name: "Curso Ingles basico",
  teacher: "Juan Perez",
  lessons: 23,
});
console.log(inglesBasico);

const rutaIngles = new LearningPath({
  id: 1,
  name: "Escuela Ingles",
  description: "Ganate tu primer B1",
  category: "Ingles",
  courses: [inglesBasico],
});

console.log(rutaIngles);

const edgar = new Student({
  name: "Edgar Gc",
  username: "edgargc026",
  points: 2000,
  learningPaths: [rutaIngles],
  approvedCourses: ["Curso Definitivo HTML y CSS", "Curso Practio HTML y CSS"],
});

console.log(edgar);

Y de esta manera puedes tenerlo mas acomodado c:

Aquí está mi solución al reto:

class LearningPath {
    constructor({
        name,
        courses,
    }) {
        this.name = name;
        this.courses = courses;
    }

    addCourse(nombreCurso) {
        this.courses.push(nombreCurso);
    }

    deleteCourse(nombreCurso) {
        indexCourse = this.courses.indexOf(nombreCurso);
        this.courses.pop(indexCourse);
    }
}

const escuelaWeb = new LearningPath({
    name: "Escuela de Desarrollo Web",
    courses: [
        "Curso Definitivo de HTML y CSS",
        "Curso Practico de HTML y CSS",
        "Curso de Responsive Design"
    ]
});

const escuelaDataScience = new LearningPath({
    name: "Escueala de Data Science",
    courses: [
        "Curso de Análisis de Negocios para Ciencia de Datos",
        "Curso de Tableau",
        "Curso de Principios de Visualización de Datos para Business Intelligence"
    ]
});

const escuelaVgs = new LearningPath({
    name: "Escuela de Videojuegos",
    courses: [
        "Curso de Creación de Videjuegos",
        "Curso de Diseño de Videojuegos",
        "Curso Profesional de Diseño de Videojuegos",
    ]
});```

despues de haver pausado el video 28 veces por fin consegui copiar el codigo.
y despues del minuto 6:55 😱️😱️😱️😱️ aksjghlvkjfh lasjkdhflkajsghalkjh

Acaun aporte de mi parte. Como sabran mozilla developer es la pagina donde esta la mayor documentacion de desarrollo web y tecnologias en internet
//
Articulo para principiante de POO JS > https://developer.mozilla.org/es/docs/Learn/JavaScript/Objects/Object-oriented_JS

class LearningPath {
  constructor({ name, courses = [] }) {
    this.name = name;
    this.courses = courses;
  }
}

const desarrolloWeb = new LearningPath({
  name: "Escuela de Desarrollo Web",
  courses: ["Curso Definitivo HTML y CSS", "Curso Práctico de HTML y CSS"],
});

const dataScience = new LearningPath({
  name: "Escuela de Data Science",
  courses: ["Curso de Tableau", "Curso de Python"],
});

También estoy pensando en borrar Facebook 😄

class LearningPaths{
    constructor({
        learningPaths = []
    }) {
        this.learningPaths = learningPaths
    }
    learningPathsAdd(newPaths) {
        this.learningPaths.push(newPaths)
    }
}

const newRoutes = new LearningPaths({})

class ApprovedCourses{
    constructor({
        approvedCourses = []
    }) {
        this.approvedCourses = approvedCourses
    }
    approvedCoursesAdd(newCourse) {
        this.approvedCourses.push(newCourse)
    }
}

const webSchool = new ApprovedCourses({})


class Student {
    constructor({
        name,
        username,
        email,
        socialMedia: {
            twitter = undefined,
            facebook = undefined,
            instagram = undefined,
        },
        approvedCourses = [],
        learningPaths = []
    }){
        this.name = name
        this.username = username
        this.email = email
        this.socialMedia = {
            twitter,
            facebook,
            instagram,
        }
        this.approvedCourses = approvedCourses
        this.learningPaths = learningPaths
    }
}

const gabriel = new Student({
    name: 'Gabriel',
    username: 'gabyRotger',
    email: '[email protected]',
    socialMedia: {
        twitter:'@gabriel',
        facebook: undefined,
        instagram: 'Rotger_Gabriel'
    },
    approvedCourses: [
        webSchool
    ],
    learningPaths: [
        webSchool,
        newRoutes
    ]
})
class PlatziStudent {
  constructor({
      name,
      email,
      twitter = undefined,
      instagram = undefined,
      facebook = undefined,
      approvedCourses = [],
      learningPaths = [],
  }){
      this.name = name;
      this.email = email;
      this.socialMedia = {
        twitter,
        instagram,
        facebook,
      };
      this.approvedCourses = approvedCourses;
      this.learningPaths = learningPaths;
    }
}
class LearningPaths {
  constructor({
      escuelaName,
      escuelaCursos = [],
  }){
      this.escuelaName = escuelaName;
      this.escuelaCursos = escuelaCursos;
    }
}


const desarrolloWeb = new LearningPaths({
  escuelaName: 'Escuela de desarrollo web',
  escuelaCursos: {curso1: 'introduccion Js', curso2: 'Introduccion Patrones de diseño'},
});

const dataScience = new LearningPaths({
  escuelaName: 'Escuela de data science',
  escuelaCursos: {curso1: 'introduccion dataScience', curso2: 'basico python'},
});

const videojuegos = new LearningPaths({
  escuelaName: 'Escuela de data videojuegos',
  escuelaCursos: {curso1: 'introduccion unity4d', curso2: 'basico algoritmos'}
});


const Juan1 = new PlatziStudent({
  name: "JuanDc",
  username: "Juan_Dc_Es_Batman",
  email: "[email protected]",
  twitter: "@fdc",
  instagram: undefined,
  facebook: undefined,
  learningPaths: [
    desarrolloWeb,
    dataScience,
    videojuegos,
  ],
});
class LearningPaths{
    constructor({
        name,
        courses = []
    }){
        this.name = name;
        this.courses = courses;
    }
}

const escuelaWeb = new LearningPaths({
    name: "Escuela de desarrollo web",
});

const escuelaData = new LearningPaths({
    name: "Escuela de DataScience",
});

const escuelaVgs = new LearningPaths({
    name: "Escuela de Vgs",
});



class Student{
    constructor({
        name, 
        username,
        email,
        twitter = undefined,
        instagram = undefined,
        facebook = undefined,
        approvedCourses = [],
        learningPaths = []
    }){
        this.name = name; 
        this.username = username;
        this.email = email;
        this.socailMedia={
            twitter,
            instagram,
            facebook
        };
        this.approedCourses = approvedCourses;
        this.learningPaths = learningPaths;
    }
}   

const victor = new Student({
    name : "Victor Hugo Cruz",
    username : "hugutiobody",
    email : "[email protected]",
    learningPaths : [
        escuelaWeb,
        escuelaData
    ]
});

const vanesa = new Student({
    name : "Vanesa Pozo",
    username : "vanesita024",
    email : "[email protected]",
    learningPaths : [
        escuelaVgs,
        escuelaData
    ]
});

const emanuel = new Student({
    name : "Emanuel Cruz Pozo",
    username : "emita",
    email : "[email protected]",
    twitter : "emitas_pro"
});
class LearningPath {
    constructor({
        nameSchool,
        pathSchool = [
            {
                nameSchool: 'Escuela de Desarrollo Web',
                courses: [
                    'Curso de computación básica',
                    'Fundamentos de ingenieria de software',
                    'Curso profesional de Git y GitHub',
                    'Curso básico de JavaScript',
                    'Curso de Webpack',
                ]
            },
            {
                nameSchool: 'Escuela de Data Science e Inteligencia Artificial',
                courses: [
                    'Curso de Análisis de Negocios para Ciencia de Datos',
                    'Curso Básico de Python',
                    'Curso de Python Intermedio: Comprehensions, Lambdas y Manejo de Errores',
                    'Curso de Manipulación y Análisis de Datos con Pandas y Python',
                    'Curso de Fundamentos Prácticos de Machine Learning',
                ]
            },
            {
                nameSchool: 'Escuela de Videojuegos',
                courses: [
                    'Curso de Introducción a la Producción de Videojuegos',
                    'Curso Profesional de Diseño de Videojuegos',
                    'Curso de Dirección de Videojuegos',
                    'Curso Intermedio de Programación de Videojuegos 2D con Unity',
                    'Curso de VR con Unity',
                ]
            },
        ],
    }) {
        this.nameSchool = nameSchool;
        this.pathSchool = pathSchool;
        this.courses = this.getCourses(this.pathSchool);
    }

    getCourses(pathCursosForSchool) {
        let i = 0;
        for (i in pathCursosForSchool) {
            if (pathCursosForSchool[i].nameSchool === this.nameSchool) {
                return pathCursosForSchool[i].courses;
            }
        }
    }
}

const escuelaWeb = new LearningPath({
    nameSchool: 'Escuela de Desarrollo Web',
});
const escuelaData = new LearningPath({
    nameSchool: 'Escuela de Data Science e Inteligencia Artificial',
});
const escuelaVgs = new LearningPath({
    nameSchool: 'Escuela de Videojuegos',
});

class Student {
    constructor({
        name,
        email,
        username,
        twitter = undefined,
        instagram = undefined,
        facebook = undefined,
        approvedCourses = [],
        learningPaths = [],
    }) {
        this.name = name;
        this.email = email;
        this.username = username;
        this.socialMedia = {
            twitter,
            instagram,
            facebook,
        };
        this.approvedCourses = approvedCourses;
        this.learningPaths = learningPaths;
    }
}

const juan2 = new Student({
    name: "JuanDC",
    username: "juandc",
    email: "[email protected]",
    twitter: "fjuandc",
    learningPaths: [
        escuelaWeb,
        escuelaVgs,
    ],
});

const miguelito2 = new Student({
    name: "Miguelito",
    username: "migelitofeliz",
    email: "[email protected]",
    instagram: "migelito_feliz",
    learningPaths: [
        escuelaWeb,
        escuelaData,
    ],
});

la clase

class LearningPaths {
    constructor({
        namePaths,
        courses = []
    })
    {
        this.namePaths = namePaths;
        this.courses = courses
    }

    addCourse(newCourse){
        this.courses.push(newCourse)
    }
};

los objetos

const desarrolloWeb = new LearningPaths({
    namePaths: "Escuela de desarrollo Web",
    courses : [
        "Curso de Computacion Basica 2019",
        "Curso Gratis de Programación Básica",
        "Curso Básico de Algoritmos y Pensamiento Lógico"
    ]
});

const disenoGrafico = new LearningPaths({
    namePaths : "Escuela de Diseño Gráfico",
    courses : [
        "Audiocurso Glosario de Términis de Diseño",
        "Curso de Técnocas para Desarrollar tu Creatividad"
    ]
});
 

Si no te ha quedado claro las ventajas de la POO, aquí te dejo 3.

  • Programar más rápido: Como bien ya vimos en la clase, con nuestros moldes ya hechos podemos realizar trabajos extensos en menos tiempo.
  • Aumentar tu nivel como dev: Ya dejamos de hacer código a lo bruto, y teniendo los conocimientos de la POO podemos resolver problemas de manera mas eficiente, ordenada y escalable.
  • Evitar ese molesto código Spaghetti que todxs hemos escrito alguna vez xD

La mayor ventaja de la programación orientada a objetos es poder tener muchísimas menos líneas de código y hacer el mismo proceso.

Quien rayos tiene Facebook ?
QUE AGRADABLE SUJETO guiño

Bien creo que esto es lo que asi quedaria la clase para crear learning paths

class Student{
    constructor({
       	name,
        	userName,
       	 email,
        	twitter = undefined, 
        	instagram = undefined, 
        	facebook = undefined, 
        	approvedCourses = [], 
        	learningPaths = {}
          }){
        this.name = name;
        this.userName = userName;
        this.email = email;
        this.socialMedia = {
            twitter, instagram, facebook
        }
        this.approvedCourses = approvedCourses;
        this.learningPaths = learningPaths;
    }
}

class leaningPath {
    constructor({name, courses}){
        this.name = name;
        this.courses = courses;
    }
}

webDev = new leaningPath({
    name: "Web Development", 
    courses: ["Basic HTML & CCS", "Practical HTML & CSS", "Basic JS", 
	     "Intermediate JS", "OOP in JS", "ECMASCRIPT", "Design systems"
             ]
});

javier = new Student({name: "Javier Gamez", userName: "jgamez", 
                      email: "[email protected]", 
		      learningPaths: webDev});

RETO

class Student{
    constructor({
        name,
        email,
        username,
        twitter = undefined,
        instagram = undefined,
        facebook = undefined,
        approvedCourses = [],
        learningPath = []
    }){
       this.name = name;
       this.email = email;
       this.username = username;
       this.socialMedia = { 
            twitter,
            instagram,
            facebook
       };
       this.approvedCourses = approvedCourses;
       this.learningPath = learningPath;
    }
}

class learningPath{
    constructor(name, courses = []){
        this.name = name;
        this.courses = courses;
    }
}

const escuelaDesarrolloWeb = new learningPath('desarrollo web', ['fisisca', 'quimica']);
const esccuelaIngles = new learningPath('ingles', ['ingles basico', 'ingles intermedio']);

const victor = new Student({
    name: 'victor',
    username: 'victorsheepman',
    email: '[email protected]',
    learningPath: [escuelaDesarrolloWeb, esccuelaIngles] 
});

Reto Cumplido:

class LearningPath {
    constructor({
        name,
        courses = [],
    }) {
        this.name = name;
        this.courses = courses;
    }

    agragarNameRuta(nameNuevo) {
        this.name = nameNuevo;
    }

    agregarCursoRuta(curso) {
        this.courses.push(curso);
    }
}

const escuelaWeb = new LearningPath({
    name: "Escuela de Desarrollo Web",
    courses: [
        "Curso Definitivo de HTML y CSS",
        "Curso Práctico de HTML y CSS",
        "Curso de Responsive Design",
    ],
});

const escuelaData = new LearningPath({
    name: "Escuela de Data Science",
    courses: [
        "Curso básico de Python",
        "Curso Avanzado de Python",
        "Data Analitic Básico",
    ],
});

const escuelaVgs = new LearningPath({
    name: "Escuela de Videojuegos",
    courses: [
        "Curso Básico de Programación",
        "Curso Básico de Udemy",
        "Curso Avanzado de Udemy",
    ],
});

Así me quedo el reto

Así hice el reto

class LearningPath {
    constructor({
        nameLearning,
        courses,
        url,
    }) {
        this.nameLearning = nameLearning;
        this.courses = courses;
        this.url = url;
    }
}
const escuelaMarketing = new LearningPath({
    nameLearning: "Escuela de Marketing Digital",
    url: "https://platzi.com/home",
    courses: [
        "Curso de Content Marketing",
        "Curso de Community Manager",
        "Curso de Brand Storytelling",
    ]
})
const escuelaEcommerce = new LearningPath({
    nameLearning: "Escuela de E-Commerce y Negocios Digitales",
    url: "https://platzi.com/home",
    courses: [
        "Curso para Empezar a Vender por Internet",
        "Curso de Fundamentos de Ecommerce",
        "Curso de Business Model Canvas",
    ]
})

Reto:

class LearningPaths {
    constructor({
        name,
        courses,
    }){
        this.name = name;
        this.courses = courses;
    }
}
const escuelaWeb = new LearningPaths({
    name: "Escuela de Desarrollo Web",
    courses: [
        "Curso Definitivo de HTML Y CSS",
        "Curso Práctico de HTML Y CSS",
        "Curso de Responsive Desing",
    ],
});
const escuelaData = new LearningPaths({
    name: "Escuela de Data Science",
    courses: [
        "Curso DataBusiness",
        "Curso DataViz",
        "Curso Tableau",
    ],
});
const escuelaVgs = new LearningPaths({
    name: "Escuela de Videojuegos",
    courses: [
        "Curso Introducción a la Producción de Vgs",
        "Curso de Unreal Engine",
        "Curso de Unioty 3D"
    ],
});```

Hola
Les comparto mi codigo junto con la sección del Reto

JS

class Student {
    constructor({
        name,
        email,
        username,
        twitter = undefined,
        instagram = undefined,
        approvadesCourses = [],
        learningPaths = [],
    }) {
        this.name = name;
        this.email = email;
        this.username = username;
        this.socialMedia = {
            twitter,
            instagram,
        };
        this.approvadesCourses = approvadesCourses;
        this.learningPaths = learningPaths;
    }
};

class LearningPaths{
    constructor({
        nameLearningPath,
        courses,
    }) {
        this.nameLearningPath = nameLearningPath;
        this.courses = courses;
    }
}

const escuelaWeb = new LearningPaths({
    nameLearningPath:"Escuela de Desarrollo Web",
    courses: [
        "Curso de Computación Básica",
        "Curso Básico de Algoritmos y Pensamiento Lógico",
        "Curso de Fundamentos de Ingeniería de Software",
        "Curso de Prework:Configuración de Entorno de Desarrollo en Windows",
        "Curso de Introducción a la Terminal de Linea de Comandos",
        "Curso Profesional de Git y GitHub",
        "Curso Definitivo de HTML y CSS",
        "Curso Practico de HTML y CSS",
        "Curso de Preprocesadore CSS",
        "Curso de Frontend Developer",
        "Curso de Programación Orientada a Objetos",
        "Curso Básico de Programación Orientada a Objetos con JavaScript",
    ]
});
const escuelaDataScience = new LearningPaths({
    nameLearningPath:"Escuela de Data Science",
    courses: [
        "Curso de Análisis de Negocios para Ciencias de Datos",
        "Curso Básico de Phyton",
        "Curso de Introducción a la Terminal de Linea de Comandos",
        "Curso Profesional de Git y GitHub",
        "Curso de Fundamentos de Matemáticas",
        "Curso de Python Intermedio",
        "Curso de Introducción al Pensamiento Computacional con Phyton",
    ]
});

const juan2 = new Student({
    name:"JuanDC",
    username: "juandc",
    email: "[email protected]",
    twitter: "fjuandc",
    learningPaths: escuelaWeb,
});
juan2.approvadesCourses.push(escuelaWeb.courses[1])
juan2.approvadesCourses.push(escuelaWeb.courses[3])
juan2.approvadesCourses.push(escuelaWeb.courses[4])
juan2.approvadesCourses.push(escuelaWeb.courses[7])

const miguelito2 = new Student({
    name:"Miguelito",
    username: "miguelitofeliz",
    email: "[email protected]",
    twitter: "miguelito_feliz",
    learningPaths: escuelaDataScience,
});

Aquí mi código c:

class Course{
    constructor({name, teacher, points}){
        this.name = name;
        this.teacher = teacher;
        this.points = points;
    }
}

class LearningPath{
    constructor({name, courses = []}){
        this.name = name;
        this.courses = courses;
    }

    addCourse(course){
        this.courses.push(course);
    }

    deleteCourse(courseName){
        this.courses = this.courses.filter(course => course.name != courseName);
    }
}

const DBC = new Course({
    name: "Curso de Bases de Datos", 
    teacher: "Angel2",
    points: 100,
});
const ADBC = new Course({
    name: "Curso de Bases de Datos Avanzado", 
    teacher: "Juan2",
    points: 100,
});

const DVC = new Course({
    name: "Curso de Data Visualization",
    teacher: "Pedro",
    points: 200,
});

const BIC = new Course({
    name: "Curso de Bussines Intelligence para Ciencia de Datos",
    teacher: "Pedro",
    points: 300,
});

const dataSciencePath = new LearningPath({
    name: "Ruta para Aprender Ciencia de Datos",
    courses: [DVC, BIC]
});

const dataBasesPath = new LearningPath({
    name: "Ruta para Aprender Todo Sobre Bases de Datos",
    courses: [ADBC, DBC]
});

class Student {
  constructor({
    name, age, email, username,
    twitter, instagram, facebook, linkedin,
    approvedCourses = [], learningPaths = [],
  }) {
    this.name = name;
    this.age = age;
    this.email = email;
    this.username = username;
    this.socialMedia = {
        twitter: twitter,
        instagram: instagram,
        facebook: facebook,
        linkedin: linkedin,
    };
    this.approvedCourses = approvedCourses;
    this.learningPaths = learningPaths;
  }
  getInfo(){
    console.log(`
        --------------- Información del Estudiante -------------
        Nombre: ${this.name}
        Edad: ${this.age}
        Email: ${this.email}
        Nombre de Usuario: ${this.username}

        ---- Redes Sociales ----
        Instagram: ${this.socialMedia.instagram}
        Facebook: ${this.socialMedia.facebook}
        LinkedIn: ${this.socialMedia.linkedin}
        Twitter: ${this.socialMedia.twitter}

        ---- Rutas de Aprendizaje ----
    `);
    console.log(this.learningPaths);
  }
}

const angel = new Student({
    email: "[email protected]",
    username: "aelindarte",
    name: "Angel",
    age: 17,
    learningPaths: [dataBasesPath, dataSciencePath]
});

const juan = new Student({
    email: "[email protected]",
    username: "JuanDC",
    name: "Juan",
    age: 17,
    learningPaths: [dataSciencePath],
});

angel.getInfo();

Simple

class Paths {

    constructor(nCourses, courses=[]) {
        { 
        this.courses = courses;
        this.nCourses = nCourses;
    }
    }

    addCourse(course) {
        this.courses.push(course);
    }
}

const webDeveloperPath = new Paths(97);

Solución al reto:

class LearningPath {
  constructor({
    name
  }) {
    this.name = name,
    this.courses = []
  }

  addCourse(newCourse) {
    this.courses.push(newCourse);
  }
}

const escuelaWeb = new LearningPath({name: 'Escuela de Desarrollo Web'});
escuelaWeb.addCourse('Curso Definitivo de HTML y CSS');
escuelaWeb.addCourse('Curso Práctico de HTML y CSS');
escuelaWeb.addCourse('Curso de Responsive Design');
escuelaWeb.addCourse('Curso de Sistemas de Diseño');
const escuelaData = new LearningPath({name: 'Escuela de Data Science'});
escuelaData.addCourse('Curso DataBusiness');
escuelaData.addCourse('Curso DataViz');
escuelaData.addCourse('Curso Tableau');
const escuelaVgs = new LearningPath({name: 'Escuela de Videojuegos'});
escuelaVgs.addCourse('Curso Introducción a la Producción de Vgs');
escuelaVgs.addCourse('Curso de Unreal Engine');
escuelaVgs.addCourse('Curso de Unity 3D');

Hola, vengo a flexear mi codigo

class LearningPath{
	constructor({
		name,
		cantidadDeCursos = 0,
		cursos = [],
	}){
		this.name = name;
		this.cursos = cursos;
		this.cantidadDeCursos = cursos.length;
	};

	addCourse(course){
		this.cursos.push(course);
		this.cantidadDeCursos++;
	}
}
const escuelaWeb = new learningPath({
	name: "Escuela de Desarrollo Web",
	cursos: 
	[
		"Curso Desarrollo Web",
		"Curso HTML",
		"Curso CSS",
		"Curso JavaScript",
	]
});

const escuelaData = new learningPath({
	name: "Escuela de Data Science",
	cursos:
	[
		"Curso de Data Science",
		"Curso de Data Visualization",
		"Curso de Data Analytics",
	]
});

Ya termine de flexear mi codigo, a ver la sig clase a ver si masomenos es lo que plantea.

Mi solucion :

class LearningPath{
	constructor({
		name,
		cantidadDeCursos = 0,
		cursos = [],
	}){
		this.name = name;
		this.cursos = cursos;
		this.cantidadDeCursos = cursos.length;
	};

	addCourse(course){
		this.cursos.push(course);
		this.cantidadDeCursos++;
	}
}
const escuelaWeb = new LearningPath({
	name: "Escuela de Desarrollo Web",
	cursos: 
	[
		"Curso Desarrollo Web",
		"Curso HTML",
		"Curso CSS",
		"Curso JavaScript",
	]
});

const escuelaData = new LearningPath({
	name: "Escuela de Data Science",
	cursos:
	[
		"Curso de Data Science",
		"Curso de Data Visualization",
		"Curso de Data Analytics",
	]
});

abierto a toda critica 😃

class LearningPaths {
  constructor({ name, courses }) {
    this.name = name;
    this.courses = courses;
  }

  agregarCurso(cursoNuevo) {
    this.courses.push(cursoNuevo);
  }

  remplazar_cursos(courseOld, coursenew) {
    this.courses.splice(this.courses.indexOf(courseOld), 1, coursenew);
  }

  deleteCurso(curso) {
    this.courses.splice(this.courses.indexOf(curso), 1);
  }
}

const escuelaWeb = new LearningPaths({
  name: "EscuelaWeb",
  courses: ["Html", "Css", "JavaScript"],
});

const escuelaData = new LearningPaths({
  name: "EscuelaData",
  courses: ["sql", "Curso de Tableau"],
});

const escuela_English = new LearningPaths({
  name: "Escuela de English",
  courses: ["A1", "A2", "B1", "B2"],
});
class LearningPath {
  constructor({ name, courses = [] }) {
    this.name = name;
    this.courses = courses;
  }

  addCourse(course) {
    this.courses.push(course);
  }

  deleteCourse(course) {
    this.courses.splice(this.courses.indexOf(course), 1);
  }
}

const escuelaWeb = new LearningPath({
  name: "Escuela de desarrollo Web",
  courses: [
    "Curso definitivo de HTML y CSS",
    "Curso Practico de HTML y CSS",
    "Curso de Responsive Design",
  ],
});

const escuelaData = new LearningPath({
  name: "Escuela de Data Science",
  courses: ["Curso DataBusiness", "Curso DataViz", "Curso Tablau"],
});

const escuelaVgs = new LearningPath({
  name: "Escuela de videojuegos",
  courses: [
    "Curso de introduccion a la produccion de Vgs",
    "Curso de Unreal Engine",
    "Curso de Unity",
  ],
});
class Student {
  constructor({
    name,
    email,
    username,
    twitter = undefined,
    instagram = undefined,
    facebook = undefined,
    approvedCourses = [],
    learningPaths = [],
  }) {
    this.name = name;
    this.email = email;
    this.username = username;
    this.socialMedia = {
      twitter,
      instagram,
      facebook,
    };
    this.approvedCourses = approvedCourses;
    this.learningPaths = learningPaths;
  }
}

const juan2 = new Student({
  name: "Juan",
  email: "[email protected]",
  username: "juandc",
  twitter: "juandc",
  learningPaths: [escuelaWeb, escuelaVgs],
});

const miguelito2 = new Student({
  name: "miguel",
  email: "[email protected]",
  username: "migueldc",
  twitter: "migueldc",
  learningPaths: [escuelaWeb, escuelaData],
});
class rutasAprendizaje{
    constructor({
        titulo,
        categoria,
        profesores = [],
        cursos = [],
    }){
        this.titulo = titulo;
        this.categoria = categoria;
        this.profesores = profesores;
        this.cursos = cursos;

    }

    sumarCurso(curso) {
        this.cursos.push(curso);

        
    }
  
}

const desarrolloWeb = new rutasAprendizaje({
    titulo: "Desarrollo Web Full Stack",
    categoria: "Desenvolvimento Web",
    profesores : ["Juan","Diego","RetaxMaster"],
    cursos : ["HTML DEFINITIVO","CSS DEFINITIVO","Design Responsive","JS"],
});


class estudiante3{
    constructor({
        nombre,
        edad,
        email,
        cursosAprobados = [],
        rutasAprendizaje = [],
        facebook = undefined,
        twitter = undefined,
        instagram = undefined,
    }){
        this.nombre = nombre;
        this.edad = edad;
        this.email = email;
        this.redesSociales = {
            facebook,
            twitter,
            instagram,
        };
        this.cursosAprobados = cursosAprobados;
        this.rutasAprendizaje = rutasAprendizaje;

    }
}

const gabriel = new estudiante3({
    nombre : "Gabriel",
    edad : 20,
    email : "[email protected]",
    facebook : "gabriel romero",
});
 class LearningPaths {
    constructor({
        nombre,
        cursos = [],
        totalCursos,
        numeroEstudiantes,
        profesores = [],
    }) {
        this.nombre = nombre;
        this.cursos = cursos;
        this.totalCursos = totalCursos;
        this.numeroEstudiantes = numeroEstudiantes;
        this.profesores = profesores;
    }
}

const escuelaJS = new LearningPaths({
    nombre: "Escuala de JavaScript",
    cursos: [
        "Curso de Prework: Configuración de Entorno de Desarrollo en Windows",
        "  Curso de  Prework: Configuración de Entorno de Desarrollo en Linux",
        "Curso de Prework: Configuración de Entorno de Desarrollo en macOS",
        "Curso de Frontend Developer",
        "Curso Práctico de Frontend Developer",
    ],
    totalCursos: 23,
    numeroEstudiantes: 264000,
    profesores: [
        " JuanDC ",
        "Oscar Barajas",
        "Diego De Granda",
        " Estefany Aguilar",
        "Carlos Hernández ",
        " Nicolas Molina",
    ]
})

Esta fue mi solucion para el problema

class LearningPaths{
    constructor({
        name,
        id,
        path = []
    }){
        this.name = name;
        this.id = id,
        this.path = path;
    }

    getName()
    {
        return this.name;
    }

    setName(named)
    {
        this.name = named;
    }

    getPath()
    {
        return this.path;
    }

    setPath(new_path)
    {
        for(let i of new_path)
        {
            this.path.push(i);
        }
    }
}

y esto fue el codigo que hize en base al de la clase


class Student{
    constructor({
        fullname,
        username,
        email,
        twitter = undefined,
        instagram = undefined,
        facebook = undefined,
        learningPaths = [],
        approvedCourses = []
    }){
        this.Fullname = fullname;
        this.username = username;
        this.email = email;
        this.socialMedia = {
            twitter,
            instagram,
            facebook
        };
        this.learningPaths = learningPaths;
        this.approvedCourses = approvedCourses;
    }

    addLearningPaths(object_paths)
    {
        this.learningPaths.push(object_paths)
    }

    getLearningPaths()
    {
        this.learningPaths.forEach(i => console.log({
            id: i.id,
            name: i.name,
            path: i.path
        }));
    }

    addApprovedCourses(course_aproved, id_course )
    {
        this.approvedCourses.push([id_course, course_aproved]);
    }

    getApprovedCourses()
    {
        console.log("Tus cursos aprovados");
        this.approvedCourses.forEach(i => console.log(`${i[0]}`));
    }
};

const juan = new Student({
    name: "Juan",
    username: "Tryna",
    email: "[email protected]",
    twitter: "tsebastian.g"
});

const web_development = new LearningPaths({ 
    name: "Web Development",
    id: 1,
    path: ["Fundamentos de Javascript", "Curso practico de javascript", "POO javascript"] 
});

const backend_go = new LearningPaths({ 
    name: "Backend con Go",
    id: 2,
    path: ["Fundamentos de Backend", "Curso practico de GO", "Microservicios con Go"] 
});

juan.addLearningPaths(web_development);
juan.addLearningPaths(backend_go);
juan.getLearningPaths();
juan.addApprovedCourses(web_development.id, web_development.path[2]);
juan.addApprovedCourses(backend_go.id, backend_go.path[2]);
juan.getApprovedCourses();

Si ven algo que pueda, por favor haganmelo saber

¡¡¡¡CONSEJO DEL DÍA!!!
No borren el object literal de ejemplo del profe, solo modifiquen las redes sociales para que se ajusten a su constructor y los pasan como parámetro cuando vayan a crear el estudiante

const profile = {
    name: "Eduard",
    username: "ecra",
    points: 1000,
    twitter:"ecra98",
    instagram: "ecra98__",
    facebook: "Eduard",
    approvedCourses: [
        "Curso Definitivo de HTML y CSS"
    ],
    learningPaths:[
        {
            name:"Escuela de Desarrollo Web",
            courses: [
                "Curso Definitivo de HTML y CSS"
            ]
        },
        {
            name:"Escuela de Videojuegos",
            courses: [
                "Curso Videojuegos"
            ]
        }
    ]
}

const newStudent = new Student(profile)

Reto:

class LearningPath {
    constructor({
        name,
        cursos = [],
        horasAprox = 0

    }) {
        this.name = name;
        this.cursos = cursos;
        this.horasAprox = horasAprox;
    }
}

const escuelaWeb = new LearningPath({
    name: "Escuela Desarrollo web",
    horasAprox: 30,
    cursos: [
        "Computacion básica",
        "Programacion básica",
        "Algoritmos y pensamiento lógico",
        "Fundamentos Ing software"
    ]

});

const escuelaData = new LearningPath({
    name: "Escuela Data Science",
    horasAprox: 80,
    cursos: [
        "Analisis de negocios",
        "Excel Basico",
        "Python basico",
        "Introduccion a terminal y linea de comandos"
    ]

});

const escuelaVgs = new LearningPath({
    name: "Escuela Desarrollo Videojuegos",
    horasAprox: 60,
    cursos: [
        "Planeacion",
        "Creacion y diseño",
        "Prototipado de personajes",
        "Introduccion a C#"
    ]

});

/ Creador de Cursos
class Cursos{

    constructor({  

        nombreCurso,
    })
    {
        this.nombreCurso = nombreCurso;
    };
};


//Cursos 
const jsBasico = new Cursos({
    nombreCurso: "Curso Basico de JavaScript",
})

const CplusBasico = new Cursos({
    nombreCurso: "Curso Basico de C++",
})

const PracticoJS = new Cursos({
    nombreCurso: "Curso Practico de JS",
})

const PracticoCplus = new Cursos({
    nombreCurso: "Curso Practico de C++",
})

const IntrACrypto = new Cursos({
    nombreCurso: "Curso Introduccion al mundo Crypto",
})


//Creador de Rutas de Aprendizaje
class LearningPaths{

    constructor({escuela, cursos = []})
    {
        this.escuela = {
            escuela,
            cursos: [cursos,],
        }
    };

    nuevoCurso(cursoN)
    {
        this.escuela.cursos.push(cursoN)
    };


};


//Instancias de rutas 
const escuelaWeb = new LearningPaths({
    escuela: "Escuela de Desarollo web",
    cursos: [jsBasico,]
});

const escuelaPrograming = new LearningPaths({
    escuela: "Escuela de programacíon",
    cursos: [CplusBasico],
});





//Creador de Estudiantes 
class Student {

    constructor({
        
            name,
            email,
            username,
            twitter = undefined,
            instagram = undefined,
            facebook = undefined,
            approvedCourses = [],
            learningPaths = [],
        
    }) {

        this.name = name
        this.email = email
        this.username = username
        this.socialMedia = {            
            twitter,
            instagram,
            facebook,
        }
        this.approvedCourses = approvedCourses
        this.learningPaths = learningPaths
    
    };

    ingresarCursoARuta(x=0,cursoN)
    {
        this.learningPaths[x].escuela.cursos.push(cursoN)
    }


};


const Gustavo1 = new Student({
    name: "GustavoGT",
    username: "gusgus",
    email: "[email protected]",
    instagram: "gus_gus"
})


const Gustavo2 = new Student({
    name: "GustavoMT",
    username: "gus_gus_MT",
    email: "[email protected]",
    instagram: "gus_gus_MT",
    twitter: "MT_gus",
    learningPaths: [
        escuelaWeb,
        escuelaPrograming,
    ]
})

Mi reto quedó algo así:
La clase learningPaths con cada uno de sus métodos, y los objetos (escuelas) con sus atributos.

Mientras que la clase estudiantes queda así
.

¡Aquí está mi solución al reto!🤠

class LearningPath{
    constructor({nameSchool, courses = []}){
        this.nameSchool = nameSchool;
        this.courses = courses;
    
    };

    addSchool(newSchool){
        this.nameSchool.push(newSchool);
    };
    addCourses(newCourses){
        this.courses.push(newCourses);
    };
};

const escuelaWeb = new LearningPath({
    nameSchool: "Escuela de Desarrollo Web",
    courses: [
        "Curso de Frontend Developer",
        "Curso Práctico de Frontend Developer",
        "Curso Definitivo de HTML y CSS",
        "Curso de Closures y Scope en JavaScript",
        "Curso de Programación Orientada a Objetos: POO",
    ],
});

const escuelaData = new LearningPath({
    nameSchool:  "Escuela de Data Scientist",
    courses: [
        "Curso de Fundamentos de Matemáticas",
        "Curso Básico de Python",
        "Curso de Principios de Visualización de Datos para Business Intelligence",
        "Curso Profesional de Python",
        "Curso de Matemáticas para Data Science: Estadística Descriptiva",
    ],
});

const escuelaVgs = new LearningPath({
    nameSchool: "Escuela de VideoJuegos",
    courses: [
        "Curso de Introducción a la Producción de Videojuegos",
        "Curso para Conseguir Inversión para Videojuegos: Preparar un Pitch Exitoso",
        "Curso de Game Maker Studio 2: Introducción a Creación de Videojuegos",
        "Curso Intermedio de Programación de Videojuegos 2D con Unity",
        "Curso de Introducción a Unreal Engine: Configuración y Entorno de Desarrollo",
    ],
});

Hola, este es mi aporte
creo que me falta pero lo hice a conciencia

Dejo mis apuntes e interpretación de esta clase.
https://www.notion.so/Curso-B-sico-POO-JS-8b1ae724db364a06b5cac3055526c7b1

class Courses {
    constructor({
        name,
        teacher,
        lession,
        time
    }){
        this.name    = name;
        this.teacher = teacher;
        this.lession = lession;
        this.time    = time;
    }
}

const html = new Courses({
    name: 'Curso de HTML y CSS',
    teacher: 'Juan Dc',
    lession: 17,
    time : '4 hora'
})


const javascript = new Courses({
    name: 'Curso de JS y POO',
    teacher: 'Juan Dc',
    lession: 17,
    time : '4 hora'
})

class LearningPath {
    
    constructor({
        name,
        courses = []
    }) {
        this.name = name,
        this.courses = courses
    }

    addCourses (newCourse) {
        this.courses.push(newCourse);
    }
}

const desarrolloWeb = new LearningPath({
    name: 'Desarrollo web',
    courses: [
       javascript,
       html
    ]
})

class Student {
    constructor({
        name,
        email,
        username,
        twitter = undefined,
        instagram = undefined,
        facebook = undefined,
        approvedCourses = [],
        learningPaths = []
    }) {
        this.name = name;
        this.email = email; 
        this.username = username;
        this.socialMedia = {
            twitter,
            instagram,
            facebook
        }
        this.twitter = twitter;
        this.instagram = instagram; 
        this.facebook = facebook;
        this.approvedCourses = approvedCourses;
        this.learningPaths = learningPaths;
    }


    addLearningPath (newPath) {
        this.learningPaths.push(newPath);
    }
}

const juan2 = new Student({
    name: 'Juan dc',
    email: 'mareo.sdgamil.com',
    twitter: 'mateofd',
    learningPaths: desarrolloWeb
})
<code> class Learnings{
    constructor({
        name,
        cursosTotal,
        cursosRuta = [],
    })
    {
        this.name = name;
        this.cursosTotal = cursosTotal;
        this.cursosRuta = cursosRuta;
    }
}

const escuelaDeDesarrolloWeb = new Learnings({
    name: "Escuela de desarrollo web",
    cursosTotal: 3,
    cursosRuta: [
        "curso definitivo de html y css",
        "curso practico de html y css",
        "curso de responsive design",
    ]
});

const  escuelaDeWordpress = new Learnings({
    name: "Escuela de wordpress",
    cursosTotal: 3,
    cursosRuta: [
        "curso definitivo de html y css",
        "curso practico de html y css",
        "curso de responsive design",
    ]
});
//------------------------- Prototipo Ruta de aprendizaje
class LearningPath{
    constructor({
        name,
        courses,
    }) {
        this.name = name;
        this.courses = courses;
    };
};
// -------------------------------------------- Instancia de ruta de aprendizaje
let escuelaDesarrolloWeb = new LearningPath({
    name: 'Escuela de desarrollo web',
    courses: [
        "Curso de Html",
        "Curso de CSS"
    ],
});
let escuelaEcommerce = new LearningPath({
    name: 'Escuela de Ecommerce',
    courses: [
        "Curso de Google Ads",
        "Curso de Marketing Digital"
    ],
});

//------------------------------------- Prototipo estudiante
class Student{
    constructor({
        name,
        email,
        username,
        facebook = undefined,
        twitter = undefined,
        instagram = undefined,
        approvedCourses = [],
        learningPath = [
            escuelaDesarrolloWeb,
            escuelaEcommerce,
        ]
    }) {
        this.name = name;
        this.email = email;
        this.username = username;
        this.socialMedia = {
            facebook,
            twitter,
            instagram,
        };
        this.approvedCourses = approvedCourses;
        this.learningPath =learningPath;
    };
    passCourse(newCourse){
        this.approvedCourses.push(newCourse);
    };
};

//--------------------------- Instancia Estudiantes
let jhon = new Student({
    name: 'jhon',
    username: 'jhonOG',
    email: '[email protected]',
    instagram: 'jhonOG',
    learningPath: [
        escuelaDesarrolloWeb
    ],
});

let esteban = new Student({
    name: 'esteban',
    username: 'estebanOG',
    email: '[email protected]',
    facebook: '@estebanortiz',
    learningPath: [
        escuelaEcommerce,
    ],
});

Esta es mi solución al reto:

class LearningPath {
  constructor({ id, title, description, courses = [] }) {
    this.id = id;
    this.title = title;
    this.description = description;
    this.courses = courses;
  }
}

class Student {
  constructor({
    name,
    email,
    surname,
    age,
    instagram = null,
    facebook = null,
    twitter = null,
    approvedCourses = [],
    learningPaths = [],
  }) {
    this.name = name;
    this.email = email;
    this.surname = surname;
    this.age = age;
    this.socialMedia = {
      instagram,
      facebook,
      twitter,
    };
    this.approvedCourses = approvedCourses;
    this.learningPaths = learningPaths;
  }
}

Anidando el uso de prototipos

class learningPaths {
    constructor({
        name,
        courses = [],
    }){
        this.name = name,
        this.courses = courses
    }
}

Lo instanciamos de la siguiente manera

const escuelaWeb = new learningPaths({
    name: "Escuela de desarrollo web",
    courses: [
        "Introduccion a javascript",
        "Curso practico de javascript"
    ]
});

Luego en nuestro prototipo de estudiantes

class Student3 {
    constructor({
        name,
        email,
        username,
        twitter =  undefined,
        instagram,
        facebook,
        approvedCourses = [],
        learningPaths,
    }){
        this.name = name;
        this.email = email;
        this.username = username;
        this.socialMedia = {
            twitter,
            instagram,
            facebook
        };
        this.approvedCourses = approvedCourses;
        this.learningPaths = learningPaths;
    }

    addCourseApproved(newCourse) {
        this.approvedCourses.push(newCourse);
    }
}

Al instanciar el objeto…

const Juan2 = new Student3({
    name: "Juan",
    username: "JuanDC",
    email: "[email protected]",
    username: "xxJuanxx",
    cursosAprobados: ["Curso de html"],
    learningPaths: escuelaWeb
});

my ejercicio

class LearningPath {
	constructor({
		namePath,
		courses = [],
		description,
	}){
		this.namePath = namePath;
		this.courses = courses;
		this.description = description;
	}
}

const webDevelopment = new LearningPath({
	namePath: 'Escuela de desarrollo web',
	courses: ['Intro Terminal','Git y gitHub','Definitivo html y css','basico js','basico React'],
	description: 'en la escuela de desarrollo web aprenderas todas las bases para ser un frontend developer'
})

const englishAcademy = new LearningPath({
	namePath: 'Academia de ingles',
	courses: ['time in english','reposition of place','Verb to be','nouns','speaking exercise'],
	description: 'En la academia de ingles podras dominar el este increible idioma, que esperas!'
})

class Student{
	constructor({
		name,
		email,
		userName,
		twitter = undefined,
		instagram = undefined,
		approvedCourses = [],
		learningPaths = [],
	}){
		this.name = name;
		this.email = email;
		this.userName = userName;
		this.socialMedia ={
			twitter,
			instagram
		}
		this.approvedCourses = approvedCourses;
		this.learningPaths = learningPaths;
	}
}

const diego = new Student({
	name: 'diego',
	userName: 'DiegoDelgadoMao',
	email: '[email protected]',
	twitter: '@diegoDelgadoMao',
	learningPaths: [webDevelopment,englishAcademy]
})

const andres = new Student({
	name: 'andres',
	userName: 'andresPastrana',
	email: '[email protected]',
	instagram: 'andres_pastrana01',
	learningPaths: [englishAcademy]
})

Esta es la clase que desarrollé, a la cual le incluí un par de métodos para agregar o eliminar áreas y niveles a cada ruta de aprendizaje, simulando la forma en la que Platzi tiene organizada cada escuela.

Mi pequeña versión :{

Bueno lo voy entendiendo cada vez mas.

class LearningPath {
    constructor({
        name,
        courses = []
    })
    {
        this.name = name;
        this.courses = courses;
    }
}

    const escuelaWeb = new LearningPath({
        name: "Desarrollo Web",
        courses: ["curso de desarrollo web con html y css", "curso de animacion con css", "curso de sistemas de diseño", "curso de css grid"],
    });

    const escuelaData = new LearningPath({
        name: "Escuela de data science",
        courses: ["curso de python", "curso de algebra lineal", "curso de estadisticas en programacion", "curso de machine learning"],
    });

class Student {
    constructor({
        name,
        email,
        username,
        twitter = undefined,
        instagram = undefined,
        facebook = undefined,
        approved = [],
        learningPaths = [],
    }
    ) {
        this.name;
        this.username= username;
        this.email= email;
        this.socialMedia = {
            twitter,
            instagram,
            facebook
        };
        this.approved = approved;
        this.learningPaths = learningPaths;
    }
};

const juan2 = new Student({
    name: "juandc",
    username: "juandc",
    email: "[email protected]",
    twitter: "jusnadc",
    learningPaths: [escuelaWeb],
});

const miguelito = new Student({
    name: "migueldc",
    username: "miegueldc",
    email: "[email protected]",
    twitter: "jmigueldc",
    learningPaths: [escuelaData],
});

quedo claro que al profe no le gusta facebook XD

//Class
class learningPaths {
    constructor({
        name,
        courses:[],
    }){
        this.name = name;
        this.courses = courses;
    }
    //Metodos Agregar Curso
    agregarCurso(newCourse){
        this.courses.push(newCourse);
    }
}
const escuelaWeb = new learningPaths(
    {
        name: 'Escuela de Desarrollo Web',
        courses:[
            'cursoJS',
            'cursoReact',
            'cursoNextJS',
        ]
    }
);
const escuelaData = new LearningPaths({
    name: "Escuela de Data Science",
    courses: [
      'cursoPython',
      'CursoMatematicas',
      'CursoExcel',
    ],
  }); 

listo he creado mi clase

class learningPaths {
c

onstructor ({
        id,
        courses = [],
        teacher,
    }) {
        this.id = id;
        this.courses = courses;
        this.teacher = teacher;
    }
}

Aquí está mi solución al reto

1. Crear una clase LearningPath:

class LearningPath {
    constructor (pathName, pathCourses) {
        this.path = {
            name: pathName,
            courses: pathCourses,
        };
    }
}

2. Crear una Instancia de esa Clase

const webDev = new LearningPath("Desarrollo Web",["curso1", "curso2"]);

3. Agregar a la lista del estudiante

estudiante1.addLearningPath(webDev.path);

Para hacer el punto 3, se debe agregar el siguiente método a la clase estudiante:

addLearningPath(newPath) {
        this.learningPaths.push(newPath);
    }

El reto terminado

Jajajaj buen spam de redes profee!!! jajaja

<code>
class LearningPaths{
    constructor({
        name,
        courses,
        horas,
    }) 
    {
        this.name = name;
        this.courses = courses;
        this.horas = horas; 
    }
  }
const desarrolloweb = new LearningPaths({
    name: "Desarrolo web",
    courses: ["html,css"],
    horas: 28,
});
const ingenieria = new LearningPaths({
    name: "Desarrolo ingenieria",
    courses: ["ing,css"],
    horas: 20,
});
//Despues lo llamo como variable

 const juan2 = new Student({
    name: "JuanDC",
    username: "juandc",
    email: "[email protected]",
    twitter: "fjuandc",
    learningPaths: desarroloweb,

  }); 
class studient {
    constructor({
        name,
        email,
        user_name,
        twitter = undefined,
        instagram = undefined,
        facebook = undefined,
        aprovedCourses = [],
        learningPaths = []
    }){
        this.name = name;
        this.email = email;
        this.user_name = user_name;
        this.social_media = {
            twitter, 
            instagram,
            facebook
        }
        this.aprovedCourses = [] = aprovedCourses,
        this.learningPaths = [] = learningPaths,
        this.points = 0
    }
    add_course_add_points(course){
        this.aprovedCourses.push(course);
        this.points += 150;
    }
    add_learningPaths(learningPath){
        this.learningPaths.push(learningPath);
        this.points += 50;
    }
    add_instagram(user){
        this.social_media.instagram = user;
        this.points += 50;
    }

    add_facebook(user){
        this.social_media.facebook = user;
        this.points += 50;
    }

    add_twitter(user){
        this.social_media.twitter = user;
    }
}

class courses{
    constructor({
        name,
        teacher,
        sessions = []
    }){
        this.name = name;
        this.teacher = teacher;
        this.sessions = [] = sessions;
    }
    add_session(session){
        this.sessions.push(session);
    }
}

class learningPaths{
    constructor({
        name,
        courses = []
    }){
        this.name = name;
        this.courses = [] = courses;
    }
    add_course(course){
        this.courses.push(course);
    }
}

let curso_basico_html_css = new courses({
    teacher: "juan david castro",
    sessions: ["que es html","principos de maquetado"],
    name: "Curso basico de html y css"
});
let curso_basico_de_javascript = new courses({
    teacher: "juan david castro",
    sessions: ["que es javascript","como funciona javascript"],
    name: "Curso basico de javascript"
});

let desarrollo_web = new learningPaths({
    name:"Escuela de desarrollo web",
    courses: [curso_basico_html_css,curso_basico_de_javascript]
});

let luis = new studient({
    name: "luis gomez ojeda",
    user_name: "luisgomezojeda_22",
});

luis.add_course_add_points(desarrollo_web.curso_basico_de_javascript.name);

luis.add_course_add_points(desarrollo_web.curso_basico_html_css);

luis.add_learningPaths(desarrollo_web.name);

luis.add_instagram("_luisgomezojeda_");


Hola, les dejo mi codigo de como difini la clase de Learning Paths 😃

class learningPaths {
    constructor ({
        name,
        courses = [],
    }) {

        this.name = name;
        this.courses = courses;

    }

    agregarCurso(nuevoCursito) {
        this.courses.push(nuevoCursito);
    }

    eliminarCurso(viejoCursito) {
        this.courses = this.courses.filter(curso => curso != viejoCursito);
    }

}
class LearningPaths{
    constructor({
        name, courses=[], coursesApproveds,
    }){
        this.name=name;
        this.courses=courses;
        this.coursesApproveds=coursesApproveds;

    }
}
const EscuelaDev=new LearningPaths({
    name:"Escuela de desarrollo web",
    courses:15,
    coursesApproveds:["Curso de maquetacion"]
});
const EscuelaData=new LearningPaths({
    name:"Escuela de Data Science",
    courses:12,
    coursesApproveds:[]
});
const EscuelaVideojuegos=new LearningPaths({
    name:"Escuela de Videojuegos",
    courses:20,
    coursesApproveds:[]
})

Con esta clase podemos crear cursos:

class course
{
  constructor
  ({
    name,
    teacher,
    lessons = []
  })
  {
    this.name = name;
    this.teacher = teacher;
    this.lessons = lessons;
  }
}

Con esta otra clase vamos a poder crear learningPaths, agregar cursos con la función addCourse y quitar los cursos específicos que querramos (escribir exactamente el nombre del curso a remover 😢)

class learningPaths
{
  constructor
  ({
    name,
    courses = [],
  })
  {
    this.name = name;
    this.courses = courses;
  }
  addCourse(name, teacher)
  {
    let nuevoCurso = new course
    ({
      name: `${name}`,
      teacher: `${teacher}`,
    });
    this.courses.push(nuevoCurso);
  }
  removeCourse(course)
  {
    let buscador = this.courses.indexOf(course);
    this.courses.splice(buscador, 1);
  }
}

Y queda más o menos asi:

const desarrolloWeb = new learningPaths
({
  name: "Escuela de desarrollo Web",
  courses: 
  [
    new course
    ({
      name: "Curso de programación básica",
      teacher: "Freddy Vega",
    }),
    new course
    ({
      name: "Curso intrducción a JavaScript",
      teacher: "Juan David Castor",
    }),
  ]
})

PD: perdonen los errores de tipeo toy cansado 😢 recien vuelvo del trabajo pero… NUNCA PARES DE APRENDER !

Esta es la solución que le di al learningPath

class learningPath {
    constructor ({
        courseName,
        lengthInHours,
        teacher,
        classesContent = [],
        requirements = [],
        reviews = [],
    }) {
        this.courseName = courseName;
        this.lengthInHours = lengthInHours;
        this.teacher = teacher;
        this.classesContent = classesContent;
        this.requirements = requirements;
        this.reviews = reviews;
    }
    addReviews(newReview) {
        this.reviews.push(newReview);
    }
    classContent(newTopic) {
        this.classesContent.push(newTopic);
    }
    classRequirements(newRequirement) {
        this.requirements.push(newRequirement);
    }
}
const dataScienceSchool = new learningPath({
    courseName: "Data Science",
    lengthInHours: 4,
    teacher: "Diego Hernandez",
    classesContent: [
        "Curso Basico de Python",
        "Curso Excel Basico"
    ],
    reviews: [
        "Great",
        "Amazing!"
    ],
    requirements: [
        "Programacion orientada a objetos"
    ],
});
const webDevelopment = new learningPath ({
    courseName: "Web Development",
    lengthInHours: 4,
    teacher: "Paco Romero",
    classesContent: [
        "Curso Basico de HTML y CSS",
        "Curso practico de HTML"
    ],
    reviews: [
        "I love it!",
        "It was amazing!"
    ],
    requirements: [
        "Programacion orientada a objetos"
    ],
});
const gitAndGithub = new learningPath ({
    courseName: "Git And Github ",
    lengthInHours: 4,
    teacher: "Paula Moreno",
    classesContent: [
        "Curso de programacion basica",
    ],
    reviews: [
        "Amazing!",
    ],
    requirements: [
        "Programacion orientada a objetos",
    ],
});

Aquí mi aporte 😄

class learningPath {
    constructor({
        courses,
        name,
    })
    {
        this.courses = courses;
        this.name = name;
    }
}

const escuelaDiseñoUx = new learningPath({
    name: "Diseño UX",
    courses:[
        "Introduccion a Figma",
        "Photoshop",
        "Curso básico de Html y css"
    ],

});

Estuve practicando con la clase persona

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

    mostrarInfo(){
        console.log(`Nombre: ${this.nombre} 
                    Apellido: ${this.apellido}`);
    }
}
<code> 

class Student {
    constructor({
        name,
        email,
        username,
        twitter = undefined,
        instagram = undefined,
        faceboock = undefined,
        aprovedCourses = [],
        learningPaths = [],
    }) {
        this.name = name;
        this.email = email;
        this.username = username;
        this.socialmedia = {
            twitter ,
            instagram,
            faceboock,
        };        
        this.aprovedCourses = aprovedCourses;
        this.learningPaths = learningPaths;
    };
};

class LearningPaths {
    constructor({
        schoolName,
        courses = [],
    }) {
        this.schoolName = schoolName;
        this.courses = courses;
    };
};

const escuelaWeb = new LearningPaths({
    schoolName: "Escuela de Desarrolloweb",
    courses: [
        "Curso definitivo HTML y CSS",
        "Curso practico HTML y CSS",
        "Responsive Design",
    ],
});
const escuelaData = new LearningPaths({
    schoolName: "Escuela de desarrollo Vgs",
    courses: [
        "Curso introductorio a la produccionde Vgs",
        "Curso unreal engine",
        "Curso Unity 3d",
    ],
});
const escuelaVgs = new LearningPaths({
    schoolName: "Escuela de Data Science",
    courses: [
        "Curso Data Business",
        "Curso DataViz",
        "Curso Tableau",
    ],
});


const juan2 = new Student ({
    name: "JuanDC",
    username: "juandc",
    email: "[email protected]",
    twitter: "fjuandc",    
    learningPaths: [
        escuelaWeb,        
        escuelaVgs,
    ],
    
});

const miguelito2 = new Student ({
    name: "Miguelito",
    username: "miguelito",
    email: "[email protected]",
    instagram: "miguelito",    
    learningPaths: [
        escuelaWeb,
        escuelaData,        
    ],
    
});

class Student {
constructor({
name,
email,
twitter = undefined,
instagram = undefined,
approvedCourses= [],
learningPaths= [],
}){
this.name=name;
this.email=email;
this.socialMedia= {
twitter,
instagram,
};
this.approvedCourses=approvedCourses;
this.learningPaths=learningPaths;
}
};

class LearningPaths {
constructor({name,teacher,time,stars}){
this.name=name;
this.teacher=teacher;
this.time=time;
this.stars=stars;
}
}

const desarrolloWeb = new LearningPaths({
name:“desarrollo web”,
time: “4 horas”,
teacher: “juan villalvazo”,
stars: 5,
})

const migel= new Student({
name:“migel”,
email:"[email protected]",
learningPaths:[desarrolloWeb]
});

//Reto
class LearningPath {
    constructor({
        name,
        courses = [],
    }) {
        this.name = name;
        this.courses = courses;
    }
};
const webDevelopment = new LearningPath({
    name: "Escuela de Desarrollo Web",
    courses: [
        "HTML",
        "CSS",
        "JS",
        "React",
    ],
});
const dataScience = new LearningPath({
    name: "Escuela de Data Science",
    courses: [
        "Matemáticas",
        "Python",
        "TensorFlow",
    ],
})

class Student3 {
    constructor({
        name,
        email,
        username,
        twitter = undefined,
        instagram = undefined,
        approvedCourses = [],
        learningPaths = [],
    }) {
        this.name = name;
        this.email = email;
        this.username = username;
        this.socialMedia = {
            twitter,
            instagram,
        };
        this.approvedCourses = approvedCourses;
        this.learningPaths = learningPaths;
    }
}

const john = new Student3({
    name: "JuanDC",
    username: "Juarg14",
    email: "[email protected]",
    twitter: "juan51",
    learningPaths: webDevelopment,
});

const mike = new Student3({
    name: "MigueDC",
    username: "Migueag14",
    email: "[email protected]",
    instagram: "miguel51",
    learningPaths: dataScience,
});

No es la version definitiva, pero aqui esta mi solucion del reto. Pienso que hay que dividirlo incluso un poco mas en la clase de “Course” para crear la separacion necesaria.

class Student {
	constructor({ namer, ager, coursesApproved, email = '@social', facebook = null, twitter = null, instagram = null, }) {
		this.name = namer;
		this.age = ager;
		this.coursesApproved = coursesApproved;
		this.email = email;
		this.socialMedia = {
			facebook,
			twitter,
			instagram,
		};
		this.learningPath = [ new LearningPath("My Courses"), ];
	}

	approveCourse(course) {
		this.coursesApproved.push(course);
	}
}


class LearningPath {
	constructor({ name }) {
		this.name = name;
		this.created_at = new Date();
		this.last_modified = this.created_at;
		this.courses = [];
	}
}

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

Adjunto mi código, en la consola me aparecen los cursos

class LearningPath{
    constructor({
        courseName,
         teacher
        }) {
        this.courseName = courseName
        this.teacher = teacher
    }
}

const videoGames = new LearningPath({
    courseName: 'Escuela de Videojuegos',
    teacher: 'Patrick',
})

const react = new LearningPath({
    courseName: 'Escuela de React',
    teacher: 'Joan',
})

class Student{
    constructor({
        name,
        email,
        username,
        twitter = undefined,
        instagram = undefined,
        facebook = undefined,
        approvedCourses = [],
        learningPaths = [],
    }){
        this.name = name
        this.email = email
        this.username = username
        this.socialMedia = {
            twitter,
            facebook,
            instagram,
        }
        this.approvedCourses = approvedCourses
        this.learningPaths = learningPaths
    }
}



const juan = new Student({
    name: 'Juan',
    username: 'juanito',
    email: '[email protected]',
    twitter: 'fjuandc',
    learningPaths: [react,]
})

const miguel = new Student({
    name: 'Miguel',
    username: 'miguelito',
    email: '[email protected]',
    twitter: 'mikelele',
    learningPaths: [videoGames, react],
})
miguel
Student {name: 'Miguel', email: '[email protected]', username: 'miguelito', socialMedia: {…}, approvedCourses: Array(0), …}
approvedCourses: []
email: "[email protected]"
learningPaths: Array(2)
0: LearningPath {courseName: 'Escuela de Videojuegos', teacher: 'Patrick'}
1: LearningPath {courseName: 'Escuela de React', teacher: 'Joan'}
length: 2
[[Prototype]]: Array(0)
name: "Miguel"
socialMedia: {twitter: 'mikelele', facebook: undefined, instagram: undefined}
username: "miguelito"
[[Prototype]]: Object```

Les comparto mi Codigo, hice clases para cursos y rutas de aprendizaje, espero les ayude :3

console.group("Practica con las Clases en JavaScript")
    //Clase Cursos
    class Courses{
        constructor({
            nameCourse,
            instructor,
            durationOfCourse,
            level,
        }){
            this.nameCourse=nameCourse;
            this.instructor=instructor;
            this.durationOfCourse=durationOfCourse;
            this.level=level;
        }
    }
    //Creacion de Cursos
    const CursoProfesionalGitYGithub=new Courses({
        nameCourse:'Curso Profesional de Git y GitHub',
        instructor:'Freddy Vega',
        durationOfCourse:'6 Horas de Contenido',
        level:'Basico'
    });


    const cursoComputacionBasica=new Courses({
        nameCourse:'Curso de Computación Básica',
        instructor:'Ricardo Celis',
        durationOfCourse:'2 Horas de Contenido',
        level:'Basico'
    })

    // Clase Rutas de Aprendizaje
    class learningPath{
        constructor({
            name,
            courses=[],
        }){
            this.name=name;
            this.courses=courses;
        }
        addCourseToLearningPath(course){
            this.courses.push(course)
        }
    }
    //Creacion de Rutas de Aprendizaje
    const escuelaDesarrolloWeb=new learningPath({
        name:'Escuela de Desarrollo Web',
    })

    //Añadiendo los cursos a la rutas de aprendizaje
    escuelaDesarrolloWeb.addCourseToLearningPath(cursoComputacionBasica);
    escuelaDesarrolloWeb.addCourseToLearningPath(CursoProfesionalGitYGithub);
    console.log(escuelaDesarrolloWeb)

    class Student2{
        constructor({
            name,
            lastName,
            instagram=undefined,
            facebooh=undefined,
            twitter=undefined,
            learningPaths=[],
            aproveCourses=[],

        }){
            this.name=name;
            this.lastName=lastName;
            this.instagram=instagram;
            this.facebooh=facebooh;
            this.twitter=twitter;
            this.learningPaths=learningPaths;
            this.aproveCourses=aproveCourses;
        }

        passCourses(courseApproved){
            this.aproveCourses.push(courseApproved);

        };

        addLearningPath(learningPath){
            this.learningPaths.push(learningPath);
        }

    }

    const eliana=new Student2({
        name:'Eliana Andréa',
        lastName:'Polo',
    });

    console.group("Eliana sin Ruta de Aprendizajes");
        console.log(eliana);
    console.groupEnd();

    eliana.passCourses(cursoComputacionBasica)

    console.group("Eliana Con una Ruta de Aprendizaje");
        eliana.addLearningPath(escuelaDesarrolloWeb);
        console.log(eliana)



console.groupEnd()```
class LearningPath{
    constructor({
        name,
        cursosAgregados = [],
        cursosEnProgreso = [],
        cursosAprobados = [],
    }){
        this.name = name;
        this.cursosAgregados = [];
        this.cursosAprobados = [];
        this.cursosEnProgreso = [];
    }
}

LearningPath.prototype.agregarCurso = function(curso){
    this.cursosAgregados.push(curso);
}

LearningPath.prototype.agregarCursoEnProgreso = function(curso){
    this.cursosEnProgreso.push(curso);
}

LearningPath.prototype.aprobarCurso = function(curso){
    this.cursosEnProgreso.splice(cursosEnProgreso.indexOf(curso), 1);
    this.cursosAprobados.push(curso);
}

const escuelaWeb = new LearningPath({
    name: "Escuela de desarrollo web",
});
const escuelaData = new LearningPath({
    name: "Escuela de data science",
});
const escuelaVideojuegos = new LearningPath({
    name: "Escuela de videojuegos",
});

class LearningPaths{
    constructor({nombre, numeroCursos, fechaCracion, areaEnseñanza}){
        this.nombre = nombre;
        this.numeroCursos = numeroCursos; 
        this.fechaCracion = fechaCracion; 
        this.areaEnseñanza = areaEnseñanza;    
    }
}

const escuelaWeb = new LearningPaths({
    nombre: "escuela de Desarrollo Web",
    numeroCursos: 174,
    fechaCracion: 2018,
    areaEnseñanza: "desarrollo Web Frontend y Backend"
});
const escuelaDataScience = new LearningPaths({
    nombre: "escuela de Data Science",
    numeroCursos: 45,
    fechaCracion: 20120,
    areaEnseñanza: "control y manejo de base de datos"
});
const escuelaVideojuegos = new LearningPaths({
    nombre: "escuela de video juegos",
    numeroCursos: 52,
    fechaCracion: 2021,
    areaEnseñanza: "creacion, planificacion de videojuegos en unity y unrealEngine"
});

Que maravilla de curso.

class Student {
  constructor({ name, email, coursesApproved = [], learningPath = [] }) {
    this.name = name;
    this.email = email;
    this.coursesApproved = coursesApproved;
    this.learningPath = learningPath;
  }
}

class LearningPath {
  constructor({ name, courses }) {
    this.name = name;
    this.courses = courses;
  }
}

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

const desarrolloWeb = new Course({ name: 'Curso de Desarrollo Web Basico' });
const desarrolloWebAdv = new Course({
  name: 'Curso de Desarrollo Web Avanzado',
});

const juanitoPath = new LearningPath({
  name: 'Desarrollo Web',
  courses: [desarrolloWeb, desarrolloWebAdv],
});
const juanito = new Student({
  name: 'Juanito',
  email: '[email protected]',
  learningPath: juanitoPath,
  coursesApproved: [desarrolloWeb],
});

class LearningPaths {
	constructor ({
		name,
		courses = [],
	}) {
	this.name = name;
		this.courses = [] = courses;
	}
}

const escuelaWeb = new LearningPaths({
	name: " Escuela de Desarrollo Web",
	courses: [
		"Introduccion al Desarrollo Web",
		"Curso intermedio de Desarrollo Web",
		"Curso Practico de Desarrollo Web",
		"Curso Profesional de Desarrollo Web",
	],
});
const escuelaData = new LearningPaths({
	name: " Escuela de Data Science",
	courses: [
		"Introduccion a Data Science",
		"Curso intermedio de Data Science",
		"Curso Practico de Data Science",
		"Curso Profesional de Data Science",
	],
});
const escuelaVgs = new LearningPaths({
	name: " Escuela de Desarrollo de Videojuegos",
	courses: [
		"Introduccion al Desarrollo Videojuegos",
		"Curso intermedio de Desarrollo Videojuegos",
		"Curso Practico de Desarrollo Videojuegos",
		"Curso Profesional de Desarrollo Videojuegos",
	],
});

Acá comparto mi solución al desafío:

Primero, creé una clase Course en la cual voy creando cada curso.

class Course {
    constructor({
        name,
        time,
        clases,
        teacher
    }){
        this.name = name;
        this.time = time;
        this.clases = clases;
        this.teacher = teacher
    }
}
const course1 = new Course({
    name: 'Curso Básico de Programación Orientada a Objetos con JavaScript',
    time: '4 horas',
    clases: 17,
    teacher: 'Juan David Castro'
})
const course2 = new Course({
    name: 'Curso de Análisis de Negocios para Ciencia de Datos',
    time: '2 horas',
    clases: 23,
    teacher: 'Sílvia Ariza Sentís'
})

Después, creo las rutas de aprendizaje:

class RutaAprendizaje{
    constructor({
        name,
        cursos = []
    }){
        this.name = name;
        this.cursos = cursos;
    }
}

const ruta1 = new RutaAprendizaje({name: 'Escuela JavaScript', cursos : [course1]})
const ruta2 = new RutaAprendizaje({name: 'Escuela Data Science', cursos : [course2]})

Y luego ya solo le envío la ruta a cada estudiante:

class Student {
    constructor({
        name,
        email,
        username,
        twitter = undefined,
        instagram = undefined,
        facebook = undefined,
        approvedCourses = [],
        learningPaths = []
    }){
        this.name = name;
        this.email = email;
        this.username = username;
        this.socialMedia = {
            twitter,
            instagram,
            facebook
        };
        this.approvedCourses = approvedCourses;
        this.learningPaths = learningPaths;
    }
}

const miguelito = new Student({
    name: 'miguelito',
    username: 'miguelitofeliz',
    email: '[email protected]',
    twitter: 'miguelito_feliz',
    learningPaths: [ruta1, ruta2]
})

Yo lo hice pero con algo así como gestión de tareas

class User {
    constructor({
        username,
        password,
        name,
        age,
        tasks = [],
        goals = [],
    }){
        
        this.username = username;
        this.password = password;
        this.name = name;
        this.age = age;
        this.tasks = tasks;
        this.goals = goals;

    }

    addTask(task,expDate){
        this.tasks.push({"task":task,"expDate":expDate});
    }
}

const usuario1 = new User({
    name:"Sancho Pancho",
    age:17,
    password: "********",
    username: "sancho503",
});

usuario1.addTask("Cocinar Pastas","3 horas");
usuario1.addTask("Estudiar Javascript","2 horas");

console.log(usuario1);

class Goal{
    constructor({
        name,
        expDate,
        goalTasks = [],
    }){
        this.name = name;
        this.expDate = expDate;
        this.goalTasks = goalTasks;
    }

    addGoalTask(task){
        this.goalTasks.push(task);
    }
}

const goal1 = new Goal({
    name: "Sacar la Basura",
    expDate: "5 horas",
});

goal1.addGoalTask("Recoger Basura del Baño");
goal1.addGoalTask("Recoger Basura de la cocina");
goal1.addGoalTask("Meter todo en una bolsa");

console.log(goal1);

usuario1.goals = goal1;

console.log(usuario1);

Y suelta esto:

Es bastante interezante, solo sabia le metodo de los objetos literales, pero con esto es mucho mas facil el asunto.

Aqui esta mi aporte, por suerte tengo acceso a la beta de GitHub copilot y me ayudo en el trabajo 😃

class RutaAprendizaje {
  constructor({ nombre, duracion, nivel }) {
    this.nombre = nombre;
    this.duracion = duracion;
    this.nivel = nivel;
  }
}

class Estudiante {
  constructor({
    name,
    age,
    email,
    twitter = undefined,
    instagram = undefined,
    facebook = undefined,
    cursosAprobados = [],
    rutasAprendizaje = [],
  }) {
    this.name = name;
    this.age = age;
    this.email = email;
    this.socialMedia = {
      twitter,
      instagram,
      facebook,
    };
    this.cursosAprobados = [];
    this.rutaAprendizaje = [];
  }
}

var DesarrolloWeb = new RutaAprendizaje({
  nombre: "Desarrollo Web",
  duracion: "3 meses",
  nivel: "Intermedio",
});
var MatematicasAvanzadas = new RutaAprendizaje({ 
    nombre: "Matematicas Avanzadas", 
    duracion: "3 meses", 
    nivel: "Intermedio" 
});

var Carlos = new Estudiante({
     name: "Carlos", 
     age: 17, 
     email: "[email protected]", 
     rutasAprendizaje = [DesarrolloWeb, MatematicasAvanzadas] 
});
class learningPaths{
    constructor({
        id,
        name,
        description,
    }){
        this.id = id;
        this.name = name;
        teacher = [];
        description = description;
    }
};

const escuelaWeb = new learningPaths({
    id = 1445,
    name = "Curso programacion orientado a objetos",
    description = "Aprenderas las bases implementadas para POO"
    
});

const escuelaData = new learningPaths({
    id = 3848,
    name = "Curso analisis de datos",
    description = "Aprenderas a gestionar los datos de una empresa",
})


class Student{
    constructor({
        name,
        email,
        username,
        twitter = undefined,
        instagram = undefined,
        facebook = undefined,
        approvedCourses = [],
        learningPaths = [],
    }){
        this.name = name;
        this.email = email;
        this.username = username;
        this.socialMedia = {
            twitter,
            instagram,
            facebook,
        };
        
        this.approvedCourses  = approvedCourses;
        this.learningPaths  = learningPaths;
    }
}

const juan2 = new Student({
    name: "juanDC",
    username: "juandc",
    email: "[email protected]",
    twitter: "fjuandc",
});

const miguelito2 = new Student({
    name: "Miguelito",
    username: "miguelitofeliz",
    email: "[email protected]",
    twitter: "miguelito_feliz",
});

class learningPath {
    constructor({
        name,
        courses = [],
    })
        {
            this.name = name;
            this.courses = courses;
        }
    agregarCurso(nuevoCurso){
        this.courses.push(nuevoCurso);
    }
}

const escuelaWeb = new learningPath({
    name: "Escuela de desarrollo web",
    courses: [
        "Curso de terminal",
        "Curso definitivo de javascript",
        "Curso definitivo de html y css",
    ],
});
const escuelaData = new learningPath({
    name: "Escuela de Ciencias de Datos",
    courses: [
        "Curso de sql",
        "Curso mongo db",
        "Curso postgressql",
    ],
});
const escuelaVgs = new learningPath({
    name: "Escuela de Video Juegos",
    courses: [
        "Curso de Unity",
        "Curso de terminal",
        "Curso ingles",
    ],
});

![](

parte del reto … decidí crear una nueva clase Courses para este ejemplo y usarlo como Objeto al crear una nueva ruta .

class LearningPath {
    constructor({

        name,
        courses = [],

    }) {
        this.name = name;
        this.courses = courses;
    }

    addCourse(course) {
        this.courses.push(course);
    }
}

class Courses {
    constructor({
        id,
        name,
        teacher,
        time,
        progress,
    }) {
        this.id = id,
        this.name = name,
        this.teacher = teacher,
        this.time = time,
        this.progress = progress
    }

}


const nuevaRuta = new LearningPath({
    name: "Escuela de desarrollo Web",
    courses: [new Courses({name:"Curso definitifo de HTML y CSS", progress: "18%"})]
})

RETO:

class StudentVersus {
    constructor({
        name,
        email,
        username,
        twitter = undefined,
        instagram = undefined,
        facebook = undefined,
        approvedCourses = [],
        learningPaths = [],
    }) {
        this.name = name
        this.email = email
        this.username = username
        this.socialMedia = {
            twitter,
            instagram,
            facebook,
        }
        this.approvedCourses = approvedCourses
        this.learningPaths = learningPaths
    }
}

class LearningPaths {
    constructor({
        name,
        courses = []
    }) {
        this.name = name
        this.courses = courses
    }
}

const dario = new StudentVersus({
    name: "dario",
    email: "[email protected]",
    username: "hdarioDev",
    twitter: "hdariodev",
    learningPaths: new LearningPaths({ name: "Escuela React ", courses: ["React intro", "React medio", "React avanzado"] })
})
console.log("-------Implementando clases ")
console.log(dario)

Reto Terminado!! 😃🥳

class LearningPath {
    constructor({
        name,
        courses = [],
    }) {
        this.name = name;
        this.courses = courses;
    }
    nuevoCurso(nuevoCursito) {
        this.courses.push(nuevoCursito);
    }
}

const EscuelaWeb = new LearningPath({
    name: "Escuela de Desarollo Web",
    courses: [
        "Curso Definitivo de HTML y CSS",
        "Curso Práctico de HTML y CSS",
        "Curso de Responsive Design",
    ]
});

EscuelaWeb.nuevoCurso("Curso de CSS Grid");

JavaScript es único.

nadie usa Facebook, quien usa Facebook , yo no uso Facebook XD

Reto Culminado

class LearningPaths {
    constructor({
        name,
        courses = [],
        difficulty,
        courseNumbers,
        percentage = undefined,
    }) {
        this.name = name;
        this.courses = courses;
        this.difficulty = difficulty;
        this.courseNumbers = courseNumbers;
        this.percentage = percentage;
    }
    addCourse(newCourse){
        this.courses.push(newCourse);
    };
};

const escuelaWeb = new LearningPaths({
    name:"Escuela desarrollo Web",
    courses: [
        "Curso Definitivo de HTML y CSS",
        "Curso Práctico de HTML y CSS",
        "Curso de Responsive Desing",
    ],
    difficulty: "Básico",
    courseNumbers: 106,
});

class LearningPath {
constructor({
nameSchool,
courses = [],
}){
this.nameSchool = nameSchool;
this.courses = courses;
}
addCourses (courses) {
this.courses.push(courses);
}
}

Asi lo resolvi quedo atento a retro!

class learningPath {
    constructor(escuela,cursos=[]){
        this.escuela=escuela;
        this.cursos=cursos;
    }

    cursosNuevos(nuevoCurso){
        this.cursos.push(nuevoCurso)
    }
} 

const CienciaDatos = new learningPath('Ciencia de datos',['Ingles'])
CienciaDatos.cursosNuevos('SEO')