JavaScript高阶函数的应用

定义

　　高阶函数是指至少满足下列条件之一的函数：

  • 函数可以作为参数被传递；
  • 函数可以作为返回值输出。

　　JavaScript语言中的函数显然满足高阶函数的条件，在实际开发中，无论是将函数当作参数传递，还是让函数的执行结果返回另外一个函数，这两种情形都有很多应用场景，以下就是一些高阶函数的应用。

应用

一、作为参数传递

ajax异步请求

// callback为待传入的回调函数
var getUserInfo = function(userId, callback) {
     $.ajax("http://xxx.com/getUserInfo?" + userId, function(data) {
        if (typeof callback === "function") {
            callback(data);
        }
    });
}

getUserInfo(13157, function(data) {
    alert (data.userName);
});

Array.prototype.sort

　　Array.prototype.sort接受一个函数当作参数，这个函数里面封装了数组元素的排序规则。从Array.prototype.sort的使用可以看到，我们的目的是对数组进行排序，这是不变的部分；而使用什么规则去排序，则是可变的部分。把可变的部分封装在函数参数里，动态传入Array.prototype.sort，使Array.prototype.sort方法成为了一个非常灵活的方法。

//从小到大排列
[1, 4, 3].sort(function(a, b) {
    return a - b;
});
// 输出: [1, 3, 4]

//从大到小排列
[1, 4, 3].sort(function(a, b) {
    return b - a;
});
// 输出: [4, 3, 1]

　　类似的数组方法还有map()，reduce()，filter()，详见此篇博客：JS中几种常见的高阶函数

二、作为返回值

判断数据的类型

var Type = {};

for (var i = 0, type; type = [‘String‘, ‘Array‘, ‘Number‘][i++];) {
    (function(type) {
        Type[‘is‘ + type] = function(obj) {
            return Object.prototype.toString.call(obj) === ‘[object ‘+ type +‘]‘;
           }
       })(type)
};

Type.isArray([]);     // 输出：true
Type.isString("str");     // 输出：true

单例模式

var getSingle = function(fn) {
    var ret;
    return function() {
        return ret || (ret = fn.apply(this, arguments));
    };
};

三、实现AOP

　　AOP（面向切面编程）的主要作用是：把一些跟核心业务逻辑模块无关的功能抽离出来，这些跟业务逻辑无关的功能通常包括日志统计、安全控制、异常处理等。把这些功能抽离出来之后，再通过“动态植入”的方式掺入业务逻辑模块中。

　　这样做的好处首先是可以保持业务逻辑模块的纯净和高内聚性，其次是可以很方便地复用日志统计等功能模块。

　　通常，在JavaScript中实现AOP，都是指把一个函数“动态植入”到另外一个函数之中，具体的实现技术有很多，下面的例子通过扩展Function.prototype来做到这一点。

Function.prototype.before = function(beforefn) {
    var __self = this;    // 保存原函数的引用
    return function() {    // 返回包含了原函数和新函数的"代理"函数
        beforefn.apply(this, arguments);     // 执行新函数，修正this
        return __self.apply(this, arguments);    // 执行原函数
    }
};

Function.prototype.after = function(afterfn) {
    var __self = this;
    return function() {
        var ret = __self.apply(this, arguments);
        afterfn.apply(this, arguments);
        return ret;
    }
};

var func = function() {
    console.log(2);
};

func = func.before(function() {
    console.log(1);
}).after(function() {
    console.log(3);
});

func();

// 按顺序打印出1，2，3

四、currying

　　currying（函数柯里化），又称部分求值。一个currying的函数首先会接受一些参数，接受了这些参数之后，该函数并不会立即求值，而是继续返回另外一个函数，刚才传入的参数在函数形成的闭包中被保存起来。待到函数被真正需要求值的时候，之前传入的所有参数都会被一次性用于求值。

