Abstracción con objetos literales y deep copy

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.

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

Zajith Corro Viveros

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.

Obed Paz

Diego Vanegas

Para los que somos mas gráficos…

JeanCarlos Atoche Pascual

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

Miguel Ángel Reyes Moreno

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

Maday Choque

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

Ricardo Alfonso Chavez Vilcapoma

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

Uriel Solis Salinas

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.

Jhon_B

Carlos Esteban Lara Gil

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

Andrés Felipe Eslava Zuluaga

Excelente clase

Enrique Illescas Castillo

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.✅

freddy conto mena

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

Keiner Ariel Naranjo Zambrano

La funcion del deepCopy habria que corregirla para la parte de arrays, ya que si se copia elementos que son arrays o propiedades que son arrays, no los guarda como arrays tal cual, sino como objetos en donde la clave se convierte en el indice y el valor en el valor del array, por ejemplo al copiar el array \[0,1,2,3,4] se obtiene el elemento {0:1,1:2,2:3,3:4}

Alan Dell Oso

En esta clase no terminé de comprender la ventaja de crear un objeto a partir de una deep copy de otro objeto, vs lo que se enseña en la clase anterior (que creo que estaba pensada como siguiente a esta) de hacerlo con una función RORO, que a efectos de la verdadera creación de un objeto, me parece más práctico ya que se pueden definir los valores de las propiedades desde el momento cero y realizar validaciones mucho más completas que con este método. Aunque si fue una buena adición el recordar lo del encapsulamiento con seal y freeze.

Roxidi Oronoz

```js // FUNCION PARA EDITAR LAS PROPIEDADES DEL OBJETO COPIADO: function editProperties(obj, properties) { for (const prop in properties) { if (obj.hasOwnProperty(prop)) { // Verificamos si la propiedad es un objeto y si tiene subpropiedades if (typeof properties[prop] === 'object' && properties[prop] !== null) { // Llamamos recursivamente a la función para editar las subpropiedades editProperties(obj[prop], properties[prop]); } else { // Editamos la propiedad obj[prop] = properties[prop]; } } } } ```// FUNCION PARA EDITAR LAS PROPIEDADES DEL OBJETO COPIADO:function editProperties(obj, properties) { for (const prop in properties) { if (obj.hasOwnProperty(prop)) { // Verificamos si la propiedad es un objeto y si tiene subpropiedades if (typeof properties\[prop] === 'object' && properties\[prop] !== null) { // Llamamos recursivamente a la función para editar las subpropiedades editProperties(obj\[prop], properties\[prop]); } else { // Editamos la propiedad obj\[prop] = properties\[prop]; } } }}

Brandon Lee Aguero Fernandez

Espera queeee, como que con funciones 🤯

Raymondi Alejandro Ramos Vásquez