Operatori 

Aggiunge le espressioni numeriche. Se entrambe le espressioni sono numeri interi, la somma è un numero intero; se almeno una delle due espressioni è un numero a virgola mobile, la somma è un numero a virgola mobile.

Se una delle espressioni è una stringa, tutte le altre espressioni vengono convertite in stringhe e concatenate anziché sommate. Altrimenti, se un’espressione non è un numero, Flash^® Player la converte in un numero.

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

Elementi API correlati

Assegna a expression1 il valore di expression1 + expression2. Ad esempio, le due istruzioni seguenti danno lo stesso risultato:

x += y; 
x = x + y; 

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

Elementi API correlati

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

Inizializza un nuovo array o un array multidimensionale con gli elementi specificati (a0 e così via) oppure accede agli elementi di un array. L’operatore di accesso agli array consente di impostare e recuperare in modo dinamico nomi di istanza, variabili e oggetti, e di accedere alle proprietà dell’oggetto.

Uso 1: un array è un oggetto le cui proprietà sono definite elementi, ciascuno identificato mediante un numero chiamato indice. Quando create un array, dovete racchiudere gli elementi tra gli operatori di accesso all’array ([]) (parentesi quadre). Un array può contenere elementi di vari tipi; Ad esempio, l’array seguente, denominato employee, ha tre elementi: il primo è un numero, e il secondo e il terzo sono stringhe (racchiuse tra virgolette):

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

Nell’esempio seguente viene creato un array chiamato employee_array con tre elementi e viene modificato il terzo elemento dell’array.

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 */ 

Elementi API correlati

Valuta se un’espressione specificata dal primo operando è un membro del tipo di dati specificato dal secondo operando. Se il primo operando è membro del tipo di dati, il risultato è il primo operando. Altrimenti, il risultato è il valore null.

L’espressione utilizzata per il secondo operando deve restituire un tipo di dati.

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

Elementi API correlati

Assegna il valore di expression2 (l’operando a destra) alla variabile, all’elemento di array o alla proprietà in expression1. L’assegnazione può avvenire in base al valore o al riferimento. L’assegnazione in base al valore copia il valore effettivo di expression2 e lo memorizza in expression1. L’assegnazione in base al valore viene utilizzata quando expression2 è un valore di base, ovvero è di tipo Boolean, Number, int, uint o String. L’assegnazione in base al riferimento memorizza un riferimento a expression2 in expression1 e viene comunemente utilizzata con l’operatore new. L’uso dell’operatore new crea un oggetto nella memoria e assegna a una variabile un riferimento a quella posizione di memoria.

Nota: in ActionScript 3.0 tutti i valori (compresi quelli di base) sono oggetti e tutte le assegnazioni vengono eseguite in base al riferimento, ma gli oggetti di base hanno operatori speciali che consentono a tali oggetti di comportarsi come se fossero stati assegnati in base al valore.

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

Elementi API correlati

 myXML.@attributeName 

Identifica gli attributi di un oggetto XML o XMLList. Ad esempio, myXML.@id identifica gli attributi denominati id per l’oggetto XML myXML. Potete anche utilizzare la sintassi seguente per accedere agli attributi: myXML.attribute("id"), myXML["@id"] emyXML.@["id"]. È consigliata la sintassi myXML.@id. Per restituire un oggetto XMLList di tutti i nomi di attributi, utilizzate @*. Per restituire un attributo con un nome che corrisponde a una parola riservata di ActionScript, utilizzate il metodo attribute() invece dell’operatore @.

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

Elementi API correlati

Converte expression1 e expression2 in numeri interi senza segno a 32 bit ed esegue un’operazione AND booleana su ogni bit dei parametri convertiti in numeri interi. I numeri a virgola mobile vengono convertiti in numeri interi scartando tutti i decimali. Il risultato è un nuovo numero intero a 32 bit.

Un numero intero positivo viene convertito in valore esadecimale senza segno con un valore massimo di 4294967295 o 0xFFFFFFFF; un valore maggiore del massimo perde le cifre più significative quando viene convertito, in modo da rimanere un numero a 32 bit. Un numero negativo viene convertito in un valore esadecimale senza segno tramite la notazione del complemento a due, con il minimo pari a -2147483648 o 0x800000000; un numero minore del minimo viene convertito nel complemento a due con maggiore precisione, prima di perdere le cifre più significative.

