| Paquete | Nivel superior |
| Clase | public dynamic class Array |
| Herencia | Array  Object |
| Versión del lenguaje: | ActionScript 3.0 |
| Versiones de motor de ejecución: | AIR 1.0, Flash Player 9, Flash Lite 4 |
[0], el segundo elemento, [1], y así sucesivamente. Para crear un objeto Array, deberá utilizar el constructor new Array(). Array() también puede invocarse como función. Además, puede utilizar el operador de acceso a un conjunto ([]) para inicializar un conjunto u obtener acceso a elementos de un conjunto.
Puede almacenar una amplia variedad de tipos de datos en un elemento de conjunto, incluidos números, cadenas, objetos e incluso otros conjuntos. Puede crear un conjunto multidimensional creando un conjunto indexado y asignando a cada uno de sus elementos un conjunto indexado distinto. Un conjunto de este tipo se considera multidimensional porque puede emplearse para representar datos en una tabla.
Los conjuntos son conjuntos dispersos, lo que significa que puede haber un elemento en el índice 0 y otro en el índice 5, pero nada en las posiciones de índice intermedias. En este caso, los elementos situados en las posiciones 1 a 4 son indefinidos, lo que indica la ausencia de un elemento, no necesariamente la presencia de un elemento con el valor undefined.
La asignación de conjunto se hace por referencia en lugar de por valor. Cuando se asigna una variable de conjunto a otra variable de conjunto, ambas hacen referencia al mismo conjunto:
var oneArray:Array = new Array("a", "b", "c");
var twoArray:Array = oneArray; // Both array variables refer to the same array.
twoArray[0] = "z";
trace(oneArray); // Output: z,b,c.
No utilice la clase Array para crear conjuntos asociativos (también conocidos como hashes), que son estructuras de datos que contienen elementos con nombre en lugar de elementos numerados. Para crear conjuntos asociativos, utilice la clase Object. Si bien ActionScript permite crear conjuntos asociativos empleando la clase Array, no es posible utilizar ninguno de los métodos o las propiedades de la clase Array con conjuntos asociativos.
Puede ampliar la clase Array y anular o añadir métodos. Sin embargo, debe especificar la subclase como dynamic o, de lo contrario, perderá la capacidad para almacenar datos en un conjunto.
Elementos de API relacionados
Ocultar propiedades públicas heredadas
Mostrar propiedades públicas heredadas| Propiedad | Definido por | ||
|---|---|---|---|
 | constructor : Object
