Prototipos en la práctica

No entiendo nada jaja

No entiendo nada jajajaj, odio que expliquen con casos hipoteticos, por que solo escucho perro, perro, jajaja nada como que expliquen con ejercicios practicos, algo que de verdad se puede usar en un ambiente laboral.

Estas cuestiones complejas de entender a la primera o hasta abstractas tienen que explicar con gráficos o otros métodos, para que la mente no acostumbrada entienda. Leyendo los comentarios es bastante complicado para algunos compañeros. No sé si los "profesores" de Platzi toman clases de enseñar primeramente antes de dictar a miles de personas que están confiando en la plataforma. Diego de Grada es Genial, pero es un error que veo en muchos cursos de la plataforma. Parece que pusieron a sus amigos a dictar sin formación pedagógica alguna.

Mi recomendación para los que no le están entendiendo todo bien y en mi caso me ha funcionado es complementar lo que se aborda en la clase con materia externo ya sea chatgpt para conceptos o en algún sitio web con fin educativo y por ultimo repetir la clase cuando no te ha quedado del todo claro adicionalmente tomarse el tiempo para comprender y aprender estos conceptos ya que en la mayoría son abstractos. finalmente les recomiendo tener paciencia tómense el tiempo que necesiten.

En la vida real, considera una empresa que tiene un modelo de clase `Empleado`. Cada empleado tiene métodos como `trabajar` y `tomarVacaciones`. Si deseas añadir un nuevo método `recibirSalario` a un empleado específico, puedes hacerlo directamente en la instancia (por ejemplo, `empleado1.recibirSalario = function() {...}`). Sin embargo, si necesitas que todos los empleados compartan ese método, debes agregarlo al prototipo de `Empleado` con `Empleado.prototype.recibirSalario = function() {...}`. Así, todos los empleados, incluidos los que crearás en el futuro, tendrán acceso a este método. Esto ilustra cómo funciona la herencia y los prototipos en la programación orientada a objetos.

Una buena forma de hacer estas cosas sin marearse tanto es ver las cosas como un árbol en donde se hereda todo, y cuando hacemos un prototypo se hace en la base y eso va para los hijos.

Estás en el camino correcto. Los prototipos se asocian a clases y no a instancias. Al crear una clase, se genera un prototipo que contiene métodos y propiedades que las instancias heredan. La cadena de prototipos permite que las instancias busquen métodos en sus clases padres. Asegúrate de entender cómo se inyectan métodos en el prototipo de la clase, no en la instancia.

Si no entendiste, cosa que si esta a mi parecer bien explicada en el video, es que un prototype se encuentra solo en una: class o en una función constructora. Cuando quieras modificar una class o una fn constructora tienes que hacerlo mediante su ".prototype" directamente a ellas, no a una instancia. El prototype viaja de arriba hacia abajo, como una cascada de agua, lo que haya arriba moja al de abajo, a menos que le pongas paraguas pero eso ya es para otro tema(si es que existe), saludos! Mis notas de JS: <https://www.repasoactivo.com/deck-43-javascript>

Por primera vez durante dos años que empece a aprender JS al fin he entendido las clases, herencias y prototipos JAJAJA grande el profe

A mí no me costó trabajo entender. Quizá es porque ya tengo al menos un curso anterior, pero sí entiendo sin problema las cadenas de prototipos.

¿Cuál es la diferencia entre el uso de prototype y la herencia?

