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; 

var myVar:String = 'tag';
			myVar &&= "<" + myVar + "/>";
			trace (myVar); // output: <tag/>

var myVar:String = 'tag';
			if (myVar != '') {
			  myVar = "<" + myVar + "/>";
			}
			trace (myVar); // output: <tag/>

Eléments de l’API associés

Inverse la valeur Boolean d’une variable ou d’une expression. Si expression est une variable avec la valeur absolue ou convertie true, la valeur de !expression est false. Si l’expression x && y prend la valeur false, l’expression !(x && y) prend la valeur true.

Les expressions suivantes illustrent le résultat de l’utilisation de l’opérateur logique NOT (!) :

• !true renvoie la valeur false.
• !false renvoie la valeur true.

var happy:Boolean = false; 
if (!happy) { 
	trace("don't worry, be happy"); // don't worry, be happy 
} 

Eléments de l’API associés

Renvoie expression1 s’il a la valeur true ou peut être converti en true et expression2 dans tous les autres cas. Si vous utilisez un appel de fonction tel que expression2, la fonction n’est pas appelée si expression1 renvoie true.

Si les deux opérandes sont de type Boolean, le résultat n’est de true si au moins l’une des expressions a la valeur true. Le résultat n’est de false que si les deux expressions sont false, comme indiqué dans le tableau suivant :

var a:Number = 10; 
var b:Number = 250; 
var start:Boolean = false; 
if ((a > 25) || (b > 200) || (start)) { 
    trace("the logical OR test passed"); // the logical OR test passed 
} 

L’exemple suivant illustre la façon dont des résultats inattendus peuvent être obtenus si vous utilisez un appel de fonction en deuxième opérande. Si l’expression à gauche de l’opérateur renvoie true, ce résultat est renvoyé sans évaluer l’expression de droite (la fonction fx2() n’est pas appelée).

function fx1():Boolean { 
	trace("fx1 called"); 
	return true; 
} 
function fx2():Boolean { 
	trace("fx2 called"); 
	return true; 
} 
if (fx1() || fx2()) { 
	trace("IF statement entered");
}

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; 

myVar ||= "default";

Eléments de l’API associés

Calcule le reste de expression1 divisé par expression2. Si l’un des opérandes n’est pas numérique, l’opérateur modulo (%) tente de le convertir en nombre.

Le signe du résultat de l’opération modulo correspond au signe du dividende (le premier nombre). Par exemple, -4 % 3 et -4 % -3 renvoient tous deux -1.

trace(12 % 5);    // 2 
trace(4.3 % 2.1); // 0.0999999999999996 
trace(4 % 4);     // 0 

Eléments de l’API associés

Affecte à expression1 la valeur de expression1 % expression2. Les deux instructions suivantes sont équivalentes :

x %= y; 
x = x % y; 

var a:Number = 14; 
var b:Number = 5; 
a %= b;
trace(a); // 4 

Eléments de l’API associés

Multiplie deux expressions numériques. Lorsque les deux expressions sont des entiers, le produit est un entier. Lorsque l’une ou les deux expressions sont des nombres à virgule flottante, le produit est un nombre à virgule flottante.

trace(2*3); // 6 

trace(2.0 * 3.1416); // 6.2832 

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

x *= y 
x = x * y 

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

var i:Number = 5; 
var c:Number = 4 - 6; 
var d:Number = i + 2; 
trace(c *= d); // -14 

Eléments de l’API associés

namespace::property

namespace::method()

namespace::xmlObject.property

namespace::xmlObject.@attribute

Identifie l’espace de noms d’une propriété, d’une méthode, d’une propriété XML ou d’un attribut XML.

public class NamespaceExample extends Sprite {
	public namespace French;
	public namespace Hawaiian;
	public function NamespaceExample() {
		trace(Hawaiian::hello()); // aloha
		trace(French::hello()); // bonjour
	}
    Hawaiian function hello():String {
        return "aloha";
    }

    French function hello():String { 
        return "bonjour";
    }
}

var soap:Namespace = new Namespace("http://schemas.xmlsoap.org/wsdl/soap/");
var w:Namespace = new Namespace("http://weather.example.org/forecast");
var myXML:XML = 
	<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/"> 
	 <soap:Body>
	  <w:forecast xmlns:w="http://weather.example.org/forecast">
	   <w:city>Quito</w:city>
	   <w:country>Ecuador</w:country>
	   <date>2006-01-14</date>
	  </w:forecast>
	  </soap:Body>
	</soap:Envelope>;
	
trace(myXML.soap::Body.w::forecast.w::city); // Quito

Eléments de l’API associés

Instancie une occurrence de classe. L’opérateur new peut être utilisé avec une classe ou une variable du type Class pour créer une occurrence d’une classe. L’opérateur new est couramment utilisé avec un objet de classe pour créer une occurrence d’une classe. Par exemple, l’instruction new Sprite() crée une occurrence de la classe Sprite.

