Array  - AS3

Entero no negativo que especifica el número de elementos del conjunto. Esta propiedad se actualiza automáticamente cuando se añaden nuevos elementos al conjunto. Cuando se asigna un valor a un elemento de conjunto (por ejemplo, my_array[index] = value), si index es un número e index+1 es mayor que la propiedad length, esta propiedad length se actualizará a index+1.

Nota: si asigna un valor a la propiedad length inferior a la longitud existente, el conjunto se truncará.

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

Le permite crear un conjunto con los elementos especificados. Puede especificar valores de cualquier tipo. El primer elemento de un conjunto siempre tiene el índice (o la posición) 0.

Nota: esta clase muestra dos entradas de constructor porque el constructor acepta tipos de argumentos variables. El constructor se comporta de forma diferente dependiendo del tipo y el número de argumentos pasados, como se detalla en cada entrada. ActionScript 3.0 no admite la sobrecarga de métodos o constructores.

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

Le permite crear un conjunto con el número especificado de elementos. Si no especifica ningún parámetro, se creará un conjunto con 0 elementos. Si especifica un número de elementos, se creará un conjunto con el número de elementos indicado por numElements.

Nota: esta clase muestra dos entradas de método constructor porque el constructor acepta tipos de argumentos variables. El constructor se comporta de forma diferente dependiendo del tipo y el número de argumentos pasados, como se detalla en cada entrada. ActionScript 3.0 no admite la sobrecarga de métodos o constructores.

Elementos de 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 los elementos especificados en los parámetros con los elementos de un conjunto y crea un conjunto nuevo. Si los parámetros especifican un conjunto, se concatenarán los elementos de dicho conjunto. Si no se pasa ningún parámetro, el nuevo conjunto será un duplicado (clon vacío) del conjunto 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

Ejecuta una función de prueba en cada elemento del conjunto hasta que se llega a un elemento que devuelve false para la función especificada. Este método se utiliza para determinar si todos los elementos de un conjunto cumplen un criterio como, por ejemplo, que tengan valores inferiores a un número determinado.

En el caso de este método, el segundo parámetro, thisObject, debe ser null si el primer parámetro, callback, es un cierre del método. Supongamos que crea una función en un clip de película llamado me:

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

Supongamos que posteriormente utiliza el método every() en un conjunto llamado myArray:

     myArray.every(myFunction, me);
     

Dado que myFunction es miembro de la clase Timeline, que no puede ser anulada por me, el motor de ejecución de Flash emitirá una excepción. Puede evitar este error de tiempo de ejecución asignando la función a una variable de la siguiente 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 de 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);
        }
    }
}

Ejecuta una función de prueba en cada elemento del conjunto y construye un nuevo conjunto para todos los elementos que devuelven true para la función especificada. Si un elemento devuelve false, no se incluye en el nuevo conjunto.

En el caso de este método, el segundo parámetro, thisObject, debe ser null si el primer parámetro, callback, es un cierre del método. Supongamos que crea una función en un clip de película llamado me:

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

Supongamos que posteriormente utiliza el método filter() en un conjunto llamado myArray:

 
     myArray.filter(myFunction, me);
     

Dado que myFunction es miembro de la clase Timeline, que no puede ser anulada por me, el motor de ejecución de Flash emitirá una excepción. Puede evitar este error de tiempo de ejecución asignando la función a una variable de la siguiente 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 de 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)" : ""));
        }
    }
}

Ejecuta una función en cada elemento del conjunto.

En el caso de este método, el segundo parámetro, thisObject, debe ser null si el primer parámetro, callback, es un cierre del método. Supongamos que crea una función en un clip de película llamado me:

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

Supongamos que posteriormente utiliza el método forEach() en un conjunto llamado myArray:

     myArray.forEach(myFunction, me);
     

Dado que myFunction es miembro de la clase Timeline, que no puede ser anulada por me, el motor de ejecución de Flash emitirá una excepción. Puede evitar este error de tiempo de ejecución asignando la función a una variable de la siguiente 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)" : ""));
        }
    }
}

Busca un elemento en un conjunto utilizando el operador de igualdad estricta (===) y devuelve la posición de índice del elemento.

Parámetros

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

Inserte un elemento individual en un conjunto. Este método modifica la matriz sin realizar ninguna copia de la misma.

Parámetros

Convierte los elementos de un conjunto en cadenas, inserta el separador especificado entre los elementos, los concatena y devuelve la cadena resultante. Un conjunto anidado siempre va separado por una coma (,), no por el separador pasado al método join().

Parámetros

Elementos de 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

Busca un elemento en un conjunto hacia atrás desde el último elemento y devuelve la posición de índice del elemento coincidente utilizando el operador de igualdad estricta (===).

