Ajoute 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); // Nombre 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);

Voir aussi

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 

Voir aussi

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 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 > Donne la liste des Variables en mode test pour afficher la liste des éléments du tableau.*/ 

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]);
} 
/* Sortie de la boucle for : 
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]);
}
/* Sortie de la boucle for :
foo
bar */ 

Voir aussi

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

Voir aussi

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é 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; // en miles
trace(mercury.diameter); // 3030

var merkur:Object = mercury;
merkur.diameter = 4878;  // en kilomètres
trace(mercury.diameter); // 4878

Voir aussi

 myXML.@attributeName 

Identifie les attributs d'un objet XML ou XMLList. Par exemple : myXML.@id identifie les attributs appelés id pour l'objet XML myXML. Vous pouvez également employer la syntaxe suivante pour accéder aux attributs : myXML.attribute("id"), myXML["@id"] et myXML.@["id"]. La syntaxe myXML.@id est recommandé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()); // attribut
    trace(xml2[i].name());     // id et couleur
 } 

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

Voir aussi

Convertit expression1 et expression2 en entiers non signés de 32 bits, et exécute une opération Boolean ET 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 avec une valeur maximale de 4294967295 ou 0xFFFFFFFF ; une valeur supérieure au maximum perd ses chiffres les plus significatifs lorsqu'elle est convertie, de sorte que la valeur soit toujours de 32 bits. Un nombre négatif est converti en valeur hexadécimale non signée à l'aide de la notation complément à deux, avec une valeur minimale de -2147483648 ou 0x800000000 ; tout nombre inférieur à cette 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é en tant que nombre à complément à deux de 32 bits, de sorte que le résultat soit un entier compris entre -2147483648 et 2147483647.

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

  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 

Voir aussi

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 

Voir aussi

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 après la virgule. Un entier positif est converti en valeur hexadécimale non signée avec une valeur maximale de 4294967295 ou 0xFFFFFFFF ; une valeur supérieure au maximum perd ses chiffres les plus significatifs lorsqu'elle est convertie, de sorte que la valeur soit toujours de 32 bits. Un nombre négatif est converti en valeur hexadécimale non signée à l'aide de la notation complément à deux, avec une valeur minimale de -2147483648 ou 0x800000000 ; tout nombre inférieur à cette 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é en tant que nombre à complément à deux de 32 bits, de sorte que le résultat soit 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() empêche une erreur d'exécution

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 binaire == 0001 
// 8 binaire == 1000 
trace(1 << 3); // 8 

Voir aussi

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; 
// Décale tous les bits d'un emplacement vers la gauche. 
x <<= 1; 
trace(x); // 8 
// 4 décimal = 0100 binaire 
// 8 décimal = 1000 binaire 

Voir aussi

Convertit l'expression en un entier signé de 32 bits, puis applique un complément à un au niveau du bit. Ainsi, tout bit 0 devient 1 et inversement. Le résultat est un nouvel entier signé de 32 bits. Cet opérateur est également connu comme complément d'opérateur du 1 ou opérateur de complément au niveau du bit.

Par exemple, la valeur hexadécimale 0x7777 est représentée de la façon suivante en binaire :

0111011101110111

La négation au niveau du bit de cette valeur, ~0x7777, renvoie :

1000100010001000

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

Les opérateurs au niveau du bit sont principalement utilisés pour représenter les bits indicateurs (valeurs Boolean contractées sur 1 bit).

Un nombre à virgule flottante est converti en entier en supprimant tous les chiffres après la virgule. Un entier positif est converti en valeur hexadécimale non signée avec une valeur maximale de 4294967295 ou 0xFFFFFFFF ; une valeur supérieure au maximum perd ses chiffres les plus significatifs lorsqu'elle est convertie, de sorte que la valeur soit toujours de 32 bits. Un nombre négatif est converti en valeur hexadécimale non signée à l'aide de la notation complément à deux, avec une valeur minimale de -2147483648 ou 0x800000000 ; tout nombre inférieur à cette 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é en tant que nombre à complément à deux de 32 bits, de sorte que le résultat soit un entier compris entre -2147483648 et 2147483647.

