Aún no tienes acceso a esta clase

Crea una cuenta y continúa viendo este curso

Objetos literales y prototipos en JavaScript

5/17
Recursos

Aportes 57

Preguntas 23

Ordenar por:

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

Prototipos (Prototypes)
JavaScript es un lenguaje basado en prototipos, por lo tanto entender el objeto prototype es uno de los conceptos más importantes que los profesionales de JavaScript necesitan saber. Este artículo te dará una breve descripción del objeto prototype a través de varios ejemplos. Antes de leer este artículo, deberás tener un entendimiento básico de la referencia this en JavaScript.

Objeto prototype
En honor a la claridad, vamos a examinar el siguiente ejemplo:

function Punto2D(x, y) {
  this.x = x;
  this.y = y;
}

Al declararse la función Punto2D, una propiedad predeterminada llamada prototype será creada para ella (ten en cuenta que, en JavaScript, una función es también un objeto). La propiedad prototype es un objeto que contiene una propiedad constructor y su valor es la función Punto2D: Punto2D.prototype.constructor = Punto2D. Y cuando tú llamas a Punto2D con la palabra reservada new, los objetos recién creados heredarán todas las propiedades de Punto2D.prototype. Para verificar esto, puedes agregar un método llamado mover en Punto2D.prototype de la siguiente manera:

Punto2D.prototype.mover  = function(dx, dy) {
  this.x += dx;
  this.y += dy;
}

var p1 = new Point2D(1, 2);
p1.mover (3, 4);
console.log(p1.x); // 4
console.log(p1.y); // 6

El Point2D.prototype es llamado objeto prototipo o prototipo del objeto p1 y de cualquier otro objeto creado con la sintaxis new Point2D(…) . Puedes agregar tantas propiedades al objeto Point2D.prototype como quieras. Lo que suele hacerse es declarar métodos en Point2D.prototype y otras propiedades se declararán en la función constructora.

Los objetos integrados en JavaScript se construyen de manera similar. Por ejemplo:

El prototipo de los objetos creados con la sintaxis new Object() o {} es Object.prototype
El prototipo de los arreglos creados con la sintaxis new Array() o [] es Array.prototype
Y es igual con otros objetos integrados como Date y RegExp.
Object.prototype es heredado por todos los objetos y no tiene prototipo (su prototipo es null)

Cadena de prototipos

El mecanismo de la cadena del prototipo es simple: cuando accede a una propiedad p en el objeto obj, el motor de JavaScript buscará esta propiedad dentro del objeto obj. Si el motor falla en la búsqueda, continúa buscando en el prototipo de objeto obj y así sucesivamente hasta llegar a Object.prototype. Si finalizada la búsqueda no se ha encontrado nada, el resultado será undefined. Por ejemplo:

var obj1 = {
  a: 1,
  b: 2
};

var obj2 = Object.create(obj1);
obj2.a = 2;

console.log(obj2.a); // 2
console.log(obj2.b); // 2
console.log(obj2.c); // undefined

En el fragmento de código anterior, la declaración var obj2 = Object.create(obj1) creará el objeto obj2 con el objeto prototipo obj1. En otras palabras, obj1 se convierte en el prototipo de obj2 en lugar de Object.prototype por defecto. Como puedes ver, bno es una propiedad de obj2, pero puedes acceder a ella a través de la cadena de prototipos. Sin embargo, para la propiedad c, se obtiene un valor undefined porque no se puede encontrar en obj1 y en Object.prototype.

Al crear el prototype aprobarCurso, quería ahorrarme un par de palabras y use una arrow function. Por supuesto me mando error.

Student.prototype.aprobarCurso = (nuevo) => {
    this.cursosAprobados.push(nuevo)
}

-Se debe a que las arrow function no tienen THIS. 🙂

¿Qué es un literal?
La definición de literal alude a algo textual, por ejemplo, si declaramos una variable de la siguiente manera:

let colorDelSol = "Amarillo";

Podemos decir la variable colorDelSol tiene asignada un string literal ya que se asigna el valor textualmente.

Exactamente lo mismo ocurre con los objetos literales, por ejemplo:

let perro = {
   nombre:"Scott",
   color:"Cafe",
   edad: 5,
   macho: true
};

