1.对象合适于网络和治理数据，轻易构成树型组织。
Javascript包含一个原型链特征，许可对象继续另一对象的属性。准确的运用它能削减对象的初始化时刻和内存斲丧。
2.函数它们是javascript的基础模块单位，用于代码复用、信息隐蔽和组合挪用。函数用于指定对象的行动。一般来说，编程就是将一组需求分解成一组函数和数据组织的妙技。
3.模块我们可以运用函数和闭包来组织模块。模块是一个供应接口却隐蔽完成状况和完成的函数或对象。

1.自定义范例–组织函数形式(伪类形式)

在基于类的体系中，对象是如许定义的：运用类来形貌它是什么样的。假如修建是基于类的体系，则修建师会先画出屋子的蓝图，然后屋子都根据该蓝图来制作。

在运用自定义范例形式完成继续的时刻,我们只须要将参数通报给组织函数，然后将参数挂载在实例对象上。其他关于实例对象的要领都不必通报参数，由于经由历程 实例对象挪用的要领内部的this都可以接见到该参数。挂载在实例this对象上的变量称为实例变量。

组合–继续

function Person (name, age, job) {
    // 实例变量
    this.name = name;
    this.age = age;
    this.job = job;
}
Person.prototype.sayName = function () {
    alert(this.name);
}

var person1 = new Person('Nicholas', 29, 'Software Engineer');
var person2 = new Person('Greg', 27, 'Doctor');

function SuperType (name) {
    this.name = name;
    this.colors = ['red','blue', 'green'];
}

SuperType.prototype.sayName = function () {
    console.log(this.name);
}

function SubType (name, age) {
    // 继续属性
    SuperType.call(this,name);
    this.age = age;
}

// 继续要领
SubType.prototype = new SuperType();

SubType.prototype.sayAge = function () {
    console.log(this.age)
}

var instance1 = new SubType('Nicholas', 29);
instance1.colors.push('black')
console.log(instance1.colors);
instance1.sayName();
instance1.sayAge();

var instance2 = new SubType('Greg', 27)
console.log(instance2.colors);
instance2.sayName();
instance2.sayAge();

在继续属性和继续要领上，我们一共挪用了两次超类组织函数，当经由历程new挪用超类组织函数建立子类组织函数的原型时，有一个题目，子类组织函数的原型对象如今就是超类组织函数的实例，因而也会有在超类组织函数为实例对象this增加的属性，只是值为undefined罢了，也就是说经由历程new挪用超类组织器函数来变动子类革新器的原型时，那末在子类组织器的原型上便会有过剩的属性。这便造成了糟蹋。而我们须要的实在只是，子类组织器的原型可以继续超类组织器原型的要领罢了。因而我们须要的，1.建立一个子类组织器原型对象。2.此子类组织器原型继续自超类组织器的原型。3.由于我们在1中改写了子类组织器的原型对象，也就是从新建立了原型对象，因而我们须要在新建立的原型对象上增加constructor属性并将其赋值为子类组织器函数。
将上面的代码改写一些，以下所示。

关于constructor属性:只在组织器函数的原型上才有的属性并指向该组织器，改写了的原型对象默许是没有constructor属性的。

寄生组合式–继续

function inheritPrototype (subType,superType) {
    var prototype = Object.create(superType.prototype);
    prototype.constructor = subType;
    subType.prototype = prototype;
};

function SuperType (name) {
    this.name = name;
    this.colors = ['red', 'blue', 'green'];
}
SuperType.prototype.sayName = function () {
    console.log(this.name);
}
function SubType(name, age) {
    //继续属性
    SuperType.call(this,name);
    this.age = age;
}
//继续要领
inheritPrototype(SubType,SuperType);
SubType.prototype.sayAge = function () {
    console.log(this.age);
}

var instance = new SubType();

经由历程隐蔽那些所谓的prototype操纵细节，如今看起来没那末奇异了。然则不是真的有所发明:
没有私有环境，一切属性都是公然的。无法接见父类的要领。难以调试

2.原型

在一个地道的原型形式中，我们会抛弃类，转而专注对象。基于原型的继续比拟基于类的继续在概念上更简朴:一个新对象可以继续一个旧对象的属性。你经由历程组织有效的对象最先，接着可以组织更多和谁人对象相似的对象。这就可以完全避免把一个运用拆解成一系列嵌套抽象类的分类历程

在基于原型的体系中,我们建立的对象，看起来要像我们想要的一切这类范例的对象那样，然后通知javascript引擎，我们想要更多像如许的对象。假如修建是基于原型的，修建师会先建一所屋子，然后将屋子都建成像这类样子容貌的。

要领Object.creat()作为new操纵符的替代计划，运用它来建立javascript对象时，能增加一种更像是基于原型的觉得。

function myMammal = {
    name : 'Herb the Mammal',
    get_name : function () {
        return this.name;
    },
    says : function () {
        return this.saying || '';
    }
}

