深拷贝

首先说一下深拷贝的实现对象肯定是引用类型，比如Array和Object这样的，因为基本类型比如Number、String的值不可变的，这里的不可变就是数值本身的不可变，比如说2你不能凭空变成1，如果你说我的数值变量能够多次赋值啊，那和我这个不一样，你的是基本数据类型在栈中存储，栈中存的值，然后你赋给另外的值，那就是栈里面存的值变成了新的赋值。
然后这里也顺便说，引用对象的变量是存在栈里面的，存的是被引用对象在堆里面的地址

  • 栈是自动分配固定大小的空间内存，比如int是多少字节，short又是多少字节，然后系统自动回收，先进后出🐴。
  • 然后堆是动态分配内存，内存大小不固定，也不会自动释放，堆数据结构是一种无序的树状结构，同时它还满足key-value键值对的存储方式；我们只用知道key名，就能通过key查找到对应的value

然后说道哪里了？哦继续讲深拷贝

var obj1={
a:1,
b:{
	c:1
}
var obj2=obj1
var obj3=shallowCopy(obj1)
var obj4=deepCopy(obj2)

现在上面有三种拷贝方法来拷贝obj1，分别是赋值、浅拷贝和深拷贝

  • 对于obj2来说，就相当于在栈中给了一个变量，存储obj1对象在堆内存的中存储地址，所以obj1和obj2实质上是相同的，两个是互相在操作同一个对象
  • 对于shallowCopy来说，字面意思，只是浅浅的复制一层，涉及深的地方，也就是引用对象的地方，像代码中的b对象，就还是和obj1的b对象是一样的，存了个对象的地址，对于obj3来说它可以自由操控浅浅的a，不递归的拷贝，不深层次遍历的拷贝
  • 对于deepCopy深拷贝来说，就是完全的拷贝，实际上是递归的拷贝，深层次的拷贝
  • 下面代码就是完整实现
  • 另外要注意的是在判断是否是引用类型的时候注意点，也就是怎么判断一个数据的类型[指路]
  • 在下面主要用了
let arr=[]
let obj={}
console.log(typeof arr)//object
console.log(typeof obj)//object
console.log(typeof arr == 'object') //true
console.log(typeof arr == 'array')//false
console.log(typeof obj == 'object')//true
console.log(arr.constructor == Object) //false
console.log(arr.constructor == Array)//true
console.log(obj.constructor == Object)//true
var a=[]
console.log(typeof a )//'object'
// console.log(typeof a == object)// ReferenceError: object is not defined
console.log(typeof a == 'object')// true
console.log(typeof a == 'array')// false
console.log( a.constructor=== Object)//false
console.log(a.constructor === Array)//true
//遍历对象
// var obj = {'0':'a','1':'b','2':'c'};
// Object.keys(obj).forEach(function(key){
//      console.log(key,obj[key]);
// });
// const object1 = {
//   a: 'somestring',
//   b: 42
// };
//用for of 遍历对象 
//注意和map set的差别 for (let [key, value] of mySet.entries()) 
// for (const [key, value] of Object.entries(object1)) {
//   console.log(`${key}: ${value}`);// a: 'somestring'
//   console.log(object1[key])//somestring
//   console.log(object1.key)//undefined 不能用.和变量来取属性值
// }

const shallowCopy=function(obj){
  var newCon={}
  for(let i in obj){
    newCon[i]=obj[i]
  }
  return newCon
}

const deepCopy=function(obj){
  let newCon=obj.constructor==Object?{}:[]
  if(typeof obj !== 'object'){
    return ;
  }else{
    // 第一种
  //  return  newCon=JSON.parse(JSON.stringify(obj))
  // 第二种
  // for(let i in obj){
  //   // console.log(i) //属性名
  //   // console.log(obj[i])//属性值
  //   // console.log(obj.i)//undefined
  //   if(obj[i].constructor==Object){
  //     newCon[i]=shallowCopy(obj[i])
  //   }else{
  //     newCon[i]=obj[i]
  //   }
  // }
  // return newCon
  // 第三种
  for(const [key,value] of Object.entries(obj)){
    if(typeof value == 'object'){
      newCon[key]=deepCopy(obj[key])
    }else {
      newCon[key]=value
    }
  }
    return newCon
  }
}
let obj1={
    a:1,
    b:{
      c:1
    }
}
let obj2=deepCopy(obj1)
let obj3=shallowCopy(obj1)

console.log('first:')
console.log(obj1)//{ a: 1, b: { c: 1 } }
console.log(obj2)//{ a: 1, b: { c: 1 } }
console.log(obj3)//{ a: 1, b: { c: 1 } }


obj2.a=2
obj2.b.c=2

obj3.a=3
console.log('second:')
console.log(obj1)//{ a: 1, b: { c: 1 } }
console.log(obj2)//{ a: 2, b: { c: 2 } }
console.log(obj3)//{ a: 3, b: { c: 1 } }

obj3.b.c=3
console.log('third:')
console.log(obj1)//{ a: 1, b: { c: 3 } }
console.log(obj2)//{ a: 2, b: { c: 2 } }
console.log(obj3)//{ a: 3, b: { c: 3 } }

好的👌🏻，去跳绳了跳绳🤸🏽♀️