No tienes acceso a esta clase

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

Shallow copy en JavaScript

6/20
Recursos

El Shallow Copy (copia superficial) se refiere a la forma de crear un nuevo objeto a partir de las propiedades de otro. Esta copia solo se hace a un nivel alto, no se hace con objetos dentro de objetos (nested objects), lo que provoca que la modificaci贸n de una de sus propiedades, modifique el objeto principal.

Shallow copy con el bucle for

Podemos copiar las propiedades de un objeto en otro haciendo uso del bucle for:

const obj1 = {
	a: "a",
	b: "b"
}

const obj2 = {}

for (propiedad in obj1) {
	obj2[propiedad] = obj1[propiedad];
}

Si dese谩ramos modificar los valores de los atributos del objeto copia, el objeto original no se ve afectado:

obj2.a = "AAA";
obj2.b = "BBB";

console.log(obj2); // { a: 'AAA', b: 'BBB' }
console.log(obj1); // { a: 'AAA', b: 'BBB' }

Pero, si hay objetos dentro del objeto original (nested objects) el objeto original s铆 se ver铆a afectado ante las modificaciones hechas en dichos sub objetos:

const obj1 = {
	a: "a",
	b: "b",
	c: {
		d: "d",
		e: "e"
	}
}

const obj2 = {}

for (propiedad in obj1) {
	obj2[propiedad] = obj1[propiedad];
}

obj2.a = "atributo a";
obj2.b = "atributo b";
obj2.c.d = "objeto dentro de otro";

console.log(obj2);
console.log(obj1);

/* > Mensaje en consola
{
  a: 'atributo a',
  b: 'atributo b',
  c: {
		d: 'objeto dentro de otro',
		e: 'e'
	}
}
{
	a: 'a',
	b: 'b',
	c: {
		d: 'objeto dentro de otro',
		e: 'e'
	}
}
*/

Shallow copy con Object.assign

El Object.assign nos permite realizar el mismo shallow copy que podemos hacer con el bucle for.

const obj1 = {
	a: "a",
	b: "b",
	c: {
		d: "d",
		e: "e"
	}
}

const obj3 = Object.assign({}, obj1);

// Con esto podemos crear copias exactas
console.log(obj1); // { a: 'a', b: 'b', c: { d: 'd', e: 'e' } }
console.log(obj3); // { a: 'a', b: 'b', c: { d: 'd', e: 'e' } }

// Sin embargo, si hacemos modificaciones en los nested objects...
obj1.c.d = "COPIA DESDE EL OBJ1";

// se ver谩n afectados los dem谩s objetos copiados
console.log(obj3); // { a: 'a', b: 'b', c: { d: 'COPIA DESDE EL OBJ1', e: 'e' } }

Aun as铆, tendremos los mismos problemas si el objeto original posee nested objects.

Object.create

Nos permite crear un objeto que tenga como parte de su prototipo los atributos de otro objeto:

const obj1 = {
	a: "a",
	b: "b",
	c: {
		d: "d",
		e: "e"
	}
}

const obj4 = Object.create(obj1);
Object.create para que un objeto tenga como prototipo los atributos de otro

Hasta ahora hemos podido resolver parcialmente el problema de copiar objetos, ya que a煤n tenemos inconvenientes cuando los objetos originales tienen anidados otros objetos. Tratemos de resolver esto con JSON.parse y JSON.stringify. 馃懆鈥嶐煉

Contribuci贸n creada por: Mart铆n 脕lvarez (Platzi Contributor) con el aporte de Zajith Corro Viveros.

Aportes 43

Preguntas 6

Ordenar por:

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

o inicia sesi贸n.

Shallow Copy se refiere a la forma de crear un nuevo objeto a partir de las propiedades de otro. Esta copia solo se hace a un nivel alto, no se hace con objetos dentro de objetos (nested objects), lo que provoca que la modificaci贸n de una de sus propiedades, modifique el objeto principal.

const person = {
	name: 'Eduardo',
	email: '[email protected]',
  social: {
    facebook: 'Eduardo Garcia',
    twiiter: 'EduGar'
  }
}

const person2 = {}

for (prop in person) {
  person2[prop] = person[prop]
}

