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. Il 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 si passa 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. Assicurarsi 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"); // Output: 100,130,two
            trace(average(4, 7, 13));     // Output: 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);
}

Vedere anche

Definisce metodi e proprietà delle classi ActionScript principali che sono proprietà fisse anziché proprietà prototipo. Quando si imposta l'opzione del compilatore "-as3" su true (which is the default setting 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).

Vedere anche

Viene visualizzata all'interno di un ciclo (for, for..in, for each..in, do..whileowhile) oppure in un blocco di istruzioni associate a un caso 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 uno 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, utilizzare 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, vedere la voce dell'istruzione label.

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

Vedere anche

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.

Nota: il parametro statements deve sempre terminare con un'istruzione break. Se si omette l'istruzione break dal parametro statements, l'esecuzione prosegue con l'istruzione case successiva invece di uscire dall'istruzione switch.

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

Vedere anche

[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 si sta sviluppando un sistema di registrazione delle fatture, è possibile creare una classe Invoice che definisca tutti i metodi e le proprietà richiesti per le fatture. A quel punto, si può utilizzare il nuovo comando new Invoice() per creare gli 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 si includono 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.

È possibile 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 si definisce 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, utilizzare la parola chiave implements. Per creare sottoclassi di una classe, utilizzare la parola chiave extends. (Una classe può estendere solo una classe, ma può implementare diverse interfacce.) È possibile utilizzare implements ed extends in un'unica istruzione. Gli esempi seguenti mostrano 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); 

Vedere anche

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

Vedere anche

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 di fuori di un ciclo. Nei cicli nidificati, utilizzare 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++; 
}

In un ciclo for, l'istruzione continue può anche essere utilizzata per ignorare il resto del corpo del ciclo. Nell'esempio seguente, se i % 3 è uguale a 0, l'istruzione trace(i) viene ignorata:

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

Vedere anche

default: statements 

Definisce il caso predefinito 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 si utilizza 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"); 
}

Vedere anche

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 default xml namespace dichiarazione è 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 = <test1 />;
trace("x1 ns: " + x1.namespace());
            
scopeCheck();    

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

}

L'output trace() di questo esempio è il seguente:

x1 ns: http://www.example.com/namespaces/
x3 ns: 
x4 ns: http://schemas.xmlsoap.org/soap/envelope/
x2 ns: http://www.example.com/namespaces/

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

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

var x2:XML = <test2 xmlns = "http://www.w3.org/1999/XSL/Transform/" />;
trace(x2.namespace());
    // http://www.w3.org/1999/XSL/Transform/

var x3:XML = <test3 xmlns:soap-env="http://schemas.xmlsoap.org/soap/envelope/" />;
trace(x3.namespace());
    // http://www.example.com/namespaces/

Vedere anche

do { statement(s) } while (condition)

Simile a un ciclo while, ad 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 si entra 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 si conosce il numero di ripetizioni necessarie per il ciclo, utilizzare 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); 
/* output: 
0 
1 
2 
3 
4
*/

Vedere anche

dynamic class className { // class definition here }

Specifica che le istanze di una classe accettano l'aggiunta di proprietà dinamiche in fase di runtime. Se si utilizza l'attributo dynamic su una classe, è possibile aggiungere proprietà alle istanze di tale classe in fase di runtime. Le classi non contrassegnate come dynamic sono considerate chiuse, 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 si estende 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); // output: new

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

Vedere anche

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

Vedere anche

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.

La parola chiave extends può essere utilizzata anche per estendere un'interfaccia. Un'interfaccia che estende un'altra interfaccia include tutte le dichiarazioni di metodo dell'interfaccia originale.

L'esempio seguente mostra il contenuto di un file di nome Vehicle.as, che definisce la classe Vehicle:

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(); // output: [Vehicle] start 
myNewCar.stop(); // output: [Car] stop with anti-lock brakes 
myNewCar.activateCarAlarm(); // output: [Car] activateCarAlarm

Si potrebbe anche scrivere una sottoclasse della classe Vehicle mediante l'istruzione super, che può essere utilizzata dalla sottoclasse per accedere alla funzione di costruzione della superclasse. L'esempio seguente mostra un terzo file ActionScript, denominato Truck.as, sempre nella stessa directory. La classe Truck utilizza super nella funzione di costruzione e nel metodo reverse() sostituito.

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(); // output: [Truck] make beeping sound [Vehicle] reverse 
myTruck.stop(); // output: [Vehicle] stop

Vedere anche

false

Un valore booleano che rappresenta false. Un valore booleano può essere true o false; il contrario di false è 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 booleano 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

L'esempio seguente mostra che la stringa "false" viene convertita nel valore booleano true:

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

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

Vedere anche

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.

Vedere anche

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.

Vedere anche

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, viene eseguito statement 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); // output: 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); // output: 5050

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