Una referencia a la clase de objeto o función constructora para una instancia de objeto determinada. | Object | |
| length : uint
Entero no negativo que especifica el número de elementos del conjunto. | Array | ||
| Método | Definido por | ||
|---|---|---|---|
Le permite crear un conjunto con los elementos especificados. | Array | ||
Le permite crear un conjunto con el número especificado de elementos. | Array | ||
Concatena los elementos especificados en los parámetros con los elementos de un conjunto y crea un conjunto nuevo. | Array | ||
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. | Array | ||
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. | Array | ||
Ejecuta una función en cada elemento del conjunto. | Array | ||
|
Indica si un objeto tiene definida una propiedad especificada. | Object | |
Busca un elemento en un conjunto utilizando el operador de igualdad estricta (===) y devuelve la posición de índice del elemento. | Array | ||
Inserte un elemento individual en un conjunto. | Array | ||
|
Indica si hay una instancia de la clase Object en la cadena de prototipo del objeto especificado como parámetro. | Object | |
Convierte los elementos de un conjunto en cadenas, inserta el separador especificado entre los elementos, los concatena y devuelve la cadena resultante. | Array | ||
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 (===). | Array | ||
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. | Array | ||
Elimina el último elemento de un conjunto y devuelve el valor de dicho elemento. | Array | ||
|
Indica si existe la propiedad especificada y si es enumerable. | Object | |
Añade uno o varios elementos al final de un conjunto y devuelve la nueva longitud del conjunto. | Array | ||
Elimine un elemento individual de un conjunto. | Array | ||
Invierte la colocación del conjunto. | Array | ||
|
Establece la disponibilidad de una propiedad dinámica para operaciones de bucle. | Object | |
Elimina el primer elemento de un conjunto y devuelve dicho elemento. | Array | ||
Devuelve un conjunto nuevo que consta de un rango de elementos del conjunto original sin modificar el conjunto original. | Array | ||
Ejecuta una función de prueba en cada elemento del conjunto hasta que se llega a un elemento que devuelve true. | Array | ||
Ordena los elementos de un conjunto. | Array | ||
Ordena los elementos de un conjunto por uno o varios campos del conjunto. | Array | ||
Añade y elimina elementos de un conjunto. | Array | ||
Devuelve una cadena que representa los elementos del conjunto especificado. | Array | ||
Devuelve una cadena que representa los elementos del conjunto especificado. | Array | ||
Añade uno o varios elementos al comienzo de un conjunto y devuelve la nueva longitud del conjunto. | Array | ||
|
Devuelve el valor simple del objeto especificado. | Object | |
| Constante | Definido por | ||
|---|---|---|---|
| CASEINSENSITIVE : uint = 1 [estática]
Especifica una ordenación con distinción entre mayúsculas y minúsculas para los métodos de ordenación de la clase Array. | Array | ||
| DESCENDING : uint = 2 [estática]
Especifica una ordenación descendente para los métodos de ordenación de la clase Array. | Array | ||
| NUMERIC : uint = 16 [estática]
Especifica una ordenación numérica (en lugar de por cadena de caracteres) para los métodos de ordenación de la clase Array. | Array | ||
| RETURNINDEXEDARRAY : uint = 8 [estática]
Especifica que una ordenación devuelva un conjunto formado por los índices de un conjunto. | Array | ||
| UNIQUESORT : uint = 4 [estática]
Especifica el requisito de ordenación exclusivo para los métodos de ordenación de la clase Array. | Array | ||
length | propiedad |
length:uint| Versión del lenguaje: | ActionScript 3.0 |
| Versiones de motor de ejecución: | AIR 1.0, Flash Player 9, Flash Lite 4 |
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á.
Implementación
public function get length():uint public function set length(value:uint):voidEjemplo ( Cómo utilizar este ejemplo )
names con el elemento de cadena Bill. A continuación, utiliza el método push() para añadir otro elemento de cadena Kyle. La longitud del conjunto, tal como se determina con la propiedad length, era un elemento antes de utilizar push() y se convierte en dos elementos tras llamar a push(). Se añade otra cadena, Jeff, para que la longitud de names sea de tres elementos. A continuación, se llama dos veces al método shift() para eliminar Bill y Kyle, por lo que el conjunto final tiene una longitud length de uno.
var names:Array = new Array("Bill");
names.push("Kyle");
trace(names.length); // 2
names.push("Jeff");
trace(names.length); // 3
names.shift();
names.shift();
trace(names.length); // 1
Array | () | Información sobre |
public function Array(... values)| Versión del lenguaje: | ActionScript 3.0 |
| Versiones de motor de ejecución: | AIR 1.0, Flash Player 9, Flash Lite 4 |
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.
Parámetros... values — Una lista separada por comas de uno o más valores arbitrarios.
Nota: si sólo se pasa un parámetro numérico al constructor Array, se da por hecho que especifica la propiedad |
Emite
RangeError — El argumento es un número que no es un entero mayor o igual que 0.
|
Elementos de API relacionados
Ejemplo ( Cómo utilizar este ejemplo )
one, two y three y, seguidamente, se convierten los elementos en una cadena.
package {
import flash.display.Sprite;
public class Array_Array_3 extends Sprite {
public function Array_Array_3() {
var myArr:Array = new Array("one", "two", "three");
trace(myArr.length); // 3
trace(myArr); // one,two,three
}
}
}
Array | () | Información sobre |
public function Array(numElements:int = 0)| Versión del lenguaje: | ActionScript 3.0 |
| Versiones de motor de ejecución: | AIR 1.0, Flash Player 9, Flash Lite 4 |
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.
ParámetrosnumElements:int (default = 0) |
Emite
RangeError — El argumento es un número que no es un entero mayor o igual que 0.
|
Elementos de API relacionados
Ejemplo ( Cómo utilizar este ejemplo )
myArr sin argumentos y con una longitud inicial de 0:
package {
import flash.display.Sprite;
public class Array_Array extends Sprite {
public function Array_Array() {
var myArr:Array = new Array();
trace(myArr.length); // 0
}
}
}
"one" y se añade el elemento de cadena "six" al final del conjunto mediante el método push():
package {
import flash.display.Sprite;
public class Array_Array_2 extends Sprite {
public function Array_Array_2() {
var myArr:Array = new Array(5);
trace(myArr.length); // 5
myArr[0] = "one";
myArr.push("six");
trace(myArr); // one,,,,,six
trace(myArr.length); // 6
}
}
}
concat | () | método |
AS3 function concat(... args):Array| Versión del lenguaje: | ActionScript 3.0 |
| Versiones de motor de ejecución: | AIR 1.0, Flash Player 9, Flash Lite 4 |
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
... args — Un valor de cualquier tipo de datos (como números, elementos o cadenas) que se va a concatenar en un conjunto nuevo.
|
Array — Un conjunto que contiene los elementos de este conjunto seguidos de los elementos de los parámetros.
|
Ejemplo ( Cómo utilizar este ejemplo )
- El conjunto
numbers, que contiene los números1,2y3. - El conjunto
letters, que contiene las letrasa,byc. - El conjunto
numbersAndLetters, que llama al métodoconcat()para generar el conjunto[1,2,3,a,b,c]. - El conjunto
lettersAndNumbers, que llama al métodoconcat()para generar el conjunto[a,b,c,1,2,3].
var numbers:Array = new Array(1, 2, 3);
var letters:Array = new Array("a", "b", "c");
var numbersAndLetters:Array = numbers.concat(letters);
var lettersAndNumbers:Array = letters.concat(numbers);
trace(numbers); // 1,2,3
trace(letters); // a,b,c
trace(numbersAndLetters); // 1,2,3,a,b,c
trace(lettersAndNumbers); // a,b,c,1,2,3
every | () | método |
AS3 function every(callback:Function, thisObject:* = null):Boolean| Versión del lenguaje: | ActionScript 3.0 |
| Versiones de motor de ejecución: | AIR 1.0, Flash Player 9, Flash Lite 4 |
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
callback:Function — La función que se va a ejecutar en cada elemento del conjunto. Esta función puede contener una comparación simple (por ejemplo, item < 20) o una operación más compleja y se invoca con tres argumentos; el valor de un elemento, el índice de un elemento y el objeto Array:
function callback(item:*, index:int, array:Array):Boolean; | |
thisObject:* (default = null)this para la función.
|
Boolean — Se devuelve el valor booleano true si todos los elementos del conjunto devuelven true para la función especificada; en caso contrario, false.
|
Elementos de API relacionados
Ejemplo ( Cómo utilizar este ejemplo )
isNumeric es true para el primer conjunto y es false para el segundo:
package {
import flash.display.Sprite;
public class Array_every extends Sprite {
public function Array_every() {
var arr1:Array = new Array(1, 2, 4);
var res1:Boolean = arr1.every(isNumeric);
trace("isNumeric:", res1); // true
var arr2:Array = new Array(1, 2, "ham");
var res2:Boolean = arr2.every(isNumeric);
trace("isNumeric:", res2); // false
}
private function isNumeric(element:*, index:int, arr:Array):Boolean {
return (element is Number);
}
}
}
filter | () | método |
AS3 function filter(callback:Function, thisObject:* = null):Array| Versión del lenguaje: | ActionScript 3.0 |
| Versiones de motor de ejecución: | AIR 1.0, Flash Player 9, Flash Lite 4 |
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
callback:Function — La función que se va a ejecutar en cada elemento del conjunto. Esta función puede contener una comparación simple (por ejemplo, item < 20) o una operación más compleja y se invoca con tres argumentos; el valor de un elemento, el índice de un elemento y el objeto Array:
function callback(item:*, index:int, array:Array):Boolean; | |
thisObject:* (default = null)this para la función.
|
Array — Un nuevo conjunto que contiene todos los elementos del conjunto original que han devuelto true.
|
Elementos de API relacionados
Ejemplo ( Cómo utilizar este ejemplo )
package {
import flash.display.Sprite;
public class Array_filter extends Sprite {
public function Array_filter() {
var employees:Array = new Array();
employees.push({name:"Employee 1", manager:false});
employees.push({name:"Employee 2", manager:true});
employees.push({name:"Employee 3", manager:false});
trace("Employees:");
employees.forEach(traceEmployee);
var managers:Array = employees.filter(isManager);
trace("Managers:");
managers.forEach(traceEmployee);
}
private function isManager(element:*, index:int, arr:Array):Boolean {
return (element.manager == true);
}
private function traceEmployee(element:*, index:int, arr:Array):void {
trace("\t" + element.name + ((element.manager) ? " (manager)" : ""));
}
}
}
forEach | () | método |
AS3 function forEach(callback:Function, thisObject:* = null):void| Versión del lenguaje: | ActionScript 3.0 |
| Versiones de motor de ejecución: | AIR 1.0, Flash Player 9, Flash Lite 4 |
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
callback:Function — La función que se va a ejecutar en cada elemento del conjunto. Esta función puede contener un comando simple (por ejemplo, una sentencia trace()) o una operación más compleja y se invoca con tres argumentos; el valor de un elemento, el índice de un elemento y el objeto Array:
function callback(item:*, index:int, array:Array):void; | |
thisObject:* (default = null)this para la función.
|
Ejemplo ( Cómo utilizar este ejemplo )
trace() en la función traceEmployee() de cada elemento del conjunto:
package {
import flash.display.Sprite;
public class Array_forEach extends Sprite {
public function Array_forEach() {
var employees:Array = new Array();
employees.push({name:"Employee 1", manager:false});
employees.push({name:"Employee 2", manager:true});
employees.push({name:"Employee 3", manager:false});
trace(employees);
employees.forEach(traceEmployee);
}
private function traceEmployee(element:*, index:int, arr:Array):void {
trace(element.name + " (" + element.manager + ")");
}
}
}
trace() en una función traceEmployee() ligeramente modificada en cada elemento del conjunto:
package {
import flash.display.Sprite;
public class Array_forEach_2 extends Sprite {
public function Array_forEach_2() {
var employeeXML:XML = <employees>
<employee name="Steven" manager="false" />
<employee name="Bruce" manager="true" />
<employee name="Rob" manager="false" />
</employees>;
var employeesList:XMLList = employeeXML.employee;
var employeesArray:Array = new Array();
for each (var tempXML:XML in employeesList) {
employeesArray.push(tempXML);
}
employeesArray.sortOn("@name");
employeesArray.forEach(traceEmployee);
}
private function traceEmployee(element:*, index:Number, arr:Array):void {
trace(element.@name + ((element.@manager == "true") ? " (manager)" : ""));
}
}
}
indexOf | () | método |
AS3 function indexOf(searchElement:*, fromIndex:int = 0):int| Versión del lenguaje: | ActionScript 3.0 |
| Versiones de motor de ejecución: | AIR 1.0, Flash Player 9, Flash Lite 4 |
Busca un elemento en un conjunto utilizando el operador de igualdad estricta (===) y devuelve la posición de índice del elemento.
Parámetros
searchElement:* — El elemento que se va a buscar en el conjunto.
| |
fromIndex:int (default = 0) |
int — La posición de índice basada en cero del elemento en el conjunto. Si no se encuentra el argumento searchElement, el valor devuelto es -1.
|
Elementos de API relacionados
Ejemplo ( Cómo utilizar este ejemplo )
package {
import flash.display.Sprite;
public class Array_indexOf extends Sprite {
public function Array_indexOf() {
var arr:Array = new Array(123,45,6789);
arr.push("123-45-6789");
arr.push("987-65-4321");
var index:int = arr.indexOf("123");
trace(index); // -1
var index2:int = arr.indexOf(123);
trace(index2); // 0
}
}
}
insertAt | () | método |
AS3 function insertAt(index:int, element:*):void| Versión del lenguaje: | ActionScript 3.0 |
| Versiones de motor de ejecución: | Flash Player 19, AIR 19 |
Inserte un elemento individual en un conjunto. Este método modifica la matriz sin realizar ninguna copia de la misma.
Parámetros
index:int — Un entero que especifica la posición del conjunto en la que se va a insertar el elemento. Puede utilizar un entero negativo para especificar una posición relativa al final de la matriz (por ejemplo, -1 es el último elemento de la matriz).
| |
element:* |
join | () | método |
AS3 function join(sep:*):String| Versión del lenguaje: | ActionScript 3.0 |
| Versiones de motor de ejecución: | AIR 1.0, Flash Player 9, Flash Lite 4 |
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
sep:* (default = NaN) |
String — Una cadena formada por los elementos de un conjunto convertidos en cadenas y separados por el parámetro especificado.
|
Elementos de API relacionados
Ejemplo ( Cómo utilizar este ejemplo )
myArr con los elementos one, twoy three y, a continuación, una cadena que contiene one and two and three con el método join().
var myArr:Array = new Array("one", "two", "three");
var myStr:String = myArr.join(" and ");
trace(myArr); // one,two,three
trace(myStr); // one and two and three
specialChars con los elementos (, ), - y un espacio en blanco y, a continuación, crea una cadena que contiene (888) 867-5309. Después, utilizando un bucle for, elimina cada tipo de carácter especial de specialChars para generar una cadena (myStr) que contiene exclusivamente los dígitos del número de teléfono: 888675309. Tenga en cuenta que otros caracteres, como +, se podrían añadir a specialChars y esta rutina funcionaría con formatos de números de teléfono internacionales.
var phoneString:String = "(888) 867-5309";
var specialChars:Array = new Array("(", ")", "-", " ");
var myStr:String = phoneString;
var ln:uint = specialChars.length;
for(var i:uint; i < ln; i++) {
myStr = myStr.split(specialChars[i]).join("");
}
var phoneNumber:Number = new Number(myStr);
trace(phoneString); // (888) 867-5309
trace(phoneNumber); // 8888675309
lastIndexOf | () | método |
AS3 function lastIndexOf(searchElement:*, fromIndex:int = 0x7fffffff):int| Versión del lenguaje: | ActionScript 3.0 |
| Versiones de motor de ejecución: | AIR 1.0, Flash Player 9, Flash Lite 4 |
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
searchElement:* — El elemento que se va a buscar en el conjunto.
| |
fromIndex:int (default = 0x7fffffff)fromIndex, la búsqueda comenzará en el último elemento del conjunto.
|
int — La posición de índice basada en cero del elemento en el conjunto. Si no se encuentra el argumento searchElement, el valor devuelto es -1.
|
Elementos de API relacionados
Ejemplo ( Cómo utilizar este ejemplo )
package {
import flash.display.Sprite;
public class Array_lastIndexOf extends Sprite {
public function Array_lastIndexOf() {
var arr:Array = new Array(123,45,6789,123,984,323,123,32);
var index:int = arr.indexOf(123);
trace(index); // 0
var index2:int = arr.lastIndexOf(123);
trace(index2); // 6
}
}
}
map | () | método |
AS3 function map(callback:Function, thisObject:* = null):Array| Versión del lenguaje: | ActionScript 3.0 |
| Versiones de motor de ejecución: | AIR 1.0, Flash Player 9, Flash Lite 4 |
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
callback:Function — La función que se va a ejecutar en cada elemento del conjunto. Esta función puede contener un comando simple (por ejemplo, el cambio de mayúsculas a minúsculas y viceversa de un conjunto de cadenas) o una operación más compleja y se invoca con tres argumentos; el valor de un elemento, el índice de un elemento y el objeto Array:
function callback(item:*, index:int, array:Array):String; | |
thisObject:* (default = null)this para la función.
|
Array — Un nuevo conjunto que contiene los resultados de la función en cada elemento del conjunto original.
|
Elementos de API relacionados
Ejemplo ( Cómo utilizar este ejemplo )
package {
import flash.display.Sprite;
public class Array_map extends Sprite {
public function Array_map() {
var arr:Array = new Array("one", "two", "Three");
trace(arr); // one,two,Three
var upperArr:Array = arr.map(toUpper);
trace(upperArr); // ONE,TWO,THREE
}
private function toUpper(element:*, index:int, arr:Array):String {
return String(element).toUpperCase();
}
}
}
pop | () | método |
AS3 function pop():*| Versión del lenguaje: | ActionScript 3.0 |
| Versiones de motor de ejecución: | AIR 1.0, Flash Player 9, Flash Lite 4 |
Elimina el último elemento de un conjunto y devuelve el valor de dicho elemento.
Valor devuelto* — El valor del último elemento (de cualquier tipo de datos) del conjunto especificado.
|
Elementos de API relacionados
Ejemplo ( Cómo utilizar este ejemplo )
letters con los elementos a, b y c. El último elemento (c) se elimina del conjunto con el método pop() y se asigna al objeto String letter.
var letters:Array = new Array("a", "b", "c");
trace(letters); // a,b,c
var letter:String = letters.pop();
trace(letters); // a,b
trace(letter); // c
push | () | método |
AS3 function push(... args):uint| Versión del lenguaje: | ActionScript 3.0 |
| Versiones de motor de ejecución: | AIR 1.0, Flash Player 9, Flash Lite 4 |
Añade uno o varios elementos al final de un conjunto y devuelve la nueva longitud del conjunto.
Parámetros
... args — Uno o más valores que se añadirán al conjunto.
|
uint — Un entero que representa la longitud del nuevo conjunto.
|
Elementos de API relacionados
Ejemplo ( Cómo utilizar este ejemplo )
letters y llena el conjunto con los elementos a, b y c utilizando el método push().
var letters:Array = new Array();
letters.push("a");
letters.push("b");
letters.push("c");
trace(letters.toString()); // a,b,c
letters, que se llena inicialmente con el elemento a. Seguidamente, se utiliza el método push() una vez para añadir los elementos b y c al final del conjunto (tras el método push(), el conjunto tiene tres elementos).
var letters:Array = new Array("a");
var count:uint = letters.push("b", "c");
trace(letters); // a,b,c
trace(count); // 3
removeAt | () | método |
AS3 function removeAt(index:int):*| Versión del lenguaje: | ActionScript 3.0 |
| Versiones de motor de ejecución: | Flash Player 19, AIR 19 |
Elimine un elemento individual de un conjunto. Este método modifica la matriz sin realizar ninguna copia de la misma.
Parámetros
index:int — Un entero que especifica el índice del elemento del conjunto que se va a eliminar. Puede utilizar un entero negativo para especificar una posición relativa al final de la matriz (por ejemplo, -1 es el último elemento de la matriz).
|
* — El elemento que se eliminó del conjunto original.
|
reverse | () | método |
AS3 function reverse():Array| Versión del lenguaje: | ActionScript 3.0 |
| Versiones de motor de ejecución: | AIR 1.0, Flash Player 9, Flash Lite 4 |
Invierte la colocación del conjunto.
Valor devueltoArray — El nuevo conjunto.
|
Ejemplo ( Cómo utilizar este ejemplo )
letters con los elementos a, b y c. El orden de los elementos del conjunto se invierte con el método reverse() para generar el conjunto [c,b,a].
var letters:Array = new Array("a", "b", "c");
trace(letters); // a,b,c
letters.reverse();
trace(letters); // c,b,a
shift | () | método |
AS3 function shift():*| Versión del lenguaje: | ActionScript 3.0 |
| Versiones de motor de ejecución: | AIR 1.0, Flash Player 9, Flash Lite 4 |
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.
Valor devuelto* — El primer elemento (de cualquier tipo de datos) de un conjunto.
|
Elementos de API relacionados
Ejemplo ( Cómo utilizar este ejemplo )
letters con los elementos a, b y c. El método shift() se utiliza para eliminar el primer elemento (a) de letters y se asigna a la cadena firstLetter.
var letters:Array = new Array("a", "b", "c");
var firstLetter:String = letters.shift();
trace(letters); // b,c
trace(firstLetter); // a
slice | () | método |
AS3 function slice(startIndex:int = 0, endIndex:int = 16777215):Array| Versión del lenguaje: | ActionScript 3.0 |
| Versiones de motor de ejecución: | AIR 1.0, Flash Player 9, Flash Lite 4 |
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
startIndex:int (default = 0)startIndex es un número negativo, el punto inicial comenzará al final del conjunto, donde -1 es el último elemento.
| |
endIndex:int (default = 16777215)endIndex es un número negativo, el punto final se especificará desde el final del conjunto, donde -1 es el último elemento.
|
Array — Un conjunto que consta de un rango de elementos del conjunto original.
|
Ejemplo ( Cómo utilizar este ejemplo )
letters con los elementos [a,b,c,d,e,f]. Se crea el conjunto someLetters llamando al método slice() en los elementos del uno (b) al tres (d), lo que genera un conjunto con los elementos b y c.
var letters:Array = new Array("a", "b", "c", "d", "e", "f");
var someLetters:Array = letters.slice(1,3);
trace(letters); // a,b,c,d,e,f
trace(someLetters); // b,c
letters con los elementos [a,b,c,d,e,f]. A continuación, se crea el conjunto someLetters llamando al método slice() en el elemento dos (c), lo que genera un conjunto con los elementos [c,d,e,f].
var letters:Array = new Array("a", "b", "c", "d", "e", "f");
var someLetters:Array = letters.slice(2);
trace(letters); // a,b,c,d,e,f
trace(someLetters); // c,d,e,f
letters con los elementos [a,b,c,d,e,f]. A continuación, se crea el conjunto someLetters llamando al método slice() del segundo elemento hasta el último (e), lo que genera un conjunto con los elementos e y f.
var letters:Array = new Array("a", "b", "c", "d", "e", "f");
var someLetters:Array = letters.slice(-2);
trace(letters); // a,b,c,d,e,f
trace(someLetters); // e,f
some | () | método |
AS3 function some(callback:Function, thisObject:* = null):Boolean| Versión del lenguaje: | ActionScript 3.0 |
| Versiones de motor de ejecución: | AIR 1.0, Flash Player 9, Flash Lite 4 |
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
callback:Function — La función que se va a ejecutar en cada elemento del conjunto. Esta función puede contener una comparación simple (por ejemplo, item < 20) o una operación más compleja y se invoca con tres argumentos; el valor de un elemento, el índice de un elemento y el objeto Array:
function callback(item:*, index:int, array:Array):Boolean; | |
thisObject:* (default = null)this para la función.
|
Boolean — Se devuelve el valor booleano true si algún elemento del conjunto devuelve true para la función especificada; en caso contrario se devuelve false.
|
Elementos de API relacionados
Ejemplo ( Cómo utilizar este ejemplo )
package {
import flash.display.Sprite;
public class Array_some extends Sprite {
public function Array_some() {
var arr:Array = new Array();
arr[0] = "one";
arr[1] = "two";
arr[3] = "four";
var isUndef:Boolean = arr.some(isUndefined);
if (isUndef) {
trace("array contains undefined values: " + arr);
} else {
trace("array contains no undefined values.");
}
}
private function isUndefined(element:*, index:int, arr:Array):Boolean {
return (element == undefined);
}
}
}
sort | () | método |
AS3 function sort(... args):Array| Versión del lenguaje: | ActionScript 3.0 |
| Versiones de motor de ejecución: | AIR 1.0, Flash Player 9, Flash Lite 4 |
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
... args — Los argumentos que especifican una función de comparación y uno o más valores que determinan el comportamiento de la ordenación.
Este método utiliza la sintaxis y el orden de argumentos
|
Array — El valor devuelto depende de si pasa algún argumento, como se describe en la siguiente lista:
|
Elementos de API relacionados
Ejemplo ( Cómo utilizar este ejemplo )
vegetables con los elementos [spinach, green pepper, cilantro, onion, avocado]. A continuación, el conjunto se ordena utilizando el método sort(), al que se llama sin ningún parámetro. El resultado es el grupo vegetables ordenado alfabéticamente ([avocado, cilantro, green pepper, onion, spinach]).
var vegetables:Array = new Array("spinach",
"green pepper",
"cilantro",
"onion",
"avocado");
trace(vegetables); // spinach,green pepper,cilantro,onion,avocado
vegetables.sort();
trace(vegetables); // avocado,cilantro,green pepper,onion,spinach
vegetables con los elementos [spinach, green pepper, Cilantro, Onion, and Avocado]. El conjunto se ordena con el método sort(), al que se llama sin ningún parámetro la primera vez; el resultado es [Avocado,Cilantro,Onion,green pepper,spinach]. A continuación, se vuelve a llamar a sort() en vegetables con la constante CASEINSENSITIVE como parámetro. El resultado es el grupo vegetables ordenado alfabéticamente ([Avocado, Cilantro, green pepper, Onion, spinach]).
var vegetables:Array = new Array("spinach",
"green pepper",
"Cilantro",
"Onion",
"Avocado");
vegetables.sort();
trace(vegetables); // Avocado,Cilantro,Onion,green pepper,spinach
vegetables.sort(Array.CASEINSENSITIVE);
trace(vegetables); // Avocado,Cilantro,green pepper,Onion,spinach
vegetables, que luego se llena mediante cinco llamadas al método push(). Cada vez que se llama a push(), se crea un nuevo objeto Vegetable mediante una llamada al constructor Vegetable(), que acepta un objeto String (name) y un objeto Number (price). Al llamar a push() cinco veces con los valores mostrados se obtiene el siguiente conjunto: [lettuce:1.49, spinach:1.89, asparagus:3.99, celery:1.29, squash:1.44]. El método sort() se utiliza en ese momento para ordenar el conjunto y generar el siguiente conjunto [asparagus:3.99, celery:1.29, lettuce:1.49, spinach:1.89, squash:1.44].
var vegetables:Array = new Array();
vegetables.push(new Vegetable("lettuce", 1.49));
vegetables.push(new Vegetable("spinach", 1.89));
vegetables.push(new Vegetable("asparagus", 3.99));
vegetables.push(new Vegetable("celery", 1.29));
vegetables.push(new Vegetable("squash", 1.44));
trace(vegetables);
// lettuce:1.49, spinach:1.89, asparagus:3.99, celery:1.29, squash:1.44
vegetables.sort();
trace(vegetables);
// asparagus:3.99, celery:1.29, lettuce:1.49, spinach:1.89, squash:1.44
//The following code defines the Vegetable class
class Vegetable {
private var name:String;
private var price:Number;
public function Vegetable(name:String, price:Number) {
this.name = name;
this.price = price;
}
public function toString():String {
return " " + name + ":" + price;
}
}
sort() se utiliza con una función de ordenación personalizada (sortOnPrice) que realiza la ordenación según el precio, y no alfabéticamente. Observe que la nueva función getPrice() extrae el precio.
var vegetables:Array = new Array();
vegetables.push(new Vegetable("lettuce", 1.49));
vegetables.push(new Vegetable("spinach", 1.89));
vegetables.push(new Vegetable("asparagus", 3.99));
vegetables.push(new Vegetable("celery", 1.29));
vegetables.push(new Vegetable("squash", 1.44));
trace(vegetables);
// lettuce:1.49, spinach:1.89, asparagus:3.99, celery:1.29, squash:1.44
vegetables.sort(sortOnPrice);
trace(vegetables);
// celery:1.29, squash:1.44, lettuce:1.49, spinach:1.89, asparagus:3.99
function sortOnPrice(a:Vegetable, b:Vegetable):Number {
var aPrice:Number = a.getPrice();
var bPrice:Number = b.getPrice();
if(aPrice > bPrice) {
return 1;
} else if(aPrice < bPrice) {
return -1;
} else {
//aPrice == bPrice
return 0;
}
}
// The following code defines the Vegetable class and should be in a separate package.
class Vegetable {
private var name:String;
private var price:Number;
public function Vegetable(name:String, price:Number) {
this.name = name;
this.price = price;
}
public function getPrice():Number {
return price;
}
public function toString():String {
return " " + name + ":" + price;
}
}
numbers con los elementos [3,5,100,34,10]. Una llamada al método sort() sin ningún parámetro, ordenaría el grupo alfabéticamente y generaría un resultado no deseado [10,100,3,34,5]. Para ordenar correctamente los valores numéricos, se debe transferir la constante NUMERIC al método sort(), que ordena los objetos number del modo siguiente: [3,5,10,34,100].
Nota: el comportamiento predeterminado de la función sort() es gestionar cada entidad como una cadena. Si se utiliza el argumento Array.NUMERIC, el motor de ejecución de Flash intenta convertir los valores no numéricos en enteros para ordenarlos. Si falla, el motor de ejecución emite un error. Por ejemplo, el motor de ejecución puede convertir correctamente un valor de cadena de "6" en un entero, pero se emitirá un error si encuentra un valor de cadena de "seis".
var numbers:Array = new Array(3,5,100,34,10); trace(numbers); // 3,5,100,34,10 numbers.sort(); trace(numbers); // 10,100,3,34,5 numbers.sort(Array.NUMERIC); trace(numbers); // 3,5,10,34,100
sortOn | () | método |
AS3 function sortOn(fieldName:Object, options:Object = null):Array| Versión del lenguaje: | ActionScript 3.0 |
| Versiones de motor de ejecución: | AIR 1.0, Flash Player 9, Flash Lite 4 |
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
fieldName:Object — Una cadena que identifica un campo que se va a utilizar como valor de ordenación, o un conjunto en la cual el primer elemento representa el campo de ordenación principal, el segundo representa el campo de ordenación secundario, etc.
| |
options:Object (default = null)bitwise OR (|) (OR en modo bit) que cambian el comportamiento de la ordenación. Estos son los valores válidos del parámetro options:
Las sugerencias están activadas si se utiliza la forma de cadena del indicador (por ejemplo, |
Array — El valor devuelto depende de si se pasa algún parámetro:
|
Elementos de API relacionados
Ejemplo ( Cómo utilizar este ejemplo )
vegetables, que luego se llena mediante cinco llamadas al método push(). Cada vez que se llama a push(), se crea un nuevo objeto Vegetable mediante una llamada al constructor Vegetable(), que acepta un objeto String (name) y un objeto Number (price). Al llamar a push() cinco veces con los valores mostrados se obtiene el siguiente conjunto: [lettuce:1.49, spinach:1.89, asparagus:3.99, celery:1.29, squash:1.44]. Seguidamente, se utiliza el método sortOn() con el parámetro name para generar el siguiente conjunto: [asparagus:3.99, celery:1.29, lettuce:1.49, spinach:1.89, squash:1.44]. Se vuelve a llamar al método sortOn() con el parámetro price y con las constantes NUMERIC y DESCENDING para generar un conjunto ordenado numéricamente en orden descendente: [asparagus:3.99, spinach:1.89, lettuce:1.49, squash:1.44, celery:1.29].
var vegetables:Array = new Array();
vegetables.push(new Vegetable("lettuce", 1.49));
vegetables.push(new Vegetable("spinach", 1.89));
vegetables.push(new Vegetable("asparagus", 3.99));
vegetables.push(new Vegetable("celery", 1.29));
vegetables.push(new Vegetable("squash", 1.44));
trace(vegetables);
// lettuce:1.49, spinach:1.89, asparagus:3.99, celery:1.29, squash:1.44
vegetables.sortOn("name");
trace(vegetables);
// asparagus:3.99, celery:1.29, lettuce:1.49, spinach:1.89, squash:1.44
vegetables.sortOn("price", Array.NUMERIC | Array.DESCENDING);
trace(vegetables);
// asparagus:3.99, spinach:1.89, lettuce:1.49, squash:1.44, celery:1.29
class Vegetable {
public var name:String;
public var price:Number;
public function Vegetable(name:String, price:Number) {
this.name = name;
this.price = price;
}
public function toString():String {
return " " + name + ":" + price;
}
}
records, que luego se llena mediante tres llamadas al método push(). Cada vez que se llama a push(), las cadenas name y city y zip se añaden a records. Se usan tres bucles for para imprimir los elementos del conjunto. El primer bucle for imprime los elementos en el orden en que se han añadido. El segundo bucle for se ejecuta una vez ordenado records por nombre y, después, por ciudad utilizando el método sortOn(). El tercer bucle for genera un resultado distinto porque records se vuelve a ordenar primero por ciudad y luego por nombre.
var records:Array = new Array();
records.push({name:"john", city:"omaha", zip:68144});
records.push({name:"john", city:"kansas city", zip:72345});
records.push({name:"bob", city:"omaha", zip:94010});
for(var i:uint = 0; i < records.length; i++) {
trace(records[i].name + ", " + records[i].city);
}
// Results:
// john, omaha
// john, kansas city
// bob, omaha
trace("records.sortOn('name', 'city');");
records.sortOn(["name", "city"]);
for(var i:uint = 0; i < records.length; i++) {
trace(records[i].name + ", " + records[i].city);
}
// Results:
// bob, omaha
// john, kansas city
// john, omaha
trace("records.sortOn('city', 'name');");
records.sortOn(["city", "name"]);
for(var i:uint = 0; i < records.length; i++) {
trace(records[i].name + ", " + records[i].city);
}
// Results:
// john, kansas city
// bob, omaha
// john, omaha
users, que luego se llena mediante cuatro llamadas al método push(). Cada vez que se llama a push(), se crea un objeto User con el constructor User() y se añaden una cadena name y un objeto uint age a los usuarios. El conjunto resultante es [Bob:3,barb:35,abcd:3,catchy:4].
Seguidamente, el conjunto se ordena del modo siguiente:
- Sólo por nombre: se genera el conjunto
[Bob:3,abcd:3,barb:35,catchy:4] - Por nombre y utilizando la constante
CASEINSENSITIVE: se genera el conjunto[abcd:3,barb:35,Bob:3,catchy:4] - Por nombre y utilizando las constantes
CASEINSENSITIVEyDESCENDING: se genera el conjunto[catchy:4,Bob:3,barb:35,abcd:3] - Sólo por edad: se genera el conjunto
[abcd:3,Bob:3,barb:35,catchy:4] - Por edad y utilizando la constante
NUMERIC: se genera el conjunto[Bob:3,abcd:3,catchy:4,barb:35] - Por edad y utilizando las constantes
DESCENDINGyNUMERIC: se genera el conjunto[barb:35,catchy:4,Bob:3,abcd:3]
A continuación, se crea un conjunto llamado indices y se asignan los resultados de una ordenación por edad que utilice también las constantes NUMERIC y RETURNINDEXEDARRAY, lo que genera el conjunto [Bob:3,abcd:3,catchy:4,barb:35], que se imprime con un bucle for.
class User {
public var name:String;
public var age:Number;
public function User(name:String, age:uint) {
this.name = name;
this.age = age;
}
public function toString():String {
return this.name + ":" + this.age;
}
}
var users:Array = new Array();
users.push(new User("Bob", 3));
users.push(new User("barb", 35));
users.push(new User("abcd", 3));
users.push(new User("catchy", 4));
trace(users); // Bob:3,barb:35,abcd:3,catchy:4
users.sortOn("name");
trace(users); // Bob:3,abcd:3,barb:35,catchy:4
users.sortOn("name", Array.CASEINSENSITIVE);
trace(users); // abcd:3,barb:35,Bob:3,catchy:4
users.sortOn("name", Array.CASEINSENSITIVE | Array.DESCENDING);
trace(users); // catchy:4,Bob:3,barb:35,abcd:3
users.sortOn("age");
trace(users); // abcd:3,Bob:3,barb:35,catchy:4
users.sortOn("age", Array.NUMERIC);
trace(users); // Bob:3,abcd:3,catchy:4,barb:35
users.sortOn("age", Array.DESCENDING | Array.NUMERIC);
trace(users); // barb:35,catchy:4,Bob:3,abcd:3
var indices:Array = users.sortOn("age", Array.NUMERIC | Array.RETURNINDEXEDARRAY);
var index:uint;
for(var i:uint = 0; i < indices.length; i++) {
index = indices[i];
trace(users[index].name, ": " + users[index].age);
}
// Results:
// Bob : 3
// abcd : 3
// catchy : 4
// barb : 35
splice | () | método |
AS3 function splice(startIndex:int, deleteCount:uint, ... values):Array| Versión del lenguaje: | ActionScript 3.0 |
| Versiones de motor de ejecución: | AIR 1.0, Flash Player 9, Flash Lite 4 |
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
startIndex:int — Un entero que especifica el índice del elemento del conjunto donde comienza la inserción o eliminación. Puede utilizar un entero negativo para especificar una posición relativa al final de la matriz (por ejemplo, -1 es el último elemento de la matriz).
| |
deleteCount:uint — Un entero que especifica el número de elementos que se van a eliminar. Este número incluye el elemento especificado en el parámetro startIndex. Si no especifica ningún valor para el parámetro deleteCount, el método eliminará todos los valores desde el elemento startIndex hasta el último elemento del conjunto. Si el valor es 0, no se eliminará ningún elemento.
| |
... values — Una lista opcional de uno o varios valores separados por comas que se va a insertar en el conjunto en la posición especificada en el parámetro startIndex. Si un valor insertado es de tipo Array, el conjunto se mantiene intacto y se inserta como un elemento individual. Por ejemplo, si divide un conjunto existente de longitud tres con otro conjunto de longitud tres, el conjunto resultante sólo tendrá cuatro elementos. Uno de los elementos, sin embargo, será un conjunto de longitud tres.
|
Array — Un conjunto que contiene los elementos eliminados del conjunto original.
|
Ejemplo ( Cómo utilizar este ejemplo )
vegetables con los elementos [spinach, green pepper, cilantro, onion, avocado]. A continuación, se llama al método splice() con los parámetros 2 y 2, con lo que se asigna cilantro y onion al conjunto spliced. El conjunto vegetables contiene en ese momento [spinach,green pepper,avocado]. Se llama al método splice() por segunda vez con los parámetros 1, 0 y al conjunto spliced para asignar [cilantro,onion] como el segundo elemento de vegetables.
var vegetables:Array = new Array("spinach",
"green pepper",
"cilantro",
"onion",
"avocado");
var spliced:Array = vegetables.splice(2, 2);
trace(vegetables); // spinach,green pepper,avocado
trace(spliced); // cilantro,onion
vegetables.splice(1, 0, spliced);
trace(vegetables); // spinach,cilantro,onion,green pepper,avocado
cilantro y onion se trazan como si vegetables tuviera 5 elementos, aunque en realidad tenga cuatro (y el segundo elemento sea otro conjunto que contiene dos elementos). Para añadir cilantro y onion por separado, se haría lo siguiente:
var vegetables:Array = new Array("spinach",
"green pepper",
"cilantro",
"onion",
"avocado");
var spliced:Array = vegetables.splice(2, 2);
trace(vegetables); // spinach,green pepper,avocado
trace(spliced); // cilantro,onion
vegetables.splice(1, 0, "cilantro", "onion");
trace(vegetables); // spinach,cilantro,onion,green pepper,avocado
toLocaleString | () | método |
public function toLocaleString():String| Versión del lenguaje: | ActionScript 3.0 |
| Versiones de motor de ejecución: | AIR 1.0, Flash Player 9, Flash Lite 4 |
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().
String — Una cadena de elementos de conjunto.
|
Elementos de API relacionados
toString | () | método |
public function toString():String| Versión del lenguaje: | ActionScript 3.0 |
| Versiones de motor de ejecución: | AIR 1.0, Flash Player 9, Flash Lite 4 |
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().
String — Una cadena de elementos de conjunto.
|
Elementos de API relacionados
Ejemplo ( Cómo utilizar este ejemplo )
vegnums del tipo de datos String.
var vegetables:Array = new Array(); vegetables.push(1); vegetables.push(2); vegetables.push(3); vegetables.push(4); vegetables.push(5); var vegnums:String = vegetables.toString(); trace(vegnums+",6"); // 1,2,3,4,5,6
unshift | () | método |
AS3 function unshift(... args):uint| Versión del lenguaje: | ActionScript 3.0 |
| Versiones de motor de ejecución: | AIR 1.0, Flash Player 9, Flash Lite 4 |
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
... args — Uno o más números, elementos o variables que se insertarán al principio del conjunto.
|
uint — Un entero que representa la nueva longitud del conjunto.
|
Elementos de API relacionados
Ejemplo ( Cómo utilizar este ejemplo )
names. Las cadenas Bill y Jeff se añaden utilizando el método push() y, después, las cadenas Alfred y Kyle se añaden al principio de names mediante dos llamadas al método unshift().
var names:Array = new Array();
names.push("Bill");
names.push("Jeff");
trace(names); // Bill,Jeff
names.unshift("Alfred");
names.unshift("Kyle");
trace(names); // Kyle,Alfred,Bill,Jeff
CASEINSENSITIVE | Constante |
public static const CASEINSENSITIVE:uint = 1| Versión del lenguaje: | ActionScript 3.0 |
| Versiones de motor de ejecución: | AIR 1.0, Flash Player 9, Flash Lite 4 |
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
DESCENDING | Constante |
public static const DESCENDING:uint = 2| Versión del lenguaje: | ActionScript 3.0 |
| Versiones de motor de ejecución: | AIR 1.0, Flash Player 9, Flash Lite 4 |
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
NUMERIC | Constante |
public static const NUMERIC:uint = 16| Versión del lenguaje: | ActionScript 3.0 |
| Versiones de motor de ejecución: | AIR 1.0, Flash Player 9, Flash Lite 4 |
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
RETURNINDEXEDARRAY | Constante |
public static const RETURNINDEXEDARRAY:uint = 8| Versión del lenguaje: | ActionScript 3.0 |
| Versiones de motor de ejecución: | AIR 1.0, Flash Player 9, Flash Lite 4 |
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
UNIQUESORT | Constante |
public static const UNIQUESORT:uint = 4| Versión del lenguaje: | ActionScript 3.0 |
| Versiones de motor de ejecución: | AIR 1.0, Flash Player 9, Flash Lite 4 |
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
myArr sin argumentos y con una longitud inicial de 0:
package {
import flash.display.Sprite;
public class ArrayExample extends Sprite {
public function ArrayExample() {
var myArr:Array = new Array();
trace(myArr.length); // 0
}
}
}
Tue Jun 12 2018, 02:12 PM Z