Overige optimalisaties

Gebruik voor een TextField-object liever de methode appendText() in plaats van de += -operator.

Wanneer u de text -eigenschap van de TextField-klasse gebruikt, gebruikt u de appendText() -methode in plaats van de += -operator. Als u de appendText() -methode gebruikt, levert dit prestatieverbeteringen op.

De volgende code gebruikt bijvoorbeeld de += -operator en de loop duurt 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 

In het volgende voorbeeld, wordt de += -operator vervangen met behulp van de appendText() -methode.

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 

Het voltooien van de code duurt nu 847 ms.

Werk tekstvelden indien mogelijk buiten loops bij.

Deze code kan zelfs verder worden geoptimaliseerd met behulp van een eenvoudige techniek. Het bijwerken van een tekstveld in elke loop neemt veel interne verwerking in beslag. De uitvoeringstijd van een code wordt sterk verminderd als u een tekenreeks samenvoegt en deze aan een tekstveld buiten de loop toewijst. Het voltooien van de code duurt nu 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 

Wanneer u met HTML-tekst werkt, is de eerste aanpak zo langzaam, dat deze in sommige gevallen een Timeout -uitzondering veroorzaakt in Flash Player: Er kan bijvoorbeeld een uitzondering optreden als de onderliggende hardware te traag is.

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

Als u de waarde aan een tekenreeks buiten de loop toewijst, wordt de code in slechts 29 ms voltooid.

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 

Gebruik zo weinig mogelijk de vierkante-hakenoperator.

Het gebruik van deze operator kan de prestatie vertragen. U kunt gebruik ervan voorkomen, door uw referentie in een lokale variabele op te slaan. Het volgende codevoorbeeld geeft het inefficiënte gebruik van de vierkante-hakenoperator weer.

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 

De volgende geoptimaliseerde versie beperkt het gebruik van deze operator:

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 

Integreer indien mogelijk uw code om het aantal functieaanroepen in uw code te beperken.

Het aanroepen van functies kan duur zijn. Probeer het aantal functieaanroepen te beperken door inlinecode toe te passen. Door uw code inline te plaatsen, kunt u uw prestatie verder optimaliseren. Onthoud hierbij echter, dat door het gebruik van inlinecode uw code moeilijker herbruikbaar wordt en dat hierdoor de grootte van uw SWF-bestand groter wordt. Sommige functie-aanroepen, zoals de Math-klassemethoden, kunnen eenvoudig inline worden geplaatst. De volgende code gebruikt de Math.abs() -methode voor het berekenen van absolute waarden.

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 berekening die door Math.abs() wordt uitgevoerd, kan handmatig worden uitgevoerd en inline worden geplaatst.

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

Als u de functieaanroep inline plaatst, resulteert dit in code die tot vier keer zo snel werkt. Deze aanpak is in veel situaties bruikbaar, maar houd rekening met het effect op de herbruikbaarheid en het onderhoudsgemak.

Vermijd het evalueren van instructies in loops.

Een andere vorm van optimalisatie kan worden bereikt door een instructie niet te evalueren in een loop. De volgende code wordt over een array herhaald, maar is niet geoptimaliseerd, omdat de arraylengte voor elke herhaling wordt geëvalueerd:

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

U kunt de waarde beter opslaan en opnieuw gebruiken:

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

Gebruik omgekeerde volgorde voor while-loops.

Een while-loop in omgekeerde volgorde is sneller dan een voorwaartse loop:

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

Deze tips vormen een aantal manieren om ActionScript te optimaliseren en laten zien hoe één coderegel de prestaties en het geheugen kan beïnvloeden. Er zijn vele andere vormen van ActionScript-optimalisatie mogelijk. Klik op de volgende koppeling voor meer informatie: http://www.rozengain.com/blog/2007/05/01/some-actionscript-30-optimizations/ .

De voorwaarden van Creative Commons zijn niet van toepassing op Twitter™- en Facebook-berichten.