person2.name = 'Eduardo Miguel'
person
/* {
  name: 'Eduardo',
  email: '[email protected]',
  social: { facebook: 'Eduardo Garcia', twiiter: 'EduGar' }
} */

person2
/* {
  name: 'Eduardo Miguel',
  email: '[email protected]',
  social: { facebook: 'Eduardo Garcia', twiiter: 'EduGar' }
} */

person2.social.facebook = 'Eduardo Miguel Garcia'
person
/* {
  name: 'Eduardo',
  email: '[email protected]',
  social: { facebook: 'Eduardo Miguel Garcia', twiiter: 'EduGar' }
} */

person2
/* {
  name: 'Eduardo Miguel',
  email: '[email protected]',
  social: { facebook: 'Eduardo Miguel Garcia', twiiter: 'EduGar' }
} */

Existe un m茅todo del objeto Object que nos permite hacer esta copia directa, con el m茅todo Object.assign(). Sin embargo, este m茅todo sigue conservando el problema de los objetos internos.

const person = {
	name: 'Eduardo',
	email: '[email protected]',
  social: {
    facebook: 'Eduardo Garcia',
    twiiter: 'EduGar'
  }
}

const person2 = Object.assign({}, person)

person2.name = 'Eduardo Miguel'
person
/* {
  name: 'Eduardo',
  email: '[email protected]',
  social: { facebook: 'Eduardo Garcia', twiiter: 'EduGar' }
} */

person2
/* {
  name: 'Eduardo Miguel',
  email: '[email protected]',
  social: { facebook: 'Eduardo Garcia', twiiter: 'EduGar' }
} */

person2.social.facebook = 'Eduardo Miguel Garcia'
person
/* {
  name: 'Eduardo',
  email: '[email protected]',
  social: { facebook: 'Eduardo Miguel Garcia', twiiter: 'EduGar' }
} */

person2
/* {
  name: 'Eduardo Miguel',
  email: '[email protected]',
  social: { facebook: 'Eduardo Miguel Garcia', twiiter: 'EduGar' }
} */

De la misma manera existe otro m茅todo que nos permite hacer esta copia, el m茅todo Object.create(). A diferencia de los m茅todos anteriores, este m茅todo copia un objeto como el prototipo del nuevo objeto. Sin embargo, sigue conservando el mismo problema de los objetos internos.

const person = {
	name: 'Eduardo',
	email: '[email protected]',
  social: {
    facebook: 'Eduardo Garcia',
    twiiter: 'EduGar'
  }
}

const person2 = Object.create(person)

person2.name = 'Eduardo Miguel'
person
/* {
  name: 'Eduardo',
  email: '[email protected]',
  social: { facebook: 'Eduardo Garcia', twiiter: 'EduGar' }
} */

person2
/* {
  name: 'Eduardo Miguel',
  __proto__: {
    name: 'Eduardo Miguel',
    email: '[email protected]',
    social: {
      facebook: 'Eduardo Garcia',
      twiiter: 'EduGar'
    }
  }
} */

person2.social.facebook = 'Eduardo Miguel Garcia'
person
/* {
  name: 'Eduardo',
  email: '[email protected]',
  social: { facebook: 'Eduardo Miguel Garcia', twiiter: 'EduGar' }
} */

person2
/* {
  name: 'Eduardo Miguel',
  __proto__: {
    name: 'Eduardo Miguel',
    email: '[email protected]',
    social: {
      facebook: 'Eduardo Miguel Garcia',
      twiiter: 'EduGar'
    }
  }
} */

Shallow copy en JavaScript

Shallow copy

El Shallow Copy (copia superficial) es una copia bit a bit de un objeto. Se crea un nuevo objeto que tiene una copia exacta de los valores del objeto original. Si alguno de los campos del objeto son referencias a otros objetos, solo se copian las direcciones de referencia, es decir, solo se copia la direcci贸n de memoria.

Object.assign()

El m茅todo Object.assign () copia todas las propiedades propias enumerables de uno o m谩s objetos de origen a un objeto de destino. Devuelve el objeto de destino modificado.

Las propiedades del objeto de destino se sobrescriben con las propiedades de los or铆genes si tienen la misma clave. Las propiedades de las fuentes posteriores sobrescriben a las anteriores.

