Abstracción con objetos literales y deep copy

Para refrescar un poco la memoria.

Resumen !

Abstracción con objetos literales y deep copy

Object.isSealed()

El método **Object.isSealed()** si el objeto está sellado.

Devuelve true si el objeto está sellado, de lo contrario devuelve false. Un objeto está sellado si no es extensible y si todas sus propiedades no se pueden configurar y por lo tanto no removibles (pero no necesariamente no modificables).

Object.isFrozen()

El método **Object.isFrozen()** determina si un objeto está congelado.

Devuelve true si el objeto está sellado, de lo contrario devuelve false. Un objeto está sellado si no es extensible y si todas sus propiedades no se pueden configurar y por lo tanto no removibles (pero no necesariamente no modificables).

Un objeto está congelado si y solo si no es extendible, todas sus propiedades son no-configurables, y todos los datos de sus propiedades no tienen capacidad de escritura.

Código Clase

/* Codigo para hacer un DeepCopy */
const studentBase = {
    name: undefined,
    email: undefined,
    age: undefined,
    approvedCourse: undefined,
    learningPaths: undefined,
    socialMedia: {
        twitter: undefined,
        instagram: undefined,
        facebook: undefined,
    }
};

const carlos = deepCopy(studentBase);
// Object.defineProperty(carlos, "name", {
//     value: "Carlitos",
//     configurable: false,
// });
Object.seal(carlos); // Es lo mismo que lo de arriba pero mas easy
carlos.name = "Carlitos";

Object.isSealed(carlos); // Nos muestra con True o False si todas las propiedades estan selladas
Object.isFrozen(carlos); // Nos muestra con True o False si todas las propiedades estan congeladas

Object.freeze()

Este método congela un objeto que sea pasado. Es decir:

• Impide que se le agreguen nuevas propiedades
• Impide que sean eliminas propiedades ya existentes
• Impide que sus las propiedades internas (writable, enumerable y configurable) sean modificadas

Object.seal()

Este método sella un objeto que sea pasada. Es decir:

• Impide que nuevas propiedades sean agregadas
• Cambia en todas las propiedades configurable: false, con lo que impide que sean borradas
• Las propiedades aún puede ser modificadas, ya que writable esta true

Object.isSealed()

Este método determina si un objeto se encuentra sellado. Devuelve un valor boolean. Es decir:

• El objeto no es extendible, por lo cual no se pueden agregar más propiedades
• Todas sus propiedades no se pueden configurar, por lo tanto no son removibles

const person = {
  name: 'Eduardo',
  lastName: 'Mendez',
}

Object.seal(person)
Object.isSealed(person) // true

Esta función no toma en cuenta que la función Object.seal() haya sido aplicada en el objeto. Nosotros podemos simular el comportamiento de Object.seal() con otras funciones:

const person = {
  name: "Eduardo",
  lastName: "Mendez",
};

Object.preventExtensions(person);
Object.defineProperty(person, "name", { configurable: false });
Object.defineProperty(person, "lastName", { configurable: false });

Object.isSealed(person) // true

Object.isFrozen()

Este método determina si un objeto se encuentra congelado. Devuelve un valor boolean. Es decir:

• El objeto no es extendible, por lo cual no se pueden agregar más propiedades
• Todas sus propiedades no se pueden configurar, por lo tanto no son removibles
• Todas sus propiedades no pueden ser reescritas.

const person = {
  name: 'Eduardo',
  lastName: 'Mendez',
}

Object.freeze(person)
Object.isFrozen(person) // true

Al igual que Object.isSealed(), esta función no toma en cuenta que la función Object.freeze() haya sido aplicada en el objeto. Nosotros podemos simular el comportamiento de Object.freeze() con otras funciones:

const person = {
  name: "Eduardo",
  lastName: "Mendez",
};

Object.preventExtensions(person);
Object.defineProperty(person, "name", { configurable: false, writable: false });
Object.defineProperty(person, "lastName", {
  configurable: false,
  writable: false,
});

Object.isFrozen(person) // true

Object.preventExtensions() evita o previene que nuevas propiedades sean agregadas a un objeto.

Para los que somos mas gráficos…

Abstracción con objetos literales y deep copy

const studentBase = {
  name: undefined,
  email: undefined,
  age: undefined,
  approvedCourses: undefined,
  learningPaths: undefined,
  socialMedia: {
    facebook: undefined,
    twitter: undefined,
    instagram: undefined,
  }
};