Donde:

El nombre del objeto es perro y sus claves/valores se describen en la siguiente tabla:

Clave Valor Tipo de dato
nombre Scott string
color Cafe string
edad 5 int
macho true bolean

Los tipos de datos que puede almacenar un objeto pueden ser strings, enteros, boleanos, inclusive otros objetos.

Acceder a valores de un objeto
Existen 2 maneras simples para poder acceder a los valores de un objeto:

Notación de punto
Consiste en escribir el nombre del objeto seguido de un punto y el nombre de la propiedad a la cual se quiere acceder: objeto.clave

let perro = {
   nombre:"Scott",
   color:"Cafe",
   edad: 5,
   macho: true
};

console. info (perro.nombre); // Scott
console. info(perro.edad); // 5
Notación de corchetes / llaves cuadradas o brackets
Consiste en escribir el nombre del objeto anteponiendo entre corchetes la clave a la que se quiere acceder: objeto[clave]

let perro = {
   nombre:"Scott",
   color:"Cafe",
   edad: 5,
   macho: true
};


console.info(perro['nombre']); // Scott
console.info(perro['edad']);  // 5

Ambas maneras retornan los mismos resultados, por lo tanto se pueden considerar homónimas, pero en la práctica se acostumbra a usar más la notación de punto.

Métodos en un objeto
Un objeto no solo se limita a la agrupación de claves valores, es posible también incorporar métodos de la siguiente manera:

let perro = {
   nombre:"Scott",
   color:"Cafe",
   edad: 5,
   macho: true,
   ladrar: function(){
     return(`${this.nombre} puede ladrar`)
   }

};

console.log(perro.ladrar()); // Scott puede ladrar

Inserción de nuevos campos a un objeto
Para agregar nuevos campos al objeto solo basta con mencionar el nombre del objeto seguido de la propiedad nueva y el valor nuevo a insertar: perro.tamaño = “Grande”;

let perro = {
   nombre:"Scott",
   color:"Cafe",
   edad: 5,
   macho: true,
   ladrar: function(){
     return(`${this.nombre} puede ladrar`)
   },

};

perro.tamaño = "Grande";
console.log(perro);
/*
[object Object] {
  color: "Cafe",
  edad: 5,
  ladrar: function(){
     return(`${this.nombre} puede ladrar`)
   },
  macho: true,
  nombre: "Scott",
  tamaño: "Grande"
}
*/

Con ellos conseguiremos agregar un nuevo valor al objeto.

Actualizar campos del objeto
Basta con sobre escribir una propiedad ya existente, de la siguiente manera:

let perro = {
   nombre:"Scott",
   color:"Cafe",
   edad: 5,
   macho: true,
   ladrar: function(){
     return(`${this.nombre} puede ladrar`)
   },

};

perro.edad = 8;
console.log(perro);
/*
[object Object] {
  color: "Cafe",
  edad: 8,
  ladrar: function(){
     return(`${this.nombre} puede ladrar`)
   },
  macho: true,
  nombre: "Scott"
}
*/

Eliminación de campos
Para borrar una propiedad de un objeto se utiliza la palabra reservada delete de la siguiente manera:
delete nombre_del_objeto.clave;
Por ejemplo:

let perro = {
   nombre:"Scott",
   color:"Cafe",
   edad: 5,
   macho: true,
   ladrar: function(){
     return(`${this.nombre} puede ladrar`)
   }

};

delete perro.color;
console.log(perro);
/*
let perro = {
   nombre:"Scott",
   color:"Cafe",
   edad: 5,
   macho: true,
   ladrar: function(){
     return(`${this.nombre} puede ladrar`)
   },

};
*/




Veo mucha luz en este curso. Estaba en la Escuela De JavaScript y este curso no está allí. Vine a la escuela de desarrollo web y si está.
Cuando intenté ver el curso de JavaScript Profesional no entendía nada, pero Juan lo ha hecho mucho más fácil en este curso. Debería también estar este en la escuela de JavaScript.

12 videos menos para salir de la caverna…

Genial, no sabía que se podían declarar funciones de una manera más limpia en los objetos literales.

