代码改变世界

javascript定义类

2009-03-01 19:15  Iron  阅读(190)  评论(0)  编辑  收藏  举报
javascript里构建类主要有4种方式
1.构造方式定义类
2.原型方式定义类
3.构造和原型结合方式创建类
4.动态的原型方式

各有优缺点,具体如下
1.构造方式定义类，优点:多个实例对象不共享类的属性值，缺点:每个实例对象都会产生出一个函数say

Java代码 复制代码
  1. //构造方式定义类，优点:多个实例对象不共享类的属性值，缺点:每个实例对象都会产生出一个函数say   
  2. function User(){   
  3.     this.username = "zhangsan";//this.不能丢   
  4.        
  5.     this.say = function(){//this.不能丢   
  6.         alert("username:" + this.username );//this.不能丢   
  7.     }   
  8.     //下面注释的这种写法不对   
  9. //  function say(){   
  10. //      alert("username:" + this.username );   
  11. //  }   
  12. }   
  13.   
  14. var user = new User();   
  15. user.username = "lisi";   
  16. user.say();//username:lisi   
  17.   
  18. var user1 = new User();   
  19. user1.say();//username:zhangsan,不受user对象的影响  
//构造方式定义类，优点:多个实例对象不共享类的属性值，缺点:每个实例对象都会产生出一个函数say
function User(){
 this.username = "zhangsan";//this.不能丢
 
 this.say = function(){//this.不能丢
  alert("username:" + this.username );//this.不能丢
 }
 //下面注释的这种写法不对
// function say(){
//  alert("username:" + this.username );
// }
}

var user = new User();
user.username = "lisi";
user.say();//username:lisi

var user1 = new User();
user1.say();//username:zhangsan,不受user对象的影响


//多个实例对象不共享类的属性值:
Java代码 复制代码
  1. //多个实例对象不共享类的属性值，如下:   
  2. function User(){   
  3.     this.username = new Array();//this.不能丢   
  4.        
  5.     this.say = function(){//this.不能丢   
  6.         alert("username:" + this.username );//this.不能丢   
  7.     }   
  8. }   
  9.   
  10. var user = new User();   
  11. user.username.push("zhangsan");   
  12. user.say();//username:zhangsan   
  13.   
  14. var user1 = new User();   
  15. user1.say();//user1的username为空，不为zhangsan,因为user1的属性值不受user影响  
//多个实例对象不共享类的属性值，如下:
function User(){
 this.username = new Array();//this.不能丢
 
 this.say = function(){//this.不能丢
  alert("username:" + this.username );//this.不能丢
 }
}

var user = new User();
user.username.push("zhangsan");
user.say();//username:zhangsan

var user1 = new User();
user1.say();//user1的username为空，不为zhangsan,因为user1的属性值不受user影响


2.原型方式定义类,缺点:类的属性值如果是引用类型的(非Number和String类型)，则多个实例对象共享
Java代码 复制代码
  1. //原型方式定义类,缺点:类的属性值如果是引用类型的(非Number和String类型)，则多个实例对象共享   
  2. function User(){   
  3. }   
  4. User.prototype.username = "zhangsan";   
  5. User.prototype.say = function(){   
  6.     alert("username: " + this.username );   
  7. }   
  8.   
  9. var user = new User();   
  10. user.username = "lisi";   
  11. user.say();//username:lisi   
  12.   
  13. var user1 = new User();   
  14. user1.say();//username:zhangsan  
//原型方式定义类,缺点:类的属性值如果是引用类型的(非Number和String类型)，则多个实例对象共享
function User(){
}
User.prototype.username = "zhangsan";
User.prototype.say = function(){
 alert("username: " + this.username );
}

var user = new User();
user.username = "lisi";
user.say();//username:lisi

var user1 = new User();
user1.say();//username:zhangsan


