Array  - AS3

Um inteiro não negativo que especifica o número de elementos na matriz. Essa propriedade é automaticamente atualizada quando novos elementos são adicionados à matriz. Quando você atribui um valor a um elemento de matriz (por exemplo, my_array[index] = value), se index for um número e index+1 for maior do que a propriedade length, essa propriedade length será atualizada para index+1.

Nota: se você atribuir um valor à propriedade length que seja menor do que o comprimento existente, a matriz será truncada.

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

Permite criar uma matriz que contenha os elementos especificados. Você pode especificar valores de qualquer tipo. O primeiro elemento de uma matriz sempre tem um índice (ou posição) de 0.

Nota: esta classe mostra duas entradas de construtor, uma vez que o construtor aceita tipos variáveis de argumentos. O construtor se comporta de forma diferente dependendo do tipo e do número de argumentos transmitidos, conforme detalhado em cada entrada. O ActionScript 3.0 não oferece suporte à sobrecarga de métodos ou construtores.

Elementos da API relacionados

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

Permite criar uma matriz do número especificado de elementos. Se você não especificar parâmetros, será criada uma matriz contendo 0 elementos. Se você especificar um número de elementos, será criada uma matriz com o número de elementos de numElements.

Nota: esta classe mostra duas entradas de método de construtor, uma vez que o construtor aceita tipos variáveis de argumentos. O construtor se comporta de forma diferente dependendo do tipo e do número de argumentos transmitidos, conforme detalhado em cada entrada. O ActionScript 3.0 não oferece suporte à sobrecarga de métodos ou construtores.

Elementos da API relacionados

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

Concatena os elementos especificados nos parâmetros com os elementos em uma matriz e cria uma nova matriz. Se os parâmetros especificarem uma matriz, os elementos dessa matriz serão concatenados. Se você não transmitir nenhum parâmetro, a nova matriz será uma duplicata (clone superficial) da matriz original.

Parâmetros

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

Executa uma função de teste em cada item da matriz até que seja alcançado um item que retorne false para a função especificada. Use este método para determinar se todos os itens de uma matriz atendem a um critério, como ter valores menores do que um certo número.

Para esse método, o segundo parâmetro, thisObject, deverá ser null se o primeiro parâmetro, callback, for um fechamento de método. Suponha que você crie uma função em um clipe de vídeo denominada me:

     function myFunction(obj:Object):void {
        //your code here
     }
     

Em seguida, suponha que você use o método every() em uma matriz denominada myArray:

     myArray.every(myFunction, me);
     

Como myFunction é um membro da classe Timeline, que não pode ser substituída por me, o tempo de execução do Flash lançará uma exceção. Esse erro de tempo de execução pode ser evitado atribuindo a função a uma variável, desta forma:

     var myFunction:Function = function(obj:Object):void {
         //your code here
     };
     myArray.every(myFunction, me);
     

Parâmetros

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

Elementos da API relacionados

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

Executa uma função de teste em cada item da matriz e constrói uma nova matriz para todos os itens que retornarem true para a função especificada. Se um item retornar false, ele não será incluso na nova matriz.

Para esse método, o segundo parâmetro, thisObject, deverá ser null se o primeiro parâmetro, callback, for um fechamento de método. Suponha que você crie uma função em um clipe de vídeo denominada me:

     function myFunction(obj:Object):void {
        //your code here
     }
     

Em seguida, suponha que você use o método filter() em uma matriz denominada myArray:

 
     myArray.filter(myFunction, me);
     

Como myFunction é um membro da classe Timeline, que não pode ser substituída por me, o tempo de execução do Flash lançará uma exceção. Esse erro de tempo de execução pode ser evitado atribuindo a função a uma variável, desta forma:

     var myFunction:Function = function(obj:Object):void {
         //your code here
         };
     myArray.filter(myFunction, me);
     

Parâmetros

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

Elementos da API relacionados

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

Executa uma função em cada item da matriz.

Para esse método, o segundo parâmetro, thisObject, deverá ser null se o primeiro parâmetro, callback, for um fechamento de método. Suponha que você crie uma função em um clipe de vídeo denominada me:

     function myFunction(obj:Object):void {
        //your code here
     }
     

Em seguida, suponha que você use o método forEach() em uma matriz denominada myArray:

     myArray.forEach(myFunction, me);
     

Como myFunction é um membro da classe Timeline, que não pode ser substituída por me, o tempo de execução do Flash lançará uma exceção. Esse erro de tempo de execução pode ser evitado atribuindo a função a uma variável, desta forma:

     var myFunction:Function = function(obj:Object):void {
         //your code here
         };
     myArray.forEach(myFunction, me);
     

Parâmetros

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

Procura um item em uma matriz, usando a igualdade estrita (===), e retorna a posição de índice do item.

Parâmetros

Elementos da API relacionados

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

Inserir um único elemento em uma matriz. Este método modifica a matriz sem fazer uma cópia.

Parâmetros

Converte em strings os elementos de uma matriz, insere o separador especificado entre os elementos, faz a sua concatenação e retorna a string resultante. Uma matriz aninhada é sempre separada por uma vírgula (,) e não pelo separador transmitido ao método join().

