Opérateurs 

Additionne des expressions numériques. Si les deux expressions sont des entiers, la somme est un entier. Si l’une ou les deux expressions sont des nombres à virgule flottante, la somme est un nombre à virgule flottante.

Si l’une des expressions est une chaîne, toutes les autres sont converties en chaînes et concaténées au lieu d’être additionnées. Dans le cas contraire, si une expression n’est pas numérique, Flash^® Player la convertit en nombre.

trace(2 + 3); // 5

trace(2.5 + 3.25); // 5.75

trace("Number " + 8 + 0); // Number 80

var oldBalance:Number = 1345.23; 
var currentBalance = deposit_txt.text + oldBalance; 
trace(currentBalance); 

var oldBalance:Number = 1345.23; 
var currentBalance:Number = Number(deposit_txt.text) + oldBalance;
trace(currentBalance);

Eléments de l’API associés

Affecte à expression1 la valeur de expression1 + expression2. Par exemple, les deux instructions suivantes ont le même résultat :

x += y; 
x = x + y; 

var x:Number = 5; 
var y:Number = 10; 
x += y; 
trace(x); // 15 

Eléments de l’API associés

myArray = [a0, a1,...aN]
myArray[i] = value 
myObject[propertyName]

Initialise un nouveau tableau, simple ou multidimensionnel, avec les éléments spécifiés (a0, etc.) ou accède aux éléments d’un tableau. L’opérateur d’accès au tableau permet de définir et de récupérer, de façon dynamique, des noms d’occurrence, de variable et d’objet. Il permet également d’accéder aux propriétés d’objet.

Utilisation 1 : un tableau est un objet dont les propriétés sont appelées éléments, tous identifiés par des nombres appelés index. Lorsque vous créez un tableau, vous entourez les éléments avec l’opérateur ([]) d’accès au tableau (crochets). Un tableau peut regrouper différents types d’éléments. Par exemple, le tableau suivant, appelé employee, comporte trois éléments ; le premier est un nombre et les deux suivants sont des chaînes (entre guillemets) :

var employee:Array = [15, "Barbara", "Jay"]; 

var ticTacToe:Array = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]; 
			
/* Select Debug > List Variables in test mode 
to see a list of the array elements.*/ 

var my_array:Array = new Array(); 
my_array[0] = 15; 
my_array[1] = "Hello"; 
my_array[2] = true; 

my_array[3] = "George"; 

var ticTacToe:Array = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]; 
trace(ticTacToe[1][2]); // 6 

var obj:Object = new Object();
obj.prop1 = "foo";
trace(obj["prop" + 1]); // foo
obj.prop2 = "bar";
for (j in obj) {
	trace(obj[j]);
} 
/* Output of for loop: 
foo
bar */

var my_array:Array = []; 
var my_array:Array = new Array(); 

L’exemple suivant crée un tableau appelé employee_array avec trois éléments et modifie le troisième.

var employee_array = ["Barbara", "George", "Mary"]; 
trace(employee_array); // Barbara,George,Mary 
employee_array[2] = "Sam"; 
trace(employee_array); // Barbara,George,Sam 

var obj:Object = new Object();
obj.prop1 = "foo";
obj.prop2 = "bar";

for (var i:int = 1;i < 3;i++) {
	trace(obj["prop"+i]);
}
/* Output of for loop:
foo
bar */ 

Eléments de l’API associés

Evalue si une expression spécifiée par le premier opérande est membre du type de données indiqué par le deuxième opérande. Si le premier opérande est membre du type de données, le résultat est le premier opérande. Sinon, il contient la valeur null.

L’expression utilisée pour le second opérande doit renvoyer un type de données.

public var myArray:Array = ["one", "two", "three"];
trace(myArray as Array);  // one,two,three
trace(myArray as Number); // null
trace(myArray as int);    // null

Eléments de l’API associés

Affecte la valeur expression2 (opérande à droite) à la variable, l’élément de tableau ou une propriété dans expression1. L’affectation peut se faire par valeur ou par référence. L’affectation par valeur copie la valeur réelle de expression2 et la stocke dans expression1. L’affectation par valeur est utilisée lorsque expression2 est une valeur primitive (son type de données est Boolean, Number, int, uint ou String). L’affectation par référence stocke une référence à expression2 dans expression1. L’affectation par référence est généralement utilisée avec l’opérateur new. L’opérateur new crée un objet en mémoire et une référence à cet emplacement en mémoire est affectée à une variable.

Remarque : dans ActionScript 3.0, toutes les valeurs (y compris les primitives) sont des objets, et toutes les affectations s’effectuent par référence. Cependant, les objets primitifs ont des opérateurs spéciaux qui les autorisent à se comporter comme s’ils avaient été affectés par valeur.

var z:Number = 5;

var x:String;
x = "hello";

var moonsOfJupiter:Array = new Array();
moonsOfJupiter[0] = "Callisto";

var mercury:Object = new Object();
mercury.diameter = 3030; // in miles
trace(mercury.diameter); // 3030

var merkur:Object = mercury;
merkur.diameter = 4878;  // in kilometers
trace(mercury.diameter); // 4878

Eléments de l’API associés

 myXML.@attributeName 

Identifie les attributs d’un objet XML ou XMLList. Par exemple, myXML.@id identifie les attributs nommés id pour l’objet XML myXML. Vous pouvez également utiliser la syntaxe suivante pour accéder aux attributs : myXML.attribute("id"), myXML["@id"] et myXML.@["id"]. La syntaxe myXML.@id est conseillée. Pour renvoyer un objet XMLList pour tous les noms d’attribut, utilisez @*. Pour renvoyer un attribut dont le nom est un mot réservé d’ActionScript, employez la méthode attribute() au lieu de l’opérateur @.

var myXML:XML = 
	<item id = "42">
		<catalogName>Presta tube</catalogName>
		<price>3.99</price>
	</item>;

trace(myXML.@id); // 42

var xml:XML =<example id='123' color='blue'/>
 var xml2:XMLList = xml.@*;
 trace(xml2 is XMLList); // true
 trace(xml2.length());  // 2
 for (var i:int = 0; i < xml2.length(); i++)
 { 
	trace(typeof(xml2[i]));    // xml
	trace(xml2[i].nodeKind()); // attribute
	trace(xml2[i].name());     // id and color
 } 