Object.create()

El m茅todo Object.create () crea un nuevo objeto, utilizando un objeto existente como prototipo del objeto reci茅n creado.

La diferencia entre Object.create y Object.assign

La principal diferencia entre Object.create() y Object.assign() es que el m茅todo Object.assign crea un nuevo Object. utiliza el objeto proporcionado como prototipo del Objeto reci茅n creado. Mientras que el m茅todo Object.assign() copia todas las propiedades de los objetos de origen al objeto de destino, que es el primer par谩metro de esta funci贸n y devuelve este Objeto de destino.

Por lo tanto, vemos que mientras Object.create() define propiedades en nuestro Object reci茅n creado. Object.assign() simplemente asigna el valor de los objetos de origen de destino a nuestro Objeto de destino.

C贸digo Clase

const obj1 = {
    a: 'a',
    b: 'b',
    c: {
        d: 'd',
        e: 'e',
    },
};

// Shallow Copy con for
const obj2 = {};
for (prop in obj1) {
    obj2[prop] = obj1[prop]; 
}

// Metodos de Object para hacer Shallow Copy
const obj3 = Object.assign({}, obj1);
const obj4 = Object.create(obj1);

Momento epico para los fans del anime en el min 5:32

El for loop que se aplico es para aquellos tipos de datos que no son iterables, tales como los objetos literales, la sintaxis es bastante simple.

for(item in obj){
  @code
}

Hay una sintaxis similar para aquellos tipos de datos que si son iterables, tales como strings o arrays:

for(item of arr){
  @code
}

Tambi茅n podemos copiar las propiedades de un objeto usando el spread operator (鈥)
Ejemplo:

const foo = {
  english: 'hello',
  french: 'bonjour',
  japanese: 'konnichiwa'
};
const bar = { ...foo };

console.log(bar);
// { english: 'hello', french: 'bonjour', japanese: 'konnichiwa' }

Sin embargo, seguir铆amos teniendo el problema de los objetos que est谩n dentro de otros objetos.

const carlos = {
	name: 'Carlos',
	age: 26,
	activities: {
		sports: 'Basketball',
		videoGames: 'COD'
	}
};
const maria = { ...carlos };
maria.name = 'Maria';
maria.age = 23;
maria.activities.sports = 'Soccer';

console.log(maria);
// { name: 'Maria', age: 23, activities: { sports: 'Soccer', videoGames: 'COD' } }

console.log(carlos)
// { name: 'Carlos', age: 26, activities: { sports: 'Soccer', videoGames: 'COD' } }

Ahora entiendo por que se dice que JavaScript es un lenguaje incomprendido :p

Tambi茅n podemos modificar las propiedades cuando las copiamos con Object.create() de la siguiente forma

obj4.__proto__.b = "Esta es otra opcion"

existen dos for para objetos,

for (objeto in objetos) {} >> IN es para iterar sus propiedades
for (objeto on objetos) {} >> ON es para iterar sus valores

Les paso un articulo que explica de forma muy clara que es el shallow copy y su contra parte el deep copy, espero y les guste y les ayude mucho! 馃槂
https://medium.com/@manjuladube/understanding-deep-and-shallow-copy-in-javascript-13438bad941c

馃導锔 Shallow copy en JavaScript

Ideas/conceptos claves

Object.assign()聽copia todas las聽propiedades enumerables de uno o m谩s objetos fuente a un objeto destino. Devuelve el objeto destino.

Object.create()聽crea un objeto nuevo, utilizando un objeto existente como el prototipo del nuevo objeto creado.

Recursos

Object.assign() - JavaScript | MDN

Object.create() - JavaScript | MDN

The Difference Between Object.create and Object.assign - CodeCalls

Apuntes

  • Para poder clonar un objeto en JavaScript 鈥渟uperficialmente鈥 podemos realizarlo mediante diferentes formas

Recorriendo las propiedades del Objecto

const obj1 = {
	a: "a",
	b: "b",
};

const obj2 = {};
for(prop in obj1){
	obj2[prop] = obj1[prop]
}
  • Lo que se realiza en el c贸digo anterior es iterar el objeto a copiar y pasar los valores en el nuevo objeto.
  • Lastimosamente, cuando se trata de objetos como atributos seguimos copiando solo la referencia, como por ejemplo:
