Istruzioni, parole chiave e direttive 

function functionName(parameter0, parameter1, ...rest){ 
	// statement(s) 
} 

Specifica che una funzione accetta qualunque numero di argomenti separati da virgole. L’elenco di argomenti diventa un array disponibile in tutto il corpo della funzione. Il nome dell’array è specificato dopo i caratteri ... nella dichiarazione del parametro. Il parametro può avere qualsiasi nome che non corrisponda a una parola riservata

Se utilizzato con altri parametri, il parametro ... (rest) deve essere dichiarato per ultimo. L’array con parametro ... (rest) viene compilato solo se il numero degli argomenti passati alla funzione supera il numero degli altri parametri.

Ogni argomento dell’elenco di argomenti separati da virgole viene inserito in un elemento dell’array. Se passate un’istanza della classe Array, l’intero array viene inserito in un singolo elemento dell’array con parametro ... (rest).

L’uso di questo parametro rende indisponibile l’oggetto arguments. Anche se il parametro ... (rest) offre la stessa funzionalità dell’array arguments e della proprietà arguments.length, non fornisce invece una funzionalità simile a quella di arguments.callee. Assicuratevi che non sia necessario utilizzare arguments.callee prima di usare il parametro ... (rest).

package {
	import flash.display.MovieClip;
	
	public class RestParamExample extends MovieClip {
		public function RestParamExample() {
			traceParams(100, 130, "two"); // 100,130,two
			trace(average(4, 7, 13));     // 8
		}
	}
}


function traceParams(... rest) {
 	trace(rest);
 }
 
function average(... args) : Number{
	var sum:Number = 0;
	for (var i:uint = 0; i < args.length; i++) {
		sum += args[i];
	}
	return (sum / args.length);
}

Elementi API correlati

Definisce metodi e proprietà delle classi ActionScript principali che sono proprietà fisse anziché proprietà prototipo. Quando impostate l’opzione del compilatore "-as3" su true (impostazione predefinita in Flex Builder 2), lo spazio dei nomi AS3 viene aperto automaticamente per tutte le classi principali. Ciò significa che un’istanza di una classe principale utilizza proprietà e metodi fissi anziché le versioni delle stesse proprietà e degli stessi metodi che sono associate all’oggetto prototipo della classe. L’uso di proprietà fisse solitamente garantisce prestazioni migliori, ma non può assicurare la compatibilità retroattiva con la specifica dell’edizione 3 del linguaggio ECMAScript (ECMA-262).

Elementi API correlati

Viene visualizzata all’interno di un ciclo (for, for..in, for each..in, do..while o while) oppure in un blocco di istruzioni associate a un case particolare in un’istruzione switch. Quando viene utilizzata in un ciclo, l’istruzione break indica a Flash di ignorare il resto del corpo del ciclo, arrestare la ripetizione ciclica ed eseguire l’istruzione che segue l’istruzione ciclica. Quando viene utilizzata in un’istruzione switch, l’istruzione break indica a Flash di ignorare il resto delle istruzioni in quel blocco case e passare alla prima istruzione che segue l’istruzione switch che le racchiude.

Nei cicli nidificati, break ignora solo il resto del ciclo immediato e non esce dall’intera serie di cicli nidificati. Per uscire da una serie completa di cicli nidificati, utilizzate label o try..catch..finally.

L’istruzione break può avere un’etichetta opzionale che deve corrispondere all’etichetta di un’istruzione esterna. L’uso di un’etichetta che non corrisponde all’etichetta di un’istruzione esterna genera un errore di sintassi. Le istruzioni break con etichetta possono essere utilizzate per uscire da più livelli di istruzioni di ciclo nidificate, da istruzioni switch oppure da istruzioni block. Per un esempio, vedete la voce dell’istruzione label.

var i:int = 0;
while (true) { 
	trace(i); 
	if (i >= 10) { 
		break; // this will terminate/exit the loop 
	} 
	i++; 
} 
/*
0 
1 
2 
3 
4 
5 
6 
7 
8 
9 
10*/

Elementi API correlati

case jumpTarget: statements

Definisce una destinazione per l’istruzione switch. Se il parametro jumpTarget è uguale al parametro expression dell’istruzione switch utilizzando l’uguaglianza rigorosa (===), Flash Player esegue le istruzioni del parametro statements finché non incontra un’istruzione break o la fine dell’istruzione switch.

Se si utilizza l’istruzione case al di fuori di un’istruzione switch, si verifica un errore e lo script non viene compilato.

var thisMonth:int = new Date().getMonth(); 
switch (thisMonth) { 
	case 0 : 
		trace("January"); 
		break; 
	case 1 : 
		trace("February"); 
		break; 
	case 5 : 
	case 6 : 
	case 7 : 
		trace("Some summer month"); 
		break; 
	case 8 : 
		trace("September"); 
		break; 
	default : 
		trace("some other month"); 
}

Elementi API correlati

[dynamic] [public | internal] [final] class className [ extends superClass ] [ implements interfaceName[, interfaceName... ] ] { 
	// class definition here
}

Definisce una classe che consente di creare le istanze degli oggetti che condividono i metodi e le proprietà definite dall’utente. Ad esempio, se state sviluppando un sistema di registrazione delle fatture, potete creare una classe Invoice che definisca tutti i metodi e le proprietà richiesti per le fatture. Utilizzerete quindi il comando new Invoice() per creare i relativi oggetti Invoice.

Ogni file ActionScript di origine può contenere una sola classe che è visibile ad altri file di origine o script. La classe visibile esternamente può essere pubblica o interna e deve essere definita all’interno di un’istruzione package. Se includete altre classi nello stesso file, queste devono essere collocate all’esterno dell’istruzione package e alla fine del file.

Il nome della classe visibile esternamente deve corrispondere al nome del file di origine ActionScript che la contiene. Il nome del file di origine esterno deve essere uguale a quello della classe, con l’aggiunta dell’estensione .as. Ad esempio, se la classe viene denominata Studente, il file che la definisce dovrà chiamarsi Studente.as.

Le definizioni di classe non possono essere nidificate, vale a dire non è possibile definire altre classi all’interno di una definizione di classe.

Potete definire un metodo di funzione di costruzione, ovvero un metodo che viene eseguito ogni volta che viene creata una nuova istanza della classe. Il nome del metodo della funzione di costruzione deve corrispondere al nome della classe. Se non definite un metodo di questo tipo, viene creata automaticamente una funzione di costruzione predefinita.

Per indicare che gli oggetti possono aggiungere le proprietà dinamiche e accedervi in fase di runtime, specificare la parola chiave dynamic prima dell’istruzione di classe. Per dichiarare che la classe implementa un’interfaccia, utilizzate la parola chiave implements. Per creare sottoclassi di una classe, utilizzate la parola chiave extends. (Una classe può estendere solo una classe, ma può implementare diverse interfacce.) Potete utilizzare implements e extends in un’unica istruzione. Negli esempi seguenti vengono illustrati gli usi più comuni delle parole chiave implements ed extends:

class C implements Interface_i, Interface_j // OK 
class C extends Class_d implements Interface_i, Interface_j // OK 
class C extends Class_d, Class_e // not OK 

