Array indicizzati

Per creare un'istanza Array o Vector è possibile utilizzare diverse tecniche. Tuttavia, le tecniche per creare i diversi tipi di array presentano delle leggere differenze tra loro.

Il modo più elementare per aggiungere degli elementi a un array consiste nell'utilizzare l'operatore di accesso all'array [] . Per impostare il valore di un elemento di un array indicizzato, utilizzate il nome dell'array o del vettore e il numero di indice sul lato sinistro dell'istruzione di assegnazione:

songTitles[5] = "Happy Birthday";

Se l'array o il vettore non hanno già un elemento corrispondente a quel numero di indice, l'indice viene creato e il valore viene archiviato in quella posizione. Se a quel numero di indice, corrisponde già un valore, il nuovo valore sostituisce quello preesistente.

Gli oggetti Array consentono di creare un elemento in corrispondenza di qualsiasi posizione di indice. Negli oggetti Vector, invece, potete assegnare un valore a un indice esistente o al primo valore di indice sequenziale disponibile. Il primo valore di indice sequenziale disponibile corrisponde alla proprietà length dell'oggetto Vector. Il modo più sicuro per aggiungere un nuovo elemento a un oggetto Vector consiste nell'utilizzare un codice simile a quello seguente:

myVector[myVector.length] = valueToAdd;

Tre dei metodi della classe Array e Vector, ( push() , unshift() e splice() ) consentono di inserire elementi in un array. Il metodo push() consente di aggiungere uno o più elementi al termine di un array. In altre parole, l'ultimo elemento inserito nell'array mediante il metodo push() avrà il numero di indice più alto. Il metodo unshift() consente di inserire uno o più elementi all'inizio di un array, vale a dire in posizione di indice 0. Il metodo splice() consente di inserire un qualsiasi numero di elementi in una posizione di indice specificata dell'array.

Nell'esempio seguente sono illustrati tutti e tre i metodi. Viene creato un array denominato planets per memorizzare i nomi dei pianeti in ordine di prossimità al sole. In primo luogo, viene chiamato il metodo push() per inserire l'elemento iniziale, Mars . Quindi viene chiamato il metodo unshift() per inserire l'elemento che appartiene alla prima parte dell'array, Mercury . Infine, viene chiamato il metodo splice() per inserire gli elementi Venus e Earth dopo Mercury , ma prima di Mars . Il primo argomento inviato a splice() , il valore intero 1, indica che l'inserimento deve iniziare dalla posizione di indice 1. Il secondo argomento inviato a splice() , il valore intero 0, indica che nessun elemento deve essere eliminato. Infine, il terzo e il quarto argomento inviati a splice() , Venus e Earth , rappresentano gli elementi da inserire.

var planets:Array = new Array(); 
planets.push("Mars"); // array contents: Mars 
planets.unshift("Mercury"); // array contents: Mercury,Mars 
planets.splice(1, 0, "Venus", "Earth"); 
trace(planets); // array contents: Mercury,Venus,Earth,Mars

I metodi push() e unshift() restituiscono entrambi un numero intero senza segno che rappresenta la lunghezza dell'array modificato. Il metodo splice() restituisce un array vuoto se utilizzato per inserire elementi, cosa che potrebbe sembrare strana, ma che acquista maggior senso alla luce della versatilità del metodo splice() . Il metodo splice() non consente solo di inserire elementi in un array, ma anche di rimuovere elementi. Se utilizzato per rimuovere elementi, il metodo splice() restituisce un array contenente gli elementi rimossi.

Il modo più elementare per recuperare degli elementi da un array consiste nell'utilizzare l'operatore di accesso all'array [] . Per recuperare il valore di un elemento di un array indicizzato, utilizzate il nome dell'oggetto Array o Vector e il numero di indice sul lato destro dell'istruzione di assegnazione:

var myFavoriteSong:String = songTitles[3];

È possibile tentare di recuperare un valore da un array o da un vettore utilizzando un indice per il quale non esiste alcun elemento. In questo caso, l'oggetto Array restituisce un valore non definito, mentre l'oggetto Vector rileva un'eccezione RangeError.

I tre metodi per le classi Array e Vector, pop() , shift() e splice() consentono di rimuovere gli elementi. Il metodo pop() consente di rimuovere un elemento dalla fine di un array. In altre parole, con questo metodo è possibile rimuovere l'elemento situato nella posizione di indice più alta. Il metodo shift() rimuove un elemento dall'inizio dell'array, vale a dire l'elemento che si trova in posizione di indice 0. Il metodo splice() , che può essere utilizzato anche per inserire elementi, consente di rimuovere un numero arbitrario di elementi a partire dalla posizione di indice specificata dal primo argomento inviato al metodo.

