Sujets sur : optimize actionscript code

Un Cours ActionScript 3 réclamés par les Développeurs suivant la Formation AS3 Facile.

Vous trouverez un ensemble de conseils à suivre pour optimiser votre code ActionScript 3 et le rendre plus performant 😉

J’ai testé chacun de ces exemples dans des applications flash. Il existe plusieurs benchmarks sur internet montrant les gains de performances.

1 – Évitez les multiplications dans les boucles

Mauvaise version

Le résultat est multiplié par un facteur 10 à chaque boucle. La multiplication n’est pas nécessaire.

multiplication

const n: int;
var i: int;
 
var result: int;
 
for( i = 0; i < n; ++i )
{
	result= i * 10;
	trace( result.toString() );
}

Version correcte

La multiplication peut être remplacée par une addition qui est beaucoup moins gourmande en ressources mémoires.

Et nous obtenons exactement le même résultat.

addition

const n: int;
var i: int;
 
var result: int;
 
for( i = 0; i < n; ++i )
{
	trace( result.toString() );
	value += 10;
}

2 – Le Casting

Mauvaise version

Les éléments du tableau sont demandés directement. C’est une mauvaise solution parce que le Player Flash ne connait pas l’objet et la refactorisation du code est impossible.

casting

const list: Array /* type VectorTest */;
var i: int = list.length;
 
while( --i > -1 )
	list[ i ].x = Math.random();

Versions correctes

Il suffit de caster l’objet à l’intérieur du tableau pour améliorer les performances.

casting

const list: Array /* de VectorTest */;
var i: int = list.length;
 
while( --i > -1 )
	VectorTest( list[ i ] ).x = Math.random();

Dans la majorité des cas, utilisez plutôt les Vecteurs pour typer vos tableaux.

casting

const list: Vector.<VectorTest>;
var i: int = list.length;
 
while( --i > -1 )
	list[ i ].x = Math.random();

3 – Réutilisez les instances créées

Mauvaise version

Dans l’exemple suivant, l’instance Point est créée à chaque itération. C’est très couteux en ressource et inutile.

instances

const n: int = 1024;
 
for( var i: int = 0; i < n; ++i )
{
	var point: Point = new Point();
 
	point.x = point.y = Math.random();
 
	// utilisation du "point" ...
}

Version correcte

Il n’est pas nécessaire de créer une nouvelle instance de Point à chaque itération. Une seule instance est nécessaire pour la boucle.

instance

const n: int = 1024;
var point: Point = new Point();
 
for( var i: int = 0; i < n; ++i )
{
	point.x = point.y = Math.random();
 
	// utilisation du "point" ...
}

4 – L’appel de fonction

Lorsque c’est possible, évitez d’appeler directement les fonctions Math() de Flash Player. Elles sont couteuses en ressources.

Remplacez les fonctions Math par leurs équivalents avec les opérations (additions, multiplications…).

fonction

// version lente
y = Math.abs(x);
 
// version équivalente beaucoup plus rapide
y = x > 0.0 ? x : -x;

5 – Le typage

Mauvaise version

Dans l’exemple ci-dessous, la création de l’objet n’est pas typée. C’est une mauvaise solution parce que le Player Flash ne connait pas l’objet. C’est une pratique non recommandée pour le refactoring et la Programmation Orientée Objet.

typage

for( var i: int = 0; i < 1033; ++i )
{
	var oData: Object = {};
 
	oData.x = 1.0;
	oData.y = 2.0;
	oData.z = 3.0;
}

Version correcte

Lors de la création de l’objet, typez ses propriétés correctement. Ainsi le Player Flash connait l’objet et peut lui appliquer des optimisations spécifiques, en fonction du type (Number, String,…).

typage

package
{
	public final class Data
	{
		public var x: Number;
		public var y: Number;
		public var z: Number;
	}
}
 
// dans un autre fichier ActionScript
for( var i: int = 0; i < 1033; ++i )
{
	var oData: Data= new Data();
 
	oData.x = 1.0;
	oData.y = 2.0;
	oData.z = 3.0;
}

6 – Déclaration de variables

Mauvaise version

Lorsque vous avez besoin de déclarer plusieurs variables, la déclaration une ligne par variable n’est pas une solution optimisée.

declaration variables

var a:int=0;
var b:int=0;
var c:int=0;

Version correcte

Pour déclarer plusieurs variables, il est plus optimisé d’utiliser la déclaration sur une seule ligne 😉

declaration variable

var a:int=0, b:int=0, c:int=0;

7 – Boucle For

Une règle très simple en ActionScript 3, utilisez des integers pour les itérations de vos boucles.

Mauvaise version

boucle for

for (var i: Number = 0; i < n; i++)
void;

Version correcte

Pour une exécution plus rapide, utilisez int à la place de Number dans vos boucles.

boucle for

for (var i: int = 0; i < n; i++)
void;

8 – Optimisation des multiplications

Si vous utilisez cette opération i*33, le résultat sera de type Number.

L’accès au tableau est optimisé pour les types int. Donc pour vos calculs dans les tableaux, pensez au casting du résultat en int.

Mauvaise version

multiplications

for (;i<n2;i++)
	Data(array[i*2]).x = 2;

Version optimisée

multiplication

for (;i<n2;i++)
	Data( array[ int(i*2) ] ).x = 2;

9 – Les constantes des autres classes

Une autre optimisation concerne l’utilisation d’une constante provenant d’une autre classe.

Mauvaise version

cosntantes

var iVar:int;
 
for(var i:Number=0; i<100000; i++)
{
	iVar = UneClass.UNE_CONSTANT;
}

Version correcte

Le code précédent peut être optimisé en sortant la constante de la boucle.

Vous créez une variable en dehors de la boucle pour recevoir la constante.

constantes

var iVar:int;
var iConstant:int = UneClass.UNE_CONSTANT;
 
for(var i:Number=0; i<100000; i++)
{
	iVar = iConstant;
}

10 – Les opérateurs sur les bits

L’utilisation des opérateurs sur les bits augmente significativement les performances.

A la place de la multiplication et de la division utilisation les syntaxes sur les bits.

Mauvaise version

opérateurs sur les bits

for(var i:int=0; i<100000; i++)
{
	var val1:int = 4 * 2;
	var val2:int = 4 * 4;
	var val3:int = 4 / 2;
	var val4:int = 4 / 4;
}

Version optimisée

opérateurs sur les bits

for(var i:int=0; i<100000; i++)
{
	var val1:int = 4 << 1;
	var val2:int = 4 << 2;
	var val3:int = 4 >> 1;
	var val4:int = 4 >> 2;
}

11 – Utilisez des Vector à la place des Array

Le Player Flash version 10 a ajouté un nouveau type de données les Vector (ou Vecteurs).

Les Vector sont plus rapides que les Array pour générer des listes des données et parcourir des collections.

Version Array non optimisée

Vector

var a:Array = new Array(LENGTH);
 
for(var i:int = 0; i < LENGTH; i++)
{
	a[i] = Math.random() * 100000;
}

Version équivalent avec Vector

Vector

var v:Vector.<Number> = new Vector.<Number>(LENGTH, true);
 
for(var i:int = 0; i < LENGTH; i++)
{
	v[i] = Math.random() * 100000;
}

Pour aller plus loin dans l’optimisation ActionScript 3

Il y a encore plusieurs autres optimisations à apporter dans votre développement Flash.

Je vous conseille d’étudier l’excellent livre de Thibault Imbert sur l’optimisation des publicités.

Avez-vous d’autres optimisations à suggérer ?

Partagez vos optimisations de code ActionScript 3 dans les commentaires ci-dessous.