Matrices indexadas -- Flash CS3

Las matrices indexadas almacenan una serie de uno o más valores organizados de forma que se pueda acceder a cada valor mediante un valor entero sin signo. El primer número de índice siempre es 0 y aumenta una unidad por cada elemento que se añada a la matriz. Como muestra el código siguiente, una matriz indexada se crea llamando al constructor de la clase Array o inicializando la matriz con un literal de matriz:

// Utilizar constructor de matriz.
var myArray:Array = new Array();
myArray.push("one");
myArray.push("two");
myArray.push("three");
trace(myArray); // salida: one,two,three

// Utilizar un literal de matriz.
var myArray:Array = ["one", "two", "three"];
trace(myArray); // salida: one,two,three

La clase Array también contiene propiedades y métodos que permiten modificar matrices indexadas. Estas propiedades y métodos se aplican casi de forma exclusiva a matrices indexadas en lugar de a matrices asociativas.

Las matrices indexadas usan un entero de 32 bits sin signo como número de índice. El tamaño máximo de una matriz indexada es 2³² - 1 ó 4.294.967.295. Si se intenta crear una matriz de tamaño superior al tamaño máximo, se producirá un error en tiempo de ejecución.

Un elemento de matriz puede contener un valor de cualquier tipo de datos. ActionScript 3.0 no incorpora el concepto de matrices con tipo, por lo que no es posible especificar que todos los elementos de una matriz pertenecen a un tipo de datos específico.

En esta sección se explica la manera de crear y modificar matrices indexadas con la clase Array, empezando por la creación de una matriz. Los métodos que modifican matrices se clasifican en tres categorías que cubren la forma de insertar elementos, eliminar elementos y ordenar matrices. Los métodos de un grupo final tratan una matriz existente como de sólo lectura; estos métodos simplemente consultan matrices. Los métodos de consulta devuelven una nueva matriz, en lugar de modificar una matriz existente. La sección concluye con una descripción de la manera de ampliar la clase Array.

Subtemas

Creación de matrices

La función constructora de Array se puede utilizar de tres maneras distintas. En primer lugar, si se llama al constructor sin argumentos, se obtiene una matriz vacía. Se puede utilizar la propiedad length de la clase Array para comprobar que la matriz no tiene elementos. Por ejemplo, el código siguiente llama al constructor de Array sin argumentos:

var names:Array = new Array();
trace(names.length); // salida: 0

En segundo lugar, si se utiliza un número como único parámetro del constructor de Array, se crea una matriz de esa longitud y se establece el valor de cada elemento en undefined. El argumento debe ser un entero sin signo entre 0 y 4.294.967.295. Por ejemplo, el código siguiente llama al constructor de Array con un solo argumento numérico:

var names:Array = new Array(3);
trace(names.length); // salida: 3
trace(names[0]); // salida: undefined
trace(names[1]); // salida: undefined
trace(names[2]); // salida: undefined

En tercer lugar, si se llama al constructor y se le pasa una lista de elementos como parámetros, se crea una matriz con elementos correspondientes a cada uno de los parámetros. El código siguiente pasa tres argumentos al constructor de Array:

var names:Array = new Array("John", "Jane", "David");
trace(names.length); // salida: 3
trace(names[0]); // salida: John
trace(names[1]); // salida: Jane
trace(names[2]); // salida: David

También se pueden crear matrices con literales de matriz o literales de objeto. Un literal de matriz se puede asignar directamente a una variable de tipo matriz, como se indica en el siguiente ejemplo:

var names:Array = ["John", "Jane", "David"];

Inserción de elementos de matriz

Tres de los métodos de la clase Array (push(), unshift() y splice()) permiten insertar elementos en una matriz. El método push() añade uno o más elementos al final de una matriz. Es decir, el último elemento insertado en la matriz mediante el método push() tendrá el número de índice más alto. El método unshift() inserta uno o más elementos al principio de una matriz, que siempre tiene el número de índice 0. El método splice() insertará un número arbitrario de elementos en un índice especificado de la matriz.

En el ejemplo siguiente se ilustran los tres métodos. Se crea una matriz denominada planets para almacenar los nombres de los planetas por su orden de proximidad al sol. En primer lugar se llama al método push() para añadir el elemento inicial, Mars. En segundo lugar, se llama al método unshift() para insertar el elemento que debe estar al principio de la matriz, Mercury. Por último, se llama al método splice() para insertar los elementos Venus y Earth a continuación de Mercury, pero antes de Mars. El primer argumento enviado a splice(), el entero 1, dirige la inserción para que se realice en el número de índice 1. El segundo argumento enviado a splice(), el entero 0, indica que no se debe eliminar ningún elemento. Por último, el tercer y el cuarto argumento enviados a splice(), Venus y Earth son los elementos que se van a insertar.