//* Objeto literal
const ximena = {
  name: 'Ximena',
  age: 21,
  hermosa: true,
  cursosAprobados: [
    "Curso de introducción al Marketing Digital",
    "Curso de Community Manager"
  ],
  aprobarCurso(nuevoCursito) {
    this.cursosAprobados.push(nuevoCursito);
  },
};


//* Prototipo
function Student(name, age, cursosAprobados) {
  this.name = name
  this.age = age
  this.cursosAprobados = cursosAprobados
};

//* Nueva manera de escribir funciones
Student.prototype.aprobarCurso = function(nuevoCursito){
  this.cursosAprobados.push(nuevoCursito)
};

const miguel = new Student(
  "Miguel Ángel",
  22,
  ['Básico de React', 'Profesional de JS']
);

Algo muy importante es que de la primera manera en la que Juan creó la función aprobar curso (dentro de la función constructora) NO es una buena práctica, ya que de esa manera todas las instancias de Student heredarían esa función, lo que a futuro afectaría el rendimiento, lo mejor es hacerlo de la segunda forma (Directamente al prototipo) para evitar ese consumo innecesario de recursos 😃

Al fin estoy entiendo que era todo eso de object y proto que sale en la consola, lo había visto ya en varios cursos pero nunca tocaban ese tema.

I know is a little bizarre, but this is the practice code that I made to test everything related to classes build with functions.

function Classer(namer) {
	this.name = namer;
	this.perro = '@perro';
	this.ojo = () => 'go go power ranger';
}

Classer.prototype.joeCarter = function (ohYeah) {
	return 'Oh Yeah! ' + ohYeah;
}

const literalObj = {
	name: 'center',
	joeCarter() {
		return 123;
	}
};

const litClasser = new Classer('Tesla');

Googleen todos los conceptos y busquenlos en w3school o mozilla Developer y el conocimiento se fija muy bien cuando hacen eso. ;D

A un objeto tambien podemos entrar a traves de la notacion de corchetes [], esto es de gran ayuda si por ejemplo no sabemos que valor vamos a añadir, podria ser el caso de que una funcion reciba como argumento una nueva propiedad

Creo que les puede ayudar un poco esta informacion POO MDN

**CODIGO CON APUNTES **
Literal object, prototype object, instance


//Un objeto literal, Literal Object
const natalia = {
    name: 'natalia',
    age: 20,
    approvedCourse: [
        'Curso definitivo de HTML y CSS', 'Curso practico de HTM y CSS'
    ],
    passCourse(newCourse) {
      this.approvedCourse.push(newCourse);
    },
};
 
//Un prototipo de objeto para crear n obejetos 

function Student (name, age, approvedCourse) {
    this.name = name;
    this.age = age;
    this.approvedCourse = approvedCourse;

    // *** Metodo adentro del del prototipo de objeto ***/
    //this.passCourse = function (newCourse)  {
    //    this.approvedCourse.push(newCourse);
    //}
}
//Una forma nueva de definir el metodo fuera del del prototipo

    Student.prototype.passCourse = function (newCourse)  {
        this.approvedCourse.push(newCourse);
    }

// Creamos una instancia del prototipo Student 

const steve = new Student(
    'Steve Licona',
    35,
    [
    'Introducción a la POO', 'POO con JavaScript', 'JavaScript Practico'
    ],

) 

El código de la clase probado y listo para usar:

const natalia = {
  name: "Natalia",
  age: 20,
  cursosAprobados: [
    "Curso Definitivo de HTML y CSS",
    "Curso Practico de HTML y CSS"
  ],
  aprobarCurso(nuevoCurso) {
    this.cursosAprobados.push(nuevoCurso);
  }
}

natalia.aprobarCurso("Curso de CSS Grid");

function Student (name, age, cursosAprobados) {
  this.name = name;
  this.age = age;
  this.cursosAprobados = cursosAprobados;
  // this.aprobarCurso = fucntion (nuevoCurso) {
  //   this.cursosAprobados.push(nuevoCurso);
  // }
}

Student.prototype.aprobarCurso = function (nuevoCurso) {
  this.cursosAprobados.push(nuevoCurso);
}

const juanita = new Student(
  "Juanita de Arcos",
  15,
  [
    "Curso de introduccion a los videojuegos",
    "Curso de creacion de personajes",
  ],
);

