1.闭包(closure)是什么

闭包概念: 一个函数对周围状态的引用捆绑在一起,内存函数中访问到其他函数的作用域

 function fun() {
      let sum = 10

      function fu() {
        console.log(sum);
      }
      fu()
    }
    fun()

总结:

• 总结：
  • 闭包本质仍是函数，只不是从函数内部返回的
  • 闭包能够创建外部可访问的隔离作用域，避免全局变量污染
  • 过度使用闭包可能造成内存泄漏

 回调函数也能访问函数内部的局部变量。

2.递归函数

递归函数: 在函数中调用自己 类似于循环,也要有结束条件

   <script>
       function fun() {
            console.log('11');
            fun()
        }
        fun()
    </script>

3.浅拷贝

浅拷贝: 拷贝的是地址

<script>
    // 常见方法:
    // 拷贝对象:Object.assign()/展开运算符{...obj}拷贝对象
    // 拷贝数组:Array.prototype.concat()或者[...arr]
    // 展开运算符
    const obj = {
      name: '万叶',
      age: 18
    }
    const o = {
      ...obj
    }
    console.log(o);
    o.age = 20
    console.log(o);
    console.log(obj);

    Object.assign()
    const obj = {
      name: '万叶',
      age: 18
    }
    consto = {}
    Object.assign(o, obj)
    o.age = 20
    console.log(o);
    console.log(obj);
  </script>

总结: 如果是简单数据类型拷贝值,引用数据类型拷贝的是地址,如果是单层对象没有问题,如果是多层就有问题

4.深拷贝

深拷贝: 拷贝的是对象,不是地址 常用方式有三种:

1.通过递归函数实现深拷贝

  <script>
    const obj = {
      uname: 'pink',
      age: 18,
      hobby: ['乒乓球', '足球'],
      family: {
        baby: '小pink'
      }
    }
    const o = {}
    // 拷贝函数
    function deepCopy(newObj, oldObj) {
      debugger
      for (let k in oldObj) {
        // 处理数组的问题  一定先写数组 在写 对象 不能颠倒
        if (oldObj[k] instanceof Array) {
          newObj[k] = []
          //  newObj[k] 接收 []  hobby
          //  oldObj[k]   ['乒乓球', '足球']
          deepCopy(newObj[k], oldObj[k])
        } else if (oldObj[k] instanceof Object) {
          newObj[k] = {}
          deepCopy(newObj[k], oldObj[k])
        } else {
          //  k  属性名 uname age    oldObj[k]  属性值  18
          // newObj[k]  === o.uname  给新对象添加属性
          newObj[k] = oldObj[k]
        }
      }
    }
    deepCopy(o, obj) // 函数调用  两个参数 o 新对象  obj 旧对象
    console.log(o)
    o.age = 20
    o.hobby[0] = '篮球'
    o.family.baby = '老pink'
    console.log(obj)
    console.log([1, 23] instanceof Object)
  </script>

2.通过JSON.stringify

 <script>
    const obj = {
      uname: 'pink',
      age: 18,
      hobby: ['乒乓球', '足球'],
      family: {
        baby: '小pink'
      }
    }
    const o = {}
    // 拷贝函数
    function deepCopy(newObj, oldObj) {
      debugger
      for (let k in oldObj) {
        // 处理数组的问题  一定先写数组 在写 对象 不能颠倒
        if (oldObj[k] instanceof Array) {
          newObj[k] = []
          //  newObj[k] 接收 []  hobby
          //  oldObj[k]   ['乒乓球', '足球']
          deepCopy(newObj[k], oldObj[k])
        } else if (oldObj[k] instanceof Object) {
          newObj[k] = {}
          deepCopy(newObj[k], oldObj[k])
        }
        else {
          //  k  属性名 uname age    oldObj[k]  属性值  18
          // newObj[k]  === o.uname  给新对象添加属性
          newObj[k] = oldObj[k]
        }
      }
    }
    deepCopy(o, obj) // 函数调用  两个参数 o 新对象  obj 旧对象
    console.log(o)
    o.age = 20
    o.hobby[0] = '篮球'
    o.family.baby = '老pink'
    console.log(obj)
    console.log([1, 23] instanceof Object)
   </script>

3.lodash/cloneDeep

<script src="./lodash.min.js"></script>
  <script>
    // js库lodash里面cloneDeep内部实现了深拷贝
    const obj = {
      name: '万叶',
      age: 18
    }
    const o = _.cloneDeep(obj)
    console.log(o);
  </script>