Il risultato viene interpretato come numero di complemento a due a 32 bit, in modo che sia un numero intero compreso tra -2147483648 e 2147483647.

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

  1101
& 1011
  ----
  1001

Gli esempi seguenti mostrano il comportamento della conversione del valore restituito:

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

Elementi API correlati

Assegna a expression1 il valore di expression1 & expression2. Ad esempio, le due espressioni seguenti sono equivalenti:

x &= y; 
x = x & y; 

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

Elementi API correlati

Converte expression1 e shiftCount in numeri interi a 32 bit e sposta tutti i bit in expression1 a sinistra per il numero di posti specificato dal numero intero risultante dalla conversione di shiftCount. Le posizioni di bit che vengono svuotate in seguito a questa operazione vengono riempite con 0 e i bit spostati oltre l’estremità sinistra vengono scartati. Lo spostamento di un valore verso sinistra di una posizione equivale a moltiplicarlo per 2.

Un numero a virgola mobile viene convertito in numero intero scartando tutti i decimali. Un numero intero positivo viene convertito in valore esadecimale senza segno con un valore massimo di 4294967295 o 0xFFFFFFFF; un valore maggiore del massimo perde le cifre più significative quando viene convertito, in modo da rimanere un numero a 32 bit. Un numero negativo viene convertito in un valore esadecimale senza segno tramite la notazione del complemento a due, con il minimo pari a -2147483648 o 0x800000000; un numero minore del minimo viene convertito nel complemento a due con maggiore precisione, prima di perdere le cifre più significative.

Il risultato viene interpretato come numero di complemento a due a 32 bit, in modo che sia un numero intero compreso tra -2147483648 e 2147483647.

Se il risultato è un numero intero negativo, viene generato un errore di runtime se tentate di assegnare il risultato a una variabile del tipo uint. Anche se ActionScript non ha un operatore di "spostamento a sinistra bit a bit senza segno", potete ottenere lo stesso effetto, ed evitare l’errore di runtime, utilizzando 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 

Nell’esempio seguente, il numero intero 7 viene spostato di 8 bit verso sinistra:

x = 7 << 8

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

L’istruzione trace seguente mostra che i bit sono stati spostati di tre posizioni verso sinistra:

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

Elementi API correlati

Esegue un’operazione di spostamento bit a bit a sinistra (<<=) e memorizza il contenuto come risultato in expression1. Le due espressioni seguenti sono equivalenti:

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 

Elementi API correlati

Converte expression in un numero intero con segno a 32 bit, quindi applica un complemento a uno bit a bit. In altre parole, nel risultato, ogni bit 0 viene impostato su 1 e ogni bit 1 viene impostato su 0. Il risultato è un numero intero a 32 bit con segno. Questo operatore è anche noto come operatore del complemento a uno o operatore del complemento bit a bit.

Ad esempio, il valore esadecimale 0x7777 è rappresentato da questo numero binario:

0111011101110111

La negazione bit a bit di quel valore esadecimale, ~0x7777, è questo numero binario:

1000100010001000

In formato esadecimale, questo è 0x8888. Di conseguenza, ~0x7777 è 0x8888.

Gli operatori bit a bit vengono più comunemente utilizzati per rappresentare i flag bit (valori booleani compressi in 1 bit ciascuno).

Un numero a virgola mobile viene convertito in numero intero scartando tutti i decimali. Un numero intero positivo viene convertito in valore esadecimale senza segno con un valore massimo di 4294967295 o 0xFFFFFFFF; un valore maggiore del massimo perde le cifre più significative quando viene convertito, in modo da rimanere un numero a 32 bit. Un numero negativo viene convertito in un valore esadecimale senza segno tramite la notazione del complemento a due, con il minimo pari a -2147483648 o 0x800000000; un numero minore del minimo viene convertito nel complemento a due con maggiore precisione, prima di perdere le cifre più significative.

Il risultato viene interpretato come numero di complemento a due a 32 bit, in modo che sia un numero intero compreso tra -2147483648 e 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 

Elementi API correlati

Converte expression1 e expression2 in numeri interi senza segno a 32 bit e inserisce un 1 in ogni posizione di bit nella quale i bit corrispondenti di expression1 o expression2 sono 1.