var planets:Array = new Array();
planets.push("Mars");       // contenido de la matriz: Mars
planets.unshift("Mercury"); // contenido de la matriz: Mercury,Mars
planets.splice(1, 0, "Venus", "Earth");
trace(planets);             // contenido de la matriz: Mercury,Venus,Earth,Mars

Los métodos push() y unshift() devuelven un entero sin signo que representa la longitud de la matriz modificada. El método splice() devuelve una matriz vacía cuando se utiliza para insertar elementos, algo que puede parecer extraño, pero que tiene sentido si se tiene en cuenta la versatilidad que ofrece dicho método. Se puede utilizar el método splice() no sólo para insertar elementos en una matriz, sino también para eliminar elementos de una matriz. Cuando se utiliza para eliminar elementos, el método splice() devuelve una matriz que contiene los elementos eliminados.

Eliminación de elementos de matriz

Tres de los métodos de la clase Array (pop(), shift() y splice()) permiten eliminar elementos de una matriz. El método pop() elimina un elemento del final de la matriz. Es decir, elimina el elemento que tenga el número de índice más alto. El método shift() elimina un elemento del principio de la matriz, lo que significa que siempre elimina el elemento con el número de índice 0. El método splice(), que también se puede utilizar para insertar elementos, elimina un número arbitrario de elementos empezando por el que tiene el número de índice especificado por el primer argumento enviado al método.

En el ejemplo siguiente se utilizan los tres métodos para eliminar elementos de una matriz. Se crea una matriz denominada oceans para almacenar los nombres de grandes masas de agua. Algunos de los nombres de la matriz son lagos, no océanos, por lo que hay que eliminarlos.

En primer lugar, se utiliza el método splice() para eliminar los elementos Aral y Superior, e insertar los elementos Atlantic e Indian. El primer argumento enviado a splice(), el entero 2, indica que la operación debe empezar por el tercer elemento de la lista, que tiene el índice 2. El segundo argumento, 2, indica que hay que eliminar dos elementos. Los restantes argumentos, Atlantic e Indian, son valores que deben insertarse a partir del índice 2.

En segundo lugar, se utiliza el método pop() para eliminar el último elemento de la matriz, Huron. Y por último, se utiliza el método shift() para eliminar el primer elemento de la matriz, Victoria.

var oceans:Array = ["Victoria", "Pacific", "Aral", "Superior", "Indian", "Huron"];
oceans.splice(2, 2, "Arctic", "Atlantic"); // sustituye Aral y Superior
oceans.pop();   // elimina Huron
oceans.shift(); // elimina Victoria
trace(oceans);  // salida: Pacific,Arctic,Atlantic,Indian

Los métodos pop() y shift() devuelven el elemento eliminado. El tipo de datos del valor devuelto es Object, ya que las matrices pueden contener valores de cualquier tipo de datos. El método splice() devuelve una matriz que contiene los valores eliminados. Se puede modificar el ejemplo de la matriz oceans de forma que la llamada a splice() asigne la matriz a una nueva variable de matriz, como se indica en el siguiente ejemplo:

var lakes:Array = oceans.splice(2, 2, "Arctic", "Atlantic");
trace(lakes); // salida: Aral,Superior

Es posible encontrar código que utilice el operador delete en un elemento de matriz. El operador delete establece el valor de un elemento de matriz en undefined, pero no elimina el elemento de la matriz. Por ejemplo, el código siguiente utiliza el operador delete en el tercer elemento de la matriz oceans, pero la longitud de la matriz sigue siendo 5:

var oceans:Array = ["Arctic", "Pacific", "Victoria", "Indian", "Atlantic"];
delete oceans[2];
trace(oceans);        // salida: Arctic,Pacific,,Indian,Atlantic
trace(oceans[2]);     // salida: undefined
trace(oceans.length); // salida: 5

Se puede utilizar la propiedad length de una matriz para truncarla. Si se establece la propiedad length de una matriz en una longitud inferior a la longitud actual de la matriz, se trunca la matriz, eliminándose los elementos almacenados en números de índice mayores que el nuevo valor de length menos 1. Por ejemplo, si se ordena la matriz oceans de forma que todas las entradas válidas estén al principio de la matriz, se puede utilizar la propiedad length para eliminar las entradas del final de la matriz, como se indica en el código siguiente:

var oceans:Array = ["Arctic", "Pacific", "Victoria", "Aral", "Superior"];
oceans.length = 2;
trace(oceans); // salida: Arctic,Pacific

Ordenación de una matriz

