es6对象拷贝

es6 对象深拷贝和浅拷贝

let obj1 = { a: 0 , b: { c: 0}}; 
let obj2 = Object.assign({}, obj1); 
console.log(JSON.stringify(obj2)); // { a: 0, b: { c: 0}} 
//第一层次是深拷贝
obj2.a = 1; 
console.log(JSON.stringify(obj1)); // { a: 1, b: { c: 0}} 
console.log(JSON.stringify(obj2)); // { a: 0, b: { c: 0}} 
//第二层次是浅拷贝
obj2.b.c = 3; 
console.log(JSON.stringify(obj1)); // { a: 1, b: { c: 3}} 
console.log(JSON.stringify(obj2)); // { a: 2, b: { c: 3}} 

// 深拷贝 
obj1 = { a: 0 , b: { c: 0}}; 
let obj3 = JSON.parse(JSON.stringify(obj1)); 
obj1.a = 4; 
obj1.b.c = 4; 
console.log(JSON.stringify(obj3)); // { a: 0, b: { c: 0}}
 

//====Object.assign=====
//----------------对象拷贝--第一层次深拷贝----------------
let data =  {nm:'nm1',age:1} ;
let target={} 
//深拷贝
Object.assign(target,data);
target.nm='nmtarget'
alert(JSON.stringify(data));//{nm:'nm1',age:1}
//----------------数组拷贝--浅拷贝----------------
let arrdata =  [{nm:'nm1',age:1}] ;
let arrtarget=[]
//浅拷贝
Object.assign(arrtarget,arrdata);
arrtarget[0].nm='nmtarget'
alert(JSON.stringify(arrdata));//{nm:'nmtarget',age:1}

//====扩展运算符...=====
//----------------对象拷贝--第一层次深拷贝----------------
let data =  {nm:'nm1',age:1} ;
let target={...data} 
target.nm='nmtarget'
alert(JSON.stringify(data));//{nm:'nm1',age:1}
//----------------数组拷贝--浅拷贝----------------
let arrdata =  [{nm:'nm1',age:1}] ;
let arrtarget=[...arrdata]
arrtarget[0].nm='nmtarget'
alert(JSON.stringify(arrdata));//{nm:'nmtarget',age:1}

=============对象操作===========

//------深拷贝
let a={title:'1'};
let b={...a,title:"2"};
console.log(JSON.stringify(a));//{"title":"1"}
console.log(JSON.stringify(b));//{"title":"2"}

a={title:'1'};
b={...a};
b.title='2';
alert(JSON.stringify(a));//{"title":"1"}
alert(JSON.stringify(b));//{"title":"2"}

//------浅拷贝
a={title:'1'}
b=a;
b.title='2';
alert(JSON.stringify(a));//{"title":"2"}
alert(JSON.stringify(b));//{"title":"2"}

=============数组拷贝==========
let data = [{nm:'nm1',age:1},{nm:'nm2',age:2}];
 
 //深拷贝
let cacheData = data.map(item => ({ ...item }));
cacheData[0].nm='nmcacheData'
alert(JSON.stringify(data));

//浅拷贝
let  Data1 = data ;
Data1[0].nm='nmData1'
alert(JSON.stringify(data)); 

//浅拷贝
let  Data2 =[...data];
Data2[0].nm='nmData2'
alert(JSON.stringify(data)); 

 

https://blog.csdn.net/Dong8508/article/details/83338847

 

const object1 = {
  a: 1,
  b: 2,
  c: 3
};
 
const object2 = Object.assign({c: 4, d: 5}, object1);
console.log(object2);
 
> Object { c: 3, d: 5, a: 1, b: 2 }
 
这是浅拷贝，返回的不是一个新对象，而是把一个或多个源对象添加到目标对象
 
 
let object1 = {
  a: 1,
  b: 2,
  c: 3
};
 
let object2 = {...object1};
object1.a=11;
 
console.log(object2);
> Object { a: 11, b: 2, c: 3 }
 
这也是浅拷贝

 

let object1 = {
  a: 1,
  b: 2,
  c: 3
};
 
let object2 =JSON.parse( JSON.stringify(object1));
object2.a=11;
 
console.log(object1,object2);
 
> Object { a: 1, b: 2, c: 3 } Object { a: 11, b: 2, c: 3 }

https://www.cnblogs.com/xbblogs/p/8954165.html

==========浅拷贝1=========
function clone(origin) {
  return Object.assign({}, origin);
}

==========浅拷贝2=========

function clone(origin) {
  return JSON.parse(JSON.stringify(origin))
}

==========深拷贝1=========
function clone(origin) {
  let originProto = Object.getPrototypeOf(origin);
  return Object.assign(Object.create(originProto), origin);
}

==========深拷贝2=========

function clone(obj){
    return  Object.create(
      Object.getPrototypeOf(obj),
      Object.getOwnPropertyDescriptors(obj)
    )
}

 
 
​