Un numero a virgola mobile viene convertito in numero intero scartando tutti i decimali. Un numero intero positivo viene convertito in valore esadecimale senza segno con un valore massimo di 4294967295 o 0xFFFFFFFF; un valore maggiore del massimo perde le cifre più significative quando viene convertito, in modo da rimanere un numero a 32 bit. Un numero negativo viene convertito in un valore esadecimale senza segno tramite la notazione del complemento a due, con il minimo pari a -2147483648 o 0x800000000; un numero minore del minimo viene convertito nel complemento a due con maggiore precisione, prima di perdere le cifre più significative.

Il risultato viene interpretato come numero di complemento a due a 32 bit, in modo che sia un numero intero compreso tra -2147483648 e 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) 

Elementi API correlati

Assegna a expression1 il valore di expression1 | expression2. Le seguenti due istruzioni, ad esempio, sono equivalenti:

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) 

Elementi API correlati

Converte expression e shiftCount in numeri interi a 32 bit e sposta tutti i bit in expression a destra per il numero di posti specificato dal numero intero risultante dalla conversione di shiftCount. I bit che vengono spostati oltre l’estremità destra vengono scartati. Per conservare il segno dell’espressione originale, i bit a sinistra vengono sostituiti con 0 se il bit più significativo (ovvero quello all’estrema sinistra) di expression è 0, oppure con 1 se il bit più significativo è 1. Spostare un valore verso destra di una posizione equivale a dividere per 2 e scartare il resto.

Un numero a virgola mobile viene convertito in numero intero scartando tutti i decimali. Un numero intero positivo viene convertito in valore esadecimale senza segno con un valore massimo di 4294967295 o 0xFFFFFFFF; un valore maggiore del massimo perde le cifre più significative quando viene convertito, in modo da rimanere un numero a 32 bit. Un numero negativo viene convertito in un valore esadecimale senza segno tramite la notazione del complemento a due, con il minimo pari a -2147483648 o 0x800000000; un numero minore del minimo viene convertito nel complemento a due con maggiore precisione, prima di perdere le cifre più significative.

Il risultato viene interpretato come numero di complemento a due a 32 bit, in modo che sia un numero intero compreso tra -2147483648 e 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)

Elementi API correlati

Esegue un’operazione di spostamento bit a bit a destra e memorizza il risultato in expression.

Le due istruzioni seguenti sono equivalenti:

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.

Elementi API correlati

Uguale all’operatore di spostamento a destra (>>) ad eccezione del fatto che non conserva il segno dell’espressione originale poiché nei bit a sinistra vengono inseriti dei valori 0.

Un numero a virgola mobile viene convertito in numero intero scartando tutti i decimali. Un numero intero positivo viene convertito in valore esadecimale senza segno con un valore massimo di 4294967295 o 0xFFFFFFFF; un valore maggiore del massimo perde le cifre più significative quando viene convertito, in modo da rimanere un numero a 32 bit. Un numero negativo viene convertito in un valore esadecimale senza segno tramite la notazione del complemento a due, con il minimo pari a -2147483648 o 0x800000000; un numero minore del minimo viene convertito nel complemento a due con maggiore precisione, prima di perdere le cifre più significative.

Il risultato viene interpretato come numero intero a 32 bit senza segno, in modo che sia un numero intero compreso tra 0 e 4294967295.

Nota: ActionScript non ha un operatore di "spostamento a sinistra bit a bit senza segno" complementare, ma potete ottenere lo stesso effetto utilizzando uint(expression << shiftCount).

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

Elementi API correlati

Esegue un’operazione di spostamento bit a bit a destra senza segno e memorizza il risultato in expression. Le due istruzioni seguenti sono equivalenti:

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

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

Elementi API correlati

Converte expression1 e expression2 in numeri interi senza segno a 32 bit e restituisce un 1 in ogni posizione di bit nella quale i bit corrispondenti di expression1 o expression2, ma non entrambi, sono 1.

Un numero a virgola mobile viene convertito in numero intero scartando tutti i decimali. Un numero intero positivo viene convertito in valore esadecimale senza segno con un valore massimo di 4294967295 o 0xFFFFFFFF; un valore maggiore del massimo perde le cifre più significative quando viene convertito, in modo da rimanere un numero a 32 bit. Un numero negativo viene convertito in un valore esadecimale senza segno tramite la notazione del complemento a due, con il minimo pari a -2147483648 o 0x800000000; un numero minore del minimo viene convertito nel complemento a due con maggiore precisione, prima di perdere le cifre più significative.

