lodash一些深浅拷贝的测试

代码如下

// assign：后面的会覆盖前面的对象属性，不会递归遍历。
// merge: 后面的会覆盖前面的对象属性，会递归遍历。
// defaults：前面的属性不为undefined且与后面属性名相同，后面的对象属性会被忽略，不会递归遍历。
// defaultsDeep: 前面的属性不为undefined且与后面属性名相同，后面的对象属性会被忽略，会递归遍历。
// Object.assign()
// JSON.stringify()  JSON.parse()

// 1.Object.assign()是浅拷贝，也就是，假如源对象的属性值是一个对象的引用,那么它也只指向那个引用
// 而不是拷贝成一个新对象作为新属性
// 相同的属性后面的会覆盖前面的，不同的属性会一起都添加上去
// let obj1 = {
//   a: 1,
//   b: {
//     c: 2
//   }
// }

// let newObj = Object.assign({}, obj1)
// newObj.b.c = 100
// console.log(obj1.b.c)//100 

// 2.json.strinfgy是深拷贝，但是属性是函数的话，不会被拷贝
// let obj1 = {
//   a: 1,
//   b: {
//     c: 2
//   },
//   d() {
//     console.log('11')
//   }
// }

// let newObj = JSON.parse(JSON.stringify(obj1))
// newObj.b.c = 100
// console.log(obj1.b.c)//2 
// console.log(newObj.d())//报错newObj.d is not a function

const _ = require('./lodash')
// 看来import是模块化专用的引包引js文件方式，没有npm init的话还是不行
// import _ from './lodash'// Cannot use import statement outside a module


// 1.lodash拷贝方法一.assign  浅拷贝
// 相同的属性后面的会覆盖前面的，不同的属性会一起都添加上去
// let obj1 = {
//   a: 1,
//   b: {
//     c: 2
//   },
//   d: 111
// }
// let obj2 = {
//   a: 3,
//   b: {
//     c: 4
//   }
// }
// let newObj = _.assign({}, obj1, obj2)
// newObj.b.c = 100
// console.log(obj2.b.c)//100


// 2.lodash拷贝方法一.merge  深拷贝
// 相同的属性后面的会覆盖前面的，不同的属性会一起都添加上去
// let obj1 = {
//   a: 1,
//   b: {
//     c: 2
//   },
//   d: 111
// }
// let obj2 = {
//   a: 3,
//   b: {
//     c: 4
//   }
// }
// let newObj = _.merge({}, obj1, obj2)
// newObj.b.c = 100
// console.log(obj2.b.c)//4


// 3.lodash拷贝方法一.defaults  浅拷贝
// 相同的属性只要不为空，后面再怎么加上去拷贝都不会影响到前面的，不同的属性会一起都添加上去
// let obj1 = {
//   a: 1,
//   b: {
//     c: 2
//   },
//   d: 111
// }
// let obj2 = {
//   a: 3,
//   b: {
//     c: 4
//   }
// }
// let newObj = _.defaults({}, obj1, obj2)
// newObj.b.c = 100
// console.log(obj1.b.c)//100  

// 4.lodash拷贝方法一.defaultsDeep  浅拷贝
// 相同的属性只要不为空，后面再怎么加上去拷贝都不会影响到前面的，不同的属性会一起都添加上去
// let obj1 = {
//   a: 1,
//   b: {
//     c: 2
//   },
//   d: 111
// }
// let obj2 = {
//   a: 3,
//   b: {
//     c: 4
//   }
// }
// let newObj = _.defaultsDeep({}, obj1, obj2)
// newObj.b.c = 100
// console.log(obj1.b.c)//2 

// 5.lodash拷贝方法一.extend 也就是assignIn 深拷贝
// 相同的属性后面的会覆盖前面的，不同的属性会一起都添加上去
// 和merge很像，但是这个方法原型链上的属性也会拷贝
let obj1 = {
  a: 1,
  b: {
    c: 2
  },
  d: 111
}
let obj2 = {
  a: 3,
  b: {
    c: 4
  }
}
let newObj = _.extend({}, obj1, obj2)
newObj.b.c = 100
console.log(obj1.b.c, newObj)//2  

// 5.1extend测试
// 把源对象原型链上的属性也合并到目标对象上！
function Foo() {
  this.c =
    3;
}


Foo.prototype.d =
  4;

let fuck = _.extend({
  a:
    1
},
  new Foo());

console.log(fuck)







//问题 展开运算符是深拷贝吗  浅拷贝。。。
// let obj1 = {
//   a: 1,
//   b: {
//     c: 2
//   },
//   d: 111
// }
// let obj2 = { ...obj1 }
// obj2['b']['c'] = 100
// console.log(obj1)

// 参考资料
// https://blog.csdn.net/u011153667/article/details/52275797
// https://blog.csdn.net/qwe435541908/article/details/105008730