递归是什么以及递归的用法和递归的优缺点

递归

---

提示：写完文章后，目录可以自动生成，如何生成可参考右边的帮助文档

---

一、递归是什么?

递归：是函数自己调用自己。
特点:类似于循环（比如for()循环）
注意点:递归必须要有结束语句（即结束递归的条件），否则递归就是死循环

二、使用步骤

1.引入库

代码如下（示例）：

  function fn() {
      console.log(1);
      fn()
  }
  fn()//循环报错

像这样的就是调用递归但没有设置递归的结束条件，递归就会陷入死循环

2.例:用if else语句编写累加的效果代码

代码如下（示例）：

function getNum(n) {
    if (n == 1) {
    return 1
     } else if (n == 2) {
     return 2 + getNum(1)
    } else if (n == 3) {
     return 3 + getNum(2)
     } else if (n == 4) {
     return 4 + getNum(3)
     } else if (n == 5) {
     return 5 + getNum(4)
     }
}
console.log(getNum(5));//15
console.log(getNum(4));//10
console.log(getNum(100));//5050

3.例:用递归方法编写累加的效果代码

function getNum(n) {
    if (n == 1) {
        return 1
    } else { return n + getNum(n - 1) }
}
console.log(getNum(5));//15
console.log(getNum(4));//10
console.log(getNum(100));//5050

通过两种方法代码数量上的比对，可以很明确的看出递归要比if else方法方便快捷

4.而递归的深拷贝也是一个重点

  var obj = {
      name: 'obj',
      age: 18,
      object: {
          name: 'object',
          age: { age: 18 }
      },
      arr: [1, 2, 3]
  }
  var newObj = {}
  function recursion(newObj, obj) {
      for (key in obj) {
          //解决更小的子问题
          if (obj[key] instanceof Object) {
              newObj[key] = {}
              recursion(newObj[key], obj[key])
          } else if (obj[key] instanceof Array) {
              newObj[key] = []
              recursion(newObj[key], obj[key])
          } else {
              newObj[key] = obj[key]//for in 拷贝继承
          }
      }
  }
  recursion(newObj, obj)
    //若不加newObj.name = 'newObj'语句，则则打印obj和newOb两个结果一致
  // 都为{name: 'obj', age: 18, object: {…}, arr: Array(3)}
  //若加上newObJ.name='newObj',则打印obj和newOb两个结果出现了变化
  newObj.name = 'newObj'
  newObj.object.name = 'newObj1'// newObj中 age: { age: 18 }name: "newObj1"
  newObj.object.age.age = 20// newObj中age: {age: 20}
  console.log(obj);
  console.log(newObj);//{name: 'newObj', age: 18, object: {…}, arr: {…}}

---

总结

提示：这里对文章进行总结：

在递归的过程中,问题会被分解为更小的子问题,直到达到基本情况,然后逐步解决这些问题并返回结果,最终达到所要的目的,递归可分为两个关键因素,基本情况和递归调用,基本情况是指能直接解决的问题和情况,递归调用是指在解决问题时用相同的算法或函数来处理更小规模的子问题
但递归可能会占用大量的内存空间,因为每次递归调用都需要保存当前的状态