var ReadOnlyFlag:int = 0x0001; // définit le bit 0 en tant qu'indicateur de lecture seule 
var flags:int = 0; 
trace(flags); 
/* Pour définir l'indicateur de lecture seule dans la variable flags, le code suivant utilise le OU au niveau du bit : 
*/
flags |= ReadOnlyFlag; 
trace(flags); 
/* Pour supprimer l'indicateur de lecture seule dans la variable flags, 
   créez un masque avec le SAUF au niveau du bit sur ReadOnlyFlag. 
   Dans le masque, tous les bits sont définis sur 1 sauf l'indicateur de lecture seule. 
   Ensuite, utilsez le ET au niveau du bit avec le masque pour supprimer l'indicateur de lecture seule. 
   Le code suivant crée le masque et applique le ET au niveau du bit : 
*/ 
flags &= ~ReadOnlyFlag; 
trace(flags); 
// 0 1 0 

Voir aussi

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

Un nombre à virgule flottante est converti en entier en supprimant tous les chiffres après la virgule. Un entier positif est converti en valeur hexadécimale non signée avec une valeur maximale de 4294967295 ou 0xFFFFFFFF ; une valeur supérieure au maximum perd ses chiffres les plus significatifs lorsqu'elle est convertie, de sorte que la valeur soit toujours de 32 bits. Un nombre négatif est converti en valeur hexadécimale non signée à l'aide de la notation complément à deux, avec une valeur minimale de -2147483648 ou 0x800000000 ; tout nombre inférieur à cette 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é en tant que nombre à complément à deux de 32 bits, de sorte que le résultat soit un entier compris entre -2147483648 et 2147483647.

// 15 décimal = 1111 binaire 
var a:Number = 15; 
// 9 décimal = 1001 binaire 
var b:Number = 9; 
// 1111 | 1001 = 1111 
trace(a | b); // renvoie 15 décimal (1111 binaire) 

Voir aussi

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

x |= y; 
x = x | y; 

// 15 décimal = 1111 binaire 
var a:Number = 15; 
// 9 décimal = 1001 binaire 
var b:Number = 9; 
// 1111 |= 1001 = 1111 
trace(a |= b); // renvoie 15 décimal (1111 binaire) 

Voir aussi

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 après la virgule. Un entier positif est converti en valeur hexadécimale non signée avec une valeur maximale de 4294967295 ou 0xFFFFFFFF ; une valeur supérieure au maximum perd ses chiffres les plus significatifs lorsqu'elle est convertie, de sorte que la valeur soit toujours de 32 bits. Un nombre négatif est converti en valeur hexadécimale non signée à l'aide de la notation complément à deux, avec une valeur minimale de -2147483648 ou 0x800000000 ; tout nombre inférieur à cette 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é en tant que nombre à complément à deux de 32 bits, de sorte que le résultat soit 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)

Voir aussi

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++) { 
        // Extrait le dernier bit significatif avec le ET au niveau du bit. 
        var lsb:Number = numberToConvert & 1; 
        // Ajoute ce bit au résultat.
        result = (lsb ? "1" : "0")+result; 
        // Décale numberToConvert vers la droite d'un bit, pour afficher le bit suivant. 
        numberToConvert >>= 1; 
    } 
    return result; 
} 
trace(convertToBinary(479)); 
// Renvoie la chaîne 00000000000000000000000111011111. 
// Cette chaîne est la représentation binaire du nombre décimal 479.

Voir aussi

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 après la virgule. Un entier positif est converti en valeur hexadécimale non signée avec une valeur maximale de 4294967295 ou 0xFFFFFFFF ; une valeur supérieure au maximum perd ses chiffres les plus significatifs lorsqu'elle est convertie, de sorte que la valeur soit toujours de 32 bits. Un nombre négatif est converti en valeur hexadécimale non signée à l'aide de la notation complément à deux, avec une valeur minimale de -2147483648 ou 0x800000000 ; tout nombre inférieur à cette 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 

