原生js中的深浅拷贝笔记

深浅拷贝,是我们在处理数据中一定会遇到的问题,浅拷贝是引用地址的拷贝,主要是针对object类型,新数据和原始数据会相互影响。深拷贝是值的拷贝,是单独一个内存空间,不会互相影响。

浅拷贝

import clone from "/node_modules/lodash-es/clone.js";
import cloneDeep from "/node_modules/lodash-es/cloneDeep.js";

const obj = {
  name: "zs",
  age: 18,
  sex: "男",
  address: {
    province: "北京",
    city: "海淀",
  },
};
/**
 * 浅拷贝
 */
const o = obj;
o.name = "ls";
console.log(o);
console.log(obj);

/**
 * 浅拷贝
 */
const o = clone(obj);
o.name = "ls";
o.address.province = "上海";
console.log(o);
console.log(obj);
// concat() 方法用于连接两个或多个数组。此方法不会更改现有数组,而是返回一个新数组。
// 但是是一个浅拷贝,如果数组中包含引用类型,则两个数组中该位置的元素是同一个对象
import cloneDeep from "/node_modules/lodash-es/cloneDeep.js";
const arr1 = [1, 2, 3];
const arr2 = [4, 5];

const arr3 = arr1.concat(arr2);
console.log("🚀 ~ arr3:", arr3);
arr2.push(6);
console.log("🚀 ~ arr2:", arr2);
console.log("🚀 ~ arr3:", arr3);



const arr1 = [1, 2, 3];
const arr2 = [4, 5, { name: "张三" }];

const arr3 = arr1.concat(arr2);
console.log("🚀 ~ arr3:", arr3);
arr2[2].name = "李四";
console.log("🚀 ~ arr2:", arr2);
console.log("🚀 ~ arr3:", arr3);

// 深拷贝
const arr4 = cloneDeep(arr1.concat(arr2));
arr2[2].name = "李四";
console.log("🚀 ~ arr4:", arr4);
console.log("🚀 ~ arr2:", arr2);
```js

//浅拷贝
const o = { ...obj };
o.address.province = "山东";
o.name = "zxy";
console.log("🚀 ~ o:", o);
console.log("🚀 ~ obj:", obj);


const o1 = {};
Object.assign(o1, obj);
o1.address.province = "山东";
console.log("🚀 ~ obj:", obj);
console.log("🚀 ~ o1:", o1);

深拷贝,lodash里面的方法

//深拷贝
const o = cloneDeep(obj);
o.address.province = "山东";
o.address.city = "济南";
console.log("🚀 ~ obj:", obj);
console.log("🚀 ~ o:", o);

递归,封装深拷贝

function fn(num = 5) {
  if (num === 0) return;
  console.log(num);
  fn(--num);
}
fn();

function time() {
  console.log(new Date().toLocaleTimeString());
  setTimeout(time, 1000);
}

 time();

//浅拷贝
const obj = {
  name: "张三",
  age: 20,
  hobby: ["篮球", "足球"],
  address: {
    province: "广东省",
    city: "广州市",
  },
};
const o = {};

// for (let key in obj) {
//   o[key] = obj[key];
// }
// o.hobby.push("羽毛球");
// console.log("🚀 ~ o:", o);
// console.log("🚀 ~ obj:", obj);

//深拷贝
function deepClone(target, source) {
  for (let key in source) {
    if (source[key] instanceof Array || source[key] instanceof Object) {
      target[key] = source[key].constructor === Array ? [] : {};
      deepClone(target[key], source[key]);
    } else {
      target[key] = source[key];
    }
  }
}

// 深拷贝
// deepClone(o, obj);
// o.hobby.push("羽毛球");
// console.log("🚀 ~ o:", o);
// console.log("🚀 ~ obj:", obj);

深拷贝JSON.parse(JSON.stringify(obj));

const o2 = JSON.parse(JSON.stringify(obj));
const o2 = {};
deepClone(o2, obj);
obj.hobby.push("羽毛球2222");
obj.address.city = "深圳";
console.log("🚀 ~ o2:", o2);
console.log("🚀 ~ obj:", obj);

参考结果

在这里插入图片描述
在这里插入图片描述

  • 1
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
好的,关于JavaScript数组浅拷贝的问题,我可以为你做一个简要的介绍并举个例子。 首先来看浅拷贝,它会创建一个新的数组,这个新数组的元素是对原始数组对应元素的引用。这意味着如果修改原始数组的元素,新数组对应的元素也会受到影响。下面是一个浅拷贝的例子: ```javascript var originalArray = [1, 2, 3, 4]; var newArray = originalArray.slice(); originalArray[2] = 'changed'; console.log(originalArray); // [1, 2, "changed", 4] console.log(newArray); // [1, 2, 3, 4] ``` 上面代码使用了 `slice()` 方法进行了拷贝操作。我们修改了原始数组的第三个元素,发现新的数组并没有发生变化。 接下来再看拷贝,它会创建一个新的数组,并且完全复制原始数组的所有元素,这意味着即使修改原始数组的元素,新数组对应的元素也不会受到影响。由于JavaScript没有原生拷贝方法,我们通常需要使用递归函数或第三方库来实现。下面是一个使用 JSON 序列化和反序列化实现拷贝的例子: ```javascript var originalArray = [1, 2, [3, 4]]; var newArray = JSON.parse(JSON.stringify(originalArray)); originalArray[2][0] = 'changed'; console.log(originalArray); // [1, 2, ["changed", 4]] console.log(newArray); // [1, 2, [3, 4]] ``` 注意,使用 `JSON.stringify()` 和 `JSON.parse()` 实现拷贝的时候,要确保原始数组仅包含可以被 JSON 序列化的数据类型,例如数字、字符串、布尔值、null 以及包含这些类型的数组和对象。如果原始数组包含了函数、undefined、Symbol 等类型,这种方法就会出现问题了。 希望这个简单的例子能够帮助你理解 JavaScript 数组浅拷贝的概念。如果你还有其他问题,请随时向我提出。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值