是什么

函数式编程： 定义好输入参数， 封装逻辑过程， 输出结果

// 命令式编程
var array = [0, 1, 2, 3];
for (let i = 0; i < array.length; i++) {
  array[i] = Math.pow(array[i], 2);
}

// 函数式方式
[0, 1, 2, 3].map((num) => Math.pow(num, 2));

纯函数

定义： 无副作用的函数

• 特性
  • 输入值相同，返回值相同
  • 不会造成作用域的变化，如修改全量变量或者外部参数
• 优势
  • 函数可测试
  • 可读性更强
  • 适合模块化

高阶函数

定义： 把函数作为参数的函数

const once = (fn) => {
  let done = false;
  return function() {
    if (!done) {
      fn.apply(this, fn);
    } else {
      console.log("该函数已经执行");
    }
    done = true;
  };
};

柯里化

定义：把一个多参数函数转换一个嵌套的一元函数的过程。

原函数
新函数=柯里化（原函数）
新函数调用

let fn = (x, y) => x + y;
const curry = function(fn) {
  return function(x) {
    return function(y) {
      return fn(x, y);
    };
  };
};
let newFn = curry(fn);
console.log(newFn(1)(2));

普遍使用

// 多参数柯里化；
const curry = function(fn) {
  return function curriedFn(...args) {
    if (args.length < fn.length) {
      return function() {
        return curriedFn(...args.concat([...arguments]));
      };
    }
    return fn(...args);
  };
};
const fn = (x, y, z, a) => x + y + z + a;
const myfn = curry(fn);
console.log(myfn(1)(2)(3)(1));

compose

组合： 从左到右执行

function afn(a){
    return a*2;
}
function bfn(b){
    return b*3;
}
const compose = (a,b)=>data=>a(b(data));
let myfn =  compose(afn,bfn);
console.log( myfn(2));

管道： 从右到做执行

const compose = (...fns)=>val=>fns.reverse().reduce((acc,fn)=>fn(acc),val);