函数与原型链

一、什么是原型

原型是Javascript中的继承的基础，JavaScript的继承就是基于原型的继承。

1.1 函数的原型对象

​ 在JavaScript中，我们创建一个函数A( 就是声明一个函数 ), 那么浏览器就会在内存中创建一个对象B，而且每个函数都默认会有一个属性
prototype 指向了这个对象( 即： prototype的属性的值是这个对象
)。这个对象B就是函数A的原型对象，简称函数的原型。这个原型对象B 默认会有一个属性 constructor 指向了这个函数A (
意思就是说：constructor属性的值是函数A )。

​ 看下面的代码：

/*
	声明一个函数，则这个函数默认会有一个属性叫 prototype 。而且浏览器会自动按照一定的规则
	创建一个对象，这个对象就是这个函数的原型对象，prototype属性指向这个原型对象。这个原型对象
	有一个属性叫constructor 执行了这个函数

	注意：原型对象默认只有属性：constructor。其他都是从Object继承而来，暂且不用考虑。
*/
function Person () {

}

下面的图描述了声明一个函数之后发生的事情：

1.2 使用构造函数创建对象

​ 当把一个函数作为构造函数 (理论上任何函数都可以作为构造函数)
使用new创建对象的时候，那么这个对象就会存在一个默认的不可见的属性，来指向了构造函数的原型对象。 这个不可见的属性我们一般用
[[prototype]] 来表示，只是这个属性没有办法直接访问到。

​ 看下面的代码：

/*
	利用构造函数创建一个对象，则这个对象会自动添加一个不可见的属性 [[prototype]], 而且这个属性
	指向了构造函数的原型对象。
*/
  var p1 = new Person();

观察下面的示意图：

说明：

1. 从上面的图示中可以看到，创建p1对象虽然使用的是Person构造函数，但是对象创建出来之后，这个p1对象其实已经与Person构造函数没有任何关系了，p1对象的[[ prototype ]]属性指向的是Person构造函数的原型对象。
2. 如果使用new Person()创建多个对象，则多个对象都会同时指向Person构造函数的原型对象。
3. 我们可以手动给这个原型对象添加属性和方法，那么p1,p2,p3…这些对象就会共享这些在原型中添加的属性和方法。
4. 如果我们访问p1中的一个属性name，如果在p1对象中找到，则直接返回。如果p1对象中没有找到，则直接去p1对象的[[prototype]]属性指向的原型对象中查找，如果查找到则返回。(如果原型中也没有找到，则继续向上找原型的原型—原型链。 后面再讲)。
5. 如果通过p1对象添加了一个属性name，则p1对象来说就屏蔽了原型中的属性name。 换句话说：在p1中就没有办法访问到原型的属性name了。
6. 通过p1对象只能读取原型中的属性name的值，而不能修改原型中的属性name的值。 p1.name = “李四”; 并不是修改了原型中的值，而是在p1对象中给添加了一个属性name。

看下面的代码：

function Person () {

}
// 可以使用Person.prototype 直接访问到原型对象
//给Person函数的原型对象中添加一个属性 name并且值是 "张三"
Person.prototype.name = "张三";
Person.prototype.age = 20;

var p1 = new Person();
/*
   访问p1对象的属性name，虽然在p1对象中我们并没有明确的添加属性name，但是
   p1的 [[prototype]] 属性指向的原型中有name属性，所以这个地方可以访问到属性name
   就值。
   注意：这个时候不能通过p1对象删除name属性，因为只能删除在p1中删除的对象。
*/
console.log(p1.name);  // 张三

var p2 = new Person();
console.log(p2.name);  // 张三  都是从原型中找到的，所以一样。

console.log(p1.name === p2.name);  // true

// 由于不能修改原型中的值，则这种方法就直接在p1中添加了一个新的属性name，然后在p1中无法再访问到
//原型中的属性。
p1.name = "李四";
console.log("p1：" + p1.name);
// 由于p2中没有name属性，则对p2来说仍然是访问的原型中的属性。	
console.log("p2:" + p2.name);  // 张三  

二、与原型有关的几个属性和方法

2.1 prototype属性

​ prototype 存在于构造函数中 (其实任意函数中都有，只是不是构造函数的时候prototype我们不关注而已) ，他指向了这个构造函数的原型对象。

​ 参考前面的示意图。

2.2 constructor属性

​ constructor属性存在于原型对象中，他指向了构造函数

看下面的代码：

