JAVASCRIPT定义对象的四种方式

先写一个函数，下面几个方式会用到 

Javascript代码

1. function showSalary(){  
2.     alert(this.salary);  
3. }  

工厂方式 
先创建对象，然后添加属性和方法，不需要用NEW创建对象， 
如果把函数写在内部，每次调用都会创建新的函数，放在外面，封装性不好 

Javascript代码

1. function createWorker(sAage,sSalary,sDepartment){  
2.   
3.   var oWorker=new Object();  
4.     
5.   oWorker.age=sAage;  
6.     
7.   oWorker.salary=sSalary;  
8.     
9.   oWorker.department=sDepartment;  
10. //创建函数的方式一，指向我们文章开头写好的函数名，缺点是函数在对象的外部，封装性不好  
11.   oWorker.tellSalary=showSalary;  
12. //创建函数的方式二，在对象内部声明匿名函数，虽然封装在对象内部了，但没个对象会有不同的函数版本，浪费内存  
13.   oWorker.tellSalary=function(){  
14.     alert(this.salary);  
15.   }  
16.     
17.   return oWorker;  
18. }  
19.   
20. var worker1=createWorker(24,1000,"Dev");  
21. worker1.tellSalary();  
22.   
23. var worker2=createWorker(24,3000,"Dev");  
24. worker2.tellSalary();  

构造函数方式 
在构造函数内部不创建对象，使用this关键字，创建时候用new操作符，如果把函数声明在内部，存在和工厂方式相同的问题，重复创建函数。为每个对象都创建独立的函数版本。放在外部，封装性不好 

Javascript代码

1. function Worker(sAage,sSalary,sDepartment){  
2.       
3.   this.age=sAage;  
4.     
5.   this.salary=sSalary;  
6.     
7.   this.department=sDepartment;  
8.     
9.   //同工厂方式  
10.   this.tellSalary=showSalary;  
11.   //同工厂方式  
12.   this.tellSalary=function(){  
13.     alert(this.salary);  
14.   }  
15.   
16. }  
17.   
18. var worker3=new Worker(24,1000,"Dev");  
19. worker3.tellSalary();  
20.   
21. var worker4=new Worker(24,3000,"Dev");  
22. worker4.tellSalary();  

原型方式，创建对象时不能使用构造传递参数，必须先创建对象，然后改变属性的值 

Javascript代码 

1. function Worker(){  
2. }  
3.   
4.   
5. Worker.prototype.age=24;  
6.   
7. Worker.prototype.salary=1000;  
8.   
9. Worker.prototype.department="Dev";  
10.   
11. Worker.prototype.homeaddress=new Array("www","dd");  
12.   
13. // 创建多个对象时，要想一想此处为什么不会和构造函数方式及工厂方式一样，创建多个函数的实例  
14.   
15. //要理解prototype的概念，prototype是父对象的一个实例  
16.   
17. Worker.prototype.tellSalary=function(){  
18.     alert(this.age);  
19. }  
20.   
21. var worker5=new Worker();  
22.   
23. var worker6=new Worker();  
24.   
25. worker5.tellSalary();  
26.   
27. alert(worker5.homeaddress)  
28.   
29. //修改原型中引用类型的值，会影响到所有已经实例化的对象  
30. worker6.homeaddress.push("gg")   
31.   
32. alert(worker5.homeaddress)  

混合原型和构造函数方式 
可以传递参数构造对象，多个实例对象共享一个函数 

Javascript代码

1. function Worker(sAage,sSalary,sDepartment){  
2.       
3.   this.age=sAage;  
4.     
5.   this.salary=sSalary;  
6.     
7.   this.department=sDepartment;  
8.     
9.   this.homeaddress=new Array("www","dd");  
10.     
11. }  
12.   
13. //只创建tellSalary函数一个实例,没有内存浪费  
14. Worker.prototype.tellSalary=function(){  
15.     alert(this.age);  
16. }  
17.   
18. var worker7=new Worker(23,3000,"Dev");  
19.   
20. var worker8=new Worker(43,1000,"Dev");  
21.   
22. worker7.tellSalary();  
23.   
24. alert(worker7.homeaddress) // ww dd  
25.   
26. worker8.homeaddress.push("gg")  
27.   
28. alert(worker7.homeaddress) //www dd  
29.   
30. alert(worker8.homeaddress) // www dd gg  

第四种的方式看上去也很散落，可以改进一下 

Javascript代码 

1. var person=function(sname,sage){  
2.    this.name=sname;  
3.    this.age=sage;  
4. };  
5.   
6. person.prototype={  
7.    tellName:function(){  
8.          alert(this.name);  
9.    },  
10.      
11.    tellAge:function(){  
12.          alert(this.age);  
13.    }  
14. };  

优点： 
  1. 可以传参数构造一个新对象 
  2. 当有多个对象产生时，不会创建多个函数实体，没有内存浪费 
  3. 封装想很好，属性和方法分开，