### **¿Qué son los prototipos en JavaScript?** Los **prototipos** en JavaScript son como una receta que le dice a los objetos cómo deben comportarse y qué propiedades o métodos pueden usar. JavaScript es un lenguaje basado en **prototipos**, lo que significa que los objetos pueden **heredar propiedades y métodos de otros objetos**. En lugar de usar clases (como en otros lenguajes), cada objeto tiene un **prototipo** del cual puede obtener características. ### 🔹 **¿Cómo funciona?** Cuando creas un objeto en JavaScript y le pides una propiedad o método, el motor de JavaScript busca primero dentro del objeto. Si no lo encuentra, revisa en su **prototipo** (y sigue subiendo en la cadena de prototipos hasta encontrarlo o hasta llegar a `null`). ### 🔹 **Ejemplo práctico en un ambiente laboral** Imagina que trabajas en una empresa y necesitas hacer un sistema de empleados. Cada empleado tiene un **nombre** y un **cargo**. Además, todos los empleados pueden **saludar**, pero cada empleado puede tener diferentes datos. En lugar de repetir la función `saludar` para cada empleado, usamos **prototipos** para definir el método una sola vez y que todos los empleados lo hereden. ✅ **Código con prototipos** ```js // 1. Creamos una función constructora para los empleados function Empleado(nombre, cargo) { this.nombre = nombre; this.cargo = cargo; } // 2. Agregamos un método al prototipo de Empleado Empleado.prototype.saludar = function() { console.log(`Hola, soy ${this.nombre} y trabajo como ${this.cargo}.`); } // 3. Creamos empleados usando la función constructora const empleado1 = new Empleado("Ana", "Desarrolladora Frontend"); const empleado2 = new Empleado("Carlos", "Diseñador UX/UI"); // 4. Llamamos al método saludar (se hereda del prototipo) empleado1.saludar(); // Salida: Hola, soy Ana y trabajo como Desarrolladora Frontend. empleado2.saludar(); // Salida: Hola, soy Carlos y trabajo como Diseñador UX/UI. ```🔹 **¿Por qué es útil esto en el trabajo?** * Evita repetir código innecesario. * Permite ahorrar memoria porque los métodos no se duplican en cada objeto. * Hace el código más limpio y fácil de mantener. Este enfoque es muy común en proyectos grandes, especialmente en JavaScript antiguo antes de que existieran las clases (`class`). Sin embargo, sigue siendo importante entender los prototipos porque **las clases en JavaScript también funcionan internamente con prototipos**.

No entiendo la ventaja o la utilidad de añadir un método desde el prototipo y no añadirlo en la clase constructora, la verdad es que la explicación de este tema es un lio, se está liando logaritmicamente a medida que lo está explicando

en los comentarios veo que la generación de cristal se queja mucho, no leo lloros XD

Me costo mucho entender esta clase. inclusive usando la opcion preguntar. mi sugerencia es buscar otro ejemplo y hacer un paso a paso con salida desde la consola y no el navegador para poder seguir la herencia en la clases, metodo e instancia.

Los Prototypes solo se Crea con las Clases || FuncionesConstructoras ; Las Instancias Nunca tienen un Prototypo ; La forma correcta de agregar un Metodo nuevo a las instancias es Agregar el Metodo al prototype de una clases || funcion\_constructora .

eres un super profesor genial gracias /// prototipos y herencias   clases y funciones construtoras /// esto son prototipos de nuestros moldes class Animal {  constructor(nombre,tipo){    this.nombre = nombre;    this.tipo = tipo;  }    // metodo    emitesonido() {        console.log("el animal emite un sonido");    } }/// esto son prototipos de nuestros moldes   class Perro  extends Animal{    constructor(nombre,tipo,raza){      super(nombre,tipo);             this.raza = raza;    }     // metodo    emiteunsondo (){        console.log("el perro ladra");    }     // metodo     corre(){        console.log(`el perro ${this.nombre} corre alegremente en el parque`)    }   } const perro1 =  new Perro("boby", "perro","labrador");console.log(perro1); perro1.corre(); perro1.nuevometodos  = function () {    console.log("esta es una nueva metoso");} perro1.nuevometodos();  // esto es para agrgar un metodo pero solo a la clase Perro.prototype.segundoMetodo = function () {    console.log(`el perro ${this.nombre} correro super rapido en el parque`);}; perro1.segundoMetodo();

Me gusto como ilustro la manera en la que encadenan prototipos, hasta ahora entiendo esta parte y como todo encadena con el objeto global. Recomiendo repasar el concepto, método, instancia ypropiedad quiza anatomia de una funcion y anatomia de un objeto para entender esta clase y desmenuzar hasta comprender o este tema sera un poco enredozo, usar IA es muy util tambien para desmenuzar y generar conceptos y ejemplos lo recomiendo mucho.