var myCat = Object.create(myMammal);
myCat.name = 'Henrietta';
myCat.saying = 'meow';
myCat.purr = function (n) {
    var i, s = '';
    for (i = 0;i < n; i += 1) {
        if(s) {
            s += '-'
        }
        s += 'r';
    }
    return s;
}

myCat.get_name = function () {
    return this.says + ' ' + this.name + this.says;
}

这是一种”差别化继续”。经由历程定制一个新的对象，我们指明它与所基于的基础对象的区分。
有时刻，它对某些数据组织继续于其他数据组织的情况异常有效。

3.函数化–工场形式

在伪类形式里，组织器函数Cat不能不反复组织器Mammal已完成的事情。在函数化形式中那不再须要了，由于组织器Cat将会挪用组织器Mammal，让Mammal去做对象建立中的大部分事情，一切Cat只关注本身的差别即可。

函数化形式有很大的灵活性。它比拟伪类形式不仅带来的事情更少，还让我们获得更好的封装和信息隐蔽，以及接见父类要领的才能。
假如我们用函数化得款式去建立对象，而且该对象的一切要领都不必this或that,那末该对象就是持久性的。一个持久性的对象就是一个简朴功用函数的鸠合。

私有变量:任安在函数中定义的变量，都可以认为是私有变量，由于不能在函数外部接见这些变量。

闭包

闭包是阻挠渣滓接纳器将变量从内存中移除的要领，使的在建立变量的实行环境的表面可以接见到该变量。

请记着:闭包由函数建立。每次挪用函数会建立一个唯一的实行环境对象。函数实行完后，实行对象就会被抛弃，除非挪用者援用了它。固然，假如函数返回的是数字，就不能援用函数的实行环境对象。然则假如函数返回的是一个更庞杂的组织，像是函数、对象或许数组，将返回值保存到一个变量上，就建立了一个对实行环境的援用。

Function.prototype.method = function (name,func) {
    this.prototype[name] = func;
    return this; 
}
// 工场mammal函数
var mammal = function (spec) {
    var that = {};

    that.get_name = function () {
        return spec.name;
    }
    that.says = function (spec) {
        return spec.saying || '';
    } 

    return that;
}

// 工场cat函数(基于mammal的函数)
var cat = function (spec) {
    spec.saying = spec.saying || 'meow';
    var that = mammal(spec);
    that.purr = function (n) {
        var i, s = '';
        for (i = 0; i < n; i += 1) {
            if(s) {
                s += '-';
            }
            s += 'r';
        }
    }
    that.get_name = function () {
        return that.says() + ' ' + spec.name + ' ' + that.says();
    }
    return that;
}

// 建立myCat对象
var myCat = cat({name: 'Henrietta'});

Object.method('superior',function (name) {
    var that = this,
        method = that[name];
    return function () {
        return method.apply(that, arguments)
    }
})

// 工场coolcat函数(基于cat函数)
var coolcat = function (spec) {
    var that = cat(spec),
        super_get_name = that.superior('get_name');
    that.get_name = function (n) {
        return 'like ' + super_get_name() + ' baby';
    }
    return that;
}

var myCoolCat = coolcat({name : 'Bix'});

var name = myCoolCat.get_name();

函数化模块形式有很大的灵活性。它比拟组织函数形式不仅带来的事情更少，还让我们获得更好的封装歇息和隐蔽，以及接见父类要领的才能。假如对象的一切状况都是私有的，那末该对象就成为一个”防伪(tamper-proof)”对象。该对象的属性是可以被替代或许删除，当该对象的完整性不会遭到破坏。我们用函数式的款式建立一个对象，而且该对象的一切要领都不运用this或许that，那末该对象就是持久性对象。一个持久性对象，就是一个简朴的函数功用的鸠合。
一个持久性的对象不会被入侵。接见一个持久性的对象时，除非有要领受权，不然攻击者不会接见对象的内部状况。

模块形式

前面的形式是用于 自定义范例建立私有变量和特权要领的。而道格拉斯所说的模块形式则是为 单例建立私有变量和特权要领。所谓单例指的就是只要一个实例的对象。(就是用对象字面量示意法建立的对象)

var singleton = function () {
    // 私有变量和函数
    var privateVariable = 10;

    function privateFunction () {
        return false;
    }
    //特权/公有要领和属性
    return {
        publicProvperty: true;

        publicMethod: function () {
            privateVariable++;
            return privateFunction();
        }
    }
}

从本质上讲，这个对象字面量定义的是单例的大众接口。这类形式在须要对单例举行某些初始化，同时又须要保护其私有变量时异常有效。简言之，假如必需建立一个对象并以某些数据对其举行初始化，同时还要公然一些可以接见这些私有数据的要领。

加强的模块形式

这类加强的模块形式合适那些单例必需是某种范例的实例，同时还必需增加某些属性和要领对其加以加强的例子。

var singleton = function () {
    // 私有变量和函数
    var privateVariable = 10;

    function privateFunction () {
        return false
    }
    // 建立对象
    var object = new CustomType();

    // 增加特权/公有属性和要领
    object.publicProperty = true;
    object.publicMethod = function () {
        privateVariable++;
        return privateFunction();
    }

    return object;
}()