JS学习篇（四）—— 原型和原型链

工厂模式

定义：抽象了创建具体对象的过程
优点：解决了创建多个相似对象的问题
缺点：没有解决对象识别的问题（也就是怎么知道一个对象的类型）

 function createPerson (name,age,job) {
       var o = new Object();
       o.name = name;
       o.age = age;
       o.job = job;
       o.sayName = function () {
           console.log(this.name);
       }
       return o;
  }
  var person1 = createPerson('hahah',18,'teacher');

构造函数模式

构造函数可以用来创建特定类型的对象，像Object和Array这样的原生构造函数，在运行的时候会自动出现在执行环境中；此外还可以自己创建自定义的构造函数，从而定义自定义对象类型的属性和方法
优点：和工厂模式相比，可以将自定义构造函数的实例标记为独特的类型

function Person (name,age,job) {
      this.name = name;
      this.age = age;
      this.job = job;
      this.sayName = function () {
          console.log(this.name);
      }
}
   var person1 = new Person('hahah',18,'teacher');
   console.log(person1)

我们可以看到构造函数模式和工厂模式不同的是：
没有显式地创建对象;
直接将属性和方法赋给了this对象
没有return语句

并且自定义构造函数名称是大写，普通函数名称是小写

上面代码中要创建新的Person 构造函数的新实例，需要通过new操作符，主要会经历以下四个过程：(任意函数只要通过new操作符来调用，那它就可以作为构造函数)

1：创建一个新的对象
2：将构造函数的作用域赋给这个新对象，也就是将this指向这个对象
3：执行构造函数的代码（为这个对象添加属性）
4：返回这个新的对象

所以知道上面几个过程之后，可以尝试自己实现new操作符

function create() {
    let obj = new Object()  // 创建一个空的对象
    let Con = [].shift.call(arguments)// 获得构造函数
    obj.__proto__ = Con.prototype // 链接到原型
    // 绑定 this；执行构造函数
    let result = Con.apply(obj, arguments)    
    // 确保 new 出来的是个对象
    return typeof result === 'object' ? result : obj
}

constructor属性
而对于构造函数创建的实例对象，都有一个constructor（构造函数）属性，这个属性指向创建这个实例的构造函数，在上个例子中也就是指向Person
有 person1.constructor === Person //true
所以可以使用constructor属性来判断一个变量的类型

原型模式

prototype属性：
每个函数都有一个prototype（原型）属性，这个属性是一个指针，指向调用构造函数创建的实例对象的原型对象
优点：可以让所有的对象实例共享原型对象所包含的属性和方法

function Person () {
}
Person.prototype.name = 'aaaa';
Person.prototype.age = 18;
Person.prototype.job = 'job';
Person.prototype.sayName = function () {
      console.log(this.name);
}
var person1 = new Person();
person1.sayName()   //aaaa

通过原型我们不需要在构造函数中定义对象的实例信息，而是直接可以将这些信息添加到原型对象中

原型和原型链

每个函数都有一个prototype属性。指向这个原型；
然后原型对象有个constructor属性指向构造函数，所以上面的例子中的
Person.prototype.constructor = Person,
每个对象都有一个_proto_属性：指向创建这个对象的构造函数的原型
原型链：JavaScript对象通过__proto__ 指向父类对象，直到指向Object对象为止，这样就形成了一个原型指向的链条, 即原型链。

• Object 是所有对象的爸爸，所有对象都可以通过 __proto__ 找到它
• Function 是所有函数的爸爸，所有函数都可以通过 __proto__ 找到它
• Function.prototype 和 Object.prototype 是两个特殊的对象，他们由引擎来创建 除了以上两个特殊对象， 其他对象都是通过构造器 new 出来的
• 函数的 prototype 是一个对象，也就是原型
• 对象的 __proto__指向原型，
• __proto__ 将对象和原型连接起来组成了原型链

方法：

isPrototypeOf():用于测试一个对象是否存在于另一个对象的原型链上
Object.create：使用现有对象作为新创建的对象的原型来创建新对象

function Foo() {}
function Bar() {}
function Baz() {}

Bar.prototype = Object.create(Foo.prototype);
Baz.prototype = Object.create(Bar.prototype);

var baz = new Baz();

console.log(Baz.prototype.isPrototypeOf(baz)); // true
console.log(Bar.prototype.isPrototypeOf(baz)); // true
console.log(Foo.prototype.isPrototypeOf(baz)); // true
console.log(Object.prototype.isPrototypeOf(baz)); // true

getPrototypeOf(obj) ：返回指定对象的原型,参数的需要返回原型的对象
hasOwnProperty() 方法会返回一个布尔值，指示对象自身属性中是否具有指定的属性，参数是检测的属性的 String 字符串形式表示的名称；要注意的是：即使属性的值是 null 或 undefined，只要属性存在，hasOwnProperty 依旧会返回 true

o = new Object();
o.propOne = null;
o.hasOwnProperty('propOne'); // 返回 true
o.propTwo = undefined;
o.hasOwnProperty('propTwo'); // 返回 true

in操作符：来判断一个属性是否存在于这个对象中。但是在查找这个属性时候，先在对象本身中找，如果对象找不到再去原型中找。换句话说，只要对象和原型中有一个地方存在这个属性，就返回true
for...in...:一般用来遍历对象而不用来遍历数组，会遍历可枚举（Enumerable,默认为true）的属性，包括原型上面的