var xml:XML = <example class='123'/>
trace(xml.attribute("class"));

Eléments de l’API associés

Convertit expression1 et expression2 en entiers non signés de 32 bits, et exécute une opération Boolean AND sur chaque bit des paramètres de l’entier. Les nombres à virgule flottante sont convertis en entiers en supprimant les chiffres après la virgule. Le résultat est un nouvel entier de 32 bits.

Un entier positif est converti en valeur hexadécimale non signée, la maximale étant de 4294967295 ou 0xFFFFFFFF. Toute valeur supérieure à la maximale perd ses chiffres les plus significatifs lorsqu’elle est convertie, de sorte qu’elle soit toujours de 32 bits. Un nombre négatif est converti en valeur hexadécimale non signée à l’aide d’une notation en complément à deux, la valeur minimale étant -2147483648 ou 0x800000000. Un nombre inférieur à la valeur minimale est converti en complément à deux avec une plus grande précision, avant de perdre ses chiffres les plus significatifs.

Le résultat étant interprété comme un nombre en complément à deux sur 32 bits, il s’agit d’un entier compris entre -2147483648 et 2147483647.

var insert:Number = 13; 
var update:Number = 11; 
trace(insert & update); // 9 (or 1001 binary) 

  1101
& 1011
  ----
  1001

Les exemples suivants illustrent le comportement de la conversion de la valeur renvoyée :

trace(0xFFFFFFFF); // 4294967295 
trace(0xFFFFFFFF & 0xFFFFFFFF); // -1 
trace(0xFFFFFFFF & -1); // -1 
trace(4294967295 & -1); // -1 
trace(4294967295 & 4294967295); // -1 

Eléments de l’API associés

Affecte à expression1 la valeur de expression1 &expression2. Par exemple, les deux expressions suivantes sont équivalentes :

x &= y; 
x = x & y; 

var x:Number = 15; 
var y:Number = 9; 
trace(x &= y); // 9 

Eléments de l’API associés

Convertit expression1 et shiftCount en entiers de 32 bits et décale tous les bits de expression1 vers la gauche en fonction du nombre spécifié par l’entier résultant de la conversion de shiftCount. Les positions de bits qui sont vidées suite à cette opération sont remplies par des 0 et les bits déplacés vers la gauche sont supprimés Le fait de décaler une valeur d’une unité vers la gauche revient à la multiplier par 2.

Un nombre à virgule flottante est converti en entier en supprimant tous les chiffres situés après la virgule. Un entier positif est converti en valeur hexadécimale non signée, la maximale étant de 4294967295 ou 0xFFFFFFFF. Toute valeur supérieure à la maximale perd ses chiffres les plus significatifs lorsqu’elle est convertie, de sorte qu’elle soit toujours de 32 bits. Un nombre négatif est converti en valeur hexadécimale non signée à l’aide d’une notation en complément à deux, la valeur minimale étant -2147483648 ou 0x800000000. Un nombre inférieur à la valeur minimale est converti en complément à deux avec une plus grande précision, avant de perdre ses chiffres les plus significatifs.

Le résultat étant interprété comme un nombre en complément à deux sur 32 bits, il s’agit d’un entier compris entre -2147483648 et 2147483647.

Si le résultat est un entier négatif, une erreur se produit à l’exécution si vous tentez d’affecter le résultat à une variable de type uint. Bien qu’ActionScript ne possède pas d’opérateur de « décalage gauche au niveau du bit non signé », vous pouvez obtenir le même résultat et éviter l’erreur d’exécution en utilisant uint(expression1 << shiftCount) :

var num1:uint = 0xFF;
var num2:uint = uint(num1 << 24); // uint() prevents runtime error

x = 1 << 10

   00000000001 binary 
<<          10 decimal
--------------
   10000000000 binary equals 1024 decimal 

Dans l’exemple suivant, l’entier 7 est décalé de 8 bits vers la gauche :

x = 7 << 8

   00000000111 binary 
<<           8 decimal
--------------
   11100000000 binary equals 1792 decimal 

L’instruction trace suivante montre le décalage de trois positions vers la gauche que les bits ont subi :

// 1 binary == 0001 
// 8 binary == 1000 
trace(1 << 3); // 8 

Eléments de l’API associés

Effectue un décalage vers la gauche (<<=) au niveau du bit et stocke ensuite le contenu dans expression1. Les deux expressions suivantes sont équivalentes :

A <<= B
A = (A << B)

var x:Number = 4; 
// Shift all bits one slot to the left. 
x <<= 1; 
trace(x); // 8 
// 4 decimal = 0100 binary 
// 8 decimal = 1000 binary 

Eléments de l’API associés

Convertit expression en un entier signé de 32 bits, puis applique un complément à un au niveau du bit. Cela implique que chaque bit qui est un 0 se voit affecter la valeur 1 dans le résultat, et chaque bit qui est un 1 la valeur 0. Le résultat est un nouvel entier signé de 32 bits. Cet opérateur est également connu sous le nom d’opérateur en complément à un ou d’opérateur de complément au niveau du bit.

Par exemple, la valeur hexadécimale 0x7777 est représentée par le nombre binaire suivant :

0111011101110111

Par exemple, la négation au niveau du bit de la valeur hexadécimale ~0x7777 est représentée de la façon suivante en binaire :

1000100010001000

En hexadécimal, ceci se traduit par 0x8888. Par conséquent, ~0x7777 donne 0x8888.

L’utilisation la plus répandue des opérateurs au niveau du bit consiste à représenter les bits indicateurs (valeurs booléennes contractées sur 1 bit).

Un nombre à virgule flottante est converti en entier en supprimant tous les chiffres situés après la virgule. Un entier positif est converti en valeur hexadécimale non signée, la maximale étant de 4294967295 ou 0xFFFFFFFF. Toute valeur supérieure à la maximale perd ses chiffres les plus significatifs lorsqu’elle est convertie, de sorte qu’elle soit toujours de 32 bits. Un nombre négatif est converti en valeur hexadécimale non signée à l’aide d’une notation en complément à deux, la valeur minimale étant -2147483648 ou 0x800000000. Un nombre inférieur à la valeur minimale est converti en complément à deux avec une plus grande précision, avant de perdre ses chiffres les plus significatifs.

