Javascript对象创建多种方法

 

Javascript代码 
function showSalary(){ 
    alert(this.salary); 
} 
 

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

 

Javascript代码 
function createWorker(sAage,sSalary,sDepartment){ 
 
  var oWorker=new Object(); 
   
  oWorker.age=sAage; 
   
  oWorker.salary=sSalary; 
  
  oWorker.department=sDepartment; 
//创建函数的方式一，指向我们文章开头写好的函数名，缺点是函数在对象的外部，封装性不好 
  oWorker.tellSalary=showSalary; 
//创建函数的方式二，在对象内部声明匿名函数，虽然封装在对象内部了，但没个对象会有不同的函数版本，浪费内存 
  oWorker.tellSalary=function(){ 
    alert(this.salary); 
  } 
   
  return oWorker; 
} 
 
var worker1=createWorker(24,1000,"Dev"); 
worker1.tellSalary(); 
 
var worker2=createWorker(24,3000,"Dev"); 
worker2.tellSalary(); 
 

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

 

Javascript代码 
function Worker(sAage,sSalary,sDepartment){ 
     
  this.age=sAage; 
   
  this.salary=sSalary; 
   
  this.department=sDepartment; 
   
  //同工厂方式 
  this.tellSalary=showSalary; 
  //同工厂方式 
  this.tellSalary=function(){ 
    alert(this.salary); 
  } 
 
} 
 
var worker3=new Worker(24,1000,"Dev"); 
worker3.tellSalary(); 
var worker4=new Worker(24,3000,"Dev"); 
worker4.tellSalary(); 
 

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

 

Javascript代码 
function Worker(){ 
}   
Worker.prototype.age=24; 
Worker.prototype.salary=1000; 
 
Worker.prototype.department="Dev"; 
 
Worker.prototype.homeaddress=new Array("www","dd"); 
 
// 创建多个对象时，要想一想此处为什么不会和构造函数方式及工厂方式一样，创建多个函数的实例 
 
//要理解prototype的概念，prototype是父对象的一个实例 
 
Worker.prototype.tellSalary=function(){ 
    alert(this.age); 
} 
 
var worker5=new Worker(); 
 
var worker6=new Worker(); 
 
worker5.tellSalary(); 
 
alert(worker5.homeaddress) 
 
//修改原型中引用类型的值，会影响到所有已经实例化的对象 
worker6.homeaddress.push("gg")  
 
alert(worker5.homeaddress) 
 

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

 

Javascript代码 
function Worker(sAage,sSalary,sDepartment){ 
     
  this.age=sAage; 
   
  this.salary=sSalary; 
   
  this.department=sDepartment; 
   
  this.homeaddress=new Array("www","dd"); 
   
} 
 
//只创建tellSalary函数一个实例,没有内存浪费 
Worker.prototype.tellSalary=function(){ 
    alert(this.age); 
} 
 
var worker7=new Worker(23,3000,"Dev"); 
 
var worker8=new Worker(43,1000,"Dev"); 
 
worker7.tellSalary(); 
 
alert(worker7.homeaddress) // ww dd  
worker8.homeaddress.push("gg") 
 
alert(worker7.homeaddress) //www dd  
alert(worker8.homeaddress) // www dd gg 
 

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

 

Javascript代码 
var person=function(sname,sage){ 
   this.name=sname; 
   this.age=sage; 
}; 
 
person.prototype={ 
   tellName:function(){ 
         alert(this.name); 
   }, 
    
   tellAge:function(){ 
         alert(this.age); 
   } 
}; 
 
优点：
  1. 可以传参数构造一个新对象
  2. 当有多个对象产生时，不会创建多个函数实体，没有内存浪费
  3. 封装想很好，属性和方法分开，