常见的函数式编程操作

1、柯里化： (概念 & 应用 & 好处)

柯里化的概念：

柯里化（Currying）是把接受多个参数的函数变成接受单一参数的函数，并且返回一个用于接受剩余参数的新函数，当参

数都传递完成后， 则立即返回函数执行结果。

function getSum(a,b){

return a+b

}

getSum(1,2)

getSum(1,3)

getSumm(1,4)

此时，如果我们的相加的基准一直都是某一个固定的值，比如1的话，就会一直重复1，为了避免重复，继续对函数进行

改造：
 

function getSum(a){

return function(b){

return a+b

}

}

let getSum1=getSum(1)

getSum1(2)

getSum1(3)

利用Lodash库实现函数柯里化

const _ = require('lodash')

const getSum = function (a, b, c) {

return a + b + c;

};

const curried = _.curry(getSum);

curried(1)(2)(3);

// => 6

curried(1, 2)(3);

// => 6

curried(1, 2, 3);

// => 6

lodash中的柯里化函数

_.curry(func）

参数：需要柯里化的函数

返回值：柯里化后的函数

功能：创建一个函数，该函数接收一个或多个func的参数，如果func所需要的参数都被提供，则执行func并返回执行的结果，

否则继续返回该函数并等待接收剩余的参数

通常，我们在实践中使用柯里化都是为了把某个函数变得单值化，这样可以增加函数的多样性，使得其适用性更强：

const _ = require('lodash');

const replace = _.curry(function(what, replacement, str) {

return str.replace(what, replacement);

});

const replaceSpaceWith = replace(/\s*/);

const replaceSpaceWithComma = replaceSpaceWith(',');

const replaceSpaceWithDash = replaceSpaceWith('-')

通过上面这种方式，我们从一个 replace 函数中产生很多新函数，可以在各种场合进行使用。

柯里化的原理

function curryIt(fn) {

return function curryFun(...args) {

if (args.length < fn.length) {

return function () {

return curryFun(...args.concat([...arguments])

}

}

return fn(...args)

}

}

function add(a, b, c) {

return '调用了';

}

var c = curryIt(add);

var c1 = c(1);

var c2 = c1(2);

var c3 = c2(3);

console.log(c3); // 调用了

由此我们可以看出，柯里化是一种“预加载”函数的方法，通过传递较少的参数，得到一个已经记住了这些参数的新函数，

某种意义上讲，这是一种对参数的“缓存”，是一种非常高效的编写函数的方法！

柯里化的优点

柯里化可以让我们给一个函数传递较少的参数得到一个已经记住了某些固定参数的新函数

这是一种对函数参数的缓存

让函数变的更灵活，让函数的粒度更小

可以把多元函数转换成一元函数，可以组合使用函数产生强大的功能

函数组合的概念：

定义：如果一个函数要经过多个函数处理才能得到最终值，这个时候可以把中间过程的函数合并成一个函数

有时候我们会写出洋葱代码，即一层套一层的方法h(g(f(x)))。

[]例如实现一个具体的场景：找出数组的最后一个元素：_.first(_.reverse(array))，这种多次嵌套就是洋葱代码，为了解

决这种状况，需要使用函数组合

题目一：找出数组中的最后一个元素

function reverse(array){

return array.reverse()

}

function first(array){

return array[0]

}

// 一般调用

first(reverse([1,2,3]))

// 函数组合调用

const last = compose(first,reverse)

console.log(last([1,2,3]))

// 函数组合

function compose(f,g){

return function(value){

return f(g(value))

}

}

利用Lodash库实现函数组合：

lodash中组合函数flow()和flowRight()，它们都可以组合多个函数，flow()是从左到右运行，flowRight()是从右到左运

行。

const _= require('lodash')

const reverse =arr=>arr.reverse()

const first = arr=>arr[0]

const f= _.flowRight(first,reverse)

// const f= _.flow(reverse,first)

console.log(f([1,2,3]))

函数组合的原理（模拟实现 lodash中的 flowRight() ）：

const reverse =arr=>arr.reverse()

const first = arr=>arr[0]

function compose(...fns) {

return function (x) {

return fns.reverse().reduce(function (arg, fn) {

return fn(arg);

}, x)

}

}

const compose=(...args)=>value=>args.reverse().reduce((acc,fn)=>fn(acc),[])

const f = compose(first,reverse)

console.log(f([1,2,3]))

推荐教程：两小时快速掌握函数式编程