Le résultat étant interprété comme un nombre en complément à deux sur 32 bits, il s’agit d’un entier compris entre -2147483648 et 2147483647.

var ReadOnlyFlag:int = 0x0001; // defines bit 0 as the read-only flag 
var flags:int = 0; 
trace(flags); 
/* To set the read-only flag in the flags variable, 
   the following code uses the bitwise OR: 
*/
flags |= ReadOnlyFlag; 
trace(flags); 
/* To clear the read-only flag in the flags variable, 
   first construct a mask by using bitwise NOT on ReadOnlyFlag. 
   In the mask, every bit is a 1 except for the read-only flag. 
   Then, use bitwise AND with the mask to clear the read-only flag. 
   The following code constructs the mask and performs the bitwise AND: 
*/ 
flags &= ~ReadOnlyFlag; 
trace(flags); 
// 0 1 0 

Eléments de l’API associés

Convertit expression1 et expression2 en entiers non signés de 32 bits et insère un 1 à chaque position de bit, où les bits correspondants de expression1 ou expression2 sont de 1.

Un nombre à virgule flottante est converti en entier en supprimant tous les chiffres situés après la virgule. Un entier positif est converti en valeur hexadécimale non signée, la maximale étant de 4294967295 ou 0xFFFFFFFF. Toute valeur supérieure à la maximale perd ses chiffres les plus significatifs lorsqu’elle est convertie, de sorte qu’elle soit toujours de 32 bits. Un nombre négatif est converti en valeur hexadécimale non signée à l’aide d’une notation en complément à deux, la valeur minimale étant -2147483648 ou 0x800000000. Un nombre inférieur à la valeur minimale est converti en complément à deux avec une plus grande précision, avant de perdre ses chiffres les plus significatifs.

Le résultat étant interprété comme un nombre en complément à deux sur 32 bits, il s’agit d’un entier compris entre -2147483648 et 2147483647.

// 15 decimal = 1111 binary 
var a:Number = 15; 
// 9 decimal = 1001 binary 
var b:Number = 9; 
// 1111 | 1001 = 1111 
trace(a | b); // returns 15 decimal (1111 binary) 

Eléments de l’API associés

Affecte à expression1 la valeur de expression1 | expression2. Par exemple, les deux instructions suivantes sont équivalentes :

x |= y; 
x = x | y; 

// 15 decimal = 1111 binary 
var a:Number = 15; 
// 9 decimal = 1001 binary 
var b:Number = 9; 
// 1111 |= 1001 = 1111 
trace(a |= b); // returns 15 decimal (1111 binary) 

Eléments de l’API associés

Convertit expression et shiftCount en entiers de 32 bits et décale tous les bits de expression vers la droite en fonction du nombre spécifié par l’entier résultant de la conversion de shiftCount. Les bits décalés vers la droite sont supprimés. Pour préserver le signe de l’expression d’origine, les bits situés à gauche sont remplacés par des 0 si le bit le plus significatif (le plus à gauche) de expression est 0, et par des 1 si le bit le plus significatif est 1. Le décalage vers la droite d’une valeur d’une unité équivaut à une division par 2 et au rejet du reste.

Un nombre à virgule flottante est converti en entier en supprimant tous les chiffres situés après la virgule. Un entier positif est converti en valeur hexadécimale non signée, la maximale étant de 4294967295 ou 0xFFFFFFFF. Toute valeur supérieure à la maximale perd ses chiffres les plus significatifs lorsqu’elle est convertie, de sorte qu’elle soit toujours de 32 bits. Un nombre négatif est converti en valeur hexadécimale non signée à l’aide d’une notation en complément à deux, la valeur minimale étant -2147483648 ou 0x800000000. Un nombre inférieur à la valeur minimale est converti en complément à deux avec une plus grande précision, avant de perdre ses chiffres les plus significatifs.

Le résultat étant interprété comme un nombre en complément à deux sur 32 bits, il s’agit d’un entier compris entre -2147483648 et 2147483647.

var a:Number = 65535 >> 8; 
trace(a); // 255

    00000000000000001111111111111111 binary (65535 decimal)
>>                                 8 decimal
--------------------
    00000000000000000000000011111111 binary (255 decimal)

var a:Number = -8 >> 1;
trace(a); // -4

    11111111111111111111111111111000 binary (-8 decimal)
>>							    1 decimal
--------------------
    11111111111111111111111111111100 binary (-4 decimal)

Eléments de l’API associés

Effectue un décalage au niveau du bit vers la droite et stocke le résultat dans expression.

Les deux instructions suivantes sont équivalentes :

A >>= B; 
A = (A >> B);

function convertToBinary(numberToConvert:Number):String { 
	var result:String = ""; 
	for (var i = 0; i < 32; i++) { 
		// Extract least significant bit using bitwise AND. 
		var lsb:Number = numberToConvert & 1; 
		// Add this bit to the result.
		result = (lsb ? "1" : "0")+result; 
		// Shift numberToConvert right by one bit, to see next bit. 
		numberToConvert >>= 1; 
	} 
	return result; 
} 
trace(convertToBinary(479)); 
// Returns the string 00000000000000000000000111011111. 
// This string is the binary representation of the decimal number 479.

Eléments de l’API associés

Identique à l’opérateur de décalage vers la droite au niveau du bit (>>), à la différence qu’il ne conserve pas le signe de l’expression d’origine car les bits de gauche sont toujours remplacés par des 0.

Un nombre à virgule flottante est converti en entier en supprimant tous les chiffres situés après la virgule. Un entier positif est converti en valeur hexadécimale non signée, la maximale étant de 4294967295 ou 0xFFFFFFFF. Toute valeur supérieure à la maximale perd ses chiffres les plus significatifs lorsqu’elle est convertie, de sorte qu’elle soit toujours de 32 bits. Un nombre négatif est converti en valeur hexadécimale non signée à l’aide d’une notation en complément à deux, la valeur minimale étant -2147483648 ou 0x800000000. Un nombre inférieur à la valeur minimale est converti en complément à deux avec une plus grande précision, avant de perdre ses chiffres les plus significatifs.

Le résultat est interprété comme un entier de 32 bits non signé, de sorte que le résultat soit un entier compris entre 0 et 4294967295.