// 通用currying函数，接受一个参数，即将要被currying的函数
var currying = function(fn) {
    var args = [];
    return function() {
        if (arguments.length === 0) {
            return fn.apply(this, args);
        } else {
            [].push.apply(args, arguments);
            return arguments.callee;// arguments.callee，指向当前函数的引用
        }
    }
};

// 将被currying的函数
var cost = (function() {
    var money = 0;
    return function() {
        for (var i = 0, l = arguments.length; i < l; i++) {
            money += arguments[i];
        }
        return money;
    }
})();

var cost = currying( cost );    // 转化成currying函数

cost( 100 );    // 未真正求值
cost( 200 );    // 未真正求值
cost( 300 );    // 未真正求值

console.log (cost());     // 求值并输出：600

五、uncurrying

　　在JavaScript中，当我们调用对象的某个方法时，其实不用去关心该对象原本是否被设计为拥有这个方法，这是动态类型语言的特点，也是常说的鸭子类型思想。

　　同理，一个对象也未必只能使用它自身的方法，那么有什么办法可以让对象去借用一个原本不属于它的方法呢？

　　答案对于我们来说很简单，call和apply都可以完成这个需求，因为用call和apply可以把任意对象当作this传入某个方法，这样一来，方法中用到this的地方就不再局限于原来规定的对象，而是加以泛化并得到更广的适用性。

　　而uncurrying的目的是将泛化this的过程提取出来，将fn.call或者fn.apply抽象成通用的函数。

// uncurrying实现
Function.prototype.uncurrying = function() {
    var self = this;
    return function() {
        return Function.prototype.call.apply(self, arguments);
    }
};

// 将Array.prototype.push进行uncurrying，此时push函数的作用就跟Array.prototype.push一样了，且不仅仅局限于只能操作array对象。
var push = Array.prototype.push.uncurrying();

var obj = {
    "length": 1,
    "0": 1
};

push(obj, 2);
console.log(obj);   // 输出：{0: 1, 1: 2, length: 2}

六、函数节流

　　当一个函数被频繁调用时，如果会造成很大的性能问题的时候，这个时候可以考虑函数节流，降低函数被调用的频率。

　　throttle函数的原理是，将即将被执行的函数用setTimeout延迟一段时间执行。如果该次延迟执行还没有完成，则忽略接下来调用该函数的请求。

　　throttle函数接受2个参数，第一个参数为需要被延迟执行的函数，第二个参数为延迟执行的时间。

var throttle = function(fn, interval) {
    var __self = fn,    // 保存需要被延迟执行的函数引用
        timer,      // 定时器
        firstTime = true;    // 是否是第一次调用

    return function() {
        var args = arguments,
            __me = this;

        if (firstTime) {    // 如果是第一次调用，不需延迟执行
            __self.apply(__me, args);
            return firstTime = false;
        }

        if (timer) {    // 如果定时器还在，说明前一次延迟执行还没有完成
            return false;
        }

        timer = setTimeout(function() {  // 延迟一段时间执行
            clearTimeout(timer);
            timer = null;
            __self.apply(__me, args);
        }, interval || 500 );
    };
};

window.onresize = throttle(function() {
    console.log(1);
}, 500 );

事件结束

　　对于某些可以频繁触发的事件，有时候我们希望在事件结束后进行一系列操作。这时我们可以利用高阶函数做如下处理：

function debounce(fn, interval) {
    var timer = null;

      function delay() {
        var target = this;
        var args = arguments;
        return setTimeout(function(){
              fn.apply(target, args);
        }, interval);
      }

      return function() {
        if (timer) {//如果定时器还存在，就清除
              clearTimeout(timer);
        }
        timer = delay.apply(this, arguments);
      }
};
window.onresize = debounce(function(){
    console.log(‘resize end‘);
}, 500);

七、分时函数

　　当一次的用户操作会严重地影响页面性能，如在短时间内往页面中大量添加DOM节点显然也会让浏览器吃不消，我们看到的结果往往就是浏览器的卡顿甚至假死。

