javascript定义对象的方式

javascript定义对象的方式（javascript中没有类，只有对象）
1)基于已有对象扩充属性和方法(弊端:每次创建都与要重新定义属性方法)
 var object = new Object();
 alert(object.name);  //打印undefined
 //object["name"] = "zhaoyilin"
 object.name = "zhaoyilin"; //为object增添了name属性
 object.sayName = function(name){ //为object增添sayName函数
  this.name = name;
        alert(this.name);
 }
 //var object = {username: zhangsan , password :123};(这样定义最常见)
 alert(object.name);  //打印zhaoyilin
 delete object.name;  //删除
 alert(object.name) ; //打印undefined

2)工厂方式
 //工厂方式创建对象
1:function createObject(password){
   var object = new Object();
   object.username = "张三";
   pbject.password = password;
   object.getusername = function(){
      alert(this.username);   
   }
   return object;
 }
 var object1 = createObject();(弊端：每生成一个对象，都会生成新的getusername方法，浪费内存，我们多个对象需要多份
属性，但只需要共享一个函数对象)

2://改进版
 function getusername(){
  alert(this.username);
 }
 function createObject(password){
   var object = new Object();
   object.username = "张三";
   pbject.password = password;
   object.getusername = getusername; //返回引用
   return object;
 }
 var object1 = createObject();
弊端: 不是很清晰 getusername()方法分开了

3）构造函数方式
  function Person(//可以传参数){
     //在执行第一行代码前，js引擎会为我们生成一个对象
     this.username = "zhangsan"
     this.password = "123"
     this.getInfo = function(){
      alert(this.username+","+"this.password")
     } 
     //此处有一个隐藏的return语句，用于将之前生成的对象返回(必须要用new产生对象才会return) 
  } 
  var person = new Person();

4)原型("prototype")方式
 //使用prototype方式创建对象（prototype是Object对象里面的属性）
1: function Person(){
 }
 Person.prototype.username = "zhangsan";
 Person.prototype.getusername = function(){
  alert(this.username);
 }
 var person = new Person(); //这样生成的对象都拥有username属性和getusername函数
 弊端:单纯使用原型方式定义类无法在构造函数中为属性赋初值，只能在对象生成后再去改变属性值。
2: function Person(){

 }
 Person.prototype.username = new Array();
 Person.prototype.getusername = function(){
  alert(this.username);
 }
 var person = new Person();
 person.prototype.push("zhangsan");
 person.prototype.push("lisi")
 var person2 = new Person();
 person.getusername();
 person2.getusername();
 //这两个对象调用getusername()方法都是输出"zhangsan" "lisi" 这就引出了另一个弊端:
 如果使用原型方式对象，那么生成的对象会共项原型中的属性，这样一个对象改变了该属性也会反映到其他对象中.

person ----------->Person ----
                                             |----->username  //这和java的内存管理机制一样
person2----------->Person ----

3: 改进版 : 原型+构造函数定义对象（即不共享属性，但共享方法，是个很好的解决方案）
 function Person(){
   this.username = new Array();
 }
 Person.prototype.getInfo = function(){
   alert(this.username);
 }
 var p = new Person();
 var p2 = new Pesron();
 p.username.push("zhangsan");
 p2.usename.push("lisi");
 调用getInfo() p对象输出zhangsan p2输出lisi 两个数组对象不会相互影响。

5）动态原型方式：在构造函数中定义一个标志量

 function Person(){
   this.username = "zhangsan";
   if(typeof Person.flag == "undefined"){
      alert("invoked!");
      Person.prototype.getInfo = function(){   //执行一次就会产生共享方法
       alert(this.username);
      }
      Person.flag = true;
   }
 }
 var person = new Person();
 var person2 = new Person();
 person.getInfo();  //"invoked!" "zhangsan"
 person2.getInfo(); //"zhangsan"