Remarque : ActionScript ne possède pas d’opérateur de « décalage gauche au niveau du bit non signé » complémentaire, mais vous pouvez obtenir le même résultat en utilisant uint(expression << shiftCount).

var a:Number = -1 >>> 1; 
trace(a); // 2147483647 

Eléments de l’API associés

Effectue un décalage droit au niveau du bit non signé et stocke le résultat dans expression. Les deux instructions suivantes sont équivalentes :

A >>>= B; 
A = (A >>> B); 

var a:Number = -1;
a >>>= 1; 
trace(a); // 2147483647 

Eléments de l’API associés

Convertit expression1 et expression2 en entiers non signés de 32 bits et insère un 1 à chaque position de bit, où les bits correspondants de expression1 ou expression2 (mais pas des deux) sont de 1.

Un nombre à virgule flottante est converti en entier en supprimant tous les chiffres situés après la virgule. Un entier positif est converti en valeur hexadécimale non signée, la maximale étant de 4294967295 ou 0xFFFFFFFF. Toute valeur supérieure à la maximale perd ses chiffres les plus significatifs lorsqu’elle est convertie, de sorte qu’elle soit toujours de 32 bits. Un nombre négatif est converti en valeur hexadécimale non signée à l’aide d’une notation en complément à deux, la valeur minimale étant -2147483648 ou 0x800000000. Un nombre inférieur à la valeur minimale est converti en complément à deux avec une plus grande précision, avant de perdre ses chiffres les plus significatifs.

Le résultat étant interprété comme un nombre en complément à deux sur 32 bits, il s’agit d’un entier compris entre -2147483648 et 2147483647.

// 15 decimal = 1111 binary 
// 9 decimal = 1001 binary 
var a:Number = 15 ^ 9; 
trace(a); 
// 1111 ^ 1001 = 0110 
// returns 6 decimal (0110 binary) 

Eléments de l’API associés

Affecte à expression1 la valeur de expression1 ^ expression2. Par exemple, les deux instructions suivantes sont équivalentes :

x ^= y 
x = x ^ y 

// 15 decimal = 1111 binary 
var a:Number = 15; 
// 9 decimal = 1001 binary 
var b:Number = 9; 
trace(a ^= b); // returns 6 decimal (0110 binary) 

Eléments de l’API associés

/* comment */

/* comment

   comment */

Délimite une ou plusieurs lignes de commentaires de script. Les caractères qui apparaissent entre le séparateur ouvrant (/*) et le séparateur fermant (*/) sont interprétés comme des commentaires et ignorés par le compilateur ActionScript. Utilisez ces séparateurs pour des commentaires sur plusieurs lignes. Pour les commentaires sur une seule ligne, entrez le délimiteur //.

Vous recevrez un message d’erreur si vous omettez le séparateur de bloc de commentaires fermant (*/) ou si vous tentez d’imbriquer des commentaires. Lorsqu’un séparateur ouvrant (/*) est utilisé, le premier séparateur fermant (*/) suivant ferme le commentaire, quel que soit le nombre de séparateurs ouvrants placés devant lui.

/* records the X and Y positions of 
the ball and bat movie clips */ 
var ballX:Number = ball_mc._x; 
var ballY:Number = ball_mc._y; 
var batX:Number = bat_mc._x; 
var batY:Number = bat_mc._y; 

/* This is an attempt to nest comments. 
/* But the first closing tag will be paired 
with the first opening tag */ 
and this text will not be interpreted as a comment */ 

Eléments de l’API associés

 myXML = <{tagName} {attributeName} = {attributeValue}>{content}

Evalue une expression utilisée dans un initialiseur XML ou XMLList. Un initialiseur XML ou XMLList est une valeur littérale affectée à une variable de type XML ou XMLList. Une expression qui est délimitée par les opérateurs XML { et } peut être utilisée dans un initialiseur XML ou XMLList au lieu de noms ou de valeurs littérales. Une expression peut être utilisée à la place de tagName, attributeName, attributeValue et content.

var tagname:String = "item"; 
var attributename:String = "id"; 
var attributevalue:String = "5"; 
var content:String = "Chicken"; 
var x:XML = <{tagname} {attributename}={attributevalue}>{content}</{tagname}>; 
trace(x.toXMLString()); // <item id="5">Chicken</item>

Eléments de l’API associés

 myXML[expression]

Accède à une propriété ou un attribut d’un objet XML ou XMLList. L’opérateur accolades vous permet d’accéder aux noms des propriétés inaccessibles avec l’opérateur point (.).

var myXML:XML = <a><foo-bar>44</foo-bar></a>;
trace(myXML["foo-bar"]);

Eléments de l’API associés

Calcule expression1, puis expression2, etc. L’opérateur est principalement utilisé avec l’instruction de boucle for et s’accompagne souvent de l’opérateur parenthèses ().

for (i = 0, j = 0; i < 3 && j < 3; i++, j+=2) { 
	trace("i = " + i + ", j = " + j); 
} 
// output: 
// i = 0, j = 0 
// i = 1, j = 2

var v:Number = 0; 
v = 4, 5, 6; 
trace(v); // 4 

var v:Number = 0; 
v = (4, 5, 6); 
trace(v); // 6 

var v:Number = 0; 
var z:Number = 0; 
v = v + 4 , z++, v + 6; 
trace(v); // 4 
trace(z); // 1 

var v:Number = 0; 
var z:Number = 0; 
v = (v + 4, z++, v + 6); 
trace(v); // 6 
trace(z); // 1 

Eléments de l’API associés

Concatène (combine) des chaînes. Si l’une des expressions est une chaîne, toutes les autres sont converties en chaînes et concaténées.

Si les deux expressions sont des nombres, cet opérateur se comporte comme un opérateur d’addition.

var lastName:String = "Cola"; 
var instrument:String = "Drums"; 
trace(lastName + " plays " + instrument); // Cola plays Drums 

trace("Number " + 8 + 0); // Number 80

var a:String = 3 + 10 + "asdf"; 
trace(a); // 13asdf 
var b:String = "asdf" + 3 + 10; 
trace(b); // asdf310 

Eléments de l’API associés

expression1 + expression2

Concatène (combine) des valeurs XML ou XMLList dans un objet XMLList. Le résultat est un objet XMLList uniquement si les deux opérandes sont des valeurs XML ou XMLList.

