Array indicizzati

Flash Player 9 e versioni successive, Adobe AIR 1.0 e versioni successive

Gli array indicizzati sono in grado di memorizzare uno o più valori organizzati in modo che ciascun valore risulti accessibile mediante l'uso di un valore intero. Il primo indice è sempre il numero 0 e viene incrementato di un'unità a ogni elemento successivo aggiunto all'array. In ActionScript 3.0 vengono utilizzate due classi come array indicizzati: Array e Vector.

Gli array indicizzati utilizzano valori interi senza segno a 32 bit come numeri di indice. La dimensione massima di un array indicizzato è 232 - 1 o 4.294.967.295. Qualsiasi tentativo di creare un array di dimensioni superiori genera un errore di runtime.

Per accedere a un singolo elemento di un array indicizzato, utilizzate l'operatore di accesso array ([]) per specificare la posizione di indice dell'elemento al quale desiderate accedere. Il seguente codice, ad esempio, rappresenta il primo elemento (corrispondente all'indice 0) all'interno di un array indicizzato chiamato songTitles:

songTitles[0]

La combinazione del nome della variabile array e dell'indice racchiuso tra parentesi quadre funziona come un identificatore singolo (pertanto può essere utilizzato allo stesso modo di qualsiasi nome di variabile). È possibile assegnare un valore a un elemento di un array indicizzato utilizzando il nome e l'indice sul lato sinistro di un'istruzione di assegnazione:

songTitles[1] = "Symphony No. 5 in D minor";

Allo stesso modo, è possibile recuperare il valore di un elemento di un array indicizzato utilizzando il nome e l'indice sul lato destro di un'istruzione di assegnazione:

var nextSong:String = songTitles[2];

Potete, inoltre, utilizzare all'interno delle parentesi quadre una variabile anziché fornire un valore esplicito (la variabile deve contenere un valore intero non negativo quale un valore uint, int positivo o un'istanza di numero intero positivo). Questa tecnica viene utilizzata solitamente per applicare dei cicli agli elementi all'interno di un array indicizzato ed effettuare un'operazione su tutti o alcuni elementi. Il seguente esempio di codice dimostra come utilizzare questa tecnica. Il codice utilizza un ciclo per accedere a ciascun valore in un oggetto Array chiamato oddNumbers. Utilizza l'istruzione trace() per restituire ciascun valore nella forma “oddNumber[indice] = valore”:

var oddNumbers:Array = [1, 3, 5, 7, 9, 11]; 
var len:uint = oddNumbers.length; 
for (var i:uint = 0; i < len; i++) 
{ 
    trace("oddNumbers[" + i.toString() + "] = " + oddNumbers[i].toString()); 
}

La classe Array

Il primo tipo di array indicizzato è la classe Array. Un'istanza Array può contenere un valore appartenente a qualsiasi tipo di dati. Lo stesso oggetto Array, inoltre, può contenere oggetti appartenenti a tipi di dati diversi tra loro. Una singola istanza Array, ad esempio, può contenere un valore stringa per l'indice 0, un valore numerico per l'indice 1 e un oggetto XML per l'indice 2.

La classe Vector

Un altro tipo di array indicizzato disponibile in ActionScript 3.0 è la classe Vector (vettore). Un'istanza Vector è un array tipizzato; questo implica che tutti gli elementi all'interno di un'istanza Vector appartengono sempre allo stesso tipo di dati.

Nota: la classe Vector è disponibile a partire da Flash Player 10 e Adobe AIR 1.5.

Quando dichiarate una variabile Vector o create un'istanza per un oggetto Vector, dovete specificare esplicitamente il tipo di dati che il vettore può contenere. I tipi di dati specificati inseriti vengono definiti come tipo base del vettore. In fase di runtime e di compilazione (modalità rigorosa), viene controllato qualsiasi codice che imposta un valore di un elemento del vettore o recupera un valore da un vettore. Se il tipo di dati dell'oggetto aggiunto o recuperato non corrisponde al tipo base del vettore, si verifica un errore.

Oltre alla restrizione relativa al tipo di dati, la classe Vector presenta altre restrizioni che la distinguono dalla classe Array:

  • Un vettore è un array di tipo denso. Un oggetto Array può contenere dei valori negli indici 0 e 7 anche se non contiene alcun valore nelle posizioni da 1 a 6. Un vettore, invece, deve avere un valore (o null) per ciascun indice.

  • È possibile, inoltre, fissare la dimensione del vettore. Questo implica che il numero di elementi contenuti dal vettore non può essere modificato.

  • L'accesso agli elementi di un vettore è soggetto al controllo dei limiti. Non è mai possibile leggere un valore da un indice di grandezza superiore a quello dell'ultimo elemento del vettore (length - 1). Non è mai possibile impostare un valore con un indice più grande di uno rispetto all'indice finale corrente (in altre parole è possibile impostare i valori solo in corrispondenza degli indici esistenti dell'indice [length]).

