### 原型链的理解

#### 概念

+ javascript每一个对象**包括原型对象**都有一个内置的`proto`属性指向创建他的函数对象的原型对象，即`prototype`属性

#### 作用

+ 实现对象的继承

### 理解

1.函数对象

+ 在javascript中，函数就是对象

2.原型对象

+ 当定义一个函数对象的时候，会包含一个预定的属性，`prototype`，这就属性称之为原型对象

3.\__proto__

+ javascript 在创建对象的时候，都会有一个\_proto\_的内置属性，用于指向创建它的函数对象的`prototype`。原型对象也有\_proto\_ 属性。因此在不断的指向中，形成了原型链。

4.new

+ 当使用new关键字去调用构造函数就相当于执行啦

5.constructor

+ 原型对象prototype上都有个预定义的constructor属性，用来引用它的函数对象。这是一种循环引用

​

### 继承

+ **构造函数绑定**

> 使用call或apply方法，将父对象的构造函数绑定在子对象上，即在子对象构造函数中加一行：

```javascript

function test(name,height) {

this.name = name

this.height= height

};

function trys(age){

this.age = age

test.apply(this,["张三","180cm"])

//apply(this,argument)第一个参数为改变this指向,第二个参数为一个伪数组每一项对应 调用apply的函数的形参。

//call(this,name,height) 第一个参数为this,后面参数为调用call的函数的形参。

}

let person = new trys;

person.age = "18"

console.log(person)

```

 

+ prototype模式

```javascript

function test(name,height) {

this.name = name

this.height= height

this.do=function(hobby){

console.log("我是"+this.name+"我今年"+this.age+"岁"+"身高"+this.height+"我喜欢"+hobby)

}

};

function trys(age){

this.age = age

}

trys.prototype =new test

trys.prototype.constructor = trys;

// trys.prototype =new test 将trys的constructor 属性指向了test,每一个实例对象也会有一个constructor属性默认指向prototype的constructor 属性,person.constructor==test

所以需要将trys的constructor属性重新指回trys

let person = new trys;

person.name = "张三"

person.age = 18

person.height = 180

person.do("打羽毛球")

console.log(person)

```


+ 直接继承prototype

> 是对第二种方法的改进。由于person对象中，不变的属性都可以直接写入person.prototype。所以，我们也可以让man()跳过 person()，直接继承person.prototype。

```javascript

function person (){

}

person.prototype.skill = "开车"

function man(){

this.hobby = "泡妞"

}

man.prototype = person.prototype;

man.prototype.constructor = man;

let xiaoming = new man ;

console.log(xiaoming.skill);

```

+ 利用空对象作为中介

> 用第三种方法会改变person的constructor 的指向 所以有了这种方法 定义一个空的

> 对象作为中介

```javascript

function person (){

}

person.prototype.skill = "开车"

function man(){

this.hobby = "泡妞"

}

function F (){

}

F.prototype =person.prototype

man.prototype = new F()

man.prototype.constructor = man;

let xiaoming = new man ;

```

> 我们将上面的继承封装

```javascript

　 function extend(Child, Parent) {

　　　　var F = function(){};

　　　　F.prototype = Parent.prototype;

　　　　Child.prototype = new F();

　　　　Child.prototype.constructor = Child;

　　}

```

+ 拷贝继承

>把父对象的所有属性和方法，拷贝进子对象

``` javascript

function extend2(Child, Parent) {

　　　　var p = Parent.prototype;

　　　　var c = Child.prototype;

　　　　for (var i in p) {

　　　　　　c[i] = p[i];

　　　　　　}

　　　　c.uber = p;

　　}

```

+ 非构造函数继承

```javascript

let person = {

skill:"行走"

}

let xiaomming = {

age:"18"

}

function object(o) {

　　　　function F() {}

　　　　F.prototype = o;

　　　　return new F();

　　}

let xiaoming = object(person)

console.log(xiaoming.skill) //行走

```

+ 浅拷贝

***这样的拷贝有一个问题。那就是，如果父对象的属性等于数组或另一个对象，那么实际上，子对象获得的只是一个内存地址，而不是真正拷贝，因此存在父对象被篡改的可能。***

```javascript

let person = {

skill:"行走"

}

let xiaomming = {

age:"18"

}

function extendCopy(p) {

　　　　var c = {};

　　　　for (var i in p) {

　　　　　　c[i] = p[i]; //遍历p对象,将p对象的每一个属性 都赋值给c对象的每一项

　　　　}

　　　　return c;

　　}

let xiaoming = extendCopy(person);

console.log(xiaoming.skill)//行走

```

+ 深拷贝

>"深拷贝"，就是能够实现真正意义上的数组和对象的拷贝。只要递归调用"浅拷贝"就行了。

``` javascript

let person = {

skill:"行走"

}

let xiaomming = {

age:"18"

}

　　function deepCopy(p, c) {

　　　　var c = c || {};

　　　　for (var i in p) {

　　　　　　if (typeof p[i] === 'object') {

　　　　　　　　c[i] = (p[i].constructor === Array) ? [] : {};

　　　　　　　　deepCopy(p[i], c[i]);

　　　　　　} else {

　　　　　　　　　c[i] = p[i];

　　　　　　}

　　　　}

　　　　return c;

　　}

var xiaoming = deepCopy(person)

console.log(xiaoming.skill)

```