Passaggio da ActionScript 1 ad ActionScript 2

Imparare a scrivere con la nuova sintassi

Inserito il 19-05-2006

Durante la mia frequentazione del web e dei forum in cui scrivo, mi capita spesso di leggere di molti che, pur utilizzando ormai da diverso tempo Flash MX 2004 o addirittura Flash 8, ancora continuano a scrivere e pubblicare in AS1. Questa più che una scelta ponderata risulta essere quasi una necessità per chi crede che il passaggio da AS1 ad AS2 sia difficile, come se si stesse approdando ad un mondo completamente diverso.

In realtà le regole da applicare agli script perchè siano compatibili con AS2, sono veramente minime e più che altro fanno parte di un modo di scrivere gli script in maniera corretta. Con questo articolo cercherò di riassumere e spiegare queste regole in maniera semplice, cercando di mettermi nei panni di chi non ha mai scritto in questo modo. Innanzi tutto facciamo un elenco delle regole aggiunte in AS2:

Tralasciando per un momento l'ultimo punto (ne parleremo in un prossimo articolo), vediamo le prime tre cose.

Case-sensitive:

Cosa vuol dire case-sensitive? E' la capacità di distinzione tra caratteri minuscoli e maiuscoli, questo significa che la variabile "pippo" non è uguale a "Pippo" e "loadmovie" non è come scrivere "loadMovie", nel primo caso per flash "loadmovie" non è un metodo dei MovieClip, direi che non c'è molto da spiegare, il tutto sta solo a fare più attenzione nella distinzione tra maiuscole e minuscole, quando si scrive il codice. Un piccolo esempio giusto per chiarire questo primo punto

var pippo:String = "la mia variabile è 'pippo'";
trace(Pippo); // output: undefined
trace(pippo); // output: la mia variabile è 'pippo'
var num1:Number = 10;
var num2:Number = 15;
var numsum = nUM1+num2;
var numsum2 = num1+num2;
trace (numsum); // output: NaN (Not a Number)
trace (numsum2); // output: 25

Come si può notare dal codice di esempio precedente, ho inizializzato le variabili in una maniera particolare, questo ci introduce alla seconda caratteristica da considerare nel nuovo modo di scrivere gli script AS, lo strict data typing.

Variabili fortemente tipate (strict data typing):

Per strict data typing o variabili fortemente tipate, si intende che la dichiarazione del tipo di variabile deve risultare esplicita nel momento in cui viene creata, e una volta creata, la variabile non potrà assumere un valore diverso a meno di una reinizializzazione in maniera diversa. E allora come si fà a scrivere il codice in questo modo? Semplicemente utilizzando la parola chiave var prima del nome della variabile, poi subito dopo il nome bisogna inserire due punti (:) e il tipo di variabile, quindi in finale avremo una cosa del genere var miaVar:String; e questo basta per inizializzare una variabili con lo strict data typing.

Per completezza vedremo un ultimo aspetto di questo nuovo modo di scrivere AS, sulle funzioni.
Analizziamo questo codice

var miaFunzione:Function = function(target:MovieClip):String {
	var str:String = target._name;
	return str;
}

var miaFunzione:Function, lo abbiamo appena visto, dichiariamo la variabile "miaFunzione" che sarà di tipo Function.

= function(), nulla di nuovo rispetto ad AS1, è lo stesso modo di dichiarare una funzione.

(target:MovieClip), e qui invece vediamo una differenza rispetto ad AS1, infatti oltre a inserire i parametri che andranno a comporre la funzione, ne dobbiamo rendere esplicito anche il tipo, di nuovo useremo i due punti e la dichiarazione del tipo.

:String, e questa è la novità più importante, il "ritorno" di valore della funzione che dovrà essere del tipo dichiarato in questo punto, così se il ritorno dovesse non corrispondere, o se non dovesse esserci ritorno, viene segnalato un errore dello script. Naturalmente esiste anche il caso in cui la funzione non debba restituire nulla, in questo caso il tipo deve essere :Void oppure non deve essere dichiarato.

In finale il comando usato per restituire il valore dalla funzione è return, identico anche per AS1.

Dichiarazione obbligatoria delle variabili:

Ultima cosa, non meno importante, è la dichiarazione obbligatoria delle variabili, per chi scrive codice corretto non dovrebbe essere chissà quale novità, una variabile per essere utilizzata deve esistere, normale no?! Non in AS1 dove era possibile fare una cosa del genere miaVar+=1; senza aver dichiarato da nessun'altra parte la variabile miaVar. In AS2 se si prova a fare un trace della variabile "miaVar" dopo quanto scritto sù, si ottiene undefined. Quindi in AS2, prima bisognerà dichiarare la variabile e poi potremo utilizzarla

var miaVar:Number;
miaVar+=1;
trace(miaVar); // output: 1

Scope:

Lo scope, è l'effettiva "area" in cui una determinata variabile, metodo, proprietà ,funzione od operatore è fruibile ed utilizzabile, di solito coincide con la zona in cui una variabile viene inizializzata, ad esempio dentro il metodo di un movieclip, per capire meglio analizziamo un esempio

var name:String = this._name;
trace(name); // output: _level0
createEmptyMovieClip("mc", 1);
mc.onLoad = function(){
	var name:String = this._name;
	trace(name); // output: _level0.mc
	trace(_level0.name); // output: _level0
}

Come si può notare dall'esempio, la stessa dichiarazione fatta fuori e dentro il metodo genera un output differente, questo perchè l'ingresso nel metodo di una classe sposta lo scope dal "livello" superiore a quello adiacente, chiaramente non è la lettura di dieci righe che ci farà capire come utilizzare nel modo corretto lo scope, ci vorrà un bel po' di pratica per capire dove una variabile, metodo, proprietà ecc... esaurisca il proprio scope, spero comunque che questo chiarimento possa aiutare.

Conclusioni:

In pratica l'unica differenza tra i due è che con AS2 gli errori concettuali di scrittura vengono segnalati e bloccati mentre con AS1 era possibile scrivere codice "sporco" senza nessun problema, se non nel momento stesso in cui questo codice diventava fruibile per l'utente finale, con la conseguenza di errori del player e rallentamenti dovuti a tali "buchi" di programmazione.

Come si può appurare dal quadro esposto, non è difficile tanto il fatto di passare da una sintassi semplice ad una complessa, quanto il fatto di abituarsi a scrivere un codice sintatticamente corretto, che si tratti di AS1 o di AS2, la differenza è che nel primo caso nessuno ci può fermare, mentre nel secondo se si sbaglia, le cose non funzionano.