第一章：
    以后章节会用到的定义新方法的方法

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



第二章：
    1，注释：避免使用/* */，尽量使用//
        因为*会出现在正则表达式中，例如以下的内容会引起错误
        /*
            var rm_a = /a*/.match(s);
        */
   
    2，数字：
        JavaScript只有一个单一的数字类型，内部表示为64位浮点数，因此1和1.0是相同的值。

        带有指数的数字表示：由e之前的部分乘以10的e之后部分的次方。

　　　　　　　　　　　　例如100表示为1e2


        NaN表示一个不能产生正常结果的运算结果。NaN不等于任何值，包括它自己。可以使用isNaN()检测NaN。

    3，字符串：
        \为转义字符
        length属性表示字符串长度
        字符串是不可变的。通过 + 运算符连接其他字符串会得到一个新的字符串。

    4，语句
        当var语句用在函数内部时，它定义了这个函数的私有变量
        JavaScript中的代码块不会创建一个新的作用域，因此，变量应该被定义在函数的顶端，而不是代码块中。
        下面列出的值被当做假(false)：
            ·false
            ·null
            ·undefined
            ·空字符串’’
            ·数字0
            ·数字NaN
       
        通过检测object.hasOwnProperty(variable)来确定这个属性名实该对象的成员，还是从原型链里找到的。
       

第三章：
    JavaScript的简单类型包括number、string、boolean、null和undefined，其他所有值都是object
    对象字面量：
        var empty_object = {};
        var stooge = {
            ‘first-name’ : ‘Jerome’,
            ‘last-name’ : ‘Howard’
        }

    检索：
        检索对象中包含的值，可以采用在[]后缀中扩住一个字符串表达式的方式，也可以使用 . 表示法代替，优先考虑 . 表示法。
        如果检索一个不存在的成员元素的值，将返回一个undefined值
        || 运算符可以用来填充默认值

var status =flight.status || ‘unknown’;  //当flight.status不存在时，将’unknown’值赋给status


         当尝试检索一个undefined值将会导致TypeError异常，可以通过 && 运算符来避免

flight.equipment;                    // undefined
flight.equipment.model;                // throw ‘TypeError’
flight.equipment && flight.equipment.model; // undefined



    删除：
        delete运算符可以用来删除对象的属性，不会触及原型链中的任何对象。
        删除对象的属性可能会让来自原型链中的属性浮现出来

    减少全局变量污染：
        最小化使用全局变量的一个方法是在应用中只创建唯一一个全局变量
            var MYAPP = {};


第四章：
    函数对象：
        对象是”名/值”对的集合并拥有一个连到原型对象的隐藏连接。对象字面量产生的对象连接到Object.prototype，函数对象连接到Function.prototype(该原型对象本身连接到Object.prototype)。
        每个函数在创建时附有两个附加的隐藏属性：函数的上下文和实现函数行为的代码       
        每个函数在创建时也随带有一个prototype属性，它的值是一个拥有constructor属性且值即为该函数的对象

    函数调用：
        调用一个函数时将暂停当前函数的执行，传递控制权和参数给新函数，除了声明时定义的形式参数外，还有两附加参数：this和arguments。this的值取决于调用的模式。在JavaScript中共有四种调用模式：
                方法调用模式、函数调用模式、构造器调用模式和apply调用模式，它们在如何初始化this上存在差异。

     方法调用模式：
        当函数被保存为对象的一个属性时，它被称为一个方法。当一个方法被调用时，this为该对象。

var myObject = {
    value : 0,
    increment : function(inc) {
        this.value += typeof inc === ‘number’ ? inc : 1;
    }
}
myObject.increment();
alert(myObject.value);    // 1



    函数调用模式：
        当一个函数并非一个对象的属性时，那么它被当做一个函数来调用：
            var sum = add(3, 4);
        这个时候，this被绑定到全局变量。这样的结果造成方法不能利用内部函数来工作，因为内部函数的this绑定了错误的值。解决方案：如果该方法定义一个变量并给它赋值为this，那么内部函数就可以通过那个变量访问到this，按照约定，那个变量命名为that：

myObject.double = function() {
    var that = this;  //解决方法

    var helper = function() {
        that.value = add(that.value, that.value);
    };
    helper();    //以函数的形式调用helper
}

// 以方法的形式调用double
myObject.double();


构造器调用模式：
    如果在一个函数前面带上new来调用，那么将创建一个隐藏连接到该函数的prototype成员的新对象，同时this将会被绑定到那个新对象上。

// 名字为Quo的构造函数
var Quo = function(string) {
    this.status = string;
}
// 给Quo的所有实例提供一个名为get_status的公共方法
Quo.prototype.get_status = function() {
    return this.status;
};
// 构造一个Quo实例
var myQuo = new Quo(‘confused’);

    不推荐使用这种形式的构造器函数。


Apply调用模式：
    apply方法允许我们选择this值。apply方法接收两个参数，第一个是将被绑定给this的值，第二个是一个参数数组

var array = [3, 4];
var sum = add.apply(null, array);  // sum值为7
var statusObject = {
    status : ‘A-OK’
};
// statusObject没有继承自Quo.prototype，但我们可以在statusObject上
// 调用get_status方法
var status = Quo.prototype.get_status.apply(statusObject);  // status值为 ‘A-OK’


返回：
    一个函数总是会返回一个值，如果没有指定返回值，则返回undefined
    如果函数以在前面加上new的方式来调用，且返回值不是一个对象，则返回this


给类型增加方法：   

 

//给Number增加integer方法来提取数字中的整数部分：
Number.prototype.integer = function() {
    return Math[ this < 0 ? ‘ceiling’ : ‘floor’ ](this);
}

//给String增加一个移除字符串末端空白的方法：
String.prototype.trim = function() {
    return this.replace(/^\s+|\s+$/g, ‘’);
}

 


模块：
    模块模式的一般形式：一个定义了私有变量和函数的函数，利用闭包创建可以访问私有变量和函数的特权函数，然后返回这个特权函数，或者把它们保存在一个可以访问的地方


级联：
    如果一些方法没有返回值，那么我们可以让它们返回this而不是undefined。这样就可以在一条语句中依次调用同一个对象的多个方法


记忆：
    函数可以用对象去记住先前操作的结果，从而能避免无谓的运算，这种优化被称为记忆。
    例如，当我们要计算Fibonacci数列：

var fibonacci = function(n) {
    return n < 2 ? n : fibonacci(n - 1) + fibonacci(n - 2);
}
for(var i=0; i<=10; i++) {
    document.writeln(‘//’ + i + ‘:’ + fibonacci(i));
}


    在这个循环中，fibonacci被调用453次，我们调用了它11次，但它自己可能用442次调用去计算刚刚计算的值，让我们使用一个memo的数组保存计算结果：

var fibonacci = function(n) {
    var memo = [0, 1];
    var fib = function(n) {
    var result = memo[n];
    if(typeof result !== ‘number’) {
        result = fib(n - 1) + fib(n - 2);
        memo[n] = result;
    }
    return result;
    };
    return fib;
}();


    这样再次计算会发现，这个函数只调用了29次。

    我们可以把这种形式一般化，编写一个函数来帮助我们构造带记忆功能的函数。memoizer函数将取得一个初始的memo数组和fundamental函数。它返回一个管理memo存储和在需要时调用fundamental函数的shell函数。

var memoizer = function(memo, fundamental) {
    var shell = function(n) {
        var result = memo[n];
        if(typeof result !== ‘number’) {
            result = fundamental(shell, n);
            memo[n] = result;
        }
        return result;
    };
    return shell;
};