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; 

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

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

Elementi API correlati

Inverte il valore booleano di una variabile o espressione. Se expression è una variabile con un valore convertito o assoluto true, il valore di !expression è false. Se l’espressione x && y restituisce false, l’espressione !(x && y) restituisce true.

Le espressioni seguenti mostrano il risultato dell’uso dell’operatore NOT (!) logico:

• !true restituisce false.
• !false restituisce true.

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

Elementi API correlati

Restituisce expression1 se è true o può essere convertita in true, in caso contrario restituisce expression2. Se usate una chiamata a una funzione come expression2, la funzione non viene chiamata se expression1 restituisce true.

Se entrambi gli operandi sono di tipo Boolean, il risultato è true se una o entrambe le espressioni sono true; il risultato è invece false solo nel caso in cui entrambe le espressioni siano false, come mostra la tabella seguente:

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

L’esempio seguente mostra come l’uso di una chiamata di funzione come secondo operando può portare a risultati imprevisti. Se l’espressione a sinistra dell’operatore restituisce true, tale risultato viene restituito senza che venga valutata l’espressione a destra (la funzione fx2() non viene chiamata).

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

Elementi API correlati

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

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

myVar ||= "default";

Elementi API correlati

Calcola il resto di expression1 diviso per expression2. Se uno degli operandi non è un valore numerico, l’operatore modulo (%) tenta di convertirlo in un numero.

Il segno del risultato del modulo corrisponde al segno del dividendo (ovvero il primo numero). Ad esempio, -4 % 3 e -4 % -3 restituiscono entrambi -1.

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

Elementi API correlati

Assegna a expression1 il valore di expression1 % expression2. Le due istruzioni seguenti sono equivalenti:

x %= y; 
x = x % y; 

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

Elementi API correlati

Moltiplica due espressioni numeriche. Se entrambe le espressioni sono numeri interi, il prodotto è un numero intero. Se almeno una delle due espressioni è un numero a virgola mobile, il prodotto è un numero a virgola mobile.

trace(2*3); // 6 

trace(2.0 * 3.1416); // 6.2832 

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

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 

Elementi API correlati

namespace::property

namespace::method()

namespace::xmlObject.property

namespace::xmlObject.@attribute

Identifica lo spazio dei nomi di una proprietà, un metodo, una proprietà XML o un attributo 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

Elementi API correlati

Crea una nuova istanza di classe. L’operatore new può essere utilizzato con una classe o una variabile di tipo Class per creare un’istanza di una classe. L’operatore new viene solitamente utilizzato con un oggetto classe per creare un’istanza di una classe. Ad esempio, l’istruzione new Sprite() crea un’istanza della classe Sprite.

L’operatore new può anche essere utilizzato per associare una classe a una risorsa incorporata, vale a dire un oggetto esterno (ad esempio un’immagine, un suono o un carattere) che viene compilato in un file SWF. Ogni risorsa incorporata è rappresentata da una classe di risorsa incorporata univoca. Per accedere a una risorsa incorporata, dovete utilizzare l’operatore new per creare un’istanza della classe ad essa associata. Successivamente, potete chiamare i metodi e le proprietà appropriate della classe della risorsa incorporata per modificare la risorsa.

Se preferite definire le classi con oggetti Function anziché con la parola chiave class, potete utilizzare l’operatore new per creare oggetti basati su funzioni di costruzione. Non confondete le funzioni di costruzione con i metodi di costruzione di una classe. Una funzione di costruzione è un oggetto Function definito mediante la parola chiave function ma che non fa parte di una definizione di classe. Se create oggetti mediante le funzioni di costruzione, dovete utilizzare l’ereditarietà di prototipo anziché quella di 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);

Elementi API correlati

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

Crea un nuovo oggetto e lo inizializza con le coppie di proprietà name e value specificate. L’uso di questo operatore equivale a utilizzare la sintassi di new Object e indicare le coppie di proprietà mediante l’operatore di assegnazione. Il prototipo dell’oggetto appena creato viene solitamente chiamato oggetto Object.

