La comprensión en profundidad de la pila JavaScript y la pila, copia superficial y copia profunda

JavaScript en copia superficial y copia en profundidad de
  la escuela durante tanto tiempo debemos tener JavaScript poco profundas frente a copia profunda aún no está familiarizado con él, ya que se utiliza hoy en día en el proyecto, y tarde o temprano tiene que ordenar sus pensamientos, y antes de la comprensión, empezamos con los datos de localización almacenados tipo de pila JavaScript para empezar con él!           

Ahora tomamos el tema de aprender!

 Uno: ¿Cuál es la pila?

  Todos sabemos: En el campo de la informática, la pila es de dos estructuras de datos, sólo pueden estar en un extremo (llamado la parte superior de la pila (parte superior)) para insertar elementos de datos y borrado.

Montón: prioridad de la cola, FIFO; lanzado asignado automáticamente por el sistema operativo, los parámetros de la función almacenados, las variables locales, y similares. Operar de manera similar a una estructura de datos de la pila.
Pila: último en salir; la asignación dinámica, la liberación es generalmente asignado por el programador, si el programador no libera al final del programa se puede recuperar desde el sistema operativo, lo que toca lista de distribución similar.
Por encima de todo pertenecen a las piezas básicas de la computadora, esto no entrar en detalles, vamos a analizar lo JavaScript para ponerse en contacto con la pila.
Dos: tipos básicos y los tipos de referencia y la pila ¿Cuál es el enlace en JavaScript?
tipos de datos de JavaScript se dividen en dos clases:
1. tipos básicos : Indefinido, NULL, booleanos, y el número de la cadena, estos 5 tipos básicos de datos se puede acceder directamente, que se asignan de acuerdo con el valor almacenado en la memoria de pila (stack) segmento de datos simple, se determina el tamaño de los datos, el espacio de memoria puede asignarse.
2. Los tipos de referencia: un objeto que se almacena en la memoria de pila (pila), una variable se guarda realmente puntero que apunta a otra ubicación.
  Por encima de nosotros sabemos lo que es la pila, y los tipos de datos de JavaScript, aquí estamos JS acuerdo con el tipo de datos para explicar sus circunstancias copiar:

var obj1 = {nombre: 'bangbang', edad: 18 };
var b = obj1;
var c = obj1.age; 

console.log (b.name); // bangbang 
console.log (c); // 18 
// 改变b和c值的 
b.name = 'yanniu' ; 
c = 22 ; 
console.log (obj1.name); // yanniu 
console.log (obj1.age); // 18

 Ver más arriba: cuando cambiamos b de los datos, vemos los datos obj1.name está cambiando, pero cambiamos de datos c, se encontró que el valor de obj1.age no cambia, lo que muestra: b y obj1 operación variable es el mismo objeto, c, y completamente independiente de obj1. Se ilustra de la siguiente manera:

   

Tres: ¿Qué es la copia superficial?
  De acuerdo con la declaración anterior, los tipos básicos de copia en la memoria solamente cuando abrieron un nuevo espacio, y su elemento padre (de nuevo, que llamamos el objeto primario se copia elementos) pertenecen el uno al otro quiere hacer algo, por lo que la copia es la profundidad relativa en los tipos de referencia, por lo que podemos ahorrar una referencia al tipo de objeto padre! ¡Hey! a continuación, nos fijamos!
Por ejemplo:

var father1 = {nombre: 'Shàngdì', Edad: 1000, Job: [ 'Maestro', 'Cook' ]};
 // función de copia superficial 
función Copiar (obj) {
 var Childs = {};
 para ( var clave en obj ) { 
Childs [Key] = obj [Key]; 
} 
regreso Childs; 
} 
var niño1 = Copiar (father1); 
la console.log (niño1); // {nombre: 'Shàngdì', Edad: 1000} 
la console.log ( typeof child1); // objeto 

// cambiar el nombre del nombre del atributo objeto secundario del objeto padre no encontraron ningún efecto ja, ja! 
= Child1.name 'bangbang' ;
la console.log (father1); // {nombre: 'Shàngdì', Edad: 1000} 
la console.log (niño1); // {nombre: 'bangbang', Edad: 1000} 

