La priorité et l’associativité des opérateurs déterminent leur ordre de traitement. Bien qu’il soit évident, pour ceux qui connaissent bien l’arithmétique, que le compilateur traite l’opérateur de multiplication (*) avant l’opérateur d’addition (+), le compilateur a besoin d’instructions claires quant à l’ordre à appliquer aux opérateurs. L’ensemble de ces instructions est appelé ordre de priorité des opérateurs. ActionScript définit une priorité par défaut que l’opérateur parenthèses (()) permet de modifier. Par exemple, le code suivant modifie la priorité par défaut de l’exemple précédent pour forcer le compilateur à traiter l’opérateur d’addition avant l’opérateur de multiplication :
var sumNumber:uint = (2 + 3) * 4; // uint == 20
Il arrive que plusieurs opérateurs de même priorité apparaissent dans la même expression. Dans ce cas, le compilateur utilise les règles d’associativité pour identifier le premier opérateur à traiter. Tous les opérateurs binaires, sauf les opérateurs d’affectation, sont associatifs gauche, ce qui signifie que les opérateurs de gauche sont traités avant ceux de droite. Les opérateurs d’affectation et l’opérateur conditionnel (?:) sont associatifs droit, ce qui signifie que les opérateurs de droite sont traités avant ceux de gauche.
Prenons par exemple les opérateurs inférieur à (<) et supérieur à (>), qui ont le même ordre de priorité. Lorsque les deux opérateurs sont employés dans la même expression, celui de gauche est traité en premier puisque tous deux sont associatifs gauche. Cela signifie que les deux instructions suivantes donnent le même résultat :
trace(3 > 2 < 1); // false
trace((3 > 2) < 1); // false
L’opérateur supérieur à est traité en premier, ce qui donne une valeur true car l’opérande 3 est supérieur à l’opérande 2. La valeur true est ensuite transmise à l’opérateur inférieur à, avec l’opérande 1. Le code suivant représente cet état intermédiaire :
trace((true) < 1);
L’opérateur Inférieur à convertit la valeur true en la valeur numérique 1 et compare cette valeur numérique au second opérande 1 pour renvoyer la valeur false (la valeur 1 n’est pas inférieure à 1).
trace(1 < 1); // false
Vous pouvez modifier l’associativité gauche par défaut avec l’opérateur parenthèses. Vous pouvez demander au compilateur de traiter l’opérateur inférieur à en premier lieu en plaçant cet opérateur et son opérande entre parenthèses. L’exemple suivant utilise l’opérateur parenthèses pour produire un résultat différent en utilisant les mêmes nombres que l’exemple précédent :
trace(3 > (2 < 1)); // true
L’opérateur inférieur à est traité en premier, ce qui donne une valeur false car l’opérande 2 n’est pas inférieur à l’opérande 1. La valeur false est ensuite transmise à l’opérateur supérieur à, avec l’opérande 3. Le code suivant représente cet état intermédiaire :
trace(3 > (false));
L’opérateur supérieur à convertit la valeur false en la valeur numérique 0 et compare cette valeur numérique à l’autre opérande 3 pour renvoyer la valeur true (la valeur 3 est supérieure à 0).
trace(3 > 0); // true
Le tableau suivant répertorie les opérateurs gérés par ActionScript 3.0 par ordre de priorité décroissant. Chaque ligne du tableau contient des opérateurs ayant la même priorité. Chaque ligne d’opérateurs a une priorité supérieure à la ligne située au-dessous dans le tableau.
Groupe
|
Opérateurs
|
Principal
|
[] {x:y} () f(x) new x.y x[y] <></> @ :: ..
|
Suffixe
|
x++ x--
|
Unaire
|
++x --x + - ~ ! delete typeof void
|
Multiplication
|
* / %
|
Ajout
|
+ -
|
Décalage au niveau du bit
|
<< >> >>>
|
Relationnel
|
< > <= >= as in instanceof is
|
Egalité
|
== != === !==
|
AND au niveau du bit
|
&
|
XOR au niveau du bit
|
^
|
OR au niveau du bit
|
|
|
AND logique
|
&&
|
OR logique
|
||
|
Conditionnel
|
?:
|
Affectation
|
= *= /= %= += -= <<= >>= >>>= &= ^= |=
|
Virgule
|
,
|