Il risultato viene interpretato come numero di complemento a due a 32 bit, in modo che sia un numero intero compreso tra -2147483648 e 2147483647.

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

Elementi API correlati

Assegna a expression1 il valore di expression1 ^ expression2. Le seguenti due istruzioni, ad esempio, sono equivalenti:

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) 

Elementi API correlati

/* comment */

/* comment

   comment */

Delimita una o più righe di commento di script. I caratteri racchiusi tra il delimitatore di apertura (/*) e quello di chiusura (*/) vengono considerati commenti e ignorati dal compilatore ActionScript. Utilizzate questi delimitatori per identificare i commenti su più righe successive; per i commenti a riga singola, utilizzate il delimitatore //.

Viene generato un messaggio di errore se omettete il delimitatore di chiusura del blocco di commento (*/) oppure tentate di nidificare dei commenti. Dopo un delimitatore di apertura (/*), il primo delimitatore di chiusura (*/) chiude il commento, indipendentemente dal numero di delimitatori di apertura che lo precedono.

/* 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 */ 

Elementi API correlati

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

Valuta un’espressione utilizzata in un inizializzatore XML o XMLList. Un inizializzatore XML o XMLList è un valore letterale assegnato a una variabile del tipo XML o XMLList. Un’espressione delimitata dagli operatori XML { e } può essere utilizzata in un inizializzatore XML o XMLList al posto di valori o nomi letterali. Potete utilizzare un’espressione al posto di tagName, attributeName, attributeValue e 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>

Elementi API correlati

 myXML[expression]

Accede a una proprietà o a un attributo di un oggetto XML o XMLList. L’operatore parentesi quadre permette di accedere a nomi di proprietà che non sono accessibili con l’ operatore punto (.).

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

Elementi API correlati

Valuta expression1, quindi expression2 e così via. Questo operatore viene utilizzato principalmente nelle istruzioni cicliche for, spesso assieme all’operatore parentesi ().

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 

Elementi API correlati

Concatena (combina) più stringhe. Se un’espressione è una stringa, tutte le altre espressioni vengono convertite in stringhe e concatenate.

Se entrambe le espressioni sono numeri, questo operatore si comporta come un operatore di addizione.

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 

Elementi API correlati

expression1 + expression2

Concatena (combina) dei valori XML o XMLList in un oggetto XMLList. Viene restituito un oggetto XMLList solo se entrambi gli operandi sono valori XML o 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’istruzione trace produce il seguente output:

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

Elementi API correlati

Assegna a expression1 il valore di expression1 + expression2. Ad esempio, le due istruzioni seguenti danno lo stesso risultato:

x += y; 
x = x + y;

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

Elementi API correlati

expression1 += expression2

Assegna aexpression1, che è un oggetto XMLList, il valore di expression1 + expression2. Ad esempio, le due istruzioni seguenti danno lo stesso risultato:

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’istruzione trace produce il seguente output:

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

<location>Springfield</location>

Elementi API correlati

expression1 ? expression2 : expression3

Restituisce expression1 e se il valore di expression1 è true, il risultato è il valore di expression2; in caso contrario, il risultato è il valore di 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--

Sottrae 1 dall’operando. L’operando può essere una variabile, un elemento di un array o la proprietà di un oggetto. Il formato pre-decremento dell’operatore (--expression) sottrae 1 da expression e restituisce il risultato. Il formato post-decremento dell’operatore (expression--) sottrae 1 da expression e restituisce il valore iniziale di expression (il valore prima della sottrazione).

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

Elimina la proprietà dell’oggetto specificata da reference; il risultato è true se la proprietà non esiste dopo il completamento dell’operazione, altrimenti è false. L’operatore delete restituisce true se viene chiamato su una proprietà inesistente o su una proprietà dinamica non definita in una classe.

L’operatore delete può non riuscire e restituire false se il reference parametro non può essere eliminato. Non potete eliminare proprietà fisse oppure variabili dichiarate con l’istruzione var. Una proprietà fissa è una variabile o un metodo definito in una definizione di classe.

L’operatore delete non può essere utilizzato per eliminare una proprietà di una classe, a meno che non si tratti di una classe dinamica aggiunta in fase di runtime. Le proprietà delle classi chiuse non possono essere eliminate con delete. Impostate invece la proprietà su null.