var x1:XML = 
		<employee id = "42">
			<firstName>Joe</firstName>
			<lastName>Smith</lastName>
		</employee>;

var x2:XML = 
		<employee id = "43">
			<firstName>Susan</firstName>
			<lastName>Jones</lastName>
		</employee>;

var myXMLList:XMLList = x1 + x2;
	
trace(myXMLList.toXMLString()); 

L’instruction trace produit le résultat suivant :

<employee id = "42">
	<firstName>Joe</firstName>
	<lastName>Smith</lastName>
</employee>
<employee id = "43">
	<firstName>Susan</firstName>
	<lastName>Jones</lastName>
</employee>
	

Eléments de l’API associés

Affecte à expression1 la valeur de expression1 + expression2. Par exemple, les deux instructions suivantes ont le même résultat :

x += y; 
x = x + y;

var x1:String = "My name is "; 
x1 += "Gilbert"; 
trace(x1); // My name is Gilbert 

Eléments de l’API associés

expression1 += expression2

Affecte à expression1, qui est un objet XMLList, la valeur de expression1 + expression2. Par exemple, les deux instructions suivantes ont le même résultat :

x += y; 
x = x + y; 

var x1:XML = <location>Athens</location>;	
var x2:XML = <location>Paris</location>;		
myXMLList = x1 + x2;

var x3:XML = <location>Springfield</location>;
myXMLList += x3;
		    
trace(myXMLList.toXMLString());

L’instruction trace produit le résultat suivant :

<location>Athens</location>
	
<location>Paris</location>	

<location>Springfield</location>

Eléments de l’API associés

expression1 ? expression2 : expression3

Calcule expression1, et si la valeur de expression1 est true, le résultat de la valeur de expression2 ; autrement le résultat est la valeur de expression3.

var x:Number = 5; 
var y:Number = 10; 
var z = (x < 6) ? x: y; 
trace(z); // returns 5

var timecode:String = (new Date().getHours() < 11) ? "AM" : "PM"; 
trace(timecode); 

if (new Date().getHours() < 11) { 
	var timecode:String = "AM"; 
} else { 
	var timecode:String = "PM"; 
}
trace(timecode); 

--expression

expression--

Soustrait 1 de l’opérande. L’opérande peut être une variable, un élément de tableau ou une propriété d’objet. La forme avant décrémentation de l’opérateur (--expression) soustrait 1 de expression et renvoie le résultat. La forme après décrémentation de l’opérateur (expression--) soustrait 1 de expression et renvoie la valeur initiale de expression (la valeur précédant la soustraction).

var x:Number = 3; 
var y:Number = --x; // y is equal to 2

var x:Number = 3; 
var y:Number = x--; // y is equal to 3

for (var i = 10; i > 0; i--) { 
	trace(i); 
}

 delete reference

Détruit la propriété objet spécifiée par reference. Le résultat est true si la propriété n’existe pas à la fin de l’opération, et false dans tous les autres cas. L’opérateur delete renvoie true s’il est appelé sur une propriété non existante ou une propriété dynamique non définie dans une classe.

L’opérateur delete peut échouer et renvoyer false si le paramètre reference ne peut pas être supprimé. Vous ne pouvez pas supprimer les propriétés fixes ni les variables qui sont déclarées avec l’instruction var. Une propriété fixe est une variable ou une méthode déclarée dans une définition de classe.

L’opérateur delete ne peut pas servir à détruire une propriété de classe, à moins que celle-ci soit dynamique et ajoutée à l’exécution. Les propriétés des classes scellées ne peuvent pas être détruites par delete. Définissez plutôt la propriété sur null.

Remarque : vous ne pouvez pas supprimer un objet, mais vous pouvez le rendre éligible pour le nettoyage en retirant toutes les références à l’objet. La référence la plus répandue à un objet est une variable qui le désigne. Vous pouvez supprimer une telle référence en définissant la variable sur null. Le nettoyeur de mémoire supprime tout objet qui n’a pas de références.

// create the new object "account" 
var account:Object = new Object(); 
// assign property name to the account 
account.name = "Jon"; 
// delete the property 
delete account.name; 
trace(account.name); // undefined

// delete a nonexistent property
var fooDeleted:Boolean = delete account.foo;
trace(fooDeleted); // true

L’exemple suivant supprime la valeur d’un élément de tableau, mais la valeur de la propriété length n’est pas modifiée :

var my_array:Array = new Array(); 
my_array[0] = "abc"; // my_array.length == 1 
my_array[1] = "def"; // my_array.length == 2 
my_array[2] = "ghi"; // my_array.length == 3 
// my_array[2] is deleted, but Array.length is not changed 
delete my_array[2]; 
trace(my_array.length); // 3 
trace(my_array); // abc,def,

L’exemple suivant montre comment la valeur Boolean renvoyée par delete peut servir de condition pour une future exécution du code. Lorsqu’un élément a déjà été supprimé, tout nouvel appel de delete sur l’élément renvoie false.

var my_array:Array = [ "abc", "def", "ghi" ];
var deleteWasSuccessful:Boolean

deleteWasSuccessful = delete my_array[0];
if(deleteWasSuccessful) delete my_array[1];
deleteWasSuccessful = delete my_array[0];
if(deleteWasSuccessful) delete my_array[2];

trace(my_array) // outputs: undefined,undefined,ghi

Eléments de l’API associés

 delete reference

Supprime les éléments ou les attributs XML spécifiés par reference.

 
var x1:XML = <x1>
				<a id = "52">AYY</a>
				<a>AYY 2 </a>
				<b>BEE</b>
				<c>CEE</c>
			</x1>;

trace(x1.toXMLString());
trace("___________");

delete x1.a.@id;

trace(x1.toXMLString());
trace("___________");

delete x1.b;

trace(x1.toXMLString());
trace("___________");

delete x1.a;

trace(x1.toXMLString());

Le résultat se présente comme suit :

<x1>
  <a id="52">AYY</a>
  <a>AYY 2</a>
  <b>BEE</b>
  <c>CEE</c>
</x1>
___________
<x1>
  <a>AYY</a>
  <a>AYY 2</a>
  <b>BEE</b>
  <c>CEE</c>
</x1>
___________
<x1>
  <a>AYY</a>
  <a>AYY 2</a>
  <c>CEE</c>
