Avantage d'utiliser 'static' sur des consts privés?

Question

Je me demandais s'il y a un avantage à utiliser

private static const

au lieu de

private const

pour les constantes privées? Est-ce que cela change si vous n'avez qu'une instance de la classe ou du multiple? Je soupçonne que pourrait être un peu de mémoire/avantage de performance en utilisant static si vous avez plusieurs instances de la classe.

Answer 1

Comme l'indique mmsmatt, ils économisent un peu de mémoire. Habituellement, ce n'est pas le meilleur endroit pour économiser de la mémoire cependant. Vous devriez plutôt vous préoccuper des fuites de mémoire, des formats de fichiers efficaces et de la représentation des données en général. Un inconvénient des constantes statiques est que tous les accès globaux sont plus lents que l'accès local. instance.ident surpasse Class.ident. Exécutez ce code pour tester:

package { 
    import flash.display.Sprite; 
    import flash.text.TextField; 
    import flash.utils.*; 
    public class Benchmark extends Sprite { 
     private static const delta:int = 0; 
     private const delta:int = 0;   
     private var output:TextField; 
     public function Benchmark() { 
      setTimeout(doBenchmark, 1000); 
      this.makeOutput(); 
     } 
     private function doBenchmark():void { 
      var i:int, start:int, sum:int, inst:int, cls:int; 

      start = getTimer(); 
      sum = 0; 
      for (i = 0; i < 100000000; i++) sum += this.delta; 
      out("instance:", inst = getTimer() - start); 

      start = getTimer(); 
      sum = 0; 
      for (i = 0; i < 100000000; i++) sum += Benchmark.delta; 
      out("class:", cls = getTimer() - start); 

      out("instance is", cls/inst, "times faster"); 
     } 
     private function out(...args):void { 
      this.output.appendText(args.join(" ") + "\n"); 
     } 
     private function makeOutput():void { 
      this.addChild(this.output = new TextField()); 
      this.output.width = stage.stageWidth; 
      this.output.height = stage.stageHeight; 
      this.output.multiline = this.output.wordWrap = true; 
      this.output.background = true;   
     }  
    } 
} 

Answer 2

private static const Les membres sont stockés une fois par type.

private const Les membres sont stockés une fois par instance.

Alors oui, vous économisez de la mémoire.

Answer 3

Cela dépend du cas. Comme indiqué, le statique sera une fois par type et non statique une fois par instance, donc cela dépend du nombre d'instances que vous allez avoir. Je dis cela parce que si vous avez un composant qui est instancié seulement une fois à la fois (comme un pop-up prompt) et que vous le jetez complètement de la mémoire après, cela signifie que vous utilisez comme statique inutile mémoire car il ne disparaîtra jamais cette variable statique. Si c'est quelque chose que vous aurez plusieurs instances de (comme les particules ou les fenêtres multiples) alors oui, il est préférable d'utiliser statique parce qu'ils partageront la même variable.