Vedere anche

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, utilizzare la funzionedescribeType(), 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]); 
} 
/* output:
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); 
    } 
}
/* output:
I have a string property named city
I have a string property named firstName
*/

Vedere anche

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'istruzionefor each..in può essere utilizzata non solo per gli oggetti XML, ma anche per gli oggetti e gli array. L'istruzione 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); 
} 
/* output:
Tara
27
San Francisco
*/

var myArray:Array = new Array("one", "two", "three"); 
for each(var item in myArray) 
    trace(item); 
/* output: 
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); 
    } 
}

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

var doc:XML = 
        <body>
            <p>Hello</p>
            <p>Hola</p>
            <hr />
            <p>Bonjour</p>
        </body>;
for each (var item in doc.p) {
    trace(item);
}

/* output:
Hello
Hola
Bonjour
*/

Vedere anche

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à. È possibile definire una funzione in una posizione e chiamarlada 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. È possibile trasmettere diversi parametri a una funzione ogni volta che viene chiamata, in modo da poterlo la funzione in situazioni diverse.

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

Uso 1: è possibile utilizzare la parola chiave function per definire una funzione con un nome, dei parametri e delle istruzioni specifiche. 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: è anche possibile 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à, è possibile 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); // output: 9

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

Vedere anche

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, creare un getter senza un setter corrispondente. Viceversa, per creare una proprietà di sola scrittura, creare 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); 
/* output: 
San Fran San Francisco */

Quando si esegue il trace di giants.name, si utilizza un metodo getter per restituire il valore della proprietà.

Vedere anche

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

Valuta una condizione per determinare l'istruzione successiva da eseguire. Se la condizione restituisce true, Flash Player 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. Utilizzare 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.

Vedere anche

myClass implements interface01 [, interface02 , ...] 

Specifica che una class 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.

Nota: per utilizzare questa parola chiave, è necessario specificare ActionScript 2.0 e Flash Player 6 o superiore nella scheda Flash della finestra di dialogo Impostazioni pubblicazione del file FLA. Questa parola chiave è supportata solo quando è utilizzata nei file di script esterni, non negli script scritti nel pannello Azioni.

Vedere anche

import packageName.className 
import packageName.*

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

Dopo aver specificato la direttiva import è possibile 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 si desidera accedere, è possibile 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 si importa una classe ma non la si utilizza nello script, essa non viene esportata nel file SWF. Questo significa che è possibile importare pacchetti di grandi dimensioni senza doversi 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();

Vedere anche

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 si apportano modifiche a un file incluso, è necessario salvarlo e ricompilare gli eventuali file FLA che lo utilizzano.

Vedere anche

 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; vale a dire, 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.

Vedere anche

[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 per impostazione predefinita allo spazio dei nomi internal.

Vedere anche

label: statement
label: {
    statements
}

Associa un'istruzione a un identificatore al quale è possibile fare riferimento con break o continue. Nei cicli nidificati, un'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 è consentito 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, è possibile inserire nel blocco break un'istruzione 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);
    }
}
/* output:
1
2
...
79
*/

L'esempio seguente mostra come utilizzare un'etichetta con un blocco di istruzioni. Nell'esempio seguente, il blocco di istruzioni ha l'etichetta foo, che consente all'istruzione break di saltare l'ultima istruzione del blocco:

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

Vedere anche

namespace name [= uri]

Consente di controllare la visibilità delle definizioni. Gli spazi dei nomi predefiniti includono public, private, protectede internal (questi spazi dei nomi specifici vengono chiamati anche "specificatori di controllo accesso" e sono trattati anche nella documentazione alla voce "Attributi delle proprietà di classe"). Se gli spazi dei nomi predefiniti non sono adatti alle proprie esigenze, è possibile definire uno personalizzato.

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

• Innanzi tutto, definire lo spazio dei nomi personalizzato mediante la parola chiavenamespace. Ad esempio, il codice namespace version1 crea uno spazio dei nomi chiamato version1.
• Quindi, applicare 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, fare riferimento allo spazio dei nomi utilizzando la parola chiave use o anteponendo lo spazio dei nomi a un identificatore. 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.

Vedere anche

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. Utilizzare null per rappresentare valori mancanti o che non presentano un tipo di dati definito.

Non confondere 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");
    }
}

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

Vedere anche

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'attributooverride e verificare che il nome, il numero 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 è possibile 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

Benché non sia consentito sostituire una proprietà dichiarata con var o const, è possibile ottenere una funzionalità simile impostando come getter-setter la proprietà della classe base e sostituendo i metodi definiti con get e set.

Vedere anche

package packageName {
    class someClassName { 
    } 
}

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

Vedere anche

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ù 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. Utilizzare questa parola chiave se si desidera limitare l'accesso a una variabile o funzione.

