No tienes acceso a esta clase

隆Contin煤a aprendiendo! 脷nete y comienza a potenciar tu carrera

脷ltima oportunidad para asegurar tu aprendizaje por 1 a帽o a precio especial

Antes: $249

Currency
$189/a帽o

Paga en 4 cuotas sin intereses

Paga en 4 cuotas sin intereses
Suscr铆bete

Termina en:

0D
7H
26M
29S

Abstracci贸n con objetos literales y deep copy

11/20
Recursos

Aplicaremos la abstracci贸n y encapsulamiento a nuestros objetos en JavaScript sin necesidad de utilizar prototipos ni clases. Emplearemos el deep copy para generar nuevos objetos a partir de un objeto base y los encapsularemos con ayuda de los m茅todos del superprototipo Object tales como defineProperty, seal y freeze.

Abstracci贸n con deep copy en JavaScript

Vamos a crear un objeto base para un estudiante:

// 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. Para ello emplearemos deep copy con recursividad:

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;
}

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

// GENERANDO NUEVOS OBJETOS
const juan = deepCopy(studentBase);
const emma = deepCopy(studentBase);

Encapsulamiento de objetos con Object.defineProperty

Sabemos que con Object.defineProperty es posible editar las propiedades writable, enumerable y configurable de los atributos de un objeto. Con esto limitamos el acceso a los datos de los nuevos objetos que generemos.

Editemos la propiedad configurable del atributo name del objeto juan para evitar que sea borrada:

Object.defineProperty(juan, "name", {
	value: "Juanito", // 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 juan.name

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

/* > Mensaje en consola
{
  name: 'Juanito',
  email: undefined,
  age: undefined,
  approvedCourses: undefined,
  learningPaths: undefined,
  socialMedia: { twitter: undefined, instagram: undefined, facebook: undefined }
}
*/

Object.seal para restringir la eliminaci贸n de atributos

Seguramente deseemos tener esta configuraci贸n con el resto de nuestros atributos y as铆 evitar que sean borradas, pero tendr铆amos que hacerlo uno por uno. Podemos simplificar esta labor utilizando Object.seal:

Object.seal(juan); // Ahora todos los atributos est谩n restringidos a que sean eliminados

Verificar si no se pueden borrar los atributos de un objeto

Con Object.isSealed podemos comprobar si todas las propiedades de un objeto est谩n bloqueadas a que sean eliminadas. Nos devolver谩n un booleano.

Object.isSealed(juan);

Verificar si los atributos de un objeto no pueden ser borradas ni editadas

Empleamos Objcet.isFrozen para preguntar si las propiedades de un objeto est谩n restringidas a su eliminaci贸n y edici贸n. Devolver谩 un booleano.

Object.isFrozen(juan);
Datos acerca de las propiedades de encapsulamiento

Contribuci贸n creada por: Mart铆n 脕lvarez (Platzi Contributor) con el aporte de Javier Salcedo Salgado.

Aportes 17

Preguntas 4

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

o inicia sesi贸n.

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