javascript对象的几种创建方式

约定不等于承诺〃 2022-05-19 10:11 361阅读 0赞

1、通过Object构造函数或对象字面量创建单个对象　　
这些方式有明显的缺点：使用同一个接口创建很多对象，会产生大量的重复代码。为了解决这个问题，出现了工厂模式。
2、工厂模式：在一个函数内创建好对象，然后把对象返回。工厂模式虽然解决了创建多个相似对象的问题，但却没有解决对象识别的问题。

  1. function createPerson(name,age,job){     
  2. var o=new Object();    
  3. o.name=name;    
  4. o.age=age;    
  5. o.job=job;    
  6. o.sayName=function(){         
  7. alert(this.name);    
  8. };    
  9. return 0;}
  10. var person1=createPerson("Nicholas",29,"Software Engineer");
  11. var person2=createPerson("Greg",27,"Doctor");

3、构造函数模式：创建自定义的构造函数，从而定义自定义对象类型的属性和方法。与工厂模式相比，具有以下特点：
* 没有显式创建对象；
* 直接将属性和方法赋给了this对象；
* 没有return语句；
* 要创建新实例，必须使用new操作符；（否则属性和方法将会被添加到window对象）
* 可以使用instanceof操作符检测对象类型
构造函数的问题：构造函数内部的方法会被重复创建，不同实例内的同名函数是不相等的。可通过将方法移到构造函数外部解决这一问题，但面临新问题：封装性不好。这些问题可通过原型模式解决。

  1. function Person(name,age,job){    
  2. this.name=name;    
  3. this.age=age;   
  4. this.job=job;    
  5. this.sayName=function(){        
  6. alert(this.name);    
  7. };
  8. }var person1=new Person(...);
  9. var person2=new Person(...);

4、原型模式
我们创建的每个函数都有一个prototype属性，这个属性是一个指针，指向一个对象，而这个对象的用途是包含可以由特定类型的所有实例共享的属性和方法。使用原型对象的好处是可以让所有对象实例共享它所包含的属性和方法。原型对象的问题：
它省略了为构造函数传递初始化参数这一环节，结果所有实例在默认情况下都将取得相同的属性值，虽然这会在一定程度带来一定的不便，但不是最大的问题，最大的问题是由其共享的本性所决定的。
对于包含基本值的属性可以通过在实例上添加一个同名属性隐藏原型中的属性。然后，对于包含引用数据类型的值来说，会导致问题。

  1. function Person(){}
  2. Person.prototype.name="Nicholas";
  3. Person.prototype.age=29;
  4. Person.prototype.job="...";
  5. Person.prototype.sayName=function(){    ...};
  6. var person1=new Person();
  7. person1.sayName();//"Nicholas"

5、组合构造函数和原型模式
这是创建自定义类型的最常见的方式。构造函数模式用于定义实例属性，而原型模式用于定义方法和共享的属性。所以每个实例都会有自己的一份实例属性的副本，但同时共享着对方法的引用，最大限度的节省了内存。同时支持向构造函数传递参数。

  1. function Person(name,age,job){     
  2.     this.name=name;    
  3.     this.age=age;    
  4.     this.job=job;    
  5.     this.friends=["S","C"];
  6. }
  7. Person.prototype={    
  8.     constructor:Person,    
  9.     sayName:function(){         
  10.         alert(this.name);    
  11.     }
  12. };
  13. var person1=new Person(...);

6、动态原型模式这里只有sayName（）不存在的情况下，才会将它添加到原型中，这段代码只会在初次调用构造函数时才执行。这里对原型所做的修改，能够立刻在所有实例中得到反映。

  1. function Person(name,age,job){     
  2.     this.name=name;    
  3.     this.age=age;    
  4.     this.job=job;    
  5. if(typeof this.sayName!="function"){        
  6.     Person.prototype.sayName=function(){             
  7.         alert(this.name);        
  8.     };    
  9. }}

7、寄生构造函数模式：
这种模式 的基本思想是创建一个函数，该函数的作用仅仅是封装创建对象的代码，然后再返回新创建的对象；但 从表面上看，这个函数又很像是典型的构造函数。
关于寄生构造函数模式，有一点需要说明：首先，返回的对象与构造函数或者与构造函数的原型属 性之间没有关系；也就是说，构造函数返回的对象与在构造函数外部创建的对象没有什么不同。为此， 不能依赖 instanceof 操作符来确定对象类型。由于存在上述问题，我们建议在可以使用其他模式的情 况下，不要使用这种模式。

  1. function Person(name, age, job){          
  2.     var o = new Object();         
  3.     o.name = name;         
  4.     o.age = age;         
  5.     o.job = job;         
  6.     o.sayName = function(){                  
  7.     alert(this.name);         
  8. };             
  9.     return o; 
  10. }

8、 稳妥构造函数模式：所谓稳妥对象，指的是没有公共属性，而且其方法也不引用 this 。

  1. function Person(name, age, job){               
  2. //创建要返回的对象 
  3. var o = new Object();    
  4. //可以在这里定义私有变量和函数 
  5. //添加方法 
  6. o.sayName = function(){                  
  7. alert(name);         
  8. };                  
  9. //返回对象 
  10. return o; 
  11. }
  12. Object.create(prototype, descriptors)

9、ES5定义了一个名为Object.create（）的方法，它创建一个新对象，其中第一个参数是这个对象的原型，第二个参数对对象的属性进行进一步描述。

  1. var newObj = Object.create(null, { size: { value: "large", }, shape: { value: "round", } });

发表评论

表情：
评论列表 （有 0 条评论，361人围观）

还没有评论，来说两句吧...

相关阅读