中国领先的IT技术网站
|
|

JavaScript创建对象模式与最佳实践

多年以来,JavaScript开发者们与原型链的关系总是若即若离,纠缠不清。而今天我们最有可能遇到的两种创建对象的方式,一种是强烈依赖原型链的class语法,另一种则是完全不依赖原型链的工厂函数语法。这两种方式在性能上和特点上是不一样的——尽管差别不太大。

作者:众成翻译来源:码农网|2016-06-20 11:32

开发者大赛路演 | 12月16日,技术创新,北京不见不散


在JavaScript中“创建对象”是一个复杂的话题。这门语言提供了很多种创建对象的方式,不论新手还是老手都可能对此感到无所适从,不知道应该选择哪一种。不过,尽管创建对象的方法很多,看上去语法差异也很大,但实际上它们的相似性可能比你所以为的要多。本文将带领你踏上一段梳理对象创建方法的旅程,为你揭示不同方法之间的依赖与递进关系。

对象字面量

我们的第一站毫无疑问就是创建对象最简单的方法,对象字面量。JavaScript总是宣扬自己能够“无中生有”地创建对象——不需要类、不需要模板、不需要原型——“噌”地一下,一个有方法有数据的对象就出现了。

  1. var o = {  
  2.   x: 42,  
  3.   y: 3.14,  
  4.   f: function() {},  
  5.   g: function() {}  
  6. }; 

但这种方法有一个缺点:如果我们想在其他地方创建一个同类型的对象,就得把这个对象的方法、数据和初始化都复制粘贴过去。我们需要一种能够批量创建同类型对象的方法,而不是只创建一个对象。

工厂函数

我们的下一站是工厂函数。显然,用这种方法来创建一类具有相同结构、接口和实现的对象是最简单的。我们不直接创建一个对象字面量,而是将对象字面量作为函数的返回值,当我们需要多次或多处创建同类型的对象时,只要调用这个函数就行了。

  1. function thing() {  
  2.   return {  
  3.     x: 42,  
  4.     y: 3.14,  
  5.     f: function() {},  
  6.     g: function() {}  
  7.   };  
  8. }  
  9.  
  10. var o = thing(); 

但这种方法也有一个缺点:它会导致内存膨胀,因为每一个对象都包含了工厂函数的独立副本。理论上我们希望所有对象共享一个工厂函数副本。

原型链

JavaScript提供了一种内置的在对象之间共享数据的机制,叫做原型链。当我们访问一个对象的属性时,它会委托某些其他对象来完成这一请求。我们可以利用这一点来修改工厂函数,使它创建的每个对象只包含自己特有的数据,而对其他属性的请求则全部委托给原型链上共有的一个对象。

  1. var thingPrototype = {  
  2.   f: function() {},  
  3.   g: function() {}  
  4. };  
  5.  
  6. function thing() {  
  7.   var o = Object.create(thingPrototype);  
  8.  
  9.   o.x = 42;  
  10.   o.y = 3.14;  
  11.  
  12.   return o;  
  13. }  
  14.  
  15. var o = thing(); 

事实上,JavaScript本身就有内置的机制来支持这种通用模式。我们不需要自己创建这个共有的对象(即原型对象),JavaScript会自动为每个函数创建一个原型对象,我们可以把共享数据直接放在这个对象里。

  1. thing.prototype.f = function() {};  
  2. thing.prototype.g = function() {};  
  3.  
  4. function thing() {  
  5.   var o = Object.create(thing.prototype);  
  6.  
  7.   o.x = 42;  
  8.   o.y = 3.14;  
  9.  
  10.   return o;  
  11. }  
  12.  
  13. var o = thing(); 

但这种方法也有一个缺点:会导致重复。上述thing函数的第一行和最后一行在每一个“委托原型的工厂函数”中都会重复一次,几乎没有区别。

ES5 类