　　这个问题的解决方案之一是下面的timeChunk函数，timeChunk函数让创建节点的工作分批进行，比如把1秒钟创建1000个节点，改为每隔200毫秒创建8个节点。

　　timeChunk函数接受3个参数，第1个参数是创建节点时需要用到的数据，第2个参数是封装了创建节点逻辑的函数，第3个参数表示每一批创建的节点数量。

var timeChunk = function(ary, fn, count) {
    var t;

    var start = function() {
        for ( var i = 0; i < Math.min( count || 1, ary.length ); i++ ){
            var obj = ary.shift();
            fn( obj );
        }
     };

     return function() {
        t = setInterval(function() {
          if (ary.length === 0) {  // 如果全部节点都已经被创建好
              return clearInterval(t);
          }
          start();
        }, 200);    // 分批执行的时间间隔，也可以用参数的形式传入
    };
};

八、惰性加载函数

　　在Web开发中，因为浏览器之间的实现差异，一些嗅探工作总是不可避免。比如我们需要一个在各个浏览器中能够通用的事件绑定函数addEvent，常见的写法如下：

方案一：

var addEvent = function(elem, type, handler) {
    if (window.addEventListener) {
       return elem.addEventListener(type, handler, false);
    }

    if (window.attachEvent) {
          return elem.attachEvent(‘on‘ + type, handler);
    }
};

　　缺点：当它每次被调用的时候都会执行里面的if条件分支，虽然执行这些if分支的开销不算大，但也许有一些方法可以让程序避免这些重复的执行过程。

方案二：

var addEvent = (function() {
    if (window.addEventListener) {
        return function(elem, type, handler) {
            elem.addEventListener(type, handler, false);
        }
    }
    if (window.attachEvent) {
        return function(elem, type, handler) {
            elem.attachEvent(‘on‘ + type, handler);
        }
    }
})();

　　缺点：也许我们从头到尾都没有使用过addEvent函数，这样看来，一开始的浏览器嗅探就是完全多余的操作，而且这也会稍稍延长页面ready的时间。

方案三：

var addEvent = function(elem, type, handler) {
    if (window.addEventListener) {
       addEvent = function(elem, type, handler) {
           elem.addEventListener(type, handler, false);
       }
    } else if (window.attachEvent) {
        addEvent = function(elem, type, handler) {
            elem.attachEvent(‘on‘ + type, handler);
        }
    }
    addEvent(elem, type, handler);
};

　　此时addEvent依然被声明为一个普通函数，在函数里依然有一些分支判断。但是在第一次进入条件分支之后，在函数内部会重写这个函数，重写之后的函数就是我们期望的addEvent函数，在下一次进入addEvent函数的时候，addEvent函数里不再存在条件分支语句。

原文地址：https://www.cnblogs.com/goloving/p/8370591.html

时间： 2024-09-30 21:01:15

JavaScript高阶函数的应用的相关文章

JavaScript高阶函数

所谓高阶函数(higher-order function) 就是操作函数的函数,它接收一个或多个函数作为参数,并返回一个新函数. 下面的例子接收两个函数f()和g(),并返回一个新的函数用以计算f(g()); //返回一个新的可以计算f(g())的函数 //返回的函数h()将它所有的实参传入g(),然后将g()的返回值传入f() //调用f()和g()时的this值和调用h()时的this值是同一个this function compose(f,g){ return function(){ re

JavaScript 高阶函数 + generator生成器

map/reduce map()方法定义在JavaScript的Array中,我们调用Array的map()方法,传入我们自己的函数,就得到了一个新的Array作为结果: function pow(x) { return x * x; } var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9]; arr.map(pow); // [1, 4, 9, 16, 25, 36, 49, 64, 81] map()传入的参数是pow,即函数对象本身. 你可能会想,不需要map(),写

JavaScript高阶函数 map reduce filter sort

