JavaScript 是一门弱范例言语，从不须要范例转换。对象继承关联变得可有可无。关于一个对象来讲主要的时它能够做什么，而不是它从哪里来。

浏览《javascript言语精炼》笔记！

伪类

js的原型存在很多的抵牾，它不能直接让对象从别的一个对象继承，反而涌现了一个过剩的简介曾：经由过程组织函数来发生对象。

当函数对象建立的时刻，function组织器发生的函数对象会运转相似如许的代码：

function Person() {};
Person.prototype = {
    constructor: this;
};

新的函数汇给予一个prototype的值，由于js言语没有供应一个要领去肯定哪一个函数式打算来做组织器的，所以每一个函数都邑有一个prototype的对象。而体贴的是prototype对象，而不是constructor。

但采纳组织器挪用情势，等于运用了new前缀去挪用一个函数时，函数实行的体式格局会转变。

Function.method('new', function(){
    var that = Object.create(this.prototype),
        other = this.apply(this, arguments);

    return (typeof other === 'object' && other) || that;
});

1. 先建立一个新的对象，它继承自组织器函数的原型对象
2. 挪用组织器函数，绑定this到新的对象上面
3. 假如它的放回值不是一个对象的话，就放回哪一个新对象

来定义两个组织器并扩大它的原型：

function Person(name) {
    this.name = name;
};  
Person.prototype.sayName = function(){
     alert(this.name);
};

function Cat(name) {
    this.name = name;
};

能够让另一个伪类去继承Person，经由过程定义它的constructor函数而且替代了它prototype为一个Person的实例来完成：

Cat.prototype = new Person;

然后来给Cat的prototype上增加一个要领：

Cat.prototype.sayHello = function(){
    alert('Hello');
};

末了实例化Cat而且挪用它的要领：

var cat = new Cat('john');
cat.sayName(); // john
cat.sayHello(); // Hello

末了另有修正Cat的construction指向：

Cat.prototype.constructor = Cat;

能够经由过程运用method要领来定义一个inherits要领来完成伪类的继承：

Function.method('inherits', function(Parent){
    this.prototype = new Parent;
    return this;
});

伪类情势继承的题目：

• 没有私有环境，一切属性都是公然的。无法接见super（父类）要领。
• 假如在挪用组织器函数时刻遗忘挪用new操作符，那末this将不会绑定到新的对象上，而是全局window上。
• “伪类”的情势能够给不收悉js的程序员轻易，但它也隐蔽了该言语的实在实质。自创类的示意法能够误导程序员去编写过于深切与庞杂的条理构造。
• construction的指向毛病。

对象说明符

有的时刻，组织器能够要接收一大串的参数，而且还要记着参数的递次是很难题滴，在这类情况下，编写组织器的时刻让它接收一个对象说明符，能够会越发的轻易。

function Person(name, age, sex, scholl, add) {};

参数改成对象说明符的情势：

function Person({
    name: 'john',
    age: 16,
    sex: 'man',
    scholl: 'zhyz',
    add:  'zhuhai'
});

优点：如今能够多个参数根据恣意递次去分列，假如组织器会智慧的运用默认值，一些参数能够被疏忽掉，而且代码越发轻易的浏览。

原型

在一个地道的原型继情势中，我们会摒弃类，转而专注于对象。

基于原型的继承先对基于类的继承在概念上越发简朴：一个对象能够继承以旧的对象。

用对象字面量来建立一个对象：

var Person = {
    name: 'john',
    sayName: function(){
        alert(this.name);
    },
    sayHello: function(){
        alert('Hello');
    }
};

有了想要的对象后，就能够应用Object.create要领来组织出更多的实例：

var nPerson = Object.create(Person);
nPerson.sayName(); // john

这是一种差异化继承。经由过程定制一个新的对象，我们指明它与所基于的基础对象的区分。

下面的例子演示了怎样运用Object.create来完成类式继承。这是一个单继承。（来自MDN）

//Shape - superclass
function Shape() {
  this.x = 0;
  this.y = 0;
}

Shape.prototype.move = function(x, y) {
    this.x += x;
    this.y += y;
    console.info("Shape moved.");
};

// Rectangle - subclass
function Rectangle() {
  Shape.call(this); //call super constructor.
}

Rectangle.prototype = Object.create(Shape.prototype);

var rect = new Rectangle();

rect instanceof Rectangle //true.
rect instanceof Shape //true.

rect.move(1, 1); //Outputs, "Shape moved."

函数化

大部分所看到的继承情势的一个缺点就是没办法去庇护隐私。对象的属性都是可见的。没有办法获得私有的变量和函数。

var consturctor = function(spec, my){
    var that,   // 其他的私有实例变量
        my = my || {};

    // 把同享的变量和函数增加到 my 中
    // 给 that = 一个新的对象
    // 增加给 that 的特权要领

    // 末了把 that 对象返回
    return that;
};

1. 建立一个对象。
2. 定义私有实例的变量和要领。
3. 给这个新的对象扩大要领，这些要领具有特权去接见参数。
4. 返回谁人对象。

spec对象包括组织器须要组织一个新的实例的一切信息。spec的能够会被复制到私有变量中，或许被其他函数转变，或许要领能够在须要的时刻接见spec的信息。

声明该对象私有的实例变量的要领。经由过程简朴地声明变量就能够做到了。组织器的变量和内部函数变成了该实例的私有成员。

my对象是一个为继承链中的构组织器供应的隐秘同享的容器。经由过程给my对象增加同享隐秘成员：

my.member = value;

然后组织一个新的对象而且把它赋值给that。接着扩大that，到场构成该对象接口的特权要领。能够分派一个新函数成为that的成员要领，然后再把它分派给that：

var methodical = function(){ ... };
that.methodical = methodical;

分两步去定义methodical的优点就是，假如其他要领想要挪用methodical,它们能够直接挪用methodical()而是不是that.methodical()。假如实例遭到损坏或修正，挪用methodical还是会继承事情，由于它们私有的methodical不会该实例被修正的影响。

末了把that返回。

函数化情势有很大的灵活性。它比拟伪类情势不仅带来的事情更少，还让我们获得更好的封装和信息隐蔽，以及接见父类要领的才能。

假如对象的一切状况都是私有的，那末该对象就成为一个“防伪”对象。该对象的属性能够被替代或删除，但该对象的完整性不会遭到危险。

部件

从一套部件中吧对象组装出来。比方，组织一个给任何对象增加简朴事宜处置惩罚特征的函数。他会给对象增加一个on要领、一个fire要领和一个私有的事宜注册表对象。

用这类要领，一个组织器函数能够从一套部件中把对象组装出来。js的弱范例在这里就是一个庞大的上风，由于无需消费精神去相识对象在范例体系中的集成关联。

var eventuality = function(that){
    var registry = {};

    that.fire = function(e){
        var arry, func, handler, i,
            type = typeof e === 'string' ? e : e.type;

        if (registry.hasOwnProperty(type)) {
            array = registry[type];
            for (i = 0; i < array.length; i += 1) {
                handler = array[i];
                func = handler.method;
                if (typeof func === 'string') {
                    func = this[func];
                }
                func.apply(this, handler.parameters || [e]);
            }
        }
        return this;
    };

    that.on = function(type, method, parameters){
        var handler = {
            method;: method,
            parameters: parameters
        };
        if (registry.hasOwnProperty(type)) {
            registry[type].push(handler);
        } else {
            registry[type] = [handler];
        }
        return that;
    };

    return that;
};