protocol类型与 java 类型对照 proto prototype

文章目录

• 前言
• 正文

• 每个实例对象都会有__proto__属性,其被称为隐式原型
• 每一个构造函数都有prototype属性，被称为显示原型
• 每一个实例对象的隐式原型__proto__属性指向自身构造函数的显式原型prototype
• 每一个构造函数的prototype也是一个对象，它的__proto__属性又指向它上一级的构造函数（原型链）

---

前言

其实上面的三句话是对这张图一部分解释：

上面的person是构造函数生成的一个实例；

再结合这三句话 你就明白了

是不是你和我一样经常忘记原型和原型链的知识点，忘记prototype和__proto__是啥东西，所以我的标题加了再一次，这东西真的非常重要，但是记不住，记不住的根本原因还是没有彻底理解。所以写这篇文章让你我永久记住

正文

每个实例对象都会有__proto__属性,其被称为隐式原型

const obj =  new Object()
console.log(obj);

function f(){

}
console.log(f.__proto__);

class ctx{

}

console.log(ctx.__proto__);

上述代码和结果可以看出，无论是类，函数，还是Object对象new出来的实例，都有__proto__属性，称为隐式原型,本质上也是对象

每一个构造函数都有prototype属性，被称为显示原型

//创建了一个构造函数 
function People (name,str) {
    this.name = name;
    this.act = function () {
        console.log("我是"+this.name);
    };
}
console.log(People);

//实例化一个People
const Bob = new People('鲍勃')
console.log(Bob);

每一个实例对象的隐式原型__proto__属性指向自身构造函数的显式原型prototype

console.log(Bob.proto === People.prototype);//true
继续是上面的代码

//创建了一个构造函数 
function People (name,str) {
    this.name = name;
    this.act = function () {
        console.log("我是"+this.name);
    };
}
console.log(People);

//实例化一个People
const Bob = new People('鲍勃')
console.log(Bob);


console.log(Bob.__proto__ === People.prototype);//true

每一个构造函数的prototype也是一个对象，它的__proto__属性又指向它上一级的构造函数（原型链）

复制并修改了一下那位大神的代码，注释上已经写得明明白白了

这里需要注意的是Object是属于原型链的顶层，所有构造函数的的prototype方法的__都指向__Object.prototype(除了…Object.prototype自身)

function Fun(){
            }
//            我创造了一个函数Fn
//            这个函数由Function生成（Function作为构造函数）
            var fn=new Fun()
//            我创建了一个函数fn
//            这个函数由构造函数Fun生成


            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在原型链中,是作为对象prototype的一个属性存在的,它指向构造函数（由于主要讲原型链，这个就没在意、）；

            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


//            以上，有兴趣的可以一一验证　　F12搞起.

---