面向对象的理解

1.原型链
每一个构造函数都一个属性叫做prototype，指向一个对象。
当这个构造函数被new的时候，它的每一个实例的__proto__属性，也指向这个对象。
每一个函数天生都有prototype属性指向一个空对象。也就是说，我们不需要定义prototype属性，任何一个函数只要写出来，他就拥有prototype属性。这个属性对自己而言是没有任何意义。它的唯一意义是它实例的指明灯！构造函数的prototype的指向，和它new出来实例的__proto__属性的指向是一样的！

我们称People.prototype是People构造函数的“原型”，People.prototype是xiaoming的“原型对象”。
当xiaoming身上没有某一个属性的时候，系统会沿着__proto__去寻找他的原型对象身上有没有这个属性。
2.方法的定义在原型上
我们把函数若写构造函数里面，就相当于定义在了每一个对象身上，此时函数会产生多个不同的副本，影响程序的效率，开销内存大！此时可以把函数定义在构造函数的原型上，这样new出的实例，__proto__就会指向这个对象，从而能够使用这个方法。
3.内置构造函数
Object 函数：系统内置了一个Object函数，可以直接new它，返回一个空对象。然后就可以给空对象添加属性。

Object.prototype是所有对象原型链终点而
Object.prototype.__proto__ 为null
Function 函数：系统内置了一个Function的构造函数，用于构造函数的。事实上，所有的function字面量，都是它的实例。


任何函数都是Function的实例，Object也是Function的实例。Function自己也是自己的实例！
4.原型链的深入
引用类型值的对象他们的字面量的__proto__就是他们类型的构造函数的prototype

({}).__proto__ === Object.prototype
([]).__proto__ === Array.prototype
(/\d/).__proto__ === RegExp.prototype
(function(){}).__proto__ === Function.prototype

通过new关键字，此时构造函数的prototype即是实例的__proto__。
任何一个对象都有原型对象，原型链的最终的指向是Object.prototype.

5.constructor 属性
任何一个构造函数的prototype身上都有constructor属性，指向构造函数。
注意：constructor 属性特别的脆弱，当我们修改原型对象的属性为字面量的时候，此时constructor 就没了。

function People(){};
People.prototype.content = function(){
    alert("初始值")
}
People.prototype = {
    "content":function(){
        alert("修改后得值")
    }
};

var xiaoming = new People();
xiaoming.content();
console.log(People.prototype.constructor === People) //false
console.log(xiaoming.constructor == People);	//false
console.log(xiaoming.constructor); //不是People 但是通过字面量的形式定义就是Object

6.instanceof运算符
这个运算符用来检测某一个对象是不是某一个构造函数的实例
因为Object.prototype是所有原型链的终点，所任任何对象 instanceof Object都为true

小题目：
(new Array()).constructor.constructor.constructor == (new Array()).constructor

小题目：

function Fun(para1,para2,para3){
        var obj = {};
        obj.para1 = para1;
        obj.para2 = para2;
        obj.para3 = para3;
        return obj;
    }
    Fun.prototype.para4 = 4;
    var o = new Fun(1,2,3);
    console.log(o.para1); 
    console.log(o.para4); 
    console.log(o instanceof Fun);
    console.log(o.__proto__ == Fun.prototype); 
    

var A = function() {};
    A.prototype = {};
    var B = {};
    console.log(A.constructor === Function); //输出什么？
    console.log(B.constructor === Object);   //输出什么？
    var a = new A();
    A.prototype = {};
    var b = new A();
    b.constructor = A.constructor;
    console.log(a.constructor == A);//输出什么？
    console.log(a.constructor == b.constructor);//输出什么？
    console.log(a instanceof A);//输出什么？
    console.log(b instanceof A);//输出什么？