| Pacchetto | Primo livello |
| Classe | public dynamic class Array |
| Ereditarietà | Array  Object |
| Versione linguaggio: | ActionScript 3.0 |
| Versioni runtime: | AIR 1.0, Flash Player 9, Flash Lite 4 |
[0] è il primo elemento dell'array, [1] è il secondo, e così via. Per creare un oggetto Array, utilizzate la funzione di costruzione new Array(). Potete anche chiamare Array() come funzione. Inoltre, potete utilizzare l'operatore di accesso all'array ([]) per inizializzare un array o accedere agli elementi di un array.
Potete memorizzare una vasta gamma di tipi di dati in un elemento di array, tra cui numeri, stringhe, oggetti e persino altri array. Potete creare un array multidimensionale creando un array indicizzato e assegnando un array indicizzato diverso a ognuno dei suoi elementi. Un array di questo tipo è considerato multidimensionale poiché può essere utilizzato per rappresentare i dati in una tabella.
Gli array sono sparsi, il che significa che potrebbe essere presente un elemento in corrispondenza dell'indice 0 e un altro in corrispondenza dell'indice 5, ma non esserci nulla nelle posizioni intermedie tra questi due elementi. In tal caso, gli elementi nelle posizioni da 1 a 4 sono "undefined", indicazione che denota l'assenza di un elemento, non necessariamente la presenza di un elemento con il valore undefined.
L'assegnazione all'array avviene in base al riferimento anziché al valore. Quando assegnate una variabile di array a un'altra variabile di array, entrambe fanno riferimento allo stesso array:
var oneArray:Array = new Array("a", "b", "c");
var twoArray:Array = oneArray; // Both array variables refer to the same array.
twoArray[0] = "z";
trace(oneArray); // Output: z,b,c.
Non utilizzate la classe Array per creare array associativi (definiti anche hash), che sono strutture di dati diverse che contengono elementi con nome anziché elementi numerati. Per creare array associativi, utilizzate la classe Object. Benché ActionScript consenta di creare gli array associativi mediante la classe Array, con gli array associativi non è possibile utilizzare nessuno dei metodi o delle proprietà della classe Array.
Potete estendere la classe Array e ignorare o aggiungere metodi. Tuttavia, dovete specificare la sottoclasse come dynamic per non perdere la possibilità di memorizzare dati in un array.
Altri esempi
Inserimento di elementi di array
Recupero di valori e rimozione degli elementi di un array
Ordinamento di un array
Query di un array
Estensione della classe Array
Esempio di array: PlayList
Altre informazioni
Elementi fondamentali degli array
Array indicizzati
Array associativi
Array multidimensionali
Clonazione di array
Elementi API correlati
Nascondi proprietà pubbliche ereditate
Mostra proprietà pubbliche ereditate| Proprietà | Definito da | ||
|---|---|---|---|
 | constructor : Object
