JavaScript模式读书笔记 第6章 代码复用模式

主要使用代码继承来完成复用。

1，使用类式继承。

-1，类式继承：按照类的方式来实现继承，即所谓的类式。

-2，类式继承：通过构造函数（child）获取来自parent的属性，从而创建对象。

<script>

		

	//parent

	 function Parent(name){

		

		this.name = name || ‘Adam‘;

	 }

	 Parent.prototype.say = function(){

	 

		return this.name;

	 }

	 //child

	 function Child(name){

		

 

	 }

	//此处实现继承，需要自己实现

	 inherit(Child, Parent);

 

  </script>

-3，默认模式

 

	 //默认模式

	 function inherit(C, P){

		

		C.prototype = new P();

	 }

 

	 var kid = new Child();

	 console.log(kid.say());//输出Adam

-4，借用构造函数

借用父类构造函数，它传递子对象以绑定到this，并且还转发任意参数。

<script>

	

	//父构造函数

	function Article(){

		

		this.tags = [‘js‘, ‘css‘];

	}

	var article = new Article();

 

	function BlogPost(){

 

	}

	BlogPost.prototype = article;//获取到对应对象的一个引用

	var blog = new BlogPost();

 

	function StaticPost(){

		

		Article.call(this);//获取到对应对象成员的副本，相当于在本对象中生成同样的一个成员变量

	}

	var page = new StaticPost();

	

	console.log(article.hasOwnProperty(‘tags‘));//true

	console.log(blog.hasOwnProperty(‘tags‘));//false

	console.log(page.hasOwnProperty(‘tags‘));//true

 

  </script>

-5，借用和设置原型

<script>

	

	function Child(a, b, c, d){

		

		Parent.apply(this, arguments);//通过借用获取到父类的成员变量

	}

 

	Child.prototype = new Parent();//通过此处获父类的方法

 

  </script>

<script>

	

	function Parent(name){

		

		this.name = name || "Tom";

	}

	Parent.prototype.say = function(){

		

		return this.name;

	}

	function Child(name){

		

		Parent.apply(this, arguments);

	}

 

	Child.prototype = new Parent();

 

	var kid = new Child("Child");

	console.log(kid.name);//child

	console.log(kid.say());//child

	delete kid.name;

	console.log(kid.say());//Tom

 

  </script>

-6，共享原型

function inherit(C, P){

   

   C.prototype = P.prototype;

}

如果继承链下方的某个子类修改原型，那么会影响到所有原型链上的对象。

-7，临时构造函数

function inherit(C, P){

 

   var F = function(){};

   F.prototype = P.prototype;

   C.prototype = new F();

}

-8，Klass

a. 都有一套关于如何命名类方法的公约。

b. 存在从其他类所继承的类。

c.在子类中可以访问父类或超类。

 <script>

	

	var klass = function(Parent, props){

		

		var Child, F, i;

 

		//1. 新构造函数

		Child = function(){

			

			if(Child.uber && Child.uber.hasOwnProperty("_construct")){

				

				Child.uber._construct.apply(this, arguments);

			}

 

			if(Child.prototype.hasOwnProperty("_construct")){

				

				Child.prototype._construct.apply(this, arguments);

			}

		};

 

		//2. 继承

		Parent = Parent || Object;

		F = function(){};

 

		F.prototype = Parent.prototype;

		Child.prototype = new Child();

		Child.uber = Parent.prototype;

		Child.prototype.constructor = Child;

 

		//3.添加实现方法

		for(i in props){

			

			if(props.hasOwnProperty(i)){

				

				Child.prototype[i]= props[i];

			}

		}

 

		return Child;

 

	};

 

  </script>

代码复用才是目的，继承只是实现这一目标的方法之一。