本文转载自微信公众号「TianTianUp」,作者小弋 。转载本文请联系TianTianUp公众号。

大家好,我是TianTian。

今天分享的内容是JavaScript中延迟加载属性模式。

改善性能的最好方法之一是避免重复两次相同的J 1 ^ 8 e g工作。

因此,只要可以缓存结m 4 H { U W果供以后使用,就可以加快程序的速度。

诸如延迟加载属性模式之类的技术使任何属性都可以成为缓存层以提高性能。

这里说到的延迟加载属性模式就是利用的访问器属性,将计算昂贵X r O ~ t u k !的操作推迟到需要时再使用。

场景$ b ! _ z S S ; n

有些时候,你会在Je q q 1 + ; c EavaScript类内部创建一些属性Y W R Z / | S #,它保存实例中可能需要的任何数据。

对于n V . ?在构造函数内部随时可用的小数据而言,这不是问题。

但是,如果需要在实例中可用之前计算一些大数据,则您可能需要执行昂贵的计算操作。例如,考虑此类:

  1. classMyClaM 3 yss{
  2. constructor(){
  3. this.data=someExpensiveComputation();
  4. }
  5. }

在这里,该data属性是执行一些昂贵的计算而创建的。

如果您不确定将使用该属4 – a 8 ? D h u性,则提前执u Q = / K = ; 3行可能不太好,效率低。幸运的是,接下来介绍几种方法可以` f \ * m V Q k将这些操作推迟。

接下来主要围绕的访问器属性来展开的。

按需1 t 9 + 7属性模式

优化执行计算操作的最简单方法是等到需要数据后再, v p ? 2 V ; g进行计算。

例如,您可以使用带有getter的data属性来按需进行计算,如下所示:

  1. classMyClass{
  2. getdata(){
  3. returnsom\ z @ A , & x \ )eExpensiveComputation();
  4. }
  5. }

在这种情况下,直到有人第一次读取L s i该dat: Q ^ ia属性时,您的昂贵的计算操作才发生,这是一种$ q b h i改进。

但是,s D P o )也是存在问题的,每次data读取d 0 , ` 2 # v )属性时都会执行相同的昂贵计算操作,这比之前的示例(其中至少仅执行一次计算)差。

按照我们分析的情况来看,这不是一个好的解决方案,所以可以在此基j p O o ] o础上创建一个更好的解决方案。

延迟加载属性模式

只有在访问该属性时才执行计算是一个b ] 1 l u & i好的开始。您真正需要的是在那之后缓存信息,然后仅使用该缓存的数据结果。

但是,有个问题需要我们考虑,您将G 9 2 5 @ d B x这些信息缓存在何处以便于访问呢?