// NOTA: Este cambio subobjeto atributo de trabajo que está cambiando matriz 
// empleo hallazgo para el objeto principal resultó ser influyente, miedo a la muerte del bebé, cómo hacerlo, y que esto lo usa copiar es lo correcto! 
child1.job.push ( 'programador' ); 
el console.log (father1); // {nombre: 'Shàngdì', Edad: 1000, Job: [ 'Maestro', 'Cook', 'programador']} 
el console.log (niño1); // {nombre: 'Shàngdì', Edad: 1000, Job: [ 'Maestro', 'Cook', 'programador']}

 

Pueden ser analizados por la anterior: un poco profunda copia de las veces, cuando cambiamos la matriz de objetos hijo, padre objetos realidad cambie demasiado, es decir: el objeto primario y objetos secundarios en copia superficial cuando apuntan a la misma matriz de la memoria: la Figura:

 Si queremos copiar y objeto hijo padre con ninguna asociación, entonces tenemos que usar copia profunda! ¡Hey! Hijo no puede ser seguido por completo el largo ah padre!

Cuatro: ¿Qué es una copia profunda?
copia profunda se copia en el objeto padre al objeto secundario, y las operaciones tanto de la memoria y la posterior copia independientemente el uno del otro!

función deepCopy (obj) {
 var o;
interruptor ( typeof obj) {
 caso 'indefinido': descanso ;
caso 'cadena': o = obj + ''; romper ;
caso 'número': o = obj - 0; romper ;
caso 'booleano': o = obj; romper ;
caso 'objeto' :
 si (obj === nula ) { 
     O = nulo ; 
   } Demás {
 si (obj instanceof Array) { 
     O =[];
     para ( var i = 0, len = obj.length; i <len; i ++ ) { 
        o.push (deepCopy (obj [i])); 
     } 
  } Demás { 
     O = {};
    para ( var k en obj) { 
       O [k] = deepCopy (obj [k]); 
     } 
  } 
} 
Romper ;
por defecto : o = obj; romper ; 
 } 
    Devolver o; 
}

 

Aquí hay algunas maneras clonar para su referencia, pero son diferentes, sus propias pruebas:
Segundo método: La forma más fácil

función deepCopy (obj) {
     retorno JSON.parse (JSON.stringify (obj)); 
}

Método tres:

función deepCopy (obj) {
 var newobj, obj;
si (obj.constructor == Object) { 
  newobj = nuevo obj.constructor (); 
} Demás { 
  newobj = nueva obj.constructor (obj.valueOf ()); // valueOf ()方法返回matriz对象的原始值
}
 para ( var clave en obj) {
 si (newobj [clave]! = Obj [clave]) {
 si ( typeof (obj [clave]) == 'objeto' ) { 
 newobj [tecla] = deepCopy (obj [tecla]); 
} Demás {
  newobj [tecla] = obj [tecla]; 
 } 
} 
} 
Newobj.toString = obj.toString; 
newobj.valueOf = obj.valueOf;
volver newobj; 
}

Método cuatro:

var cloneObj = función (obj) {
 var str, newobj = obj.constructor === matriz? []: {};
si ( typeof obj == 'objeto'! ) {
 retorno ; 
} Demás  si (window.JSON) { 
str = JSON.stringify (obj), // 系列化对象 
newobj = JSON.parse (str); // 还原 
} más {
 para ( var i en obj) { 
newobj [i] = typeof obj [i] === 'objeto'?  
cloneObj (obj [i]): obj [i]; 
} 
}
volver newobj; 
};

Método cinco: (JavaScript Object Oriented Programming Guide)

función deepCopy (p, c) { 
c = c || {};
para ( var i en p) {
 si (p.hasOwnProperty (i)) {
 si ( typeof p [i] === 'objeto' ) { 
c [i] = Array.isArray (p [i])? []: {}; 
deepCopy (p [i], c [i]); 
} Más { 
c [i] = p [i]; 
} 
} 
} 
Retorno } 

Original a partir de: https://blog.csdn.net/flyingpig2016/article/details/52895620