L'esempio in basso utilizza tutti e tre i metodi per rimuovere elementi da un'istanza Array. Viene creato un array chiamato oceans (oceani) all'interno del quale verranno archiviati i nomi di grandi masse di acqua. Alcuni dei nomi dell'Array sono laghi, per cui è necessario rimuoverli.

In primo luogo, viene chiamato il metodo splice() per rimuovere gli elementi Aral e Superior e vengono inseriti gli elementi Atlantic e Indian . Il primo argomento inviato a splice() , il valore intero 2, indica che l'operazione deve iniziare con il terzo elemento dell'elenco, che si trova in posizione di indice 2. Il secondo argomento, 2, indica che le voci da rimuovere devono essere 2. Gli argomenti rimanenti, Atlantic e Indian , sono i valori da inserire a partire dalla posizione di indice 2.

Quindi, viene utilizzato il metodo pop() per rimuovere l'ultimo elemento dell'array, Huron . Successivamente, viene utilizzato il metodo shift() per rimuovere il primo elemento dell'array, Victoria .

var oceans:Array = ["Victoria", "Pacific", "Aral", "Superior", "Indian", "Huron"]; 
oceans.splice(2, 2, "Arctic", "Atlantic"); // replaces Aral and Superior 
oceans.pop(); // removes Huron 
oceans.shift(); // removes Victoria 
trace(oceans);// output: Pacific,Arctic,Atlantic,Indian

I metodi pop() e shift() restituiscono entrambi l'elemento che era stato rimosso. Per un'istanza Array, il tipo di dati del valore restituito è Object perché gli array possono contenere valori di qualunque tipo di dati. Per un'istanza Vector, il tipo di dati del valore restituito è il tipo base del vettore. Il metodo splice() restituisce un array contenente i valori rimossi. È possibile modificare l'esempio dell'array oceans in modo che la chiamata al metodo splice() assegni all'array una nuova variabile di array, come illustrato dall'esempio seguente:

var lakes:Array = oceans.splice(2, 2, "Arctic", "Atlantic"); 
trace(lakes); // output: Aral,Superior

È possibile imbattersi in codici che utilizzano l'operatore delete su un elemento dell'oggetto Array. L'operatore delete imposta il valore di un elemento di array su undefined , ma non rimuove l'elemento dall'array. Ad esempio, il codice seguente usa l'operatore delete sul terzo elemento nell'array oceans , ma la lunghezza dell'array rimane 5:

var oceans:Array = ["Arctic", "Pacific", "Victoria", "Indian", "Atlantic"]; 
delete oceans[2]; 
trace(oceans);// output: Arctic,Pacific,,Indian,Atlantic 
trace(oceans[2]); // output: undefined 
trace(oceans.length); // output: 5

È possibile troncare un array o un vettore mediante la proprietà length dell'array. Se impostate la proprietà length di un array indicizzato su una lunghezza inferiore rispetto alla lunghezza corrente dell'array, l'array verrà troncato e tutti gli elementi con numero di indice superiore rispetto al nuovo valore length meno 1 verranno eliminati. Ad esempio, se ordinate l'array oceans in modo che tutte le voci valide si trovino all'inizio dell'array, potete utilizzare la proprietà length per rimuovere le voci situate alla fine dell'array, come mostra il seguente codice:

var oceans:Array = ["Arctic", "Pacific", "Victoria", "Aral", "Superior"]; 
oceans.length = 2; 
trace(oceans); // output: Arctic,Pacific

Esistono tre metodi che consentono di modificare l'ordine di un array indicizzato: reverse() , sort() e sortOn() ; questi metodi consentono di disporre gli elementi in ordine diretto o inverso. Tutti e tre i metodi consentono di modificare l'array esistente. La seguente tabella riassume questi metodi e il relativo comportamento degli oggetti Array e Vector.

var oceans:Array = ["Arctic", "Atlantic", "Indian", "Pacific"]; 
oceans.reverse(); 
trace(oceans); // output: Pacific,Indian,Atlantic,Arctic

var poets:Array = ["Blake", "cummings", "Angelou", "Dante"]; 
poets.sort(); // default sort 
trace(poets); // output: Angelou,Blake,Dante,cummings 
 
poets.sort(Array.CASEINSENSITIVE); 
trace(poets); // output: Angelou,Blake,cummings,Dante 
 
poets.sort(Array.DESCENDING); 
trace(poets); // output: cummings,Dante,Blake,Angelou 
 
poets.sort(Array.DESCENDING | Array.CASEINSENSITIVE); // use two options 
trace(poets); // output: Dante,cummings,Blake,Angelou