graciaas profe excelente explicación solo toca practicar mucho

Esta clase si la entendí muy poco y eso que la repeti 3 veces. Deberian crear un ejemplo más practico y no solo hipotetico.

La cadena de prototipos en JavaScript es el mecanismo que permite la herencia de propiedades y métodos entre objetos. Cuando intentas acceder a una propiedad o método de un objeto, JavaScript busca primero en el objeto mismo y, si no lo encuentra, sube por la cadena de prototipos hasta encontrarlo o llegar al final, que es `null`. Esto es fundamental para entender cómo funcionan las instancias y los métodos compartidos en la programación orientada a objetos en JavaScript.

van a entender mejor en el curso siguiente donde explica como navegar el DOM

vengo despues de masomenos mes y medio de haber terminado este curso, haciendo el curso de introduccion de patrones de diseño me di cuenta de que esta parte no quedo muy bien explicada, me atore en las penultimas clases de dicho curso, y tuve que volver aca y verme como 6 clases para poder medio entender esas clases del curso de introduccion a patrones de diseño. para dar ese salto se complica bastante, deberian mejorar un poco la ruta en ese aspecto. por que empiezan a mostrar POO en otro lenguaje, sin explicar nada de dicho lenguaje y cuesta aun mas entender sin tener bases tan solidas en este curso.

Y aqui el mismo ejemplo de mi comentario anterior pero con clases: ```js // 1. Definimos una clase Empleado class Empleado { constructor(nombre, cargo) { this.nombre = nombre; this.cargo = cargo; } // 2. Método saludar (se define una vez y se comparte entre todas las instancias) saludar() { console.log(`Hola, soy ${this.nombre} y trabajo como ${this.cargo}.`); } } // 3. Creamos empleados usando la clase const empleado1 = new Empleado("Ana", "Desarrolladora Frontend"); const empleado2 = new Empleado("Carlos", "Diseñador UX/UI"); // 4. Llamamos al método saludar empleado1.saludar(); // Salida: Hola, soy Ana y trabajo como Desarrolladora Frontend. empleado2.saludar(); // Salida: Hola, soy Carlos y trabajo como Diseñador UX/UI. ```![]()

Gente, para los que estamos empezando, yo igual que ustedes soy nuevo pero gracias a la profundizacion con ChatGPT he entendido mejor los términos confusos. Para los que dicen que esto deberia ser mas claro, entiendan que probablemente estas clases son de lo mas claro que se lo pueden entregar y en un ambiente laboral les toca si o si solucionar a ustedes, sean proactivos y reactivos, busquen por diferentes medios, la programación no es cuestion de 1 clase y ya aprendiste todo el término sino algo de iterar, buscar, leer y seguir buscando, chatGPT es el mejor para dar respuestas resumidas, explicadas lo mejor y mas desglosado posible e incluso te explica con ejemplos practicos si asi se lo pides. Menos quejas y mas acción muchachos!!! En otro comentario dejaré una explicacion que me dejó GPT con ejemplo acerca de Prototipos, ojalá les sirva!