const obj1 = {
	a: "a",
	b: "b",
	c: {
		d: "d"
	}
};

Object.assign()

  • Object.assign() permite crear un nuevo objeto mediante la copia de otro
  • Recibe como parametro dos valores:
    1. El objeto inicial donde se asignaran las propiedades del objeto a copiar
    2. El objeto a copiar o asignar valores
const obj3 = Object.assign({}, obj1);
  • De igual forma los objetos como propiedades se siguen copiando las referencias

Object.create()

  • Object.create() crea un nuevo objeto, recibiendo un objeto anterior, pero todas las propiedades no estar谩n directamente en el objeto sino que en su prototipo
  • Recibe como par谩metro el objeto a copiar
const obj4 = Object.create(obj1);
  • De igual forma sigue con el problema de que no puede copiar absolutamente un objeto
馃搶 **RESUMEN:** Shallow copy es copiar un objeto a nivel superficial sin tener en cuenta las otras referencias internas como propiedades que puede tener.

Les recomiendo usar el spread operator, el cual nos sirve para tomar una copia de objetos o incluso arreglos.

const obj1 = {
    a: "a",
    b: "b",
};
console.log(obj1)
const obj2 = {...obj1};
console.log(obj2)

A mi algo algo que me sirvi贸 mucho fue recordar la clase de Freddy del curso gratis de programaci贸n b谩sica en la que explica muy bien como accedes a los atributos de los objetos con los ciclos for utilizando index => (instancia in objeto) donde instancia itera en el 铆ndice y of => (instancia of objeto) y en of la instancia itera sobre el objeto

I si creamos un for donde verificamos que es un objeto para crear otro for y asignar as铆 las propiedades!

javascript spread operator

const obj1 = {
    a:"a",
    b:"b",
    c:{
        ac:"ac",
        bc:"bc"
    }
}

const obj2 = {...obj1,c:{...obj1.c}}
console.log("objeto original" ,obj1);
obj2.a ="AAAAA"
obj2.c.ac ="dc"
console.log("objeto 2 modificado",obj2);
// usando object create
const obj3 = Object.create({},obj1)
const obj4 = Object.create(obj1);

Algo as铆 es como entend铆:

Es como si obj4 heredara de obj1 pero los cambios que se le hagan a los objetos un nivel m谩s interno afectaran tanto al original como a la copia, que cosas raras 馃槓

Vaya lio el de copiar un Objeto

Object.assign({}, car) y el spreed operator es lo mismo.
.

Solo copia los datos por valor en el primer nivel de propiedades, mientras que los objetos de los siguientes niveles son asignados por referencia, de la misma manera que si se hiciera con " = 鈥

Shallow copy (copiado superficial) es una copia de bits de un objeto; esto quiere decir que se crea un nuevo objeto que tiene una copia exacta de los valores en el objeto original; PERO si alguno de los campos del objeto son objetos, solo se van a copiar las referencias a las mismas.

la palabra shallow en spanish se puede interpretar como poco profundo.

si uno modifica en este caso el objeto c que esta dentro del obj4 podemos sobre escribir ese objeto es interesante馃槸

Cuando me preguntan qu茅 es JavaScript:
鈥淯na cosa muy interesante que puede ser un error o un feature dependiendo de c贸mo quieras verlo鈥

Tambien en vez de copiar el objeto manualmente con un For lo podemos hacer usando las propiedades Object.keys y array.map

Con for:
for (prop in obj1) {
    obj2[prop] = obj1[prop];
}

Con Propiedades
Object.keys(obj1).map(prop => {
    obj3[prop] = obj1[prop];
})

Forma1 de copiar efectivamente Objetos sin copiar la referencia al espacio en memoria del objeto copiado. const objeto2 = Object.assign({} , objeto1); ....

Estuve haciendo un experimento peque帽o :

let x = [];   //array
let y = [];   //array
let z = {};  //objeto

Object.getPrototypeOf(y).constructor;
// devuelve esto :      茠 Array() { [native code] }
Object.getPrototypeOf(z).constructor;
// devuelve esto :      茠 Object() { [native code] }

