A煤n no tienes acceso a esta clase

Crea una cuenta y contin煤a viendo este curso

Deep copy con recursividad

9/19
Recursos

Aportes 43

Preguntas 9

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesi贸n.

Hola! Les comparto mi aporte de como entendi el codigo paso por paso:

Funcion bucle compleja pero en recursividad.

let array = [1,23,41,52,42,5,656,6,98]
let numeroArray = 0;

let fun = (numerito) => {
    if( numerito < array.length ) {
    let valorArray = array[numerito];
    console.log(valorArray);
    return fun(numerito + 1)
    } else {
        console.log("fin");
    }  
}

let y = fun(numeroArray);

Deep copy.

Utilizaresmos recursividad para crear copia de los objetos y que no se rompan si tenemos objetso dentro de objetos dentro de objetos, o si tenemos metodos dentro de nuestros objetos.

Bien, deep copy en muchos aspectos es un gran algoritmo con manejo de datos, recursividad, etc etc, por lo tanto ire escribiendo fracciones de codigo y explicandolas, y cua do termine de explicar todo, pondre el algoritmo completo.

const obj1 = {
    a: "a",
    b: "b",
    c: {
       d: "d",
       e: "e", 
    },
    editA() {
        this.a = "AAAAA";
    }
}; 
//lo de aca arriba es el objeto a copiar

function isObject(subject) {
    return typeof subject == "object"
}
function esUnArray(subject) {
    return Array.isArray(subject);
}
//estas 2 funciones son funciones de validacion de datos, estan seran llamads y se les pasaran un parametro, la mayoria de datos se puede validar con typeof, ergo, los arrays son los unicos que tienen un metodo espacial = Array.isArray(objetoAsaberSiEsUnArray)

function deepCopy(subject) {
    let copySubject;
//dentro de sta funcion sucedera todo,el copysubject guardara los datos, este esta esperando a saber si los datos son objetos,arrays u otras cosas como strings
    const subjectIsArray = esUnArray(subject);
    const subjectIsObject = isObject(subject);

//con las constantes subjectIsArray,   subjectIsObject trabajere los datos,  estas son las encargadas de llamar a  las funciones que hicimos fuera de la funcion deepCopy.
  

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

//por ultimo empezamos a trabajar con los datos ya validados, segun el dato que sea correspondiente, trbajaremos objeto,arrays u otros valores.
//2da parte del algoritmo
for(key in subject) {
//Creamos un bucle for, este bucle (a in b)se puede ejecutar en una estructura de datos como arrays, objetos. Este loop signfica que el elemento a pasara por TODA la estructura de datos de b, y claro, dependieno la posicion de a,este tendra el valor de donde este parado encima. ejemplo: 
//let array = [52,42,56];
//for(a in array) {
	//console.log(array[a]);
//}
        const keyIsObject = isObject(subject[key]);
//con keyIsObject VUELVO a validar si los datos DENTRO de la estructura de datos YA VALIDADA son objetos o datos. 

        if(keyIsObject) {
            copySubject[key] = deepCopy(subject[key]);
// si resulta que son objetos, entonces iremos copiando y pegando los datos en copySubject, y estos datos se iran copiando de manera identica y exitosa gracias la recursividad deepCopy(subject[key]);

} else {
            if(subjectIsArray) {
                copySubject.push(subject[key]);
            } else {
                copySubject[key] = subject[key]
            }
        }
    }
 //estos 2 ultimos casos son mas sencillos ya que simplemente se basa en arrays u elementos que no sean ni arrays ni objetos   
 
    return copySubject;
// Y al final de todo, la funcion debe devolver algo,verdad? en este caso, quien es el que almaceno todos los datos de el objeto que copiamos? el copySubject, bien, ese es quien retornamos.
} 

para mi esta es una de las clases que no entiendes por completo pero que con el tiempo estoy seguro lograr comprender. En conclusi贸n me llevo que copiar objetos en Javascript es un poco laborioso.

Hola compa帽eros 馃榾, estuve jugando un poco con el c贸digo de la case para entenderlo mejor, y se puede simplificar de esta forma, mas sencillo de leer:

function deepCopy(subject) {
  let copy;

  if (Array.isArray(subject)) {
    copy = [];
  } else if (typeof subject === "object") {
    copy = {};
  } else {
    return subject;
  }

  for (key in subject) {
    copy[key] = deepCopy(subject[key]);
  }

  return copy;
}

