js继承的6种方式

继承和闭包一直是前端开发的一个重点难点，特别是继承。平时开发过程中如果用的不算很多，就更难以去理解透彻了。要把继承理解透彻，还是需要花点时间的。

【原型链继承】【借用构造函数继承】【组合继承(原型链+构造函数)】【原型式继承】【寄生式继承】【寄生组合式继承】

想要继承，就必须要提供个父类（继承谁，提供继承的属性）

       // 父类 
		function Preson(name){  // 给构造函数添加参数
			this.name = name;
			this.sun = function(){
				alert(this.name)
			}
		}
		Preson.prototype.age = 10; // 给构造函数添加了原型属性

1.原型链继承

       //1.原型链继承
		function Per(){
			this.name = 'ker';
		}
		Per.prototype = new Preson(); // 主要
		var per1 = new Per();
		console.log(per1.age);
		// instanceof 判斷元素是否在另一个元素的原型链上
		// per1 继承了Per1 instanceof Person
		console.log(per1 instanceof Preson )  // true

重点:让新实例的原型等于父类的实例。,
        特点:1.实例课可继承的属性有:
                1.实例的构造函数的属性;
                2.父类构造函数的属性;
                3.父类原型的属性;
                (新实例不会继承父类实例的属性!)
        缺点:1.新实例无法向父类函数传参;
             2.继承单一;
             3.所有新实例都会共享父类实例的属性 
             (原型上的屬性是共享的,一个实例修改了原型属性,;另一个实例的原型属性也会被修改)

2.借用构造函数继承

function Con(){
			Preson.call(this,'jer'); //重点
			this.age = 12;
		}
		var con1 = new Con();
		console.log(con1.name);  //'jer'
		console.log(con1.age);  // 12
		console.log(con1 instanceof Preson); // false

重点:用.call() 和.apply()将父类构造函数引入字函数(在子函数中做了父类函数的自执行(复制))
        特点:1.只继承了父类构造函数的属性,没有继承父类原型的属性;
            2.解决了原型链继承的缺点1 2 3
            3.可以继承多个构造函数属性(call多个)
            4.在子实例中可以向父实例传参
        缺点:1.只继承父类构造函数的额属性,
            2.无法实现构造函数的复用
            3.每个新实例都有父类构造函数副本,臃肿

3.组合继承(组合原型链继承和借用构造函数继承)(常用)

function SubType(name){
			Preson.call(this,name); //借用构造函数模式
		}
		SubType.prototype = new Preson();//原型链继承
		var sub = new SubType('ger');
		console.log(sub.name);//'ger'继承了构造函数属性
		console.log(sub.age);//10 继承了父类原型的属性

重点:结合了两种模式的优点,传参和复用,
        特点:1.可以继承父类原型上的属性,可以传参,可以复用
            2.每个新实例引入的构造函数属性是私有的 
        缺点:调用了两次父类构造函数(耗内存),子类的构造函数会代替原型上的那个父类构造函数

4.原型式继承

//先封装一个函数容器，用来输出对象和承载继承的原理
		function content(obj){
			function F(){}; 
			F.prototype = obj; //继承传入的参数
			return new F(); // 返回函数对象
		}
		var sup = new Preson(); // 拿到父类的实例
		var sup1 = content(sup);
		console.log(sup1.age); //10 继承了父函数的属性

重点:用一个函数包装一个对象,然后返回这个函数的调用,这个函数就变成了个可以随意增添,
            属性的实例或对象,object.create()就是这个原理
        特点:类似于复制一个对象,用函数来包装,
        缺点:1.所有实例都会继承原型上的属性
            2.无法实现复用  (新实例属性都是后面添加的)

5.寄生式继承

function contentt(obj){
			function FF(){}
			FF.prototype = obj; //继承了传入的参数
			return new FF();    // 返回函数对象
		}
		var supt = new Preson(); // 
		// 以上是原型式继承，给原型式继承再套个壳子传递参数
		function subobject(obj){
			var sub = contentt(obj);
			sub.name = 'gar';
			return sub;
		}
		var sup2 = subobject(supt)
		// 这个函数经过声明之后就成了可增添属性的对象
		console.log(typeof subobject); // function
		console.log(typeof sup2); //object
		console.log(sup2.name);// 'gar' 返回了一个sub对象，继承了subde属性

重点:就是给原型式继承外面套了壳子,
        有点:没有创建自定义类型,因为只是套了一个壳子返回对象,这个函数顺理成章的就成了创建的新对象,
        缺点:没有原型,无法复用,

6.寄生组合式继承

//寄生
		function content(obj){
			function F(){};
			F.prototype = obj;
			return new F()
		}
		// content 就是F实例的另一种表示法
		var con = content(Person.prototype);
		// con实例（F实例）的原型继承了父类函数的原型
		// 上述更像是原型链继承，只不过只继承了原型属性
		
		//组合
		function Sub(){
			Person.call(this) // 继承了父类构造函数的属性
		} // 解决了组合式两次调用构造函数属性的缺点
		//重点
		Sub.prototype = con; //继承了con实例
		con.constructor = Sub; //(一定要) 修复实例
		var sub1 = new Sub();
		// Sub的实例就继承了构造函数的属性，父类实例，con的函数属性
		console.log(sub1.age); // 10

寄生:在函数内返回对象然后调用,
组合:1.函数的原型等于另一个实例,2.在函数中用apply或者call引入另一个构造函数,可传参,

重点：修复了组合继承的问题。

总结：

     继承这些知识点与其说是对象的继承，更像是函数的功能用法，如何用函数做到复用，组合，这些和使用继承的思考是一样的。上述几个继承的方法都可以手动修复他们的缺点，但就是多了这个手动修复就变成了另一种继承模式。
　　　　这些继承模式的学习重点是学它们的思想，不然你会在coding书本上的例子的时候，会觉得明明可以直接继承为什么还要搞这么麻烦。就像原型式继承它用函数复制了内部对象的一个副本，这样不仅可以继承内部对象的属性，还能把函数（对象，来源内部对象的返回）随意调用，给它们添加属性，改个参数就可以改变原型对象，而这些新增的属性也不会相互影响。