Voir aussi

Effectue un décalage droite 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 

Voir aussi

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

Un nombre à virgule flottante est converti en entier en supprimant tous les chiffres après la virgule. Un entier positif est converti en valeur hexadécimale non signée avec une valeur maximale de 4294967295 ou 0xFFFFFFFF ; une valeur supérieure au maximum perd ses chiffres les plus significatifs lorsqu'elle est convertie, de sorte que la valeur soit toujours de 32 bits. Un nombre négatif est converti en valeur hexadécimale non signée à l'aide de la notation complément à deux, avec une valeur minimale de -2147483648 ou 0x800000000 ; tout nombre inférieur à cette 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é en tant que nombre à complément à deux de 32 bits, de sorte que le résultat soit un entier compris entre -2147483648 et 2147483647.

// 15 décimal = 1111 binaire  
// 9 décimal = 1001 binaire 
var a:Number = 15 ^ 9; 
trace(a); 
// 1111 ^ 1001 = 0110 
// renvoie 6 décimal (0110 binaire) 

Voir aussi

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

x ^= y 
x = x ^ y 

// 15 décimal = 1111 binaire 
var a:Number = 15; 
// 9 décimal = 1001 binaire 
var b:Number = 9; 
trace(a ^= b); // renvoie 6 décimal (0110 binaire) 

Voir aussi

/* commentaire */

/* commentaire

   commentaire */

Délimite une ou plusieurs lignes de commentaires de script. Les caractères qui s'affichent entre le premier (/*) et le dernier séparateur (*/) sont interprétés comme des commentaires et sont ignorées par le compilateur d'ActionScript. Pour délimiter plusieurs lignes successives de commentaires, utilisez ces séparateurs ; pour une seule ligne, choisissez le délimiteur //.

Si vous omettez le séparateur de bloc de commentaires fermant (*/) ou si vous tentez d'imbriquez des commentaires, vous obtiendrez un message d'erreur. Lorsque vous utilisez un séparateur ouvrant (/*), le premier séparateur fermant (*/) suivant termine le commentaire, quel que soit le nombre de séparateurs ouvrant placés avant lui.

/* Enregistre les coordonnées X et Y de la balle et de la batte 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; 

/* Tentative d'imbrication des commentaires. 
/* Cependant, la première balise fermante sera associée à la première balise ouvrante 
et ce texte ne peut pas être interprété comme un commentaire */ 

Voir aussi

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

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>

Voir aussi

 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"]);

Voir aussi

Evalue expression1, puis expression2, et ainsi de suite. Cet opérateur est utilisé principalement avec l'instruction for loop et est généralement utilisé avec l'opérateur parenthèses ().

for (i = 0, j = 0; i < 3 && j < 3; i++, j+=2) { 
    trace("i = " + i + ", j = " + j); 
} 
// renvoie : 
// 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 

Voir aussi

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 ce 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); // Nombre 80

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

Voir aussi

expression1 + expression2

Concatène (combine) des valeurs XML ou XMLList dans un objet XMLList. Un objet XMLList est renvoyé 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>
    

Voir aussi

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 

Voir aussi

expression1 += expression2

Affecte à expression1, qui est un objet XMLList, la valeur 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>

Voir aussi

expression1 ? expression2 : expression3

Evalue expression1, et si la valeur de expression1 est true, le résultat reprend la valeur de expression2. Sinon, le résultat reprend la valeur de expression3.

var x:Number = 5; 
var y:Number = 10; 
var z = (x < 6) ? x: y; 
trace(z); // renvoie 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); 

Voir aussi

--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) soustraie 1 de expression et renvoie le résultat. La forme après décrémentation de l'opérateur (expression--) soustraie 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); 
}