function Person () {
}
console.log(Person.prototype.constructor === Person);	// true
var p1 = new Person();
  //使用instanceof 操作符可以判断一个对象的类型。  
  //typeof一般用来获取简单类型和函数。
  //而引用类型一般使用instanceof，因为引用类型用typeof 总是返回object。
console.log(p1 instanceof Person);	// true

我们根据需要，可以Person.prototype 属性指定新的对象，来作为Person的原型对象。

但是这个时候有个问题，新的对象的constructor属性则不再指向Person构造函数了。

看下面的代码：

function Person () {

}
//直接给Person的原型指定对象字面量。则这个对象的constructor属性不再指向Person函数
Person.prototype = {
	name:"志玲",
	age:20
};
var p1 = new Person();
console.log(p1.name);  // 志玲

console.log(p1 instanceof Person); // true
console.log(Person.prototype.constructor === Person); //false
//如果constructor对你很重要，你应该在Person.prototype中添加一行这样的代码：
/*
Person.prototype = {
  constructor : Person	//让constructor重新指向Person函数
}
*/

2.3 proto 属性(注意：左右各是2个下划线)

​ 用构造方法创建一个新的对象之后，这个对象中默认会有一个不可访问的属性 [[prototype]] , 这个属性就指向了构造方法的原型对象。

​
但是在个别浏览器中，也提供了对这个属性[[prototype]]的访问(chrome浏览器和火狐浏览器。ie浏览器不支持)。访问方式：p1.proto

​ 但是开发者尽量不要用这种方式去访问，因为操作不慎会改变这个对象的继承原型链。

function Person () {

}
//直接给Person的原型指定对象字面量。则这个对象的constructor属性不再指向Person函数
Person.prototype = {
	constructor : Person,
	name:"志玲",
	age:20
};
var p1 = new Person();

console.log(p1.__proto__ === Person.prototype);	//true

2.4 hasOwnProperty() 方法

​ 大家知道，我们用去访问一个对象的属性的时候，这个属性既有可能来自对象本身，也有可能来自这个对象的[[prototype]]属性指向的原型。

​ 那么如何判断这个对象的来源呢？

​ hasOwnProperty方法，可以判断一个属性是否来自对象本身。

function Person () {

}
Person.prototype.name = "志玲";
var p1 = new Person();
p1.sex = "女";
  //sex属性是直接在p1属性中添加，所以是true
console.log("sex属性是对象本身的：" + p1.hasOwnProperty("sex"));
  // name属性是在原型中添加的，所以是false
console.log("name属性是对象本身的：" + p1.hasOwnProperty("name"));
  //  age 属性不存在，所以也是false
console.log("age属性是存在于对象本身：" + p1.hasOwnProperty("age"));

所以，通过hasOwnProperty这个方法可以判断一个对象是否在对象本身添加的，但是不能判断是否存在于原型中，而且也有可能这个属性不存在。

也即是说，在原型中的属性和不存在的属性都会返回fasle。

如何判断一个属性是否存在于原型中呢？

2.5 in 操作符

​
in操作符用来判断一个属性是否存在于这个对象中。但是在查找这个属性时候，现在对象本身中找，如果对象找不到再去原型中找。换句话说，只要对象和原型中有一个地方存在这个属性，就返回true

function Person () {

}
Person.prototype.name = "志玲";
var p1 = new Person();
p1.sex = "女";
console.log("sex" in p1);		//对象本身添加的，所以true
console.log("name" in p1);	//原型中存在，所以true
console.log("age" in p1); 	//对象和原型中都不存在，所以false

回到前面的问题，如果判断一个属性是否存在于原型中：

如果一个属性存在，但是没有在对象本身中，则一定存在于原型中。

function Person () {
}
Person.prototype.name = "志玲";
var p1 = new Person();
p1.sex = "女";

//定义一个函数去判断原型所在的位置
function propertyLocation(obj, prop){
	if(!(prop in obj)){
		console.log(prop + "属性不存在");
	}else if(obj.hasOwnProperty(prop)){
		console.log(prop + "属性存在于对象中");
	}else {
		console.log(prop + "对象存在于原型中");
	}
}
propertyLocation(p1, "age");
propertyLocation(p1, "name");
propertyLocation(p1, "sex");

三、组合原型模型和构造函数模型创建对象

3.1 原型模型创建对象的缺陷

​
原型中的所有的属性都是共享的。也就是说，用同一个构造函数创建的对象去访问原型中的属性的时候，大家都是访问的同一个对象，如果一个对象对原型的属性进行了修改，则会反映到所有的对象上面。

​ 但是在实际使用中，每个对象的属性一般是不同的。张三的姓名是张三，李四的姓名是李四。