Ahora ustedes se preguntaran:
驴Porque en el ciclo for ya no hay validaciones?, esto es debido a que el valor key dentro del for va a corresponder a dos posibles valores: indices de un array, o keys de objetos, dependiendo que sea subject (un objeto o un array) , y como esta misma sintaxis sirve para objetos y arrays podemos usar la misma linea de c贸digo, teniendo encuenta que ya antes creamos copy con los valores {} o [] dependiendo si subject era un objeto o array

Jugando un poco con el debugger he visto como la variable let copySubject; empieza a obtener sus elementos
Imagen1
la function deepCopy identifica que es un objecto { } .

Imagen2
los dos primeros elementos ingresan normal: copySubject[key] = subject[key]; //{a,b}.

Imagen3
en el elemento c:{} identifica que hay un objeto .

Imagen4
ingresan de forma normal los elementos copySubject[key] = subject[key]; //{d,e}.

Imagen5
es el momento de ingresar la function editA(){} lo detecta como objeto.

Imagen6
con este ultimo paso, copia todo el contenido de la funcion y para a finalizar la function.

Deep Copy con recursividad

Se dice que el objeto tiene un Deep Copy cuando cada propiedad del objeto apunta a una copia separada, incluso si la propiedad apunta a un objeto (valores de referencia). Se crea una copia separada del objeto de referencia para el objeto de destino. En caso de copia profunda, las propiedades de referencia del objeto de origen y las propiedades de referencia del objeto de destino apuntan a diferentes ubicaciones de memoria.

Resumen de Deep Copy

  • El objeto de destino contiene una copia separada del nombre, la edad y la designaci贸n.
  • Instancias separadas de tipos de valor. Se crea una referencia separada para objetos complejos (鈥渄irecci贸n鈥)

La propiedad 鈥淒irecci贸n鈥 de los objetos de origen y destino apuntan a diferentes ubicaciones de memoria. Si el usuario actualiza la propiedad de la direcci贸n en el objeto de origen, las actualizaciones no se reflejan en el objeto de destino.

var userName = {
  name: "Mayank Gupta",
  age: 30,
  designation: "Developer",
  address: {
    street: "Rohini",
    city: "Delhi"
  }
}

Lectura importante!

Deep and Shallow Copy in JavaScript

C贸digo Clase

const obj1 = {
    a: 'a',
    b: 'b',
    c: {
        d: 'd',
        e: 'e',
    },
    editA() {
        this.a = 'Abcd'
    }
};

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

function deepCopy(subject) {
    let copySubject;

    const subjectIsObject = isObject(subject)
    const subjectIsArray = isArray(subject)
 
    // inicializamos la variable copySubject segun su tipo de dato
    if (subjectIsArray) {
        copySubject = [];
    } else if (subjectIsObject) {
        copySubject = {};
    } else {
        return subject;
    }

    // Empieza la recursividad
    for (key in subject) {
        const keyIsObject = isObject(subject[key]); // propiedad de nuestro elemento

        if (keyIsObject) {
            copySubject[key] = deepCopy(subject[key]) // Si la propiedad es un objeto, se vuelve a llamar a deepCopy para volver a hacer las asignaciones por cada una de las propiedades de los objetos.
        } else {
            if (subjectIsArray) {
                copySubject.push(subject[key])
            } else {
                copySubject[key] = subject[key]
            }
        }
    }

    return copySubject;
}

// Pruebas en devTools
// const obj2 = deepCopy(obj1);

// obj1
// obj2

// obj1.a = 'AMORMIO'

// obj2.a = 'Si estoy debajo del vaiv茅n de tus piernas'

// obj1
// obj2

Tomando como inspiraci贸n los aportes de @irvingjuarez y @lgfh, les comparto una soluci贸n efectiva y m谩s corta:

.

.

P.D. Dej茅 los statements a la derecha de los if para que no ocupara m谩s l铆neas y la imagen no fuese m谩s larga.

Aqui hay un error, ya que en la funcion isObject, incluso aunque le pases como argumento un array, te da true. Sin embargo, existe otra forma de validar eso:
.
El funci贸n deber铆a quedar as铆;

function isObject(subject){
  return Object.prototype.toString.call(subject) == "[object Object]";
}

Sabemos si es un array si el string es [object Array]

