javascript prototype&_proto_&constructor

1，每个对象都有一个__proto__属性。

2，每个构造函数都有一个prototype的方法。

3，_proto_指向自身构造函数的prototype方法。

4，constructor 返回创建该对象的构造函数。

注：（构造函数标准为大写开头，如Function()，Object()等等JS中自带的构造函数，以及自己创建的）都具有一个名为prototype的方法，js中的函数也是对象。所以函数也带有__proto__属性。

     // 构造函数
    function Foo(y) {
        // 构造函数将会以特定模式创建对象：被创建的对象都会有"y"属性
        this.y = y;
    }
    // "Foo.prototype"存放了新建对象的原型引用
    // 所以我们可以将之用于定义继承和共享属性或方法
    // 所以，和上例一样，我们有了如下代码：
    // 继承属性"x"
    Foo.prototype.x = 250;
    // 继承方法"calculate"
    Foo.prototype.calculate = function(z) {
        return this.x + this.y + z;
    };
    // 使用foo模式创建 "b" and "c"
    var b = new Foo();
    var c = new Foo();
    // 调用继承的方法
    b.calculate(); // 
    c.calculate(); // 
    // 让我们看看是否使用了预期的属性
    console.log(
        b.__proto__ === Foo.prototype, // true
        c.__proto__ === Foo.prototype, // true
        // "Foo.prototype"自动创建了一个特殊的属性"constructor"
        // 指向a的构造函数本身
        // 实例"b"和"c"可以通过授权找到它并用以检测自己的构造函数
        b.constructor === Foo, // true
        c.constructor === Foo, // true
        Foo.prototype.constructor === Foo, // true
        b.calculate === b.__proto__.calculate, // true
        b.__proto__.calculate === Foo.prototype.calculate // true
    );


    // 字符串：String()
    var str = "张三";
    console.log(str.constructor); // function String() { [native code] }
    console.log(str.constructor === String); // true
    // 数组：Array()
    var arr = [1, 2, 3];
    console.log(arr.constructor); // function Array() { [native code] }
    console.log(arr.constructor === Array); // true
    // 数字：Number()
    var num = 5;
    console.log(num.constructor); // function Number() { [native code] }
    console.log(num.constructor === Number); // true
    // 自定义对象：Person()
    function Person() {
        this.name = "CodePlayer";
    }
    var p = new Person();
    console.log(p.constructor); // function Person(){ this.name = "CodePlayer"; }
    console.log(p.constructor === Person); // true
    // JSON对象：Object()
    var o = {
        "name": "张三"
    };
    console.log(o.constructor); // function Object() { [native code] }
    console.log(o.constructor === Object); // true
    // 自定义函数：Function()
    function foo() {
        alert("CodePlayer");
    }
    console.log(foo.constructor); // function Function() { [native code] }
    console.log(foo.constructor === Function); // true
    // 函数的原型：bar()
    function bar() {
        alert("CodePlayer");
    }
    console.log(bar.prototype.constructor); // function bar(){ alert("CodePlayer"); }
    console.log(bar.prototype.constructor === bar); // true

function Fun(){
            }
//            我创造了一个函数Fn
//            这个函数由Function生成（Function作为构造函数）
            var fn=new Fun()
//            我创建了一个函数fn
//            这个函数由Fn生成（Fn作为构造函数)
            
            
            console.log(fn.__proto__===Fun.prototype)    //true
//            fn的__proto__指向其构造函数Fun的prototype
            console.log(Fun.__proto__===Function.prototype)        //true
//            Fun的__proto__指向其构造函数Function的prototype
            console.log(Function.__proto__===Function.prototype)    //true
//            Function的__proto__指向其构造函数Function的prototype
//            构造函数自身是一个函数，他是被自身构造的
            console.log(Function.prototype.__proto__===Object.prototype)    //true
//            Function.prototype的__proto__指向其构造函数Object的prototype
//            Function.prototype是一个对象,同样是一个方法,方法是函数,所以它必须有自己的构造函数也就是Object
            console.log(Fun.prototype.__proto__===Object.prototype)         //true
//             与上条相同
//             此处可以知道一点,所有构造函数的的prototype方法的__都指向__Object.prototype(除了....Object.prototype自身)
            console.log(Object.__proto__===Function.prototype)        //true
//            Object作为一个构造函数(是一个函数对象!!函数对象!!),所以他的__proto__指向Function.prototype
            console.log(Object.prototype.__proto__===null)        //true
//            Object.prototype作为一切的源头,他的__proto__是null

//            下面是一个新的,额外的例子

            var obj={}
//            创建了一个obj
            console.log(obj.__proto__===Object.prototype)        //true
//            obj作为一个直接以字面量创建的对象，所以obj__proto__直接指向了Object.prototype，而不需要经过Function了！！

//            下面是根据原型链延伸的内容
//            还有一个上文并未提到的constructor,  constructor在原型链中,是作为对象prototypr的一个属性存在的,它指向构造函数（由于主要讲原型链，这个就没在意、）；

            console.log(obj.__proto__.__proto__===null)        //true
            console.log(obj.__proto__.constructor===Object)        //true
            console.log(obj.__proto__.constructor.__proto__===Function.prototype)        //true
            console.log(obj.__proto__.constructor.__proto__.__proto__===Object.prototype)    //true    
            console.log(obj.__proto__.constructor.__proto__.__proto__.__proto__===null)        //true
            console.log(obj.__proto__.constructor.__proto__.__proto__.constructor.__proto__===Function.prototype)    //true
            

代码转自两位大神的例子。谢谢了。此处存储

http://www.cnblogs.com/libin-1/p/6014925.html

http://www.jb51.net/article/74394.htm