Nota: non è possibile eliminare un oggetto, ma potete renderlo idoneo per il processo di garbage collection rimovendo tutti i relativi riferimenti. Il riferimento più comune a un oggetto è una variabile che punta ad esso. Un riferimento di questo tipo può essere rimosso impostando la variabile su null. Il processo di garbage collection rimuove gli oggetti privi di riferimenti.

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

Nell’esempio seguente viene eliminato il valore di un elemento di array, ma il valore della proprietà length non viene modificato:

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,

Nell’esempio seguente viene illustrato come il valore Boolean restituito da delete possa essere utilizzato come condizione per l’esecuzione successiva del codice. Notate che se un elemento è già stato eliminato, una nuova chiamata a delete per lo stesso elemento restituisce 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

Elementi API correlati

 delete reference

Elimina gli elementi o attributi XML specificati da 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());

L’output è il seguente:

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

L’output di questo esempio è il seguente:

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

 myXML..childElement1..@attributeName 

Va agli elementi discendenti di un oggetto XML o XMLList, oppure (se combinato con l’operatore @) trova gli attributi corrispondenti dei discendenti. Gli elementi o attributi corrispondenti non devono necessariamente essere elementi secondari diretti rispetto all’oggetto XML o XMLList; possono essere a un livello più basso della struttura (ad esempio, inferiori di due o più livelli). Il risultato è un oggetto XMLList, perché più di un elemento secondario o attributo può corrispondere.

L’ordine dei nodi dell’oggetto XMLList restituito è il risultato di una ricerca in profondità (depth-first traversal). Ad esempio, considerate il codice seguente:

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

Viene prodotto l’output seguente:

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

Per restituire discendenti con nomi che corrispondono a parole riservate di ActionScript, utilizzare il metodo XML.descendants() invece dell’operatore discendente (..). come nell’esempio seguente:

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

Elementi API correlati

Divide expression1 per expression2. Il risultato della divisione corrisponde a un numero a virgola mobile e doppia precisione.

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

Elementi API correlati

Assegna a expression1 il valore di expression1 / expression2. Le seguenti due istruzioni, ad esempio, sono equivalenti:

x /= y; 
x = x / y;

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

Elementi API correlati

object.property_or_method

Accede a variabili di classe e metodi, ottiene e imposta proprietà di oggetto e delimita i pacchetti o le classi importate.

import flash.utils.Timer;

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

Elementi API correlati

myXML.childElement
myXML.@attributeName 

Va agli elementi secondari di un oggetto XML o XMLList, oppure (se combinato con l’operatore @) restituisce gli attributi di un oggetto XML o XMLList. L’oggetto restituito è un oggetto XMLList, perché più di un elemento secondario o attributo può corrispondere.

Per restituire elementi con nomi che corrispondono a parole riservate di ActionScript, utilizzate il metodo XML.elements() o XML.descendants() invece dell’operatore XML punto (.), come nell’esempio seguente:

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

Elementi API correlati

Confronta due espressioni per verificarne l’uguaglianza. Il risultato è true se le espressioni sono uguali.

Se i tipi di dati dei due operandi corrispondono, la definizione di uguale dipende dal tipo di dati:

• i valori di tipo int, uint e Boolean sono considerati uguali se hanno lo stesso valore;
• I numeri con valori corrispondenti vengono considerati uguali, a meno che non siano entrambi NaN.
• Se il valore di entrambi gli operandi è null o undefined, vengono considerati uguali.
• le espressioni String sono uguali se hanno lo stesso numero di caratteri e questi sono identici;
• per gli oggetti XML:
  • Se un operando è un nodo di testo o di attributo e l’altro ha un contenuto semplice, entrambi vengono convertiti in stringhe con il metodo toString() e vengono considerati uguali se le stringhe risultanti corrispondono.
  • in caso contrario, gli oggetti vengono considerati uguali sono se il nome completo, gli attributi e le proprietà secondarie di entrambi corrispondono;
• gli oggetti XMLList vengono considerati uguali se hanno lo stesso numero di proprietà e sia l’ordine che i valori delle proprietà corrispondono;
• Per gli oggetti Namespace, i valori vengono considerati uguali se le proprietà uri di entrambi gli oggetti corrispondono.
• Per gli oggetti QName, i valori vengono considerati uguali se le proprietà uri e localName di entrambi gli oggetti corrispondono.
• le variabili che rappresentano oggetti, array e funzioni vengono confrontate in base ai riferimenti. Due espressioni di questo tipo sono uguali se entrambe si riferiscono allo stesso oggetto, array o funzione. Due array separati non vengono mai considerati uguali, anche se contengono lo stesso numero di elementi.

