最初，在通过构造函数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
由于this是obj，obj的原型是common对象，obj执行common里面的get()方法时，
Object.getPrototypeOf(this)这个返回的是common对象，这样就导致了栈溢出报错。使用super更改代码：
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对象。