// Filename Plant.as 
package {
  public class Plant { 
	// Define property names and types 
	private var _leafType:String; 
	private var _bloomSeason:String; 
	// Following line is constructor 
	// because it has the same name as the class 
	public function Plant(param_leafType:String, param_bloomSeason:String) { 
		// Assign passed values to properties when new Plant object is created 
		_leafType = param_leafType; 
		_bloomSeason = param_bloomSeason; 
	} 
	// Create methods to return property values, because best practice 
	// recommends against directly referencing a property of a class 
	public function get leafType():String { 
		return _leafType; 
	} 
	public function get bloomSeason():String { 
		return _bloomSeason; 
	} 
  }
}

var pineTree:Plant = new Plant("Evergreen", "N/A"); 
// Confirm parameters were passed correctly 
trace(pineTree.leafType); 
trace(pineTree.bloomSeason); 

Elementi API correlati

const identifier = value 

Specifica una costante, ovvero una variabile alla quale è possibile assegnare un valore una sola volta.

La costante può essere definita mediante la tipizzazione forte aggiungendo un carattere di due punti (:) seguito dal tipo di dati.

const MIN_AGE:int = 21;
MIN_AGE = 18; // error

const product_array:Array = new Array("Studio", "Dreamweaver", "Flash", "ColdFusion", "Contribute", "Breeze"); 
product_array.push("Flex"); // array operations are allowed
product_array = ["Other"];  // assignment is an error
trace(product_array); 

Elementi API correlati

continue [label]

Salta tutte le istruzioni rimanenti nel ciclo più interno e avvia l’iterazione successiva del ciclo come se il controllo fosse passato normalmente alla fine del ciclo. L’istruzione continue non ha alcun effetto al fuori di un ciclo. Nei cicli nidificati, utilizzate il parametro opzionale label per saltare più cicli anziché solo quello più interno.

L’istruzione continue può avere un’etichetta opzionale che deve corrispondere all’etichetta di un’istruzione esterna. L’uso di un’etichetta che non corrisponde all’etichetta di un’istruzione esterna genera un errore di sintassi. Le istruzioni continue con etichetta possono essere utilizzate per saltare più livelli di istruzioni di ciclo nidificate.

var i:int = 0; 
while (i < 10) { 
	if (i % 3 == 0) { 
		i++; 
		continue; 
	} 
	trace(i); 
	i++; 
}

 
for (var i:int = 0; i < 10; i++) { 
	if (i % 3 == 0) { 
		continue; 
	} 
	trace(i); 
}

Elementi API correlati

default: statements 

Definisce l’istruzione case predefinita di un’istruzione switch. Le istruzioni vengono eseguite se il parametro expression dell’istruzione switch non è uguale (in base all’operazione di uguaglianza rigorosa [===]) ad alcuno dei parametri expression che seguono le parole chiave case per una data istruzione switch.

Un’istruzione switch non richiede un’istruzione case default. Un’istruzione case default non deve necessariamente essere l’ultima dell’elenco. Se utilizzate un’istruzione default al di fuori di un’istruzione switch, si verifica un errore e lo script non viene compilato.

var dayOfWeek:int = new Date().getDay(); 
switch (dayOfWeek) { 
	case 1 : 
		trace("Monday"); 
		break; 
	case 2 : 
		trace("Tuesday"); 
		break; 
	case 3 : 
		trace("Wednesday"); 
		break; 
	case 4 : 
		trace("Thursday"); 
		break; 
	case 5 : 
		trace("Friday"); 
		break; 
	default : 
		trace("Weekend"); 
}

Elementi API correlati

La direttiva default xml namespace imposta lo spazio dei nomi predefinito da utilizzare per gli oggetti XML.

Se non si specifica default xml namespace, lo spazio dei nomi predefinito è quello "senza nome" (ovvero con l’URI impostato su una stringa vuota). L’area di validità di una dichiarazione default xml namespace è all’interno di un blocco di funzione, come per una variabile.

var nsDefault1:Namespace = new Namespace("http://www.example.com/namespaces/");
default xml namespace = nsDefault1;
	    
var x1:XML = ;
trace("x1 ns: " + x1.namespace());
			
scopeCheck();	

var x2:XML = ;
trace("x2 ns: " + x2.namespace());
		
function scopeCheck(): void {
	
	var x3:XML = ;
	trace("x3 ns: " + x3.namespace());
				
	var nsDefault2:Namespace = new Namespace("http://schemas.xmlsoap.org/soap/envelope/");
	default xml namespace = nsDefault2;
		    
	var x4:XML = ;
	trace("x4 ns: " + x4.namespace());

}

var nsDefault:Namespace = new Namespace("http://www.example.com/namespaces/");
default xml namespace = nsDefault;
            
var x1:XML = ;

trace(x1.namespace());
	// http://www.example.com/namespaces/

var x2:XML = ;
trace(x2.namespace());
	// http://www.w3.org/1999/XSL/Transform/

var x3:XML = ;
trace(x3.namespace());
	// http://www.example.com/namespaces/

Elementi API correlati

do { statement(s) } while (condition)

Simile a un ciclo while, a eccezione del fatto che le istruzioni vengono eseguite una volta prima della valutazione iniziale della condizione. Quindi, le istruzioni vengono eseguite solo se la condizione restituisce true.

Un ciclo do..while fa in modo che il codice all’interno del ciclo venga eseguito almeno una volta. Questa operazione può essere svolta anche mediante un ciclo while posizionando una copia delle istruzioni da eseguire prima che il ciclo while cominci, ma molti programmatori ritengono che i cicli do..while siano più semplici da leggere.

Se la condizione restituisce sempre true, il ciclo do..while è infinito. Se entrate in un ciclo infinito, si verificano dei problemi in Flash Player e viene visualizzato un messaggio di errore o il lettore si blocca. Quando possibile, se conoscete il numero di ripetizioni necessarie per il ciclo, utilizzate un ciclo for. I cicli for sono facili da leggere e sottoporre a debug, ma non sostituiscono i cicli do..while in tutte le circostanze.

var myVar:Number = 0; 
do { 
	trace(myVar); 
	myVar++; 
} 
while (myVar < 5); 
/*
0 
1 
2 
3 
4
*/

Elementi API correlati