• I valori degli operandi sono undefined e null, nel qual caso il risultato è true.
• la conversione automatica del tipo di dati converte i tipi di dati dei valori String, Boolean, int, uint e Number in tipi compatibili e i valori convertiti sono uguali, nel qual caso gli operandi vengono considerati uguali;
• Un solo operando è del tipo XML con contenuto semplice (hasSimpleContent() == true) e dopo la conversione in stringhe di entrambi gli operandi con il metodo toString() le stringhe risultanti corrispondono.
• un operando è del tipo XMLList e una delle due seguenti condizioni è vera:
  • La proprietà length dell’oggetto XMLList è 0 e l’altro oggetto è undefined.
  • La proprietà length dell’oggetto XMLList è 1 e un elemento dell’oggetto XMLList corrisponde all’altro operando.

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 

Elementi API correlati

Esegue un confronto tra due espressioni e determina se expression1 è maggiore di expression2; in caso affermativo, l’operatore restituisce true. Se expression1 è minore di o uguale a expression2, l’operatore restituisce false.

Se entrambi gli operandi sono del tipo String, vengono confrontati in base all’ordine alfabetico; tutte le lettere maiuscole vengono prima delle minuscole. In caso contrario, gli operandi vengono prima convertiti in numeri, quindi confrontati.

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

Confronta due espressioni e determina se expression1 è maggiore di o uguale a expression2 (true) o se expression1 è minore di expression2 (false).

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

Elementi API correlati

Valuta se una proprietà appartiene a un oggetto specifico. Per utilizzare l’operatore in, specificate un nome di proprietà come primo operando e un oggetto come secondo operando. Se l’oggetto specificato contiene tale proprietà, il risultato è true; in caso contrario il risultato è false.

Se l’oggetto specificato è del tipo Array, potete utilizzare l’operatore in per verificare se un particolare numero di indice è valido. Se passate un indice come primo operando, il risultato è true se l’indice si trova in un intervallo valido di numeri di indice, in caso contrario è false.

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

Nell’esempio seguente viene utilizzato l’operatore in per mostrare che i numeri 0, 1 e sono numeri di indice validi nell’oggetto myArray, ma il numero 3 non lo è.

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

Elementi API correlati

++expression

 expression++

Aggiunge 1 a un’espressione. L’espressione può essere una variabile, un elemento di un array o la proprietà di un oggetto. Il formato pre-incremento dell’operatore (++expression) aggiunge1 e expression e restituisce il risultato. Il formato post-incremento dell’operatore (expression++) aggiunge 1 a expression e restituisce il valore iniziale di expression (il valore prima dell’addizione).

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 
*/

Prova l’esatto opposto dell’ operatore di uguaglianza (==). Se expression1 è uguale a expression2, il risultato è false. Come nel caso dell’operatore di uguaglianza (==), la definizione di uguale dipende dai tipi di dati confrontati.

Se i tipi di dati dei due operandi corrispondono, la definizione di uguale dipende dal tipo di dati:

• i valori di tipo int, uint e Boolean sono considerati uguali se hanno lo stesso valore;
• I numeri con valori corrispondenti vengono considerati uguali, a meno che non siano entrambi NaN.
• Se il valore di entrambi gli operandi è null o undefined, vengono considerati uguali.
• le espressioni String sono uguali se hanno lo stesso numero di caratteri e questi sono identici;
• per gli oggetti XML:
  • Se un operando è un nodo di testo o di attributo e l’altro ha un contenuto semplice, entrambi vengono convertiti in stringhe con il metodo toString() e vengono considerati uguali se le stringhe risultanti corrispondono.
  • in caso contrario, gli oggetti vengono considerati uguali sono se il nome completo, gli attributi e le proprietà secondarie di entrambi corrispondono;
