Entero no negativo que especifica el número de elementos de la matriz. Esta propiedad se actualiza automáticamente cuando se añaden nuevos elementos a la matriz. Cuando se asigna un valor a un elemento de matriz (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, la matriz 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 una matriz con el número especificado de elementos. Si no especifica ningún parámetro, se creará una matriz con 0 elementos. Si especifica un número de elementos, se creará una matriz 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.

Véase también

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

Le permite crear una matriz con los elementos especificados. Puede especificar valores de cualquier tipo. El primer elemento de una matriz 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.

Véase también

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 los elementos especificados en los parámetros con los elementos de una matriz y crea una matriz nueva. Si los parámetros especifican una matriz, se concatenarán los elementos de dicha matriz.

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 de la matriz 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 una matriz 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 { //su código aquí }
     

Supongamos que posteriormente utiliza el método every() en una matriz llamada myArray:

     myArray.every(myFunction, me);
     

Dado que myFunction es miembro de la clase Timeline, que no puede ser anulada por me, Flash Player 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 { //su código aquí}; myArray.every(myFunction, me);
     

Parámetros

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

Véase también

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 de la matriz y construye una nueva matriz para todos los elementos que devuelven true para la función especificada. Si un elemento devuelve false, no se incluye en la nueva matriz.

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 { //su código aquí }
     

Supongamos que posteriormente utiliza el método filter() en una matriz llamada myArray:

     myArray.filter(myFunction, me);
     

Dado que myFunction es miembro de la clase Timeline, que no puede ser anulada por me, Flash Player 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 { //su código aquí }; myArray.filter(myFunction, me);
     

Parámetros

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

Véase también

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 de la matriz.

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 { //su código aquí }
     

Supongamos que posteriormente utiliza el método forEach() en una matriz llamada myArray:

     myArray.forEach(myFunction, me);
     

Dado que myFunction es miembro de la clase Timeline, que no puede ser anulada por me, Flash Player 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 { //su código aquí }; 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 una matriz utilizando el operador de igualdad estricta (===) y devuelve la posición de índice del elemento.

Parámetros

Véase también

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

Convierte los elementos de una matriz en cadenas, inserta el separador especificado entre los elementos, los concatena y devuelve la cadena resultante. Una matriz anidada siempre va separada por una coma (,), no por el separador pasado al método join().

Parámetros

Véase también

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 una matriz 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

Véase también

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 una matriz y construye una nueva matriz de elementos correspondientes a los resultados de la función en cada elemento de la matriz 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 { //su código aquí }
     

Supongamos que posteriormente utiliza el método map() en una matriz llamada myArray:

     myArray.map(myFunction, me);
     

Dado que myFunction es miembro de la clase Timeline, que no puede ser anulada por me, Flash Player 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 { //su código aquí }; myArray.map(myFunction, me);
     

Parámetros

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

Véase también

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 una matriz y devuelve el valor de dicho elemento.

Véase también

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 una matriz y devuelve la nueva longitud de la matriz.

Parámetros

Véase también

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

Invierte la colocación de la matriz.

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 una matriz y devuelve dicho elemento. Los restantes elementos de la matriz se desplazan de su posición original, i, a i-1.

Véase también

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

Devuelve una matriz nueva que consta de un rango de elementos de la matriz original sin modificar la matriz original. La matriz devuelta incluye el elemento startIndex y todos los elementos hasta endIndex, sin incluir éste.

Si no se pasa ningún parámetro, se creará un duplicado de la 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

Ejecuta una función de prueba en cada elemento de la matriz hasta que se llega a un elemento que devuelve true. Utilice este método para determinar si todos los elementos de una matriz 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 { //su código aquí }
     

Supongamos que posteriormente utiliza el método some() en una matriz llamada myArray:

     myArray.some(myFunction, me);
     

Dado que myFunction es miembro de la clase Timeline, que no puede ser anulada por me, Flash Player 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 { //su código aquí }; myArray.some(myFunction, me);
     

Parámetros

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

Véase también

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 una matriz. 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).
• La matriz se modifica para reflejar el orden de clasificación; los elementos que tengan campos de ordenación idénticos se sitúan consecutivamente en la matriz ordenada 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 una matriz 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

Véase también

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 una matriz por uno o varios campos de la matriz. La matriz debe tener las siguientes características:

• La matriz es indexada, no asociativa.
• Cada elemento de la matriz 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 la matriz. 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 la matriz ordenada 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).
• La matriz se modifica para reflejar el orden de clasificación; los elementos que tengan campos de ordenación idénticos se sitúan consecutivamente en la matriz ordenada 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 una matriz sencilla (por ejemplo, una matriz 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 una matriz 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: las matrices fieldName y options deben tener el mismo número de elementos; de lo contrario la matriz options se ignora. Asimismo, las opciones Array.UNIQUESORT y Array.RETURNINDEXEDARRAY sólo pueden utilizarse como primer elemento de la matriz y, en caso contrario, se ignoran.

Parámetros

Véase también

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 una matriz. Este método modifica la matriz sin realizar ninguna copia de ella.

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) { // las sentencias van aquí }
  

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 de la matriz especificada. Cada elemento de la matriz, 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().

Véase también

Devuelve una cadena que representa los elementos de la matriz especificada. Cada elemento de la matriz, 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().

Véase también

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 una matriz y devuelve la nueva longitud de la matriz. Los restantes elementos de la matriz se desplazan de su posición original, i, a i+1.

Parámetros

Véase también

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.

Véase también

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.

Véase también

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 matriz como una cadena de carácter y genera los resultados en orden Unicode.

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

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

El valor de esta constante es 16.

Véase también

Especifica que una ordenación devuelva una matriz formada por los índices de una matriz. 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 de la matriz mientas la matriz original permanece sin cambios.

El valor de esta constante es 8.

Véase también

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.

Véase también