Parâmetros

Elementos da API relacionados

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

Procura um item em uma matriz, operando para trás a partir do último item, e retorna a posição do índice do item correspondente usando a igualdade estrita (===).

Parâmetros

Elementos da API relacionados

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

Executa uma função em cada item de uma matriz e constrói uma nova matriz de itens correspondentes aos resultados da função em cada item na matriz original.

Para esse método, o segundo parâmetro, thisObject, deverá ser null se o primeiro parâmetro, callback, for um fechamento de método. Suponha que você crie uma função em um clipe de vídeo denominada me:

     function myFunction(obj:Object):void {
        //your code here
     }
     

Em seguida, suponha que você use o método map() em uma matriz denominada myArray:

     myArray.map(myFunction, me);
     

Como myFunction é um membro da classe Timeline, que não pode ser substituída por me, o tempo de execução do Flash lançará uma exceção. Esse erro de tempo de execução pode ser evitado atribuindo a função a uma variável, desta forma:

     var myFunction:Function = function(obj:Object):void {
         //your code here
         };
     myArray.map(myFunction, me);
     

Parâmetros

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

Elementos da API relacionados

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

Remove o último elemento de uma matriz e retorna o valor desse elemento.

Elementos da API relacionados

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

Adiciona um ou mais elementos ao final de uma matriz e retorna o novo comprimento dessa matriz.

Parâmetros

Elementos da API relacionados

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

Remover um único elemento de uma matriz. Este método modifica a matriz sem fazer uma cópia.

Parâmetros

Inverte a matriz no lugar.

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

Remove o primeiro elemento de uma matriz e retorna esse elemento. Os elementos restantes da matriz são movidos da posição original, i, a i-1.

Elementos da API relacionados

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

Retorna uma nova matriz que consiste em uma faixa de elementos a partir da matriz original, sem modificar a matriz original. A matriz retornada inclui o elemento startIndex e todos os elementos até, mas sem incluir, o elemento endIndex.

Se você não transmitir nenhum parâmetro, a nova matriz será uma duplicata (clone superficial) da matriz original.

Parâmetros

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

Executa uma função de teste em cada item da matriz até que seja alcançado um item que retorne true. Use este método para determinar se todos os itens de uma matriz atendem a um critério, como ter um valor menor do que um certo número.

Para esse método, o segundo parâmetro, thisObject, deverá ser null se o primeiro parâmetro, callback, for um fechamento de método. Suponha que você crie uma função em um clipe de vídeo denominada me:

     function myFunction(obj:Object):void {
        //your code here
     }
     

Em seguida, suponha que você use o método some() em uma matriz denominada myArray:

     myArray.some(myFunction, me);
     

Como myFunction é um membro da classe Timeline, que não pode ser substituída por me, o tempo de execução do Flash lançará uma exceção. Esse erro de tempo de execução pode ser evitado atribuindo a função a uma variável, desta forma:

     var myFunction:Function = function(obj:Object):void {
         //your code here
         };
     myArray.some(myFunction, me);
     

Parâmetros

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

Elementos da API relacionados

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

Classifica os elementos em uma matriz. Esse método classifica de acordo com valores Unicode. (ASCII é um subconjunto de Unicode.)

Por padrão, Array.sort() funciona da seguinte maneira:

• A classificação faz distinção entre maiúsculas e minúsculas (Z precede a).
• A classificação é ascendente (a precede b).
• A matriz é modificada para refletir a ordem de classificação; vários elementos que têm campos de classificação idênticos são inseridos consecutivamente na matriz classificada, sem nenhuma ordem em particular.
• Todos os elementos, independentemente do tipo de dados, são classificados como se fossem strings. Sendo assim, 100 precede 99, já que "1" é um valor de string menor do que "9".

Para classificar uma matriz usando configurações diferentes das configurações padrão, você pode usar uma das opções de classificação descritas na parte sortOptions da descrição do parâmetro ...args ou pode criar a sua própria função personalizada para fazer a classificação. Se você criar uma função personalizada, chame o método sort() e use o nome da sua função personalizada como primeiro argumento (compareFunction)

Parâmetros

Elementos da API relacionados

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

Classifica os elementos em uma matriz de acordo com um ou mais campos nessa matriz. A matriz deve ter as seguintes características:

• A matriz é indexada e não associativa.
• Cada elemento da matriz contém um objeto com uma ou mais propriedades.
• Todos os objetos têm pelo menos uma propriedade em comum, cujos valores podem ser usados para classificar a matriz. Essa propriedade é chamada de field.

Se você transmitir vários parâmetros fieldName, o primeiro campo representará o campo de classificação principal, o segundo representará o próximo campo de classificação e assim por diante. O Flash classifica de acordo com valores Unicode. (ASCII é um subconjunto de Unicode.) Se um dos elementos que estiver sendo comparado não contiver o campo especificado no parâmetro fieldName, ficará pressuposto que esse campo deve ser definido como undefined e que os elementos devem ser inseridos consecutivamente na matriz classificada, sem nenhuma ordem em particular.

