JS对于闭包和递归的理解

有过一些JS基础的小伙伴应该知道这两个概念今天分享下我的一些理解

递归：

简单理解就是自己调用自己，

函数内部调用自身就是递归、自己不断调用自己会形成循环来达成某些功能、但要加退出条件以免变成死循环

举个栗子：深层次 数据结构中根据商品ID查询该商品

 const data = [
    {
      id:1001,
      className:'显示器',
      goods:[
        {
          id:1101,
          className: 'AOC27G2',
          price:1368,
        },
        {
          id:1102,
          className: '三星玄冰骑士',
          price:1168,
        },
      ]
    },
    {
      id:2001,
      className:'CPU处理器',
      goods:[
        {
          id:2101,
          className: '英特尔酷睿I3-12100F',
          price:786,
        },
        {
          id:2102,
          className: 'AMD锐龙R5-3600',
          price:959,
        },
      ]
    },
    {
      id:3001,
      className:'显卡',
      goods:[
        {
          id:3101,
          className: 'GTX-1050TI',
          price:1050,
        },
        {
          id:3102,
          className: 'GTX-1650',
          price:1199,
        },
      ]
    },
  ]

      let e = []
  function GetData(json,id) {

      json.forEach(item => {
        if (item.id == id){
          //console.log(item);
          e.push(item)
        }else if (item.goods && item.goods.length > 0){
          e = GetData(item.goods,id)
        }
      })
      return e

  }

    console.log(GetData(data, 1001))  
    console.log(GetData(data, 2102)) 
    console.log(GetData(data, 3101)) 
    console.log(GetData(data, 4444)) 

查询了四次第四次没有查询到就没有push进到数组里

闭包：

一般来说内部函数可以使用外部全局变量、外部无法直接使用函数内部的变量

 闭包的主要作用 就是延申了变量的作用范围、

还有第二点：

闭即封闭，既然是封闭， 那为什么要封闭呢？封闭的重要作用是什么？  一定是隔离？ 为什么要隔离，一定是为了避免污染，在避免污染的情况下，  延申变量作用域  让外部能用 函数内部的变量

var fun=function(){
var obj={};
obj.getNumber=function (){  return 1;}
return obj;
}

使用闭包的场景是在，页面方法函数特别多，担心写的函数被污染，就会用一个闭包，包裹下

我们再来举一个打车的例子：

start 起步价   total 总价  add 每公里价格  fen 起步价包含公里  dirve 堵车加价

  /** 计算打的费用 **/

  let car  =(
      function () {
      let start = 8,total = 0,add = 3,fen = 2,dirve = 10;
      return {
        price : function (n) {
            if (n <= fen){
              total = start
            }else {
              total = ((n-fen)*add) + start
            }
            return total
        },
        du:function (flag) {
          flag ? total += dirve : total
          return total
        }
      }
    }
  )()

  console.log(car.price(14))
  console.log(car.du(false))
  console.log(car.du(true))
  console.log(car.price(2))

注意：一般情况下函数调用完毕后 内部的变量都会被释放销毁、使用闭包要避免内存泄漏

其他补充：闭包为什么会造成内存泄漏_whose_moon月的博客-CSDN博客_闭包为什么会造成内存泄漏

1、父函数里面嵌套的子函数，子函数访问父函数的局部变量。
2、通过return将子函数暴露到全局作用域，子函数就形成闭包。
3、通过闭包，父函数的局部变量没有被销毁，可通过闭包去调用 ，但同时，这个局部变量也不会被全局变量污染。