Me parece que hay un momento en el que la clase se hace confusa y es el momento en que el profe decide en el ciclo For In anidar el if de si subjectIsArray, y ademas de la anidaci贸n, que utilice subjectIsArray como validaci贸n sin pasarle ningun parametro, a mi parecer debi贸 generar un keyIsArray al igual que lo hizo con keyIsObject, y de paso no anidar el if, a que no tiene proposito en si mismo.
les dejo el mismo codigo solo que con unas peque帽as modificaciones a ver que les parece.

const obj1 = {
  a:"b",
  c:"d",
  f:"g",
  capC(prop) {
    this.prop = toUpperCase(this.prop)
  },
  h:"i",
  j:"k",
}

function isObj (elm) {
  return Object.prototype.toString.call(elm) == '[object Object]'
  // return typeof elm == 'object'
}

function isArr (elm) {
  return Array.isArray(elm)
}

function deepCopy (elmToCopy) {
  let copyElm
  
  let itsAnObject = isObj(elmToCopy)
  let itsAnArray = isArr(elmToCopy)
  
  if(itsAnArray)
  {
    copyElm = []
  } 
  else if (itsAnObject)
  {
    copyElm = {}
  } 
  else 
  {
    return elmToCopy
  }
  
  for(subElm in elmToCopy)
  {
    const subElmItsObj = isObj(elmToCopy[subElm])
    const subElmItsArr = isArr (elmToCopy[subElm])
    
    if(subElmItsObj)
    {
      copyElm[subElm] = deepCopy(elmToCopy[subElm])
    } 
    else if (subElmItsArr)
    {
      copyElm.push(elmToCopy[subElm])
    } else {
      copyElm[subElm] = elmToCopy[subElm]
    }
  }
  
  return copyElm
}

let obj2 = deepCopy(obj1)

console.log(obj2)


Esta clase me hizo volar la cabeza pero todo totalmente comprensible! El mejor profe!

esta clase si que me mareo tuve que verla varias veces!! es un excelente profe pero este tema me pudo xD a volver a mirar hasta comprender

Holaa, comparto mi solucion a la funcion deepCopy

function typeOfElem(elem) {
  let result;

  switch (Object.prototype.toString.call(elem)) {
    case "[object Object]":
      result = "object";
      break;
    case "[object Array]":
      result = "array";
      break;
    default:
      result = "no problem";
      break;
  }

  return result;
}

function deepCopy(elem) {
  let copy;
  let elemType = typeOfElem(elem);

  if (elemType === "array") {
    copy = [];
  } else if (elemType === "object") {
    copy = {};
  } else {
    return elem;
  }

  for (let item in elem) {
    let elemType2 = typeOfElem(item);

    if (elemType2 === "object") {
      item = deepCopy(item);
    }

    if (elemType === "array") {
      copy.push(item);
    } else {
      copy[item] = elem[item];
    }
  }

  return copy;
}

Una versi贸n acortada y simplificada que estuve probando 馃槢 :

const deepCopy = elem => {
  if(!isObject(elem)) return elem
  
  const copyOfElem = isArray(elem) ? [] : {}
  
  for(key in elem){
    const current = elem[key]
    
    copyOfElem[key] = isObject(current)
    		? deepCopy(current)
    		: current
  }
  
  return copyOfElem
}

El funcionamiento es el mismo, pero utiliza algunos trucos para acortar espacio

  1. Solo verifica si es un objeto porque los arrays tambi茅n son objetos, as铆 que solo puede ser o un objeto o un primitivo
  2. Para inicializar la copia como solo tiene 2 opciones (array u objeto) entonces usa una ternaria
  3. Con el for in ya recorre el array as铆 que solo debe verificar si el elemento es un objeto o agregar el elemento en esa posici贸n

Hice algunas pruebas y funcionan igual, pero a lo mejor se me escapa alg煤n edge case, si lo ven me servir铆a mucho, grax ;D

Tuve que ver el video 3 veces para lograr comprenderlo, pero al fin pude lograrlo, creo que las clases de Juan son de lo mejor y su energ铆a lo es todo 馃槃

Les comparto como anot茅 lo que hace la funci贸n deepCopy para mis apuntes:

  1. Recibe como par谩metro una variable.
  2. Se verifica si es un objeto, array o otro tipo de variable.
    1. Si es objeto o array entra en un ciclo. Sino retorna la copia de la variable.
  3. Si se entra al ciclo, por cada elemento o atributo del objeto o array
    1. Se verifica nuevamente si es objeto, array o variable.
      1. Si este atributo es un objeto, se llama de nuevo a la misma funci贸n. (Ac谩 esta la recursividad). Y se vuelve al primer paso hasta copiar este objeto.
    2. Si es un array se utiliza el m茅todo push.
    3. Si es otro tipo de variable solo se hace una asignaci贸n normal.
  4. Finalmente el ciclo acaba y se devuelve el array o el objeto copiado.

