• Índice

Introducción

¿Qué hay dentro de los objetos en JavaScript?

requisitos

• [ ] Closures y Scope
• [ ] Fundamentos de POO
• [ ] POO Básico en JS

<aside> 💡 Tomas la Escuela de Desarrollo Web en ORDEN MIJO!

</aside>

Que se va a ver en este curso?

Retrocederemos hasta el inicio de lo aprendido en el curso anterior para mejorar el entendimiento de como funcionan los objetos dentro de JavaScript, y como "jaquiar" el sistema de prototipos para nuestro beneficio cuando trabajemos con POO

Profundicemos en los objetos

Static: atributos y métodos estáticos en JavaScript

Hasta ahora habíamos aprendido que apara acceder a los métodos o atributos de una clase o prototipo teníamos que crear una instancia del prototipo(Objeto). Pero hay una forma de que podemos saltarnos tener que crear una instancia del prototipo para acceder a los métodos o atributos, esta es la forma Static

Para crear atributos estáticos los cuales podamos acceder sin crear un objeto o una instancia de este prototipo, solo hay que agregar al atributo la palabra static

Métodos estáticos de Objetct

const objetito = {
    name: "Carlitos",
    email: "[email protected]",
    age: 16,
}

Object.keys()

Nos devuelve una lista con todos los keys(nombres claves) de nuestro objeto objetito

Object.keys(objetito)
// (3) ["name", "email", "age"]

Object.getOwnPropertyNames()

Hace prácticamente lo mismo que Object.keys con pequeñas diferencias

Object.getOwnPropertyNames(objetito)
// (3) ["name", "email", "age"]

Object.entries()

El método entries nos devolverá un arrays de arrays donde tendremos nuestra palabra clave con su  respectivo valor por cada propiedad del prototipo [key,  value]

Object.entries(objetito)
// [
//     0: (2) ["name", "Carlitos"]
//     1: (2) ["email", "[email protected]"]
//     2: (2) ["age", 16]
// ]

Object.getOwnPropertyDescriptors(objetito)

Nos devuelve todas las propiedades de los objetos, con sus keys y values, y otros atributos. Los atributos writable, configurable y enumerable es la forma que tiene JavaScript para limitar el acceso modificar o modificación de nuestros atributos o de nuestros objetos.

Object.getOwnPropertyDescriptors(objetito) 
// {
//     age:{
//         configurable: true
//         enumerable: true
//         value: 16
//         writable: true
//     }
//     email:{
//         configurable: true
//         enumerable: true
//         value: "[email protected]"
//         writable: true
//     }
//     name:{
//         configurable: true
//         enumerable: true
//         value: "Carlitos"
//     }
// }

Encapsulamiento

Si recordamos del curso anterior, el objetivo del encapsulamiento es limitar quien puede modificar, acceder o ejecutar nuestros métodos o atributos de la clase o prototipo.

Ahora con las propiedades writable configurable enumerable podemos limitar quien tiene acceso, modificar nuestros objetos.

Métodos estáticos del prototipo Object

Código Clase

const carlos = {
    name: 'carlito',
    age: 18,
    approvedCourses: ["Curso 1"],
    
    addCourse(newCourse) {
        console.log("This", this);
        console.log("This.approvedCourses", this.approvedCourses);
        this.approvedCourses.push(newCourse); // this hace referencia al objeto carlos
    },
};

// console.log(Object.keys(carlos));
// console.log(Object.getOwnPropertyNames(carlos));

// console.log(Object.entries(carlos));

    // console.log(Object.entries(carlos)[1][0]); // Codigo probado en consola
    // console.log(Object.entries(carlos)[1][1]); // Codigo probado en consola
    // console.log(Object.entries(carlos)[3][1]); // Codigo probado en consola
    // console.log(Object.entries(carlos)[3][1]("Curso 2")); // Error
     
console.log(Object.getOwnPropertyDescriptors(carlos));

Object.defineProperty(carlos, "pruebaNasa", {
    value: "extraterrestres",
    writable: true,
    enumerable: true,
    configurable: true
})