A causa di queste restrizioni, un vettore presenta tre vantaggi principali rispetto a un'istanza Array i cui elementi sono tutti istanze di una sola classe:

  • Prestazioni: l'iterazione e l'accesso agli elementi dell'array sono molto più veloci quando si utilizza un'istanza Vector rispetto a un'istanza Array.

  • Sicurezza del tipo: in modalità rigorosa, il programma di compilazione può identificare gli errori relativi al tipo di dati. Questi errori possono comprendere l'assegnazione a un vettore di un valore appartenente a un tipo di dati errato o l'attesa di un tipo di dati errato nel corso della lettura di un valore contenuto nel vettore. Anche in fase di runtime viene effettuato un controllo dei tipi di dati in caso di lettura o scrittura di dati su un oggetto Vector. Notate, tuttavia, che quando si utilizza il metodo push() o unshift() per aggiungere valori a un vettore, i tipi di dati degli argomenti non vengono verificati in fase di compilazione. Quando utilizzate questi metodi, i valori vengono comunque verificati in fase di runtime.

  • Affidabilità: la verifica dell'intervallo in fase di esecuzione (o la verifica lunghezza fissa) incrementa in modo rilevante l'affidabilità rispetto agli array.

Nonostante le restrizioni e i vantaggi aggiuntivi, la classe Vector è molto simile alla classe Array. Le proprietà e i metodi di un oggetto Vector sono simili (e in molti casi identici) alle proprietà e ai metodi di un oggetto Array. In molti casi, al posto di un'istanza Array in cui tutti gli elementi hanno lo stesso tipo di dati, è preferibile utilizzare un'istanza Vector.

Creazione di array

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.

Creazione di un'istanza Array

È possibile creare un oggetto Array chiamando la funzione di costruzione Array() o utilizzando la sintassi letterale Array.

La funzione di costruzione Array() può essere utilizzata in tre modi. Primo: se chiamate la funzione di costruzione senza argomenti, viene restituito un array vuoto. Potete utilizzare la proprietà length della classe Array per verificare che l'array non contenga elementi. Il codice seguente consente, ad esempio, di chiamare la funzione di costruzione Array() senza argomenti:

var names:Array = new Array(); 
trace(names.length); // output: 0

Secondo: se utilizzate un numero come unico parametro della funzione di costruzione Array(), viene creato un array di lunghezza corrispondente, con il valore di ciascun elemento impostato su undefined. L'argomento deve essere un numero intero senza segno compreso tra 0 e 4.294.967.295. Il codice seguente consente, ad esempio, di chiamare la funzione di costruzione Array() con un solo argomento numerico:

var names:Array = new Array(3); 
trace(names.length); // output: 3 
trace(names[0]); // output: undefined 
trace(names[1]); // output: undefined 
trace(names[2]); // output: undefined

Terzo: se chiamate la funzione di costruzione e inviate un elenco di elementi come parametri, viene creato un array con elementi corrispondenti a ognuno dei parametri. Il codice seguente consente di trasmettere tre argomenti alla funzione di costruzione Array():

var names:Array = new Array("John", "Jane", "David"); 
trace(names.length); // output: 3 
trace(names[0]); // output: John 
trace(names[1]); // output: Jane 
trace(names[2]); // output: David

È anche possibile inoltre creare degli array con valori letterali, assegnando un valore letterale di array direttamente a una qualsiasi variabile di array, come illustrato nell'esempio seguente:

var names:Array = ["John", "Jane", "David"];

Creazione di un'istanza Vector

È possibile creare un'istanza Vector chiamando la funzione di costruzione Vector.<T>(). È possibile creare un vettore anche chiamando la funzione globale Vector.<T>(). Questa funzione converte uno specifico oggetto in un'istanza Vector. In Flash Professional CS5 e versioni successive, Flash Builder 4 e versioni successive, nonché Flex 4 e versioni successive, potete anche creare un'istanza Vector utilizzando la sintassi letterale di Vector.

Ogniqualvolta dichiarate una variabile Vector (o in modo simile, un parametro del metodo Vector o un tipo di metodo restituito), è necessario specificare la variabile Vector. Nel creare un'istanza Vector, è necessario, inoltre, specificare il tipo base chiamando la funzione di costruzione Vector.<T>(). In altri termini, ogni volta che utilizzate il termine Vector in ActionScript, dovete specificare il tipo base.

