定义

高阶函数是最少满足下面一个前提的函数：
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的观点。