Deep copy con recursividad

const obj1 = {
  a: 'a',
  b: 'b',
  c: {
    d: 'd',
    e: 'e',
  },
  editA() {
    this.a = 'AAAAA';
  }
};

function isObject(subject) {
  return typeof subject === 'object' && subject !== null;
}

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

function deepCopy(subject) {
  let copySubject;

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

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

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

    //*if else - if else
    keyIsObject ? copySubject[key] = deepCopy(subject[key]) : subjectIsArray ? copySubject.push(subject[key]) : copySubject[key] = subject[key];
  }

  return copySubject;
}

deepCopy(obj1);

Excelente clase, cada detalle bien llevado hasta aqui.

Aqui dejo mi versi贸n refactorizada de deepCopy:

function deepCopy(subject) {
  if (typeof subject !== 'object') return subject;
  const copySubject = Array.isArray(subject) ? [] : {};
  Object.keys(subject).forEach(key => {
    copySubject[key] = deepCopy(subject[key]);
  })
  return copySubject;
}

me hizo recordar cuando en la universidad nos pidieron elaborar un programa que le pegaras un bloque de codigo y te dijera que lenguaje era cuantas variables se habian creado y si existian condicionales y cuantos eran鈥 analizar linea por linea los texto, en este caso analizando cada loop del for in

Debugeado a mano para quienes no sepan que esta pasando a la perfeccion 鉂わ笍

function deepCopy(subject) {
    let copySubject;

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

    if (subjectIsArray) 
    {
        copySubject = [];
        console.log("Inicializammos en ", copySubject);
    } 
    
    else if (subjectIsObject) 
    {
        copySubject = {};
        console.log("Inicializamos en ", copySubject);
    } 
    else 
    {
        return subject;
    }

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

        if (keyIsObject) 
        {
            copySubject[key] = deepCopy(subject[key]);
            console.log(copySubject, "BandObject");
        } 
        
        else 
        {
            if (subjectIsArray) 
            {
                copySubject.push(subject[key]);
                console.log(`push of ${subject[key]} : BandArray`);
            } 

            else 
            {
                copySubject[key] = subject[key];
                console.log(copySubject, " BandNormie");
            }
        }
    }

    return copySubject;
}

Si ven algun error agradezco de sus comentarios

Simplific谩ndolo un poco, el c贸digo quedar铆a as铆:

function deepCopy(element) {
  let copy;
  
  if (Array.isArray(element)) copy = [];
  else if (typeof element === "object") copy = {};
  else return element;
  
  for (item in element) {
    copy[item] = deepCopy(element[item]); 
  }
  return copy;
}

En ese caso yo lo hago asi鈥 estoy en el 2030

//objeto ejemplo
const original= {
    name: "Pedrito",
    lastName: "Roca",
    personalinformation: {
       date: "11-11-2222",
       phone: 1122334455, 
    },
    editA() {
        this.name = "Pietro";
    },
    unascosas:[1,2,3,{a:"holaa", b:"lalalsl", c:23},5,6]
}; 

//metodo ultrasuperfantastico para copiar
const copia = {...original};

console.log(original);
console.log(copia);

Mi propuesta del algoritmo

function miDeepCopy(subject){
    let copySubject;
    if (typeof subject === 'object' && subject !== null) {
        copySubject = {};
    } else if(Array.isArray(subject)){
        copySubject = [];
    }else{
        return subject;
    }

    for(let i in subject){
        if(typeof subject[i] === 'object' && subject[i] !== null){
            copySubject[i] = miDeepCopy(subject[i]);
        }else if(Array.isArray(subject[i])){ //if it is an array
            copySubject[i] = subject[i].slice();
        }else{
            copySubject[i] = subject[i];
        }
    }
    return copySubject;
}

me siento satisfecho de aprender a la primera esto, puedo mimir en paz hoy

a pesar que tuve que repetir la clase un par de veces, y detenerme en la explicacion y reflexionar lo que decia el profe, es gratificante poder entender el codigo, y asi mejorar nuestra comunicacion con nuestra maquina, muy satisfecho con esta clase.

As铆 fu como lo entend铆