Per specificare il tipo base del vettore dovete utilizzare la sintassi del parametro. Il parametro che specifica il tipo segue immediatamente la parola Vector all'interno del codice. È costituito da un punto (.) seguito dal nome della classe inserito all'interno di parentesi angolari (<>), come mostrato in questo esempio:

var v:Vector.<String>; 
v = new Vector.<String>();

Nella prima riga dell'esempio, la variabile v viene dichiarata come istanza Vector.<String>. In altre parole, rappresenta un array indicizzato che può contenere istanze String. La seconda riga chiama la funzione di costruzione Vector() per creare un'istanza dello stesso tipo di vettore (cioè un vettore i cui elementi siano tutti oggetti String). Assegna quindi quell'oggetto a v.

Uso della funzione di costruzione Vector.<T>()

Se utilizzate la funzione di costruzione Vector.<T>() senza alcun argomento, viene creata un'istanza Vector vuota. Potete verificare che un vettore sia vuoto, controllandone la proprietà length. Il seguente codice, ad esempio, chiama la funzione di costruzione Vector.<T>() senza argomenti:

var names:Vector.<String> = new Vector.<String>(); 
trace(names.length); // output: 0

Se conoscete in anticipo quanti saranno gli elementi che il vettore dovrà contenere, potete predefinire il numero di elementi del vettore. Per creare un vettore con un certo numero di elementi, indicate il numero di elementi come primo parametro (il parametro length). Poiché gli elementi del vettore non possono essere vuoti, vengono riempiti con istanze del tipo base. Se il tipo base è un tipo di riferimento che consente dei valori null, tutti gli elementi del vettore appena creato saranno null. In caso contrario, tutti gli elementi conterranno il valore predefinito assegnato alla loro classe. Una variabile unità, ad esempio, non può essere null. Di conseguenza, all'interno del seguente codice di esempio, il vettore nominato ages (età) viene creato con sette elementi tutti contenenti il valore 0.

var ages:Vector.<uint> = new Vector.<uint>(7); 
trace(ages); // output: 0,0,0,0,0,0,0 

Infine, utilizzando la funzione di costruzione Vector.<T>(), potete creare un vettore a lunghezza fissa, assegnando il valore true al secondo parametro (il parametro fixed). In questo caso, il vettore viene creato con un numero specifico e immutabile di elementi. Notate, tuttavia, che i valori degli elementi di un vettore a lunghezza fissa, possono essere modificati in qualsiasi momento.

Utilizzo della funzione di costruzione della sintassi letterale di Vector

In Flash Professional CS5 e versioni successive, Flash Builder 4 e versioni successive, nonché Flex 4 e versioni successive, potete passare un elenco di lavori alla funzione di costruzione Vector.<T>() per specificare i valori iniziali del vettore:

// var v:Vector.<T> = new <T>[E0, ..., En-1 ,]; 
// For example: 
var v:Vector.<int> = new <int>[0,1,2,];

Le informazioni seguenti sono valide per questa sintassi:

  • La virgola finale è opzionale.

  • Elementi vuoti nell'array non sono supportati; un'istruzione del tipo var v:Vector.<int> = new <int>[0,,2,] genera un errore del compilatore.

  • Non potete specificare una lunghezza predefinita per l'istanza Vector. Piuttosto, la lunghezza corrisponde al numero di elementi nell'elenco di inizializzazione.

  • Non potete specificare se l'istanza Vector ha una lunghezza fissa. Al contrario, utilizzate la proprietà fixed.

  • Perdite di dati ed errori si possono verificare se gli elementi passati come valori non corrispondono al tipo specificato. Ad esempio:
    var v:Vector.<int> = new <int>[4.2]; // compiler error when running in strict mode 
    trace(v[0]); //returns 4 when not running in strict mode

Uso della funzione di costruzione Vector.<T>()

Oltre alla funzione di costruzione Vector.<T>() e della sintassi letterale di Vector, potete anche utilizzare la funzione globale Vector.<T>() per creare un oggetto Vector. La funzione globale Vector.<T>() è una funzione di conversione. Quando chiamate la funzione globale Vector.<T>(), dovete specificare il tipo base del vettore che verrà restituito dal metodo. Come argomento, è necessario inserire un singolo array indicizzato (istanza Array o Vector). Il metodo, quindi, restituisce un vettore il cui tipo base è quello specificato e contenente i valori dell'array sorgente specificato come argomento. Il seguente codice di esempio mostra la sintassi che chiama la funzione globale Vector.<T>():