juanita.aprobarCurso("Curso de Unreal Engine");

También podemos acceder a la propiedad de un objeto literal a través de la notación de corchetes [] y lo que haya dentro debe ser entre comillas a excepción de que sea una variable
_Ejemplo
_

natalia[“age”]
//Devolverá la edad de natalia

JavaScript es a menudo descrito como un lenguaje basado en prototipos - para proporcionar mecanismos de herencia, los objetos pueden tener un objeto prototipo, el cual actúa como un objeto plantilla que hereda métodos y propiedades.

Un objeto prototipo del objeto puede tener a su vez otro objeto prototipo, el cual hereda métodos y propiedades, y así sucesivamente. Esto es conocido con frecuencia como la cadena de prototipos, y explica por qué objetos diferentes pueden tener disponibles propiedades y métodos definidos en otros objetos.

Bien, para ser exactos, los métodos y propiedades son definidos en la propiedad prototype, que reside en la función constructora del objeto, no en la instancia misma del objeto.

En JavaScript, se establece un enlace entre la instancia del objeto y su prototipo (su propiedad proto, la cual es derivada de la propiedad prototype sobre el constructor), y las propiedades y metodos son encontrados recorriendo la cadena de prototipos.

Nota: Es importante entender que, tanto el prototipo de la instancia de un objeto (al cual se accede mediante Object.getPrototypeOf(obj), o a través de la propiedad proto) como el prototipo que contiene el constructor (que se encuentra en la propiedad prototype del constructor) hacen referencia al mismo objeto.

De pronto para los que no entendieron la parte del this, les dejo este breve articulo a como yo lo entendi.

Objeto This

Es un objeto especial que hace referencia al contexto en el que se esta ejecutando la función.

Lo que hace es apuntar a la referencia del objeto literal creado ejemplo.

const nathy = {
    name: 'natalia',
    age: function () {
        document.addEventListener('click', (event){
            this.name
            /*sin embargo esto no va a hace referencia al name del
            objeto nathy ya como que this apunta al contexto de referencia de la
            funcion this terminara apuntando a document.*/
        })
    }
}

Es decir this apunta a la referencia del contexto del cuál se ejecute. Actualmente hay diferentes maneras con las (arroy funtions ) de apuntar directamente a la referencia del objeto y no a la referencia de donde se ejecuta dicho contexto.


const nathy = {
    name: 'natalia',
    age: function () {
        document.addEventListener('click', event => this.name)
    }
}

El operador => de las arrow función trae implicitame un metodo que permite apuntar directamente al objeto literal nathy.

Excelente clase, tanto esta como la anterior me encantaron 😄

Primer Prototipo:

fin Primera forma de trabajar con los prototipos

Llamando a una funcion por fuera de la primera function usando prototipe



function student1(name , age , cursosAprobados){
    this.name= name;
    this.age =  age;
    this.cursosAprobados = cursosAprobados;
    this.aprobarCursos = function(nuevoCurso){
        this.cursosAprobados.push(nuevoCurso);
    }
    // this.cursosAprobados.push()
}

function student2(name , age , cursosAprobados){
    this.name= name;
    this.age =  age;
    this.cursosAprobados = cursosAprobados;
   
}

student2.prototype.aprobarCursos=function(nuevoCurso){
    this.cursosAprobados.push(nuevoCurso);

}
const Monica = new student1('Monica' , 28 , ['JS basico' , 'python avanzado']);
const Juanita =  new student2('Juanita' , 28 , ['JS basico' , 'python avanzado']);

class student {
    constructor(nameUser,age){
        this.nameUser = nameUser;
        this.age = age;
        this.cursosAprobados = [];
        this.puntos = 0;
    }

    sumar_curso(curso){
        this.cursosAprobados.push(curso);
        this.puntos += 150;
    }
}

Tengo entendido que la function () { } tiene acceso al mismo this que el ejemplo que utiliza el objeto literal.

Good class! Teacher JuanDC has a funny and clear way to teach.

Si no estoy mal la nueva sintaxis para crear clases en JS es asi:

Obteto literal

