1、原型编程的基本规则
所有的数据都是对象。
要得到一个对象，不是通过实例化类，而是找到一个对象作为原型并克隆它。
对象会记住它的原型。
如果对象无法响应某个请求，它会把这个请求委托给它自己的原型。
2、JavaScript 中的根对象是 Object.prototype 对象。Object.prototype 对象是一个空的
对象
3、除去不常用的 with 和 eval 的情况，具体到实际应用中，this 的指向大致可以分为以下 4种。
作为对象的方法调用。
作为普通函数调用。
构造器调用。
Function.prototype.call 或 Function.prototype.apply 调用。
4、call和apply的区别
Function.prototype.call 和 Function.prototype.apply 都是非常常用的方法。它们的作用一模
一样，区别仅在于传入参数形式的不同。
apply 接受两个参数，第一个参数指定了函数体内 this 对象的指向，第二个参数为一个带下
标的集合，这个集合可以为数组，也可以为类数组，apply 方法把这个集合中的元素作为参数传
递给被调用的函数；
call 传入的参数数量不固定， 跟 apply 相同的是， 第一个参数也是代表函数体内的 this 指向，
从第二个参数开始往后，每个参数被依次传入函数
5、闭包
闭包的更多作用：
1. 封装变量 ；
var mult = (function() {
var cache = {};
var calculate = function() { // 封闭 calculate 函数
console.log('计算函数', this);
var a = 1;
for (var i = 0, l = arguments.length; i < l; i++) {
a = a * arguments[i];
}
return a;
};
console.log('自执行函数', arguments)
return function() {
console.log('返回函数', arguments)
var args = Array.prototype.join.call(arguments, ',');
if (args in cache) {
return cache[args];
}
var count = calculate.apply(this, arguments);
console.log(count)
return cache[args] = count;
}
})();
2. 延续局部变量的寿命
var report = (function(){
var imgs = [];
return function( src ){
var img = new Image();
imgs.push( img );
img.src = src;
}
})();
6、高阶函数的其他应用
1）currying - 函数柯里化 （function 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;
}
}
};
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 函数
2） uncurrying
Function.prototype.uncurrying = function() {
var self = this;
console.log(self);
return function() {
var obj = Array.prototype.shift.call(arguments);
console.log(obj);
return self.apply(obj, arguments);
// return self.apply(arguments);
};
};
var push = Array.prototype.push.uncurrying();
下面的代码是 uncurrying 的另外一种实现方式：
Function.prototype.uncurrying = function(){
var self = this;
return function(){
return Function.prototype.call.apply( self, arguments );
}
};
3）函数节流
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 );
4）分时函数
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 ); // 分批执行的时间间隔，也可以用参数的形式传入
};
};
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();
5）惰性加载函数
<html>
<body>
<div id="div1">点我绑定事件</div>
<script>
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 );
};
7、小结
在进入设计模式的学习之前， 本章挑选了闭包和高阶函数来进行讲解。 这是因为在 JavaScript
开发中，闭包和高阶函数的应用极多。就设计模式而言，因为 JavaScript这门语言的自身特点，
许多设计模式在 JavaScript 之中的实现跟在一些传统面向对象语言中的实现相差很大。在
JavaScript 中，很多设计模式都是通过闭包和高阶函数实现的。这并不奇怪，相对于模式的实现
过程，我们更关注的是模式可以帮助我们完成什么。