Voir aussi

 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) // renvoie : undefined,undefined,ghi

Voir aussi

 delete reference

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

Lorsqu'il est utilisé avec un opérande XMLList, le résultat de l'opérateur delete est toujours true, car l'opérande XMLList fait toujours référence à un objet XMLList valide (qui peut être vide).

 
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

Voir aussi

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

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

Voir aussi

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 

Voir aussi

object.property_or_method

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

import flash.utils.Timer;

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

Voir aussi

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 car plusieursXMLList éléments enfant ou attribut peuvent correspondre.

Pour renvoyer les éléments dont les noms correspondent Mots réservés d'ActionScript, utilisez la méthode XML.elements() ou XML.descendants() à la place du point XML (.) opérateur, comme indiqué 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

Voir aussi

Vérifie si deux expressions sont égales. Le résultat est true lorsque les expressions sont égales.

Si les types de données des deux opérandes correspondent, la définition d'égalité dépend du type de données des opérandes :

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

• Les valeurs de l'opérande sont undefined et null, auquel cas le résultat est true.
• La conversion automatique du type de données convertit les valeurs des types String, Boolean, int, uint et Number en types compatibles et les valeurs converties sont égales, auquel cas les opérandes sont considérés comme égaux.
• Un opérande est de type XML avec un contenu simple (hasSimpleContent() == true). Les deux opérandes sont ensuite converties en chaîne avec la méthode toString(), ce qui permet d'obtenir des chaînes concordantes.
• Un opérande est de type XMLList et l'une des deux conditions suivantes est true :
  • La propriété length de l'objet XMLList est 0, et l'autre objet est undefined.
  • La valeur de la propriété length de l'objet XMLList est 1 et un élément de l'objet XMLList correspond à 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 

Voir aussi

Compare deux expressions et détermine si expression1 est supérieur à expression2. Dans l'affirmative, le résultat est true. Si expression1 est supérieur ou égal à 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 tout 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étermines si expression1 est supérieur ou égal à expression2 (true), ou si expression1 est inférieur à expression2 (false).

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

Voir aussi

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

Voir aussi

++expression

 expression++

Ajoute 1 à une expression. L'expression peut être une variable, un élément de tableau ou une propriété objet. La forme pré-incrément de l'opérateur (++expression) ajoute 1 à expression et renvoie le résultat. La forme post-incrément de l'opérateur (expression++) ajoute 1 à expression et renvoie la valeur initiale de expression (avant 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 
*/

Voir aussi

Recherche l'inverse de l'opérateur d'égalité (==). Si expression1 est égal à expression2, le résultat est false. Comme pour l'opérateur d'égalité (==), la définition de l'égalité dépend des types de données comparés.

Si les types de données des deux opérandes correspondent, la définition d'égalité dépend du type de données des opérandes :

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

• Les valeurs de l'opérande sont undefined et null, auquel cas le résultat est true.
• La conversion automatique du type de données convertit les valeurs des types String, Boolean, int, uint et Number en types compatibles et les valeurs converties sont égales, auquel cas les opérandes sont considérés comme égaux.
• Un opérande est de type XML avec un contenu simple (hasSimpleContent() == true). Les deux opérandes sont ensuite convertis en chaîne avec la méthode toString(), ce qui permet d'obtenir des chaînes concordantes.
• Un opérande est de type XMLList et l'une des deux conditions suivantes est true :
  • La propriété length de l'objet XMLList est 0, et l'autre objet est undefined.
  • La valeur de la propriété length de l'objet XMLList est 1 et un élément de l'objet XMLList correspond à 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

Voir aussi

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

Voir aussi

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

Voir aussi

Compare deux expressions et détermine si expression1 est inférieur à expression2. Dans l'affirmative, le résultat est true. Si expression1 est supérieur ou égal à 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 tout 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érieur à 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 tout 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 