类的属性值如果是引用类型的(非Number和String类型)，则多个实例对象共享：
Java代码 复制代码
  1. //类的属性值如果是引用类型的(非Number和String类型)，则多个实例对象共享,如下   
  2. function User(){   
  3. }   
  4. User.prototype.username = new Array();   
  5. User.prototype.say = function(){   
  6.     alert("username: " + this.username );   
  7. }   
  8.   
  9. var user = new User();   
  10. user.username.push("zhangsan") ;   
  11. user.say();//username:zhangsan   
  12.   
  13. var user1 = new User();   
  14. user1.say();//username:zhangsan,因为user1属性也会受到user的影响，user1和user指向同一引用，即共享同一属性  
//类的属性值如果是引用类型的(非Number和String类型)，则多个实例对象共享,如下
function User(){
}
User.prototype.username = new Array();
User.prototype.say = function(){
 alert("username: " + this.username );
}

var user = new User();
user.username.push("zhangsan") ;
user.say();//username:zhangsan

var user1 = new User();
user1.say();//username:zhangsan,因为user1属性也会受到user的影响，user1和user指向同一引用，即共享同一属性


3.构造和原型结合方式创建类:优点:类的方法只会产生一个，不会产生大量方法,同时属性还不共享;缺点:属性和方法分开定义不是太好。

Java代码 复制代码
  1. //构造和原型结合方式创建类:优点:类的方法只会产生一个，不会产生大量方法,同时属性还不共享;缺点:属性和方法分开定义不是太好。   
  2. function User(){   
  3.     this.username = "zhangsan";   
  4. }   
  5. User.prototype.say = function(){   
  6.     alert("username: " + this.username );   
  7. }   
  8. var user = new User();   
  9. alert(user.username);  
//构造和原型结合方式创建类:优点:类的方法只会产生一个，不会产生大量方法,同时属性还不共享;缺点:属性和方法分开定义不是太好。
function User(){
 this.username = "zhangsan";
}
User.prototype.say = function(){
 alert("username: " + this.username );
}
var user = new User();
alert(user.username);


4.动态的原型方式:优点:类的方法只会产生一个，不会产生大量方法,同时属性还不共享,同时属性和方法不是分开定义的

Java代码 复制代码
  1. ////动态的原型方式:优点:类的方法只会产生一个，不会产生大量方法,同时属性还不共享,同时属性和方法不是分开定义的   
  2.   
  3. function User(){   
  4.     this.username = "zhangsan";   
  5.        
  6.     if(typeof User.flag == "undefined"){   
  7.         alert("execute...");   
  8.         User.prototype.say = function(){   
  9.             alert("username: " + this.username );   
  10.         }   
  11.            
  12.         User.flag = true;   
  13.     }   
  14. }   
  15.   
  16. var user1 = new User();//execute...   
  17. var user2 = new User();//不会打印出execute...，则说明方法只创建了一次，即方法只会产生一个   
  18. user1.say();//username  
////动态的原型方式:优点:类的方法只会产生一个，不会产生大量方法,同时属性还不共享,同时属性和方法不是分开定义的

function User(){
 this.username = "zhangsan";
 
 if(typeof User.flag == "undefined"){
  alert("execute...");
  User.prototype.say = function(){
   alert("username: " + this.username );
  }
  
  User.flag = true;
 }
}

var user1 = new User();//execute...
var user2 = new User();//不会打印出execute...，则说明方法只创建了一次，即方法只会产生一个
user1.say();//username


总结:
构造方式定义类:缺点:类里的方法，每个实例对象都会产生一个，导致产生大量方法;优点:所有实例对象都单独拥有一份类里的属性，即属性不共享
原型方法定义类:缺点:所有实例对象都共同拥有一份类里的属性，即属性共享。优点:类的方法只会产生一个，不会产生大量方法
构造和原型结合方式创建类:优点:类的方法只会产生一个，不会产生大量方法,同时属性还不共享;缺点:属性和方法分开定义不是太好。
动态的原型方式:优点:类的方法只会产生一个，不会产生大量方法,同时属性还不共享,同时属性和方法不是分开定义的