js递归理解及使用案例

递归在平时开发中会经常用到，递归是一种编程技巧，采取函数调用函数自身的方式工作

下面是递归的特点以及使用案例
一、递归是什么？
递归通俗地讲就是函数自己调用自己，它具有以下三要素

1、一个问题可以分解为更小的问题用同样的方法解决
2、分解后的子问题求解方式一样，不同的是数据规模变小
3、存在递归终止条件

下面看看递归解决实际问题的案例
二、使用案例
1.求1-100的和

//第n项的和 sum(n) = sum(n-1)+n 终止条件n=1
function sum(n){
    if(n==1) return 1
    return sum(n-1) + n
}
let amount = sum(100)
console.log(amount) // 5050

2.求一个数组前n项的和

function arrsum(arr,n){
    if(n==1) return arr[0]
    return arrsum(arr,n-1) + arr[n-1]
}
const arrs = [1,3,4,5,7]
console.log(arrsum(arrs,1))  // 1
console.log(arrsum(arrs,2))  // 4

4.斐波那切数列(又称黄金分割数列\兔子数列)

//1、1、2、3、5、8、13、21、34.....
//规律：自身等于前两项之和；
//(n-1)+(n-2)=n
 
  function fibonacci(n){
      if(n<=2){
           return 1
       }
       return fibonacci(n-1)+fibonacci(n-2)
   }
 console.log(fibonacci(6))   // 8

遍历数组

//数组遍历，使用递归实现
let arr =[1,2,3,4,5,6,7]
function item(arr){
    if(arr.length==0)  return;
    if(arr.length==1){
        return;
    }
    item(item.slice(1))
}
item(arr)

数组扁平化

var sotArr = [56,45,96,77,33,[48,96,13],99,[44,159]];

//普通for...in循环遍历
function flattenArr(arr) {
	let result= [];
	for(let i = 0; i<arr.length;i++) {
		if(Array.isArray([arr[i]])) {
			 result = result.concat(flatten(arr[i]));
		}else {
			result.push(arr[i]);
		}
	}
	return result;
}

//使用高阶函数 reduce 
function flatten(arr) {
    return arr.reduce((prev, item) => {
        return prev.concat(Array.isArray(item) ? flatten(item) : item);
    }, []);
}

// 还可以使用es6的拓展运算符
function flatten(arr) {
    while (arr.some(item => Array.isArray(item))) {
        arr = [].concat(...arr);
    }
    return arr;
}

console.log(flattenArr(sotArr));   // [56,45,77,33,48,96,13,44,159]

对象

1.对象属性遍历

在日常的开发中，我们从服务器获取的数据一般都是json格式的，如果对象深度嵌套层级很深的情况下，使用递归是箱单简单的。

var data = {
    id:1,
    name:'幕筱佳',
    info:{
        age:18,
        sex:'男',
        adress:{
            pervice：'某某省'
            city:'某某市'

        }
    }
}
function recursiveObj(obj){
    for(let k in obj){
        if(obj.hasOwnProperty(k)){
            if(typeof obj[k] =='object'){
                recursiveObj(obj[k])
            }else{
                console.log(`${k}:${obj[k]}`)
            }
        }
    }
}
recursiveObj(data)

对象扁平化

function flattenObject(oldObject) {
    const newObject = {};
    flattenHelper(oldObject, newObject, '');
    return newObject;
    
    function flattenHelper(currentObject, newObject, previousKeyName) {
      for (let key in currentObject) {
        let value = currentObject[key];
  
        if (value.constructor !== Object) {
          if (previousKeyName == null || previousKeyName == '') {
            newObject[key] = value;
          } else {
            if (key == null || key == '') {
              newObject[previousKeyName] = value;
            } else {
              newObject[previousKeyName + '.' + key] = value;
            }
          }
        } else {
          if (previousKeyName == null || previousKeyName == '') {
            flattenHelper(value, newObject, key);
          } else {
            flattenHelper(value, newObject, previousKeyName + '.' + key);
          }
        }
      }
    }
  }

对象复制（深拷贝）

function deepCopy(obj) {
    let result = Array.isArray(obj) ? [] : {};
    for (let key in obj) {
     if (obj.hasOwnProperty(key)) {
      if (typeof obj[key] === 'object') {
        result[key] = deepCopy(obj[key]);
      } else {
        result[key] = obj[key];
      }
     }
    }
    return result;
}