Ottimizzazioni di vario tipo

Per un oggetto TextField, usate il metodo appendText() invece dell'operatore += .

Quando usate la proprietà text della classe TextField, utilizzate il metodo appendText() anziché l'operatore += . L'uso del metodo appendText() garantisce prestazioni migliori.

Ad esempio, il codice seguente utilizza l'operatore += e l'esecuzione completa del ciclo richiede 1120 ms:

addChild ( myTextField ); 
  
myTextField.autoSize = TextFieldAutoSize.LEFT; 
var started:Number = getTimer(); 
  
for (var i:int = 0; i< 1500; i++ ) 
{ 
    myTextField.text += "ActionScript 3"; 
} 
  
trace( getTimer() - started ); 
// output : 1120 

Nell'esempio seguente, l'operatore += è stato sostituito dal metodo appendText() :

var myTextField:TextField = new TextField(); 
addChild ( myTextField ); 
myTextField.autoSize = TextFieldAutoSize.LEFT; 
  
var started:Number = getTimer(); 
  
for (var i:int = 0; i< 1500; i++ ) 
{ 
    myTextField.appendText ( "ActionScript 3" ); 
} 
 
trace( getTimer() - started ); 
// output : 847 

L'esecuzione del nuovo codice richiede 847 ms.

Aggiornate i campi di testo esternamente ai cicli, quando potete.

Questo codice può essere ottimizzato ulteriormente grazie a una tecnica molto semplice. L'aggiornamento del campo di testo all'interno di ciascun ciclo consuma molte risorse di elaborazione interne. Concatenando semplicemente una stringa e assegnandola al campo di testo all'esterno del ciclo, si riduce sensibilmente il tempo necessario per l'esecuzione del codice. Ora l'esecuzione del codice richiede 2 ms:

var myTextField:TextField = new TextField(); 
addChild ( myTextField ); 
myTextField.autoSize = TextFieldAutoSize.LEFT; 
 
var started:Number = getTimer(); 
var content:String = myTextField.text; 
  
for (var i:int = 0; i< 1500; i++ ) 
{ 
    content += "ActionScript 3"; 
} 
  
myTextField.text = content; 
  
trace( getTimer() - started ); 
// output : 2 

Quando si lavora con il testo HTML, il primo approccio è così lento che in alcuni casi può essere generata un'eccezione Timeout in Flash Player. Ad esempio, può essere generata un'eccezione se l'hardware sottostante è troppo lento.

var myTextField:TextField = new TextField(); 
addChild ( myTextField ); 
myTextField.autoSize = TextFieldAutoSize.LEFT; 
  
var started:Number = getTimer(); 
  
for (var i:int = 0; i< 1500; i++ ) 
{ 
    myTextField.htmlText += "ActionScript <b>2</b>"; 
} 
 
trace( getTimer() - started ); 

Assegnando il valore a una stringa esterna al ciclo, il codice richiede solo 29 ms per essere eseguito:

var myTextField:TextField = new TextField(); 
addChild ( myTextField ); 
myTextField.autoSize = TextFieldAutoSize.LEFT; 
  
var started:Number = getTimer(); 
var content:String = myTextField.htmlText; 
  
for (var i:int = 0; i< 1500; i++ ) 
{ 
    content += "<b>ActionScript<b> 3"; 
} 
  
myTextField.htmlText = content; 
  
trace ( getTimer() - started ); 
// output : 29 

Evitate di usare l'operatore parentesi quadra, quando è possibile.

L'uso dell'operatore parentesi quadra può rallentare le prestazioni. Potete evitare di utilizzarlo memorizzandone il riferimento in una variabile locale. L'esempio seguente mostra un uso inefficiente dell'operatore parentesi quadra:

var lng:int = 5000; 
var arraySprite:Vector.<Sprite> = new Vector.<Sprite>(lng, true); 
var i:int; 
  
for ( i = 0; i< lng; i++ ) 
{ 
    arraySprite[i] = new Sprite(); 
} 
  
var started:Number = getTimer(); 
  
for ( i = 0; i< lng; i++ ) 
{ 
    arraySprite[i].x = Math.random()*stage.stageWidth; 
    arraySprite[i].y = Math.random()*stage.stageHeight; 
    arraySprite[i].alpha = Math.random(); 
    arraySprite[i].rotation = Math.random()*360; 
} 
  