dynamic class className { // class definition here }

Specifica che le istanze di una classe accettano l’aggiunta di proprietà dinamiche in fase di runtime. Se utilizzate l’attributo dynamic su una classe, potete aggiungere proprietà alle istanze di tale classe in fase di runtime. Le classi non contrassegnate come dynamic sono considerate sealed, ovvero non è possibile aggiungere proprietà alle relative istanze.

Se una classe è chiusa (non dinamica), i tentativi di ottenere (get) o impostare (set) le proprietà delle istanze della classe generano un errore. Se il compilatore viene eseguito in modalità rigorosa e si specifica il tipo di dati quando si creano le istanze, i tentativi di aggiungere proprietà a oggetti chiusi generano un errore del compilatore; altrimenti, si verifica un errore in fase di runtime.

L’attributo dynamic non è ereditato dalle sottoclassi. Se estendete una classe dinamica, la sottoclasse è dinamica solo se viene dichiarata con l’attributo dynamic.

package {

	dynamic class Expando  {
	}
	
	class Sealed {
	}
}

var myExpando:Expando = new Expando();
myExpando.prop1 = "new";
trace(myExpando.prop1); // new

var mySealed:Sealed = new Sealed();
mySealed.prop1 = "newer"; // error

Elementi API correlati

if (condition) { 
	// statement(s)
} 
else {
	// statement(s)
}

Specifica le istruzioni da eseguire se la condizione nell’istruzione if restituisce false. Le parentesi graffe ({}) che racchiudono le istruzioni che devono essere eseguite dall’istruzione else non sono necessarie se viene eseguita una sola istruzione.

if (age_txt.text>=18) { 
	trace("welcome, user"); 
} 
else { 
	trace("sorry, junior"); 
	userObject.minor = true; 
	userObject.accessAllowed = false;
}

if (age_txt.text>18) { 
	trace("welcome, user");
} 
else trace("sorry, junior");

if (score_txt.text>90) { 
	trace("A"); 
} 
else if (score_txt.text>75) { 
	trace("B"); 
} 
else if (score_txt.text>60) { 
	trace("C"); 
} 
else { 
	trace("F"); 
}

Elementi API correlati

class className extends otherClassName {}
interface interfaceName extends otherInterfaceName {} 

Definisce una classe che è una sottoclasse di un’altra classe. La sottoclasse eredita tutti i metodi, le proprietà e le funzioni definiti nella superclasse. Le classi contrassegnate come final non possono essere estese.

Potete anche utilizzare la parola chiave extends per estendere un’interfaccia. Un’interfaccia che estende un’altra interfaccia include tutte le dichiarazioni di metodo dell’interfaccia originale.

package {
	class Vehicle { 
	    var numDoors:Number; 
	    var color:String; 
	    public function Vehicle(param_numDoors:Number = 2, param_color:String = null) { 
	        numDoors = param_numDoors; 
	        color = param_color; 
	    } 
	    public function start():void { 
	        trace("[Vehicle] start"); 
	    } 
	    public function stop():void { 
	        trace("[Vehicle] stop"); 
	    } 
	    public function reverse():void { 
	        trace("[Vehicle] reverse"); 
	    } 
	}	
}

package {

	public class Car extends Vehicle { 
	    var fullSizeSpare:Boolean; 
	    public function Car(param_numDoors:Number, param_color:String, param_fullSizeSpare:Boolean) { 
	        numDoors = param_numDoors; 
	        color = param_color; 
	        fullSizeSpare = param_fullSizeSpare; 
	    } 
	    public function activateCarAlarm():void { 
	        trace("[Car] activateCarAlarm"); 
	    } 
	    public override function stop():void { 
	        trace("[Car] stop with antilock brakes"); 
	    } 
	}
}

var myNewCar:Car = new Car(2, "Red", true); 
myNewCar.start(); // [Vehicle] start 
myNewCar.stop(); // [Car] stop with anti-lock brakes 
myNewCar.activateCarAlarm(); // [Car] activateCarAlarm

package {
	class Truck extends Vehicle {
		var numWheels:Number;
		public function Truck(param_numDoors:Number, param_color:String, param_numWheels:Number) { 
			super(param_numDoors, param_color); 
			numWheels = param_numWheels; 
		} 
		public override function reverse():void { 
			beep();
			super.reverse();
		} 
		public function beep():void { 
			trace("[Truck] make beeping sound"); 
		} 
	}
}

var myTruck:Truck = new Truck(2, "White", 18); 
myTruck.reverse(); // [Truck] make beeping sound [Vehicle] reverse 
myTruck.stop(); // [Vehicle] stop

Elementi API correlati

false

Un valore booleano che rappresenta false. Un valore Boolean può essere true o false; il contrario difalse è true.

Quando la tipizzazione automatica dei dati converte false in un numero, questo diventa 0; quando converte false in una stringa, questa diventa "false".

Nota: la stringa"false" viene convertita nel valore Boolean true.

var bool1:Boolean = Boolean(false);

// converts it to the number 0
trace(1 + bool1); // outputs 1

// converts it to a string
trace("String: " + bool1); // outputs String: false

trace(Boolean("false")); // true

if ("false") {
	trace("condition expression evaluated to true");
}
else {
	trace("condition expression evaluated to false");
}
// condition expression evaluated to true

Elementi API correlati

final function methodName() { 
	// your statements here 
}
final class className {}

Specifica che un metodo non può essere sostituito o che una classe non può essere estesa. Un tentativo di sostituire un metodo o di estendere una classe contrassegnata con final genera un errore.

Elementi API correlati

Definisce i metodi della classe Proxy. I metodi della classe Proxy hanno un proprio spazio dei nomi per evitare conflitti in situazioni in cui una sottoclasse Proxy contiene nomi di metodi di istanze che corrispondono a nomi di metodi della classe Proxy.

Elementi API correlati

for ([init]; [condition]; [next]) { 
	// statement(s)
}

Valuta l’espressione init (inizializza) una volta, quindi avvia una sequenza di ripetizione ciclica. La sequenza di ripetizione ciclica inizia dalla valutazione dell’espressione condition. Se l’espressione condition restituisce true, statement viene eseguito e viene valutato next. La sequenza di ripetizione ciclica quindi riprende dalla valutazione dell’espressione condition.

Le parentesi graffe ({}) che racchiudono le istruzioni che devono essere eseguite dall’istruzione for non sono necessarie se viene eseguita una sola istruzione.

var my_array:Array = new Array(); 
for (var i:Number = 0; i < 10; i++) { 
	my_array[i] = (i + 5) * 10;  
} 
trace(my_array); // 50,60,70,80,90,100,110,120,130,140 

var sum:Number = 0; 
for (var i:Number = 1; i <= 100; i++) { 
	sum += i; 
} 
trace(sum); // 5050

var sum:Number = 0; 
for (var i:Number = 1; i <= 100; i++) 
	sum += i; 
trace(sum); // 5050

Elementi API correlati

for (variableIterant:String in object){ 
	// statement(s)
} 

Esegue un’iterazione sulle proprietà dinamiche di un oggetto o sugli elementi di un array ed esegue statement per ogni proprietà o elemento. Le proprietà degli oggetti non vengono ordinate in base a criteri particolari, quindi possono apparire in un ordine apparentemente casuale. Le proprietà fisse, come le variabili e i metodi definiti in una classe, non vengono enumerate dall’istruzione for..in. Per ottenere un elenco di proprietà fisse, utilizzate la funzione describeType, inclusa nel pacchetto flash.utils.

var myObject:Object = {firstName:"Tara", age:27, city:"San Francisco"}; 
for (var prop in myObject) { 
	trace("myObject."+prop+" = "+myObject[prop]); 
} 
/*
myObject.firstName = Tara 
myObject.age = 27 
myObject.city = San Francisco
*/

var myObject:Object = {firstName:"Tara", age:27, city:"San Francisco"}; 
for (var name in myObject) { 
	if (typeof (myObject[name]) == "string") { 
		trace("I have a string property named "+name); 
	} 
}
/*
I have a string property named city
I have a string property named firstName
*/

Altri esempi

Elementi API correlati

for each (variableIterant in object){ 
	// statement(s)
} 

Esegue un’iterazione sulle voci di una raccolta ed esegue statement per ciascuna voce. Introdotta con le estensioni del linguaggio E4X, l’istruzione for each..in può essere utilizzata non solo per gli oggetti XML, ma anche per gli oggetti e gli array. Il ciclo for each..in esegue un’iterazione unicamente sulle proprietà dinamiche di un oggetto, non su quelle fisse. Una proprietà fissa è una proprietà definita in una definizione di classe. Per utilizzare l’istruzione for each..in con un’istanza di una classe definita dall’utente, occorre dichiarare la classe con l’attributo dynamic.

A differenza dell’istruzione for..in, l’istruzione for each..in esegue l’iterazione sui valori delle proprietà di un oggetto, invece che sui nomi delle proprietà.

var myObject:Object = {firstName:"Tara", age:27, city:"San Francisco"}; 
for each (var item in myObject) { 
	trace(item); 
} 
/*
Tara
27
San Francisco
*/

var myArray:Array = new Array("one", "two", "three"); 
for each(var item in myArray) 
	trace(item); 
/*
one
two
three
*/

var myObject:Object = {firstName:"Tara", age:27, city:"San Francisco"}; 
for each (var item in myObject) { 
	if (item is String) {  
		trace("I have a string property with value " + item); 
	} 
}

/*
I have a string property with value Tara
I have a string property with value San Francisco
*/

var doc:XML = 
		
			
Hello
			
Hola
			

			
Bonjour
		;
for each (var item in doc.p) {
	trace(item);
}

/*
Hello
Hola
Bonjour
*/

Altri esempi

function functionName([parameter0, parameter1,...parameterN]) : returnType{ 
	// statement(s) 
} 
var functionName:Function = function ([parameter0, parameter1,...parameterN]) : returnType{ 
	// statement(s) 
} 

Comprende un set di istruzioni definite dall’utente per eseguire una determinata attività. Potete definire una funzione in una posizione e chiamarla da diversi script in un file SWF. Quando si definisce una funzione, è possibile anche specificare gli eventuali parametri. vale a dire i segnaposto dei valori su cui la funzione agisce. Potete passare diversi parametri a una funzione ogni volta che la chiamate, in modo da poterla riutilizzare in situazioni diverse.

Utilizzate l’istruzione return nel blocco statement(s) di una funzione per fare in modo che la funzione generi, ovvero restituisca, un valore.

Uso 1: potete utilizzare la parola chiave function per definire una funzione con un nome, dei parametri e delle istruzioni specifici. Quando uno script chiama una funzione, vengono eseguite le istruzioni nella definizione della funzione. È consentito utilizzare riferimenti di inoltro; all’interno dello stesso script, una funzione può essere dichiarata dopo che è stata chiamata. Una definizione di funzione sostituisce l’eventuale definizione preesistente della stessa funzione. Questa sintassi può essere utilizzata in tutti i casi in cui è consentita un’istruzione.

Uso 2: potete anche utilizzare function per creare una funzione anonima e restituire un riferimento ad essa. Questa sintassi è utilizzata nelle espressioni ed è particolarmente utile per installare i metodi negli oggetti.

Per ulteriori funzionalità, potete utilizzare l’oggetto arguments nella definizione della funzione. L’oggetto arguments è comunemente utilizzato per creare funzioni che accettano un numero variabile di parametri e funzioni anonime ricorsive.

function sqr(xNum:Number) { 
	return Math.pow(xNum, 2); 
} 
var yNum:Number = sqr(3); 
trace(yNum); // 9

var yNum:Number = sqr(3); 
trace(yNum); // 9 
function sqr(xNum:Number) { 
	return Math.pow(xNum, 2); 
}

Elementi API correlati

function get property() : returnType{ 
	// your statements here 
}

Definisce un getter, ovvero un metodo che può essere letto come una proprietà. Un getter è una funzione speciale che restituisce il valore di una proprietà dichiarata con la parola chiave var o const. A differenza di altri metodi, un getter viene chiamato senza parentesi (()) e assomiglia quindi a una variabile.

I getter consentono di applicare il principio denominato "information hiding", che consente di creare un’interfaccia pubblica per una proprietà privata. Il vantaggio dell’information hiding consiste nel fatto che l’interfaccia pubblica rimane inalterata anche se l’implementazione sottostante della proprietà privata cambia.

Un altro vantaggio offerto dai getter è la possibilità di essere sostituiti nelle sottoclassi, a differenza delle proprietà dichiarate con var o const.

Un getter può essere combinato con un setter per creare una proprietà di lettura-scrittura. Per creare una proprietà di sola lettura, create un getter senza un setter corrispondente. Viceversa, per creare una proprietà di sola scrittura, create un setter senza un getter corrispondente.

package {
	public class Team { 
		var teamName:String; 
		var teamCode:String; 
		var teamPlayers:Array = new Array(); 
		public function Team(param_name:String, param_code:String) { 
			teamName = param_name; 
			teamCode = param_code; 
		} 
		public function get name():String { 
			return teamName; 
		} 
		public function set name(param_name:String):void { 
			teamName = param_name; 
		}
	} 
}

var giants:Team = new Team("San Fran", "SFO"); 
trace(giants.name); 
giants.name = "San Francisco"; 
trace(giants.name); 
/*
San Fran San Francisco */

Elementi API correlati

if (condition) {
	// statement(s)
}

Valuta una condizione per determinare l’istruzione successiva da eseguire. Se la condizione restituisce true, Flash esegue le istruzioni che seguono la condizione all’interno delle parentesi graffe ({}). Se la condizione è false, Flash Player ignora le istruzioni all’interno delle parentesi graffe ed esegue le istruzioni dopo le parentesi. Utilizzate l’istruzione if con l’istruzione else per creare una logica ad albero negli script.

Le parentesi graffe ({}) che racchiudono le istruzioni che devono essere eseguite dall’istruzione if non sono necessarie se viene eseguita una sola istruzione.

Elementi API correlati

myClass implements interface01 [, interface02 , ...] 

Specifica che una classe implementa una o più interfacce. Quando una classe implementa un’interfaccia, la classe deve definire tutti i metodi dichiarati nell’interfaccia. Qualsiasi istanza di una classe che implementa un’interfaccia è considerata un membro del tipo di dati definito dall’interfaccia. Di conseguenza l’operatore is restituisce true quando l’istanza della classe è il primo operando e l’interfaccia è il secondo; inoltre, le assegnazioni di tipo forzate da e verso il tipo di dati definito dall’interfaccia funzionano.

Elementi API correlati

import packageName.className 
import packageName.*

Rende disponibili al codice le classi e i pacchetti definiti esternamente. Ad esempio, se volete utilizzare la classe flash.display.Sprite in uno script, dovete importarla. Questo requisito è diverso rispetto alle versioni precedenti di ActionScript, nelle quali la direttiva import era opzionale.

Dopo aver specificato la direttiva import, potete utilizzare il nome completo della classe, che include il nome del pacchetto, oppure solo il nome della classe.

 
import flash.display.Sprite; 

// name of class only
var mySprite:Sprite = new Sprite();

// full class name
var mySprite:flash.display.Sprite = new flash.display.Sprite();

Se il pacchetto contiene più classi alle quali desiderate accedere, potete importarle tutte in un’unica istruzione, come nell’esempio seguente:

import flash.display.*;

La direttiva import importa solo le classi, le funzioni e le variabili che si trovano al livello principale del pacchetto importato. I pacchetti nidificati devono essere importati in modo esplicito.

Se importate una classe ma non la utilizzate nello script, essa non viene esportata nel file SWF. Questo significa che potete importare pacchetti di grandi dimensioni senza dovervi preoccupare delle dimensioni del file SWF; il codice byte associato a una classe viene incluso in un file SWF solo se tale classe viene effettivamente utilizzata. Uno svantaggio dell’importazione delle classi non necessarie è costituito dalla maggiore probabilità di conflitti tra i nomi.

// On Frame 1 of a FLA: 
import adobe.example.*; 
var myFoo:foo = new foo();

include "[path]filename.as"

Comprende il contenuto del file specificato, come se i comandi del file facessero parte dello script di chiamata. La direttiva include viene chiamata al momento della compilazione. Pertanto, se apportate modifiche a un file incluso, dovete salvarlo e ricompilare gli eventuali file FLA che lo utilizzano.

 interface InterfaceName [extends InterfaceName ] {}

Definisce un’interfaccia. Le interfacce sono tipi di dati che definiscono una serie di metodi, i quali devono essere definiti da ogni classe che implementa l’interfaccia.

Un’interfaccia è simile a una classe, con le eccezioni seguenti:

• le interfacce contengono solo le dichiarazioni dei metodi, non le loro implementazioni, ovvero ogni classe che implementa un’interfaccia deve fornire un’implementazione per ciascun metodo dichiarato nell’interfaccia;
• Le definizioni dei metodi di interfaccia non possono avere attributi quali public o private, ma i metodi implementati devono essere contrassegnati come public nella definizione della classe che implementa l’interfaccia.
• Un’interfaccia può ereditare più interfacce mediante l’istruzione extends, oppure per mezzo di una classe tramite l’istruzione implements.

A differenza di ActionScript 2.0, ActionScript 3.0 consente l’utilizzo dei metodi getter e setter nelle definizioni delle interfacce.

Elementi API correlati

[internal] var varName
[internal] const kName
[internal] function functionName()  { 
	// your statements here 
}
[internal] class className{
	// your statements here 
}
[internal] namespace nsName

Specifica che una classe, una variabile, una costante o una funzione è disponibile a qualsiasi chiamante nello stesso pacchetto. Le classi, le proprietà e i metodi appartengono allo spazio dei nomi internal per impostazione predefinita.

Elementi API correlati

label: statement
label: {
    statements
}

Associa un’istruzione a un identificatore al quale è possibile fare riferimento con break o continue. Nei cicli nidificati, l’istruzione break o continue che non fa riferimento a un’etichetta può saltare solo il resto del ciclo immediato e non l’intera serie di cicli nidificati. Tuttavia, se l’istruzione che definisce l’intera serie di cicli è associata a un’etichetta, un’istruzione break o continue può saltare l’intera serie di cicli facendo riferimento a tale etichetta.

Le etichette consentono anche di uscire da un blocco di istruzioni. Non potete inserire in un blocco di istruzioni un’istruzione break che non fa riferimento a un’etichetta, a meno che il blocco non faccia parte di un ciclo. Se il blocco di istruzioni è associato a un’etichetta, potete inserire nel blocco un’istruzione break che fa riferimento a tale etichetta.

outerLoop: for (var i:int = 0; i < 10; i++) {
	for (var j:int = 0; j < 10; j++) {
		if ( (i == 8) && (j == 0)) {
			break outerLoop;
		}
		trace(10 * i + j);
	}
}
/*
1
2
...
79
*/

foo: {
	trace("a");
	break foo;
	trace("b");
}
// a

Elementi API correlati

namespace name [= uri]

Consente di controllare la visibilità delle definizioni. Gli spazi dei nomi predefiniti includono public, private, protected e internal.

Nelle procedure seguenti viene illustrato come creare, applicare e fare riferimento a uno spazio dei nomi.

• Innanzi tutto, definite lo spazio dei nomi personalizzato mediante la parola chiave namespace. Ad esempio, il codice namespace version1 crea uno spazio dei nomi chiamato version1.
• Quindi, applicate lo spazio dei nomi a una proprietà o a un metodo specificandolo nella proprietà o nella dichiarazione del metodo. Ad esempio, il codice version1 myProperty:String crea una proprietà chiamata myProperty che appartiene allo spazio dei nomi version1.
• Infine, fate riferimento allo spazio dei nomi utilizzando la parola chiave use o anteponendo un identificatore allo spazio dei nomi. Ad esempio, il codice use namespace version1; fa riferimento allo spazio dei nomi version1 per le righe di codice successive, e il codice version1::myProperty fa riferimento allo spazio dei nomi version1 per la proprietà myProperty.

Elementi API correlati

native function functionName();
class className { 
	native function methodName();
}

Specifica che una funzione o un metodo è implementato da Flash Player nel codice nativo. Flash Player utilizza la parola chiave native internamente per dichiarare funzioni e metodi nell’API ActionScript. Questa parola chiave non può essere utilizzata nel codice dell’utente.  

null

Valore speciale che può essere assegnato a variabili o restituito da una funzione quando non vengono forniti dati. Potete utilizzare null per rappresentare valori mancanti o che non presentano un tipo di dati definito.

Non confondete il valore null con il valore speciale undefined. Quando null e undefined vengono confrontati mediante l’operatore di uguaglianza (==), risultano uguali. Tuttavia, quando null e undefined vengono confrontati mediante l’operatore di uguaglianza rigorosa (===), non risultano uguali.

var testArray:Array = new Array();
testArray[0] = "fee";
testArray[1] = "fi";
testArray[4] = "foo";

for (i = 0; i < 6; i++) {
    if (testArray[i] == null) {
        trace("testArray[" + i + "] == null");
    }
}

/* 
testArray[2] == null
testArray[3] == null
testArray[5] == null
*/

Elementi API correlati

Definisce i metodi della classe ObjectProxy. I metodi della classe ObjectProxy hanno un proprio spazio dei nomi per evitare conflitti in situazioni in cui una sottoclasse Proxy contiene nomi di metodi di istanze che corrispondono a nomi di metodi della classe Proxy.

override function name() { 
	// your statements here 
}

Specifica che un metodo sostituisce un metodo ereditato. Per sostituire un metodo ereditato, occorre utilizzare l’attributo override e verificare che il nome, l’attributo della proprietà class, il numero e il tipo di parametri e il tipo restituito corrispondano esattamente. Non è consentito tentare di sostituire un metodo senza utilizzare l’attributo override. Analogamente, viene generato un errore se si utilizza l’attributo override ma al metodo non corrisponde un metodo ereditato.

Non potete utilizzare l’attributo override sugli elementi seguenti:

• Variabili
• Costanti
• Metodi statici
• Metodi non ereditati
• Metodi che implementano un metodo di interfaccia
• Metodi ereditati contrassegnati come final nella superclasse

Anche se non potete sostituire una proprietà dichiarata con var o const, potete ottenere una funzionalità simile impostando come getter-setter la proprietà della classe base e sostituendo i metodi definiti con get e set.

Elementi API correlati

package packageName {
    class someClassName { 
    } 
}

Consente di organizzare il codice in gruppi distinti che possono essere importati da altri script. Dovete utilizzare la parola chiave package per indicare che una classe è un membro di un pacchetto.

Elementi API correlati

class className{ 
	private var varName;
	private const kName;
	private function methodName() { 
		// your statements here 
	}
	private namespace nsName;
}

Specifica che una variabile, una costante o un metodo è disponibile solo per la classe che ne contiene la dichiarazione o la definizione. A differenza che in ActionScript 2.0, in ActionScript 3.0 private non fornisce più l’accesso alle sottoclassi. Inoltre, private limita l’accesso sia in fase di compilazione che in runtime. Per impostazione predefinita, una variabile o una funzione è disponibile a qualsiasi chiamante nello stesso pacchetto. Utilizzate questa parola chiave se desiderate limitare l’accesso a una variabile o funzione.

Potete utilizzare questa parola chiave solo nelle definizioni di classe, non nelle definizioni di interfaccia. Non potete applicare private a una classe o a qualunque altra definizione a livello di pacchetto.

class A { 
  private var alpha:String = "visible only inside class A"; 
  public var beta:String = "visible everywhere"; 
}
	
class B extends A {
  function B() {
    alpha = "Access attempt from subclass"; // error
  }
}

Elementi API correlati

class className{ 
	protected var varName;
	protected const kName;
	protected function methodName() { 
		// your statements here 
	}
	protected namespace nsName;
}

Specifica che una variabile, una costante, un metodo o uno spazio dei nomi è disponibile solo per la classe che ne contiene la definizione e per le eventuali sottoclassi. La definizione di protected in ActionScript 3.0 è simile a quella della versione ActionScript 2.0 di private, con la differenza che protected limita l’accesso sia in fase di compilazione che in runtime. Per impostazione predefinita, una variabile o una funzione è disponibile a qualsiasi chiamante nello stesso pacchetto. Utilizzate questa parola chiave se desiderate limitare l’accesso a una variabile o funzione.

Potete utilizzare questa parola chiave solo nelle definizioni di classe, non nelle definizioni di interfaccia. Non potete applicare private a una classe o a qualunque altra definizione a livello di pacchetto.

La definizione diprotected in ActionScript 3.0 è più restrittiva di quella di protected nel linguaggio di programmazione Java. In ActionScript 3.0 protected nel linguaggio di programmazione Java protected consente l’accesso anche a qualsiasi classe dello stesso pacchetto. Ad esempio, se una classe denominata Base contiene una proprietà contrassegnata come protected, in ActionScript 3.0 solo le classi che estendono Base possono accedere alla proprietà protetta. In Java, qualunque classe dello stesso pacchetto di Base ha accesso alla proprietà protetta, anche se non si tratta di una sottoclasse di Base.

class A { 
  private var alpha:String = "visible only inside class A"; 
  protected var beta:String = "visible inside class A and its subclasses"; 
}
	
class B extends A {
  public function B() {
    beta = "Access attempt from subclass succeeded";
    trace(beta);  // Access attempt from subclass succeeded
  }
}

Elementi API correlati

public var varName
public const kName
public function functionName()  { 
	// your statements here 
}
public class className {
	// your statements here 
}
public namespace nsName

Specifica che una classe, una variabile, una costante o un metodo è disponibile a qualsiasi chiamante. Classi, variabili e metodi sono interni per impostazione predefinita, ovvero sono visibili solo all’interno del pacchetto corrente. Per rendere visibile ad altri chiamanti una classe, una variabile o un metodo, dovete utilizzare l’attributo public.

class User { 
	public var age:Number; 
	public var fname:String; 
} // end of class User definition
 
var jimmy:User = new User(); 
jimmy.age = 27; 
jimmy.fname = "jimmy";
trace(jimmy.age, jimmy.fname); // 27 jimmy

Elementi API correlati

function functionName () {
	return [expression]
}

Fa in modo che l’esecuzione torni immediatamente alla funzione di chiamata. Se l’istruzione return è seguita da un’espressione, quest’ultima viene valutata e viene restituito il risultato.

Se la definizione di una funzione include un tipo restituito, l’istruzione return deve essere seguita da un’espressione. Se non viene specificato un tipo restituito e l’istruzione return è utilizzata da sola, restituisce il valore undefined.

Non è possibile eseguire return su più valori; se tentate di eseguire questa operazione, viene restituito solo l’ultimo valore. Nel seguente esempio, viene restituito c:

return a, b, c ;

Per fare in modo che vengano restituiti più valori, utilizzate un array o un oggetto.

function sum(a:Number, b:Number, c:Number):Number { 
	return (a + b + c); 
} 
var newValue:Number = sum(4, 32, 78); 
trace(newValue); // 114

Elementi API correlati

function set property(newValue:*) : void{ 
	// your statements here 
}

Definisce un setter, ovvero un metodo che appare nell’interfaccia pubblica come proprietà. Un setter è un metodo speciale che imposta il valore di una proprietà dichiarata con la parola chiave var. A differenza di altri metodi, un setter viene chiamato senza parentesi (()) e assomiglia quindi a una variabile.

I setter consentono di applicare il principio denominato "information hiding", che consente di creare un’interfaccia pubblica per una proprietà privata. Il vantaggio dell’information hiding consiste nel fatto che l’interfaccia pubblica rimane inalterata anche se l’implementazione sottostante della proprietà privata cambia.

Un altro vantaggio offerto dai setter è la possibilità di essere sostituiti nelle sottoclassi, a differenza delle proprietà dichiarate con var.

Il tipo restituito di un setter deve essere void o non specificato.

Un setter può essere combinato con un getter per creare una proprietà di lettura-scrittura. Per creare una proprietà di sola lettura, create un getter senza un setter corrispondente. Viceversa, per creare una proprietà di sola scrittura, create un setter senza un getter corrispondente.

package {
	class User { 
	    private var userAge:Number; 
	    
	    public function get age():Number {
	    	return userAge;
	    }
	    
	    public function set age(x:Number):void {
	    	userAge = x;	
	    }
	} 
} 

var myUser:User = new User();
myUser.age = 25;
trace(myUser.age); // 25

Elementi API correlati

class someClassName{ 
	static var varName; 
	static const kName;
	static function methodName() { 
		// your statements here
	} 
}

Specifica che una variabile, una costante o un metodo appartiene alla classe e non alle sue istanze.

Per accedere a un membro statico di una classe, utilizzate il nome della classe invece del nome di un’istanza. Ad esempio, la classe Date ha un metodo statico denominato parse(), che può essere chiamato solo utilizzando la sintassi seguente:

Date.parse()

Il metodo parse non può essere chiamato su un’istanza della classe Date. Ad esempio, il codice seguente genera un errore:

var myDate:Date = new Date();
            myDate.parse("Jan 01 00:00:00 2006"); // error

Potete utilizzare la parola chiave static solo nelle definizioni di classe, non nelle definizioni di interfaccia.

I membri statici delle classi non vengono ereditati. Non è possibile fare riferimento a un membro statico di una classe utilizzando il nome di una sottoclasse, come avviene in Java o C++. Tuttavia, potete fare riferimento a una variabile statica o a un metodo statico all’interno di una classe o di una sottoclasse, senza utilizzare alcun qualificatore. Vedete l’esempio riportato di seguito.

Non potete utilizzare l’istruzione super o la parola chiave this all’interno di metodi statici.

class Users { 
	private static var numInstances:Number = 0; 
	function Users() { 
		numInstances++; 
	} 
	static function get instances():Number { 
		return numInstances; 
	} 
}

trace(Users.instances); 
var user1:Users = new Users(); 
trace(Users.instances); 
var user2:Users = new Users(); 
trace(Users.instances); 

class PowerUsers extends Users{
    function PowerUsers() {
        instances++;  // unqualified reference to static property Users.instances is legal
    }
}

trace(PowerUsers.instances); // error, cannot access static property using PowerUsers class

super([arg1, ..., argN])
super.method([arg1, ..., argN])

Richiama la versione superclasse o principale di un metodo o di una funzione di costruzione. Quando è utilizzata all’interno del corpo di una funzione di costruzione di classe, l’istruzione super() richiama la versione superclasse della funzione di costruzione. La chiamata alla funzione di costruzione della superclasse deve contenere il numero corretto di argomenti. Notate che la funzione di costruzione della superclasse viene chiamata in ogni caso, anche se non viene specificata esplicitamente. In mancanza di una chiamata esplicita, viene inserita automaticamente una chiamata senza argomenti prima della prima istruzione nel corpo della funzione di costruzione della superclasse. Di conseguenza, se definite una funzione di costruzione in una sottoclasse e la funzione di costruzione della superclasse accetta uno o più argomenti, dovete chiamare esplicitamente la funzione di costruzione della superclasse con il numero corretto di argomenti, altrimenti verrà generato un errore. La chiamata alla funzione di costruzione della superclasse, tuttavia, non deve essere necessariamente la prima istruzione nella funzione di costruzione della sottoclasse, come occorreva fare in ActionScript 2.0.

Quando viene utilizzata nel corpo del metodo di un’istanza, l’istruzione super può essere specificata con l’operatore punto (.) per chiamare la versione superclasse di un metodo, e può facoltativamente passare gli argomenti (arg1 ... argN) al metodo della superclasse. Questo è utile per creare metodi di sottoclasse che oltre ad aggiungere comportamenti supplementari ai metodi della superclasse, li richiamano affinché eseguano il loro comportamento originale.

Non potete utilizzare l’istruzione super all’interno di metodi statici.

Elementi API correlati

switch (expression) {
	caseClause: 
	[defaultClause:] 
}

Determina il passaggio del controllo a un’istruzione di una serie, a seconda del valore di un’espressione. Tutte le istruzioni switch devono includere un’istruzione case predefinita che viene eseguita se nessuna delle istruzioni case corrisponde all’espressione. Ogni istruzione case deve terminare con un’istruzione break, in modo da uscire correttamente dall’istruzione. In caso di mancata uscita da un’istruzione case viene eseguito il codice dell’istruzione case successiva, anche se questa non corrisponde all’espressione da valutare.

var switchExpression:int = 3;
		
switch (switchExpression) {
	case 0:
		trace(0);
		break;
	case 1:
		trace(1);
		break;
	case 2:
		trace(2);
		break;
	default:
		trace("Not 0, 1, or 2");
}

// Not 0, 1, or 2

Elementi API correlati

this

Un riferimento all’oggetto che contiene un metodo. Durante l’esecuzione di uno script, la parola chiave this fa riferimento all’oggetto che contiene lo script. All’interno del corpo di una funzione, la parola chiave this fa riferimento all’istanza di classe che contiene il metodo chiamato.

// incorrect version of Simple.as
/*
dynamic class Simple {
    function callfunc() {
        func();
    }
}
*/
// correct version of Simple.as
dynamic class Simple {
    function callfunc() {
        this.func();
    }
}

var simpleObj:Simple = new Simple();
simpleObj.func = function() {
	trace("hello there");
}
simpleObj.callfunc();

throw expression 

Crea (genera) un errore che può essere gestito, o rilevato, mediante un blocco di codice catch. Se un’eccezione non viene rilevata da un blocco catch, la rappresentazione sotto forma di stringa del valore generato viene inviata al pannello Output. Se un’eccezione non viene rilevata da un blocco catch o finally, la rappresentazione sotto forma di stringa del valore generato viene inviata al file di registro.

Tipicamente, vengono generate istanze della classe Error o delle sue sottoclassi (vedete la sezione degli esempi).

function checkEmail(email:String) { 
	if (email.indexOf("@") == -1) { 
		throw new Error("Invalid email address"); 
	} 
} 
checkEmail("someuser_theirdomain.com");

try { 
	checkEmail("Joe Smith"); 
} 
catch (e) { 
	trace(e); 
}
// Error: Invalid email address.

// Define Error subclass InvalidEmailError 
class InvalidEmailAddress extends Error { 
    public function InvalidEmailAddress() {
    	message = "Invalid email address."; 
    }
}

import InvalidEmailAddress; 
function checkEmail(email:String) { 
	if (email.indexOf("@") == -1) { 
		throw new InvalidEmailAddress(); 
	} 
} 
try { 
	checkEmail("Joe Smith"); 
} 
catch (e) { 
	trace(e);
}
// Error: Invalid email address.

Altri esempi

Elementi API correlati

true

Un valore booleano che rappresenta true. Un valore Boolean può essere true o false; il contrario di true è false. Quando la tipizzazione automatica dei dati converte true in un numero, questo diventa 1; quando converte true in una stringa, questa diventa "true".

var shouldExecute:Boolean;
// ...
// code that sets shouldExecute to either true or false goes here
// shouldExecute is set to true for this example:

shouldExecute = true;

if (shouldExecute == true) {
    trace("your statements here");
}

// true is also implied, so the if statement could also be written:
// if (shouldExecute) {
//         trace("your statements here");
// }

var myNum:Number;
myNum = 1 + true;
trace(myNum); // 2

Elementi API correlati

try { 
    // try block 
} finally { 
    // finally block  
} 

try { 
    // try block 
} catch(error[:ErrorType1]) {
    // catch block 
} [catch(error[:ErrorTypeN]) { 
    // catch block 
}] [finally {
    // finally block 
}]

Racchiude un blocco di codice nel quale può verificarsi un errore, quindi risponde all’errore. La gestione delle eccezioni, implementata mediante le istruzioni try..catch..finally è il meccanismo principale per la gestione delle condizioni di errore di runtime in ActionScript 3.0. Quando si verifica un errore runtime, Flash Player genera un’eccezione, ovvero sospende la normale esecuzione del codice e crea un oggetto speciale di tipo Error. Quindi, Flash Player passa (genera) l’oggetto errore al primo blocco catch disponibile. Se non è disponibile alcun blocco catch, l’eccezione viene considerata irrisolta. e determina l’interruzione dello script.

Potete utilizzare l’istruzione throw per generare esplicitamente eccezioni nel codice. Può essere specificato qualunque valore per questa istruzione, ma è consigliato l’uso di un oggetto perché garantisce flessibilità ed è conforme al comportamento di Flash Player.

Per rilevare un’eccezione, generata da Flash Player o dal codice, inserire in un blocco try il codice da cui potrebbe essere generata. Se un qualsiasi codice all’interno del blocco try genera un’eccezione, il controllo passa al blocco catch (se presente), quindi al blocco di codice finally (se presente). Il blocco finally viene sempre eseguito, a prescindere che sia stata generata un’eccezione o meno. Se il codice nel blocco try non genera un’eccezione (ovvero se il blocco try viene completato normalmente), il codice nel blocco catch viene ignorato, ma quello nel bloccofinally viene comunque eseguito. Il blocco finally viene eseguito anche se il blocco try viene chiuso mediante un’istruzione return.

Un blocco try deve essere seguito da un blocco catch, o da un blocco finally, o da entrambi. Un unico blocco try può avere più blocchi catch ma solo un blocco finally. Potete nidificare i blocchi try per il numero di livelli (profondità) desiderati.

Il parametro error specificato in un gestore catch deve essere un identificatore semplice (e o theException o x). È anche possibile assegnare un tipo al parametro. Quando sono utilizzati con più blocchi catch, i parametri con tipo consentono di rilevare più tipi di oggetti error generati da un unico blocco try.

Se l’eccezione generata è un oggetto, il tipo corrisponde se l’oggetto generato è una sottoclasse del tipo specificato. Se viene generato un errore di un tipo specifico, viene eseguito il blocco catch che gestisce l’errore corrispondente. Se viene generata un’eccezione di un tipo diverso da quello specificato, il blocco catch non viene eseguito e l’eccezione viene automaticamente eliminata dal blocco try verso un gestore catch corrispondente.

Se un errore viene generato all’interno di una funzione, e la funzione non comprende un gestore catch, ActionScript esce da quella funzione e da tutte le funzioni di chiamata, finché non viene trovato un blocco catch. Nel corso di questo processo, i gestori finally vengono chiamati a tutti i livelli.

Nota: se in un blocco try c’è un dispatcher di eventi che chiama il gestore di eventi, il blocco catch non rileva l'errore se generato nel gestore di eventi. Ogni errore generato in seguito può quindi essere rilevato intercettando LoaderInfo.uncaughtErrorEvents.

import flash.display.Sprite;

var spr:Sprite = new Sprite();
try {
	spr.addChild(spr);
}
catch (e:ArgumentError) {
	trace (e); // ArgumentError: Error #2024: An object may not be added as a child of itself.
}

class RecordSetException extends Error { 
	public function RecordSetException () {
		message = "Record set exception occurred."; 
	}
}

class MalformedRecord extends Error { 
	public function MalformedRecord {
		message = "Malformed record exception occurred."; 
	}
}

class RecordSet { 
	public function sortRows() { 
		var returnVal:Number = randomNum(); 
		if (returnVal == 1) { 
			throw new RecordSetException(); 
		} 
		else if (returnVal == 2) { 
			throw new MalformedRecord(); 
		} 
	}
	public function randomNum():Number { 
		return Math.round(Math.random() * 10) % 3; 
	}
}

import RecordSet; 
var myRecordSet:RecordSet = new RecordSet();
try { 
	myRecordSet.sortRows(); 
	trace("everything is fine"); 
} 
catch (e:RecordSetException) { 
	trace(e.toString()); 
} 
catch (e:MalformedRecord) { 
	trace(e.toString()); 
}

Altri esempi

Elementi API correlati

use namespace ns1[, ns2, ...nsN]

Determina l’aggiunta degli spazi dei nomi specificati alla serie di spazi dei nomi aperti. Gli spazi dei nomi specificati vengono rimossi dalla serie di spazi dei nomi aperti dopo l’uscita dal blocco di codice corrente. La direttiva use namespace può apparire al livello principale di un programma o di una definizione di pacchetto o di classe.

Elementi API correlati

var variableName [= value1][...,variableNameN[=valueN]] 

Specifica una variabile. Se dichiarate delle variabili all’interno di una funzione, tali variabili sono locali, vengono definite per la funzione e scadono al termine della chiamata della funzione.

Non è possibile dichiarare come variabile locale una variabile che si trova nell’area di validità un altro oggetto.

my_array.length = 25; // ok 
var my_array.length = 25; // syntax error 

È possibile assegnare un tipo di dati a una variabile aggiungendo un carattere di due punti seguito dal tipo di dati.

Potete dichiarare più variabili in un’istruzione separando le dichiarazioni mediante virgole (tuttavia, questa sintassi può ridurre la chiarezza del codice):

var first:String = "Bart", middle:String = "J.", last:String = "Bartleby";

var product_array:Array = new Array("Studio", "Dreamweaver", "Flash", "ColdFusion", "Contribute", "Breeze"); 
product_array.push("Flex"); 
trace(product_array); 
// Studio,Dreamweaver,Flash,ColdFusion,Contribute,Breeze,Flex

Elementi API correlati

while (condition) { 
	// statement(s)
}

Valuta una condizione e, se questa restituisce true, esegue una o più istruzioni prima di tornare a valutare la condizione. Dopo che la condizione ha restituito false, le istruzioni vengono ignorate e il ciclo termina.

L’istruzione while esegue le serie di operazioni seguenti. Ogni ripetizione dal punto 1 al punto 4 viene definita iterazione del ciclo. La condizione viene verificata all’inizio di ogni iterazione, come nei passaggi seguenti:

1. L’espressione condition viene valutata.
2. Se condition restituisce true o un valore che viene convertito nel valore booleano true (ad esempio, un numero diverso da zero), passare al punto 3. Altrimenti, l’istruzione while viene completata e l’esecuzione viene ripresa in corrispondenza della prima istruzione dopo il ciclo while.
3. Eseguire il blocco di istruzioni statement(s). Se viene incontrata un’istruzione continue, ignorate le istruzioni rimanenti e passate al punto 1. Se viene incontrata un’istruzione break, l’istruzione while viene completata e l’esecuzione riprende dalla prima istruzione successiva al ciclo while.
4. Andate al punto 1.

La ripetizione ciclica viene solitamente utilizzata per eseguire un’azione finché la variabile counter è inferiore al valore specificato. Alla fine di ogni ciclo, la variabile counter viene incrementata finché non viene raggiunto il valore specificato. A quel punto, la condizione non è più true e il ciclo termina.

Le parentesi graffe ({}) che racchiudono le istruzioni che devono essere eseguite dall’istruzione while non sono necessarie se viene eseguita una sola istruzione.

var i:Number = 0; 
while (i < 20) { 
	trace(i); 
	i += 3; 
}
/*
0 
3 
6 
9 
12
15 
18
*/

Elementi API correlati

with (object:Object) { 
	// statement(s)
}

Definisce un oggetto predefinito da utilizzare per l’esecuzione di una o più istruzioni, con il possibile risultato di ridurre la quantità di codice da scrivere.

Il parametro object diventa il contesto in cui le proprietà, le variabili e le funzioni del parametro statement(s) vengono lette. Ad esempio, se object è my_array e due delle proprietà specificate sono length e concat, queste proprietà vengono automaticamente lette come my_array.length e my_array.concat. In un altro esempio, seobject è state.california, qualsiasi azione o istruzione interna all’istruzione with viene chiamata dall’interno dell’istanza california.

Per trovare il valore di un identificatore nel parametro statement(s), ActionScript lo cerca in tutti i livelli della catena, secondo un ordine prestabilito, partendo dall’inizio della catena delle aree di validità specificata da object.

La catena delle aree di validità utilizzata dall’istruzione with per trovare gli identificatori comincia con il primo elemento dell’elenco seguente e continua fino all’ultimo elemento:

• L’oggetto specificato nel parametro object nell’istruzione with più interna
• L’oggetto specificato nel parametro object nell’istruzione with più esterna
• L’oggetto Activation (un oggetto provvisorio creato automaticamente quando lo script chiama una funzione che contiene le variabili locali chiamate nella funzione)
• L’oggetto contenente lo script in fase di esecuzione
• L’oggetto Global (oggetti incorporati quali Math e String)

Per impostare una variabile all’interno di un’istruzione with, è necessario aver dichiarato la variabile fuori dall’istruzione with, oppure immettere il percorso completo della linea temporale in cui la variabile dovrà risiedere. Se impostate una variabile in un’istruzione with senza dichiararla, l’istruzione with cerca il valore in base alla catena delle aree di validità. Se la variabile non esiste già, il nuovo valore viene impostato sulla linea temporale da cui l’istruzione with era stata chiamata.

function polar(r:Number):void { 
	var a:Number, x:Number, y:Number; 
	with (Math) { 
		a = PI * pow(r, 2); 
		x = r * cos(PI); 
		y = r * sin(PI / 2); 
	} 
	trace("area = " + a); 
	trace("x = " + x); 
	trace("y = " + y); 
} polar(3);
/* 
area = 28.2743338823081 
x = -3 
y = 3
*/