Opérateurs

Les opérateurs sont des fonctions spéciales qui utilisent un ou plusieurs opérandes et renvoient une valeur. Un opérande est une valeur (généralement un littéral, une variable ou une expression) utilisée par l’opérateur comme entrée. Par exemple, dans le code suivant, les opérateurs d’addition (+) et de multiplication (*) sont utilisés avec trois opérandes littéraux (2, 3 et 4) pour renvoyer une valeur. Cette valeur est ensuite utilisée par l’opérateur d’affectation (=) pour attribuer la valeur renvoyée, 14, à la variable sumNumber.

var sumNumber:uint = 2 + 3 * 4; // uint = 14

Les opérateurs peuvent être unaires, binaires ou ternaires. Un opérateur unaire utilise un opérande. Par exemple, l’opérateur d’incrémentation (++) est un opérateur unaire car il utilise un seul opérande. Un opérateur binaire utilise deux opérandes. Par exemple, l’opérateur de division (/) utilise deux opérandes. Un opérateur ternaire utilise trois opérandes. Par exemple, l’opérateur conditionnel (?:) utilise trois opérandes.

Certains opérateurs sont surchargés, ce qui signifie qu’ils se comportent différemment selon le type ou la quantité d’opérandes qui leur est transmis. L’opérateur d’addition (+) est un exemple d’opérateur surchargé qui se comporte différemment selon le type de données des opérandes. Si les deux opérandes sont des nombres, l’opérateur d’addition renvoie la somme des valeurs. Si les deux opérandes sont des chaînes, l’opérateur d’addition renvoie la concaténation des deux opérandes. L’exemple de code suivant indique comment l’opérateur se comporte différemment selon les opérandes :

trace(5 + 5); // 10 
trace("5" + "5"); // 55

Les opérateurs peuvent également se comporter différemment selon le nombre d’opérandes fourni. L’opérateur de soustraction (-) est un opérateur à la fois unaire et binaire. Lorsqu’il est fourni avec un seul opérande, l’opérateur de soustraction convertit l’opérande en valeur négative et renvoie le résultat. Lorsqu’il est fourni avec deux opérandes, l’opérateur de soustraction renvoie la différence entre les opérandes. L’exemple suivant présente l’opérateur de soustraction utilisé d’abord comme opérateur unaire, puis comme opérateur binaire.

trace(-3); // -3 
trace(7 - 2); // 5

Priorité et associativité des opérateurs

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

,

Opérateurs principaux

Les opérateurs principaux comprennent ceux utilisés pour créer des littéraux Array et Object, regrouper des expressions, appeler des fonctions, instancier des occurrences de classe et accéder à des propriétés.

Tous les opérateurs principaux, comme répertoriés dans le tableau suivant, ont la même priorité. La mention (E4X) apparaît en regard des opérateurs qui font partie de la spécification E4X.

Opérateur

Opération effectuée

[]

Initialise un tableau

{x:y}

Initialise un objet

()

Regroupe des expressions

f(x)

Appelle une fonction

new

Appelle un constructeur

x.y x[y]

Accède à une propriété

<></>

Initialise un objet XMLList (E4X)

@

Accède à un attribut (E4X)

::

Qualifie un nom (E4X)

..

Accède à un élément XML descendant (E4X)

Opérateurs de suffixe

Les opérateurs de suffixe prennent un opérateur et incrémentent ou décrémentent sa valeur. Bien que ces opérateurs soient des opérateurs unaires, ils sont classés à part du fait de leur priorité supérieure et de leur comportement particulier. Lorsque vous utilisez un opérateur de suffixe dans une expression plus grande, la valeur de l’expression est renvoyée avant le traitement de cet opérateur. Par exemple, le code suivant montre comment la valeur de l’expression xNum++ est renvoyée avant l’incrémentation de la valeur :

var xNum:Number = 0; 
trace(xNum++); // 0 
trace(xNum); // 1

Tous les opérateurs de suffixe, comme répertoriés dans le tableau suivant, ont la même priorité :

Opérateur

Opération effectuée

++

Incrémentation (suffixe)

--

Décrémentation (suffixe)

Opérateurs unaires

Les opérateurs unaires prennent un opérande. Les opérateurs d’incrémentation (++) et de décrémentation (--) de ce groupe sont des opérateurs de préfixe, c’est-à-dire qu’ils apparaissent avant l’opérande dans une expression. Les opérateurs de préfixe diffèrent de leur équivalent suffixe car l’opération d’incrémentation ou de décrémentation est effectuée avant le renvoi de la valeur de l’expression globale. Par exemple, le code suivant montre comment la valeur de l’expression ++xNum est renvoyée après l’incrémentation de la valeur :