trace( getTimer() - started ); 
// output : 16 

La seguente versione ottimizzata riduce l'uso dell'operatore parentesi quadra:

var lng:int = 5000; 
var arraySprite:Vector.<Sprite> = new Vector.<Sprite>(lng, true); 
var i:int; 
  
for ( i = 0; i< lng; i++ ) 
{ 
    arraySprite[i] = new Sprite(); 
} 
  
var started:Number = getTimer(); 
var currentSprite:Sprite; 
  
for ( i = 0; i< lng; i++ ) 
{ 
    currentSprite = arraySprite[i]; 
     currentSprite.x = Math.random()*stage.stageWidth; 
     currentSprite.y = Math.random()*stage.stageHeight; 
     currentSprite.alpha = Math.random(); 
     currentSprite.rotation = Math.random()*360; 
} 
  
trace( getTimer() - started ); 
// output : 9 

Usate il codice in linea, quando è possibile, per ridurre il numero di chiamate di funzione all'interno del codice.

Le chiamate di funzione possono richiedere molte risorse. Cercate di ridurre il numero di chiamate di funzione spostando il codice in linea. Lo spostamento in linea del codice è un buon modo per ottimizzare le prestazioni. Tuttavia, tenete presente che il codice in linea può rendere più difficile il riutilizzo del codice e incrementare le dimensioni del file SWF. Alcune chiamate di funzione, come quelle ai metodi della classe Math, sono più facili da spostare in linea. Il codice seguente utilizza il metodo Math.abs() per calcolare dei valori assoluti:

const MAX_NUM:int = 500000; 
var arrayValues:Vector.<Number>=new Vector.<Number>(MAX_NUM,true); 
var i:int; 
  
for (i = 0; i< MAX_NUM; i++) 
{ 
    arrayValues[i] = Math.random()-Math.random(); 
} 
  
var started:Number = getTimer(); 
var currentValue:Number; 
  
for (i = 0; i< MAX_NUM; i++) 
{ 
    currentValue = arrayValues[i]; 
    arrayValues[i] = Math.abs ( currentValue ); 
} 
  
trace( getTimer() - started ); 
// output : 70

Il calcolo eseguito da Math.abs() può essere eseguito manualmente e spostato in linea:

const MAX_NUM:int = 500000; 
var arrayValues:Vector.<Number>=new Vector.<Number>(MAX_NUM,true); 
var i:int; 
  
for (i = 0; i< MAX_NUM; i++) 
{ 
    arrayValues[i] = Math.random()-Math.random(); 
} 
  
var started:Number = getTimer(); 
var currentValue:Number; 
  
for (i = 0; i< MAX_NUM; i++) 
{ 
    currentValue = arrayValues[i]; 
    arrayValues[i] = currentValue > 0 ? currentValue : -currentValue; 
} 
  
trace( getTimer() - started ); 
// output : 15

Lo spostamento in linea della chiamata di funzione produce un codice oltre quattro volte più veloce. Questo approccio è utile in molte situazioni, ma valutate bene gli effetti che può avere sulla possibilità di riutilizzare il codice e sulla sua gestibilità.

Evitate di valutare le istruzioni nei cicli.

Un'altra ottimizzazione può essere ottenuta evitando di valutare un'istruzione in un ciclo. Il codice seguente esegue un'iterazione su un array, ma non viene ottimizzato perché la lunghezza dell'array viene valutata a ogni iterazione:

for (var i:int = 0; i< myArray.length; i++) 
{ 
}

È meglio memorizzare il valore e riutilizzarlo:

var lng:int = myArray.length; 
 
for (var i:int = 0; i< lng; i++) 
{ 
}

Utilizzate un ordine inverso per i cicli while.

Un ciclo while in ordine inverso è più veloce di uno in ordine standard:

var i:int = myArray.length; 
 
while (--i > -1) 
{ 
}

Questi suggerimenti indicano alcuni modi per ottimizzare il codice ActionScript, spiegando come una singola riga di codice può influire sulle prestazioni e sulla memoria. Sono possibili molte altre ottimizzazioni ActionScript. Per ulteriori informazioni, accedete al collegamento seguente: http://www.rozengain.com/blog/2007/05/01/some-actionscript-30-optimizations/ .

I post su Twitter™ e Facebook non sono coperti dai termini di Creative Commons.