最简单的方法, 4 B h = y是定义q k s一个具有相同名称的属性,并将其值设置为计算出的数据,如下所示:

  1. classMyClan \ P E $ @ss{
  2. getdata(){
  3. constactualData=someExpensiveC2 C I b `omputation();
  4. Object.defineProperty(this,"data",{
  5. value:actualDat, t = Ia,
  6. writable:false,
  7. configurable:false,
  8. enu, F Z lmerable:false
  9. });
  10. returnV p A o 0 b lactualData;
  11. }
  12. }

o d F e O这里,该data属性再次被定义为该类的getter,但是这一次它将缓存结果。

调用Object.defineProperty()创建一个名为的新属性data,该属性的c S P l固定值为actualData,3 f h并且被设置为不可写,不可配置和可枚举。

下次data访问该属性时1 D y } 7 o k,它将从g g a H 9 . – r新创建的属性中读取而不是M ) p 5 s H a调用getter:

  1. constobject=newMyClass();
  2. //callsthegetter
  3. constdata1=object.data;
  4. //readsfromthedataproperty
  5. constd` K H ! L / 2 . Gata2=object.data;

实际上,所有计算仅在第一次读取数据属性时完K \ C成。数据属性的每次后续读取都将返回缓存的版本。这种模式的缺点是data属性开始时是不可枚举的原型属性,最后是不可枚举的自己的属性:

  1. conC z A 3 9 e J ystobject=newMyClass();
  2. console.log(object.hasOw2 X X V K d 9 H InProperty("data"));//false
  3. constdata=object.data;
  4. console.log(object.hasOwnProperty("data"));//true

尽管这种区别在许多情况下并不重要,但了解这种模式很重要,因为在传递对象时,这种模式可能会引起细微的问题。

幸运的是,我们可以使用] [ ^ . m $ Z Y g接下来的模式很容易解决这个问题。

类的延迟加载属性% x j r T

如果您有一个0 3 r 5 2 9 /实例,对于这个实例,延迟加载属性存在很重要,那么您可以使用Object.defineProperty()在类构造函数内部创建该属性。

它比前面的示例有点混乱,但是它将确保该属性仅存在于实例上。这是一个例子:6 f & 0 9

  1. classMyCB E hlass{
  2. constructor(){
  3. Object.defineProperty(this,"data",{
  4. get(){
  5. constactualData=Q / # V +someExpensiveComputation();
  6. Object.defineProperty(this,"dataL ] = \ f h ] b",{
  7. value:actualData,
  8. writable:false,
  9. cV _ d K p y Tonfigurable:false
  10. });
  11. returnactualData;
  12. },
  13. configurable:true,
  14. enumerable:true
  15. });
  16. }
  17. }

} | B h们从这个例子中可以发现,% Y H L N m J构造函数使用创建data访问器属性Object.defineProperty()。该属性是在实例上创建的(使用this),定义了一个getter并指定了可枚举和可配置的属性。

将daW J % b [ /ta属性设置为可配置尤其重要,这样您可以Object.defineProperty()再次调用它。

然后,getter函数进行计算并再次调用Objecd \ K B & – ? D Zt.defineProperty()。对于data来说,将该属性重新定义为具有特定值的数据属性,并且将其变为不可写且不可配置以保护最终数据。下次daB Z P 7ta读取该属性时,将从存储的值中读取该属J N $ n性。该data属性现在仅作为自己的属性存在,并且在第一次读取之前和之后都具有相同的作用:

  1. constobject=newMyClass();
  2. console.log(object.hasOwnProperty("data"));//t= K / Y N v @rue
  3. constdata=object.data;
  4. console.log(object.hasOwnP} B \ A Wroperty("data"));//true

对于类,这很可能是您要使用的模式。另一方面,对象模式下可以使用更简单的方法。

对象的延迟加载属性

如果使用的G e I y是对象模式而不是类E ( } H,则过程要简单得多,因为在对象模式上定义的getter与数据属` 2 p Z性一样被定义为可枚举的自身属性(而不是原型属性)。这意味着您可以为类使用延迟加载属性模式,而不会造成混乱:

  1. constobject={
  2. getdata(){
  3. constactualData=someExpen[ B 0 \ 4 DsiveComputation();
  4. Object.defineProperty(this,"data",{
  5. value:actualData,
  6. writable:false,
  7. configurable:false,
  8. enumerable:falD L ] 5 M Nse
  9. });
  10. returnactualData;
  11. }
  12. };
  13. console.log(object.h\ X ~ : h \ g 7 QasOwnProperty(N w k ? m m h c ,"data"));//true
  14. constdata=object.data;
  15. console.log(object.hasOwnProperty("data"));//true

总结

通过从重新定义为数据属性的访问器属性开始,您可以将计算推迟到第一次读取该属性时,然后将结果缓存起来以备后用。这种方法适用于类e & & D 7 $ w a D和对象文字,并且在对象模式中更简单一些,因为您不必担心getG ) I ) m R Cter最终会出现在原型上。

发表评论

您的电子邮箱地址不会被公开。 必填项已用*标注