Signale le début d'un commentaire de script. Les caractères qui apparaissent entre le séparateur de commentaires (//) et le caractère de fin de ligne sont interprétés en tant que commentaires et ignorés. Utilisez ce séparateur pour les commentaires d'une ligne. Pour les commentaires sur plusieurs lignes, utilisez les séparateurs /* et */.

// Tout texte suivant un séparateur de ligne de est ignoré 
pendant la compilation

Voir aussi

Renvoie expression1 s'il a la valeur false ou peut être converti en false, 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!"); 
} 

Voir aussi

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); // renvoie : <tag/>

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

Voir aussi

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

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

• !true renvoie false.
• !false renvoie true.

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

Voir aussi

Renvoie expression1 s'il a la valeur true ou peut être converti en true, 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.

Lorsque les deux opérandes sont de type Boolean, le résultat est true si au moins l'une des expression a la valeur true. Le résultat n'est de false que si les deux expressions sont false, comme indiqué dans la table suivante :

var a:Number = 10; 
var b:Number = 250; 
var start:Boolean = false; 
if ((a > 25) || (b > 200) || (start)) { 
    trace("the OU logique test passed"); // the OU logique 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");
}

Voir aussi

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

x ||= y; 
x = x || y; 

myVar ||= "default";

Voir aussi

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 

Voir aussi

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 

Voir aussi

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 

Voir aussi

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 

Voir aussi

namespace::property

namespace::method()

namespace::xmlObject.property

namespace::xmlObject.@attribute

Permet d'identifier l'espace de nom d'une propriété, d'une méthode, d'une propriété 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

Voir aussi

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

L'opérateur new peut également être utilisé pour associer une classe à un actif intégré, c'est-à-dire un objet externe comme une image, un son ou une police, compilé dans un fichier SWF. Chaque ressource intégrée est représentée par une classe de ressources intégrées unique. Pour accéder à une ressource intégrée, vous devez utiliser l'opérateur new pour créer une occurrence de la classe associée. Ensuite, vous pouvez appeler les propriétés et méthodes appropriées de la classe de la ressource intégrée pour manipuler celle-ci.

Si vous préférez définir des classes avec des objets Function au lieu du mot clé class, utilisez l'opérateur new pour créer des objets selon des fonctions constructeur. Ne confondez pas les fonctions constructeur avec les méthodes constructeur d'une classe. Une fonction constructeur est un objet Function qui est défini avec le mot clé function, mais qui ne fat pas partie de la définition d'une classe. Si vous utilisez des fonctions constructeur pour créer des objets, vous devez choisir l'héritage par prototype au lieu de l'héritage de classe.

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);

Voir aussi

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'utilisation de cet opérateur a le même effet que la syntaxe new Object et le renseignement 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"; 

Voir aussi

(expression1[, expression2])

(expression1, expression2)

function(parameter1,..., parameterN) 

Regroupe un ou plusieurs paramètres, évalue les expressions de façon séquentielle ou entoure un ou plusieurs paramètres et les transmet en tant qu'arguments à une fonction placée avant 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 l'évaluation des expressions entre parenthèses en premier. Lorsque des parenthèses sont imbriquées, le contenu de celles de plus bas niveau est évalué en premier.

Utilisation 2 : Evalue une série d'expressions, séparées par des virgules, dans l'ordre 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()); // renvoie l'année en cours  
function traceParameter(param):void { 
  trace(param); 
} 
traceParameter(2 * 2); // 4 

Voir aussi

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

Voir aussi

/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 

Voir aussi

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 nombres et les valeurs Boolean sont considérés comme égaux lorsque leurs valeurs sont identiques.
• Les expressions de type String sont égales lorsqu'elles comportent le même nombre de caractères et que ces caractères sont identiques.
• Les variables représentant des objets, des tableaux et des fonctions sont comparées par référence. Deux variables sont égales lorsqu'elles font référence au même objet, au même tableau ou à la même fonction. Deux tableaux distincts ne sont jamais considérés comme égaux, même s'ils comportent le même nombre d'éléments.