Por padrão, Array.sortOn() funciona da seguinte maneira:

• A classificação faz distinção entre maiúsculas e minúsculas (Z precede a).
• A classificação é ascendente (a precede b).
• A matriz é modificada para refletir a ordem de classificação; vários elementos que têm campos de classificação idênticos são inseridos consecutivamente na matriz classificada, sem nenhuma ordem em particular.
• Os campos numéricos são classificados como se fossem strings. Sendo assim, 100 precede 99, já que "1" é um valor de string menor do que "9".

O Flash Player 7 adicionou o parâmetro options, que você pode usar para substituir o comportamento de classificação padrão. Para classificar uma matriz simples (por exemplo, uma matriz com apenas um campo) ou para especificar uma ordem de classificação não suportada pelo parâmetro options, use Array.sort().

Para transmitir vários sinalizadores, separe-os com o operador OR bit a bit (|):

     my_array.sortOn(someFieldName, Array.DESCENDING | Array.NUMERIC);
     

O Flash Player 8 adicionou a capacidade de especificar uma opção de classificação diferente para cada campo ao classificar de acordo com mais de um campo. No Flash Player 8 e superior, o parâmetro options aceita uma matriz de opções de classificação, de forma que cada opção de classificação corresponda a um campo de classificação no parâmetro fieldName. O exemplo a seguir classifica o campo de classificação primário, a, usando uma classificação decrescente; o segundo campo de classificação, b, usando uma classificação numérica e o campo de classificação terciário, c, usando uma classificação sem distinção entre maiúsculas e minúsculas:

     Array.sortOn (["a", "b", "c"], [Array.DESCENDING, Array.NUMERIC, Array.CASEINSENSITIVE]);
     

Nota: as matrizes fieldName e options devem ter o mesmo número de elementos; caso contrário a matriz options será ignorada. Além disso, as opções Array.UNIQUESORT e Array.RETURNINDEXEDARRAY apenas podem ser usadas como o primeiro elemento na matriz; caso contrário, serão ignoradas.

Parâmetros

Elementos da API relacionados

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

Adiciona ou remove elementos de uma matriz. Este método modifica a matriz sem fazer uma cópia.

Nota: para substituir este método em uma subclasse de Array, use ...args para os parâmetros, como mostra este exemplo:

     public override function splice(...args) {
       // your statements here
     }
     

Parâmetros

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

Retorna uma string que representa os elementos na matriz especificada. Cada elemento na matriz, começando com o índice 0 e terminando no índice mais alto, é convertido em uma string concatenada e separado por vírgulas. Na implementação ActionScript 3.0, esse método retorna o mesmo valor que o método Array.toString().

Elementos da API relacionados

Retorna uma string que representa os elementos na matriz especificada. Cada elemento na matriz, começando com o índice 0 e terminando no índice mais alto, é convertido em uma string concatenada e separado por vírgulas. Para especificar um separador personalizado, use o método Array.join().

Elementos da API relacionados

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

Adiciona um ou mais elementos ao início de uma matriz e retorna o novo comprimento dessa matriz. Os outros elementos da matriz são movidos da posição original, i, a i+1.

Parâmetros

Elementos da API relacionados

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

Especifica a classificação sem distinção entre maiúsculas e minúsculas para os métodos de classificação da classe Array. Você pode usar essa constante para o parâmetro options no método sort() ou sortOn().

O valor dessa constante é 1.

Elementos da API relacionados

Especifica a classificação decrescente para os métodos de classificação da classe Array. Você pode usar essa constante para o parâmetro options no método sort() ou sortOn().

O valor dessa constante é 2.

Elementos da API relacionados

Especifica a classificação numérica (em vez de string de caracteres) para os métodos de classificação da classe Array. A inclusão dessa constante no parâmetro options faz com que os métodos sort() e sortOn() classifiquem números como valores numéricos e não como strings de caracteres numéricos. Sem a constante NUMERIC, a classificação trata cada elemento da matriz como uma string de caractere e gera os resultados na ordem Unicode.

Por exemplo, considerando a matriz de valores [2005, 7, 35], se a constante NUMERIC não estiver inclusa no parâmetro options, a matriz classificada será [2005, 35, 7]; mas, se a constante NUMERIC estiver inclusa, a matriz classificada será [7, 35, 2005].

Essa constante aplica-se somente aos números na matriz e não se aplica a strings que contenham dados numéricos, como ["23", "5"].

O valor dessa constante é 16.

Elementos da API relacionados

Especifica que uma classificação retorna uma matriz que consiste em índices de matriz. Você pode usar essa constante para o parâmetro options no método sort() ou sortOn(), de modo a ter acesso a várias exibições dos elementos da matriz, enquanto a matriz original permanece inalterada.

O valor dessa constante é 8.

Elementos da API relacionados

Especifica a exigência de classificação exclusiva para os métodos de classificação da classe Array. Você pode usar essa constante para o parâmetro options no método sort() ou sortOn(). A opção de classificação exclusiva terminará a classificação se quaisquer dois elementos ou campos que estiverem sendo classificados tiverem valores idênticos.

O valor dessa constante é 4.

Elementos da API relacionados