function Person () {
}
Person.prototype.name = "Jack";
var p1 = new Person();
p1.sex = "man";
alert("sex" in p1);     // 对象本身添加的，所以true
alert("name" in p1);    //原型中存在，所以true
alert("age" in p1);     //对象和原型中都不存在，所以false

继承

先创建一个父类

  function Animal(name) {
       this.name = name || 'pig';
       this.sleep = function () {
           console.log(this.name+'正在睡觉');
       }
   }
   //添加一个原型方法
   Animal.prototype.eat = function (food) {
       console.log(this.name+'正在吃'+ food );
  }

原型链继承——将父类的实例作为子类的原型

   function Cat() {

   }
   Cat.prototype = new Animal();
   Cat.prototype.name = 'cat';
   var cat = new Cat();
   console.log(cat.name);
   cat.eat('fish');
   cat.sleep();
   console.log(cat instanceof Animal)
   console.log(cat instanceof Cat)

特点：非常纯粹的继承关系，实例是子类的实例，也是父类的实例 父类新增原型方法/原型属性，子类都能访问到简单，易于实现
缺点：

• 要想为子类新增属性和方法，必须要在new Animal()这样的语句之后执行，不能放到构造器中
• 无法实现多继承
• 来自原型对象的所有属性被所有实例共享
• 创建子类实例时，无法向父类构造函数传参

借用构造函数继承—使用父类的构造函数来增强子类实例，等于是复制父类的实例属性给子类

function Cat(name){
  Animal.call(this);
  this.name = name || 'Tom';
}

var cat = new Cat();
console.log(cat.name);
console.log(cat.sleep());
console.log(cat instanceof Animal); // false
console.log(cat instanceof Cat); // true

特点：

• 解决了1中，子类实例共享父类引用属性的问题
• 创建子类实例时，可以向父类传递参数
• 可以实现多继承（call多个父类对象）

缺点

• 实例并不是父类的实例，只是子类的实例
• 只能继承父类的实例属性和方法，不能继承原型属性/方法
• 无法实现函数复用，每个子类都有父类实例函数的副本，影响性能

实例继承—为父类实例添加新特性，作为子类实例返回

function Cat(name){
  var instance = new Animal();
  instance.name = name || 'Tom';
  return instance;
}

var cat = new Cat();
console.log(cat.name);
console.log(cat.sleep());
console.log(cat instanceof Animal); // true
console.log(cat instanceof Cat); // false

特点：

不限制调用方式，不管是new 子类()还是子类(),返回的对象具有相同的效果
缺点：

• 实例是父类的实例，不是子类的实例
• 不支持多继承

拷贝继承

function Cat(name){
  var animal = new Animal();
  for(var p in animal){
    Cat.prototype[p] = animal[p];
  }
  this.name = name || 'Tom';
}


var cat = new Cat();
console.log(cat.name);
console.log(cat.sleep());
console.log(cat instanceof Animal); // false
console.log(cat instanceof Cat); // true

特点：

支持多继承
缺点：

• 效率较低，内存占用高（因为要拷贝父类的属性）
• 无法获取父类不可枚举的方法（不可枚举方法，不能使用for in 访问到）

组合继承-通过调用父类构造，继承父类的属性并保留传参的优点，然后通过将父类实例作为子类原型，实现函数复用

function Cat(name){
  Animal.call(this);
  this.name = name || 'Tom';
}
Cat.prototype = new Animal();
Cat.prototype.constructor = Cat;

// 
var cat = new Cat();
console.log(cat.name);
console.log(cat.sleep());
console.log(cat instanceof Animal); // true
console.log(cat instanceof Cat); // true

特点：

• 弥补了方式2的缺陷，可以继承实例属性/方法，也可以继承原型属性/方法
• 既是子类的实例，也是父类的实例
• 不存在引用属性共享问题 可传参
• 函数可复用

缺点：

调用了两次父类构造函数，生成了两份实例

寄生组合继承-通过寄生方式，砍掉父类的实例属性，这样，在调用两次父类的构造的时候，就不会初始化两次实例方法/属性，避免的组合继承的缺点

function Cat(name){
  Animal.call(this);
  this.name = name || 'Tom';
}
(function(){
  // 创建一个没有实例方法的类
  var Super = function(){};
  Super.prototype = Animal.prototype;
  //将实例作为子类的原型
  Cat.prototype = new Super();
})();

// Test Code
var cat = new Cat();
console.log(cat.name);
console.log(cat.sleep());
console.log(cat instanceof Animal); // true
console.log(cat instanceof Cat); //true

Cat.prototype.constructor = Cat; // 需要修复下构造函数

ES6继承方法-class类继承

//定义了父类
class Father {
   constructor(x, y) {
   this.x = x;
   this.y = y;
   }
   sum() {
   console.log(this.x + this.y);
	}
 }
//子元素继承父类
class Son extends Father {
   	constructor(x, y) {
          //使用super调用了父类中的构造函数
    		super(x, y);
    }
 }
    var son = new Son(10, 20);
    son.sum(); //结果为30

详见很不错的博客