//DEEP COPY


    //Funciones para comprobar que el tipo de dato

function isObject(subject){
    return typeof subject == "object"; // recordar que los arrays tambien son de tipo objeto en js
}

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

    // Empieza la funcion de copiado profundo

Empieza la funcion de copiado profundo

function deepCopy(subject) {
    let copySubject; // Inicializa la constante que enviara al final

comprueba que la variable enviada sea un array o un objeto

    const subjectIsObject = isObject(subject); // si es array u objeto va a dar true

    const subjectIsArray = isArray(subject); // s贸lo si es array dara un true

Es necesario que este ciclo if compruebe primero que es un array, ya que como se vio anteriormente los array tambi茅n son objetos

    if (subjectIsArray) {
        copySubject = []; // transforma la variable inicializada en un array
        console.log("Es array");
    } else if (subjectIsObject) {
        copySubject = {}; // transforma la variable inicializada en un objeto
        console.log("Es objeto");
    } else {
        return subject;
 // en caso de que no sea una variable tipo objeto termina la funcion enviando solo el dato a copia
    }

    for (key in subject) {
        const keyIsObject = isObject(subject[key]); // Comprueba que la Key sea un variable de tipo objeto
        if (keyIsObject) {
            copySubject[key] = deepCopy(subject[key]); // En caso que lo sea llamara la funcion deepCopy de nuevo
        } else {
            if (subjectIsArray) {
                copySubject.push(subject[key]); // Se envia el valor de la Key que no es de tipo objeto (Number, String o boolean) al array copiado
            } else {
                copySubject[key] = subject[key]; // Se evia copia de la key al objeto copiado
            }
        }
    }
    return copySubject;};

