Documentation Flash CS3

Programmation avec ActionScript 3.0 > Syntaxe et langage ActionScript  > Opérateurs

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 le nie 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

Sous-rubriques

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 dans 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 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 pour 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.

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 instances 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é. (E4X) apparaît en regard des opérateurs qui font partie de la spécification 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é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 avant 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é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é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é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érateurs relationnels

Les opérateurs relationnels prennent deux opérandes, comparent leur 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érateurs d'égalité

Les opérateurs d'égalité prennent deux opérandes, comparent leur 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é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é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 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é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é :

Flash CS3

M'envoyer un message électronique lorsque des commentaires sont ajoutés à cette page | Rapport de commentaire

Page en cours: http://livedocs.adobe.com/flash/9.0_fr/main/00000050.html

Ajouter un commentaire