Hay tres métodos, reverse(), sort() y sortOn(), que permiten cambiar el orden de una matriz, ordenando o invirtiendo el orden. Todos estos métodos modifican la matriz existente. El método reverse() cambia el orden de la matriz de forma que el último elemento se convierte en el primero, el penúltimo elemento se convierte en el segundo, etc. El método sort() permite ordenar una matriz de diversas maneras predefinidas e incluso crear algoritmos de ordenación personalizados. El método sortOn() permite ordenar una matriz indexada de objetos con una o más propiedades comunes que se pueden utilizar como criterios de ordenación.

El método reverse() no admite parámetros y no devuelve un valor, pero permite alternar el orden de la matriz de su estado actual al orden inverso. El ejemplo siguiente invierte el orden de los océanos que se muestra en la matriz oceans:

var oceans:Array = ["Arctic", "Atlantic", "Indian", "Pacific"];
oceans.reverse();
trace(oceans); // salida: Pacific,Indian,Atlantic,Arctic

El método sort() reorganiza los elementos de una matriz con el orden de clasificación predeterminado. El orden de clasificación predeterminado tiene las siguientes características:

A veces hay que ordenar la matriz sin tener en cuenta mayúsculas o minúsculas, o en orden descendente, o si la matriz contiene números hay que ordenar numéricamente en lugar de alfabéticamente. El método sort() tiene un parámetro options que permite modificar todas las características del orden de clasificación predeterminado. Las opciones se definen mediante un conjunto de constantes estáticas de la clase Array, como se indica en la lista siguiente:

En el ejemplo siguiente se ilustran algunas de estas opciones. Se crea una matriz denominada poets que se ordena con varias opciones distintas.

var poets:Array = ["Blake", "cummings", "Angelou", "Dante"];
poets.sort(); // ordenación predeterminada
trace(poets); // salida: Angelou,Blake,Dante,cummings

poets.sort(Array.CASEINSENSITIVE);
trace(poets); // salida: Angelou,Blake,cummings,Dante

poets.sort(Array.DESCENDING);
trace(poets); // salida: cummings,Dante,Blake,Angelou

poets.sort(Array.DESCENDING | Array.CASEINSENSITIVE); // utilizar dos opciones
trace(poets); // salida: Dante,cummings,Blake,Angelou

También se puede escribir una función de ordenación personalizada, que se puede pasar como parámetro al método sort(). Por ejemplo, si se tiene una lista de nombres en la que cada elemento de la lista contiene el nombre completo de una persona, pero se desea ordenar la lista por apellido, hay que utilizar una función de ordenación personalizada que analice cada elemento y use el apellido en la función de ordenación. El código siguiente muestra cómo se puede hacer esto con una función personalizada que se utiliza como parámetro del método Array.sort():

var names:Array = new Array("John Q. Smith", "Jane Doe", "Mike Jones");
function orderLastName(a, b):int
{
    var lastName:RegExp = /\b\S+$/;
    var name1 = a.match(lastName);
    var name2 = b.match(lastName);
    if (name1 < name2)
    {
        return -1;
    }
    else if (name1 > name2)
    {
        return 1;
    }
    else
    {
        return 0;
    }
}
trace(names); // salida: John Q. Smith,Jane Doe,Mike Jones
names.sort(orderLastName);
trace(names); // salida: Jane Doe,Mike Jones,John Q. Smith

La función de ordenación personalizada orderLastName() utiliza una expresión regular para extraer el apellido de cada elemento que se va a utilizar para la operación de comparación. Se utiliza el identificador de la función orderLastName como único parámetro al llamar al método sort() de la matriz names. La función de ordenación acepta dos parámetros, a y b, ya que procesa dos elementos de matriz cada vez. El valor devuelto por la función de ordenación indica cómo deben ordenarse los elementos:

El método sortOn() está diseñado para matrices indexadas con elementos que contienen objetos. Se espera que estos objetos tengan al menos una propiedad en común que se pueda utilizar como criterio de ordenación. El uso del método sortOn() en matrices de cualquier otro tipo puede producir resultados inesperados.

El ejemplo siguiente revisa la matriz poets de forma que cada elemento sea un objeto en lugar de una cadena. Cada objeto contiene el apellido del poeta y el año de nacimiento.

var poets:Array = new Array();
poets.push({name:"Angelou", born:"1928"});
poets.push({name:"Blake", born:"1757"});
poets.push({name:"cummings", born:"1894"});
poets.push({name:"Dante", born:"1265"});
poets.push({name:"Wang", born:"701"});