entonces veamos que pasa :

Object.getPrototypeOf(y).constructor 
    ===
    Object.getPrototypeOf(x).constructor;
//devuelve :        true

es una observacion nos puede ser util creo.

Cuando hacemos asignaci贸n de objetos

let obj1=new Obj1();
let obj2=obj1;

Hacemos asignaci贸n por referencia.
Cuando hacemos el shallow copy, realizamos asignaci贸n de un objeto a otro como si lo hicieramos esto:

obj2.p1=obj1.p1;
obj2.p2=obj1.p2;
.
.
.
obj2.p_n=obj1.p_n;

Adentrandose mas en javascript, y saber que no funciona como conceptualmente debe hacerlo, se vuelve mas confuso, y me hace pensar 鈥渆n que me met铆鈥. Asumo que mas adelante se va a explicar como solucionar estas problemas de las copias, pero mas suena a parches que se aplican y no como solucion final.

Cuando tenemos un 鈥榦bjeto original鈥 y sacamos un 鈥榦bjeto copia鈥 del primero, tenemos un 鈥榦bjeto copia鈥 con los valores de cada propiedad del 鈥榦bjeto original鈥.
Si dentro 鈥榦bjeto original鈥 vive un 鈥榦bjeto anidado original鈥 -> en 鈥榦bjeto copia鈥 se crear谩 un 鈥榦bjeto copia anidado鈥.
Cada modificaci贸n que ocurra en 鈥榦bjeto copia anidado鈥 afectar谩 a 鈥榦bjeto anidado original鈥.


Object.create() - JavaScript | MDN crea un objeto nuevo, utilizando un objeto existente como el prototipo del nuevo objeto creado. El valor devuelto es un nuevo objeto con el prototipo y propiedades del objeto especificado

Object.assign() - JavaScript | MDN copia todas las propiedades enumerables de uno o m谩s objetos fuente a un objeto destino. Devuelve el objeto destino.

3. Shallow copy en Javascript

Shallow copy es una copia superficial de un objeto. Es decir, copia solo los atributos del objeto, no los objetos que contiene

const obj1 = {
    a: "a",
    b: "b",
    c: {
        d: "d",
        e: "e",
    }
}
const obj2 = {
    for(prop in obj1){
    obj2[prop] = obj1[prop]    
    }
}
//iterando por cada propiedad para que copien
// y no afecten al objeto original

1. Object.assign()

Se utiliza este metodo para copiar todas las proiedades propias ENUMERABLES(primer nivel)
de un origen a un destino

Object.assing(objetivo,... fuentes);
//Objetivo -> objeto destino
//fuentes -> objetos origen

Ejemplo:

let obj = {
    a:1
};
let copy = Object.assign({},obj);
copy.a = 2;
console.log(obj.a); //1
console.log(copy.a); //2

En el anterior ejemplo ya ambos objetos tienen asignado su propio lugar en la memoria y se comportan de manera dependient.

Podemos hacer una copia de dos o m谩s objetos con Object.assign():

let o1 = {a:1};
let o2 = {b:2};
let o3 = {c:3};
let obj = Object.assign({},o1,o2,o3);
// nuesto objeto tiene copias de los objetos fuentes
console.log(obj); //{a:1,b:2,c:3}

//si hacemos un cambio a nuestra copia
obj.a = 4;
console.log(obj); //{a:4,b:2,c:3}

// los objetos independientes mantienen su valor
console.log(o1); //{a:1}
console.log(o2); //{b:2}
console.log(o3); //{c:3}

otro ejemplo un poco m谩s grande:

let persona_1 = {
    nombre: "Juan",
    edad: 18,
    direccion: {
        calle: "Calle falsa",
        numero: 123
    }
};
//copiamos el objeto con shadowcopy
let persona_2 = Object.assign({},persona_1);

console.log(persona_1); //{nombre: "Juan", edad: 18, direccion: {鈥}
console.log(persona_2); //{nombre: "Juan", edad: 18, direccion: {鈥}
//le cambiamos el valor de nombre a persona_2
persona_2.nombre = "Pedro";

//al imprimir nos damos cuenta que ambas conservan sus otros valores
console.log(persona_1); //{nombre: "Juan", edad: 18, direccion: {鈥}
console.log(persona_2); //{nombre: "Pedro", edad: 18, direccion: {鈥}