Vous pouvez également utiliser l’opérateur new pour associer une classe à une ressource incorporée, laquelle peut être un objet externe, tel qu’une image, une police ou du son, compilé dans un fichier SWF. Chaque ressource incorporée est représentée par une classe de ressource incorporée. Pour accéder à une ressource incorporée, il convient de faire appel à l’opérateur new pour instancier la classe qui lui est associée. Par la suite, vous pouvez appeler les méthodes et propriétés appropriées de la classe de ressource incorporée pour manipuler la ressource en question.

Si vous préférez définir des classes avec des objets Function à la place du mot-clé class, utilisez l’opérateur new pour créer des objets basés sur des fonctions de constructeur. Ne confondez pas fonctions de constructeurs et méthodes de constructeur pour une classe. Une fonction constructeur est un objet Function défini avec le mot-clé function, mais qui ne fait pas partie d’une définition de classe. Si vous utilisez des fonctions constructeur pour créer des objets, vous devez utiliser un prototype hérité à la place d’une classe héritée.

class Book {
  var bName:String;
  var bPrice:Number;
  
  public function Book(nameParam:String, priceParam:Number){
    bName = nameParam;
    bPrice = priceParam;
  }
}

var book1:Book = new Book("Confederacy of Dunces", 19.95);
var book2:Book = new Book("The Floating Opera", 10.95);
trace(book1); // [object Book]

var golfCourse:Array = new Array(18);

Eléments de l’API associés

object = {name1 : value1, name2 : value2,... nameN : valueN}

Crée un objet et l’initialise avec les paires de propriétés name et value spécifiées. L’application de cet opérateur revient à utiliser la syntaxe new Object et à saisir des paires de propriétés avec l’opérateur d’affectation. Le prototype du nouvel objet est génériquement appelé Object.

Cet opérateur est également utilisé pour marquer des blocs de code contigu associés avec des instructions de contrôle du flux (for, while, if, else, switch) et des fonctions.

var object:Object = {}; 
var object:Object = new Object(); 

var account:Object = {name:"Adobe Systems, Inc.", address:"601 Townsend Street", city:"San Francisco", state:"California", zip:"94103", balance:"1000"}; 
for (i in account) { 
	trace("account."+i+" = "+account[i]); 
} 

var person:Object = {name:"Gina Vechio", children:["Ruby", "Chickie", "Puppa"]}; 

var person:Object = new Object(); 
person.name = "Gina Vechio"; 
person.children = new Array(); 
person.children[0] = "Ruby"; 
person.children[1] = "Chickie"; 
person.children[2] = "Puppa"; 

Eléments de l’API associés

(expression1[, expression2])

(expression1, expression2)

function(parameter1,..., parameterN) 

Effectue une opération de regroupement sur un ou plusieurs paramètres, calcule les expressions de façon séquentielle ou entoure un ou plusieurs paramètres et les transmet en tant qu’arguments à une fonction précédant les parenthèses.

Utilisation 1 : contrôle l’ordre d’exécution des opérateurs. Les parenthèses remplacent la séquence normale et entraînent le calcul des expressions entre parenthèses en premier. Lorsque des parenthèses sont imbriquées, le contenu entre les parenthèses les plus à l’intérieur est calculé en premier.

Utilisation 2 : évalue dans l’ordre une série d’expressions séparées par des virgules et renvoie le résultat de l’expression finale.

Utilisation 3 : entoure un ou plusieurs paramètres et les transmet à la fonction qui précède les parenthèses.

trace((2 + 3) * (4 + 5)); // 45 
trace(2 + (3 * (4 + 5))); // 29
trace(2 + (3 * 4) + 5);   // 19
trace(2 + (3 * 4) + 5);   // 19

var a:Number = 1; 
var b:Number = 2; 
function foo() { 
  a += b; 
} 
function bar() { 
  b *= 10; 
} 
trace((foo(), bar(), a + b)); // 23 

var today:Date = new Date(); 
trace(today.getFullYear()); // outputs current year 
function traceParameter(param):void { 
  trace(param); 
} 
traceParameter(2 * 2); // 4 

Eléments de l’API associés

myXML.(expression)

Evalue une expression dans du code ECMAScript pour une construction XML (E4X). Par exemple, myXML.(lastName == "Smith") identifie les éléments XML appelés lastName et la valeur "Smith". Le résultat est un objet XMLList.

var myXML:XML = 
	<employees>
		<employee id = "42">
			<firstName>Joe</firstName>
			<lastName>Smith</lastName>
		</employee>
		<employee id = "43">
			<firstName>Susan</firstName>
			<lastName>Jones</lastName>
		</employee>
		<employee id = "44">
			<firstName>Anne</firstName>
			<lastName>Smith</lastName>
		</employee>
	</employees>;
	