var xNum:Number = 0; 
trace(++xNum); // 1 
trace(xNum); // 1

Tous les opérateurs unaires, comme répertoriés dans le tableau suivant, ont la même priorité :

Opérateur

Opération effectuée

++

Incrémentation (préfixe)

--

Décrémentation (préfixe)

+

Unaire +

-

Unaire - (négation)

!

NOT logique

~

NOT au niveau du bit

delete

Supprime une propriété

typeof

Renvoie les informations de type

void

Renvoie une valeur non définie

Opérateurs de multiplication

Les opérateurs de multiplication prennent deux opérandes et effectuent des multiplications, des divisions ou des calculs de modulo.

Tous les opérateurs de multiplication, comme répertoriés dans le tableau suivant, ont la même priorité :

Opérateur

Opération effectuée

*

Multiplication

/

Division

%

Modulo

Opérateurs d’ajout

Les opérateurs d’ajout prennent deux opérandes et effectuent des calculs d’addition ou de soustraction. Tous les opérateurs d’ajout, comme répertoriés dans le tableau suivant, ont la même priorité :

Opérateur

Opération effectuée

+

Addition

-

Soustraction

Opérateurs de décalage au niveau du bit

Ces opérateurs prennent deux opérandes et décalent les bits du premier selon la valeur spécifiée dans le second. Tous les opérateurs de décalage au niveau du bit, comme répertoriés dans le tableau suivant, ont la même priorité :

Opérateur

Opération effectuée

<<

Décalage gauche au niveau du bit

>>

Décalage droit au niveau du bit

>>>

Décalage droit non signé au niveau du bit

Opérateurs relationnels

Les opérateurs relationnels prennent deux opérandes, comparent leurs valeurs et renvoient une valeur booléenne. Tous les opérateurs relationnels, comme répertoriés dans le tableau suivant, ont la même priorité :

Opérateur

Opération effectuée

<

Inférieur à

>

Supérieur à

<=

Inférieur ou égal à

>=

Supérieur ou égal à

as

Vérifie le type de données

in

Vérifie les propriétés des objets

instanceof

Vérifie la chaîne de prototype

is

Vérifie le type de données

Opérateurs d’égalité

Les opérateurs d’égalité prennent deux opérandes, comparent leurs valeurs et renvoient une valeur booléenne. Tous les opérateurs d’égalité, comme répertoriés dans le tableau suivant, ont la même priorité :

Opérateur

Opération effectuée

==

Egalité

!=

Inégalité

===

Egalité stricte

!==

Inégalité stricte

Opérateurs logiques au niveau du bit

Ces opérateurs prennent deux opérandes et effectuent des opérations logiques au niveau des bits. La priorité de ces opérateurs diffère et ils sont présentés dans le tableau suivant par ordre décroissant de priorité :

Opérateur

Opération effectuée

&

AND au niveau du bit

^

XOR au niveau du bit

|

OR au niveau du bit

Opérateurs logiques

Les opérateurs logiques prennent deux opérandes et renvoient une valeur booléenne. La priorité de ces opérateurs diffère et ils sont présentés dans le tableau suivant par ordre décroissant de priorité :

Opérateur

Opération effectuée

&&

AND logique

||

OR logique

Opérateur conditionnel

L’opérateur conditionnel est un opérateur ternaire, c’est-à-dire qu’il prend trois opérandes. Il correspond à une méthode abrégée de l’application de l’instruction conditionnelle if..else.

Opérateur

Opération effectuée

?:

Conditionnel

Opérateurs d’affectation

Les opérateurs d’affectation prennent deux opérandes et affectent une valeur à l’un d’eux en fonction de la valeur de l’autre. Tous les opérateurs d’affectation, comme répertoriés dans le tableau suivant, ont la même priorité :

Opérateur

Opération effectuée

=

Affectation

*=

Affectation de multiplication

/=

Affectation de division

%=

Affectation modulo

+=

Affectation d’addition

-=

Affectation de soustraction

<<=

Affectation de décalage gauche au niveau du bit

>>=

Affectation de décalage droit au niveau du bit

>>>=

Affectation de décalage droit au niveau du bit non signé

&=

Affectation AND au niveau du bit

^=

Affectation XOR au niveau du bit

|=

Affectation OR au niveau du bit