//cambiamos el valor de segundo nivel
persona_2.direccion.calle = "Pitufolandia";

//nos damos cuenta que ambas se les afecto el valor de donde viven
console.log(persona_1); //{nombre: "Juan", edad: 18, direccion: {calle: "Pitufolandia", numero: 123}}
console.log(persona_2); //{nombre: "Pedro", edad: 18, direccion: {calles: "Pitufolandia", numero: 123}}

Notamos que el shallow copy puede copiar solo de manera superficial, pero no puede copiar los valores dentro de otros valores, o nivel 2, etc.
Ac谩 un art铆culo m谩s completo donde saqu茅 la informaci贸n:
JavaScript 鈥 Shallow copy and Deep copy

2. Object.create()

Se utiliza para crear un objeto nuevo, utilizando un objeto existente como prototipo.

const person = {
    isHuman: false,
    printIntroduction: function(){
        console.log(`My name is ${this.name}. Am I human? ${this.isHuman}`);
    }
};
const me = Object.create(person);
me.name = "Pedro";//agregamos una propiedad al objeto "me" pero no dentro de "person"
me.isHuman = true; // hereda la propiedad que puede ser sobre escrita

me.printIntroduction(); // My name is Pedro. Am I human? true

sintaxis

Object.create(proto[, propertiesObject])
Parametros

  • proto: es el objeto que ser谩 el prototipo del nuevo objeto.
  • propertiesObject:Opcional. Si se especifica un objeto, se agregar谩n las propiedades del objeto a la nueva instancia.
    Fuentes:
    JavaScript 鈥 Object.create()

驴Que es Shallow copy?

crea un duplicado del elemento original ( ya sea simple o complejo ) pero no hace copias de cualquier elemento al que haga referencia el elemento original. En cambio, si el elemento original contiene una referencia a un objeto, entonces el la referencia correspondiente en el elemento copiado se refiere a la mismo objeto.

En fin como los objetos apuntan a memoria hay que tener cuidao xd

con shallow copy puedes copiar propiedades de objetos mientras no sea un objeto la propiedad

hacer esto:
const obj2 = {}
Esta bien porque en objetos el nombre de la variable y el valor de la variable que es un apuntador al valor son constantes

En JavaScript, la declaraci贸n const se utiliza para crear variables cuyos valores no pueden ser reasignados despu茅s de su inicializaci贸n. Esto significa que una vez que asignas un valor a una variable constante, no puedes cambiar ese valor.
.
La raz贸n por la que puedes modificar las propiedades de un objeto declarado como constante es porque la constante en s铆 almacena una referencia a un objeto en memoria, y no el objeto en s铆. Entonces, aunque la referencia en la constante no puede ser modificada, las propiedades del objeto al que hace referencia s铆 pueden ser modificadas.
.
Aqu铆 hay un ejemplo que ilustra esto:
.

const objeto = {
  propiedad: 'valor inicial'
};

objeto.propiedad = 'nuevo valor';
console.log(objeto.propiedad); // Imprime: 'nuevo valor'

.
En este ejemplo, declaramos una constante llamada objeto que apunta a un objeto. Aunque no podemos reasignar objeto a un nuevo objeto, s铆 podemos modificar la propiedad propiedad del objeto al que hace referencia.
.
Sin embargo, ten en cuenta que si intentas reasignar la constante objeto a un nuevo objeto, obtendr谩s un error:

const objeto = {
  propiedad: 'valor inicial'
};

objeto = { nuevaPropiedad: 'nuevo valor' }; // Error: No se puede reasignar una constante

.
En resumen, en JavaScript, una variable declarada con const no puede ser reasignada, pero si la constante es un objeto, puedes modificar sus propiedades.

Me parece que cobra much铆simo sentido que la modificaci贸n al hacer shallow copy vaya para abajo y no a la inversa. A final del d铆a estamos hablando de objetos, 驴no? Minuto de referencia: 9:50

Jajajaja Tiene q admitirse que realmente intenta explicarlo. Eso ultimo, si que le costo. Yo me hubiera chipado al hacerlo xD.