</x1>
___________
<x1>
  <c>CEE</c>
</x1>

 
var xml:XML = 
			<order>
				<item id="121">hamburger</item>
				<item id="122">fries</item>
				<item id="123">chocolate shake</item>
			</order>;
delete xml.item[1].*;
delete xml.item[1].@*;
trace(xml);

Le résultat se présente comme suit :

<order>
  <tem id="121">hamburger</item>
  <item/>
  <item id="123">chocolate shake</item>
</order>

 myXML..childElement1..@attributeName 

Navigue jusqu’aux éléments descendants d’un objet XML ou XMLList ou (combiné avec l’opérateur @) détecte les attributs correspondants des descendants. Les éléments ou attributs correspondants ne doivent pas être des enfants directs de l’objet XML ou XMLList ; ils peuvent être à un niveau inférieur dans l’arborescence (par exemple des petits-enfants). Le résultat est un objet XMLList, car plusieurs éléments enfant ou attribut peuvent correspondre.

L’ordre des nœuds dans l’objet XMLList renvoyé est le résultat d’une première traversée approfondie. Considérons par exemple ce qui suit :

var myXML:XML = <a>
			<b>one
				<c> 
					<b>two</b> 
				</c> 
			</b>
			<b>three</b>
		</a>;

trace(myXML..b[0].toXMLString());
trace("______________");
trace(myXML..b[1].toXMLString());
trace("______________");
trace(myXML..b[2].toXMLString());

La sortie suivante donnerait ce résultat :

<b>
  one
  <c>
    <b>two</b>
  </c>
</b>
______________
<b>two</b>
______________
<b>three</b>

Pour renvoyer des descendants dont les noms correspondent à des mots réservés d’ActionScript, utilisez la méthode XML.descendants() au lieu de l’opérateur descendant (..), comme dans l’exemple suivant :

var xml:XML = 
<enrollees>
	<student id="239">
		<class name="Algebra" />
 		<class name="Spanish 2"/>
	</student>
	<student id="206">
		<class name="Trigonometry" />
 		<class name="Spanish 2" />
	</student>
 </enrollees>;
 trace(xml.descendants("class")); 
 

var myXML:XML = 
	<employees>
		<employee id = "42">
			<firstName>Billy</firstName>
			<lastName>Einstein</lastName>
		</employee>
		<employee id = "43">
			<firstName>Sally</firstName>
			<lastName>Shostakovich</lastName>
		</employee>
	</employees>
	
trace(myXML..firstName); 
	// <firstName>Billy</firstName>
	// <firstName>Sally</firstName>
				
trace(myXML..@id); //4243

Eléments de l’API associés

Divise expression1 par expression2. Le résultat de l’opération de division est un nombre à virgule flottante de deux décimales.

trace(3/0);   // Infinity
trace(-3/0);  // -Infinity
trace(0/0);   // NaN

Eléments de l’API associés

Affecte à expression1 la valeur de expression1 / expression2. Par exemple, les deux instructions suivantes sont équivalentes :

x /= y; 
x = x / y;

var a:Number = 10; 
var b:Number = 2; 
a /= b; trace(a); // 5 

Eléments de l’API associés

object.property_or_method

Accède aux variables et aux méthodes d’une classe, récupère et définit les propriétés d’objet et délimite les packages ou les classes importé(es).

import flash.utils.Timer;

var obj:Object = new Object();
obj.propertyA = "hello";
trace(obj.propertyA);  // hello

Eléments de l’API associés

myXML.childElement
myXML.@attributeName 

Navigue jusqu’aux éléments enfant d’un objet XML ou XMLList ou (combiné avec l’opérateur @) renvoie les attributs d’un objet XML ou XMLList. L’objet renvoyé est un objet XMLList, car plusieurs éléments enfant ou attribut peuvent correspondre.

Pour renvoyer des descendants dont les noms correspondent à des mots réservés d’ActionScript, utilisez la méthode XML.elements() ou XML.descendants() au lieu de l’opérateur point XML (.), comme dans l’exemple suivant :

var xml:XML = 
	<student id="206">
		<class name="Trigonometry" />
		<class name="Spanish 2" />
	</student>;
trace(xml.elements("class"));
trace(xml.descendants("class")); 

var myXML:XML = 
	<employee id = "42">
		<firstName>Billy</firstName>
		<lastName>Einstein</lastName>
	</employee>;

trace(myXML.firstName); // Billy
trace(myXML.@id);       // 42

Eléments de l’API associés

Teste l’égalité de deux expressions. Le résultat est true lorsque les deux expressions sont égales.

Si les types de données de deux opérandes sont identiques, la condition d’égalité dépend du type de données des opérandes :

• Les valeurs de type int, uint et Boolean sont traitées comme étant égales si leurs valeurs sont identiques.
• Des nombres possédant des valeurs identiques sont considérés égaux, sauf s’ils sont tous les deux NaN.
• Si la valeur des deux opérandes est null ou undefined, ils sont traités comme étant égaux.
• Les expressions de chaîne sont égales si elles possèdent le même nombre de caractères et que ces derniers sont identiques.
• Pour des objets XML :
  • Si l’un des deux opérandes est un nœud de texte ou d’attribut et que l’autre est un contenu simple, les deux opérandes sont convertis en chaînes au moyen de la méthode toString() et considérés égaux si les chaînes résultantes sont identiques.
  • Dans le cas contraire, les objets sont égaux uniquement si leur nom qualifié, leurs attributs et leurs propriétés enfant correspondent.
• Les objets XMLList sont considérés égaux s’ils possèdent le même nombre de propriétés, et que l’ordre et les valeurs de ces propriétés sont identiques.
• Pour les types d’objet Namespace, les valeurs sont considérées égales si les propriétés uri des deux objets sont identiques.
• Pour les types d’objet QName, les valeurs sont considérées égales si les propriétés uri des deux objets sont identiques et que leurs propriétés localName le sont également.
• Les variables représentant des objets, des tableaux et des fonctions sont comparées par référence. Deux variables de ce type sont égales si elles font référence au même objet, au même tableau ou à la même fonction. Deux tableaux séparés ne sont jamais considérés comme égaux même s’ils possèdent le même nombre d’éléments.

