Javascript面对对象. 第四篇

原型模式创建对象也有自己的缺点，它省略看构造函数传参初始化这一过程，带来的缺点就是初始化的值都是一致的。

而原型最大的缺点就是它优点，那就是共享。

原型中所有属性是被很多实例共享的，共享对于函数非常合适，对于包含基本值的属性也还可以，但如果属性包含引用类型。

就存在一定的问题：

	function Box(){};
	    Box.prototype={
	    	Constructor:Box,
	    	name:"link",
	    	age:25,
	    	family:['哥哥','弟弟','妹妹'],
	    	run:function(){
	    		return this.name+this.age+'运行中。。。'
	    	}
	    }
	    var box1=new Box();
	    alert(box1.family)
	    box1.family.push('姐姐')  //添加一个引用类型
	    alert(box1.family)       // 输出      哥哥弟弟妹妹姐姐

	    var box2=new Box();
	    alert(box2.family)  //共享了box1添加的引用类型的原型    // 输出    哥哥弟弟妹妹姐姐

ps:数据共享的缘故，导致很多开发者放弃使用原型，因为每次实例化出的数据需要保留自己的特性，而不能共享。

为了解决构造传参和共享问题，可以组合构造函数+原型模式

function Box(name,age){            //不共享的使用构造函数
	this.name=name;
	this.age=age;
	this.family=['哥哥','弟弟','妹妹'];
}
	 Box.prototype={   //共享的使用原型模式
	 	constructor:Box,
	 	run:function(){
	 	  return this.name+this.age+'运行中。。。'
	 	}
	 }
	 var box1=new Box('link',25);
	 box1.family.push('姐姐')
	 alert(box1.run())
	 alert(box1.family)   // 输出    哥哥弟弟妹妹姐姐

	 var box2=new Box('links',25);
	 alert(box2.run())
	 alert(box2.family)    // 输出        哥哥弟弟妹妹

ps:这种混合模式很好的解决了传参和引用共享的大难题。是创建对象比较好的方法。

 原型模式,不管你是否调用了原型中的共享方法,它都会初始化原型中的方法,并且在声明一个对象时，构造函数+原型部分很让人怪异，最好就是把构造函数和原型封装到一起。为了解决这个问题，我们可以使用动态原型模式。

	　　　　　　//可以将原型封装到构造函数里面
		function Box(name,age){
			this.name=name;
			this.age=age;
			alert('初始化开始')
		Box.prototype.run=function(){
			return this.name+this.age+'运行中...'
		}
			alert('初始化结束')
		}
		//原型初始化，执行一次就行，没有必要每次都构造函数实例化的时候初始化！
		var box1=new Box('link',53);
		alert(box1.run())

		var box2=new Box('that',5311);
		alert(box2.run())

原型初始化，执行一次就行，没有必要每次都构造函数实例化的时候初始化！

　　　　　　　　　　function Box(name,age){
			this.name=name;
			this.age=age;

			if(typeof this.run!='function'){  //查看this是否有run
				alert('初始化开始')
		Box.prototype.run=function(){
			return this.name+this.age+'运行中...'
		}
		alert('初始化结束')
		}

		}
             //原型初始化，执行一次就行！
		var box1=new Box('link',53);
		alert(box1.run())

		var box2=new Box('that',5311);
		alert(box2.run())

ps:使用动态原型模式，要注意一下，就是不可以再使用字面量的方式重写原型，因为会切断实例和新原型之间的关联。

如果这几种方式不能满足需求，可以使用一开始那种模式：寄生构造函数！

	function Box(name,age){
			var obj = new Object();
			obj.name=name;
			obj.age=age;
			obj.run=function(){
			 return	this.name+this.age+"运行中....."
			}
			return obj
		}
		var box1=new Box('link',53);
    	alert(box1.run())

ps:寄生构造函数，其实就是工厂模式+构造函数模式。这种模式比较通用，但是不能确定对象关系，所有，在可以使用之前所说的模式时，不建议使用此模式！

在什么情况下使用寄生构造函数比较合适呢？

假如要创建一个额外方法的引用类型。由于之前说明不建议直接使用String.porotype.addstring方法，

可以使用寄生构造的方式添加:

function mystring(string){
	var str=new String(string);
      str.addString=function(){
      	return this+',添加';
      }
      return str;
}
var box1=new mystring('link');
alert(box1.addString());

在一些安全的环境中，比如禁止使用this和new，这里的this是构造函数里不使用this，这里的new是在外部实例化构造函数时不使用new,

这种创建方式叫稳妥构造函数。

　　　　　　　　　　　　function Box(name,age){
			var obj = new Object();
			obj.run=function(){
			 return	name+age+"运行中....."
			}
			return obj
		}
		var box1=Box('link',53);
    	　　　　alert(box1.run())

ps:稳妥构造函数和寄生类似。