lambda+reduce的一句艰深代码

// lambda & reduce & simple recursive
const flatten = arr => arr.reduce(
	(a, b) => a.concat(Array.isArray(b) ? flatten(b) : b), []
);

(a,b...) => exp
//相当于
function(a,b...){
	return exp...
}

/**
 * 可以简单理解为 
 * 左侧(a,b...)为参数列表 
 * 右侧exp 表达式为函数所要执行的动作，
 * 这个动作的执行结果作为返回数据
 */

 /**
  * reduce的调用方式
  * callback为回调函数, initialValue 可选参数  初始值
  */
 arr.reduce(callback, initialValue);

/**
 * 回调函数包括四个可选参数
 * ① previousValue 上一次调用 callback返回的值, 如果当前是第一次调用，则为initialValue的值
 *   如果调用reduce的时候没有传入initialValue的值,则为数组下标为0的值
 * ② currentValue & currentIndex 当前数组中被处理的值与其下标 ,如果没有传入initialValue的值,下标从1开始
 *   (下标为0的值已被previousValue占据)
 * ③ array 调用reduce的数组
 */
 var callback=function(previousValue, currentValue, currentIndex, array){
 	// do sth...
 };

Array.prototype.myReduce=function(callback,initialValue){
	if(initialValue==undefined){
		previousValue= this[0];
		currentValue = this[1];
		currentIndex = 1;
	} else{
		previousValue= initialValue;
		currentValue = this[0];
		currentIndex = 0;
	}

	for(var i=currentIndex; i<this.length;i++){
		previousValue=callback(previousValue,currentValue,currentIndex,this);
		currentValue =this[i+1];
		currentIndex =i+1;
	}

	return previousValue;
};

// 原始代码
// const flatten = arr => arr.myReduce(
// 	(a, b) => a.concat(Array.isArray(b) ? flatten(b) : b), []
// );

// 拆除lambda 得 (这里可以看到,flatten 算法实际上返回的是一个数组)
var flatten=function(arr){
	return arr.myReduce(
		function(a, b){
			return a.concat( Array.isArray(b) ? flatten(b) : b );
		},[]
	);
};

/**
 * 如果你看懂了myReduce的逻辑, 那么 a,b 的意义应该不难于理解
 * a(previousValue), 因为reduce传入了initialValue [] 所以首次调用回调 a == []
 * b(currentValue) , 首次调用下标为 0
 *
 * a.concat( Array.isArray(b) ? flatten(b) : b )
 * 循环遍历数组中的每个元素, 如果是数组 则将执行过flatten算法后得到的数组连接入a ,否则 将其连接入a
 *
 * 回调函数将 类型为数组的数组元素 连接入上层数组,实际上是在降维
 * flatten算法通过reduce的数组循环遍历和自递归实际上是在将多维数组化为一维 
 */

var test1 = [[0, 1], [2, 3], [4, 5]];
var test2 = [0, [1, [2, [3, [4, [5]]]]]];

console.log(flatten(test1));
console.log(flatten(test2));