• Les valeurs des opérandes sont undefined et null, auquel cas le résultat est true.
• La conversion automatique de type de données convertit les types de données des valeurs String, Boolean, int, uint et Number en types compatibles. Les valeurs converties sont égales, auquel cas les opérandes sont également considérés égaux.
• L’un des deux opérandes est du type XML avec du contenu simple (hasSimpleContent() == true), et une fois les deux opérandes convertis en chaîne au moyen de la méthode toString(), les chaînes résultantes sont identiques.
• L’un des opérandes est du type XMLList et l’une des deux conditions suivantes est vraie :
  • La propriété length de l’objet XMLList est 0, et l’autre objet est undefined.
  • La propriété length de l’objet XMLList est 1, et un élément de l’objet XMLList est identique à l’autre opérande.

var a:String = "David"
var b:String = "David"; 
if (a == b) { 
	trace("David is David"); 
} 

var a:Number = 5; 
var b:String = "5"; 
trace(a == b); // true

var c:Number = 1; 
var d:Boolean = true; 
trace(c == d); // true
var e:Number = 0; 
var f:Boolean = false; 
trace(e == f); // true

var g:String = "true";
var h:Boolean = true;
trace(g == h); // false

var firstArray:Array = new Array("one", "two", "three"); 
var secondArray:Array = new Array("one", "two", "three"); 
trace(firstArray == secondArray); // false 
/* Arrays are only considered equal 
if the variables refer to the same array. */
var thirdArray:Array = firstArray; 
trace(firstArray == thirdArray); // true 

Eléments de l’API associés

Compare deux expressions et détermine si expression1 est supérieur à expression2. Dans l’affirmative, le résultat est true. Si expression1 est supérieure ou égale à expression2, le résultat est false.

Si les deux opérandes sont de type String, ils sont comparés en ordre alphabétique ; toutes les majuscules ont priorité sur les minuscules. Sinon, les opérandes sont d’abord convertis en nombres, puis comparés.

var a:String = "first";
var b:String = "First";
trace(a > b); // true

var c:Number = 5;
var d:String = "4";
trace(c > d); // true

var e: Number = 2;
var f:Boolean = true;
trace(e > f); // true

Compare deux expressions et détermine si expression1 est supérieure ou égale à expression2. (true) ou expression1 est inférieure à expression2 (false).

if (new Date().getHours() >= 12) { 
	trace("good afternoon"); 
} else { 
	trace("good morning"); 
}

Eléments de l’API associés

Evalue si une propriété fait partie d’un objet spécifique. Pour utiliser l’opérateur in, spécifiez un nom de propriété comme premier opérande et un objet comme second opérande. Si l’objet que vous spécifiez contient une telle propriété, le résultat est true. Il sera false dans tous les autres cas.

Si l’objet spécifié est un objet Array, vous pouvez utiliser l’opérateur in pour vérifier si un numéro d’index particulier est valide. Si vous transmettez un entier comme premier opérande, le résultat est true si l’index est compris dans la plage des numéros d’index valides, et false dans les autres cas.

trace("PI" in Math);         // true
trace("myProperty" in Math); // false

L’exemple suivant a recours à l’opérateur in pour indiquer que les nombres 0, 1 et 2 sont des numéros d’index valides dans l’objet myArray, contrairement au nombre 3.

public var myArray:Array = ["zero", "one", "two"];
trace(0 in myArray); // true
trace(1 in myArray); // true
trace(2 in myArray); // true
trace(3 in myArray); // false

Eléments de l’API associés

++expression

 expression++

Ajoute 1 à une expression. L’expression peut être une variable, un élément de tableau ou une propriété d’objet. La forme avant incrémentation de l’opérateur (++expression) ajoute 1 à expression et retourne le résultat. La forme après incrémentation de l’opérateur (expression++) ajoute 1 à expression et retourne la valeur initiale de expression (la valeur précédant l’addition).

var preInc:Array = new Array(); 
var i:int = 0; 
while (i < 10) { 
    preInc.push(++i); 
} 
trace(preInc); // 1,2,3,4,5,6,7,8,9,10 

 
var postInc:Array = new Array(); 
var i:int = 0; 
while (i < 10) { 
   postInc.push(i++); 
} 
trace(postInc); // 0,1,2,3,4,5,6,7,8,9 

var i:int = 0; 
while (i++ < 5) { 
	trace("this is execution " + i); 
} 
/* output: 
   this is execution 1 
   this is execution 2 
   this is execution 3 
   this is execution 4 
   this is execution 5 
*/

Teste l’inverse exact de l’opérateur d’égalité (==). Si expression1 est égale à expression2, le résultat est false. Comme avec l’opérateur d’égalité (==), la condition d’égalité dépend des types de données comparés.

Si les types de données de deux opérandes sont identiques, la condition d’égalité dépend du type de données des opérandes :

• Les valeurs de type int, uint et Boolean sont traitées comme étant égales si leurs valeurs sont identiques.
• Des nombres possédant des valeurs identiques sont considérés égaux, sauf s’ils sont tous les deux NaN.
• Si la valeur des deux opérandes est null ou undefined, ils sont traités comme étant égaux.
• Les expressions de chaîne sont égales si elles possèdent le même nombre de caractères et que ces derniers sont identiques.
• Pour des objets XML :
  • Si l’un des deux opérandes est un nœud de texte ou d’attribut et que l’autre est un contenu simple, les deux opérandes sont convertis en chaînes au moyen de la méthode toString() et considérés égaux si les chaînes résultantes sont identiques.
  • Dans le cas contraire, les objets sont égaux uniquement si leur nom qualifié, leurs attributs et leurs propriétés enfant correspondent.
• Les objets XMLList sont considérés égaux s’ils possèdent le même nombre de propriétés, et que l’ordre et les valeurs de ces propriétés sont identiques.
• Pour les types d’objet Namespace, les valeurs sont considérées égales si les propriétés uri des deux objets sont identiques.
• Pour les types d’objet QName, les valeurs sont considérées égales si les propriétés uri des deux objets sont identiques et que leurs propriétés localName le sont également.
• Les variables représentant des objets, des tableaux et des fonctions sont comparées par référence. Deux variables de ce type sont égales si elles font référence au même objet, au même tableau ou à la même fonction. Deux tableaux séparés ne sont jamais considérés comme égaux même s’ils possèdent le même nombre d’éléments.