本文是笔者在看廖雪峰老师JavaScript教程时的个人总结 高阶函数 一个函数就接收另一个函数作为参数,这种函数就称之为高阶函数 1.高阶函数之map: 此时我们有一个数组和一个接受一个参数并返回一个数的函数.我们需要把这个数组的每一个值在这个函数上走一遍,从而得到一个新数组.此时就需要map了 var a = [1,2,3,4,5,6]; var b = [] var fun = function(x) { return x * x; } b = a.map(fun) alert(b)  /

【进阶 6-1 期】JavaScript 高阶函数浅析

引言   本期开始介绍 JavaScript 中的高阶函数,在 JavaScript 中,函数是一种特殊类型的对象,它们是 Function objects.那什么是高阶函数呢?本节将通过高阶函数的定义来展开介绍. 高阶函数 高阶函数英文叫 Higher-order function,它的定义很简单,就是至少满足下列一个条件的函数: 接受一个或多个函数作为输入 输出一个函数 也就是说高阶函数是对其他函数进行操作的函数,可以将它们作为参数传递,或者是返回它们. 简单来说,高阶函数是一个接收函数作为

JavaScript 高阶函数

; Run = function () { ; return Array.prototype.splice.call( arguments, -1 )[0].apply( this, arguments ) } ; Loop = function () { var count = -1 , end = arguments.length -1 , _func = arguments[ end ] ; while ( ++count < end ) { ; _func.apply( this, ar

JavaScript设计模式与开发实践-读书笔记（3）闭包和高阶函数

闭包(closure) 闭包的形成与变量的作用域以及变量的生存周期密切相关. 变量的作用域,就是指变量的有效范围. 全局变量和局部变量. 在JavaScript中,函数可以用来创造函数作用域. 变量的生存周期,全局变量的生命周期是永久的,除非我们主动销毁这个全局变量. 对于在函数体内用var关键字声明的局部变量来说,当退出函数时,这些局部变量即失去了它们的价值,它们都会随着函数调用的结束而被销毁. 利用闭包我们可以完成许多奇妙的工作. 闭包的作用: 1.封转变量 闭包可以帮助我们把一些不需要暴露

JavaScript设计模式与开发实践——读书笔记1.高阶函数(下)

上部分主要介绍高阶函数的常见形式,本部分将着重介绍高阶函数的高级应用. 1.currying currying指的是函数柯里化,又称部分求值.一个currying的函数会先接受一些参数,但不立即求值,而是继续返回给另一个函数,通过闭包存储起来.等到函数被真正需求要求值的时候,将之前传入的参数统一起来求值.例如,我们要计算一个月的开销,我们并不需要计算每天具体花了多少,而是需要计算月底总共花掉多少,也就是说,实际上我们只需要在月底计算一次.所以每个月的前29天,我们都只需要保存好当天的开销,到30

《JavaScript设计模式与开发》笔记 6.高阶函数

1.函数作为参数传递 1.回调函数 2.Array.prototype.sort 2.函数作为返回值输出 1.判断数据的类型 3.高级函数的实现AOP 4.高阶函数的其他应用 1.currying 函数柯里化 2.uncurring 3.函数节流 4.分时函数 5.惰性加载函数 1.函数作为参数传递 1.回调函数 最经常用的或许就是异步Ajax了 var getUserInfo = function(userId,callback){ $.ajax("http://xxx.com/getUser

Javascript：是你的高阶函数

在通常的编程语言中,函数的参数只能是基本类型或者对象引用,返回值也只是基本数据类型或对象引用.但在Javascript中函数作为一等公民,既可以当做参数传递,也可以被当做返回值返回.所谓高阶函数就是可以把函数作为参数,或者是将函数作为返回值的函数.这两种情形在实际开发中有很多应用场景,本文是我在工作学习中遇到的几种应用场景的总结. 回调函数 代码复用是衡量一个应用程序的重要标准之一.通过将变化的业务逻辑抽离封装在回调函数中能够有效的提高代码复用率.比如ES5中为数组增加的forEach方法,遍历