​ **但是，这个共享特性对 方法(属性值是函数的属性)又是非常合适的。**所有的对象共享方法是最佳状态。这种特性在c#和Java中是天生存在的。

3.2 构造函数模型创建对象的缺陷

​
在构造函数中添加的属性和方法，每个对象都有自己独有的一份，大家不会共享。这个特性对属性比较合适，但是对方法又不太合适。因为对所有对象来说，他们的方法应该是一份就够了，没有必要每人一份，造成内存的浪费和性能的低下。

function Person() {
    this.name = "李四";
    this.age = 20;
    this.eat = function() {
        console.log("吃完东西");
    }
}
var p1 = new Person();
var p2 = new Person();
//每个对象都会有不同的方法
console.log(p1.eat === p2.eat); //fasle

可以使用下面的方法解决：

function Person() {
    this.name = "李四";
    this.age = 20;
    this.eat = eat;
}
function eat() {
    alert("吃完东西");
}
var p1 = new Person();
var p2 = new Person();
//因为eat属性都是赋值的同一个函数，所以是true
console.log(p1.eat === p2.eat); //true

但是上面的这种解决方法具有致命的缺陷：封装性太差。使用面向对象，目的之一就是封装代码，这个时候为了性能又要把代码抽出对象之外，这是反人类的设计。

3.3 使用组合模式解决上述两种缺陷

​ 原型模式适合封装方法，构造函数模式适合封装属性，综合两种模式的优点就有了组合模式。

//在构造方法内部封装属性
function Person(name, age) {
    this.name = name;
    this.age = age;
}
//在原型对象内封装方法
Person.prototype.eat = function (food) {
    console.log(this.name + "爱吃" + food);
}
Person.prototype.introduce = function () {
    console.log(`大家好！我的名字叫${this.name}，我今年${this.age}。`);
}

var p1 = new Person("李四", 20);
var p2 = new Person("张三", 30);
p1.eat("苹果");
p2.eat("香蕉");
p1.introduce()
p2.introduce()

一、原型链与继承的概念

​
继承是所有的面向对象的语言最重要的特征之一。大部分的oop语言的都支持两种继承：接口继承和实现继承。比如基于类的编程语言Java，对这两种继承都支持。从接口继承抽象方法
(只有方法签名)，从类中继承实例方法。

​ 但是对JavaScript来说，没有类和接口的概念(ES6之前)，所以只支持实现继承，而且继承在 原型链
的基础上实现的。等了解过原型链的概念之后，你会发现继承其实是发生在对象与对象之间。这是与其他编程语言很大的不同。

二、原型链的概念

在JavaScript中，原型链是实现继承的主要方法。其基本思想是利用原型让一个引用类型关联另一个引用类型的属性和方法

​ 再回顾下，构造函数、原型(对象)和对象之间的关系。每个构造函数都有一个属性 prototype 指向一个原型对象，每个原型对象也有一个属性
constructor 指向函数，通过new 构造函数()
创建出来的对象内部有一个不可见的属性[[prototype]]指向构造函数的原型。当每次访问对象的属性和方法的时候，总是先从p1中找，找不到则再去p1指向的原型中找。

下面我们开始一步步的构造原型链，来实现继承

2.1 更换构造函数的原型

​ 原型其实就是一个对象，只是默认情况下原型对象是浏览器会自动帮我们创建的，而且自动让构造函数的 prototype 属性指向这个自动创建的原型对象。

​ 其实我们完全可以把原型对象更换成一个我们自定义类型的对象。

看下面的代码：

function Grandfather() {
    this.id = "孙子~我是你爷爷~"
}

//定义一个构造函数。
function Father () {
    // 添加name属性.  默认直接赋值了。当然也可以通过构造函数传递过来
    this.name = "马云";
}
//给Father的原型添加giveMoney方法
Father.prototype.giveMoney = function () {
    console.log("我是Father原型中定义的方法");
}
//再定义一个构造函数。
function Son () {
    //添加age属性
    this.age = 18;
}
//关键地方：把Son构造方法的原型替换成Father的对象。
Son.prototype = new Father();
//给Son的原型添加getMoney方法
Son.prototype.getMoney = function () {
    console.log("我是Son的原型中定义的方法");
}
//创建Son类型的对象
var son1 = new Son();

//发现不仅可以访问Son中定义属性和Son原型中定义的方法，也可以访问Father中定义的属性和Father原型中的方法。
//这样就通过原型完成了类型之间的继承。
//Son继承了Father中的属性和方法，当然还有Father原型中的属性和方法。
son1.giveMoney();
son1.getMoney();
console.log("Father定义的属性：" + son1.name);
console.log("Son中定义的属性：" + son1.age);

