Conjuntos indexados

Se pueden utilizar diversas técnicas para crear una instancia de Array o una instancia de Vector. No obstante, las técnicas para crear cada tipo de conjunto son ligeramente distintas.

La forma más sencilla de añadir un elemento a un conjunto indexado es utilizar el operador de acceso a conjunto ( [] ). Para establecer el valor de un elemento de conjunto indexado, utilice el nombre del objeto Array o Vector y el número de índice situado a la izquierda de una sentencia de asignación:

songTitles[5] = "Happy Birthday";

Si el objeto Array o Vector no tiene aún ningún elemento en ese índice, este se crea y se almacena el valor en él. Si ya existe un valor en el índice, el nuevo valor sustituye al existente.

Un objeto Array permite crear un elemento en cualquier índice. Sin embargo, con un objeto Vector solo es posible asignar un valor a un índice existente o al siguiente índice disponible. El siguiente índice disponible corresponde a la propiedad length del objeto Vector. El modo más seguro de añadir un nuevo elemento a un objeto Vector es utilizar un código como el siguiente:

myVector[myVector.length] = valueToAdd;

Tres de los métodos de la clase Array y Vector ( push() , unshift() y splice() ) permiten insertar elementos en un conjunto indexado. El método push() añade uno o varios elementos al final de un conjunto. Es decir, el último elemento insertado en el conjunto 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 un conjunto, que siempre tiene el número de índice 0. El método splice() insertará un número arbitrario de elementos en un índice especificado del conjunto.

En el ejemplo siguiente se ilustran los tres métodos. Un conjunto denominado planets se crea para almacenar los nombres de los planetas en orden de proximidad al sol. En primer lugar, se llama al método push() para agregar el elemento inicial, Mars . En segundo lugar, se llama al método unshift() para insertar el elemento que debe estar al principio del conjunto, 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"); // array contents: Mars 
planets.unshift("Mercury"); // array contents: Mercury,Mars 
planets.splice(1, 0, "Venus", "Earth"); 
trace(planets); // array contents: Mercury,Venus,Earth,Mars

Los métodos push() y unshift() devuelven un entero sin signo que representa la longitud del conjunto modificado. El método splice() devuelve un conjunto vacío 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 splice() . Se puede utilizar el método splice() no solo para insertar elementos en un conjunto, sino también para eliminar elementos de un conjunto. Cuando se utiliza para eliminar elementos, el método splice() devuelve un conjunto que contiene los elementos eliminados.

El modo más sencillo de recuperar el valor de un elemento en un conjunto indexado es utilizar el operador de acceso a conjunto ( [] ). Para recuperar el valor de un elemento de conjunto indexado, utilice el nombre del objeto Array o Vector y el número de índice situado a la derecha de una sentencia de asignación:

var myFavoriteSong:String = songTitles[3];

Se puede intentar recuperar un valor de un objeto Array o Vector utilizando un índice en el que no exista ningún elemento. En ese caso, un objeto Array devuelve el valor undefined y un objeto Vector emite una excepción RangeError.

Tres métodos de las clases Array y Vector ( pop() , shift() y splice() ) permiten eliminar elementos. El método pop() elimina un elemento del final del conjunto. Es decir, elimina el elemento que tenga el número de índice más alto. El método shift() elimina un elemento del principio del conjunto, 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 instancia de Array. Se crea un conjunto denominado oceans para almacenar los nombres de grandes masas de agua. Algunos de los nombres del conjunto 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 del conjunto, Huron . Y por último, se utiliza el método shift() para eliminar el primer elemento del conjunto, Victoria .

var oceans:Array = ["Victoria", "Pacific", "Aral", "Superior", "Indian", "Huron"]; 
oceans.splice(2, 2, "Arctic", "Atlantic"); // replaces Aral and Superior 
oceans.pop(); // removes Huron 
oceans.shift(); // removes Victoria 
trace(oceans);// output: Pacific,Arctic,Atlantic,Indian