• L'opérateur d'égalité stricte n'exécute une conversion automatique des données que pour les types numériques : (Number, int et uint). A l'inverse, l'opérateur d'égalité () exécute une conversion automatique des données pour tous les types primitifs.
• Lors de la comparaison de 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

// L'opérateur d'égalité (==) convertit 5 en "5", contrairement à l'opérateur d'égalité stricte
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 

Voir aussi

Recherche l'inverse exact de l'opérateur d'égalité stricte (===). L'opérateur d'inégalité stricte fonctionne de la même façon que l'opérateur d'inégalité, à la différence que seuls les types de données int et uint sont convertis.

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

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

• Les nombres et les valeurs Boolean sont considérés comme égaux lorsque leurs valeurs sont identiques.
• Les expressions de type String sont égales lorsqu'elles comportent le même nombre de caractères et que ces caractères sont identiques.
• Les variables représentant des objets, des tableaux et des fonctions sont comparées par référence. Deux variables sont égales lorsqu'elles font référence au même objet, au même tableau ou à la même fonction. Deux tableaux distincts ne sont jamais considérés comme égaux, même s'ils comportent le même nombre d'éléments.

• L'opérateur d'inégalité stricte (!==) n'exécute une conversion automatique des données que pour les types numériques : Number, int et uint. A l'inverse, l'opérateur d'inégalité (!=) exécute une conversion automatique des données pour tous les types primitifs.
• Lors de la comparaison de null et undefined, l'opérateur d'inégalité stricte (!==) renvoie 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 

Voir aussi

 "text" 

Lorsqu'ils entourent des caractères, indiquent que ces caractères ont une valeur littérale et sont considérés comme une 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

Voir aussi

-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 : Pour la soustraction, l'opérateur effectue une soustraction arithmétique sur les 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 

Voir aussi

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 

Voir aussi

[modifiers] var variableName:type

function functionName():type { ... }

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

Utilisé pour affecter un type aux données ; cet opérateur spécifie le type de variable, le type de renvoi de la fonction ou le type de paramètre de la fonction. Lorsqu'il est utilisé dans une déclaration une affectation de variable, cet opérateur spécifie le type de variable. Lorsqu'il fait partie d'une déclaration ou d'une définition de fonction, cet opérateur spécifie le type de renvoi de la fonction. Lorsqu'il est utilisé avec un paramètre de fonction dans une définition de fonction, cet opérateur spécifie le type de variable attendu pour ce paramètre.

La vérification du type se produit toujours à l'exécution. Toutefois, lorsque le compilateur est réglé sur le mode strict, tous les types sont également vérifiés à la compilation et des erreurs sont générées en cas d'incompatibilités. Les incompatibilités peuvent se produire pendant les opérations d'affectation, les appels de fonction et les ruptures de référence des membres de classe avec l'opérateur (.).

Les types utilisables incluent tous les types d'objet natifs, les classes et les interfaces que vous avez définis, ainsi que void. Les types natifs reconnus sont Boolean, Number, int, uint et String. Toutes les classes intégrées sont également prises en charge en tant que types natifs.

Si vous n'affectez aucun type aux données, la variable, valeur renvoyée par la fonction ou paramètre de fonction, est considérée comme étant sans type, ce qui signifie qu'elle peut être de tout type. Si vous souhaitez indiquer clairement votre intention d'utiliser une valeur sans type, utilisez le caractère (*) astérisque comme annotation de type. Utilisé comme annotation de type, le caractère astérisque revient à laisser une variable, valeur renvoyée par la fonction ou 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)); 

Voir aussi

Evalue expression et renvoie une chaîne spécifiant son type de données. Le résultat est limité à six valeurs de chaînes possibles : booleanfunctionnumberobjectstringxml. 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);     // nombre

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

Voir aussi

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.

Voir aussi

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

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

Voir aussi