Parámetros

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

Ejecuta una función en cada elemento de un conjunto y construye un nuevo conjunto de elementos correspondientes a los resultados de la función en cada elemento del conjunto original.

En el caso de este método, el segundo parámetro, thisObject, debe ser null si el primer parámetro, callback, es un cierre del método. Supongamos que crea una función en un clip de película llamado me:

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

Supongamos que posteriormente utiliza el método map() en un conjunto llamado myArray:

     myArray.map(myFunction, me);
     

Dado que myFunction es miembro de la clase Timeline, que no puede ser anulada por me, el motor de ejecución de Flash emitirá una excepción. Puede evitar este error de tiempo de ejecución asignando la función a una variable de la siguiente 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 de 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();
        }
    }
}

Elimina el último elemento de un conjunto y devuelve el valor de dicho elemento.

Elementos de 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

Añade uno o varios elementos al final de un conjunto y devuelve la nueva longitud del conjunto.

Parámetros

Elementos de 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

Elimine un elemento individual de un conjunto. Este método modifica la matriz sin realizar ninguna copia de la misma.

Parámetros

Invierte la colocación del conjunto.

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

Elimina el primer elemento de un conjunto y devuelve dicho elemento. Los restantes elementos del conjunto se desplazan de su posición original, i, a i-1.

Elementos de API relacionados

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

Devuelve un conjunto nuevo que consta de un rango de elementos del conjunto original sin modificar el conjunto original. El conjunto devuelto incluye el elemento startIndex y todos los elementos hasta endIndex, sin incluir éste.

Si no se pasa ningún parámetro, el nuevo conjunto será un duplicado (clon vacío) del conjunto 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

Ejecuta una función de prueba en cada elemento del conjunto hasta que se llega a un elemento que devuelve true. Utilice este método para determinar si todos los elementos de un conjunto cumplen un criterio como, por ejemplo, que tengan valores inferiores a un número determinado.

En el caso de este método, el segundo parámetro, thisObject, debe ser null si el primer parámetro, callback, es un cierre del método. Supongamos que crea una función en un clip de película llamado me:

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

Supongamos que posteriormente utiliza el método some() en un conjunto llamado myArray:

     myArray.some(myFunction, me);
     

Dado que myFunction es miembro de la clase Timeline, que no puede ser anulada por me, el motor de ejecución de Flash emitirá una excepción. Puede evitar este error de tiempo de ejecución asignando la función a una variable de la siguiente 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 de 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);
        }
    }
}

Ordena los elementos de un conjunto. Este método ordena por valores Unicode. (ASCII es un subconjunto de Unicode.)

De manera predeterminada, Array.sort() funciona de la siguiente forma:

• La ordenación distingue entre mayúsculas y minúsculas (Z precede a a).
• La ordenación es ascendente (a precede a b).
• El conjunto se modifica para reflejar el orden de clasificación; los elementos que tengan campos de ordenación idénticos se sitúan consecutivamente en el conjunto ordenado sin seguir ningún orden específico.
• Todos los elementos, con independencia de su tipo de datos, se ordenan como si fueran cadenas, de manera que 100 precede a 99, dado que "1" es un valor de cadena inferior a "9".

Para ordenar un conjunto utilizando valores que se desvían de los predeterminados, puede utilizar una de las opciones de ordenación que se describen en la parte sortOptions de la descripción del parámetro ...args, o bien puede crear una función personalizada para realizar la ordenación. Si crea una función personalizada, deberá llamar al método sort() y utilizar el nombre de la función personalizada como primer argumento (compareFunction)

Parámetros

Elementos de 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

Ordena los elementos de un conjunto por uno o varios campos del conjunto. El conjunto debe tener las siguientes características:

• El conjunto es indexado, no asociativo.
• Cada elemento del conjunto contiene un objeto con una o varias propiedades.
• Todos los objetos tienen al menos una propiedad en común, cuyos valores pueden emplearse para ordenar el conjunto. Esa propiedad se denomina field.

Si pasa varios parámetros fieldName, el primer campo representará al campo de ordenación principal, el segundo representará al siguiente campo de ordenación, etc. Flash ordena por valores Unicode. (ASCII es un subconjunto de Unicode.) Si uno de los elementos que se están comparando no contiene el campo especificado en el parámetro fieldName, se dará por hecho que el campo está definido como undefined y los elementos se colocarán consecutivamente en el conjunto ordenado sin seguir ningún orden determinado.

De manera predeterminada, Array.sortOn() funciona de la siguiente forma:

• La ordenación distingue entre mayúsculas y minúsculas (Z precede a a).
• La ordenación es ascendente (a precede a b).
• El conjunto se modifica para reflejar el orden de clasificación; los elementos que tengan campos de ordenación idénticos se sitúan consecutivamente en el conjunto ordenado sin seguir ningún orden específico.
• Los campos numéricos se ordenan como si fueran cadenas, de manera que 100 precede a 99, dado que "1" es un valor de cadena inferior a "9".

Flash Player 7 añadía el parámetro options, que puede utilizar para sobrescribir el comportamiento de ordenación anterior. Para ordenar un conjunto sencillo (por ejemplo, un conjunto con un solo campo), o si desea especificar un orden de clasificación que el parámetro options no admite, utilice Array.sort().

Para pasar varios indicadores, sepárelos con el operador OR en modo de bit (|):

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

Flash Player 8 ofrece además la posibilidad de especificar una opción de ordenación diferente para cada campo cuando se realiza una ordenación por más de un campo. En Flash Player 8 y versiones posteriores, el parámetro options acepta un conjunto de opciones de ordenación de manera que cada opción de ordenación corresponde a un campo de ordenación en el parámetro fieldName. En el ejemplo siguiente, se ordena el campo de ordenación principal a en orden descendente, el campo de ordenación secundario b empleando una ordenación numérica y el campo de ordenación terciario c utilizando su distinción entre mayúsculas y minúsculas:

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

Nota: los conjuntos fieldName y options deben tener el mismo número de elementos; de lo contrario el conjunto options se ignora. Asimismo, las opciones Array.UNIQUESORT y Array.RETURNINDEXEDARRAY sólo pueden utilizarse como primer elemento del conjunto y, en caso contrario, se ignoran.

Parámetros

Elementos de 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

Añade y elimina elementos de un conjunto. Este método modifica la matriz sin realizar ninguna copia de la misma.

Nota: para anular este método en una subclase de Array, utilice ...args para los parámetros, como se muestra en este ejemplo:

     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

Devuelve una cadena que representa los elementos del conjunto especificado. Cada elemento del conjunto, comenzando por el índice 0 y terminando por el índice más alto, se convierte en una cadena concatenada separada por comas. En la implementación ActionScript 3.0, este método devuelve el mismo valor que el método Array.toString().

Elementos de API relacionados

Devuelve una cadena que representa los elementos del conjunto especificado. Cada elemento del conjunto, comenzando por el índice 0 y terminando por el índice más alto, se convierte en una cadena concatenada separada por comas. Para especificar un separador personalizado, utilice el método Array.join().

Elementos de 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

Añade uno o varios elementos al comienzo de un conjunto y devuelve la nueva longitud del conjunto. Los restantes elementos del conjunto se desplazan de su posición original, i, a i+1.

Parámetros

Elementos de 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 una ordenación con distinción entre mayúsculas y minúsculas para los métodos de ordenación de la clase Array. Puede utilizar esta constante para el parámetro options en el método sort() o sortOn().

El valor de esta constante es 1.

Elementos de API relacionados

Especifica una ordenación descendente para los métodos de ordenación de la clase Array. Puede utilizar esta constante para el parámetro options en el método sort() o sortOn().

El valor de esta constante es 2.

Elementos de API relacionados

Especifica una ordenación numérica (en lugar de por cadena de caracteres) para los métodos de ordenación de la clase Array. Al incluir esta constante en el parámetro options, los métodos sort() y sortOn() ordenan los números como valores numéricos, no como cadenas de caracteres numéricos. Sin la constante NUMERIC, la ordenación trata cada elemento de conjunto como una cadena de carácter y genera los resultados en orden Unicode.

Por ejemplo, en el conjunto de valores [2005, 7, 35], si la constante NUMERIC no está incluida en el parámetro options, el conjunto ordenado es [2005, 35, 7], pero si la constante NUMERIC sí está incluida, el conjunto ordenado es [7, 35, 2005].

Esta constante sólo es aplicable a los números del conjunto, no a las cadenas que contienen datos numéricos como, por ejemplo, ["23", "5"].

El valor de esta constante es 16.

Elementos de API relacionados

Especifica que una ordenación devuelva un conjunto formado por los índices de un conjunto. Puede utilizar esta constante para el parámetro options en el método sort() o sortOn(), lo que le permitirá tener acceso a varias vistas de los elementos del conjunto mientras el conjunto original permanece sin cambios.

El valor de esta constante es 8.

Elementos de API relacionados

Especifica el requisito de ordenación exclusivo para los métodos de ordenación de la clase Array. Puede utilizar esta constante para el parámetro options en el método sort() o sortOn(). La opción de ordenación exclusiva pone fin a la ordenación si dos elementos o campos que se están ordenando tienen valores idénticos.

El valor de esta constante es 4.

Elementos de API relacionados