var friends:Vector.<String> = Vector.<String>(["Bob", "Larry", "Sarah"]);

La funzione globale Vector.<T>() effettua una conversione del tipo di dati su due livelli. Per prima cosa, quando un'istanza Array viene assegnata alla funzione, viene restituita un'istanza Vector. Successivamente, se l'array di origine è un'istanza Array o Vector, la funzione tenta di convertire gli elementi della sorgente in valori del tipo base. La conversione utilizza le regole di conversione del tipo di dati standard di ActionScript. Il seguente codice, ad esempio, converte i valori String dell'array sorgente in numeri interi all'interno del vettore risultante. La parte decimale del primo valore ("1.5") viene rimossa, mentre il terzo valore di tipo non numerico ("Waffles") viene convertito in 0:

var numbers:Vector.<int> = Vector.<int>(["1.5", "17", "Waffles"]); 
trace(numbers); // output: 1,17,0

Se qualcuno degli elementi non può essere convertito, si verifica un errore.

Quando il codice chiama la funzione globale Vector.<T>(), se un elemento nell'array di origine è una sottoclasse del tipo base specificato, l'elemento viene aggiunto al vettore risultante e non viene generato alcun errore. Uso della funzione di costruzione Vector.<T>() costituisce l'unico modo per convertire un vettore con un determinato tipo base T in un vettore il cui tipo base sia la superclasse di T.

Inserimento di elementi di array

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.

Nota: se la proprietà fixed di un oggetto Vector è true, il numero totale di elementi del vettore non può essere modificato. Se tentate di aggiungere un nuovo elemento a un vettore a lunghezza fissa utilizzando la tecnica qui descritta, viene generato un errore.

Recupero di valori e rimozione degli elementi di un array

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
Nota: se la proprietà fixed di un oggetto Vector è true, il numero totale di elementi del vettore non può essere modificato. Se provate a rimuovere un elemento o a troncare un vettore a lunghezza fissa utilizzando le tecniche qui descritte, viene generato un errore.

Ordinamento di un array

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.

Metodo

Comportamento dell'array

Comportamento del vettore

reverse()

Modifica l'ordine degli elementi in modo che l'ultimo elemento diventi il primo, il penultimo elemento diventi il secondo e così via

Comportamento identico a quello dell'array

sort()

Consente di ordinare gli elementi dell'array secondo diversi modi predefiniti, come ordine alfabetico o ordine numerico. È possibile inoltre specificare un algoritmo di ordinamento personalizzato.

Ordina gli elementi secondo un algoritmo di ordinamento specificato

sortOn()

Consente di ordinare gli oggetti che hanno una o più proprietà in comune, specificando la proprietà o le proprietà da utilizzare come chiavi di ordinamenti.

Non disponibile per la classe Vector

Il metodo reverse()

Il metodo reverse() non accetta parametri e non restituisce valori, ma permette di alternare l'ordine dell'array dallo stato corrente a quello inverso. Nell'esempio seguente viene invertito l'ordine degli oceani elencati nell'array oceans:

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

Ordinamento di base tramite metodo sort() (solo per la classe Array)

Per un'istanza array, il metodo sort() consente di riordinare gli elementi di un array utilizzando l'ordine predefinito. L'ordine predefinito presenta le seguenti caratteristiche:

  • Nell'ordinamento viene fatta distinzione tra maiuscole e minuscole, vale a dire che i caratteri maiuscoli precedono i minuscoli. Ad esempio, la lettera D precede la lettera b.

  • L'ordinamento è crescente, vale a dire che un codice contenente le prime lettere dell'alfabeto (quale A) precede il codice contenente le lettere successive (quale B).

  • L'ordinamento colloca valori identici l'uno accanto all'altro, ma in nessun ordine particolare.

  • L'ordinamento è basato sulle stringhe, vale a dire che gli elementi vengono convertiti in stringhe prima di essere confrontati (ad esempio, 10 precede 3 perché la stringa "1" ha un codice di carattere inferiore rispetto alla stringa "3").