trace(myXML.employee.(lastName == "Smith").@id.toXMLString()); 
	// 42
	// 44
                
trace(myXML.employee.(Number(@id) > 42).@id.toXMLString()); 
	// 43
	// 44

Eléments de l’API associés

/pattern/flags

Lorsqu’ils entourent des caractères, indiquent que ceux-ci ont une valeur littérale et doivent être traités en tant qu’expression régulière (RegExp) et non pas en tant que variable, chaîne ou tout autre élément ActionScript. Cependant, sachez que deux caractères de barre oblique (//) indiquent le début d’un commentaire.

var myRegExp:RegExp = /foo-\d+/i; 
trace(myRegExp.exec("ABC Foo-32 def.")); // Foo-32 

Eléments de l’API associés

Teste l’égalité de deux expressions, mais sans conversion automatique des données. Le résultat est true lorsque les deux expressions sont égales, types de données inclus.

L’opérateur d’égalité stricte (===) est identique à l’opérateur d’égalité (==) de trois façons :

• les types Numbers et Boolean sont comparés par valeur et sont considérés égaux s’ils ont la même valeur.
• Les expressions de chaîne sont égales si elles possèdent le même nombre de caractères et que ces derniers sont identiques.
• 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.

• L’opérateur d’inégalité stricte effectue une conversion automatique de données uniquement pour les types numériques (Number, int et uint), tandis que l’opérateur d’inégalité l’effectue pour tous les types de données primitifs.
• Lorsque vous comparez null et undefined, l’opérateur d’égalité stricte renvoie false.

Tout d’abord, les comparaisons entre les valeurs et les objets primitifs qui contiennent la même valeur renvoient true dans ActionScript 3.0, mais false dans les versions précédentes. Dans les versions précédentes, le type de données d’une valeur primitive est Boolean, Number ou String, vu que le type de données d’un objet primitif est toujours Object et non Boolean, Number ou String. L’effet concret de cette différence est que le code suivant a pour résultat false dans les versions précédentes d’ActionScript, car les types de données des opérandes ne concordent pas, mais le résultat est true dans ActionScript 3.0, dans la mesure où les valeurs primitives sont typées comme Boolean, Number, int, uint ou String, qu’elles soient englobées dans un objet ou non.

var num1:Number = 1;
var num2:Number = new Number(1);
trace(num1 === num2); // true in ActionScript 3.0, false in ActionScript 2.0
			

var num1:Number = new Number(1);
var num2:Number = new Number(1);
trace(num1 == num2);  // true in ActionScript 3.0, false in ActionScript 2.0
trace(num1 === num2); // true in ActionScript 3.0, false in ActionScript 2.0

var string1:String = "5"; 
var string2:String = "5"; 
trace(string1 == string2);  // true 
trace(string1 === string2); // true

// The equality (==) operator converts 5 to "5", but the strict equality operator does not
var string1:String = "5"; 
var num:Number = 5; 
trace(string1 == num);  // true 
trace(string1 === num); // false 

var num:Number = 1;
var bool:Boolean = true;
trace(num == bool);  // true 
trace(num === bool); // false

var num1:Number = 1;
var num2:int = 1;
var num3:uint = 1;
trace(num1 === num2); // true
trace(num1 === num3); // true

trace(null == undefined);  // true 
trace(null === undefined); // false 

Eléments de l’API associés

Teste l’inverse exact de l’opérateur d’égalité stricte (==). L’opérateur d’inégalité stricte a le même effet que l’opérateur d’inégalité, à la différence que les types de données int et uint sont convertis.

Si expression1 est égal à expression2 et que leurs types de données sont identiques, le résultat est false.

L’opérateur d’inégalité stricte (!==) est similaire à l’opérateur d’inégalité (!=) sous trois aspects :

• les types Numbers et Boolean sont comparés par valeur et sont considérés égaux s’ils ont la même valeur.
• Les expressions de chaîne sont égales si elles possèdent le même nombre de caractères et que ces derniers sont identiques.
• 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.

• L’opérateur d’inégalité stricte (!==) effectue une conversion automatique de données uniquement pour les types Number, int et uint, tandis que l’opérateur d’inégalité (!=) l’effectue pour tous les types de données primitifs.
• Dans une comparaison null et undefined, l’opérateur d’inégalité stricte (!==) renvoie la valeur true.

var s1:String = "5"; 
var s2:String = "5"; 
var s3:String = "Hello"; 
var n:Number = 5; 
var b:Boolean = true; 
trace(s1 == s2);  // true 
trace(s1 == s3);  // false 
trace(s1 == n);   // true 
trace(s1 == b);   // false 
trace(s1 === s2); // true 
trace(s1 === s3); // false 
trace(s1 === n);  // false 
trace(s1 === b);  // false 
trace(s1 !== s2); // false 
trace(s1 !== s3); // true 
trace(s1 !== n);  // true 
trace(s1 !== b);  // true 

Eléments de l’API associés

 "text" 

Lorsqu’ils entourent des caractères, les guillemets (") indiquent que ces caractères ont une valeur littérale et doivent être traités en tant que chaîne et non pas en tant que variable, valeur numérique ou tout autre élément ActionScript.

var yourGuess:String = "Prince Edward Island"; 
submit_btn.onRelease = function() { trace(yourGuess); }; 
// Prince Edward Island

Eléments de l’API associés

-expression

 expression1 - expression2

Utilisé pour la négation ou la soustraction.

Utilisation 1 : pour la négation, l’opérateur inverse le signe d’une expression numérique.

Utilisation 2 : lorsqu’il est utilisé pour la soustraction, l’opérateur effectue une soustraction arithmétique sur deux expressions numériques, en soustrayant expression2 de expression1. Lorsque les deux expressions sont des entiers, la différence est un entier. Lorsque l’une ou les deux expressions sont des nombres à virgule flottante, la différence est un nombre à virgule flottante.

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

trace(5 - 2); // 3 

L’instruction suivante soustrait le nombre à virgule flottante 1,5 du nombre à virgule flottante 3,25 :

trace(3.25 - 1.5); // 1.75 

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

x -= y ;
x = x - y;

Les expressions de type chaîne doivent être converties en nombres. Sinon, le résultat est NaN (non numérique).

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

var x:String = "5"; 
var y:String = "10"; 
x -= y; 
trace(x); // -5 

Eléments de l’API associés

[modifiers] var variableName:type

function functionName():type { ... }

function functionName(parameter1:type, ..., parameterN:type) [:type]{ ... } 

Utilisé pour l’affectation d’un type de données ; cet opérateur définit le type de variable, de renvoi de fonction ou de paramètre de fonction. Lorsqu’il est utilisé dans une déclaration ou une affectation de variable, cet opérateur spécifie le type de variable. S’il est utilisé dans une déclaration ou une définition de fonction, il définit le type de renvoi de la fonction. S’il est employé avec un paramètre de fonction dans une définition de fonction, cet opérateur indique le type de variable, sauf pour ce paramètre.

La vérification du type est toujours effectuée au moment de l’exécution. Toutefois, si le compilateur est défini sur le mode strict, tous les types sont également vérifiés au moment de la compilation, et des erreurs sont générées si des types ne correspondent pas. Cette situation peut se produire avec des opérations d’affectation, des appels de fonction et la déréférenciation de membres à l’aide de l’opérateur point (.).

Les types que vous pouvez utiliser sont notamment les types d’objet natifs, les classes et les interfaces que vous définissez, ainsi que le type void. Les types natifs reconnus sont Boolean, Number, int, uint et String. Toutes les classes prédéfinies sont également prises en charge en tant que types natifs.

Si vous n’avez pas affecté de type de données, la variable, la valeur de renvoi de fonction ou le paramètre de fonction est traité comme étant sans type, ce qui implique qu’il ou elle n’est associé(e) à aucun type de données. Si vous souhaitez vraiment utiliser une valeur sans type, entrez un astérisque (*) comme annotation de type. L’utilisation de l’astérisque comme annotation de type revient à laisser une variable, une valeur de renvoi de fonction ou un paramètre de fonction sans type.

var userName:String = ""; 

function randomInt(integer:int):int { 
	return Math.round(Math.random()*integer); 
} 
trace(randomInt(8)); 

function squareRoot(val:Number):Number { 
	return Math.sqrt(val); 
} 
trace(squareRoot(121)); 

Eléments de l’API associés

Evalue expression et renvoie une chaîne spécifiant son type de données. Le résultat est limité à six valeurs de chaîne possibles : boolean, function, number, object, string et xml. Si vous appliquez cet opérateur à une occurrence de classe définie par l’utilisateur, le résultat est la chaîne object. L’opérateur typeof permet la compatibilité ascendante. Utilisez l’opérateur is pour vérifier la compatibilité des types de données.

trace(typeof Array); // object
trace(typeof Date);  // object
trace(typeof 3);     // number

var a:String = "sample";
var b:String = new String("sample");
trace(typeof a); // string
trace(typeof b); // string 

Eléments de l’API associés

Evalue une expression, puis supprime sa valeur en renvoyant undefined. L’opérateur void est souvent employé dans les comparaisons qui utilisent l’opérateur == pour tester les valeurs non définies.

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

Définit une balise XML dans un littéral XML. Utilisez la barre oblique / pour définir la balise fermante.

var x:XML = <item id= "324">cola</item>; 

Eléments de l’API associés