const natalia = {
    name: 'Natalia',
    age: 20,
    cursosAprobados: [
        'Curso Definitivo de HTML y CSS',
        'Curso Practico de HTML y CSS',
    ],

    aprobarCurso(nuevoCurso) {
        this.cursosAprobados.push(nuevoCurso);
    }
};

    // Hacer que natalia apruebe otro curso

natalia.cursosAprobados.push('Curso de Responsive Design');

console.log(natalia);

Prototipo

function Student(name, age, cursosAprobados) {
    this.name = name;
    this.age = age;
    this.cursosAprobados = cursosAprobados;
    // this.aprobarCurso = function (nuevoCurso) { Esto también es una manera de crear un metodo
    //     this.cursosAprobados.push(nuevoCurso);
    // }
}

// Creando método para Student

Student.prototype.aprobarCurso = function (nuevoCurso) {
    this.cursosAprobados.push(nuevoCurso);
}

Creando una instancia de Student

const juanita = new Student(
    'Juanita Alejadra',
    20,
    [
        'Curso de introduccion a videjuego',
        'Curso de creacion de personajes',
    ],
)

como se vería en la consola natalia

como se vería en la consola juanita

para el caso del objeto juanita, el método aprobarCurso queda en [[Prototype]]

esa Natalia debió haber tratado al profe como un objeto :v
valla nombre “random”

//Aqui crearemos nuestro primer prototipo en JS

function Student(name, age, cursosAprobados){
    this.name = name;
    this.age = age;
    this.cursosAprobados = cursosAprobados;
}

//en esta seccion crearemos un metodo para el prototipo student

Student.prototype.aprobarCurso = function(nuevoCurso){
    this.cursosAprobados.push(nuevoCurso);
}

const juan = new Student(
    "Juan",
    25,
    [
        "Curso de introduccion a la produccion de videojuegos"
    ]
);
En mi opinion, y espero feedback 😇 Objetos literales : se crean apartar de una variable, su sintaxis para moldeo es diferente, y estos tienen comportamiento reservado... prototipos , objetos clásicos, o instancias: es el molde general del que se crean los futuros objetos heredando su comportamiento, estos además de ser diferentes en sintaxis, pueden extender desde prototype, nuevos comportamientos diseñados desde fuera por nosotros, ala hora de visualizar no los muestra en objeto general, pero si en el __proto__

JavaScript es a menudo descrito como un lenguaje basado en prototipos - para proporcionar mecanismos de herencia, los objetos pueden tener un objeto prototipo, el cual actúa como un objeto plantilla que hereda métodos y propiedades.

Un objeto prototipo del objeto puede tener a su vez otro objeto prototipo, el cual hereda métodos y propiedades, y así sucesivamente. Esto es conocido con frecuencia como la cadena de prototipos, y explica por qué objetos diferentes pueden tener disponibles propiedades y métodos definidos en otros objetos.

Bien, para ser exactos, los métodos y propiedades son definidos en la propiedad prototype, que reside en la función constructora del objeto, no en la instancia misma del objeto.

En JavaScript, se establece un enlace entre la instancia del objeto y su prototipo (su propiedad proto, la cual es derivada de la propiedad prototype sobre el constructor), y las propiedades y metodos son encontrados recorriendo la cadena de prototipos.

Nota: Es importante entender que, tanto el prototipo de la instancia de un objeto (al cual se accede mediante Object.getPrototypeOf(obj), o a través de la propiedad proto) como el prototipo que contiene el constructor (que se encuentra en la propiedad prototype del constructor) hacen referencia al mismo objeto.

El operador new permite a los desarrolladores crear una instancia de un tipo de objeto definido por el usuario o de uno de los tipos de objeto integrados que tiene un función constructora.

¿Qué es un prototipo? - Simple
Un Prototipo es la base del desarrollo de todos los objetos, imagina una casa que solo fue construida con ladrillos sin ningún tipo de decoración ni tampoco ventanas o puertas esa es nuestra base o nuestro PROTOTIPO, al agregar puertas, ventanas, focos, cableado, vamos incluyendo nuevos objetos y estos pueden ir generando más. Podemos pensar por ejemplo la COCINA como un objeto heredado del protipo casa ¿Por qué? bueno en un mundo lógico y algo estricto NO puede existir una cocina sin una casa ahora la COCINA tiene objetos como mesa, sillas, horno, refrigerador y cada objeto tiene sus propiedades(atributos) y acciones(métodos) como el horno que tiene la función calentar

