JS基础——高阶函数

定义

高阶函数是至少满足下面一个条件的函数：
1、接收一个或多个函数作为参数。比如filter函数
2、返回一个函数。 比如bind函数
举个例子：比如我们要筛数组[1,2,3,4,5]中大于3的所有元素，我们通常的实现方法为：

let newArr = [];
for(let i = 0,len = arr.length; i < len; i++){
    arr[i] > 3 && newArr.push(arr[i])
}

而使用数组filter方法的话，只需要 let newArr = arr.filter((item) => {return item > 3})。当然我们也可以通过高阶函数来自己实现：

Array.prototype.myFilter = function (fn){
    let newArr = [];
    for(let i = 0,len = this.length; i < len; i++){
        fn(this[i]) && newArr.push(this[i])
    }
    return newArr;
}
[1,2,3,4,5].myFilter((item) => { return item > 3})

我们可以通过封装高阶函数来复用和简化我们的代码。

柯里化

柯里化是将一个多参数的函数转换成多个单参数的函数，这个函数会返回一个函数去处理下一个参数。也就是把fn(a,b,c)转换为newFn(a)(b)(c)这种形象。柯里化常见的应用有：参数复用、延迟计算。比如我们有个拼接接口地址的函数：

function getUrl(service,context,api){
    return service + context + api;
}
let loginUrl = getUrl('http://localhost:8080/','auth','/login')  
let logoutUrl = getUrl('http://localhost:8080/','auth','/logout')

每次前两个参数的值都是一样，我们可以柯里化来封装下来达到参数复用：

function curry(fn){
    let args = Array.prototype.slice.call(arguments,1);    
    return function(){
        let innerArgs = Array.prototype.slice.call(arguments);
        let finalArgs = args.concat(innerArgs);
        if(finalArgs.length < fn.length){         //fn.length为函数的参数个数
            return curry.call(this,fn,...finalArgs)
        }else{
            return fn.apply(null,finalArgs)
        }
    }
}
var getAuthUrl = curry(getUrl,'http://localhost:8080/','auth');
let loginUrl = getAuthUrl('/login')
let logoutUrl = getAuthUrl('/logout')

组合函数

组合函数类似于管道，多个函数的执行时，上一个函数的返回值会自动传入到第二个参数继续执行。比如我们替换一个url中的参数：

function replaceToken(str){
    return str.replace(/{token}/g,'123455')
}
function replaceAccount(str){
    return str.replace(/{account}/g,'xuriliang')
}
replaceAccount(replaceToken('http://localhost/api/login?token={token}&account={account}'))

我们可以利用这种嵌套的写法来实现，但如果嵌套过多，代码可读性就不是很好了。当然我们也可以在一个函数里分过程实现，不过这样函数就不符合单一原则了。利用函数组合我们可以这样写：

function compose() {
    var args = arguments;
    var start = args.length - 1;
    return function() {
        var i = start;
        var result = args[start].apply(this, arguments);
        while (i--) result = args[i].call(this, result);
        return result;
    }
}
compose(replaceToken,replaceAccount)('http://localhost/api/login?token={token}&account={account}')

组合函数使得我们可以使用一些通用的函数，组合出各种复杂运算。这也是函数编程中pointfree的概念。