const juan = deepCopy(studentBase);
Object.seal(juan); //* Ninguna propiedad del objeto Juan se podrá eliminar
Object.isSealed(juan); //* Pregunta si tiene todas sus propiedades protegidas
Object.isFrozen(juan); //* Pregunta si tiene todas sus propiedades protegidas y además no se pueden agregar otras

• Object.seal(obj) se usa para evitar borrar propiedades
• Object.freeze(obj) se usa para evitar borrar y editar una propiedad

La finalidad de esta clase es demostrar que podemos crear objetos, sin prototipos o clases, esto haciendo uso de un objeto literal como molde (donde se aplico abstracción) y además poder encapsular sus propiedades haciendo uso de los métodos estáticos del prototipo global Object

Object.isSealed(juan); // Lo que nos permite este método es que si todas las propiedades de nuestro objeto que enviemos como argumento tienen la protección como "configurable": false. Nos mandaría true o false.

Object.isFrozen(juan); // Este método nos dice que si todas las propiedades que tengamos en nuestro objeto tengan el "writable" y "configurable" como false, esto quiere decir que no podremos editar ni borrar nuestras propiedades.

6. Abstracción y encapsulamiento sin usar prototipos ni clases

• Object.defineProperty()

Crear una nueva propiedad y edita alguna que ya habíamos creado:

Object.defineProperty(obj, "propiedad", {
    value: valor,
    writable: true,
    enumerable: true,
    configurable: true

});

Object.defineProperty(juan,"name",{
    value: "Luis Alberto Spinetta",
    configurable:false,
})
// proteje nuestras propiedades

• Object.seal()
  Un atajo para que las propiedades no se puedan editar

• Object.isSealed()
  Verifica si un objeto está sellado o no

• Object.isFrozen()
  determina si un objeto está congelado o no

Excelente clase

Mi resumen:

/*-----------------Abstracción de objetos literales-------------------*/

// OBJETO BASE
const studentBase = {
    name: undefined,
    email: undefined,
    age: undefined,
    approvedCourses: undefined,
    learningPaths: undefined,
    socialMedia: {
        twitter: undefined,
        instagram: undefined,
        facebook: undefined,
    },
};

//Con esto podemos crear nuevos estudiantes generando copias a partir de este objeto literal studentBase.

function isObject(subject) {
    return typeof subject == "object";
}

function isArray(subject) {
    return Array.isArray(subject);
}

// FUNCIÓN RECURSIVA
function deepCopy(subject) {
    let copySubject;

    const subjectIsObject = isObject(subject);
    const subjectIsArray = isArray(subject);

    if (subjectIsArray) {
        copySubject = [];
    } else if (subjectIsObject) {
        copySubject = {};
    } else {
        return subject;
    }

    for (key in subject) {
        const keyIsObject = isObject(subject[key]);

        if (keyIsObject) {
            copySubject[key] = deepCopy(subject[key]);
        } else {
            if (subjectIsArray) {
                copySubject.push(subject[key]);
            } else {
                copySubject[key] = subject[key];
            }
        }
    }
    return copySubject;
}

// GENERANDO NUEVOS OBJETOS
const rica = deepCopy(studentBase);
const terry = deepCopy(studentBase);

/*-----------------Encapsulación de objetos literales-------------------*/

Object.defineProperty(rica, "name", { //También permite editar propiedades existentes
	value: "Ricardito", // Definimos el valor del atributo "name" como "Juanito"
	configurable: false
});
// El resto de propiedades (writable y enumerable) por defecto serán true

// Si intentamos borrar el atributo "name"
delete rica.name

// Observamos que no fue eliminado dicho atributo, pues bloqueamos su eliminación
console.log(rica);

/*
{
    name: 'Ricardito',
    email: undefined,
    age: undefined,
    approvedCourses: undefined,
    learningPaths: undefined,
    socialMedia: { twitter: undefined, instagram: undefined, facebook: undefined }
}
*/

console.log(Object.seal(rica)); // Ahora todos los atributos están restringidos a que sean eliminados

console.log(Object.isSealed(rica)); //true //Verificar si no se pueden borrar los atributos de un objeto

Espera queeee, como que con funciones 🤯

MÉTODOS ESTATICOS DE OBJECT:🍎

	Object.seal()

protege a que se pueda eliminar nuestras propiedades.🗑️

	Object.isSealed

verifica que todas las propiedades de nuestro objeto, tiene la proteccion configurable como false.✅

Object.isFrozen(juanito)

verifica que todas las propiedades no se borren ni editen.✅

uhmmm :0

creo que todo el curso se fuese resumido en 4 videos y no hacer 20