原型与原型链

2019-02-12 本文已影响0人苹果咏

原型是一个对象，我们也称prototype为原型对象
原型的作用是共享方法


function Person() {

}
// 先使用构造函数创建一个对象：
var person = new Person();
person.name = 'Kevin';
console.log(person.name) // Kevin

// Person 就是一个构造函数，我们使用 new 创建了一个实例对象 person。

prototype

每个函数都有一个 prototype 属性，例Person.prototype，函数的 prototype 属性指向了一个对象，这个对象正是调用该构造函数而创建的实例的原型。
Person.prototype.name = 'Kevin';等价于person.name = 'Kevin';

原型：每一个JavaScript对象(null除外)在创建的时候就会与之关联另一个对象，这个对象就是我们所说的原型，每一个对象都会从原型"继承"属性。

// 1. 构造函数的问题. 
        function Star(uname, age) {//构造函数
            this.uname = uname;
            this.age = age;
            // this.sing = function() {
            //     console.log('我会唱歌');

            // }如果公共方法放在构造函数当中，创建实例的时候，都会为这个方法单独开辟内存空间来存放同一个函数，浪费内存
        }
        Star.prototype.sing = function() {//原型对象
            console.log('我会唱歌');
        }
        var ldh = new Star('刘德华', 18);//对象实例
        var zxy = new Star('张学友', 19);
        console.log(ldh.sing === zxy.sing);
        // console.dir(Star);
        ldh.sing();
        zxy.sing();
        // 2. 一般情况下,我们的公共属性定义到构造函数里面, 公共的方法我们放到原型对象身上

proto

每一个JavaScript对象(除了 null )都具有的一个属性，叫__proto__，这个属性会指向该对象的原型。例person.__proto__

function Person() {

}//构造函数Person
var person = new Person();//由构造函数Person创建出的对象person
//对象.__proto__ === 构造函数.prototype
console.log(person.__proto__ === Person.prototype); // true对象的原型和构造函数的原型是等价的
console.log(Person.prototype.constructor === Person) // true

在构造函数中加属性，原型中加方法

constructor

构造函数属性

    function Star(uname, age) {
        this.uname = uname;
        this.age = age;
    }
    Star.prototype.sing = function(){
        console.log('我会唱歌');
    }
    var ldh = new Star('刘德华', 18);
    var zxy = new Star('张学友', 19);
    console.log(ldh.__proto__.constructor == Star.prototype.constructor)//true

function Star(uname, age) {
    this.uname = uname;
    this.age = age;
}
// 很多情况下,我们需要手动的利用constructor 这个属性指回 原来的构造函数
// Star.prototype.sing = function() {
//     console.log('我会唱歌');
// };
// Star.prototype.movie = function() {
//     console.log('我会演电影');
// }
Star.prototype = {
    // 如果我们修改了原来的原型对象,给原型对象赋值的是一个对象,则必须手动的利用constructor指回原来的构造函数
    constructor: Star,
    sing: function() {
        console.log('我会唱歌');
    },
    movie: function() {
        console.log('我会演电影');
    }
}
var ldh = new Star('刘德华', 18);
var zxy = new Star('张学友', 19);
console.log(Star.prototype);
console.log(ldh.__proto__);
console.log(Star.prototype.constructor);
console.log(ldh.__proto__.constructor);

实例与原型

当读取实例的属性时，如果找不到，就会查找与对象关联的原型中的属性，如果还查不到，就去找原型的原型，一直找到最顶层为止。

function Person() {

}

Person.prototype.name = 'Kevin';

var person = new Person();

person.name = 'Daisy';
console.log(person.name) // Daisy

delete person.name;
console.log(person.name) // Kevin

给实例对象 person 添加了 name 属性，当我们打印 person.name 的时候，结果自然为 Daisy。当我们删除了 person 的 name 属性时，读取 person.name，从 person 对象中找不到 name 属性就会从 person 的原型也就是 person.__proto__ ，也就是 Person.prototype中查找，找到了 name 属性，结果为 Kevin。

原型链

JavaScript中所有的对象都是由它的原型对象继承而来。而原型对象自身也是一个对象，它也有自己的原型对象，这样层层上溯，就形成了一个类似链表的结构，这就是原型链。
所有原型链的终点都是Object函数的prototype属性，因为在JavaScript中的对象都默认由Object()构造。Objec.prototype指向的原型对象同样拥有原型，不过它的原型是null，而null则没有原型。
所以查找属性的时候查到 Object.prototype 就可以停止查找了。

var obj = new Object();
obj.name = 'Kevin'
console.log(obj.name) // Kevin
console.log(Object.prototype.__proto__ === null) // true

image.png

JS属性查找机制：依次往上找，先查对象本身有没有此属性>原型对象>Object原型对象>Object

    class Think{//构造函数
        constructor(a){
            this.a = a
        }
        lay(a){
            console.log(a)
        }
    }

    let newThink = new Think()//实例对象

    console.log(Think.prototype)//构造函数的原型
    console.log(newThink.__proto__)//实例对象的原型
    console.log(newThink.__proto__===Think.prototype);//都指向Think的原型对象
    console.log(newThink.__proto__.constructor === Think)//Think原型对象.constructor指向Think构造函数本身

    console.log(Think.prototype.__proto__)//再下一个原型是Object原型对象
    console.log(newThink.__proto__.__proto__)
    console.log(newThink.__proto__.__proto__===Think.prototype.__proto__);
    console.log(newThink.__proto__.__proto__.constructor===Object);//Object原型对象.constructor指向Object构造函数本身
    
    console.log(Think.prototype.__proto__.__proto__)//再下一个原型是null
    console.log(newThink.__proto__.__proto__.__proto__)
    console.log(newThink.__proto__.__proto__.__proto__===Think.prototype.__proto__.__proto__);

怎么记住呢？记着对象是带把的，所以实例对象对应着带把的__proto__，这个指向构造函数的原型构造函数.prototype
实例对象.__proto__ === 构造函数.prototype两个proto相等
实例对象.__proto__.constructor === 构造函数

实例对象.__proto__.__proto__ === 构造函数.prototype.__proto__
各自再加一层__proto__也相等，对应下一层原型Object原型对象，所以prototype只出现一次
实例对象.__proto__.__proto__.constructor === Object

再加一层原型也相等，这里都是等于null
实例对象.__proto__.__proto__.__proto__ === 构造函数.prototype.__proto__.__proto__

重写原型对象

function Person (){
}
var friends = new Person()
Person.prototype = {
    name: "edfewf",
    age: "32",
    sayName: function(){
        console.log(this.name)
    }
}

friends.sayName() //error
Person.prototype === friends.__proto__  //false

先创建Person的一个实例，有重写了他的原型对象，friends.sayName()时出错，因为friends指向的原型不包含sayName()函数