¡Pero qué buena clase!

Me quedaron claros varios conceptos del curso de fundamentos de POO.
Muchas gracias.

efe por juanita

Yo coloque la variable this.cursos con una asignacion de [] , demanera que no queda referenciada a algun tipo de variable sino mas bien como un array cualquiera , de esta forma con el push puedo meterle los cursos en forma de array.

Yo tengo una duda
En ES2015 se ingresaron las clases en javascript.
Por buenas prácticas ¿Debo utilizar Prototype o las clases?

Esta fue mi solucion

class learningPath{

    constructor({name,description}){

        this.name = name;
        this.description = description;
    }
}

var webDevelopment = new learningPath({

    name: "Escuela de Desarrollo Web",
    description: "Aprende desarrollo web Full Stack desde cero con HTML, CSS y JavaScript. Domina herramientas como React, Vue, Angular y backend development con Node.js."

});

var englishAcademy = new learningPath ({

    name: "Platzi English Academy ",
    description: "Aprende inglés desde cero. Consigue oportunidades de trabajo internacionales y duplica tus ingresos al comunicarte efectivamente en inglés."
});

This. hace referencia al mismo objeto, en este caso es el objeto natalia

Para los que intenten implementar arrow functions a diestra y siniestra (como lo intenté en algún momento) les dejo un recurso para que complementen lo aprendido en los cursos de -ECMAScript 6+ y -Closures y Scopes, y aprendan la razón del por qué no pueden usarlo en las mismas aplicaciones de esta clase: link

// Objeto literal

const Natalia = {
    // Atributos
    name: 'Natalia',
    age: 20,
    cursosAprobados: [
        'HTML',
        'CSS',
        'JS'
    ],
    // Métodos
    aprobarCurso(nuevoCurso) {
        // This hace referencia al propio objeto
        this.cursosAprobados.push(nuevoCurso);
    },
    // Otro método
    estudiar: () => {
        // Ojo, las funciones anónimas no soporte this
        return 'Estoy Estudiando'
    },
    // Otro método
    repasar: function () {
        return 'Estoy repasando'
    }
};

// Hacer que Natalia apruebe otro curso
//Natalia.cursosAprobados.push('Mobile First');

// Hacer que Natalia cambie de nombre
//Natalia.name = 'Natha';

Natalia.aprobarCurso('Mobile First');

console.log(Natalia.cursosAprobados);
console.log(Natalia.estudiar());
console.log(Natalia.repasar());


// Prototipos

function Student(name, age, cursosAprobados) {
    // Propiedades
    this.name =name;
    this.age = age;
    this.cursosAproabdos = cursosAprobados;
    // Método dentro del prototipo, no usaremos este
    // this.aprobarCurso = function (nuevoCurso) {
    //     this.cursosAproabdos.push(nuevoCurso);
    // }
}

// Método del prototipo por fuera
Student.prototype.aprobarCurso = function (nuevoCurso) {
    this.cursosAproabdos.push(nuevoCurso);
}

Student.prototype.estudiar = () => {
    // Ojo, las funciones anónimas no soporte this
    return 'Estoy estudiando'
}

// Creando el objeto
const mary = new Student(
    'Natalia',
    25,
    ['Java', 'JS', 'PHP']
);

mary.aprobarCurso('HTML');
console.log(mary.cursosAproabdos);
console.log(mary.estudiar());

Aquí esta mi clase Student

class Student {
    // Propiedades Base
    constructor(name, lastname, age, coursesApproved) {
        this.name = name;
        this.lastname = lastname;
        this.age = age;
        this.coursesApproved = coursesApproved;
    }
    // Metodos
    approvedCourses(newCourse) {
        this.coursesApproved.push(newCourse);
    }
}

📌 Objetos Literales

const natalia = {
// atributo
	cursosAprobados: ['Programación Básica']
// método 
	aprobarCurso(cursoAprobado) {
	this.cursosAprobados.push()cursoAprobado;
	},	
} ;

📌 Prototipos

// Prototype
function Student(name, age, cursosAprobados) {
	this.name = name,
	this.age = age,
	this.cursosAprobados,
	//metodo 
	this.alertar = function (mensaje) {
	alert('Hola!')
}
}

