JAVASCRIPT定义对象的四种方式

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

Javascript代码

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

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

Javascript代码

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

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

Javascript代码

1. functionWorker(sAage,sSalary,sDepartment){
3. this.age=sAage;
5. this.salary=sSalary;
7. this.department=sDepartment;
9. //同工厂方式
10. this.tellSalary=showSalary;
11. //同工厂方式
12. this.tellSalary=function(){
13. alert(this.salary);
14. }
16. }
18. varworker3=newWorker(24,1000,"Dev");
19. worker3.tellSalary();
21. varworker4=newWorker(24,3000,"Dev");
22. worker4.tellSalary();

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

Javascript代码

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

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

Javascript代码

1. functionWorker(sAage,sSalary,sDepartment){
3. this.age=sAage;
5. this.salary=sSalary;
7. this.department=sDepartment;
9. this.homeaddress=newArray("www","dd");
11. }
13. //只创建tellSalary函数一个实例,没有内存浪费
14. Worker.prototype.tellSalary=function(){
15. alert(this.age);
16. }
18. varworker7=newWorker(23,3000,"Dev");
20. varworker8=newWorker(43,1000,"Dev");
22. worker7.tellSalary();
24. alert(worker7.homeaddress)//wwdd
26. worker8.homeaddress.push("gg")
28. alert(worker7.homeaddress)//wwwdd
30. alert(worker8.homeaddress)//wwwddgg

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

Javascript代码

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

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