var names:Array = new Array("John Q. Smith", "Jane Doe", "Mike Jones"); 
function orderLastName(a, b):int 
{ 
    var lastName:RegExp = /\b\S+$/; 
    var name1 = a.match(lastName); 
    var name2 = b.match(lastName); 
    if (name1 < name2) 
    { 
        return -1; 
    } 
    else if (name1 > name2) 
    { 
        return 1; 
    } 
    else 
    { 
        return 0; 
    } 
} 
trace(names); // output: John Q. Smith,Jane Doe,Mike Jones 
names.sort(orderLastName); 
trace(names); // output: Jane Doe,Mike Jones,John Q. Smith

var poets:Array = new Array(); 
poets.push({name:"Angelou", born:"1928"}); 
poets.push({name:"Blake", born:"1757"}); 
poets.push({name:"cummings", born:"1894"}); 
poets.push({name:"Dante", born:"1265"}); 
poets.push({name:"Wang", born:"701"});

poets.sortOn("born", Array.NUMERIC); 
for (var i:int = 0; i < poets.length; ++i) 
{ 
    trace(poets[i].name, poets[i].born); 
} 
/* output: 
Wang 701 
Dante 1265 
Blake 1757 
cummings 1894 
Angelou 1928 
*/

var indices:Array; 
indices = poets.sortOn("born", Array.NUMERIC | Array.RETURNINDEXEDARRAY); 
for (var i:int = 0; i < indices.length; ++i) 
{ 
    var index:int = indices[i]; 
    trace(poets[index].name, poets[index].born); 
} 
/* output: 
Wang 701 
Dante 1265 
Blake 1757 
cummings 1894 
Angelou 1928 
*/

Esistono quattro metodi per cercare informazioni in un array senza modificarlo: concat() , join() , slice() e toString() . I metodi concat() e slice() restituiscono nuovi array, mentre i metodi join() e toString() restituiscono stringhe. Il metodo concat() usa un nuovo array o un elenco di elementi come argomenti e li combina con l'array esistente per creare un nuovo array. Il metodo slice() usa due parametri, denominati startIndex e endIndex , per restituire un nuovo array contenente una copia degli elementi “sezionati” dall'array esistente. Il sezionamento inizia dall'elemento in posizione startIndex e termina con l'elemento che precede endIndex . Questo sistema prevede la ripetizione: l'elemento in posizione endIndex non è incluso nel valore restituito.

Nell'esempio seguente, vengono utilizzati i metodi concat() e slice() per creare nuovi array utilizzando elementi di altri array:

var array1:Array = ["alpha", "beta"]; 
var array2:Array = array1.concat("gamma", "delta"); 
trace(array2); // output: alpha,beta,gamma,delta 
 
var array3:Array = array1.concat(array2); 
trace(array3); // output: alpha,beta,alpha,beta,gamma,delta 
 
var array4:Array = array3.slice(2,5); 
trace(array4); // output: alpha,beta,gamma

È possibile utilizzare i metodi join() e toString() per eseguire query all'interno dell'array e restituire il contenuto sotto forma di stringa. Se non vengono utilizzati parametri per il metodo join() , i due metodi si comportano in maniera identica: restituiscono una stringa contenente un elenco delimitato da virgole di tutti gli elementi dell'array. Il metodo join() , a differenza del metodo toString() , accetta un parametro denominato delimiter , che consente di selezionare il simbolo da usare come separatore tra ogni elemento della stringa restituita.

Nell'esempio seguente viene creato un array denominato rivers e vengono chiamati sia il metodo join() che il metodo toString() per restituire i valori dell'array sotto forma di stringa. Il metodo toString() viene usato per restituire valori separati da virgola ( riverCSV ), mentre il metodo join() viene usato per restituire valori separati dal carattere + .

var rivers:Array = ["Nile", "Amazon", "Yangtze", "Mississippi"]; 
var riverCSV:String = rivers.toString(); 
trace(riverCSV); // output: Nile,Amazon,Yangtze,Mississippi 
var riverPSV:String = rivers.join("+"); 
trace(riverPSV); // output: Nile+Amazon+Yangtze+Mississippi

Quando utilizzate il metodo join() , dovete considerare che gli array nidificati vengono sempre restituiti con valori separati da virgola, a prescindere dal tipo di separatore specificato per gli elementi dell'array principale, come illustrato nell'esempio seguente:

var nested:Array = ["b","c","d"]; 
var letters:Array = ["a",nested,"e"];  
var joined:String = letters.join("+"); 
trace(joined); // output: a+b,c,d+e