![](images/tip_help.png)
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.
![](images/tip_help.png)
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.
Nota:
Adobe® AIR® não gera essa exceção.
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
Nota:
No Flash Player 10.1 e no AIR 2.5, a classe String foi aprimorada de modo que as strings usem menos memória.
![](images/tip_help.png)
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
![](images/tip_help.png)
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.
Nota:
O tamanho do código tem grande impacto na execução geral do player. Caso a aplicação inclua grandes quantidades de código ActionScript, então a máquina virtual gastará quantidades significativas de tempo verificando o código e a compilação JIT. Pesquisas de propriedades podem ser lentas, por causa da profundidade das hierarquias de herança e porque caches internos costumam acumular mais informação desnecessária. Para reduzir o tamanho do código, evite o uso da estrutura Adobe® Flex®, da biblioteca da estrutura TLF, ou quaisquer grandes bibliotecas ActionScript de terceiros.
![](images/tip_help.png)
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++)
{
}
![](images/tip_help.png)
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/
.