Olika typer av optimeringar

Använd ett TextField-objekt för metoden appendText() i stället för operatorn += .

När du arbetar med egenskapen text i TextField-klassen ska du använda metoden appendText() i stället för operatorn += . Du får bättre prestanda när du använder metoden appendText() .

I exempelvis följande kod används operatorn += och slingan tar 1120 ms att slutföra:

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 

I nästa exempel är operatorn += ersatt med metoden 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 

Koden tar nu 847 ms att slutföra.

Uppdatera textfält utanför slingor när det är möjligt.

Denna kod kan optimeras ytterligare genom att använda en enkel teknik. Att uppdatera textfälten i varje slinga innebär att mycket intern bearbetningskapacitet används. Genom att enbart sammanfoga en sträng och tilldela den till textfältet utanför slingan, så kommer tiden det tar att köra koden att minska avsevärt. Koden tar nu 2 ms att slutföra.

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 

När du arbetar med HTML-text är det tidigare tillvägagångssättet så långsamt så att du i vissa fall får ett Timeout -undantag i Flash Player. Ett undantag kan till exempel genereras om den bakomliggande maskinvaran är för långsam.

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 ); 

Genom att tilldela värdet till en sträng utanför slingan så krävs det nu bara 29 ms att slutföra den:

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 

Undvik, när det är möjligt, att använda hakparentesoperatorn.

Om du använder hakparentesoperatorn kan prestandan försämras. Du kan undvika att använda den genom att spara referensen i en lokal variabel. I följande exempel visas ett ineffektivt sätt att använda hakparentesoperatorn:

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 

I följande optimerade version minskas användningen av hakparentesoperatorn:

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 

Textbunden kod minskar, när det är möjligt, antalet funktionsanrop i koden.

Funktionsanrop kan vara kostsamma. Försök minska antalet funktionsanrop genom att flytta textbunden kod. Att flytta textbunden kod är ett bra sätt att optimera för bättre prestanda. Du ska emellertid tänka på att textbunden kod kan göra det besvärligare att återanvända koden och dessutom kan storleken på SWF-filen öka. Vissa funktionsanrop, som exempelvis Math-klassmetoder, är enkla att flytta i texten. I följande kod används metoden Math.abs() för att beräkna absoluta värdena:

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

De beräkningar som utförs i Math.abs() kan göras manuellt och infogas:

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

När du flyttar funktionsanropet och gör det textbundet kommer du att få en kod som körs mer än fyra gånger snabbare. Detta arbetssätt är användbart i många situationer, men du måste tänka på hur det kan påverka återanvändbarheten och underhållet.

Undvik att utvärdera satser i slingor.

Den går att optimera ytterligare genom att inte utvärdera en stats i en slinga. Följande kod itereras över en matris, men den är inte optimerad eftersom matrislängden utvärderas vid varje iteration:

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

Det är bättre att lagra värdet och sedan återanvända det.

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

Använd omvänd ordning för while-slingor.

En while-slinga i omvänd ordning är snabbare än en framåtriktad slinga:

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

Dessa tips visar på några sätt att optimera ActionScript och hur en kodrad kan påverka prestanda och minneshantering. Det finns emellertid många andra sätt att optimera ActionScript. Du hittar mer information på följande plats: http://www.rozengain.com/blog/2007/05/01/some-actionscript-30-optimizations/ .

Twitter™- och Facebook-inlägg omfattas inte av villkoren i Creative Commons-licensen.