最初，在通过构造函数Object.create()方法创建对象，其原型是在对象被创建时指定的，对象原型在实例化之后保持不变，ES5中出现了Object.getPrototypeOf()方法来返回任意指定对象的原型，但仍缺少对象在实例化后去修改原型的方法。

ES6中新增了Object.setPrototypeOf()来修改实例指向的原型对象。举例：

let person = {
    name: 'zhangsan',
    get() {
        return this.name;
    }
}
let date = {
    time:new Date().getFullYear()+'年',
    get() {
        return this.time;
    }
}
let obj = Object.create(person);
let dt = Object.create(date);
const isAlong = Object.is(Object.getPrototypeOf(obj),person);

console.log(isAlong);  // true

console.log(obj.get()); //zhangsan

console.log(dt.get());  // 2021年

上述中先创建两个基对象（person和date），通过两个基对象去实例化，再去调取继承对象的方法。
修改对象的原型

let person = {
    name: 'zhangsan',
    get() {
        return this.name;
    }
}
let date = {
    time:new Date().getFullYear()+'年',
    get() {
        return this.time;
    }
}
let obj = Object.create(person);
let dt = Object.create(date);

// 修改对象的原型
Object.setPrototypeOf(obj,date);  

const isAlong = Object.is(Object.getPrototypeOf(obj),person);
console.log(isAlong); // false
console.log(obj.get());  // 2021年
console.log(dt.get());  // 2021年

image.png

改变对象原型的原理：对象原型的真实值被储存在内部的一个特定的属性[[Prototype]]中，调用Object.getPrototypeOf()方法返回储存在其中的值，调用Object.setPrototypeOf()方法改变其中的值。

ES6中引入了Super引用的特性，使其更加快捷的访问对象原型。

let person = {
    name: 'zhangsan',
    get() {
        return this.name;
    }
}

let common = {
    get(){
        return Object.getPrototypeOf(this).get.call(this) + 'common method'; // 修改对象原型
    }
}
let obj = Object.create(person);

Object.setPrototypeOf(common,obj);

console.log(common);
console.log(common.get()); // zhangsancommon method
const isAlong = Object.is(Object.getPrototypeOf(obj),person);
console.log(isAlong);  // true

在ES6中，还有一关键字super，super引用相当于指向对象原型的指针，实际上也就是等价于Object.setPrototypeOf(this)的值，可以简化上述的get()方法

let common = {
    get(){
        return super.get() + 'common method'; // 修改对象原型
    }
}

注意点：super引用调用对象原型上所有其他的方法，必须要在使用简写方法的对象中使用super引用，但是如果在其他方法中声明去使用就会报错。
比如使用匿名函数定义一个属性，由于上下文super引用不合法，则出现报错

let common = {
    get:function(){
        return super.get() + 'common method';
    }
}

image.png

super引用在对于多重继承的场景非常实用，不会像Object.getPrototypeOf(this).get.call(this)一样引发冲突。

let person = {
    name: 'zhangsan',
    get() {
        return this.name;
    }
}

let common = {
    get(){
        return Object.getPrototypeOf(this).get.call(this) + ' common method';
    }
}

Object.setPrototypeOf(common,person);

let obj = Object.create(common);

console.log(Object.getPrototypeOf(obj));

console.log(obj.get());

image.png

let person = {
    name: 'zhangsan',
    get() {
        return this.name;
    }
}

let common = {
    get(){
        return super.get() + ' common method';
    }
}

Object.setPrototypeOf(common,person);

let obj = Object.create(common);

console.log(Object.getPrototypeOf(obj));

console.log(obj.get());

super引用总是能指向正确的对象，因为多重继承，对于super引用而言，始终指向的都是父级的对象，也就是person对象。