Los métodos pop() y shift() devuelven el elemento eliminado. En una instancia de Array, el tipo de datos del valor devuelto es Object, ya que los conjuntos pueden contener valores de cualquier tipo de datos. En una instancia de Vector, el tipo de datos del valor es el tipo base del vector. El método splice() devuelve un objeto Array o Vector que contiene los valores eliminados. Se puede modificar el ejemplo del conjunto oceans de forma que la llamada a splice() asigne el conjunto devuelto a una nueva variable de Array, como se indica en el siguiente ejemplo:

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

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

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

Se puede utilizar la propiedad length de un conjunto para truncar un objeto Array o Vector. Si se establece la propiedad length de un conjunto indexado como una longitud inferior a la longitud actual del conjunto, este se trunca y se eliminan todos los valores almacenados en los números de índice superiores al nuevo valor de length menos 1. Por ejemplo, si el conjunto oceans se ordena de modo que todas las entradas válidas están al principio del conjunto, se puede utilizar la propiedad length para eliminar las entradas situadas al final, tal como se indica en el siguiente código:

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

Hay tres métodos, reverse() , sort() y sortOn() , que permiten cambiar el orden de un conjunto indexado, ordenando o invirtiendo el orden. Todos estos métodos modifican el conjunto existente. En la tabla siguiente se resumen estos métodos y su comportamiento en los objetos Array y Vector:

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

var poets:Array = ["Blake", "cummings", "Angelou", "Dante"]; 
poets.sort(); // default sort 
trace(poets); // output: Angelou,Blake,Dante,cummings 
 
poets.sort(Array.CASEINSENSITIVE); 
trace(poets); // output: Angelou,Blake,cummings,Dante 
 
poets.sort(Array.DESCENDING); 
trace(poets); // output: cummings,Dante,Blake,Angelou 
 
poets.sort(Array.DESCENDING | Array.CASEINSENSITIVE); // use two options 
trace(poets); // output: Dante,cummings,Blake,Angelou

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); // output: John Q. Smith,Jane Doe,Mike Jones 
names.sort(orderLastName); 
trace(names); // output: Jane Doe,Mike Jones,John Q. Smith

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

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

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); 
} 
/* output: 
Wang 701 
Dante 1265 
Blake 1757 
cummings 1894 
Angelou 1928 
*/

Cuatro métodos de las clases Array y Vector ( concat() , join() , slice() y toString() ) consultan el conjunto para obtener información, pero no lo modifican. Los métodos concat() y slice() devuelven conjuntos nuevos, mientras que los métodos join() y toString() devuelven cadenas. El método concat() requiere una nuevo conjunto o lista de elementos como argumentos, y los combina con el conjunto existente para crear una nuevo conjunto. El método slice() tiene dos parámetros, denominados startIndex y endIndex , y devuelve un nuevo conjunto que contiene una copia de los elementos "extraídos" del conjunto 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 . Esto conlleva una repetición: el elemento con índice endIndex no se incluye en el valor devuelto.

En el ejemplo siguiente se utilizan concat() y slice() para crear conjuntos nuevos a partir de elementos de otros conjuntos:

var array1:Array = ["alpha", "beta"]; 
var array2:Array = array1.concat("gamma", "delta"); 
trace(array2); // output: alpha,beta,gamma,delta 
 
var array3:Array = array1.concat(array2); 
trace(array3); // output: alpha,beta,alpha,beta,gamma,delta 
 
var array4:Array = array3.slice(2,5); 
trace(array4); // output: alpha,beta,gamma

Se pueden utilizar los métodos join() y toString() para consultar el conjunto 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 del conjunto. 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 un conjunto denominado rivers y se llama a join() y toString() para devolver los valores del conjunto 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); // output: Nile,Amazon,Yangtze,Mississippi 
var riverPSV:String = rivers.join("+"); 
trace(riverPSV); // output: Nile+Amazon+Yangtze+Mississippi

Una característica del método join() que hay tener en cuenta es que las instancias anidadas de Array o Vector siempre se devuelven con los valores separados por comas, independientemente del separador que se especifique para los elementos del conjunto 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); // output: a+b,c,d+e