Otimizações diversas

Para um objeto TextField, use o método appendText() ao invés do operador += .

Ao trabalhar com a propriedade text da classe TextField, use o método appendText() em vez de usar o operador += . O uso do método appendText() aumenta o desempenho.

Como exemplo, o código a seguir usa o operador += , e o loop demora 1120 ms para ser concluído:

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 

No exemplo a seguir, o operador += é substituído pelo método 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 

Agora o código leva 847 ms para ser concluído.

Atualize campos de texto fora dos loops, sempre que possível.

Esse código pode ser otimizado ainda mais por meio do uso de uma técnica simples. Atualizar o campo de texto em cada loop usa muito processamento interno. Por meio da simples concatenação de uma sequência de caracteres que é então atribuída ao campo de texto fora do loop, o tempo de execução do código é consideravelmente reduzido. Agora o código leva 2 ms para ser concluído:

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 

Ao trabalhar com texto HTML, a abordagem anterior é tão lenta que pode gerar uma exceção Timeout no Flash Player, em alguns casos. Por exemplo, uma exceção pode ser gerada se o hardware subjacente for muito 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 ); 

Com a atribuição do valor a uma sequência de caracteres fora do loop, o código requer apenas 29 ms para ser concluído:

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 

Evite usar o operador colchete, sempre que possível.

Usar o operador colchete pode reduzir o desempenho. Você pode evitar seu uso armazenando sua referência em uma variável local. O exemplo de código a seguir demonstra o uso ineficiente do operador colchete:

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 

A seguinte versão otimizada reduz o uso do operador colchete:

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 

Crie código embutido, sempre que possível, para reduzir o número de chamadas a funções no código.

Chamar funções pode ser dispendioso. Tente reduzir o número de chamadas a funções embutindo o código. Embutir o código é uma boa maneira de otimizar o desempenho. No entanto, lembre-se de que o código embutido dificulta a reutilização do código e pode aumentar o tamanho do arquivo SWF. Algumas chamadas a funções, como métodos da classe Math, podem ser facilmente embutidas. O código a seguir usa o método Math.abs() para calcular valores absolutos:

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

O cálculo realizado por Math.abs() pode ser feito manualmente e embutido:

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

Embutir a chamada de função resulta em código mais de quatro vezes mais rápido. Essa abordagem é útil em muitas situações, mas esteja ciente do efeito que isso pode ter na capacidade de reutilização e manutenção.

Evite avaliações de instruções nas repetições.

Outra otimização pode ser obtida deixando-se de avaliar uma instrução dentro de uma repetição. O código a seguir é iterado por uma matriz, mas não é otimizado, porque o comprimento da matriz é avaliado a cada iteração:

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

É melhor guardar o valor e reutiliza-lo.

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

Utilize ordem reversa para repetições enquanto.

Uma repetição enquanto na ordem reversa é mais rápida que uma repetição avançar:

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

Estas dicas fornecem algumas maneiras de otimizar o ActionScript, mostrando como uma linha de código pode afetar desempenho e memória. Muitas outras otimizações ActionScript são possíveis. Para obter mais informações, consulte: http://www.rozengain.com/blog/2007/05/01/some-actionscript-30-optimizations/ .

As publicações do Twitter™ e do Facebook não são cobertas pelos termos do Creative Commons.