Un riferimento all'oggetto classe o alla funzione di costruzione per una determinata istanza di oggetto. | Object | |
| length : uint
Un numero intero non negativo che specifica il numero di elementi nell'array. | Array | ||
| Metodo | Definito da | ||
|---|---|---|---|
Consente di creare un array che contiene gli elementi specificati. | Array | ||
Consente di creare un array del numero specificato di elementi. | Array | ||
Concatena gli elementi specificati nei parametri con gli elementi di un array e crea un nuovo array. | Array | ||
Esegue una funzione di prova su ciascun elemento dell'array fino a quando non viene raggiunto un elemento che restituisce false per la funzione specificata. | Array | ||
Esegue una funzione di prova su ciascun elemento dell'array e crea un nuovo array per tutti gli elementi che restituiscono true per la funzione specificata. | Array | ||
Esegue una funzione su ciascun elemento nell'array. | Array | ||
|
Indica se per un oggetto è definita una proprietà specifica. | Object | |
Cerca un elemento in un array utilizzando l'operatore di uguaglianza rigorosa (===) e restituisce la posizione di indice dell'elemento. | Array | ||
Inserite un singolo elemento in un array. | Array | ||
|
Indica se un'istanza della classe Object si trova nella catena di prototipi dell'oggetto specificato come parametro. | Object | |
Converte in stringhe gli elementi di un array, inserisce il separatore specificato tra gli elementi, li concatena e restituisce la stringa risultante. | Array | ||
Cerca un elemento in un array a ritroso partendo dall'ultimo elemento e restituisce la posizione di indice dell'elemento corrispondente mediante l'operatore di uguaglianza rigorosa (===). | Array | ||
Esegue una funzione su ciascun elemento in un array e crea un nuovo array di elementi corrispondenti ai risultati della funzione eseguita su ciascun elemento dell'array originale. | Array | ||
Rimuove l'ultimo elemento di un array e ne restituisce il valore. | Array | ||
|
Indica se la proprietà specificata esiste ed è enumerabile. | Object | |
Aggiunge uno o più elementi alla fine di un array e restituisce la nuova lunghezza dell'array. | Array | ||
Rimuovete un singolo elemento da un array. | Array | ||
Inverte l'array in posizione. | Array | ||
|
Imposta la disponibilità di una proprietà dinamica per le operazioni cicliche. | Object | |
Rimuove il primo elemento di un array e lo restituisce. | Array | ||
Restituisce un nuovo array composto da un intervallo di elementi dell'array originale, senza modificare quest'ultimo. | Array | ||
Esegue una funzione di prova su ciascun elemento dell'array fino a quando non viene raggiunto un elemento che restituisce true. | Array | ||
Ordina gli elementi di un array. | Array | ||
Ordina gli elementi di un array in base a uno o più campi dell'array. | Array | ||
Aggiunge e rimuove gli elementi di un array. | Array | ||
Restituisce una stringa che rappresenta gli elementi dell'array specificato. | Array | ||
Restituisce una stringa che rappresenta gli elementi dell'array specificato. | Array | ||
Aggiunge uno o più elementi all'inizio di un array e restituisce la nuova lunghezza dell'array. | Array | ||
|
Restituisce il valore di base dell'oggetto specificato. | Object | |
| Costante | Definito da | ||
|---|---|---|---|
| CASEINSENSITIVE : uint = 1 [statico]
Specifica l'ordinamento senza distinzione tra maiuscole e minuscole per i metodi di ordinamento della classe Array. | Array | ||
| DESCENDING : uint = 2 [statico]
Specifica l'ordinamento discendente per i metodi di ordinamento della classe Array. | Array | ||
| NUMERIC : uint = 16 [statico]
Specifica l'ordinamento numerico (anziché carattere-stringa) per i metodi di ordinamento della classe Array. | Array | ||
| RETURNINDEXEDARRAY : uint = 8 [statico]
Specifica che un ordinamento restituisce un array composto da indici di array. | Array | ||
| UNIQUESORT : uint = 4 [statico]
Specifica il requisito dell'ordinamento univoco per i metodi di ordinamento della classe Array. | Array | ||
length | proprietà |
length:uint| Versione linguaggio: | ActionScript 3.0 |
| Versioni runtime: | AIR 1.0, Flash Player 9, Flash Lite 4 |
Un numero intero non negativo che specifica il numero di elementi nell'array. Questa proprietà viene aggiornata automaticamente quando vengono aggiunti dei nuovi elementi all'array. Quando assegnate un valore a un elemento di un array (ad esempio, my_array[index] = value), se index è un numero e index+1 è maggiore della proprietà length, tale proprietà length viene aggiornata a index+1.
Nota: se assegnate alla proprietà length un valore più breve della lunghezza esistente, l'array viene troncato.
Implementazione
public function get length():uint public function set length(value:uint):voidEsempio ( Come utilizzare questo esempio )
names con l'elemento stringa Bill. Quindi, utilizza il metodo push() per aggiungere un altro elemento stringa Kyle. La lunghezza dell'array, determinata dalla proprietà length, si trova un elemento prima del metodo push() e due elementi dopo la chiamata a push(). Viene aggiunta quindi un'altra stringa, Jeff; in questo modo, la lunghezza di names è costituita da tre elementi. Il metodo shift() viene quindi chiamato due volte per rimuovere Bill e Kyle, riducendo l'array finale length a un elemento.
var names:Array = new Array("Bill");
names.push("Kyle");
trace(names.length); // 2
names.push("Jeff");
trace(names.length); // 3
names.shift();
names.shift();
trace(names.length); // 1
Array | () | Funzione di costruzione |
public function Array(... values)| Versione linguaggio: | ActionScript 3.0 |
| Versioni runtime: | AIR 1.0, Flash Player 9, Flash Lite 4 |
Consente di creare un array che contiene gli elementi specificati. Potete specificare valori di qualsiasi tipo. Il primo elemento di un array ha sempre l'indice (o la posizione) 0.
Nota: questa classe mostra due elementi di costruzione perché la funzione di costruzione accetta i tipi variabile degli argomenti. La funzione di costruzione si comporta in modo diverso a seconda del tipo e del numero di argomenti passati, come spiegato in dettaglio per ogni voce. ActionScript 3.0 non supporta l'overload dei metodi o delle funzioni di costruzione.
Parametri... values — Un elenco separato da virgole di uno o più valori arbitrari.
Nota: se alla funzione di costruzione Array viene passato un solo parametro numerico, si presuppone che quest'ultimo specifichi la proprietà |
Genera
RangeError — L'argomento è un numero, che non è un numero intero maggiore o uguale a 0.
|
Altri esempi
Elementi API correlati
Esempio ( Come utilizzare questo esempio )
one, two e three e quindi li converte in una stringa.
package {
import flash.display.Sprite;
public class Array_Array_3 extends Sprite {
public function Array_Array_3() {
var myArr:Array = new Array("one", "two", "three");
trace(myArr.length); // 3
trace(myArr); // one,two,three
}
}
}
Array | () | Funzione di costruzione |
public function Array(numElements:int = 0)| Versione linguaggio: | ActionScript 3.0 |
| Versioni runtime: | AIR 1.0, Flash Player 9, Flash Lite 4 |
Consente di creare un array del numero specificato di elementi. Se non specificate alcun parametro, viene creato un array che contiene 0 elementi. Se specificate un numero di elementi, viene creato un array con il numero numElements di elementi.
Nota: questa classe mostra due metodi di costruzione perché la funzione di costruzione accetta i tipi variabile degli argomenti. La funzione di costruzione si comporta in modo diverso a seconda del tipo e del numero di argomenti passati, come spiegato in dettaglio per ogni voce. ActionScript 3.0 non supporta l'overload dei metodi o delle funzioni di costruzione.
ParametrinumElements:int (default = 0) |
Genera
RangeError — L'argomento è un numero, che non è un numero intero maggiore o uguale a 0.
|
Altri esempi
Elementi API correlati
Esempio ( Come utilizzare questo esempio )
myArr senza argomenti e con una lunghezza iniziale pari a 0:
package {
import flash.display.Sprite;
public class Array_Array extends Sprite {
public function Array_Array() {
var myArr:Array = new Array();
trace(myArr.length); // 0
}
}
}
"one" e aggiunge l'elemento della stringa "six" alla fine dell'array mediante il metodo push():
package {
import flash.display.Sprite;
public class Array_Array_2 extends Sprite {
public function Array_Array_2() {
var myArr:Array = new Array(5);
trace(myArr.length); // 5
myArr[0] = "one";
myArr.push("six");
trace(myArr); // one,,,,,six
trace(myArr.length); // 6
}
}
}
concat | () | metodo |
AS3 function concat(... args):Array| Versione linguaggio: | ActionScript 3.0 |
| Versioni runtime: | AIR 1.0, Flash Player 9, Flash Lite 4 |
Concatena gli elementi specificati nei parametri con gli elementi di un array e crea un nuovo array. Se i parametri specificano un array, gli elementi di tale array sono concatenati. Se non passate alcun parametro, il nuovo array è un duplicato (shallow clone) dell'array originale.
Parametri
... args — Un valore di qualunque tipo di dati (numeri, elementi o stringhe) da concatenare in un nuovo array.
|
Array — Un array che contiene gli elementi di questo array seguiti dagli elementi appartenenti ai parametri.
|
Altri esempi
Esempio ( Come utilizzare questo esempio )
- L'array
numbersche contiene i numeri1,2e3. - L'array
lettersche contiene le letterea,bec. - L'array
numbersAndLettersche chiama il metodoconcat()per generare l'array[1,2,3,a,b,c]. - L'array
lettersAndNumbersche chiama il metodoconcat()per generare l'array[a,b,c,1,2,3].
var numbers:Array = new Array(1, 2, 3);
var letters:Array = new Array("a", "b", "c");
var numbersAndLetters:Array = numbers.concat(letters);
var lettersAndNumbers:Array = letters.concat(numbers);
trace(numbers); // 1,2,3
trace(letters); // a,b,c
trace(numbersAndLetters); // 1,2,3,a,b,c
trace(lettersAndNumbers); // a,b,c,1,2,3
every | () | metodo |
AS3 function every(callback:Function, thisObject:* = null):Boolean| Versione linguaggio: | ActionScript 3.0 |
| Versioni runtime: | AIR 1.0, Flash Player 9, Flash Lite 4 |
Esegue una funzione di prova su ciascun elemento nell'array fino a quando non viene raggiunto un elemento che restituisce false per la funzione specificata. Potete utilizzare questo metodo per determinare se tutti gli elementi di un array soddisfano un criterio, ad esempio se contengono valori inferiori a un determinato numero.
Per questo metodo, il secondo parametro thisObject deve essere null se il primo parametro callback è la chiusura di un metodo. Supponete di creare una funzione in un clip filmato di nome me:
function myFunction(obj:Object):void {
//your code here
}
Quindi, supponete di utilizzare il metodo every() su un array di nome myArray:
myArray.every(myFunction, me);
Dal momento che myFunction è un membro della classe Timeline, che non può essere ignorata da me, il runtime Flash genera un'eccezione. Questo errore di runtime può essere evitato assegnando la funzione a una variabile, come illustrato di seguito:
var myFunction:Function = function(obj:Object):void {
//your code here
};
myArray.every(myFunction, me);
Parametri
callback:Function — La funzione da eseguire su ciascun elemento nell'array. Questa funzione può contenere un semplice confronto (ad esempio, item < 20) oppure un'operazione più complessa, e viene richiamata con tre argomenti: il valore di un elemento, l'indice di un elemento e l'oggetto Array:
function callback(item:*, index:int, array:Array):Boolean; | |
thisObject:* (default = null)this per la funzione.
|
Boolean — Un valore booleano true se tutti gli elementi nell'array restituiscono true per la funzione specificata; in caso contrario, false.
|
Elementi API correlati
Esempio ( Come utilizzare questo esempio )
isNumeric è true per il primo array e false per il secondo:
package {
import flash.display.Sprite;
public class Array_every extends Sprite {
public function Array_every() {
var arr1:Array = new Array(1, 2, 4);
var res1:Boolean = arr1.every(isNumeric);
trace("isNumeric:", res1); // true
var arr2:Array = new Array(1, 2, "ham");
var res2:Boolean = arr2.every(isNumeric);
trace("isNumeric:", res2); // false
}
private function isNumeric(element:*, index:int, arr:Array):Boolean {
return (element is Number);
}
}
}
filter | () | metodo |
AS3 function filter(callback:Function, thisObject:* = null):Array| Versione linguaggio: | ActionScript 3.0 |
| Versioni runtime: | AIR 1.0, Flash Player 9, Flash Lite 4 |
Esegue una funzione di prova su ciascun elemento nell'array e crea un nuovo array per tutti gli elementi che restituiscono true per la funzione specificata. Se un elemento restituisce false, non viene incluso nel nuovo array.
Per questo metodo, il secondo parametro thisObject deve essere null se il primo parametro callback è la chiusura di un metodo. Supponete di creare una funzione in un clip filmato di nome me:
function myFunction(obj:Object):void {
//your code here
}
Quindi, supponete di utilizzare il metodo filter() su un array di nome myArray:
myArray.filter(myFunction, me);
Dal momento che myFunction è un membro della classe Timeline, che non può essere ignorata da me, il runtime Flash genera un'eccezione. Questo errore di runtime può essere evitato assegnando la funzione a una variabile, come illustrato di seguito:
var myFunction:Function = function(obj:Object):void {
//your code here
};
myArray.filter(myFunction, me);
Parametri
callback:Function — La funzione da eseguire su ciascun elemento nell'array. Questa funzione può contenere un semplice confronto (ad esempio, item < 20) oppure un'operazione più complessa, e viene richiamata con tre argomenti: il valore di un elemento, l'indice di un elemento e l'oggetto Array:
function callback(item:*, index:int, array:Array):Boolean; | |
thisObject:* (default = null)this per la funzione.
|
Array — Un nuovo array che contiene tutti gli elementi dell'array originale che hanno restituito true.
|
Elementi API correlati
Esempio ( Come utilizzare questo esempio )
package {
import flash.display.Sprite;
public class Array_filter extends Sprite {
public function Array_filter() {
var employees:Array = new Array();
employees.push({name:"Employee 1", manager:false});
employees.push({name:"Employee 2", manager:true});
employees.push({name:"Employee 3", manager:false});
trace("Employees:");
employees.forEach(traceEmployee);
var managers:Array = employees.filter(isManager);
trace("Managers:");
managers.forEach(traceEmployee);
}
private function isManager(element:*, index:int, arr:Array):Boolean {
return (element.manager == true);
}
private function traceEmployee(element:*, index:int, arr:Array):void {
trace("\t" + element.name + ((element.manager) ? " (manager)" : ""));
}
}
}
forEach | () | metodo |
AS3 function forEach(callback:Function, thisObject:* = null):void| Versione linguaggio: | ActionScript 3.0 |
| Versioni runtime: | AIR 1.0, Flash Player 9, Flash Lite 4 |
Esegue una funzione su ciascun elemento nell'array.
Per questo metodo, il secondo parametro thisObject deve essere null se il primo parametro callback è la chiusura di un metodo. Supponete di creare una funzione in un clip filmato di nome me:
function myFunction(obj:Object):void {
//your code here
}
Quindi, supponete di utilizzare il metodo forEach() su un array di nome myArray:
myArray.forEach(myFunction, me);
Dal momento che myFunction è un membro della classe Timeline, che non può essere ignorata da me, il runtime Flash genera un'eccezione. Questo errore di runtime può essere evitato assegnando la funzione a una variabile, come illustrato di seguito:
var myFunction:Function = function(obj:Object):void {
//your code here
};
myArray.forEach(myFunction, me);
Parametri
callback:Function — La funzione da eseguire su ciascun elemento nell'array. Questa funzione può contenere un semplice comando (ad esempio, un'istruzione trace()) oppure un'operazione più complessa e viene richiamata con tre argomenti; il valore di un elemento, l'indice di un elemento e l'oggetto Array:
function callback(item:*, index:int, array:Array):void; | |
thisObject:* (default = null)this per la funzione.
|
Esempio ( Come utilizzare questo esempio )
trace() nella funzione traceEmployee() su ogni elemento dell'array:
package {
import flash.display.Sprite;
public class Array_forEach extends Sprite {
public function Array_forEach() {
var employees:Array = new Array();
employees.push({name:"Employee 1", manager:false});
employees.push({name:"Employee 2", manager:true});
employees.push({name:"Employee 3", manager:false});
trace(employees);
employees.forEach(traceEmployee);
}
private function traceEmployee(element:*, index:int, arr:Array):void {
trace(element.name + " (" + element.manager + ")");
}
}
}
trace() in una funzione traceEmployee() leggermente modificata su ogni elemento dell'array:
package {
import flash.display.Sprite;
public class Array_forEach_2 extends Sprite {
public function Array_forEach_2() {
var employeeXML:XML = <employees>
<employee name="Steven" manager="false" />
<employee name="Bruce" manager="true" />
<employee name="Rob" manager="false" />
</employees>;
var employeesList:XMLList = employeeXML.employee;
var employeesArray:Array = new Array();
for each (var tempXML:XML in employeesList) {
employeesArray.push(tempXML);
}
employeesArray.sortOn("@name");
employeesArray.forEach(traceEmployee);
}
private function traceEmployee(element:*, index:Number, arr:Array):void {
trace(element.@name + ((element.@manager == "true") ? " (manager)" : ""));
}
}
}
indexOf | () | metodo |
AS3 function indexOf(searchElement:*, fromIndex:int = 0):int| Versione linguaggio: | ActionScript 3.0 |
| Versioni runtime: | AIR 1.0, Flash Player 9, Flash Lite 4 |
Cerca un elemento in un array utilizzando l'operatore di uguaglianza rigorosa (===) e restituisce la posizione di indice dell'elemento.
Parametri
searchElement:* — L'elemento da trovare nell'array.
| |
fromIndex:int (default = 0) |
int — Una posizione di indice a base zero dell'elemento nell'array. Se l'argomento searchElement non viene trovato, il valore restituito è -1.
|
Elementi API correlati
Esempio ( Come utilizzare questo esempio )
package {
import flash.display.Sprite;
public class Array_indexOf extends Sprite {
public function Array_indexOf() {
var arr:Array = new Array(123,45,6789);
arr.push("123-45-6789");
arr.push("987-65-4321");
var index:int = arr.indexOf("123");
trace(index); // -1
var index2:int = arr.indexOf(123);
trace(index2); // 0
}
}
}
insertAt | () | metodo |
AS3 function insertAt(index:int, element:*):void| Versione linguaggio: | ActionScript 3.0 |
| Versioni runtime: | Flash Player 19, AIR 19 |
Inserite un singolo elemento in un array. Questo metodo modifica l'array senza crearne una copia.
Parametri
index:int — Un numero intero che specifica la posizione nell’array in cui l'elemento deve essere inserito. Potete utilizzare un numero intero negativo per specificare una posizione relativa alla fine dell'array (ad esempio, -1 è l'ultimo elemento dell'array).
| |
element:* |
join | () | metodo |
AS3 function join(sep:*):String| Versione linguaggio: | ActionScript 3.0 |
| Versioni runtime: | AIR 1.0, Flash Player 9, Flash Lite 4 |
Converte in stringhe gli elementi di un array, inserisce il separatore specificato tra gli elementi, li concatena e restituisce la stringa risultante. Un array nidificato è sempre separato da un virgola (,) e non dal separatore passato dal metodo join().
Parametri
sep:* (default = NaN) |
String — Una stringa costituita dagli elementi di un array convertiti in stringhe e separati dal parametro specificato.
|
Altri esempi
Elementi API correlati
Esempio ( Come utilizzare questo esempio )
myArr con gli elementi one, two e three e quindi una stringa contenente one and two and three mediante il metodo join().
var myArr:Array = new Array("one", "two", "three");
var myStr:String = myArr.join(" and ");
trace(myArr); // one,two,three
trace(myStr); // one and two and three
specialChars con gli elementi (,), - e uno spazio vuoto e quindi crea una stringa contenente (888) 867-5309. Quindi, mediante un ciclo for, rimuove ogni tipo di carattere speciale elencato in specialChars per produrre una stringa (myStr) contenente solo le cifre rimanenti del numero di telefono: 888675309. Aggiungendo altri caratteri, ad esempio +, a specialChars, la routine può essere utilizzata per i formati di numeri di telefono internazionali.
var phoneString:String = "(888) 867-5309";
var specialChars:Array = new Array("(", ")", "-", " ");
var myStr:String = phoneString;
var ln:uint = specialChars.length;
for(var i:uint; i < ln; i++) {
myStr = myStr.split(specialChars[i]).join("");
}
var phoneNumber:Number = new Number(myStr);
trace(phoneString); // (888) 867-5309
trace(phoneNumber); // 8888675309
lastIndexOf | () | metodo |
AS3 function lastIndexOf(searchElement:*, fromIndex:int = 0x7fffffff):int| Versione linguaggio: | ActionScript 3.0 |
| Versioni runtime: | AIR 1.0, Flash Player 9, Flash Lite 4 |
Cerca un elemento in un array a ritroso partendo dall'ultimo elemento e restituisce la posizione di indice dell'elemento corrispondente mediante l'operatore di uguaglianza rigorosa (===).
Parametri
searchElement:* — L'elemento da trovare nell'array.
| |
fromIndex:int (default = 0x7fffffff)fromIndex, la ricerca comincia dall'ultimo elemento nell'array.
|
int — Una posizione di indice a base zero dell'elemento nell'array. Se l'argomento searchElement non viene trovato, il valore restituito è -1.
|
Elementi API correlati
Esempio ( Come utilizzare questo esempio )
package {
import flash.display.Sprite;
public class Array_lastIndexOf extends Sprite {
public function Array_lastIndexOf() {
var arr:Array = new Array(123,45,6789,123,984,323,123,32);
var index:int = arr.indexOf(123);
trace(index); // 0
var index2:int = arr.lastIndexOf(123);
trace(index2); // 6
}
}
}
map | () | metodo |
AS3 function map(callback:Function, thisObject:* = null):Array| Versione linguaggio: | ActionScript 3.0 |
| Versioni runtime: | AIR 1.0, Flash Player 9, Flash Lite 4 |
Esegue una funzione su ciascun elemento in un array e crea un nuovo array di elementi corrispondenti ai risultati della funzione eseguita su ciascun elemento dell'array originale.
Per questo metodo, il secondo parametro thisObject deve essere null se il primo parametro callback è la chiusura di un metodo. Supponete di creare una funzione in un clip filmato di nome me:
function myFunction(obj:Object):void {
//your code here
}
Quindi, supponete di utilizzare il metodo map() su un array di nome myArray:
myArray.map(myFunction, me);
Dal momento che myFunction è un membro della classe Timeline, che non può essere ignorata da me, il runtime Flash genera un'eccezione. Questo errore di runtime può essere evitato assegnando la funzione a una variabile, come illustrato di seguito:
var myFunction:Function = function(obj:Object):void {
//your code here
};
myArray.map(myFunction, me);
Parametri
callback:Function — La funzione da eseguire su ciascun elemento nell'array. Questa funzione può contenere un semplice comando (ad esempio, la modifica da maiuscole a minuscole e viceversa di un array di stringhe) oppure un'operazione più complessa e viene richiamata con tre argomenti; il valore di un elemento, l'indice di un elemento e l'oggetto Array:
function callback(item:*, index:int, array:Array):String; | |
thisObject:* (default = null)this per la funzione.
|
Array — Un nuovo array che contiene i risultati della funzione eseguita su ciascun elemento nell'array originale.
|
Elementi API correlati
Esempio ( Come utilizzare questo esempio )
package {
import flash.display.Sprite;
public class Array_map extends Sprite {
public function Array_map() {
var arr:Array = new Array("one", "two", "Three");
trace(arr); // one,two,Three
var upperArr:Array = arr.map(toUpper);
trace(upperArr); // ONE,TWO,THREE
}
private function toUpper(element:*, index:int, arr:Array):String {
return String(element).toUpperCase();
}
}
}
pop | () | metodo |
AS3 function pop():*| Versione linguaggio: | ActionScript 3.0 |
| Versioni runtime: | AIR 1.0, Flash Player 9, Flash Lite 4 |
Rimuove l'ultimo elemento di un array e ne restituisce il valore.
Restituisce* — Il valore dell'ultimo elemento (di qualunque tipo di dati) dell'array specificato.
|
Altri esempi
Elementi API correlati
Esempio ( Come utilizzare questo esempio )
letters con gli elementi a, b e c. L'ultimo elemento (c) viene rimosso dall'array mediante il metodo pop() e viene assegnato all'oggetto String letter.
var letters:Array = new Array("a", "b", "c");
trace(letters); // a,b,c
var letter:String = letters.pop();
trace(letters); // a,b
trace(letter); // c
push | () | metodo |
AS3 function push(... args):uint| Versione linguaggio: | ActionScript 3.0 |
| Versioni runtime: | AIR 1.0, Flash Player 9, Flash Lite 4 |
Aggiunge uno o più elementi alla fine di un array e restituisce la nuova lunghezza dell'array.
Parametri
... args — Uno o più valori da aggiungere all'array.
|
uint — Un numero intero che rappresenta la lunghezza del nuovo array.
|
Altri esempi
Elementi API correlati
Esempio ( Come utilizzare questo esempio )
letters e quindi inserisce nell'array gli elementi a, b e c mediante il metodo push().
var letters:Array = new Array();
letters.push("a");
letters.push("b");
letters.push("c");
trace(letters.toString()); // a,b,c
letters, nel quale viene inserito inizialmente l'elemento a. Il metodo push() viene quindi utilizzato per aggiungere gli elementi b e c alla fine dell'array, ovvero tre elementi dopo il push.
var letters:Array = new Array("a");
var count:uint = letters.push("b", "c");
trace(letters); // a,b,c
trace(count); // 3
removeAt | () | metodo |
AS3 function removeAt(index:int):*| Versione linguaggio: | ActionScript 3.0 |
| Versioni runtime: | Flash Player 19, AIR 19 |
Rimuovete un singolo elemento da un array. Questo metodo modifica l'array senza crearne una copia.
Parametri
index:int — Un numero intero che specifica l’indice dell’elemento dell’array che deve essere eliminato. Potete utilizzare un numero intero negativo per specificare una posizione relativa alla fine dell'array (ad esempio, -1 è l'ultimo elemento dell'array).
|
* — L’elemento che è stato rimosso dall’array originale.
|
reverse | () | metodo |
AS3 function reverse():Array| Versione linguaggio: | ActionScript 3.0 |
| Versioni runtime: | AIR 1.0, Flash Player 9, Flash Lite 4 |
Inverte l'array in posizione.
RestituisceArray — Il nuovo array.
|
Altri esempi
Esempio ( Come utilizzare questo esempio )
letters con gli elementi a, b e c. L'ordine degli elementi dell'array viene quindi invertito mediante il metodo reverse() per generare l'array [c,b,a].
var letters:Array = new Array("a", "b", "c");
trace(letters); // a,b,c
letters.reverse();
trace(letters); // c,b,a
shift | () | metodo |
AS3 function shift():*| Versione linguaggio: | ActionScript 3.0 |
| Versioni runtime: | AIR 1.0, Flash Player 9, Flash Lite 4 |
Rimuove il primo elemento di un array e lo restituisce. Gli elementi rimanenti dell'array vengono spostati dalla posizione originale i a i-1.
Restituisce* — Il primo elemento (di qualunque tipo di dati) in un array.
|
Altri esempi
Elementi API correlati
Esempio ( Come utilizzare questo esempio )
letters con gli elementi a, b e c. Il metodo shift() viene quindi utilizzato per rimuovere il primo elemento (a) da letters e assegnarlo alla stringa firstLetter.
var letters:Array = new Array("a", "b", "c");
var firstLetter:String = letters.shift();
trace(letters); // b,c
trace(firstLetter); // a
slice | () | metodo |
AS3 function slice(startIndex:int = 0, endIndex:int = 16777215):Array| Versione linguaggio: | ActionScript 3.0 |
| Versioni runtime: | AIR 1.0, Flash Player 9, Flash Lite 4 |
Restituisce un nuovo array composto da un intervallo di elementi dell'array originale, senza modificare quest'ultimo. L'array restituito comprende l'elemento startIndex e tutti gli elementi fino a endIndex escluso.
Se non passate alcun parametro, il nuovo array è un duplicato (shallow clone) dell'array originale.
Parametri
startIndex:int (default = 0)startIndex è un numero negativo, il punto iniziale comincia alla fine dell'array, dove -1 è l'ultimo elemento.
| |
endIndex:int (default = 16777215)endIndex è un numero negativo, il punto finale viene specificato dalla fine dell'array, dove -1 è l'ultimo elemento.
|
Array — Un array composto da un intervallo di elementi dell'array originale.
|
Altri esempi
Esempio ( Come utilizzare questo esempio )
letters con gli elementi [a,b,c,d,e,f]. L'array someLetters viene quindi creato mediante una chiamata al metodo slice() sugli elementi dal primo (b) al terzo (d), dando come risultato un array con gli elementi b e c.
var letters:Array = new Array("a", "b", "c", "d", "e", "f");
var someLetters:Array = letters.slice(1,3);
trace(letters); // a,b,c,d,e,f
trace(someLetters); // b,c
letters con gli elementi [a,b,c,d,e,f]. L'array someLetters viene quindi creato mediante una chiamata al metodo slice() sul secondo elemento (c), dando come risultato un array con gli elementi [c,d,e,f].
var letters:Array = new Array("a", "b", "c", "d", "e", "f");
var someLetters:Array = letters.slice(2);
trace(letters); // a,b,c,d,e,f
trace(someLetters); // c,d,e,f
letters con gli elementi [a,b,c,d,e,f]. L'array someLetters viene quindi creato mediante una chiamata al metodo slice() sugli elementi dal secondo all'ultimo partendo dalla fine (e), dando come risultato un array con gli elementi e ed f.
var letters:Array = new Array("a", "b", "c", "d", "e", "f");
var someLetters:Array = letters.slice(-2);
trace(letters); // a,b,c,d,e,f
trace(someLetters); // e,f
some | () | metodo |
AS3 function some(callback:Function, thisObject:* = null):Boolean| Versione linguaggio: | ActionScript 3.0 |
| Versioni runtime: | AIR 1.0, Flash Player 9, Flash Lite 4 |
Esegue una funzione di prova su ciascun elemento nell'array fino a quando non viene raggiunto un elemento che restituisce true. Potete utilizzare questo metodo per determinare se tutti gli elementi di un array soddisfano un criterio, ad esempio se contengono valori inferiori a un determinato numero.
Per questo metodo, il secondo parametro thisObject deve essere null se il primo parametro callback è la chiusura di un metodo. Supponete di creare una funzione in un clip filmato di nome me:
function myFunction(obj:Object):void {
//your code here
}
Quindi, supponete di utilizzare il metodo some() su un array di nome myArray:
myArray.some(myFunction, me);
Dal momento che myFunction è un membro della classe Timeline, che non può essere ignorata da me, il runtime Flash genera un'eccezione. Questo errore di runtime può essere evitato assegnando la funzione a una variabile, come illustrato di seguito:
var myFunction:Function = function(obj:Object):void {
//your code here
};
myArray.some(myFunction, me);
Parametri
callback:Function — La funzione da eseguire su ciascun elemento nell'array. Questa funzione può contenere un semplice confronto (ad esempio, item < 20) oppure un'operazione più complessa, e viene richiamata con tre argomenti: il valore di un elemento, l'indice di un elemento e l'oggetto Array:
function callback(item:*, index:int, array:Array):Boolean; | |
thisObject:* (default = null)this per la funzione.
|
Boolean — Un valore booleano true se uno qualunque degli elementi nell'array restituisce true per la funzione specificata; in caso contrario, false.
|
Elementi API correlati
Esempio ( Come utilizzare questo esempio )
package {
import flash.display.Sprite;
public class Array_some extends Sprite {
public function Array_some() {
var arr:Array = new Array();
arr[0] = "one";
arr[1] = "two";
arr[3] = "four";
var isUndef:Boolean = arr.some(isUndefined);
if (isUndef) {
trace("array contains undefined values: " + arr);
} else {
trace("array contains no undefined values.");
}
}
private function isUndefined(element:*, index:int, arr:Array):Boolean {
return (element == undefined);
}
}
}
sort | () | metodo |
AS3 function sort(... args):Array| Versione linguaggio: | ActionScript 3.0 |
| Versioni runtime: | AIR 1.0, Flash Player 9, Flash Lite 4 |
Ordina gli elementi di un array. Il metodo effettua l'ordinamento in base ai valori Unicode. (ASCII è un sottogruppo di Unicode.)
Per impostazione predefinita, Array.sort() funziona come segue:
- L'ordinamento fa distinzione tra maiuscole e minuscole (quindi, ad esempio Z precede a).
- L'ordinamento è ascendente (quindi, ad esempio a precede b).
- L'array viene modificato in modo che rispecchi l'ordinamento; gli eventuali elementi multipli che hanno campi di ordinamento identici vengono posizionati in modo consecutivo senza un ordine particolare.
- Tutti gli elementi, a prescindere dal tipo di dati, vengono ordinati come se fossero stringhe, quindi 100 precede 99, perché "1" è un valore di stringa inferiore a "9".
Per ordinare un array mediante delle impostazioni diverse da quelle predefinite, potete utilizzare una delle opzioni di ordinamento descritte nella sezione relativa alla porzione sortOptions del parametro ...args oppure creare una funzione personalizzata che effettui l'ordinamento. Se create una funzione personalizzata, potete chiamare il metodo sort() e utilizzare il nome della funzione personalizzata come primo argomento (compareFunction).
Parametri
... args — Gli argomenti che specificano una funzione di confronto e uno o più valori che determinano il comportamento dell'ordinamento.
Questo metodo utilizza la sintassi e l'ordine degli argomenti
|
Array — Il valore restituito dipende dal fatto che siano stati o meno passati degli argomenti, come descritto nell'elenco seguente:
|
Altri esempi
Elementi API correlati
Esempio ( Come utilizzare questo esempio )
vegetables con gli elementi [spinach, green pepper, cilantro, onion, avocado]. L'array viene quindi ordinato dal metodo sort() che viene chiamato senza parametri. Il risultato è vegetables in ordine alfabetico ([avocado, cilantro, green pepper, onion, spinach]).
var vegetables:Array = new Array("spinach",
"green pepper",
"cilantro",
"onion",
"avocado");
trace(vegetables); // spinach,green pepper,cilantro,onion,avocado
vegetables.sort();
trace(vegetables); // avocado,cilantro,green pepper,onion,spinach
vegetables con gli elementi [spinach, green pepper, Cilantro, Onion, and Avocado]. L'array viene quindi ordinato dal metodo sort() che viene chiamato senza parametri la prima volta; il risultato è [Avocado,Cilantro,Onion,green pepper,spinach]. Quindi, il metodo sort() viene chiamato di nuovo su vegetables con la costante CASEINSENSITIVE come parametro. Il risultato è vegetables in ordine alfabetico ([Avocado, Cilantro, green pepper, Onion, spinach]).
var vegetables:Array = new Array("spinach",
"green pepper",
"Cilantro",
"Onion",
"Avocado");
vegetables.sort();
trace(vegetables); // Avocado,Cilantro,Onion,green pepper,spinach
vegetables.sort(Array.CASEINSENSITIVE);
trace(vegetables); // Avocado,Cilantro,green pepper,Onion,spinach
vegetables, che viene successivamente compilato mediante cinque chiamate a push(). Ogni volta che viene chiamato il metodo push(), viene creato un nuovo oggetto Vegetable mediante una chiamata alla funzione di costruzione Vegetable() che accetta un oggetto String (name) e Number (price). Se chiamate push() cinque volte con i valori mostrati, ottenete l'array [lettuce:1.49, spinach:1.89, asparagus:3.99, celery:1.29, squash:1.44]. Il metodo sort() viene quindi utilizzato per ordinare l'array, e si ottiene l'array [asparagus:3.99, celery:1.29, lettuce:1.49, spinach:1.89, squash:1.44].
var vegetables:Array = new Array();
vegetables.push(new Vegetable("lettuce", 1.49));
vegetables.push(new Vegetable("spinach", 1.89));
vegetables.push(new Vegetable("asparagus", 3.99));
vegetables.push(new Vegetable("celery", 1.29));
vegetables.push(new Vegetable("squash", 1.44));
trace(vegetables);
// lettuce:1.49, spinach:1.89, asparagus:3.99, celery:1.29, squash:1.44
vegetables.sort();
trace(vegetables);
// asparagus:3.99, celery:1.29, lettuce:1.49, spinach:1.89, squash:1.44
//The following code defines the Vegetable class
class Vegetable {
private var name:String;
private var price:Number;
public function Vegetable(name:String, price:Number) {
this.name = name;
this.price = price;
}
public function toString():String {
return " " + name + ":" + price;
}
}
sort() viene utilizzato con una funzione di ordinamento personalizzata (sortOnPrice), che effettua l'ordinamento in base al prezzo e non all'ordine alfabetico. Notate che la nuova funzione getPrice() estrae il prezzo.
var vegetables:Array = new Array();
vegetables.push(new Vegetable("lettuce", 1.49));
vegetables.push(new Vegetable("spinach", 1.89));
vegetables.push(new Vegetable("asparagus", 3.99));
vegetables.push(new Vegetable("celery", 1.29));
vegetables.push(new Vegetable("squash", 1.44));
trace(vegetables);
// lettuce:1.49, spinach:1.89, asparagus:3.99, celery:1.29, squash:1.44
vegetables.sort(sortOnPrice);
trace(vegetables);
// celery:1.29, squash:1.44, lettuce:1.49, spinach:1.89, asparagus:3.99
function sortOnPrice(a:Vegetable, b:Vegetable):Number {
var aPrice:Number = a.getPrice();
var bPrice:Number = b.getPrice();
if(aPrice > bPrice) {
return 1;
} else if(aPrice < bPrice) {
return -1;
} else {
//aPrice == bPrice
return 0;
}
}
// The following code defines the Vegetable class and should be in a separate package.
class Vegetable {
private var name:String;
private var price:Number;
public function Vegetable(name:String, price:Number) {
this.name = name;
this.price = price;
}
public function getPrice():Number {
return price;
}
public function toString():String {
return " " + name + ":" + price;
}
}
numbers con gli elementi [3,5,100,34,10]. Una chiamata a sort() senza alcun parametro ordina alfabeticamente e produce il risultato indesiderato [10,100,3,34,5]. Per ordinare correttamente i valori numerici, è necessario passare la costante NUMERIC al metodo sort(), che ordina numbers nel modo seguente: [3,5,10,34,100].
Nota: il comportamento predefinito della funzione sort() è quello di gestire ogni entità come se fosse una stringa. Se utilizzate l'argomento Array.NUMERIC, il runtime Flash tenta di convertire tutti i valori non numerici in numeri interi ai fini dell'ordinamento. Se l'operazione non riesce, il runtime genera un errore. Il runtime può, ad esempio, convertire correttamente un valore String "6" in un numero intero, ma se viene rilevato un valore String "sei", genera un errore.
var numbers:Array = new Array(3,5,100,34,10); trace(numbers); // 3,5,100,34,10 numbers.sort(); trace(numbers); // 10,100,3,34,5 numbers.sort(Array.NUMERIC); trace(numbers); // 3,5,10,34,100
sortOn | () | metodo |
AS3 function sortOn(fieldName:Object, options:Object = null):Array| Versione linguaggio: | ActionScript 3.0 |
| Versioni runtime: | AIR 1.0, Flash Player 9, Flash Lite 4 |
Ordina gli elementi di un array in base a uno o più campi dell'array. L'array dovrebbe avere le proprietà caratteristiche:
- l'array è di tipo indicizzato, non associativo;
- ogni elemento dell'array contiene un oggetto con una o più proprietà;
- Tutti gli oggetti hanno almeno una proprietà in comune, i cui valori possono essere utilizzati per ordinare l'array. La proprietà viene denominata campo.
Se passate più parametri fieldName, il primo campo rappresenta il campo di ordinamento principale, il secondo rappresenta il campo di ordinamento successivo e così via. L'ordinamento viene effettuato in base ai valori Unicode (ASCII è un sottogruppo di Unicode.) Se qualcuno degli elementi che si stanno confrontando non contiene il campo specificato nel parametro fieldName, il campo viene considerato impostato su undefined e gli elementi vengono collocati consecutivamente senza un ordine particolare all'interno dell'array ordinato.
Per impostazione predefinita, Array.sortOn() funziona come segue:
- L'ordinamento fa distinzione tra maiuscole e minuscole (quindi, ad esempio Z precede a).
- L'ordinamento è ascendente (quindi, ad esempio a precede b).
- L'array viene modificato in modo che rispecchi l'ordinamento; gli eventuali elementi multipli che hanno campi di ordinamento identici vengono posizionati in modo consecutivo senza un ordine particolare.
- I campi numerici vengono ordinati come se fossero stringhe, pertanto 100 precede 99 poiché "1" è un valore di stringa inferiore a "9".
In Flash Player 7 è stato aggiunto il parametro options, utilizzabile per ignorare il comportamento predefinito per l'ordinamento. Per ordinare un array semplice (ad esempio, un array con un solo campo) o per specificare un ordinamento non supportato dal parametro options, utilizzate Array.sort().
Per passare più flag, separateli con l'operatore OR bit a bit (|):
my_array.sortOn(someFieldName, Array.DESCENDING | Array.NUMERIC);
In Flash Player 8 è stata aggiunta la capacità supplementare di specificare un'opzione di ordinamento diversa per ciascun campo quando si ordinano più campi. In Flash Player 8 e versioni successive, il parametro options accetta un array di opzioni di ordinamento tale per cui ogni opzione corrisponde a un campo di ordinamento nel parametro fieldName. L'esempio seguente ordina il campo di ordinamento principale a mediante un ordinamento discendente, il campo di ordinamento secondario b mediante un ordinamento numerico, il campo di ordinamento terziario c mediante un ordinamento senza distinzione tra maiuscole e minuscole:
Array.sortOn (["a", "b", "c"], [Array.DESCENDING, Array.NUMERIC, Array.CASEINSENSITIVE]);
Nota: gli array fieldName e options devono avere lo stesso numero di elementi, altrimenti l'array options viene ignorato. Inoltre, le opzioni Array.UNIQUESORT e Array.RETURNINDEXEDARRAY possono essere utilizzate solo come primo elemento dell'array, altrimenti vengono ignorate.
Parametri
fieldName:Object — Una stringa che identifica un campo da utilizzare come valore di ordinamento, oppure un array in cui il primo elemento rappresenta il campo di ordinamento principale, il secondo rappresenta il campo di ordinamento secondario, e così via.
| |
options:Object (default = null)bitwise OR (|) (OR bit a bit), che modificano il comportamento dell'ordinamento. I valori seguenti sono accettabili per il parametro options:
I suggerimenti sul codice sono abilitati se si utilizza il flag sotto forma di stringa (ad esempio, |
Array — Il valore restituito dipende dal fatto che siano stati o meno passati dei parametri:
|
Altri esempi
Elementi API correlati
Esempio ( Come utilizzare questo esempio )
vegetables, che viene successivamente compilato mediante cinque chiamate a push(). A ogni chiamata del metodo push(), viene creato un nuovo oggetto Vegetable mediante una chiamata alla funzione di costruzione Vegetable(), che accetta un oggetto String (name) e Number (price). Se chiamate push() cinque volte con i valori mostrati, ottenete l'array [lettuce:1.49, spinach:1.89, asparagus:3.99, celery:1.29, squash:1.44]. Il metodo sortOn() viene quindi utilizzato con il parametro name per generare il seguente array: [asparagus:3.99, celery:1.29, lettuce:1.49, spinach:1.89, squash:1.44]. Il metodo sortOn() viene chiamato di nuovo con il parametro price e le costanti NUMERIC e DESCENDING per generare un array con ordine numerico decrescente: [asparagus:3.99, spinach:1.89, lettuce:1.49, squash:1.44, celery:1.29].
var vegetables:Array = new Array();
vegetables.push(new Vegetable("lettuce", 1.49));
vegetables.push(new Vegetable("spinach", 1.89));
vegetables.push(new Vegetable("asparagus", 3.99));
vegetables.push(new Vegetable("celery", 1.29));
vegetables.push(new Vegetable("squash", 1.44));
trace(vegetables);
// lettuce:1.49, spinach:1.89, asparagus:3.99, celery:1.29, squash:1.44
vegetables.sortOn("name");
trace(vegetables);
// asparagus:3.99, celery:1.29, lettuce:1.49, spinach:1.89, squash:1.44
vegetables.sortOn("price", Array.NUMERIC | Array.DESCENDING);
trace(vegetables);
// asparagus:3.99, spinach:1.89, lettuce:1.49, squash:1.44, celery:1.29
class Vegetable {
public var name:String;
public var price:Number;
public function Vegetable(name:String, price:Number) {
this.name = name;
this.price = price;
}
public function toString():String {
return " " + name + ":" + price;
}
}
records, che viene successivamente compilato mediante tre chiamate a push(). A ogni chiamata del metodo push(), le stringhe name e city e un numero zip vengono aggiunti a records. Tre cicli for vengono utilizzati per stampare gli elementi dell'array. Il primo ciclo for stampa gli elementi seguendo l'ordine con cui sono stati aggiunti. Il secondo ciclo for viene eseguito dopo che è stato effettuato l'ordinamento di records in base al nome e alla città mediante il metodo sortOn(). Il terzo ciclo for produce un output diverso perché viene nuovamente effettuato l'ordinamento di records in base alla città e successivamente al nome.
var records:Array = new Array();
records.push({name:"john", city:"omaha", zip:68144});
records.push({name:"john", city:"kansas city", zip:72345});
records.push({name:"bob", city:"omaha", zip:94010});
for(var i:uint = 0; i < records.length; i++) {
trace(records[i].name + ", " + records[i].city);
}
// Results:
// john, omaha
// john, kansas city
// bob, omaha
trace("records.sortOn('name', 'city');");
records.sortOn(["name", "city"]);
for(var i:uint = 0; i < records.length; i++) {
trace(records[i].name + ", " + records[i].city);
}
// Results:
// bob, omaha
// john, kansas city
// john, omaha
trace("records.sortOn('city', 'name');");
records.sortOn(["city", "name"]);
for(var i:uint = 0; i < records.length; i++) {
trace(records[i].name + ", " + records[i].city);
}
// Results:
// john, kansas city
// bob, omaha
// john, omaha
users, che viene successivamente compilato mediante quattro chiamate a push(). A ogni chiamata del metodo push(), viene creato un oggetto User con la funzione di costruzione User() e una stringa name e un uint age vengono aggiunti agli utenti. L'insieme di array risultante è [Bob:3,barb:35,abcd:3,catchy:4].
L'array viene quindi ordinato nei seguenti modi:
- Solo in base al nome, restituendo l'array
[Bob:3,abcd:3,barb:35,catchy:4] - In base al nome e mediante la costante
CASEINSENSITIVE, restituendo l'array[abcd:3,barb:35,Bob:3,catchy:4] - In base al nome e mediante le costanti
CASEINSENSITIVEeDESCENDING, restituendo l'array[catchy:4,Bob:3,barb:35,abcd:3] - Solo in base all'età, restituendo l'array
[abcd:3,Bob:3,barb:35,catchy:4] - In base all'età e mediante la costante
NUMERIC, restituendo l'array[Bob:3,abcd:3,catchy:4,barb:35] - In base all'età e mediante le costanti
DESCENDINGeNUMERIC, restituendo l'array[barb:35,catchy:4,Bob:3,abcd:3]
Viene quindi creato un array denominato indices, al quale vengono assegnati i risultati dell'ordinamento in base all'età e le costanti NUMERIC e RETURNINDEXEDARRAY, restituendo l'array [Bob:3,abcd:3,catchy:4,barb:35], che viene quindi stampato mediante un ciclo for.
class User {
public var name:String;
public var age:Number;
public function User(name:String, age:uint) {
this.name = name;
this.age = age;
}
public function toString():String {
return this.name + ":" + this.age;
}
}
var users:Array = new Array();
users.push(new User("Bob", 3));
users.push(new User("barb", 35));
users.push(new User("abcd", 3));
users.push(new User("catchy", 4));
trace(users); // Bob:3,barb:35,abcd:3,catchy:4
users.sortOn("name");
trace(users); // Bob:3,abcd:3,barb:35,catchy:4
users.sortOn("name", Array.CASEINSENSITIVE);
trace(users); // abcd:3,barb:35,Bob:3,catchy:4
users.sortOn("name", Array.CASEINSENSITIVE | Array.DESCENDING);
trace(users); // catchy:4,Bob:3,barb:35,abcd:3
users.sortOn("age");
trace(users); // abcd:3,Bob:3,barb:35,catchy:4
users.sortOn("age", Array.NUMERIC);
trace(users); // Bob:3,abcd:3,catchy:4,barb:35
users.sortOn("age", Array.DESCENDING | Array.NUMERIC);
trace(users); // barb:35,catchy:4,Bob:3,abcd:3
var indices:Array = users.sortOn("age", Array.NUMERIC | Array.RETURNINDEXEDARRAY);
var index:uint;
for(var i:uint = 0; i < indices.length; i++) {
index = indices[i];
trace(users[index].name, ": " + users[index].age);
}
// Results:
// Bob : 3
// abcd : 3
// catchy : 4
// barb : 35
splice | () | metodo |
AS3 function splice(startIndex:int, deleteCount:uint, ... values):Array| Versione linguaggio: | ActionScript 3.0 |
| Versioni runtime: | AIR 1.0, Flash Player 9, Flash Lite 4 |
Aggiunge e rimuove gli elementi di un array. Questo metodo modifica l'array senza crearne una copia.
Nota: per ignorare questo metodo in una sottoclasse di Array, utilizzate ...args per i parametri, come illustra l'esempio seguente:
public override function splice(...args) {
// your statements here
}
Parametri
startIndex:int — Un numero intero che specifica l'indice dell'elemento dell'array in cui inizia l'inserimento o l'eliminazione. Potete utilizzare un numero intero negativo per specificare una posizione relativa alla fine dell'array (ad esempio, -1 è l'ultimo elemento dell'array).
| |
deleteCount:uint — Un numero intero che specifica il numero di elementi da eliminare. Questo numero include l'elemento specificato nel parametro startIndex. Se non specificate alcun valore per il parametro deleteCount, il metodo elimina tutti i valori dall'elemento startIndex fino all'ultimo elemento dell'array. Se il valore è 0, non viene eliminato alcun elemento.
| |
... values — Un elenco opzionale di uno o più valori separati da virgole da inserire nell'array nella posizione specificata nel parametro startIndex. Se un valore inserito è di tipo Array, l'array viene mantenuto invariato e inserito come elemento singolo. Se, ad esempio, unite un array esistente con una lunghezza pari a tre con un altro array con una lunghezza pari a tre, l'array risultante avrà solo quattro elementi. Uno degli elementi sarà tuttavia un array con una lunghezza pari a tre.
|
Array — Un array che contiene gli elementi che sono stati rimossi dall'array originale.
|
Altri esempi
Esempio ( Come utilizzare questo esempio )
vegetables con gli elementi [spinach, green pepper, cilantro, onion, avocado]. Il metodo splice() viene quindi chiamato con i parametri 2 e 2 che assegnano cilantro e onion all'array spliced. L'array vegetables contiene quindi [spinach,green pepper,avocado]. Il metodo splice() viene quindi chiamato una seconda volta con i parametri 1, 0 e l'array spliced per assegnare [cilantro,onion] come secondo elemento di vegetables.
var vegetables:Array = new Array("spinach",
"green pepper",
"cilantro",
"onion",
"avocado");
var spliced:Array = vegetables.splice(2, 2);
trace(vegetables); // spinach,green pepper,avocado
trace(spliced); // cilantro,onion
vegetables.splice(1, 0, spliced);
trace(vegetables); // spinach,cilantro,onion,green pepper,avocado
cilantro e onion vengono rilevati come se vegetables avesse 5 elementi, anche se in realtà ne ha quattro (e il secondo elemento è un altro array contenente due elementi). Per aggiungere cilantro e onion singolarmente, utilizzate:
var vegetables:Array = new Array("spinach",
"green pepper",
"cilantro",
"onion",
"avocado");
var spliced:Array = vegetables.splice(2, 2);
trace(vegetables); // spinach,green pepper,avocado
trace(spliced); // cilantro,onion
vegetables.splice(1, 0, "cilantro", "onion");
trace(vegetables); // spinach,cilantro,onion,green pepper,avocado
toLocaleString | () | metodo |
public function toLocaleString():String| Versione linguaggio: | ActionScript 3.0 |
| Versioni runtime: | AIR 1.0, Flash Player 9, Flash Lite 4 |
Restituisce una stringa che rappresenta gli elementi dell'array specificato. Ogni elemento dell'array, a partire dall'elemento con l'indice 0 e fino all'elemento con l'indice dal numero più alto, viene convertito in una stringa concatenata e separato per mezzo di virgole. Nell'implementazione ActionScript 3.0, questo metodo restituisce lo stesso valore del metodo Array.toString().
String — Una stringa di elementi di array.
|
Elementi API correlati
toString | () | metodo |
public function toString():String| Versione linguaggio: | ActionScript 3.0 |
| Versioni runtime: | AIR 1.0, Flash Player 9, Flash Lite 4 |
Restituisce una stringa che rappresenta gli elementi dell'array specificato. Ogni elemento dell'array, a partire dall'elemento con l'indice 0 e fino all'elemento con l'indice dal numero più alto, viene convertito in una stringa concatenata e separato per mezzo di virgole. Per specificare un separatore personalizzato, utilizzate il metodo Array.join().
String — Una stringa di elementi di array.
|
Altri esempi
Elementi API correlati
Esempio ( Come utilizzare questo esempio )
vegnums del tipo di dati String.
var vegetables:Array = new Array(); vegetables.push(1); vegetables.push(2); vegetables.push(3); vegetables.push(4); vegetables.push(5); var vegnums:String = vegetables.toString(); trace(vegnums+",6"); // 1,2,3,4,5,6
unshift | () | metodo |
AS3 function unshift(... args):uint| Versione linguaggio: | ActionScript 3.0 |
| Versioni runtime: | AIR 1.0, Flash Player 9, Flash Lite 4 |
Aggiunge uno o più elementi all'inizio di un array e restituisce la nuova lunghezza dell'array. Gli altri elementi nell'array vengono spostati dalla posizione originale i a i+1.
Parametri
... args — Uno o più numeri, elementi o variabili da inserire all'inizio dell'array.
|
uint — Un numero intero che rappresenta la nuova lunghezza dell'array.
|
Altri esempi
Elementi API correlati
Esempio ( Come utilizzare questo esempio )
names. Le stringhe Bill e Jeff vengono aggiunte mediante il metodo push() e vengono aggiunte le stringhe Alfred e Kyle all'inizio di names mediante due chiamate al metodo unshift().
var names:Array = new Array();
names.push("Bill");
names.push("Jeff");
trace(names); // Bill,Jeff
names.unshift("Alfred");
names.unshift("Kyle");
trace(names); // Kyle,Alfred,Bill,Jeff
CASEINSENSITIVE | Costante |
public static const CASEINSENSITIVE:uint = 1| Versione linguaggio: | ActionScript 3.0 |
| Versioni runtime: | AIR 1.0, Flash Player 9, Flash Lite 4 |
Specifica l'ordinamento senza distinzione tra maiuscole e minuscole per i metodi di ordinamento della classe Array. Questa costante può essere utilizzata per il parametro options nel metodo sort() o sortOn().
Il valore di questa costante è 1.
Elementi API correlati
DESCENDING | Costante |
public static const DESCENDING:uint = 2| Versione linguaggio: | ActionScript 3.0 |
| Versioni runtime: | AIR 1.0, Flash Player 9, Flash Lite 4 |
Specifica l'ordinamento discendente per i metodi di ordinamento della classe Array. Questa costante può essere utilizzata per il parametro options nel metodo sort() o sortOn().
Il valore di questa costante è 2.
Elementi API correlati
NUMERIC | Costante |
public static const NUMERIC:uint = 16| Versione linguaggio: | ActionScript 3.0 |
| Versioni runtime: | AIR 1.0, Flash Player 9, Flash Lite 4 |
Specifica l'ordinamento numerico (anziché carattere-stringa) per i metodi di ordinamento della classe Array. Includendo questa costante nel parametro options, i metodi sort() e sortOn() ordineranno i numeri come valori numerici, non come stringhe di caratteri numerici. Senza la costante NUMERIC, l'ordinamento considera ogni elemento dell'array una stringa di caratteri e fornisce i risultati in ordine Unicode.
Ad esempio, dato l'array di valori [2005, 7, 35], se la costante NUMERIC non è inclusa nel parametro options, l'array ordinato è [2005, 35, 7], mentre se la costante NUMERIC è inclusa, l'array ordinato è [7, 35, 2005].
Notate che questa costante si applica solo ai numeri compresi nell'array, non alle stringhe contenenti dati numerici, come ["23", "5"].
Il valore di questa costante è 16.
Elementi API correlati
RETURNINDEXEDARRAY | Costante |
public static const RETURNINDEXEDARRAY:uint = 8| Versione linguaggio: | ActionScript 3.0 |
| Versioni runtime: | AIR 1.0, Flash Player 9, Flash Lite 4 |
Specifica che un ordinamento restituisce un array composto da indici di array. Questa costante può essere utilizzata per il parametro options nel metodo sort() o sortOn() per avere l'accesso a più visualizzazioni degli elementi dell'array mentre l'array originale rimane invariato.
Il valore di questa costante è 8.
Elementi API correlati
UNIQUESORT | Costante |
public static const UNIQUESORT:uint = 4| Versione linguaggio: | ActionScript 3.0 |
| Versioni runtime: | AIR 1.0, Flash Player 9, Flash Lite 4 |
Specifica il requisito dell'ordinamento univoco per i metodi di ordinamento della classe Array. Questa costante può essere utilizzata per il parametro options nel metodo sort() o sortOn(). L'opzione di ordinamento univoco termina l'operazione di ordinamento se due elementi o campi qualsiasi in fase di ordinamento hanno valori identici.
Il valore di questa costante è 4.
Elementi API correlati
myArr senza argomenti e con una lunghezza iniziale pari a 0:
package {
import flash.display.Sprite;
public class ArrayExample extends Sprite {
public function ArrayExample() {
var myArr:Array = new Array();
trace(myArr.length); // 0
}
}
}
Tue Jun 12 2018, 02:44 PM Z