@1 首先我们先了解下原型链的基础知识。
function Fn(x,y) {this.x=x; this.y =y; this.say=()=>{console.log(this.x)}}
let res = Fn(10,20) // 普通函数执行 因为函数体内部没有返回值所以普通函数执行得不到返回
的结果。
let f1 = new Fn(10,20) // 这是构造函数执行
let f2 = new Fn(10,20) // 这是创造另外一个类的实例对象
console.log(f1.sum) // 因为不存在所以结果是undefiend
console.log(f1.say) // 得到的结果是10
console.log(f1.say===f2.say) // false 创建的两个实例对象是不相同的
@2 普通函数与构造函数的区别；
构造函数执行也像普通函数执行一样产生私有的上下文（作用域 初始this 代码执行）
构造函数在执行的时候会创建出一个空实例对象， 让上下文中的this执行创建的实例对象，观
察函数的返回值，如果返回值的原始值类型或者没有返回值则把创建的实例对象返回，只有
自己手动返回对象类型值，才以自己返回的为主。
@3 构造函数的特点：
1. 构造函数原型对象中有一个constructor（构造器）返回值是当前构造函数本身
Fn.prototype.constructor === Fn;
2. 不具备prototype的函数， 箭头函数
3. 每一个对象数据类型的值都具备一个属性 __proto__, 属性值 指向自己所属原型Prototype
4. 对象数据类型值、普通对象 特殊对象：数组 正则 日期 Math Error，函数对象,以及构造函
数的prototype也属于对象数据类型。
@4 案例展示：
function Fn(){
this.x = 100
this.y = 200
this.getX = function (){ console.log(this.x)}
}
Fn.prototype.getX= function (){console.log(this.x)}
Fn.prototype.getY = function(){console.log(this.Y)}
let f1 = new Fn;
let f2 = new Fn;
console.log(f1.getX===f2.getX) // false 每次new创建的实例对象是互不相关的
console.log(f1.getY===f2.getY)// true 两个实例对象自身都没有getY这个方法找的都是原型的
console.log(f1.__proto__.getY===fn.prototype.getY)// true f1.__proto__等于Fn.prototype
console.log(f1.__proto__.getX===f2.getX) // false F1找的是原型上面的方法f2找的是自身的
console.log(f1.getX===Fn.prototype.getX)// false 自身与原型的方法不相等
console.log(f1.constoructor) //Fn 相当于f1.__proto__.constructor
console.log(Fn.prototype.__proto__.constorctor)// Object 相当于object.prototype.constructor
f1.getX() // 100
f1.__proto__.getX() // undefiend Fn.prototype的this执行Fn.prototype 但这个this上面没有x
f2.getY() // 200
Fn.prototype.getY() // undefiend Fn.prototype的this指向Fn.prototype 但这个this上面没有y
@ 5 原型链之间的关系：
1 每一个构造函数function Fn(){} 通过new都可以得到一个实例对象f1 = new Fn()；
2 每个实例对象的__proto__都指向其构造函数的prototype 也就是f1.__proto__ ===
Fn.prototype;
3 每一个构造函数的prototype本身也是一个对象数据类型，也有__proto__属性，所以指向更
高一级的Object.prototype;
4 Object.prototype也是属于对象数据类型也有__proto__属性，但是object.prototype的
__peoto__指向了null。
@ 6 封装new实例对象的函数：
function _new(ctor,...params) {
let obj1 = {} // 创建一个空的对象
obj1.__proto__ = ctor.prototype // 让对象的__proto__属性指向于构造函数的prototype
const result = ctor.call(obj1,...params) // 改变this指向
if(result !== null && /^(object | function)$/.test(typeof result)) return result; // 如果这个
函数返回的是原始值类型 则把实例返回
return obj;
}
let sammao = _new(Dog,'三毛')；
严格判断：
function _new(ctor,...params) {
let obj1 = {} // 创建一个空的对象
if(!ctor.prototype || ctor===Symbol || ctor===BigInt) throw new Error(...) // 抛出错误
obj = Object.create(ctor.prototype) // 把ctor的原型挂载在obj原型上面
obj1.__proto__ = ctor.prototype // 让对象的__proto__属性指向于构造函数的prototype
const result = ctor.call(obj1,...params) // 改变this指向
if(result !== null && /^(object | function)$/.test(typeof result)) return result; // 如果这个
函数返回的是原始值类型 则把实例返回
return obj;
}
