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
|
,
|