javascript语言精粹

第四章（前面三章没啥意思）
1、枚举for in 与 for 的区别，for in 会枚举原型上的属性，而且顺序时不确定的，而for顺序确定且不会发掘原型上的属性。
2、减少全局变量方法一，为应用只创建一个唯一的全局变量。即把全局性的资源都纳入一个命名空间中。
3、函数对象通过函数字面量来创建。

var  func = function () {};

4、每个函数有两个附加参数this、arguments，this取决于调用模式（方法调用模式、函数调用模式、构造器调用模式、apply调用模式）。调用运算符是跟在任何产生一个函数值的表达式后面的一对园括号。

1. 方法调用模式：一个函数被定义为一个对象的属性时称为方法，方法被调用时，this会自动绑定到该对象。调用就是使用 . 或者 [] 操作符来访问方法。
2. 函数调用模式：函数并非一个对象的属性时，会被当作一个函数来调用，this会被绑定到全局对象。这样导致方法不能利用内部函数来帮助他工作。这是一个语言设计的失误。如下double是myobj一个属性方法：

    var add = function(a, b) {
        return a + b;
    };
    var myobj = {
        value: 3
    };
    var value = 2;
    myobj.double = function() {
        console.log("method:" + this.value); //method:3
        var help = function() {
            console.log("infunc:" + this.value);//infunc:2
            this.value = add(this.value, this.value);
        };
        help(); // 以函数形式调用help
    }
    myobj.double();
    console.log(myobj.value); //3

解决办法时保存对this的引用

 var add = function(a, b) {
        return a + b;
    }
    var myobj = {
        value: 3
    }
    var value = 2;
    myobj.double = function() {
        var _this = this;
        console.log("method:" + _this.value); //method:3
        var help = function() {
            console.log("infunc:" + _this.value); //infunc:3
            _this.value = add(_this.value, _this.value);
        };
        help(); // 以函数形式调用help
    }
    myobj.double();
    console.log(myobj.value); //6

3 构造器调用模式：使用new来调用函数。背地里会创建一个连接到该函数prototype成员的新对象，同时this被绑定到这个新对象上，绑定this后执行该函数的函数体，如果函数本身没有对象返回或者返回的不是对象，就返回这个新对象，否则返回函数中的对象，把这个新对象丢弃。所以这里的new类似于一个延迟的return语句。这里的函数被称为构造函数，一般首字母大写，这是个垃圾方法。别用，就是这样。
4、apply调用模式：显示伪多态。绑定this指向。

5、扩充类型的功能：
数字的取整方法（丢弃非整数部分）扩充：

Number.method('integet',function (){
        return Math[this < 0 ? 'ceil' : 'floor'](this);
    })

移除字符串首尾空白方法的扩充：

String.method('trim',function(){
        return this.replace(/^\s+|\s+$/g,'');
    })

好吧，你不知道method是什么？
( String, Number, Array, Function都是构造函数，所以都prototype于Function.prototype)

Function.prototype.method = function(name, func){
            if(!this.prototype[name]){
                this.prototype[name] = func;
            }
            return this;
        }

6、闭包的一些概念技巧：避免在循环中创建函数，我们可以先在循环之外创建一个辅助函数，让这个辅助函数返回一个绑定了i值的函数，就不会在这样的问题中吃苦头了。
7、异步回调可以防止同步请求导致页面假死。
8、javascript的单例模式就是用对象字面量表示法创建的对象。其属性值可以时数值或函数。

9、记忆函数 可以显著提高递归效率，以fabonacci为例。

var count = 0;
    var fibonacci = function(n){
        count++;
        return n < 2 ? n : fibonacci(n-1) + fibonacci(n-2);
    }
    console.log(fibonacci(10) + " number " + count); //177

    var fibonacci2 = function(n){
        var cache = [0,1];
        var fib = function(n){
            count++;
            var result = cache[n];
            if(typeof result !== 'number'){
                result = fib(n-1) + fib(n-2);
                cache[n] = result;
            }
            return result;
        }
        return fib;
    }()
    console.log(fibonacci2(10) + " number " + count);//19

10、函数柯里化
自己YY的：

 function addCurry() {
        var slice = Array.prototype.slice
        var args = slice.call(arguments);
        return function add() {
            arr = slice.call(arguments);
            //如果没有参数则计算结果（addCurry(1)(2)() -> 3）
            if(!arr.length){
               return args.reduce(function(pre, cur) {                                                          return pre + cur;})
            }else{//如果有参数，继续添加值args数组中
                args = args.concat(arr);
                return add;
            }
        }
    }

书上的

 Function.method('curry',function(){
        var slice = Array.prototype.slice,
            _this = this,
            args = slice.apply(arguments);
        return function(){
            return _this.apply(null,args.concat(slice.apply(arguments)));
        };
    });