上面的代码其实就完成了Son继承Father的过程。那么到底是怎么完成的继承呢？

看下面的示意图：

说明：

1. 定义Son构造函数后，我们没有再使用Son的默认原型，而是把他的默认原型更换成了Father类型对象。
2. 这时，如果这样访问 son1.name, 则先在son1中查找name属性，没有然后去他的原型( Father对象)中找到了，所以是"马云"。
3. 如果这样访问 son1.giveMoney(), 则现在son1中这个方法，找不到去他的原型中找，仍然找不到，则再去这个原型的原型中去找，然后在Father的原型对象找到了。
4. 从图中可以看出来，在访问属性和方法的时候，查找的顺序是这样的：对象->原型->原型的原型->…->原型链的顶端。 就像一个链条一样，这样 由原型连成的"链条"，就是我们经常所说的原型链。
5. 从上面的分析可以看出，通过原型链的形式就完成了JavaScript的继承。

2.2 默认顶端原型

​ 其实上面原型链还缺少一环。

​ 在 JavaScript 中所有的类型如果没有指明继承某个类型，则默认是继承的 Object 类型。这种 默认继承也是通过原型链的方式完成的。

下面的图就是一个完整的原型链：

说明：

1. 原型链的顶端一定是Object的原型对象。这也是为什么我们随意创建一个对象，就有很多方法可以调用，其实这些方法都是来自Object的原型对象。
2. 通过对象访问属性方法的时候，一定是会通过原型链来查找的，直到原型链的顶端。
3. 一旦有了继承，就会出现多态的情况。假设需要一个Father类型的数据，那么你给一个Father对象，或Son对象都是没有任何问题的。而在实际执行的过程中，一个方法的具体执行结果，就看在原型链中的查找过程了。给一个实际的Father对象则从Fahter的原型链中查找，给一个实际的Son则从Son的原型链中查找。
4. 因为继承的存在，Son的对象，也可以看出Father类型的对象和Object类型的对象。 子类型对象可以看出一个特殊的父类型对象。

2.3 测试数据的类型

​ 到目前为止，我们有3中方法来测试数据的类型。

1. **typeof：**一般用来测试简单数据类型和函数的类型。如果用来测试对象，则会一直返回object，没有太大意义。

console.log(typeof 5); // number
var v = "abc";
console.log(typeof v);  // string
console.log(typeof function () {

});  //funcion
function Person () {

}
console.log(typeof new Person()); //object

2. instanceof: 用来测试一个对象是不是属于某个类型。结果为boolean值。

function Father () {
}
function Son () {
}

Son.prototype = new Father();
var son = new Son();
console.log(son instanceof Son);  // true
  // Son通过原型继承了Father
console.log(son instanceof Father);  // true
  //Father又默认继承了Objcet
console.log(son instanceof Object); // true

3. isPrototypeOf( 对象 ) : 这是个原型的方法，参数传入一个对象，判断参数对象是不是由这个原型派生出来的。 也就是判断这个原型是不是参数对象原型链中的一环。

function Father () {

}
function Son () {

}

Son.prototype = new Father();
var son = new Son();
console.log(Son.prototype.isPrototypeOf(son));  // true
console.log(Father.prototype.isPrototypeOf(son));	// true
console.log(Object.prototype.isPrototypeOf(son));	// true

2.4 原型链在继承中的缺陷

​ 原型链并非完美无缺，也是存在一些问题的。

父类型的属性共享问题

​
在原型链中，父类型的构造函数创建的对象，会成为子类型的原型。那么父类型中定义的实例属性，就会成为子类型的原型属性。对子类型来说，这和我们以前说的在原型中定义方法，构造函数中定义属性是违背的。子类型原型中的属性被所有的子类型的实例所共有，如果有一个实例去更改，则会很快反应的其他的实例上。

看下面的代码：

function GirlFriend() {
    this.girls = ["志玲","圆圆"]
}

function Person() {

}
// 子类的原型对象中就有一个属性 girls ，是个数组
Person.prototype = new GirlFriend()

p1 = new Person()
p2 = new Person()
console.log(p1.girls)
console.log(p2.girls)

//给son1的girls属性的数组添加一个元素
p1.girls.push("亦非")
console.log(p1.girls)

//这时，发现son2中的girls属性的数组内容也发生了改变
console.log(p2.girls)  // "志玲", "圆圆", "亦非"