JS中的构造函数、原型、原型链
在典型的OOP的语言中(如Java)，都存在类的概念，类就是对象的模板，对象就是类的实例，但在ES6之前，JS并没有类的概念
1,创建对象可以通过三种方式：
1，对象字面量
let obj = {}
2,new Object()
let obj = new Object()
3,自定义构造函数
function person (name, age) {
this.name = name
this.age = age
this.sayName = function () {
console.log(this.name)
}
}
let p1 = new person('Jerry', 18)
2,构造函数
构造函数是一种特殊的函数，主要用来初始化对象，即为对象成员变量赋初始值，它总与new一起使用。我们可以把对象中一些公共的属性和方法抽取出来，然后封装到这个函数里面。
使用构造函数时注意：
1，构造函数用于创建某一类对象，其首字母大写
2，构造函数要和new一起使用
new在执行时会做以下4件事：
1，在内存中创建一个新的空对象
2，让this指向这个新的对象
3，执行构造函数里面的代码，给这个新对象添加属性和方法
4，返回这个新对象（所以构造函数里不需要return）
构造函数中可以添加一些成员，可以在构造函数本身上添加，也可以在构造函数内部的this上添加，通过两种方式添加的成员，就分别成为静态成员和实例成员
- 静态成员：在构造函数本身上添加的成员，只能由构造函数本身来访问
- 实例成员：在构造函数内部创建的对象成员，只能由实例化的对象来访问
function Person(name, age) {
this.name = name
this.age = age
this.sayName = function () {
console.log(this.name)
}
}
// 实例成员就是构造函数内部通过this添加的成员：name、age、sayName就是实例成员，实例成员只能通过实例化的对象来访问
let p1 = new Person('Jerry', 18)
Person.gender = 'male' // 静态成员，在否早函数本身上添加的成员gender就是静态成员
console.log(Person.gender) //male => 静态成员只能通过构造函数来访问率
console.log(p1.gender) // undefined => 不能通过对象来访问
3，构造函数的问题
构造函数方法很好用，但是存在浪费内存的问题
function Person(name, age) {
this.name = name
this.age = age
this.sayName = function () {
console.log(this.name)
}
}
let p1 = new Person('Jerry', 18)
let p2 = new Person('Jack', 19)
console.log(p1.sayName === p2.sayName) // false
当创建实例对象时，对于简单的数据类型，直接赋值就可以，对于复杂数据类型，当创建p1这个实例对象时，会单独开辟一块空间来存放复杂数据类型sayName这个方法，创建p2对象时，也会开辟一块空间存放sayName方法。开辟了两个空间来存放同一个函数
我们希望所有的对象使用同一个函数，这样比较节省内存，该怎么做呢？
4，构造函数原型prototype
构造函数通过原型分配的函数是所有对象共享的
js规定，每一个构造函数都有一个prototype属性，指向另一个对象。prototype就是一个对象，这个对象的所有属性和方法都会被构造函数所拥有。
function Person(name, age) {
this.name = name
this.age = age
}
Person.prototype.sayName = function () {
console.log(this.name)
}
let p1 = new Person('Jerry', 18)
let p2 = new Person('Jack', 19)
console.log(p1.sayName()) // Jerry
console.log(p2.sayName()) // Jack
console.log(p1.sayName === p2.sayName) // true
p1.__proto__ === Person.prototype // true
一般情况下，公共的属性定义到构造函数里，公共的方法放在原型对象身上。
原型是什么： 一个对象，我们也成为prototype为原型对象
原型的作用是什么：共享方法
5，对象原型proto
对象都会有一个属性proto指向构造函数的prototype原型对象，对象可以使用构造函数prototype原型对象的属性和方法，就是因为对象有proto原型的存在
- proto对象原型和原型对象prototype是等价的
- proto对象原型的意义就在于为对象的查找机制提供一个方向，或者说一条路线，但是他是一个非标准属性，因此实际开发中，不可以使用这个属性，它只是内部指向原型对象prototype
6,constructor构造函数
对象原型(proto)和构造函数(prototype)原型对象里面都有一个属性constructor属性，constructor我们成为构造函数，因为它指构造函数本身
contructor主要用于记录该对象引用于哪个构造函数，它可以让原型对象重新指向原来的构造函数
function Person(name, age) {
this.name = name
this.age = age
}
Person.prototype = {
// 如果修改了原来的原型对象，给原型对象赋值的是一个对象，则必须手动利用constructor指回原来的构造函数
constructor: Person,
sayName: function () {
}
}
let p1 = new Person('Jerry', 18)
let p2 = new Person('Jack', 20)
console.log(Person.prototype.constructor)
console.log(p1.__proto__.constructor)
一般情况下，对象的方法都在构造函数的原型对象中设置，如果多个对象的方法，我们可以给原型对象采取对象形式赋值，但是这样就会覆盖构造函数原型对象原来的内容，这样修改后的原型对象constructor就不再指向当前构造函数了。此时，我们可以在修改后的原型对象中，添加一个constructor指向原来的构造函数
7，构造函数、实例、原型对象三者之间的关系
8，原型链
1，只要是对象就有proto原型，指向原型对象
2，Person原型对象里面的proto原型指向的是Object.prototype
3,Object.prototype原型里的proto原型指向为null, 只要是对象，它里面都有一个原型proto，它指向的是原型对象prototype,原型对象里也有一个proto，它指向的是Object原型对象prototype， Object原型对象里也有一个proto,它指向的是null
简单来说就是，每个对象都有一个原型， 每一个原型又是一个对象，所以原型又有自己的原型，这样一环扣一环形成一条链，就叫原型链
9，Js的成员查找机制（规则）
1，当访问一个对象的属性(包括方法)时，首先查找这个对象自身有没有该属性
2，如果没有就查找它的原型(也就是proto指向的prototype原型对象)
3，如果还没有就查找原型对象的原型(Object的原型对象)
4，依次类推一直找到Object为止(null)
5，proto对象原型的意义就在于为对象成员查找机制提供一个方向，或者说一条路线
10，原型对象this指向
构造函数中的this指向实例对象
原型对象里面放的是方法，这个方法里面的this指向的是这个方法的调用者，也就是这个实例对象，调用方式的不同决定了this的指向不同，一般指向我们的调用者
改变函数内部this主席昂，常用的方法：bind()、call()、apply()
1，call()方法：调用一个对象，即调用函数的方式，改变函数的this指向。主要作用实现继承
foo.call(thisArg, arg1,arg2,....)
2,apply()方法：调用一个函数，即调用函数的方式，改变函数的this指向
foo.apply(thisArg, [argArray])
thisArg：在foo函数运行时指定的this值
argArray: 传递的值，必须包含在数组里
返回值就是函数的返回值，因为他就是调用函数
// 利用apply借助于数学内置对象求最大最小值
var arr = [1,20,30,60]
var max = Math.max.apply(Math, arr)
max // 60
3,bind()方法不会调用函数，但是能改变函数内部this指向
foo.bind(thisArg, arg1, arg2,.....)
thisArg: 在foo函数运行时指定的this值
arg1, arg2：传递的其他参数
返回由指定的this值和初始化参数改造的原函数拷贝，即原函数改变this之后产生的新函数
var btn = document.querySelector('button');
btn.onclick = function() {
this.diabled = true; //这个 this 指向 btn 按钮
// var that = this;
setTimeout(function() { //定时器里面的 this 指向的是 window
// that.disabled = false;
this.disabled = false;
}.bind(this), 3000); //这个 this 指向 btn 这个对象
}
总结：
- call()经常做继承
- apply()经常跟数组有关系
- bind()不立即调用函数，如果有的函数我们不需要立即调用，但是又想改变这个函数内部this指向，此时用bind()
11, 内置对象
可以通过原型对象，对原来的内置对象进行扩展自定义的方法，比如给数组增加自定义求偶数和的功能
Array.prototype.sum = function () {
let sum = 0
for (let i = 0; i < this.length; i++) {
sum += this[i]
}
return sum
}
let arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
console.log(arr.sum())
console.log(Array.prototype)
注意: 数组和字符串内置对象不能给原型对象覆盖操作Array.prototype = {}, 只能是Array.prototype.xxx = function (){}的方式。