• Les valeurs des opérandes sont undefined et null, auquel cas le résultat est true.
• La conversion automatique de type de données convertit les types de données des valeurs String, Boolean, int, uint et Number en types compatibles. Les valeurs converties sont égales, auquel cas les opérandes sont également considérés égaux.
• L’un des deux opérandes est du type XML avec du contenu simple (hasSimpleContent() == true), et une fois les deux opérandes convertis en chaîne au moyen de la méthode toString(), les chaînes résultantes sont identiques.
• L’un des opérandes est du type XMLList et l’une des deux conditions suivantes est vraie :
  • La propriété length de l’objet XMLList est 0, et l’autre objet est undefined.
  • La propriété length de l’objet XMLList est 1, et un élément de l’objet XMLList est identique à l’autre opérande.

trace(5 != 8); // true 
trace(5 != 5); // false 

var a:String = "David";
var b:String = "Fool";
if (a != b) { 
	trace("David is not a fool"); 
}

var a:Function = function() { trace("foo"); }; 
var b:Function = function() { trace("foo"); }; 
a(); // foo 
b(); // foo 
trace(a != b); // true 
a = b; 
a(); // foo 
b(); // foo 
trace(a != b); // false

var a:Array = [ 1, 2, 3 ]; 
var b:Array = [ 1, 2, 3 ]; 
trace(a);      // 1,2,3 
trace(b);      // 1,2,3 
trace(a != b); // true 
a = b; 
trace(a);      // 1,2,3 
trace(b);      // 1,2,3 
trace(a != b); // false

Eléments de l’API associés

Evalue si la chaîne de prototype d’une expression comprend l’objet prototype de function. L’opérateur instanceof permet la compatibilité ascendante avec ECMAScript édition 3 et peut s’avérer pratique pour les programmeurs expérimentés qui choisissent d’utiliser l’héritage par prototype avec des fonctions constructeur à la place des classes.

Pour vérifier si l’objet appartient à un type de données spécifique, utilisez l’opérateur is.

Lors d’une utilisation conjointe avec des classes, l’opérateur instanceof est similaire à l’opérateur is dans la mesure où la chaîne de prototype d’une classe inclut toutes ses superclasses. Les interfaces, cependant, ne sont pas incluses dans les chaînes de prototype, de sorte que l’opérateur instanceof renvoie toujours false lorsqu’il est utilisé avec des interfaces, tandis que l’opérateur is renvoie true si un objet appartient à une classe qui implémente l’interface spécifiée.

Remarque : l’opérateur ActionScript is est l’équivalent de l’opérateur Java instanceof.

var mySprite:Sprite = new Sprite();
trace(mySprite instanceof Sprite);        // true
trace(mySprite instanceof DisplayObject); // true

var mySprite:Sprite = new Sprite();
trace(mySprite instanceof IBitmapDrawable); // false
trace(mySprite is IBitmapDrawable);         // true

Eléments de l’API associés

Evalue si un objet est compatible avec un certain type de données ou une certaine classe ou interface. Utilisez l’opérateur is de préférence à l’opérateur instanceof pour les comparaisons de type. Vous pouvez également utiliser l’opérateur is pour vérifier si un objet implémente une interface.

import flash.display.*;
import flash.events.IEventDispatcher;

var mySprite:Sprite = new Sprite();
trace(mySprite is Sprite);           // true
trace(mySprite is DisplayObject);    // true
trace(mySprite is IEventDispatcher); // true

Eléments de l’API associés

Compare deux expressions et détermine si expression1 est supérieur à expression2. Dans l’affirmative, le résultat est true. Si expression1 est supérieure ou égale à expression2, le résultat est false.

Si les deux opérandes sont de type String, ils sont comparés en ordre alphabétique ; toutes les majuscules ont priorité sur les minuscules. Sinon, les opérandes sont d’abord convertis en nombres, puis comparés.

trace(5 < 10); // true 
trace(2 < 2);            // false 
trace(10 < 3);           // false 
trace("Allen" < "Jack"); // true 
trace("Jack" < "Allen"); // false 
trace("11" < "3");       // true 
trace("11" < 3);         // false (numeric comparison) 
trace("C" < "abc");      // true 
trace("A" < "a");        // true 

Compare deux expressions et détermine si expression1 est inférieur ou égal à expression2. Dans l’affirmative, le résultat est true. Si expression1 est supérieure à expression2, le résultat est false.

Si les deux opérandes sont de type String, ils sont comparés en ordre alphabétique ; toutes les majuscules ont priorité sur les minuscules. Sinon, les opérandes sont d’abord convertis en nombres, puis comparés.

trace(5 <= 10); // true 
trace(2 <= 2);            // true 
trace(10 <= 3);           // false 
trace("Allen" <= "Jack"); // true 
trace("Jack" <= "Allen"); // false 
trace("11" <= "3");       // true 
trace("11" <= 3);         // false (numeric comparison) 
trace("C" <= "abc");      // true 
trace("A" <= "a");        // true 

Indique le début d’un document de script. Les caractères qui apparaissent entre le délimiteur de commentaire (//) et le caractère de fin de ligne sont interprétés comme un commentaire et ignorés. Ce délimiteur s’applique à des commentaires sur une seule ligne. Pour les commentaires sur des lignes successives, utilisez les séparateurs /* et */.

// Any text following a line comment delimiter is ignored during compilation

Eléments de l’API associés

Renvoie expression1 s’il a la valeur false ou peut être converti en false et expression2 dans tous les autres cas. Parmi les valeurs qui peuvent être converties en false, figurent 0, NaN, null et undefined. Si vous utilisez un appel de fonction tel que expression2, la fonction n’est pas appelée si expression1 renvoie false.

Si les deux opérandes sont de type Boolean, le résultat n’est de true que si les deux opérandes sont true, comme dans le tableau suivant :

var turns:Number = 2; 
var score:Number = 77; 
if ((turns <= 3) && (score >= 75)) { 
	trace("You Win the Game!"); 
} else { 
	trace("Try Again!"); 
} 

Eléments de l’API associés

Affecte à expression1 la valeur de expression1 && expression2. Par exemple, les deux instructions suivantes sont équivalentes :

x &&= y; 
x = x && y;