javaScript设计模式中，许多模式都可以用闭包和高阶函数来实现
闭包
一般理解闭包就是返回一个匿名函数，可以访问包裹函数里面的私有变量。
var bby = function(){
var name = '365';
return function(){
console.log(name)
}
}
bby()() // 365
理解闭包需要掌握两个概念：变量作用域和生命周期
- 变量分为全局变量和局部变量
- 全局变量的生命周期是永久的，局部变量在退出函数时，生命周期结束。
- 可以使用闭包，延长局部变量的生命周期
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();
- 惰性加载函数
