underscore.js源码研究(7)

概述

很早就想研究underscore源码了，虽然underscore.js这个库有些过时了，但是我还是想学习一下库的架构，函数式编程以及常用方法的编写这些方面的内容，又恰好没什么其它要研究的了，所以就了结研究underscore源码这一心愿吧。

underscore.js源码研究(1)

underscore.js源码研究(2)

underscore.js源码研究(3)

underscore.js源码研究(4)

underscore.js源码研究(5)

underscore.js源码研究(6)

underscore.js源码研究(7)

underscore.js源码研究(8)

参考资料：underscore.js官方注释，undersercore 源码分析，undersercore 源码分析 segmentfault

函数节流与去抖

有时候有这么一个情形，就是前段设计一个按钮，每点击一次这个按钮都会向服务器发送一次http请求，那么如果有恶意用户使用代码在1秒内点击100次，这样会对服务器造成难以想象的压力，可能导致服务器崩溃。

还有这么一个情形，前端有一个事件监听，需要监听鼠标移动的位置，然后执行一个回调函数，那么每次拖拽鼠标都会执行这个回调函数，如果这个回调函数引起了DOM的变化，则会引起重排重绘，严重影响了浏览器的性能。

这个时候就可以使用函数节流与去抖。

函数节流

函数节流就是限制在一定时间内的函数执行次数。

在讨论函数节流之前，我们先来说一下函数独占：如果函数正在执行中，则不允许再次执行函数。机制是通过设置一个flag来标记函数是否正在执行。

var isQuerying = false;

//complete是一个回调函数

var sendQuery = function(complete) {

    if(isQuerying) {

        //使用return来中断函数的执行

        return;

    }

    isQuerying = true;

    // 我们模拟一个耗时操作(回调)

    setTimeout(function(){

        complete && complete();

    },2000);

}

var complete = function() {

   // 在回调中， 我们刷新标记量

   isQuerying = false;

}

$("#queryBtn").click(function(){sendQuery(complete);});

再来看一下函数节流：限制在一定时间内的函数执行次数，多余的次数将被合并为一次并延迟waiting秒执行(节流)。

//cb是回调函数，waiting是在waiting时间段内只能执行一次

var throttle = function(cb, waiting) {

    var timeout;

    var previous = 0;

    var throttled = function() {

        var now = (new Date()).getTime();

        if(!previous) previous = now;

        var remaining = waiting - (now - previous);

        //如果在时间内已经执行过

        if(remaining >= 0) {

            //如果之前延迟过一个函数那就清除这个延迟不执行

            if(timeout) {

                clearTimeout(timeout);

                timeout = null;

            }

            //这里延迟函数执行时比如更新previous

            //underscore.js直接把这里独立为一个函数

            //即把原回调函数包裹为一个延迟执行函数

            timeout = setTimeout(function() {

                var now = (new Date()).getTime();

                previous = now;

                cb();

            }, waiting);

        } else {

            previous = now;

            cb();

        }

    }

    return throttled;

}

注意：这里的执行情况可以深入研究，多余的次数到底怎么执行是个问题。

函数去抖

函数去抖就是对于一定时间段的连续的函数调用，只让其执行一次。

下面是说明函数节流(throttle)和函数去抖(debounce)区别的很好的例子：

按一个按钮发送 AJAX：给 click 加了 debounce 后就算用户不停地点这个按钮，也只会最终发送一次；如果是 throttle 就会间隔发送几次。
监听滚动事件判断是否到页面底部自动加载更多：给 scroll 加了 debounce 后，只有用户停止滚动后，才会判断是否到了页面底部；如果是 throttle 的话，只要页面滚动就会间隔一段时间判断一次。

所以关键在于，延迟执行回调函数，如果在waiting时间内又调用了这个回调函数，则刷新延迟时间(取消上次的延迟，执行新的延迟)。与函数节流的关键区别在于，没有remaining参数。

代码如下：

//cb是回调函数，waiting是时间段内，immediate是是否第一次需要立即执行一次

var debounce = function(cb, waiting, immediate) {

    var timeout;

    var debounced = function() {

        if(timeout) clearTimeout(timeout);

        timeout = null;

        //如果需要第一次立即执行一次

        if(immediate && !timeout) cb();

        //无论如何都延迟执行一次

        timeout = setTimeout(cb, waiting);

    }

    return debounced;

}

测试代码如下：

var debounce = function(cb, waiting, immediate) {

    var timeout;

    var debounced = function() {

        if(timeout) clearTimeout(timeout);

        timeout = null;

        //如果需要第一次立即执行一次

        if(immediate && !timeout) cb();

        //无论如何都延迟执行一次

        timeout = setTimeout(cb, waiting);

    }

    return debounced;

}

function print() {

  console.log('hello world');

}

var debouncedPrint = debounce(print, 1000);

window.onscroll = function() {

  debouncedPrint();

};

对象属性和方法遍历

我们可以通过Object.prototype.hasOwnProperty来判断某个属性是不是自身属性(方法)，它不会去寻找原型链上的属性(方法)。

我们还可以通过Object.keys来列举出某个对象的所有自身属性(方法)，它也不会去寻找原型链上的属性(方法)。

但是for in除了寻找对象的自身属性(方法)外，还会去寻找原型链上的属性(方法)。

in不仅会寻找自身和原型上的可枚举属性，还会寻找不可枚举属性。

值得注意的是：

Object.prototype.hasOwnProperty，Object.keys和for in都只会寻找可枚举的属性(方法)，不会寻找不可枚举的，比如toString方法等。
如果要区分属性和方法，加一个判断函数isFunction即可。

Object函数

相信对于大多数人，都只会在new里面用到Object函数，其实也可以单独使用Object函数：

var obj = Object(obj);

它的意义是：

如果obj是对象，则返回这个对象。
如果obj是undefined或者null，则返回{}。
如果obj是原始值，则返回对象包裹的原始值。

示例如下：

console.log(Object({a:2})); //{a: 2}

console.log(Object(null)); //{}

console.log(Object(2)); //{[[PrimitiveValue]]: 2}

console.log(Object(2) + 1); //3