Se puede utilizar el método sortOn() para ordenar la matriz por la propiedad born. El método sortOn() define dos parámetros, fieldName y options. El argumento fieldName debe especificarse como una cadena. En el ejemplo siguiente, se llama a sortOn() con dos argumentos, "born" y Array.NUMERIC. Se utiliza el argumento Array.NUMERIC para asegurarse de que la ordenación se realiza numéricamente en lugar de alfabéticamente. Esto es una práctica recomendable, incluso en el caso de que todos los números tengan el mismo número de dígitos, ya que garantiza que la ordenación seguirá comportándose de la manera esperada si posteriormente se añade un número con menos (o más) dígitos a la matriz.

poets.sortOn("born", Array.NUMERIC);
for (var i:int = 0; i < poets.length; ++i)
{
    trace(poets[i].name, poets[i].born);
}
/* salida:
Wang 701
Dante 1265
Blake 1757
cummings 1894
Angelou 1928
*/

Generalmente, los métodos sort() y sortOn() modifican una matriz. Si se desea ordenar una matriz sin modificarla, se debe pasar la constante Array.RETURNINDEXEDARRAY como parte del parámetro options. Esta opción ordena a los métodos que devuelvan una nueva matriz que refleje la ordenación y deje la matriz original sin cambios. La matriz devuelta por los métodos es una matriz simple de números de índice que refleja el nuevo orden de clasificación y no contiene ningún elemento de la matriz original. Por ejemplo, para ordenar la matriz poets por año de nacimiento sin modificar la matriz, se debe incluir la constante Array.RETURNINDEXEDARRAY como parte del argumento pasado para el parámetro options.

El ejemplo siguiente almacena la información de índice devuelta en una matriz denominada indices y utiliza la matriz indices junto con la matriz poets sin modificar para mostrar los poetas ordenados por año de nacimiento:

var indices:Array;
indices = poets.sortOn("born", Array.NUMERIC | Array.RETURNINDEXEDARRAY);
for (var i:int = 0; i < indices.length; ++i)
{
    var index:int = indices[i];
    trace(poets[index].name, poets[index].born);
}
/* salida:
Wang 701
Dante 1265
Blake 1757
cummings 1894
Angelou 1928
*/

Realización de consultas en una matriz

Los cuatro métodos restantes de la clase Array, concat(), join(), slice() y toString(), consultan la matriz para obtener información, pero no la modifican. Los métodos concat() y slice() devuelven matrices nuevas, mientras que los métodos join() y toString() devuelven cadenas. El método concat() requiere una nueva matriz o lista de elementos como argumentos, y los combina con la matriz existente para crear una nueva matriz. El método slice() tiene dos parámetros, denominados startIndex y endIndex, y devuelve una nueva matriz que contiene una copia de los elementos "extraídos" de la matriz existente. Se empieza por extraer el elemento con índice startIndex y el último elemento extraído es el que tiene el índice inmediatamente anterior a endIndex. Es importante recordar que el elemento con índice endIndex no se incluye en el valor devuelto.

En el ejemplo siguiente se utilizan concat() y slice() para crear matrices nuevas a partir de elementos de otras matrices:

var array1:Array = ["alpha", "beta"];
var array2:Array = array1.concat("gamma", "delta");
trace(array2); // salida: alpha,beta,gamma,delta

var array3:Array = array1.concat(array2);
trace(array3); // salida: alpha,beta,alpha,beta,gamma,delta

var array4:Array = array3.slice(2,5);
trace(array4); // salida: alpha,beta,gamma

Se pueden utilizar los métodos join() y toString() para consultar la matriz y devolver su contenido en forma de cadena. Si no se utiliza ningún parámetro para el método join(), los dos métodos se comportarán de forma idéntica: devolverán una cadena que contiene una lista delimitada por comas de todos los elementos de la matriz. El método join(), a diferencia del método toString(), admite un parámetro denominado delimiter, que permite elegir el símbolo que se debe utilizar como separador entre cada elemento de la cadena devuelta.

En el ejemplo siguiente se crea una matriz denominada rivers y se llama a join() y toString() para devolver los valores de la matriz en forma de cadena. El método toString() se utiliza para devolver valores separados por comas (riverCSV), mientras que el método join() se utiliza para devolver valores separados por el carácter +.

var rivers:Array = ["Nile", "Amazon", "Yangtze", "Mississippi"];
var riverCSV:String = rivers.toString();
trace(riverCSV); // salida: Nile,Amazon,Yangtze,Mississippi
var riverPSV:String = rivers.join("+");
trace(riverPSV); // salida: Nile+Amazon+Yangtze+Mississippi

Una característica del método join() que hay tener en cuenta es que las matrices anidadas siempre se devuelven con los valores separados por comas, independientemente del separador que se especifique para los elementos de la matriz principal, como se indica en el siguiente ejemplo:

var nested:Array = ["b","c","d"];      
var letters:Array = ["a",nested,"e"]; 
var joined:String = letters.join("+");
trace(joined); // salida: a+b,c,d+e