Potrebbe essere necessario ordinare un array a prescindere dai caratteri maiuscoli e minuscoli o in ordine decrescente, oppure l'array potrebbe contenere valori da ordinare numericamente invece che alfabeticamente. Il metodo sort() della classe Array presenta un parametro options che consente di modificare singole caratteristiche dell'ordine predefinito. Le opzioni vengono definite da una serie di costanti statiche della classe Array, come illustrato nell'elenco seguente:

  • Array.CASEINSENSITIVE: questa opzione consente di ignorare i caratteri maiuscoli/minuscoli durante l'ordinamento. La lettera minuscola b, ad esempio, precede la lettera maiuscola D.

  • Array.DESCENDING: questa opzione inverte l'ordine crescente predefinito. La lettera B, ad esempio, precede la lettera A.

  • Array.UNIQUESORT: questa opzione interrompe l'ordinamento se vengono rilevati due valori identici.

  • Array.NUMERIC: questa opzione consente un ordinamento numerico, ad esempio 3 precede 10.

Nell'esempio seguente sono evidenziate alcune di queste opzioni. Viene creato un array chiamato poets ordinato in base a una serie di opzioni differenti.

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

Ordinamento personalizzato tramite il metodo sort() (classi Array e Vector)

Oltre all'ordinamento di base disponibile per un oggetto Array, è possibile definire delle regole di ordinamento personalizzate. Questa tecnica è l'unica possibile per applicare il metodo sort() disponibile per la classe Vector. Per definire un ordinamento personalizzato, scrivete una funzione di ordinamento personalizzato e assegnatela come argomento al metodo sort().

Se, ad esempio, disponete di un elenco di nomi in cui ogni elemento contiene nome e cognome di una persona, ma desiderate ordinare l'elenco solo in base al cognome, dovete utilizzare una funzione di ordinamento personalizzata per analizzare ogni elemento e usare solo il cognome nella funzione di ordinamento. Il codice seguente illustra come è possibile farlo con una funzione personalizzata utilizzata come parametro del metodo Array.sort():

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

La funzione di ordinamento personalizzata orderLastName() usa un'espressione regolare per estrarre il cognome da ogni elemento da usare per l'operazione di confronto. L'identificatore della funzione orderLastName viene utilizzato come unico parametro durante la chiamata al metodo sort() per l'array names. La funzione di ordinamento accetta due parametri, a e b, in quanto funziona su due elementi di array per volta. Il valore restituito dalla funzione di ordinamento indica come devono essere ordinati gli elementi:

  • Un valore restituito di -1 indica che il primo parametro, a, precede il secondo parametro, b.

  • Un valore restituito di 1 indica che il secondo parametro, b, precede il primo parametro, a.

  • Un valore restituito di 0 indica che gli elementi hanno precedenza di ordinamento uguale.

Metodo sortOn() (solo classe Array)

Il metodo sortOn() è pensato per oggetti Array che contengono oggetti. Tali oggetti devono avere almeno una proprietà comune da utilizzare come chiave dell'ordinamento. L'uso del metodo sortOn() per array di qualsiasi altro tipo genera risultati inattesi.

Nota: la classe Vector non include il metodo sortOn(). Questo metodo è disponibile solamente per gli oggetti Array.

Nell'esempio seguente l'array poets viene rivisto in modo che ciascun elemento sia un oggetto anziché una stringa. Ogni oggetto contiene il cognome del poeta e l'anno di nascita.

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

È possibile utilizzare il metodo sortOn() per ordinare l'array secondo la proprietà born. Il metodo sortOn() definisce due parametri, fieldName e options. L'argomento fieldName deve essere specificato come stringa. Nell'esempio seguente, sortOn() viene chiamato con due argomenti, "born" e Array.NUMERIC. L'argomento Array.NUMERIC viene utilizzato per fare in modo che l'ordinamento sia numerico anziché alfabetico. Si tratta di un sistema efficace quando tutti i valori presentano lo stesso numero di cifre, in quanto assicura che l'ordinamento continuerà a essere eseguito correttamente anche se nell'array viene inserito un valore con un numero di cifre inferiore o superiore.

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 
*/

Ordinamento senza modifica dell'array originale (solo per la classe Array)

Solitamente i metodi sort() e sortOn() apportano delle modifiche all'array. Se desiderate ordinare un array senza modificarlo, inserite la costante Array.RETURNINDEXEDARRAY come componente del parametro options. Questa opzione indica ai metodi di restituire un nuovo array che rifletta l'ordinamento richiesto e lasci invariato l'array originale. L'array restituito dai metodi è un semplice array di numeri di indice che riflette il nuovo ordinamento e non contiene elementi dell'array originale. Per ordinare, ad esempio, l'array poets in base all'anno di nascita senza modificare l'array, includete la costante Array.RETURNINDEXEDARRAY nell'argomento del parametro options.

L'esempio seguente memorizza le informazioni di indice restituite in un array denominato indices e utilizza l'array indices unitamente all'array poets non modificato per elencare i poeti in ordine di anno di nascita:

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 
*/

Query di un array

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