`


//Original object
const obj1 = {
    a: "a",
    b: "b",
    c: {
        d: "d",
        e: "e",
    },
    // f: ["apple", "banana"],
    editA() {
        this.a = "aaaa";
    }
};

//----------- Recursion. Recursive function

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

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

//DeepCopy function
function deepCopy(subject) {
    let copySubject;

    //Validator inside the function
    const subjectIsObject = isObject(subject);
    const subjectIsArray = isArray(subject);

    //Initialize the variable copySubject 
    if(subjectIsObject) {
        copySubject = {};
    } else if (subjectIsArray) {
        copySubject = [];
    } else {
        return subject;
    }

    //For loop
    for (key in subject) {
        //Check if the key is an object
        const keyObject = isObject(subject[key]);
        const keyArray = isArray(subject[key]);
        //Make conditionals. Object, array, something else.
        if(keyObject) {
            copySubject[key] = deepCopy(subject[key]);
        } else {
            if(keyArray) {
                copySubject.push(subject[key]);
            } else {
                copySubject[key] = subject[key];
            }
        }
    }
    return copySubject;
}

Nunca me imagine que copiar un Objeto fuese de esta manera tan compleja

Algo curioso que note jugando con la funcion 鈥榠sObject鈥 es que devuelve 鈥榯rue鈥 con los arrays tambien, incluso haciendo mas estricta la comparacion con ===

function isObject(subject) {
  return typeof(subject) == 'object';
}
const object = {};
const array = [];

console.log(isObject(array))  // true

Esta clase podr铆a llegar a ser un poco confusa si no se tienen bien los fundamentos, b谩sicamente estamos reduciendo los objetos a datos primitivos los cuales guardan el valor y no la referencia en memoria, por lo cual al copiarlos estamos copiando el valor que tienen guardado.

Yo simplemente hubiese usado el desestructurador de objetos y sha, jaja

Pero entiendo que la recursividad era par dar un ejemplo de su uso

const obj1 = {
  a: "a",
  b: "b",
  c: {
     d: "d",
     e: "e", 
  },
  editA() {
      this.a = "AAAAA";
  }
};
function isArray (subject) { return Array.isArray(subject) };
function isObject (subject) { return typeof subject == "object" };

function deepCopy(subject) {
  let copySubject;
  const subjectIsArray = isArray(subject);
  const subjectIsObject = isObject(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;
}  

Les dejo mis apuntes de la clase donde tambien revisar mis apuntes del curso en gitbook:
teniendo como base el siguiente objeto con metodos vamosa ir aplicando la recursividad con el deep Copy:

const obj1 = {    a: "a",    b: "b",    c: {        d: "d",        e: "e",    },    editA() {        this.a = "AAAAAA";    }};

Validaremos si nuestro objeto de prueba es un objeto o si es un array, en el uno utilizaremos la palabra reservada typeof que nos permite validar si nuesto objetodePrueba es un objeto o lo que le pidamos, y con el array llamamos al superprototypoArray y luego a su metodo estatico isArray.

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

Para hacer el deepcopy vamos a validar si es un objeto o un array y de acuerdo a eso validaremos y daremos una respuesta de copiado seg煤n sea un objeto o un array

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 (keyIsObject) { 
                 copySubject[key] = deepCopy(subject[key]);
	} else {
                if (subjectIsArray) {
                    copySubject.push(subject[key]);
                } else {
                    copySubject[key] = subject[key];
                }
            }
        }
    }        return copySubject;
}

De esta forma iteramos la copia de nuestros objetos por cada uno de sus valores, ya tengan otros objetos u otros arrays dentro de ellos, incluyendo a sus m茅todos.

Maneras de copiar un Array(Deep and shallow)

Existen diferentes maneras de copiar un array, una de ellas es con el m茅todo slice(), que nos permite copiar un array sin modificar el original.

var original = [true, true, undefined, false, null];

//slice()
var copy1 = original.slice(0);

//spread operator
var copy2 = [...original];

Estas tienden a no funcionar cuando hay un objeto o un arreglo dentro de un array. Cuando pasa eso necesitas un deep copy
shallow copy:

var deepArray = [["Carlos"]];
var shallowCopy = deepArray.slice(0);

shallowCopy[0].push("es chevere");
console.log(deepArray[0], shallowCopy[0]);
// ["Carlos", "es chevere"]


var deepCopy = JSON.parse(JSON.stringify(deepArray));
deepCopy[0].push("es chevere");
console.log(deepArray[0],deepCopy[0])


Cuando hacemos copy, copiamos el pointer del original array

Ac谩 esta mi aporte, utilice algunas especificaciones de ES6+
Pueden ver el resto de los retos que he resuelto en este y otros cursos de esta misma escuela ac谩: https://github.com/EdinsonRequena/JsSchool
Espero les sirva de ayuda 鉂わ笍

const isObject = subject => typeof subject == 'object'
const isArrayFunc = subject => Array.isArray(subject)

const deepCopy = subject => {
    let copySubject

    const subjectIsObject = isObject(subject)
    const subjectIsArray = isArrayFunc(subject)

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

    for (let key in subject) {
        const keyIsObject = isObject(subject[key])
        if (keyIsObject) copySubject[key] = deepCopy(subject[key])
        else subjectIsArray ? copySubject.push(subject[key]) : copySubject[key] = subject[key]
    }

    return copySubject
}

const obj = {
    name: 'Andrea',
    lastName: 'Vinas',
    email: 'andre',
    age: 21,
    objectTest: {
        a: 'a',
        b: 'b',
        1: '1',
    },
    aprovedCourse: ['JavaScript', 'NodeJS', 'ReactJS'],
    addCourse(newCourse) {
        this.aprovedCourse.push(newCourse);
    }
}

const example = deepCopy(obj)

Excelente clase 馃榾

.

Exelente clase, qued贸 mucho m谩s claro el concepto introducido en la clase anterior.

UIff!! como el nombre de la clase mismo lo dice, vaya que esto si estuvo profundo y enredado de entender, como al minuto 6" ya me perd铆馃檪馃槬

Me perd铆 entre tantos objetos 馃槮

Estuve buscando en que momento se usaba el spread operator, asi que el spread operator seria un deep copy,

rayos, el profe siempre se equivoca con lo de declarar e inicializar xD

esta clase ha sido bien compleja鈥

que buena clase, es complejho pero est谩 muy bien explicado y se hace m谩s f谩cil. Encontr茅 un peque帽o error: la funci贸n isObject devuelve true cuando le pasamos un array. Lo solucion茅 para la funci贸n deepCopy cambiando un poco la valdiaci贸n:

function deepCopy (subject) {
    let copySubject;
    if (isObject(subject) && !isArray(subject)) { //si no es un array pero si es un objeto
        copySubject = {};
        for (key in subject) {
           copySubject[key] = deepCopy(subject[key]) 
        }
    } else if (isArray(subject)) {
        copySubject = [];
        for (key in subject) {
            copySubject.push(subject[key]);
        }
    } else {
        copySubject = subject
    }
    return copySubject
}

Seguro hay mejores maneras de hacerlo, espero que a alguien le sirva igual