estudien vagos XD [Herencia y la cadena de prototipos - JavaScript | MDN](https://developer.mozilla.org/es/docs/Web/JavaScript/Inheritance_and_the_prototype_chain)

Para entender los prototipos en JavaScript sin usar animales, consideremos un ejemplo de gestión de usuarios. 1. **Definición de Constructor**: Creamos un constructor para un `Usuario`. ```javascript function Usuario(nombre, edad) { this.nombre = nombre; this.edad = edad; } ``` 2. **Agregar Método al Prototipo**: A la función del constructor le añadimos un método para saludar. ```javascript Usuario.prototype.saludar = function() { console.log(`Hola, soy ${this.nombre} y tengo ${this.edad} años.`); }; ``` 3. **Crear una Instancia**: Creamos un nuevo usuario. ```javascript const usuario1 = new Usuario('Carlos', 30); ``` 4. **Llamar a Método**: Usamos el método `saludar`. ```javascript usuario1.saludar(); // Salida: Hola, soy Carlos y tengo 30 años. ``` 5. **Cadena de Prototipos**: Si creamos otro usuario, heredará el método `saludar`. ```javascript const usuario2 = new Usuario('Ana', 25); usuario2.saludar(); // Salida: Hola, soy Ana y tengo 25 años. ``` Este ejemplo ilustra cómo los prototipos permiten compartir métodos entre instancias, facilitando la reutilización de código.

sirve mucho hacer proyectos para entender donde utilizaríamos estos temas. Por ejemplo viendo estos temas de herencia me digo a mi mismo, ahh ok esto me serviría para algo en especifico de mi proyecto.

Recomendacion: no arranquen con JS sin tener bases de algoritmos, POO, y logica, platzi tiene cursos, NO TE LOS SALTES, sino hay clases que no vas a entender. Incluso podrías despues de aprender las bases de lo que mencione seguir con un lenguaje como c, c# o java y despues saltar a Java

dejo por aca el codigo mostrado en el video para la parte de los prototipos:let currentPrototype = Object.getPrototypeOf(perro1);for ( ; currentPrototype !== null; currentPrototype = Object.getPrototypeOf(currentPrototype)) { console.log(currentPrototype);} ```js let currentPrototype = Object.getPrototypeOf(perro1); for ( ; currentPrototype !== null; currentPrototype = Object.getPrototypeOf(currentPrototype)) { console.log(currentPrototype); } ```

La **cadena de prototipos** es como una escalera o una serie de "niveles" donde JavaScript busca propiedades y métodos cuando intentas acceder a algo en un objeto. * Si una propiedad o método **no está en el propio objeto**, JavaScript sube al siguiente nivel: su **prototype**. * Si tampoco está allí, sigue subiendo por los prototipos hasta llegar al final de la cadena (donde aparece `null`, que indica que no hay más prototipos).

Pero creo que seria una mejor practica agregar el nuevo metodo a la clase directamente, en este casi a la clase perro, tengo esa inquietud

Yo estaba frustrado conmigo mismo por ver la clase mas de 5 veces sin evitar disociar o entender... luego leí los comentarios y entendí que no estoy solo 🥲🙁

Los prototipos en JavaScript son un mecanismo fundamental para la herencia. Cada objeto en JavaScript tiene una propiedad interna llamada `[[Prototype]]`, que se refiere a otro objeto. Cuando intentas acceder a una propiedad de un objeto, JavaScript primero busca en el objeto mismo. Si no la encuentra, sigue buscando en el objeto al que apunta su prototipo, creando así una cadena de prototipos. Para agregar métodos o propiedades a un prototipo, se utiliza `Constructor.prototype`. Esto permite que todas las instancias de un objeto compartan métodos, optimizando el uso de memoria. Por ejemplo: ```javascript function Perro(nombre) { this.nombre = nombre; } Perro.prototype.ladrar = function() { console.log(`${this.nombre} dice guau!`); }; const perro1 = new Perro('Rex'); perro1.ladrar(); // Rex dice guau! ``` En este caso, `ladrar` es un método heredado de `Perro.prototype`, accesible desde cualquier instancia de `Perro`.

Lo ultimo, cuando pego el codigo let currentPrototype, me perdiiiiiiiiiiiiiiiiiiiiii, rayos.. tan bien que estaba.

Es la mejor explicación de herencia prototípica que he escuchado. Siempre que intentaba entenderlo en otros lugares nunca me terminaba por quedar claro.

muy mal explicada la ultima mitad del video, el concepto de clases, herencias y prototipo de por si es complicado como para simplemente mencionarlo mientras se señala una consola llena de palabras abstractas, este tipo de conceptos deberían llevar más preparación y material de apoyo como gráficas, animaciones o ejercicios más elaborados con un debug paso a paso. confié en esta plataforma por ser un emprendimiento Colombiano, pero estas clases ultimas clases no se diferencias mucho de un tutorial gratis en Youtube. estamos haciendo una inversión y queremos verlo reflejado en la rigurosidad de las clases, pedagogía y materia de apoyo en las clases, y Diego se ve que es muy bueno para JS pero no es muy bueno para enseñar

😵‍💫

## Generación de nuevos métodos en instancias y clases en JavaScript * Al trabajar con instancias en JavaScript, puede surgir la necesidad de añadir nuevos métodos específicos a ciertas instancias. * Un método en JavaScript es básicamente una función asociada a un objeto. * Se puede agregar un nuevo método a una instancia específica de la siguiente manera:perro1.nuevoMetodo = function() { console.log("Este es un método."); }; * Al guardar y llamar `perro1.nuevoMetodo()`, el mensaje "Este es un método." se imprimirá en la consola. ## Limitaciones de métodos añadidos a instancias * Agregar métodos directamente a una instancia no los hace accesibles para otras instancias de la misma clase. * Esto se debe a que el método agregado directamente a una instancia no se refleja en la clase constructora o en otras instancias. * Por ejemplo, si se tiene otra instancia `perro2`, esta no tendrá el método `nuevoMetodo` definido en `perro1`. ## Uso del prototipo para agregar métodos * Para que un método sea accesible a todas las instancias de una clase, debe agregarse al prototipo de la clase. * En JavaScript, cada función constructora tiene un prototipo, y las instancias creadas con esa función constructora heredan métodos y propiedades del prototipo. * Para agregar un método al prototipo de una clase constructora, se hace de la siguiente manera:Perro.prototype.segundoMetodo = function() { console.log("Este es otro nuevo método."); }; * Al agregar el método de esta manera, todas las instancias de `Perro`, como `perro1` y `perro2`, tendrán acceso a `segundoMetodo`. ## Importancia de entender la cadena de prototipos * La cadena de prototipos en JavaScript es el mecanismo que permite la herencia de propiedades y métodos entre objetos. * Cuando se llama a un método en una instancia, JavaScript busca ese método en la instancia misma. Si no lo encuentra, busca en el prototipo de la clase constructora, y así sucesivamente a lo largo de la cadena de prototipos. * Este proceso se puede ilustrar con el siguiente código:let prototipoActual = Object.getPrototypeOf(perro1); while (prototipoActual) { console.log(prototipoActual); prototipoActual = Object.getPrototypeOf(prototipoActual); } * Este código imprime cada nivel de la cadena de prototipos, comenzando con el prototipo de `perro1` y ascendiendo hasta `null`. ## Resumen * Añadir métodos a instancias específicas es útil para necesidades particulares, pero no se heredan a otras instancias. * Para métodos que deben estar disponibles en todas las instancias de una clase, se deben agregar al prototipo de la clase constructora. * La cadena de prototipos permite la herencia de métodos y propiedades, facilitando la reutilización de código y la organización de la lógica en JavaScript.

Un consejo que daría al Team de Platzi seria dividir esta sección del curso en varias clases mas cortas, dado que se da mucha información bastante abstracta para las personas que estan empezando en su proceso de aprendizaje en desarrollo de software. Lo ideal seria dividir la seccion del curso de Programación orientada a objetos en unas pocas clases mas, en las que se explique mediante diagramas y ejemplos mas practicos y dinamicos. La forma en la que lo explica Diego está bien, pero me da la sensación de que no se pone en la posicion de alguien que recien esta empezando, cuando uno ya es profesional del sector le puede resultar sencillo y obvio pero no es así para mucha gente. Es por eso que dividir el contenido en 4 o 5 clases mas cortas con ejrcicios a realizar podria mejorar el entendimiento de esta sección. Un saludo al Team de Platzi y nunca paremos de aprender 😊👌

Entendi esto: `prototype` es una propiedad que apenas las funciones constructoras la poseen. O sea, los objetos, que seria `perro1` en el ejemplo, no tienen esta propiedad. Pero si usamos el metodo `Object.getPrototypeOf`, debido al **prototype chain**, va a retornar el prototype de la clase de `perro1`; es decir, el prototype de `Perro`, que seria `Animal`.

```js class PrimeroB { constructor(nombre, apellido, sexo, edad, estatura, calificacionMatematicas) { this.nombre = nombre; this.apellido = apellido; this.sexo = sexo; this.edad = edad; this.estatura = estatura; this.calificacionMatematicas = calificacionMatematicas; // Esta es la propiedad } mostrarCalificacionMatematicas() { // El nombre del método debe ser diferente console.log(`Esta es tu calificación en Matemáticas: ${this.calificacionMatematicas} del niño ${this.nombre}`); } } class CalificacionEspañol extends PrimeroB { constructor(nombre, apellido, sexo, edad, estatura, calificacionMatematicas, calificacionEspañol) { super(nombre, apellido, sexo, edad, estatura, calificacionMatematicas); this.calificacionEspañol = calificacionEspañol; // Nueva propiedad para calificación en Español } mostrarCalificacionEspañol() { console.log(`Esta es tu calificación en Español: ${this.calificacionEspañol} del niño ${this.nombre}`); } } // Creando un objeto de la clase CalificacionEspañol const alumno = new CalificacionEspañol("Alejandro", "Sánchez", "Masculino", 30, 1.75, 9, 8); // Mostrando las calificaciones alumno.mostrarCalificacionMatematicas(); // Esta es tu calificación en Matemáticas: 9 del niño Alejandro alumno.mostrarCalificacionEspañol(); // Esta es tu calificación en Español: 8 del niño Alejandro ```class PrimeroB { constructor(nombre, apellido, sexo, edad, estatura, calificacionMatematicas) { this.nombre = nombre; this.apellido = apellido; this.sexo = sexo; this.edad = edad; this.estatura = estatura; this.calificacionMatematicas = calificacionMatematicas; // Esta es la propiedad } mostrarCalificacionMatematicas() { // El nombre del método debe ser diferente console.log(`Esta es tu calificación en Matemáticas: ${this.calificacionMatematicas} del niño ${this.nombre}`); } } class CalificacionEspañol extends PrimeroB { constructor(nombre, apellido, sexo, edad, estatura, calificacionMatematicas, calificacionEspañol) { super(nombre, apellido, sexo, edad, estatura, calificacionMatematicas); this.calificacionEspañol = calificacionEspañol; // Nueva propiedad para calificación en Español } mostrarCalificacionEspañol() { console.log(`Esta es tu calificación en Español: ${this.calificacionEspañol} del niño ${this.nombre}`); } } // Creando un objeto de la clase CalificacionEspañol const alumno = new CalificacionEspañol("Alejandro", "Sánchez", "Masculino", 30, 1.75, 9, 8); // Mostrando las calificaciones alumno.mostrarCalificacionMatematicas(); // Esta es tu calificación en Matemáticas: 9 del niño Alejandro alumno.mostrarCalificacionEspañol(); // Esta es tu calificación en Español: 8 del niño Alejandro

Resumen **Cuando agregas una propiedad** <u>Uso de prototype: Solo en class </u> Perro.prototype.tamaño="Pequeño" <u>Obtener el valor de prototype en un objeto puntual</u> console.log(perro1.tamaño) = Pequeño <u>Si quiero agregarle una característica específica a perro1</u> perro1.ojos="Grande" console.log(perro1)= { nombre: a , raza:b, ojos: grande} **Cuando agregas un método** <u>Uso de prototype: Solo en class </u> Perro.prototype.sonido=function () {console.log( `El perro de raza ${this.raza} ladra`} <u>Obtener el valor de prototype en un objeto puntual</u> perro1.sonido() = `El perro de raza cocker ladra` <u>Si quiero agregarle una característica específica a perro1</u> perro1.tipoJuego=function(){console.log(`Juega solo con con pelotas`}

Continuación de la clase anterior 

tengo una duda, al profesor Diego no le aparece segundoMetodo() cuando hace el llamado de perro.prototype pero cuando hice mi codigo si me apare el metodo que añadi a mi clase anexo imagenes: Este es mi codigo   y cuando hago el llamado a mesa.prototype en la consola me aparece el metodo entre los metodos 

HERENCIA Y LA CADENA DE PROTOTIPOS En programacion, herencia se refiere a transmitir caracteristicas de un padre a un hijo para que un nuevo fragmento de codigo pueda reutilizarse y desarrollarse a partir de las caracteristicas de uno existente. JavaScript implementa la herencia mediante el uso de objetos. Cada objeto tiene un enlace interno a otro objeto llamado prototype (prototipo). Ese objeto prototipo tiene un prototipo propio, y asi sucesivamente hasta llegar a un objeto con null como prototipo. Por definicion null no tiene prototipo y actua como el eslabon final en esta cadena de prototipos. Es posible mutar cualquier miembreo de cadena de prototipos o incluso intercambiar el prototipo en tiempo de ejecucion.

# Resumen de la clase Hola a todos, aquí les comparto mi resumen de esta clase! [Aquí encuentras el enlace al tema de la cadena de prototipos que menciono en los apuntes](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Inheritance_and_the_prototype_chain) 

Buenos días a todos. Para aquellos que aún les queda un poco complicado asimilar los conceptos de POO, aquí les dejo este video que me ayudó a comprender mejor --> <https://youtu.be/SI7O81GMG2A?si=5zCwiMEzWfLBVJJb> Como consejo, no se quejen del material o forma de enseñar del profesor de Platzi (es general, para cualquier curso), ya que ellos hacen su mayor esfuerzo por compartir esos conocimientos complejos a nosotros de la forma más sencilla posible. No es tan fácil desmenuzar conceptos técnicos y entregarlos procesados a un estudiante para que los comprenda nativamente. El conocimiento y la adquisición de habilidades requiere constante práctica. Además, en ninguna parte podríamos encontrar una metodología que se adapte a cada una de las formas que tenemos de aprender. Recordemos que cada persona aprende de forma distinta, hay personas más visuales, otras más auditivas, otras que incluso aprenden solo leyendo. Platzi enseña a miles de personas en muchos países, y es prácticamente imposible cubrir a plenitud todas las necesidades a nivel de aprendizaje que tenemos los estudiantes. Sé que el Team Platzi hace su mayor esfuerzo por entregarnos cursos de calidad e información valiosa, sin embargo, no significa que el curso en cuestión sea perfecto para todos (respecto a la forma en que se enseña), por lo que mencioné anteriormente sobre la manera en que individualmente aprendemos. Si algo no nos quedó muy claro o no entendemos muy bien, podemos buscar recursos adicionales en YouTube, IA, lecturas, documentación oficial, entre otros. Esto no es para nada malo, por el contrario, de eso se trata el aprendizaje: no solo de recibir la información que nos da la escuela o la universidad (en este caso, Platzi), sino también de aplicarla y complementarla por nuestra cuenta. La mejor forma de aprender, según mi experiencia, es absorber conocimiento de varios recursos para tratar de asegurar tanto como sea posible, no esperar que nos entreguen todo hecho y listo. ¿Que por qué estamos pagando, entonces? Platzi nos ofrece la posiblidad de aprender de diversos temas alrededor de varios campos laborales desde la comodidad de nuestra casa, a un precio considerablemente económico (teniendo en cuenta las otras opciones en el mercado), certificación y demás. Ah, que otras plataformas o academias también ofrecen lo mismo, puede que sí, pero también existirá el tema de que "los cursos están incompletos", "no explican bien", "para qué estoy pagando si me toca ver videos en youtube porque no entiendo". Vuelvo y digo, en ninguna parte vamos a encontrar el curso o el profesor perfecto que cubra todo lo que queremos y como lo queremos. Tengamos en cuenta el esfuerzo y el tiempo que hay detrás de cada curso. Tampoco estoy diciendo que no se pueda ofrecer retroalimentación o que no haya puntos de mejora, ¡por supuesto que los hay! Pero creo que una cosa muy distinta es pretender que no haya que buscar más recursos o leer documentación o ver otros tutoriales porque Platzi me lo va a dar todo en la boca, eso ya me parece un poco absurdo. Tanto en la universidad como en academias te dan el material y la teoría, el resto lo practicas y complementas tú por tu cuenta. Y recuerda, la mejor forma de aprender es haciendo, llevando todo el conocimiento teórico a la práctica, no esperando que esté todo condensado en un solo lugar solo porque "pagué". Feliz día y, ¡Nunca pares de aprender! <3