我们可以把那些重复的代码抽出来,放进一个自定义函数里。这个函数会创建一个对象,并与其他某个任意函数(参数函数)的原型建立委托(继承)关系,然后我们把新创建的对象作为参数,调用这个函数(参数函数),最后返回这个新的对象。

  1. function create(fn) {  
  2.   var o = Object.create(fn.prototype);  
  3.  
  4.   fn.call(o);  
  5.  
  6.   return o;  
  7. }  
  8.  
  9. // ...  
  10.  
  11. Thing.prototype.f = function() {};  
  12. Thing.prototype.g = function() {};  
  13.  
  14. function Thing() {  
  15.   this.x = 42;  
  16.   this.y = 3.14;  
  17. }  
  18.  
  19. var o = create(Thing); 

事实上,JavaScript对这种方法也有内置的支持机制。我们定义的这个create函数实际上就是new关键字的一个基本实现,因此我们可以顺手把create换成new。

  1. Thing.prototype.f = function() {};  
  2. Thing.prototype.g = function() {};  
  3.  
  4. function Thing() {  
  5.   this.x = 42;  
  6.   this.y = 3.14;  
  7. }  
  8.  
  9. var o = new Thing(); 

我们现在抵达的这一站通常被称为ES5类。它通过函数来创建对象,把需要共享的数据委托给原型对象,并使用new关键字来处理重复的逻辑。

但这种方法也有一个缺点:冗长又难看,而且在实现继承的时候会更冗长更难看。

ES6 类

JavaScript最新的相关改进是ES6 类,用新语法来实现上述功能要简洁得多。

  1. class Thing {  
  2.   constructor() {  
  3.     this.x = 42;  
  4.     this.y = 3.14;  
  5.   }  
  6.  
  7.   f() {}  
  8.   g() {}  
  9. }  
  10.  
  11. var o = new Thing(); 

比较

多年以来,JavaScript开发者们与原型链的关系总是若即若离,纠缠不清。而今天我们最有可能遇到的两种创建对象的方式,一种是强烈依赖原型链的class语法,另一种则是完全不依赖原型链的工厂函数语法。这两种方式在性能上和特点上是不一样的——尽管差别不太大。

性能

今天的JavaScript引擎已经经过了大幅度的优化,以至于很难通过JavaScript代码来推断怎样会比较快。关键在于测量方法。然而测量方法有时也会失灵。通常每六周就会有更新的JavaScript引擎发布,而在这之前采取的测量方法,和基于这种测量方法做出的决策都有可能失去意义。因此,我的经验法则是选择最官方、最广泛使用的语法,因为大多数时候它经历的实践检验最多,因而性能是最高的。目前来说class语法最符合这一点,在我写这篇文章时,class语法大约比返回字面量的工厂函数快3倍。

特点

随着ES6的发布,类与工厂函数之间曾经存在的几点差异消失了。现在,工厂函数和类都能够强制实现真正的私有数据——工厂函数通过闭包实现,类通过WeakMap实现。两者都能实现多重继承——工厂函数可以将其他属性混入自己的对象,类也可以将其他属性混入自己的原型,或者通过类工厂,通过代理也能实现。工厂函数和类也都可以在需要的时候返回任意对象,语法也都很简单。

结论

综合考虑,我更倾向于class语法。它标准、简单、干净、快速,还提供了所有曾经只有函数工厂才具备的特点。

【编辑推荐】

  1. 前端任务构建利器Gulp.js使用指南
  2. 为什么我从Python转战到Node.js
  3. 我的NodeJS一年之旅总结
  4. 逆向思维:如何判断一套JS框架不符合实际需求?
  5. 图解Javascript原型(prototype)链
【责任编辑:齐琳 TEL:(010)68476606】

点赞 0
分享:
大家都在看
猜你喜欢

读 书 +更多

Windows用户态程序高效排错

本书是一本介绍Windows系统上的用户态程序排错方法和技巧的书。本书分为4个章节,先介绍最重要的、通用的思考方法,以便制定排错步骤;再介...

订阅51CTO邮刊

点击这里查看样刊

订阅51CTO邮刊
× 51CTO学院双十二活动