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 si assegna 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 alla proprietà length si assegna un valore più breve della lunghezza esistente, l'array viene troncato.

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

Consente di creare un array del numero specificato di elementi. Se non si specifica alcun parametro, viene creato un array che contiene 0 elementi. Se si specifica 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.

Vedere anche

package {
    import flash.display.Sprite;

    public class Array_Array extends Sprite {

        public function Array_Array() {
            var myArr:Array = new Array();
            trace(myArr.length); // 0
        }
    }
}

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
        }
    }
}

Consente di creare un array che contiene gli elementi specificati. È possibile 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.

Vedere anche

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
        }
    }
}

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.

Parametri

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

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. Si utilizza 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. Si supponga di creare una funzione in un clip filmato di nome me:

     function myFunction(obj:Object):void { //inserire il codice }
     

Quindi, si supponga 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, Flash Player 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 { //inserire il codice }; myArray.every(myFunction, me);
     

Parametri

function callback(item:*, index:int, array:Array):Boolean;

Vedere anche

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

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. Si supponga di creare una funzione in un clip filmato di nome me:

     function myFunction(obj:Object):void { //inserire il codice }
     

Quindi, si supponga 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, Flash Player 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 { //inserire il codice }; myArray.filter(myFunction, me);
     

Parametri

    function callback(item:*, index:int, array:Array):Boolean;

Vedere anche

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

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. Si supponga di creare una funzione in un clip filmato di nome me:

     function myFunction(obj:Object):void { //inserire il codice }
     

Quindi, si supponga 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, Flash Player 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 { //inserire il codice }; myArray.forEach(myFunction, me);
     

Parametri

    function callback(item:*, index:int, array:Array):void;

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

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

Cerca un elemento in un array utilizzando l'operatore di uguaglianza rigorosa (===) e restituisce la posizione di indice dell'elemento.

Parametri

Vedere anche

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
        }
    }
}

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

Vedere anche

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

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

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

Vedere anche

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
        }
    }
}

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. Si supponga di creare una funzione in un clip filmato di nome me:

     function myFunction(obj:Object):void { //inserire il codice }
     

Quindi, si supponga 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, Flash Player 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 { //inserire il codice }; myArray.map(myFunction, me);
     

Parametri

    function callback(item:*, index:int, array:Array):void;

Vedere anche

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

Rimuove l'ultimo elemento di un array e ne restituisce il valore.

Vedere anche

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

Aggiunge uno o più elementi alla fine di un array e restituisce la nuova lunghezza dell'array.

Parametri

Vedere anche

var letters:Array = new Array();

letters.push("a");
letters.push("b");
letters.push("c");

trace(letters.toString()); // a,b,c

var letters:Array = new Array("a");
var count:uint = letters.push("b", "c");

trace(letters); // a,b,c
trace(count);   // 3

Inverte l'array in posizione.

var letters:Array = new Array("a", "b", "c");
trace(letters); // a,b,c
letters.reverse();
trace(letters); // c,b,a

Rimuove il primo elemento di un array e lo restituisce. Gli elementi rimanenti dell'array vengono spostati dalla posizione originale i a i-1.

Vedere anche

var letters:Array = new Array("a", "b", "c");
var firstLetter:String = letters.shift();
trace(letters);     // b,c
trace(firstLetter); // a

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 si passa alcun parametro, viene creato un duplicato dell'array originale.

Parametri

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

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

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

Esegue una funzione di prova su ciascun elemento nell'array fino a quando non viene raggiunto un elemento che restituisce true. Si utilizza 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. Si supponga di creare una funzione in un clip filmato di nome me:

     function myFunction(obj:Object):void { //inserire il codice }
     

Quindi, si supponga 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, Flash Player 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 { //inserire il codice }; myArray.some(myFunction, me);
     

Parametri

    function callback(item:*, index:int, array:Array):Boolean;

Vedere anche

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

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, è possibile 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 si crea una funzione personalizzata, è possibile chiamare il metodo sort() e utilizzare il nome della funzione personalizzata come primo argomento (compareFunction).

Parametri

Vedere anche

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

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

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

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

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

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 si passano 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, utilizzare Array.sort().

Per passare più flag, separarli 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

Vedere anche

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

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

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

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, utilizzare ...args per i parametri, come illustra l'esempio seguente:

  public override function splice(...args) { // inserire qui le istruzioni }
  

Parametri

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

 
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

Restituisce una stringa che rappresenta gli elementi dell'array specificato. Ogni elemento dell'array, a partire dall'elemento con l'indice 0 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().

Vedere anche

Restituisce una stringa che rappresenta gli elementi dell'array specificato. Ogni elemento dell'array, a partire dall'elemento con l'indice 0 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, utilizzare il metodo Array.join().

Vedere anche

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

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

Vedere anche

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

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.

Vedere anche

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.

Vedere anche

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].

Si noti 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.

Vedere anche

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.

Vedere anche

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.

Vedere anche