//  生物的构造函数function Bio(){this.life = true}Bio.prototype.getLife = function () {return this.life;}//  动物的构造函数function Animal(){this.eat = true;}Animal.prototype = new Bio();// 狗的构造函数function Dog(master){this.master = master;}Dog.prototype = new Animal();var dog1 = new Dog("cl");console.log(dog1.life);  // true
            console.log(dog1.constructor);/*输出：ƒ Bio(){this.life = true}为什么会这样，因为 Dog 和 Animal 的constructor 被重写了的缘故*/

            // 第一种方法：使用instanceof 操作符，只要用这个操作符检测实例与原型链出现过的构造函数，结果就会返回true。console.log(dog1 instanceof Dog);console.log(dog1 instanceof Animal);console.log(dog1 instanceof Bio);console.log(dog1 instanceof Object); // 全部为true// 由于原型链的关系，我们可以说dog1 是上述四个任何一个类型的实例// 第二种方法：使用isPrototypeOf() 方法。同样，只要原型链出现过的原型，都可以说是该原型链所派生的实例的原型
                console.log(Object.prototype.isPrototypeOf(dog1));console.log(Animal.prototype.isPrototypeOf(dog1));console.log(Bio.prototype.isPrototypeOf(dog1));console.log(Dog.prototype.isPrototypeOf(dog1)); // 全部为true

            function Super () {this.color = ["red","blue","green"];}function Sub () {}Sub.prototype = new Super();var ins1 = new Sub();ins1.color.push("black");console.log(ins1.color);   // ["red", "blue", "green", "black"]var ins2 = new Sub();console.log(ins2.color);  // ["red", "blue", "green", "black"]// 那么问题来了，由于Sub的所有实例都会共享这一个color属性，那么我们对ins1.color的修改能够通过ins2.color反映出来// 问题：在创建子类型的实例时，不能向超类型的构造函数传递参数。实际上，应该说是没有办法在不影响所有对象实例的情况下，给超类型的// 构造函数传递参数。有鉴于此，实践中很少会单独使用原型链

    function Animal(name){this.name = name;}function Dog(){// 通过使用call()方法（或apply()方法也可以），我们实际上在新创建的Dog实例的环境调用了Animal构造函数。这样一来// 也会在心得Dog对象上执行Animal()函数中定义的所有对象初始化代码Animal.call(this,"Nic");this.age = 29;}var ins = new Dog();console.log(ins.name); // Nicconsole.log(ins.age); // 29

        function Animal(name){this.name = name;}Animal.prototype.home = 'north';function Dog(){// 通过使用call()方法（或apply()方法也可以），我们实际上在新创建的Dog实例的环境调用了Animal构造函数。这样一来// 也会在心得Dog对象上执行Animal()函数中定义的所有对象初始化代码Animal.call(this,"Nic");this.age = 29;}Dog.prototype = new Animal();Dog.prototype.constructor = Dog;  // 修正构造函数var ins = new Dog();console.log(ins.name); // Nicconsole.log(ins.age); // 29console.log(ins.home); // north

      function object(o){function F(){};F.prototype = o;return new F();}//在object() 函数内部，先创建了一个临时性的构造函数，然后将传入的对象作为这个构造函数的原型，最后返回这个临时类型的一个新实例。// 从本质上来讲，object()对传入的对象执行了一次浅复制var person = {name : "Ni",friends : ['She','Co'],}var anotherPerson = Object(person);anotherPerson.friends.push('tom');var yetAnotherPerson = Object(person);console.log(yetAnotherPerson.friends);  // ["She", "Co", "tom"]// ECMAScript5通过新增Object.create() 方法规范了原型式继承。这个方法接收两个参数：一个用作新对象原型的对象和（可选的）一个为新对象定义//  额外属性的对象。在传入一个参数的情况下，Object.create() 与 object()方法的行为相同var  myPerson = Object.create(person,{demo:{value:"G"}});console.log(myPerson.demo); //G// 在没有兴师动众的插件构造函数，而只想让一个对象与另一个对象保持类似的情况下，原型式继承式完全可以胜任的。不过别忘了，包含引用类型的值// 的属性始终都会共享相应的值，就像适应原型模式一样
·寄生式继承寄生式继承是与原型式继承紧密相关的一种思路，并且同样也是由上面的作者推而广之的。寄生式继承的思路与继承构造函数和工厂模式类似，即创建一个仅用于封装继承过程的函数，该函数在内部以某种方式来增强对象，最后再像真的是它做了所有工作一样返回对象function object(o){function F(){};F.prototype = o;return new F();}function createAnother(orginal){var close =object(orginal);  // 通过调用函数创建一个新对象close.sayHi = function () {  // 以某种方式增强这个对象console.log('hi');}return close;  // 返回这个对象
        }var person  = {'name' : "Ni",friends : ["She","Co"],}var anPer = createAnother(person);anPer.sayHi(); // hi//在考虑到对象不是自定有类型和构造函数的情况下，寄生式继承也是一种游泳的模式，前面示范继承模式时使用的object()函数不是必需的；任何能返回新// 对象的函数都适用于此模式// 使用寄生式继承来为对象添加函数，会由于不能做到函数复用而降低效率；这一点与构造函数模式类似

        function Super(name){this.name = name;this.color  = ['red','blue'];}Super.prototype.sayName = function () {console.log(this.name);}function Sub(name,age){Super.call(this,name);  // 第二次调用Super();this.age = age;}Sub.prototype = new Super();  // 第一次调用Super();Sub.prototype.constructor = Sub;Sub.prototype.sayAge = function () {console.log(this.age);}var demo = new Sub('cl','25');demo.sayAge();  // 25// 不知道你有没有发现。第一次调用Super构造函数时，Sub.prototype会得到两个属性：name 和 color是，它们都时Super的实例属性，只不过// 位于Sub的原型中。当调用Super构造函数时，又一次在新对象上创建了name 和 color 。于是，这两个属性就屏蔽了原型中的两个同名属性// 好在我们已经找到解决这个问题方法 --- 寄生组合式继承//  所谓继承组合式继承，即姐哟个构造函数来继承属性，通过原型链的混成形式继承方法。其背后的基本思路是：不必为了指定子类型的原型而//  调用超类型的构造函数，我们所需要的无非是超类型原型的一个副本而已。本质上，就是使用寄生式继承来继承超类型的原型，然后再将// 结果制定给子类型的原型。寄生组合式继承的基本模式如下：function inheritPrototype(subType,superType) {var prototype = Object.create(superType.prototype); // 创建对象prototype.constructor = subType;    // 增强对象subType.prototype = prototype;     // 指定对象
                }/*这个示例中的 inheritPrototype() 函数实现了寄生组合式继承的最简单形式。这个函数接收两个参数:子类型构造函数和超类型构造函数。在函数内部，第一步是创建超类型原型的一个副本。第二步为创建的副本添加constructor属性，弥补因重写原型而失去的默认的constructor属性。最后一步，将创建的对象(即副本)赋值给子类型的原型。这样我们就可以调用inheritPrototype()函数的语句，去替换前面例子中为子类原型赋值的语句了：*/function SuperType(name){this.name = name;this.color = ['red','blue','green'];}SuperType.prototype.sayName = function () {console.log(this.name);}function SubType(name, age){SuperType.call(this,name);this.age = age;}inheritPrototype(SubType,SuperType);SubType.prototype.sayAge = function () {console.log(this.age);}var xx = new SubType('cl',14);console.log(xx);// 这个例子高效率体现在它之调用了一次SuperType构造的函数，并且因此避免了在SubType.prototype上创建不必要，多余的属性。与此同时，// 还能够正常使用instanceof 和 isPrototypeOf() 。开发人员普遍认为寄生组合式继承是最理想的继承范式。