Questo operatore viene anche utilizzato per contrassegnare i blocchi di codice contigui associati alle istruzioni (for, while, if, else, switch) e funzioni di controllo del flusso.

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

Elementi API correlati

(expression1[, expression2])

(expression1, expression2)

function(parameter1,..., parameterN) 

Esegue un’operazione di raggruppamento su uno o più parametri, esegue una valutazione sequenziale delle espressioni, oppure racchiude uno o più parametri e li passa come argomenti a una funzione che precede le parentesi.

Uso 1: controlla l’ordine di esecuzione degli operatori. Le parentesi hanno la priorità sul normale ordine di precedenza e le espressioni racchiuse tra parentesi vengono valutate per prime. Quando le parentesi sono nidificate, il contenuto delle parentesi interne viene valutato prima del contenuto di quelle esterne.

Uso 2: valuta una serie di espressioni, separate da virgola, in sequenza, e restituisce il risultato dell’espressione finale.

Uso 3: racchiude uno o più parametri e li passa alla funzione che precede le parentesi.

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

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

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

Elementi API correlati

myXML.(expression)

Valuta un’espressione utilizzata in un costrutto XML ECMAScript per XML (E4X). Ad esempio, myXML.(lastName == "Smith") identifica gli elementi XML con il nome lastName e il valore "Smith". Il risultato è un oggetto 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

Elementi API correlati

/pattern/flags

