Sintassi -- Flash CS3

La sintassi di un linguaggio definisce una serie di regole che devono essere rispettate quando si scrive codice eseguibile.

Sezioni

Distinzione tra maiuscole e minuscole

Nel linguaggio ActionScript 3.0 viene fatta distinzione tra maiuscole e minuscole. Gli identificatori che presentano gli stessi caratteri ma lettere minuscole e maiuscole differenti vengono considerati identificatori diversi. Ad esempio, il codice seguente crea due variabili diverse:

var num1:int;
var Num1:int;

Sintassi del punto

L'operatore punto (.) permette di accedere alle proprietà e ai metodi di un oggetto. Utilizzando la sintassi del punto, è possibile fare riferimento a una proprietà o a un metodo di una classe specificando un nome di istanza seguito dall'operatore punto e dal nome della proprietà o del metodo. Ad esempio, si consideri la seguente definizione di classe:

class DotExample
{
    public var prop1:String;
    public function method1():void {}
}

Mediante la sintassi del punto, è possibile accedere alla proprietà prop1 e al metodo method1() utilizzando il nome di istanza creato nel codice seguente:

var myDotEx:DotExample = new DotExample();
myDotEx.prop1 = "hello";
myDotEx.method1();

Si può ricorrere alla sintassi del punto anche per la definizione dei pacchetti. L'operatore punto viene utilizzato per fare riferimento ai pacchetti nidificati. Ad esempio, la classe EventDispatcher si trova in un pacchetto denominato events che è nidificato all'interno del pacchetto flash. Per fare riferimento al pacchetto events, usare l'espressione seguente:

È anche possibile fare riferimento alla classe EventDispatcher mediante l'espressione seguente:

flash.events.EventDispatcher

Sintassi della barra

La sintassi della barra non è supportata in ActionScript 3.0. Nelle versioni precedenti di ActionScript la barra inclinata indicava il percorso di un clip filmato o di una variabile.

Valori letterali

Per valore letterale si intende un valore che compare direttamente nel codice. I seguenti esempi sono valori letterali:

17
"hello"
-3
9.4
null
undefined
true
false

I valori letterali possono essere raggruppati a formare valori letterali composti. I valori letterali di array sono racchiusi tra parentesi quadre ([]) e utilizzano la virgola per separare gli elementi dell'array.

Un valore letterale array può essere utilizzato per inizializzare un array. Gli esempi seguenti mostrano due array inizializzati tramite valori letterali array. È possibile utilizzare l'istruzione new e passare il valore letterale composto come parametro alla funzione di costruzione della classe Array, ma è anche possibile assegnare valori letterali direttamente durante la creazione di istanze delle seguenti classi principali ActionScript: Object, Array, String, Number, int, uint, XML, XMLList e Boolean.

// Viene utilizzata l'istruzione new
var myStrings:Array = new Array(["alpha", "beta", "gamma"]);
var myNums:Array = new Array([1,2,3,5,8]);

// Il valore letterale viene assegnato direttamente
var myStrings:Array = ["alpha", "beta", "gamma"];
var myNums:Array = [1,2,3,5,8];

I valori letterali possono essere anche utilizzati per inizializzare un oggetto generico, ovvero un'istanza della classe Object. I valori letterali oggetto sono racchiusi tra parentesi graffe ({}) e utilizzano la virgola per separare le proprietà dell'oggetto. Ogni proprietà viene dichiarata con il carattere di due punti (:) che separa il nome della proprietà dal relativo valore.

È possibile creare un oggetto generico utilizzando l'istruzione new e passando il valore letterale dell'oggetto come parametro alla funzione di costruzione della classe Object, oppure assegnare il valore letterale dell'oggetto direttamente all'istanza che si dichiara. L'esempio seguente crea un nuovo oggetto generico e lo inizializza con tre proprietà (propA, propB e propC), con valori impostati rispettivamente su 1, 2 e 3:

// Viene utilizzata l'istruzione new
var myObject:Object = new Object({propA:1, propB:2, propC:3});

// Il valore letterale viene assegnato direttamente
var myObject:Object = {propA:1, propB:2, propC:3};

Punto e virgola

Il carattere di punto e virgola (;) può essere utilizzato per terminare un'istruzione. Se si omette il carattere del punto e virgola, il compilatore presuppone che ogni riga di codice rappresenti una singola istruzione. Poiché molti programmatori sono abituati a usare il punto e virgola per indicare la fine di un'istruzione, il codice può risultare più leggibile se si adotta questa convezione in modo omogeneo.

L'uso di un punto e virgola per terminare un'istruzione consente di includere più di un'istruzione su una sola riga; tuttavia, un "affollamento" eccessivo di istruzioni può rendere più difficoltosa la lettura del codice.

Parentesi

In ActionScript 3.0 le parentesi (()) hanno tre usi possibili. Innanzi tutto, possono essere utilizzate per cambiare l'ordine delle operazioni all'interno di un'espressione. Le operazioni raggruppate all'interno di parentesi vengono sempre eseguite per prime. Ad esempio, nel codice seguente le parentesi sono state utilizzate per cambiare l'ordine delle operazioni:

trace(2 + 3 * 4);    // 14
trace( (2 + 3) * 4); // 20

In secondo luogo, è possibile utilizzare le parentesi con l'operatore virgola (,) per valutare una serie di espressioni e restituire il risultato dell'espressione finale, come nell'esempio seguente:

var a:int = 2;
var b:int = 3;
trace((a++, b++, a+b)); // 7

Infine, è possibile utilizzare le parentesi per passare uno o più parametri a funzioni o metodi, come nell'esempio seguente, dove viene passato un valore String alla funzione trace():

trace("hello"); // hello

Commenti

Il codice ActionScript 3.0 supporta due tipi di commenti: a riga singola e su più righe. Questi meccanismi per l'inserimento di commenti sono simili a quelli di C++ e Java. Tutto il testo contrassegnato come commento viene ignorato dal compilatore.

I commenti a riga singola iniziano con due caratteri di barra (//) e continuano fino alla fine della riga. Ad esempio, il codice seguente contiene un commento a riga singola:

var someNumber:Number = 3; // Commento a riga singola

I commenti su più righe invece iniziano con una barra seguita da un asterisco (/*) e finiscono con un asterisco seguito da una barra (*/).

/* Questo è un commento multiriga che può occupare
più di una riga di codice. */

Parole chiave e riservate

parole riservate si intendono parole che non possono essere utilizzate come identificatori nel codice perché sono riservate per l'uso in ActionScript. Le parole riservate comprendono anche le parole chiave lessicali, che vengono rimosse dallo spazio dei nomi del programma dal compilatore. Se si utilizza una parola chiave lessicale come identificatore, il compilatore genera un errore. Nella tabella seguente sono elencate tutte le parole chiave lessicali di ActionScript 3.0.

Esiste inoltre un piccolo gruppo di parole chiave, chiamate parole chiave sintattiche, che possono essere utilizzate come identificatori ma hanno un significato speciale in determinati contesti. Nella tabella seguente sono elencate tutte le parole chiave sintattiche di ActionScript 3.0.

Infine, vi sono vari identificatori che talvolta vengono definiti parole riservate future. Si tratta di parole che non sono riservate in ActionScript 3.0, ma potrebbero essere considerate come parole chiave da software che incorporano ActionScript 3.0. Benché sia possibile che molti di questi identificatori possano essere utilizzati senza problemi nella maggior parte dei casi, Adobe consiglia di evitarne l'uso perché potrebbero diventare parole chiave in una versione successiva del linguaggio.

Costanti

ActionScript 3.0 supporta l'istruzione const, che permette di creare una costante. Le costanti sono proprietà il cui valore è fisso, ovvero non modificabile. È possibile assegnare un valore a una costante una sola volta, e l'assegnazione deve avvenire in prossimità della dichiarazione della costante. Ad esempio, se una costante viene dichiarata come membro di una classe, è possibile assegnare ad essa un valore solo nella dichiarazione stessa oppure nella funzione di costruzione della classe.

Il codice seguente dichiara due costanti. Alla prima, MINIMUM, viene assegnato un valore nell'istruzione della dichiarazione, mentre il valore della seconda costante, MAXIMUM, viene assegnato nella funzione di costruzione.

class A
{
    public const MINIMUM:int = 0;
    public const MAXIMUM:int;

    public function A()
    {
        MAXIMUM = 10;
    }
}

var a:A = new A();
trace(a.MINIMUM); // 0
trace(a.MAXIMUM); // 10

Se si tenta di assegnare un valore iniziale a una costante in qualunque altro modo, viene generato un errore. Ad esempio, se si imposta il valore iniziale di MAXIMUM all'esterno della classe, si verifica un errore runtime.

class A
{
  public const MINIMUM:int = 0;
  public const MAXIMUM:int;
}

var a:A = new A();
a["MAXIMUM"] = 10; // Errore runtime

L'API di Flash Player definisce un'ampia gamma di costanti utilizzabili dal programmatore. Per convenzione, le costanti in ActionScript contengono solo lettere maiuscole, con le parole separate dal carattere di sottolineatura ( _). Ad esempio, la definizione della classe MouseEvent utilizza questa convenzione di denominazione per le proprie costanti, ciascuna delle quali rappresenta un evento relativo all'input del mouse:

package flash.events
{
  public class MouseEvent extends Event
  {
    public static const CLICK:String               = "click";
    public static const DOUBLE_CLICK:String        = "doubleClick";
    public static const MOUSE_DOWN:String          = "mouseDown";
    public static const MOUSE_MOVE:String          = "mouseMove";
    ...
  }
}

as	break	case	catch
class	const	continue	default
delete	do	else	extends
false	finally	for	function
if	implements	import	in
instanceof	interface	internal	is
native	new	null	package
private	protected	public	return
super	switch	this	throw
to	true	try	typeof
use	var	void	while
with

each	get	set	namespace
include	dynamic	final	native
override	static

abstract	boolean	byte	cast
char	debugger	double	enum
export	float	goto	intrinsic
long	prototype	short	synchronized
throws	to	transient	type
virtual	volatile