www.javainfo.com.cn 上干货 欢迎收藏

js脚本语言的对象封装

1 以函数的形式封装对象

  //javascript属性的访问方法
    var tv = {};
    tv.color="red";
    tv.play=function(){
      return "hello";
    }
    for(var i in tv ){  // 可以按照顺序访问对象的属性和方法 
      alert(tv[i]);
    }

 
2 函数内包 及函数工厂模式

      var tvv = function(){  //无参数模式
	     var tv = {};
		 tv.color="red";
		 tv.play=function(){
		   return "hello";
		 }
		 return tv;	    
       }
	  
       var tvv1 = new tvv();  //对象实例化
       alert(tvv1.color);    //属性调用为  “.” 运算符
	   
	     var tvv = function(color){  //有参数模式
	     var tv = {};
		 tv.color=color;
		 tv.play=function(){
		   return "hello";
		 }
		 return tv;	    
	     }
       var tvv1 = new tvv("blue");
       alert(tvv1.color);
	 
	 //构造方法的形式
	 function tvvv(color,size){
	    this.color = color;
		this.size = size;
		this.play = function(){
		   return "fly";
		}
	 }
	 var tvvv1 = new tvvv("red","444");
	 alert(tvvv1.size); 
	 
3  prototype方法给对象附加共享代码函数块的方式 创立对象， 好处 共享内存 节约内存

	 function tiger(color,play){
	    this.color = color;
	    this.play = play;
	 }
	 //共享代码段， 不能区分不同对象，所有的对象都会维护这一段代码，及这段代码是所有对象共有的， 当实例化多个对象的时候，
	 //其中一个对象修改了这个函数的返回值，其余对象的这个函数也会返回同样的值。
	 //给tiger对象附加函数 fly 
	 tiger.prototype.fly=function(){  
	    alert("tiger flay");
	 }
	 var tiger1 = new tiger("huangse","jjj");
	 var tigger2 = new tiger("lvse","fsdfsfd");
	 //alert(tiger1.color);
	 tiger1.fly();  //tiger flay 
	 //修改 共享代码段 ，无区别对待所有的实例化对象
	 tiger.prototype.fly=function(){
	   alert("jump");
	 }
	 tigger2.fly(); //jump
	 tiger1.fly();   //jump
	 //经过上面的演示 可以放心 当tiger的fly方法声明发生变化后，再次调用的tiger1.fly() 方法 
	  //返回了最新的值 jump 而不是 tiger flay
	 */
4 混合方式  对象的最优处理方法
	 //对于可以共享的属性或方法  可以放在共享代码段里 ， 对于不能共享的属性或方法，我们需要为其声明为对象的私有
	 //属性或方法 这样可以避免属性或方法 在不同对象之间的相互影响。
	 
	 function tiger(color,play){
	   this.color = color;   //属性
	   this.play = function(){ //私有的方法 是无须共享的
	      alert("jump" + play);  
		  }
	   
	 }
	 tiger.prototype.drink=function(){
	   alert("drink warter ");
	 }
	 
	 var t1 = new tiger("lvse","t1");
	 var t2 = new tiger("huangse","t2");
	 alert(t1.color);  //lvse 
	 alert(t2.color);  //huangse
	 t1.play(); //jumpt1
	 t2.play(); //jumpt2
	 //T2 的私有方法修改了  不会影响T1的方法
	 t2.play = function(){
	   alert("t2 change play ");
	 }	 
	 t2.play();   //t2 change play
	 t1.play();   //jumpt1
	 
	 //共享属性是 内存共享的 结果是一样的 
	 t1.drink();  //drink warter 
	 t2.drink();  //drink warter 

	 
	 
	 	

  经过介绍 我们可以发现 最好的方式就是 采用混合方式， 这样可以根据实际需要设计需要的类 ，还可以避免属性或方法对不同实例的影响。

如有疑问 请留言 欢迎提供建议