È possibile utilizzare questa parola chiave solo nelle definizioni di classe, non nelle definizioni di interfaccia. Non è possibile 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
  }
}

Poiché alpha è una variabile privata, non è possibile accedervi dall'esterno della classe A, nemmeno dalla sottoclasse B. I tentativi di accesso alla variabile privata generano un errore.

Vedere anche

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. Utilizzare questa parola chiave se si desidera limitare l'accesso a una variabile o funzione.

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

La definizione di protected in ActionScript 3.0 è più restrittiva di quella di protected nel linguaggio di programmazione Java. In ActionScript 3.0 protected limita l'accesso unicamente alle sottoclassi, mentre in 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);  // output: Access attempt from subclass succeeded
  }
}

Vedere anche

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, è necessario utilizzare l'attributopublic.

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); // output: 27 jimmy

Se si trasforma una delle variabili pubbliche della classe User in una variabile privata, qualunque tentativo di accedere a tale variabile dall'esterno della classe User genera un errore.

Vedere anche

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'istruzionereturn è utilizzata da sola, restituisce il valore undefined.

Non è possibile eseguire return su più valori; se si tenta 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, utilizzare 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); // output: 114

Vedere anche

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

Definisce un setter, ovver 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, creare un getter senza un setter corrispondente. Viceversa, per creare una proprietà di sola scrittura, creare 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); // output: 25

Vedere anche

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

La parola chiave static può essere utilizzata 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, è possibile fare riferimento a una variabile statica o a un metodo statico all'interno di una classe o di una sottoclasse, senza utilizzare alcun qualificatore. Vedere l'esempio riportato di seguito.

Non è possibile 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

Vedere anche

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. Si noti 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 si definisce una funzione di costruzione in una sottoclasse e la funzione di costruzione della superclasse accetta uno o più argomenti, è necessario 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 è possibile utilizzare l'istruzione super all'interno di metodi statici.

Vedere anche

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 caso predefinito che viene eseguito 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");
}

// output: Not 0, 1, or 2

Vedere anche

this

Un riferimento all'oggetto che contiene un metodo. Durante l'esecuzione di uno script, la parola chiavethis 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();

Vedere anche

throw expression 

Crea, o 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. If an exception is not caught by a catch or finally block, the string representation of the thrown value is sent to the log file.

Tipicamente, vengono generate istanze della classe Error o delle sue sottoclassi (consultare 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); 
}
// output: 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);
}
// output: Error: Invalid email address.

Vedere anche

true

Un valore booleano che rappresenta true. Un valore booleano 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");
// }

L'esempio seguente mostra il modo in cui la tipizzazione automatica dei dati converte true nel numero 1:

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

Vedere anche

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

È possibile 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 qualsiasi codice all'interno del blocco try genera un'eccezione, il controllo passa al blocco catch (se presente), quindi al blocco 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 blocco finally 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 singolo blocco try può avere più blocchi catch ma solo un blocco finally. È possibile nidificare i blocchi try per tutti i numeri di livelli (profondità) desiderati.

Il parametro error specificato in un gestore catch deve essere un semplice identificatore come 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 espulsa 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, Flash Player 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.

import flash.display.Sprite;

var spr:Sprite = new Sprite();
try {
    spr.addChild(spr);
}
catch (e:ArgumentError) {
    trace(e); // output: 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()); 
}

Vedere anche

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.

Vedere anche

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

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

Se si dichiarano delle variabili fuori da una funzione, tali variabili sono disponibili lungo l'intera linea temporale che contiene l'istruzione.

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.

È possibile 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); 
// output: Studio,Dreamweaver,Flash,ColdFusion,Contribute,Breeze,Flex

Vedere anche

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, saltare le istruzioni rimanenti e passare 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. Andare 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, condition non è più truee il ciclo termina.

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

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

Vedere anche

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_arraye 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, se object è state.california, qualsiasi azione o istruzione interna all'istruzione with 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 dell'istruzionewith più interna
• L'oggetto specificato nel parametro object dell'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 si imposta 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.

with (someOther_mc) { 
    _x = 50; 
    _y = 100; 
    gotoAndStop(3); 
}

someOther_mc._x = 50; 
someOther_mc._y = 100; 
someOther_mc.gotoAndStop(3);

L'istruzione with è utile per accedere a più elementi contemporaneamente in un elenco delle catene delle aree di validità. Nell'esempio seguente, l'oggetto Math incorporato viene collocato all'inizio della catena delle aree di validità. L'impostazione di Math come oggetto predefinito risolve gli identificatori cos, sine PI rispettivamente a Math.cos, Math.sine Math.PI. Gli identificatori a, x, ye r non sono metodi o proprietà dell'oggetto Math, ma poiché sono presenti nell'area di attivazione della funzione polar(), risolvono alle variabili locali corrispondenti.

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);
/* output: 
area = 28.2743338823081 
x = -3 
y = 3
*/