Mi resumen al m谩ximo poder:

/*-----------------Shallow Copy(Copiar objetos en otra objeto)-------------------*/

//Permite la creaci贸n de objetos copia, siendo esta independiente al original, es decir, si se cambia algo en la copia, no afecta al original.
//Esto solo se da en objetos con un nivel de profundidad. Si hay objetos dentro de propiedades de otro objeto, se indica que hay un segundo nivel de profundidad y as铆 sucesivamente

// ### Bucle for

const obj1 = {
	a: "a",
	b: "b"
}

const obj2 = {}

for (propiedad in obj1) {
	obj2[propiedad] = obj1[propiedad];
}

console.log(obj2); //{ a: 'a', b: 'b' }

// ### Object.assign

//Permite realizar el mismo shallow copy que podemos hacer con el bucle for

const objNew = {
	a: "a",
	b: "b",
	c: {
		d: "d",
		e: "e"
	}
}

const objNew2 = Object.assign({}, objNew); //recibe dos parametros: el primero es un objeto vacio representado con {} y el segundo el objeto del cual se quiere copiar
console.log(objNew2); //{ a: 'a', b: 'b', c: { d: 'd', e: 'e' } }

// ### Object.create

//Permite crear un objeto que tenga como parte de su prototipo los atributos de otro objeto

const objNewNew = {
	a: "a",
	b: "b",
	c: {
		d: "d",
		e: "e"
	}
}

const objNewNew2 = Object.create(objNewNew);
console.log(objNewNew2); //muestra un object vacio pero la copia fue realizada dentro de __proto__

// ### Spread operator

//Permite copiar tanto un array como un objeto en otra variable, sin que la copia tenga alguna referencia en memoria que el original

let dog = {
    name : "Pascual",
    age : 3
}

let dog2 = {...dog};

dog2.name = "Roco";

console.log(dog2); //{ name: 'Roco', age: 3 }

console.log(dog); //{ name: 'Pascual', age: 3 }

//CUIDADO
//Para todos los m茅todos anteriores, si se copia un objeto con m谩s de un nivel de profundidad, entonces si se cambia el valor de una propiedad de un subnivel, este afecar谩 a la copia como al original

let a = {
    a : "a",
    b : {
        c : "c"
    }
}

let b = {...a};

b.b.c = "ccc";

console.log(a); //{ a: 'a', b: { c: 'ccc' } }

console.log(b); //{ a: 'a', b: { c: 'ccc' } }

Alguien m谩s pens贸 en la pel铆cula de Leo Dicaprio: 鈥淓l ORIGEN鈥 :鈥) ?

const obj = {
a: 鈥2鈥,
b: 鈥3鈥,
c: {
e: 鈥渆鈥,
d: 鈥渄鈥
}
}

const obj2 = {}

for(prop in obj) {
obj2[prop] = obj[prop]
console.log(鈥渟oy obj[prop]鈥)
console.log(obj[prop])

}
/*Resultado:
soy obj[prop]
2
soy obj[prop]
3
soy obj[prop]
{e: 鈥榚鈥, d: 鈥榙鈥檥

Para entender este codigo, tenes que entender estas propiedades:

prop:  de por si es: a,b,c dependiendo del momento del bucle en el que este. Es asi ya que dijimos que prop es parte de obj.


"obj2[prop] = ", esta propiedad hace 2 cosas a la vez. 

1) Inicializa una variable en obj2, en este caso inicializaria asi: obj2[a], obj2[b], pero no solo eso, sino que al mismo tiempo:

2 hicimos "obj2[prop] = obj[prop]" Lo que estuvimos haciendo es asignar un elemento de obj[prop](obj[a]=2) en obj2[prop](obj2[a] =2 )

*/

al final los objetos hijos son una fiel referencia al padre por mas que se quiera romper

Shallow copy (copiado superficial) es una copia de bits de un objeto; esto quiere decir que se crea un nuevo objeto que tiene una copia exacta de los valores en el objeto original; PERO si alguno de los campos del objeto son objetos, solo se van a copiar las referencias a las mismas

const objeto3 = Object.create(objeto1);

Eso estuvo increiblemente confuso

Jaja, puede ser un error o un feature, creo que esa respuesta es: siempre un error