// Método con prototype
Students.prototype.aprobarCurso = function(cursoAprobado) {
	this.cursosAprobados.push(cursoAprobado)
}
// Instanciar

const juanita = new Student(
	"Juanita Alejandra",
	20,
	[
	"Curso 1",
	"Curso 2",
	]
)


Hay extensiones que son realmente maravillosas para alguien que esta aprendiendo

Información Adicional:
Las funciones Lambda o funciones flecha no son funciones que puedan ser construidas como un Objeto, son solo expresiones.
Sean u y v:

let u = function () {}
let v = () => {}

u: es una función, y puede comportarse como función constructora.
v: es una expresión de función, es una función lambda.

const uu = new u(); //se construye uu y hereda el prototipo de Object
const vv = new v(); //Error v no es un constructor

De modo que no podremos usarlas para agregar propiedades a algún Literal Object

const car = {
    year: 2010,
    color: 'red',

    setColor = function (color){ //Correcto
        this.color = color;
    },
    setColor = (color) => {  //Incorrecto
        this.color = color;
    }
}

Las funciones lambda tienen sus limitaciones, sobre funciones lambda

Les dejo mi código de esta clases 👇

  • Literal Objects :
const ZERO = {
  name: 'Zero',
  age: 14,
  platziPoints: 15200,
  approvedCourses: [
    'Curso Básico de JavaScript',
    'Curso Básico de Programación en Go',
    'Curso Básico de Python',
    'Curso de Administración de Servidores Linux',
    'Curso de Economía Digital: Bitcoin y Criptomonedas 📜',
  ],
  approveCourse(course) {
    this.approvedCourses.push(course);
  },
  addPoints(points) {
    this.platziPoints += points;
  },
};

// Print current approved Courses
console.log(ZERO.approvedCourses);

// Approve a course...
ZERO.approveCourse('Curso de Introducción al Despliegue de Aplicaciones');

// Print current approved courses
console.log(ZERO.approvedCourses)

// Print current Platzi Points
console.log(ZERO.platziPoints);

// Make a good contribution to the community ⬇️

ZERO.addPoints(2400);

// Print current Platzi Points
console.log(ZERO.platziPoints);
  • Prototypes
function Student(name, age, approvedCourses) {
  this.name = name;
  this.age = age;
  this.approvedCourses = approvedCourses;
}

// eslint-disable-next-line func-names
Student.prototype.aproveCourse = function (course) {
  this.approvedCourses.push(course);
};

const MAGI = new Student('Magi', 66, ['Curso de SQL y MySQL']);
console.log(MAGI.approvedCourses);
MAGI.aproveCourse('Curso de Computación Básica');
console.log(MAGI.approvedCourses);

Les dejo mi repositorio del curso con todas mis notas y código: UltiRequiem/oop-js-platzi.

Estoy entiendo mejor con JD … en el curso anterior con Anahí sentí que fue tan repentino muchas cosas

Estuvo genial esta clase la entendí perfectamente y va tomando forma poco a poco con los temas aprendidos anteriormente y ya llevarlos al código, vamos a por mas!!
Que por cierto a día de hoy en ves de function se usan clases ya con la palabra reservada algo así:

class Student {
    constructor(name, age, cursosAprobados){
        this.name = name;
        this.age = age;
        this.cursosAprobados = cursosAprobados;
    }
    
}

Tengo entendido que es por ECS6, lo digo asi porque aún no realizo ese curso, pero he visto que es por esa razon y pues me resulta facil entenderlo asi tambien

Es muy bueno saber también que cuando el profe en el minuto 12:30 plantea 2 opciones a la hora de implementar métodos, esto trae aparejado 2 performences o rendimientos distintos al momento de generar un programa.
Les dejo un video que va mas en profundidad con este tema (el autor se toma 40 minutos para explicar prototipos) pero en el minuto 35 de este link se puede ver directamente:
https://www.youtube.com/watch?v=nS5FmAx4u_0&t=428s

Prefiero curso largos a videos de media hora!!!

min 14:30
"JUANITA ALEJANDRA"

JAJAJAJAJAJA
que clase de nombre es ese!!! jajajajajaja XD