手写深拷贝

自定义深拷贝函数

一.简单的深拷贝
  • 代码示例:
const s1 = Symbol()
const s2 = Symbol()

const obj = {
  name: "why",
  friend: {
    name: "kobe"
  },
  foo: function() {
    console.log("foo function")
  },
  [s1]: "abc",
  s2: s2
}

obj.inner = obj

const info = JSON.parse(JSON.stringify(obj))
console.log(info === obj)
obj.friend.name = "james"
console.log(info)

  • 存在弊端:

    1. json在转换的过程中不识别函数和symbol,如下图所示
    2. 知识点:obj.inner = obj
      • 对象有个inner属性指向他自己
      • 如果用了json转换之后就不可以了,会报错

    在这里插入图片描述

二.手写深拷贝函数
  1. 基本实现
    function isObject(value) {
      const valueType = typeof value
      return (value !== null) && (valueType === "object" || valueType === "function")
    }
    
    function deepClone(originValue) {
      // 判断传入的originValue是否是一个对象类型
      if (!isObject(originValue)) {
        return originValue
      }
    
      const newObject = {}
      for (const key in originValue) {
        newObject[key] = deepClone(originValue[key])
      }
      return newObject
    }
    
    
    // 测试代码
    const obj = {
      name: "why",
      age: 18,
      friend: {
        name: "james",
        address: {
          city: "广州"
        }
      }
    }
    
    const newObj = deepClone(obj)
    console.log(newObj === obj)
    
    obj.friend.name = "kobe"
    obj.friend.address.city = "成都"
    console.log(newObj)
    
    
  2. 优化深拷贝(增加新的功能)

    • 用上述基本实现深拷贝的时候,数组是也会拷贝成为对象的,因此需要对其进行优化。
    • 函数的话一般不做拷贝处理,但是也要拿到函数,上述基本实现会把传入的函数变成{}显然是不合理的
    • 增加一下对于set和map的处理
    function isObject(value) {
      const valueType = typeof value
      return (value !== null) && (valueType === "object" || valueType === "function")
    }
    
    function deepClone(originValue) {
      // 判断是否是一个Set类型
      if (originValue instanceof Set) {
        return new Set([...originValue])
      }
    
      // 判断是否是一个Map类型
      if (originValue instanceof Map) {
        return new Map([...originValue])
      }
    
      // 判断如果是Symbol的value, 那么创建一个新的Symbol
      if (typeof originValue === "symbol") {
        return Symbol(originValue.description)
      }
    
      // 判断如果是函数类型, 那么直接使用同一个函数
      if (typeof originValue === "function") {
        return originValue
      }
    
      // 判断传入的originValue是否是一个对象类型
      if (!isObject(originValue)) {
        return originValue
      }
    
      // 判断传入的对象是数组, 还是对象
      const newObject = Array.isArray(originValue) ? []: {}
      for (const key in originValue) {
        newObject[key] = deepClone(originValue[key])
      }
    
      // 对Symbol的key进行特殊的处理
      const symbolKeys = Object.getOwnPropertySymbols(originValue)
      for (const sKey of symbolKeys) {
        // const newSKey = Symbol(sKey.description)
        newObject[sKey] = deepClone(originValue[sKey])
      }
      
      return newObject
    }
    
    
    // 测试代码
    let s1 = Symbol("aaa")
    let s2 = Symbol("bbb")
    
    const obj = {
      name: "why",
      age: 18,
      friend: {
        name: "james",
        address: {
          city: "广州"
        }
      },
      // 数组类型
      hobbies: ["abc", "cba", "nba"],
      // 函数类型
      foo: function(m, n) {
        console.log("foo function")
        console.log("100代码逻辑")
        return 123
      },
      // Symbol作为key和value
      [s1]: "abc",
      s2: s2,
      // Set/Map
      set: new Set(["aaa", "bbb", "ccc"]),
      map: new Map([["aaa", "abc"], ["bbb", "cba"]])
    }
    
    const newObj = deepClone(obj)
    console.log(newObj === obj)
    
    obj.friend.name = "kobe"
    obj.friend.address.city = "成都"
    console.log(newObj)
    console.log(newObj.s2 === obj.s2)
    
    
  3. 解决循环引用问题

    • 起因加入上述功具函数的测试代码obj对象有一个属性执行自己:obj.info = obj

    • 造成的后果就是在调用的时候陷入递归的循环引用

      • deepClone方法只有在满足一定条件之后才return,如果传入的是对象,他会继续走下面的遍历
        1. newObject[info ] = deepClone(originValue[info ])----------->originValue[info ]是对象 继续赋值
        2. newObject[info ] = deepClone(originValue[info ])------------>originValue[info ]还是对象…
        3. …以此反复,陷入死循环
        for (const key in originValue) {
          newObject[key] = deepClone(originValue[key])
        }
      
    • 代码:

    function isObject(value) {
      const valueType = typeof value
      return (value !== null) && (valueType === "object" || valueType === "function")
    }
    
    function deepClone(originValue, map = new WeakMap()) {
      // 判断是否是一个Set类型
      if (originValue instanceof Set) {
        return new Set([...originValue])
      }
    
      // 判断是否是一个Map类型
      if (originValue instanceof Map) {
        return new Map([...originValue])
      }
    
      // 判断如果是Symbol的value, 那么创建一个新的Symbol
      if (typeof originValue === "symbol") {
        return Symbol(originValue.description)
      }
    
      // 判断如果是函数类型, 那么直接使用同一个函数
      if (typeof originValue === "function") {
        return originValue
      }
    
      // 判断传入的originValue是否是一个对象类型
      if (!isObject(originValue)) {
        return originValue
      }
      if (map.has(originValue)) {
        return map.get(originValue)
      }
    
      // 判断传入的对象是数组, 还是对象
      const newObject = Array.isArray(originValue) ? []: {}
      map.set(originValue, newObject)
      for (const key in originValue) {
        newObject[key] = deepClone(originValue[key], map)
      }
    
      // 对Symbol的key进行特殊的处理
      const symbolKeys = Object.getOwnPropertySymbols(originValue)
      for (const sKey of symbolKeys) {
        // const newSKey = Symbol(sKey.description)
        newObject[sKey] = deepClone(originValue[sKey], map)
      }
      
      return newObject
    }
    
    
    // deepClone({name: "why"})
    
    
    // 测试代码
    let s1 = Symbol("aaa")
    let s2 = Symbol("bbb")
    
    const obj = {
      name: "why",
      age: 18,
      friend: {
        name: "james",
        address: {
          city: "广州"
        }
      },
      // 数组类型
      hobbies: ["abc", "cba", "nba"],
      // 函数类型
      foo: function(m, n) {
        console.log("foo function")
        console.log("100代码逻辑")
        return 123
      },
      // Symbol作为key和value
      [s1]: "abc",
      s2: s2,
      // Set/Map
      set: new Set(["aaa", "bbb", "ccc"]),
      map: new Map([["aaa", "abc"], ["bbb", "cba"]])
    }
    
    obj.info = obj
    
    const newObj = deepClone(obj)
    console.log(newObj === obj)
    
    obj.friend.name = "kobe"
    obj.friend.address.city = "成都"
    console.log(newObj)
    console.log(newObj.s2 === obj.s2)
    
    console.log(newObj.info.info.info)
    
    
  • 0
    点赞
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
深拷贝和浅拷贝是 JavaScript 中用于复制对象的两种不同方式。 浅拷贝只是复制对象的第一层属性,而不会复制对象中的引用类型属性。也就是说,浅拷贝只会复制对象的引用,而不会创建一个新的对象。这意味着,如果原始对象中的引用类型属性发生变化,拷贝后的对象中的属性值也会随之改变。使用浅拷贝可以通过遍历对象中的属性,并将其复制到一个新对象中来实现。你可以使用循环、递归或者使用一些内置的方法来手写浅拷贝。举个例子,你可以通过遍历对象中的属性,并将其复制到一个新对象中来实现浅拷贝。比如使用递归的方式,你可以逐个复制对象中的属性到一个新的对象中,但是注意,只有第一层的属性会被复制到新对象中。 深拷贝则是复制对象的所有层次,包括对象的引用类型属性。这意味着,如果原始对象中的引用类型属性发生变化,拷贝后的对象中的属性值不会受影响。深拷贝会创建一个完全相同但是独立的对象。实现深拷贝可以使用递归的方式,对于对象的每一个属性,如果是引用类型,则递归调用深拷贝方法来复制属性值。你也可以使用一些内置的方法或者第三方库来实现深拷贝,比如使用 JSON.parse(JSON.stringify(object)) 来实现深拷贝。需要注意的是,使用这种方法时,对象中的函数、正则表达式以及 undefined 类型的属性会被忽略掉。 所以,通过手写深拷贝和浅拷贝,可以更好地理解递归、循环引用、weakMap、创建各种引用类型的方法、判断数据类型、箭头函数与普通函数的区别、正则表达式等知识。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* [JavaScript基础:手写浅拷贝与深拷贝](https://blog.csdn.net/imagine_tion/article/details/115322522)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 50%"] - *2* *3* [JS 浅拷贝和深拷贝详解(巨详细)](https://blog.csdn.net/qq_63299825/article/details/131003216)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 50%"] [ .reference_list ]

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值