闭包和高阶函数(节流、分时、惰性加载)

javaScript设计模式中，许多模式都可以用闭包和高阶函数来实现

闭包

一般理解闭包就是返回一个匿名函数，可以访问包裹函数里面的私有变量。

var bby = function(){
    var name = '365';
    return function(){
        console.log(name)
    }
}
bby()() // 365

理解闭包需要掌握两个概念：变量作用域和生命周期

1. 变量分为全局变量和局部变量
2. 全局变量的生命周期是永久的，局部变量在退出函数时，生命周期结束。
3. 可以使用闭包，延长局部变量的生命周期

var func = function(){
    var a = 1;
    return function(){
        a++;
        alert ( a );
    }
};
var f = func();

f(); // 输出：2
f(); // 输出：3
f(); // 输出：4
f(); // 输出：5

这是因为 f 对返回的匿名函数的引用，局部变量a 还能被外界引用，所以局部变量不会被销毁。

• 闭包的作用
  1.封装变量

将全局变量，变为私有变量，返回一个匿名函数，只能通过返回的函数，才能读取这个私有变量。

• 闭包和面向对象

场景：经常遇到的一种题型，多次执行一个函数，求输出的值。接下来用闭包和面向对象实现。

var extent = function(){
    var value = 0;
    return {
        call: function(){
            value++;
            console.log( value );
        }
    }
};

var extent = extent();
extent.call(); // 输出：1
extent.call(); // 输出：2
extent.call(); // 输出：3

需要注意的是extent 指向函数里的对象，每执行一次call() , value 加1。如果代码修改如下：

var extent = function(){
    var value = 0;
    return {
        call: function(){
            value++;
            console.log( value );
        }
    }
};

var extent1 = extent();
var extent2 = extent();

extent1.call(); // 输出：1
extent2.call(); // 输出：1
extent1.call(); // 输出：2

extent1 和 extent2 是两个不同的对象，所以它们互不影响。

好了，接下来，用面向对象的方法改写上面的代码

var extent = {
    value: 0,
    call: function(){
        this.value++;
        console.log( this.value );
    }
};

extent.call(); // 输出：1
extent.call(); // 输出：2
extent.call(); // 输出：3

• 闭包与内存管理
  大家经常说闭包会造成内存泄漏，感觉是把锅甩给“闭包”了。

局部变量封装在闭包环境中，局部变量就会一直存在。

首先，我们之所以这样做，是因为后面，会用到这个变量。如果改成全局变量，其实对内存方面的影响是一样的。这样就不能说是内存泄漏了，方正放哪里都一样。当然，不再需要用到这个变量，手动设置为null。

使用闭包比较容易形成循环引用问题

这本身不是闭包造成的，是垃圾回收机制采用引用计数造成的。两个对象循环引用，那么这两个对象都无法被回收。解决方法是：手动把变量设为null。

高阶函数

1.函数作为参数被传递
2.函数作为返回值被输出

这一部分最大的收获是在业务中，将可变的部分抽离出来，放在函数的参数中。学会划分业务中的可变和不变的部分。

高阶函数的引用

• 函数柯里化
  没有看懂，不是很理解

• 函数节流
  这个面试问的比较多，主要是频繁触发，造成的性能问题。比如：窗口大小改变、鼠标滚动
  解决的思路：限制一定时间内只能执行一次。

/*
1.第一次执行不节流
2.timer没有清除，不执行第二次
*/
var throttle = function(fn,interval){
    var fristTime = true;
    var time;
    if(fristTime){
        fn();
        fristTime = false;
    }
    if(timer){
        retun false
    }
    timer = setTimeOut(function(){
        clearTimeout(timer);
        fn()
    },interval)
}

以上只是思路，完整代码如下：

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 );

• 分时函数
  我们并不想一次性创建成百上千个内容，这样会造成卡顿。可以用分时函数来实现：一段时间内只创建固定的内容。

vat timeChunk = function(data,fn,count){
    var obj;
    var start = function(){
        for(var i =0 ;i<count;i++){
            // fn()
        }
    }

    return function(){
        t = setInterval(function(){
            //start()
        }，500)
    }

}

完整代码如下：

var timeChunk = function( ary, fn, count ){
    var obj,
    t;
    var len = ary.length;
    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 ); // 分批执行的时间间隔，也可以用参数的形式传入
    };
};

创建1000个节点，进行测试：

var ary = [];
for ( var i = 1; i <= 1000; i++ ){
    ary.push( i );
};
var renderFriendList = timeChunk( ary, function( n ){
    var div = document.createElement( 'div' );
    div.innerHTML = n;
    document.body.appendChild( div );
}, 8 );
renderFriendList();

• 惰性加载函数