Se viene utilizzato prima e dopo dei caratteri, indica che i caratteri hanno un valore letterale e devono essere considerati come espressione regolare (RegExp) e non come variabile, stringa, valore numerico o un altro elemento ActionScript. Tenete presente, tuttavia, che due caratteri di barra in sequenza (//) indicano l’inizio di un commento.

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

Elementi API correlati

Verifica l’uguaglianza di due espressioni, ma non esegue la conversione automatica dei dati. Il risultato è true se le due espressioni sono uguali, inclusi i tipi di dati.

L’operatore di uguaglianza rigorosa (===) è uguale a quello di uguaglianza (==) in tre aspetti:

• i numeri e i valori Boolean vengono confrontati in base al valore e sono considerati uguali se hanno lo stesso valore;
• le espressioni String sono uguali se hanno lo stesso numero di caratteri e questi sono identici;
• 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.

• L’operatore di uguaglianza rigorosa esegue la conversione automatica dei dati solo per i tipi numerici (Number, int e uint), mentre l’operatore di uguaglianza converte automaticamente tutti i tipi di dati di base.
• Quando si confrontano null e undefined, l’operatore di uguaglianza rigorosa restituisce false.

Innanzi tutto, i confronti tra valori di base e oggetti di base che contengono lo stesso valore restituiscono true in ActionScript 3.0, ma false nelle versioni precedenti. In queste ultime, il tipo di dati di un valore di base è Boolean, Number o String, mentre il tipo di dati di un oggetto di base è sempre Object e mai Boolean, Number o String. Come conseguenza pratica di questa differenza, il codice seguente restituisce false nelle versioni precedenti di ActionScript perché i tipi di dati degli operandi non corrispondono, ma il risultato è true in ActionScript 3.0 perché i valori di base sono del tipo Boolean, Number, int, uint o String, a prescindere che siano contenuti in un oggetto wrapper o meno.

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

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

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

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

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

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

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

Elementi API correlati

Prova l’esatto opposto dell’ operatore di uguaglianza rigorosa (===). L’operatore di disuguaglianza rigorosa si comporta come l’operatore di disuguaglianza ma converte solo i tipi di dati int e uint.

Se expression1 è uguale a expression2 e i relativi tipi di dati sono uguali, il risultato è false.

L’operatore di disuguaglianza rigorosa (!==) è uguale a quello di disuguaglianza (!=) in tre aspetti:

• i numeri e i valori Boolean vengono confrontati in base al valore e sono considerati uguali se hanno lo stesso valore;
• le espressioni String sono uguali se hanno lo stesso numero di caratteri e questi sono identici;
• 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.

• L’operatore di disuguaglianza rigorosa (!==) esegue la conversione automatica dei dati solo per i tipi numerici (Number, int e uint), mentre l’operatore di disuguaglianza (!=) converte automaticamente tutti i tipi di dati di base.
• Quando si confrontano null e undefined, l’operatore di disuguaglianza rigorosa (!==) restituisce 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 

Elementi API correlati

 "text" 

Se utilizzate prima e dopo i caratteri, indicano che i caratteri hanno un valore letterale e devono essere considerati come una stringa, non una variabile, un valore numerico o un altro elemento ActionScript.

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

Elementi API correlati

-expression

 expression1 - expression2

Utilizzato per negare o sottrarre.

Uso 1: quando viene utilizzato per la negazione, l’operatore inverte il segno di un’espressione numerica.

Uso 2: quando viene utilizzato per la sottrazione, l’operatore esegue una sottrazione aritmetica su due espressioni numeriche, sottraendo expression2 da expression1. Se entrambe le espressioni sono numeri interi, la differenza è un numero intero. Se almeno una delle due espressioni è un numero a virgola mobile, la differenza è un numero a virgola mobile.

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

trace(5 - 2); // 3 

L’istruzione seguente sottrae il numero a virgola mobile 1.5 dal numero a virgola mobile 3.25:

trace(3.25 - 1.5); // 1.75 

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

x -= y ;
x = x - y;

Le espressioni String devono essere convertite in numeri; in caso contrario, il risultato è NaN (not a number, non un numero).

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 

Elementi API correlati

[modifiers] var variableName:type

function functionName():type { ... }

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

Utilizzato per l’assegnazione di un tipo di dati; questo operatore specifica il tipo di variabile, il tipo di funzione restituito o il tipo di parametro di funzione. Se utilizzato in una dichiarazione o assegnazione di variabile, questo operatore specifica il tipo di variabile; quando viene utilizzato in una dichiarazione o definizione della funzione, specifica il tipo restituito da una funzione; se viene utilizzato con un parametro di funzione nella definizione di una funzione, specifica il tipo di variabile prevista per quel parametro.

Il controllo del tipo viene sempre eseguito in fase di runtime. Tuttavia, quando il compilatore è eseguito in modalità rigorosa, tutti i tipi vengono verificati al momento della compilazione e, in caso di mancata corrispondenza, vengono generati i relativi errori. Gli errori di corrispondenza possono verificarsi durante le operazioni di assegnazione, le chiamate di funzione e l’annullamento di riferimenti dei membri di classe mediante l’ operatore punto (.).

Possono essere utilizzati tutti i tipi di oggetti nativi, le classi e le interfacce definite dall’utente e void. I tipi nativi riconosciuti sono Boolean, Number, int, uint e String. Anche tutte le classi incorporate sono supportate come tipi nativi.

Se non si assegna un tipo di dati, la variabile, il valore restituito della funzione o il parametro di funzione viene considerato privo di tipo, ovvero il valore può essere di qualunque tipo di dati. Se si desidera esplicitare l’intenzione di utilizzare un valore privo di tipo, è possibile utilizzare il carattere di asterisco (*) come annotazione di tipo. Quando è utilizzato in un’annotazione di tipo, il carattere asterisco equivale a lasciare senza tipo una variabile, il tipo restituito di una funzione o un parametro di funzione.

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

Elementi API correlati

Valuta expression e restituisce una stringa che specifica il tipo di dati dell’espressione. Il risultato è limitato a sei possibili valori di stringa: boolean, function, number, object, string e xml. Se si applica questo operatore a un’istanza di una classe definita dall’utente, il risultato è la stringa object. L’operatore typeof è stato incluso per assicurare la compatibilità retroattiva. Utilizzate l’operatore is per verificare la compatibilità di tipo.

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

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

Elementi API correlati

Valuta un’espressione, quindi ne scarta il valore e restituisce undefined. L’operatore void viene spesso utilizzato nei confronti che utilizzano l’operatore == per verificare i valori undefined.

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

Definisce un tag XML in un letterale XML. Utilizzate la barra (/) per definire il tag di chiusura.

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

Elementi API correlati