目录
1、原型对象
constructor 属性
对象原型
2、原型链
3、instanceof
4、原型继承
1、原型对象
面向过程就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候再一个一个的依次调用就可以了。
面向对象是把事务分解成为一个个对象，然后由对象之间分工与合作。
面向过程开发(关注具体实现步骤)
面向对象开发(分析涉及的对象，指挥对象完成）----- 封装、继承、多态
原型为了共享公共的成员 prototype
原型:JS为每个构造函数提供一个属性prototype(原型)，它的值是一个对象,prototype也叫原型对象
构造函数通过原型分配的函数是所有对象所 共享的。
-
JavaScript 规定，每一个构造函数都有一个 prototype 属性，指向另一个对象，所以我们也称为原型对象
-
这个对象可以挂载函数，对象实例化不会多次创建原型上函数，节约内存
-
我们可以把那些不变的方法，直接定义在 prototype 对象上，这样所有对象的实例就可以共享这些方法。
-
构造函数和原型对象中的this 都指向 实例化的对象
<script>// 面向过程开发(关注具体实现步骤)// 面向对象开发(分析涉及的对象，指挥对象完成任务) - 封装、继承、多态function Cat(name, age) {this.name = namethis.age = age// 给实例添加eat方法，将来每一个对象都有这个eat方法，造成空间浪费// this.eat = function () {// console.log('猫吃老鼠')// }}// 给Cat原型添加公共的属性或方法,这样所有new出来的实例都可以访问Cat.prototype.eat = function () {console.log('猫吃老鼠')}Cat.prototype.nation = 'china'const cat1 = new Cat('加菲猫', 3) // {name: '',age: ,eat}const cat2 = new Cat('银渐层', 4) // {name: '',age: ,eat() {}}console.log(cat1.age)console.log(cat1.nation)cat1.eat()cat2.eat()console.log(cat1.eat === cat2.eat) // true// 原型为了共享公共的成员 prototype// 原型: JS为每个构造函数提供一个属性prototype(原型),它的值是一个对象，prototype也叫原型对象console.log(Cat.prototype)console.log(Cat.prototype.constructor === Cat) // true// function f() {}// console.log(f.prototype)</script>constructor 属性
constructor 属性，原型对象的属性---->原型对象的构造函数
<script>// constructor属性，原型对象的默认属性->原型对象的构造函数// Array.prototype.constructor === Arrayconsole.log(Array.prototype.constructor === Array) // trueconst arr = [] // new Object()console.log(arr.constructor === Array) // trueconsole.log(arr.constructor === Array.prototype.constructor) // trueconsole.log(arr.constructor) // 访问arr数组对象的constructor,会到原型去访问console.log(Object.prototype.constructor) // Object ;const obj = {}console.log(obj.constructor) // Objectconst obj2 = { a: 1 }console.log(obj.constructor === obj2.constructor) // true</script>访问成员的查找原则
访问对象成员的原则:先查找自己身上有没有，有的话就使用，没有去原型查找
<script>function Cat(name, age) {// this.name = namethis.age = age}Cat.prototype.eat = function () {console.log('猫抓老鼠')}Cat.prototype.name = '亚洲猫王'const cat = new Cat('小花', 3) // {name: '小花', age: 3}// 访问对象成员的原则: 先查找自己身上有没有，有的话就使用，没有去原型查找console.log(cat.name)</script>对象原型
对象都会有一个属性__proto__ 指向构造函数的 prototype 原型对象，之所以我们对象可以使用构造函数 prototype
__proto__ 对象原型里面也有一个 constructor属性，指向创建该实例对象的构造函数
三者关系
构造函数 原型 原型对象
每个对象都有一个_proto_属性（非标准属性->ES6标准属性），指向原型对象，它与[[Prototype]]等价
2、原型链
对象访问成员的机制
1、首先查找自身有没有，有就就近原则使用
2、自身没有该成员，通过_proto_找到原型对象，看原型对象上有没有，有就执行
3、假如原型对象上也没有，再找原型对象的_proto__，一直找到0bject.prototype
4、一直找到Object. prototype,找不到就undefined
3、instanceof
typeof 检测数据类型 不能精准的检测引用类型
instanceof 实例对象 instanceof 构造函数
判断构造函数的原型对象是不是在实例对象的原型链上
<script>// // typeof 检测数据类型// string number booleanconsole.log(typeof []) //'object'console.log(typeof {}) // 'object'console.log(Array.prototype) // 数组原型也提供toString()，自己原型的方法是拼接字符串// console.log([1, 2, 3].toString()) // [object Array]console.log({}.toString()) // [object Object]console.log(Object.prototype.toString.call([])) // call调用函数// instanceof 实例对象 instanceof 构造函数// 判断构造函数的原型对象是不是在实例对象的原型链上console.log([] instanceof Array) // trueconsole.log([] instanceof Object) // trueconsole.log({} instanceof Array) // false</script>
4、原型继承
继承方式：构造函数继承、原型继承、组合继承、。。。。
原型继承-----> 儿子的原型指向父实例对象，这样父实例对象的成员就可以实现继承
缺点：继承的引用类型属性就一份
<script>// 继承const person = {ears: 2,eat: function () {console.log('eating')},hobby: ['reading', 'running'],}function Student(name, age) {this.name = namethis.age = age}// 让Student的原型指向personStudent.prototype = personStudent.prototype.constructor = StudentStudent.prototype.study = function () {console.log('study hard!!!')} /*{ears, eat, hobby,constructor, study}*/const s1 = new Student('zs', 16)const s2 = new Student('zw', 24)console.log(s1.ears)s1.study()s1.eat()s2.hobby.push('coding')console.log(s2.hobby)console.log(s1.hobby)console.log(person)</script>
