L' importanza di un Array

[Flep]

Ciao a tutti !
Il perchè di questo articolo ?
Semplice, molti di voi sono abituati con Actionscript 2.0 ad utilizzare forme e tecniche che con la versione 3.0 riscontrano diversi errori e non vanno a buon fine.
Spesso mi arriva dalle vostre e-mail una domanda strana del tipo:
- come faccio a creare un nome di una variabile in runtime ?

Questo è tipico di chi ancora ragiona in questo modo: this['nome'+i]...
e vorrebbe realizzare una cosa del genere: var 'nome'+i:MovieClip=new MovieClip();

Il mio parere:
- this['nome'+i]... è obsoleto e davvero molto poco ' educato ' senza contare il fatto che con AS 3.0 non gira
- var 'nome'+i:MovieClip=new MovieClip(); con Actionscript non è possibile

Allora ho visto in qualche forum italiano che qualche ' genio incompreso ' ( forse troppo incompreso ) risponde a questo tipo di domande con oluzioni alquanto bizzarre.
Dato che non mi piace creare polemica e rispetto sempre il lavoro altrui non ne ho mai parlato.
Le cose viste in questi ultimi giorni però mi hanno spinto a scrivere questo articolo in quanto almeno avrò la certezza che chi vuole imparare Actionscript 3.0 correttamente potrà farlo avendo a disposizione un' altra tecnica amio avviso molto più valida.

Molte soluzioni a questi tipi di problemi si trovano utilizzando la classe Array di Actionscript 3.0 .
Alcune cose le abbiamo già viste in questo articolo, ma volevo approfondire una delle tante ' virtù ' della classe Array.
Entriamo in un esempio concreto...

Per creare oggetti in runtime, con Actionscript 3.0 non si intende di creare istanze della classe Object, come ad esempio:
var obj:Object=new Object();
obj.nome='filippo';
obj.cognome='lughi';
obj.eta=35;

in questo caso ho creato una istanza della classe Object ed ho assegnato alcune proprietà alla istanza stessa e dei valori ad ogni proprietà.
Questa soluzione è valida ma molto limitata.
Cosa fareste se dovreste ad esempio dire ad obj di ruotare su se stesso ? Oppure di creare un campo di testo e visualizzare il valore di ogni sua proprietà ?
Come si dice... vi attacchereste al tram in quanto non è possibile assegnare dei metodi ad un Object.

Creare oggetti in runtime significa creare e istanziare Classi con proprietà e metodi.
Inserire in un Array ogni istanza della Classe in modo da poter richiamare l' istanza ed ogni sua proprietà e/o metodo ogni volta che lo necessitiamo nel miglior modo possibile e nella maniera più semplice.
Sigifica tener traccia di ogni istanza e lavorare con modularità.

Creo un FLA che salvo con nome ' main.fla '.
Creo la Document Class, un file AS che salvo con nome ' Main.as ', implementata in questo modo:

package
{
	import flash.display.MovieClip;
	
	public class Main extends MovieClip
	{
		private var numItems:int=10;
		
		private var items_array:Array=new Array();
		
		public function Main()
		{
			createItems();
			readArray();
		}
		
		private function createItems():void
		{
			for(var i:int=0;i < numItems;i++)
			{
				var item:Item=new Item('nome_'+i,'cognome_'+i,i,'eMail@me.com_'+i,'city_'+i,this);
				items_array.push(item);
			}
		}
		
		private function readArray():void
		{
			trace(items_array[2].getNome());
			trace(items_array[items_array.length-1].getNome());
			
			for(var i:int=0;i < items_array.length;i++)
			{
				trace(items_array[i].getEmail());
				trace(items_array[i].getCitta());
			}
			
			items_array[5].write();
			items_array[5].tf.x=stage.stageWidth/2-items_array[5].tf.textWidth/2;
			items_array[5].tf.y=stage.stageHeight/2-items_array[5].tf.textHeight/2;
		}
	}
}

adesso creo una classe che chiamo Item.as, implementata in questo modo:

package
{
	import flash.display.MovieClip;
	import flash.text.TextField;
	
	public class Item
	{
		private var nome:String;
		private var cognome:String;
		private var eta:int;
		private var eMail:String;
		private var citta:String;
		
		private var _fla:MovieClip;
		
		public var tf:TextField;
		
		public function Item(nm:String,cn:String,et:int,em:String,ci:String,fla:MovieClip)
		{
			nome=nm;
			cognome=cn;
			eta=et;
			eMail=em;
			citta=ci;
			_fla=fla;
		}
		
		public function getNome():String
		{
			return nome;
		}
		
		public function getCognome():String
		{
			return cognome;
		}
		
		public function getEta():int
		{
			return eta;
		}
		
		public function getEmail():String
		{
			return eMail;
		}
		
		public function getCitta():String
		{
			return citta;
		}
		
		public function write():void
		{
			tf=new TextField();
			tf.text=nome+'\n'+cognome+'\n'+eta+'\n'+eMail+'\n'+citta;
			tf.width=tf.textWidth+10;
			tf.height=tf.textHeight+10;
			
			_fla.addChild(tf);
		}
	}
}

vediamo quale è lo scopo di questo articolo:

In Main.as ho una proprietà numerica con nome numItems e valore 10.
Ho anche una proprietà di tipo Array con nome items_array in cui inserirò ogni istanza della classe Item che andrò a creare.
Poi chiamo il metodo createItems che istanzierà tante istanze di Item pari al valore di numItems.
Quindi, creo un ciclo con massima iterazione il valore di numItems
for(var i:int=0;i < numItems;i++)
definisco e istanzio Item passandogli i valori che Items.as richiede ( valori a caso in quanto questo è un esercizio puramente didattico )
var item:Item=new Item('nome_'+i,'cognome_'+i,i,'eMail@me.com_'+i,'c ity_'+i,this);
chiariamo il concetto che il nome item della variabile come nasce muore, è una variabile locale che alla successiva iterazione non esiste più, quindi ne viene creata un' altra con lo stesso nome. Quello che interessa è che ogni item diventa una istanza della classe Item a cui passo dei valori per inserirli nelle sue proprietà.
Ora inserisco l' istanza di Item in un Array
items_array.push(item);

Cosa succede nella classe Item.as :

ho creato le seguenti proprietà:

private var nome:String;
private var cognome:String;
private var eta:int;
private var eMail:String;
private var citta:String;

private var _fla:MovieClip;

public var tf:TextField;

alle quali ( le prime 5 ) andrò ad assegnare un valore che mi arriva dalla funzione costruttrice ( vedere il tutorial 1 sulla OOP per chi non avesse ben chiaro il concetto di funzione costruttrice ) :

public function Item(nm:String,cn:String,et:int,em:String,ci:String,fla:MovieClip)
{
	nome=nm;
	cognome=cn;
	eta=et;
	eMail=em;
	citta=ci;
	_fla=fla;
}

quindi, quando da Main.as dico var item:Item= new Item(...) Flash esegue il codice della funzione costruttrice di Item e cioè assegna i valori alle proprietà che gli passo da Main.
Siccome le proprietà sono private ( leggere il tutorial 4 sulla OOP per eventuali approfondimenti di cosa significa private ) non sono accessibili dalle istanze della classe. Avrei potuto crearle pubbliche ma non sarebbe servito allo scopo didattico di questo tutorial, quindi ho creato dei metodi pubblici ( accessibili dalle istanze ) che recuperano il valore e lo restitiscono:

public function getNome():String
{
	return nome;
}

public function getCognome():String
{
	return cognome;
}

public function getEta():int
{
	return eta;
}

public function getEmail():String
{
	return eMail;
}

public function getCitta():String
{
	return citta;
}

Ora torniamo a Main.as e più precisamente al metodo readArray, che serve per fare alcuni trace e capire come recupeare le proprietà di ogni singola istanza di Item che risiede in items_array.

Il primo trace
trace(items_array[2].getNome());
recupera il valore della proprietà nome dell' istanza di Item che è all' indice numero 2 di items_array ( quindi la terza istanza )
ottiene il seguente output da Flash
nome_2

Il secondo trace
trace(items_array[items_array.length-1].getNome());
recupera il valore della proprietà nome dell' istanza di Item che si trova nell' ultimo indice dell' array ( che è pari al numero della lunghezza dell' array meno 1 )
ottiene il seguente output
nome_9

Adesso con un ciclo con massima iterazione la lunghezza di items_array recupero le proprietà eMail e citta di ogni istanza

for(var i:int=0;i < items_array.length;i++)
{
	trace(items_array[i].getEmail());
	trace(items_array[i].getCitta());
}

e ottengo il seguente output
eMail@me.com_0
city_0
eMail@me.com_1
city_1
eMail@me.com_2
city_2
eMail@me.com_3
city_3
eMail@me.com_4
city_4
eMail@me.com_5
city_5
eMail@me.com_6
city_6
eMail@me.com_7
city_7
eMail@me.com_8
city_8
eMail@me.com_9
city_9

Torniamo ora in Item.as e notiamo che ho implementato il metodo write:

public function write():void
{
	tf=new TextField();
	tf.text=nome+'\n'+cognome+'\n'+eta+'\n'+eMail+'\n'+citta;
	tf.width=tf.textWidth+10;
	tf.height=tf.textHeight+10;
	
	_fla.addChild(tf);
}

che crea un campo di testo dalla proprietà tf, gli assegna il testo contenente il valore delle proprietà nome, cognome, eta, eMail e citta.
Gli assegno le dimensioni reali delle dimensioni del testo più uno scarto di 10.
Aggiungo il campo di testo allo stage.
Tutto questo verrà eseguito al momento in cui una istanza di Item chiamerà appunto questo metodo.

Vediamo, torniamo a Main.as e alle utlime righe del metodo readArray

items_array[5].write();
items_array[5].tf.x=stage.stageWidth/2-items_array[5].tf.textWidth/2;
items_array[5].tf.y=stage.stageHeight/2-items_array[5].tf.textHeight/2;

chiamo il metodo write dall' istanza di Item che si trova nell' indice 5 di items_array
Item.as esegue il codice nel metodo write e poi lo posiziono al centro dello stage utilizzando tf, la proprietà di tipo textField che appunto ogni istanza si porta dietro e agendo sulle proprietà x e y, width e height appunto di quel campo di testo.
Ottenendo questo risultato:

Abbiamo visto che possiamo creare delle istanze di una classe e che possiamo assegnare metodi e proprietà a tale classe ma soprattutto abbiamo lavorato in modo corretto e modulare.
Se qualcosa non gira sappiamo esattamente dove guardare ed abbiamo un totale controllo di quello che stiamo facendo.

Alla prossima !

[Zolmandacuba]

devi avere un discreto cervello flep per avere in mente tutto questo prima di codificarlo........
ho capito bene perchè spieghi chiaro, ma ne manca di strada per contenere ancora tutti queste connessioni mentali.
Ne capisci una in più che già quella di prima ha tagliato il filo e se n'è andata via.....