Verschiedene Optimierungen

Verwenden Sie für ein TextField-Objekt die appendText() -Methode anstelle des Operators += .

Beim Arbeiten mit der text -Eigenschaft der TextField-Klasse sollten Sie die appendText() -Methode anstelle des Operators += verwenden. Die appendText() -Methode bietet eine höhere Leistung.

Im folgenden Codebeispiel wird der Operator += verwendet. Die Ausführung der Schleife dauert 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 

Im folgenden Beispiel wird der Operator += durch die appendText() -Methode ersetzt:

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 

Die Ausführung des Codes dauert nun nur 847 ms.

Aktualisieren Sie Textfelder außerhalb von Schleifen, sofern möglich.

Dieser Code kann mithilfe einer einfachen Technik noch weiter optimiert werden. Das Aktualisieren des Textfeldes in jeder einzelnen Schleife erfordert sehr viel interne Verarbeitungsleistung. Die Codeausführung kann wesentlich beschleunigt werden, wenn ein String verkettet und dem Textfeld außerhalb der Schleife zugewiesen wird. Der Code wird nun in nur 2 ms ausgeführt.

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 

Bei der Arbeit mit HTML-Text ist die zuerst genannte Vorgehensweise so langsam, dass in Flash Player manchmal eine Timeout -Ausnahme ausgelöst wird. Beispielsweise kann eine Ausnahme auftreten, wenn die verwendete Hardware zu langsam ist.

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

Wenn der Wert einem String außerhalb der Schleife zugewiesen wird, dauert die Ausführung des Codes nur 29 ms.

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 

Vermeiden Sie eckige Klammern als Operatoren, sofern möglich.

Die Verwendung von eckigen Klammern als Operatoren kann sich negativ auf die Leistung auswirken. Sie können diese Operatoren vermeiden, indem Sie Verweise in lokale Variablen einfügen. Das folgende Codebeispiel veranschaulicht eine ineffiziente Verwendung von eckigen Klammern als Operatoren:

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 

In der folgenden optimierten Version werden weniger eckige Klammern verwendet:

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 

Verwenden Sie nach Möglichkeit Inline-Code, um die Anzahl der Funktionsaufrufe im Code zu verringern.

Der Aufruf von Funktionen kann viel Arbeitsleistung in Anspruch nehmen. Versuchen Sie, die Anzahl der Funktionsaufrufe zu verringern, indem Sie Code inline platzieren. Die Inline-Platzierung von Code eignet sich gut, wenn die Leistungsoptimierung im Vordergrund steht. Beachten Sie jedoch, dass Inline-Code die Wiederverwendung von Code erschweren und zu einer größeren SWF-Datei führen kann. Einige Funktionsaufrufe, wie beispielsweise die Methoden der Math-Klasse, können problemlos inline platziert werden. Im folgenden Code wird die Math.abs() -Methode verwendet, um absolute Werte zu berechnen:

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

Die von Math.abs() durchgeführte Berechnung kann manuell erfolgen und inline platziert werden:

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

Durch die Inline-Platzierung des Funktionsaufrufs kann der Code viermal so schnell ausgeführt werden. Diese Strategie bietet zahlreiche Vorteile, sie kann sich jedoch negativ auf die Wiederverwendbarkeit und Pflegefreundlichkeit des Codes auswirken.

Vermeiden Sie die Auswertung von Anweisungen in Schleifen.

Eine weitere Optimierung lässt sich erzielen, wenn eine Anweisung nicht in einer Schleife ausgewertet wird. Der folgende Code wird in Iterationen über ein Array ausgeführt, er ist aber nicht optimiert, da die Array-Länge für jede Iteration ausgewertet wird:

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

Stattdessen sollte der Wert gespeichert und wieder verwendet werden:

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

Verwenden Sie die umgekehrte Reihenfolge für while-Schleifen.

Eine while-Schleife in umgekehrter Reihenfolge ist schneller als eine Schleife in Vorwärtsrichtung:

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

Diese Tipps helfen Ihnen bei der ActionScript-Optimierung. Sie zeigen, wie eine einzelne Codezeile Auswirkungen auf Leistung und Arbeitsspeicher haben kann. ActionScript lässt sich mit zahlreichen anderen Techniken optimieren. Weitere Informationen finden Sie unter dem folgenden Link: http://www.rozengain.com/blog/2007/05/01/some-actionscript-30-optimizations/ .

Twitter™- und Facebook-Beiträge fallen nicht unter die Bestimmungen von Creative Commons.