• gli oggetti XMLList vengono considerati uguali se hanno lo stesso numero di proprietà e sia l’ordine che i valori delle proprietà corrispondono;
• Per gli oggetti Namespace, i valori vengono considerati uguali se le proprietà uri di entrambi gli oggetti corrispondono.
• Per gli oggetti QName, i valori vengono considerati uguali se le proprietà uri e localName di entrambi gli oggetti corrispondono.
• le variabili che rappresentano oggetti, array e funzioni vengono confrontate in base ai riferimenti. Due espressioni di questo tipo sono uguali se entrambe si riferiscono allo stesso oggetto, array o funzione. Due array separati non vengono mai considerati uguali, anche se contengono lo stesso numero di elementi.

• I valori degli operandi sono undefined e null, nel qual caso il risultato è true.
• la conversione automatica del tipo di dati converte i tipi di dati dei valori String, Boolean, int, uint e Number in tipi compatibili e i valori convertiti sono uguali, nel qual caso gli operandi vengono considerati uguali;
• Un solo operando è del tipo XML con contenuto semplice (hasSimpleContent() == true) e dopo la conversione in stringhe di entrambi gli operandi con il metodo toString() le stringhe risultanti corrispondono.
• un operando è del tipo XMLList e una delle due seguenti condizioni è vera:
  • La proprietà length dell’oggetto XMLList è 0 e l’altro oggetto è undefined.
  • La proprietà length dell’oggetto XMLList è 1 e un elemento dell’oggetto XMLList corrisponde all’altro operando.

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

Elementi API correlati

Valuta se la catena di prototipi di un’espressione include l’oggetto prototipo di function. L’operatore instanceof è stato incluso per assicurare la compatibilità retroattiva con l’edizione 3 di ECMAScript e potrebbe essere utile ai programmatori avanzati che scelgono di utilizzare l’ereditarietà basata sui prototipi con le funzioni di costruzione anziché con le classi.

Per verificare se un oggetto è membro di un tipo di dati specifico, utilizzate l’ operatore is.

Quando viene utilizzato con le classi, l’operatore instanceof è simile all’operatore is perché la catena di prototipi di una classe include tutte le relative superclassi. Le interfacce, invece, non vengono incluse nelle catene di prototipi, quindi l’operatore instanceof restituisce sempre false quando viene utilizzato con le interfacce, mentre l’operatore is restituisce true se un oggetto appartiene a una classe che implementa l’interfaccia specificata.

Nota: l’operatore ActionScript is è l’equivalente dell’operatore 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

Elementi API correlati

Valuta se un oggetto è compatibile con un tipo di dati, una classe o un’interfaccia specifica. Utilizzate l’operatore is invece dell’operatore instanceof per i confronti di tipo. Potete anche utilizzare l’operatore is per controllare se un oggetto implementa un’interfaccia.

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

Elementi API correlati

Esegue un confronto tra due espressioni e determina se expression1 è minore di expression2; in caso affermativo, l’operatore restituisce true. Se expression1 è maggiore di o uguale a expression2, l’operatore restituisce false.

Se entrambi gli operandi sono del tipo String, vengono confrontati in base all’ordine alfabetico; tutte le lettere maiuscole vengono prima delle minuscole. In caso contrario, gli operandi vengono prima convertiti in numeri, quindi confrontati.

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 

Esegue un confronto tra due espressioni e determina se expression1 è minore o uguale a expression2; in caso affermativo, l’operatore restituisce true. Se expression1 è maggiore di expression2, il risultato è false.

Se entrambi gli operandi sono del tipo String, vengono confrontati in base all’ordine alfabetico; tutte le lettere maiuscole vengono prima delle minuscole. In caso contrario, gli operandi vengono prima convertiti in numeri, quindi confrontati.

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 

Indica l’inizio di un commento di script. I caratteri racchiusi tra il delimitatore (//) e il carattere di fine riga vengono considerati commenti e ignorati. Utilizzate questo delimitatore per i commenti a riga singola; per i commenti su più righe successive, utilizzate i delimitatori /* e */.

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

Elementi API correlati

Restituisce expression1 se è false o può essere convertita in false, in caso contrario restituisce expression2. Esempi di valori che possono essere convertiti in false sono 0, NaN, null e undefined. Se usate una chiamata a una funzione come expression2, la funzione non viene chiamata se expression1 restituisce false.

Se entrambi gli operandi sono di tipo Boolean, il risultato è true solo se sono entrambi true, come illustrato nella seguente tabella:

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

Elementi API correlati

Assegna a expression1 il valore di expression1 && expression2. Le seguenti due istruzioni, ad esempio, sono equivalenti:

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