Arreglos en Flash

Un arreglo en Flash nos permite guardar objetos de la misma clase bajo una misma variable. El tipo de variable que es capaz de guardar estos objetos se denomina Array. Los objetos estan almacenados de manera que comiencen desde 0, a menos que se indique lo contrario, hasta el numero total de objetos que haya dentro del arreglo, así podemos encontrar encontrar el objeto cuando se vaya a necesitar.

Imaginemonos que tenemos una lista de números de teléfonos de personas que tenemos que llamar, primero llamaremos a Juan, Jose, María y Diego. La lista de números telefónicos es nuestro arreglo y las variables dentro de este serán los nombres de las personas a las que tenemos que llamar. En Flash se podría representar de la siguiente manera:

listaTelefonica = ["Juan", "Jose", "Maria", "Diego"];

Para acceder a cada elemento individual del arreglo, utilizamos un número entero denominado índice. Este índice comienza en 0. Dentro de la lista de números de teléfonos podemos accesar a Juan con el indice 0, a Jose con el índice 1 y así sucesivamente. Para comprobar lo anterior, podemos escribir en Flash y luego presionando Ctrl + Enter:

//Para ver todos los elementos dentro del Array
trace(listaTelefonica); //Nos devolverá: Juan, Jose, Maria, Diego
//Ahora si lo que queremos es que el Array nos devuelva sólo un
//elemento en concreto, lo accesamos con el índice
trace(listaTelefonica[0]); //Nos devolverá el primer elemento del arreglo, o sea a Juan

Se puede seguir incrementando el valor del índice hasta que alcance el número que sobrepase la cantidad actual de valores que hay dentro del arreglo actualmente. En el ejemplo anterior, el último elemento del arreglo es Diego y se accesa así: listaTelefonica[3]. Cuando se sobrepase ese tope se desplegará un mensaje de undefined, que nos indica que no hay nada en esa posición.

Para agregar valores al arreglo simplemente se asigna un valor con un índice superior al último, o sea, en la variable listaTelefonica no hay nada dentro de la posición listaTelefonica[4], ahí podemos agregar un nuevo valor.

listaTelefonica[4] = "Laura";

Si lo que se quiere es modificar algún valor dentro del Array sólo asignamos un nuevo valor a la posición la cual se quiera modificar.

listaTelefonica[2] = "Luis";

Hasta aquí todo bien, ¿cierto?

Una manera menos arcaica de trabajar con Arreglos.

Una forma de crear un arreglo con ActionScript de manera más sutil es creando el objeto tipo Array y asignadoles los valores al constructor ó asignarselos uno por uno:

var listaTelefonica:Array = new Array("Juan", "Jose", "Maria", "Diego");
ó bien
var listaTelefonica:Array = new Array();
listaTelefonica[0] = "Juan";
listaTelefonica[1] = "Jose";
listaTelefonica[2] = "Maria";
listaTelefonica[3] = "Diego";

Los arreglos se utilizan en situaciones más complejas que sólo asignarle un nombre, de hecho la clase Array cuenta con una serie de funciones para que se puedan manipular más fácilmente sus valores. A continuación la lista de posibles funciones aplicables a un arreglo y sus ejemplos al final:

concat: Concatena elementos de 2 arreglos.

join: Convierte el actual separador que es una coma y un espacio en el elemento que es asignado mediante el join.

length: Especifica el número entero no negativo de elementos del arreglo.

pop: Remueve el último elemento de un Array y retorna el valor de ese elemento.

push: Agrega uno ó más elementos al final de un arreglo y retorna el nuevo tamaño del arreglo.

reverse: Invierte las posiciones de los valores del arreglo.

shift: Remueve el primer elemento de un Array y retorna el valor de ese elemento.

slice: Retorna un nuevo arreglo perteneciente a un rango de elementos del original sin modificarlo.

sort: Ordena los elementos de un arreglo.

splice: Retorna un nuevo arreglo perteneciente a un rango de elementos del original y modificándolo.

toString: Retorna una cadena con los valores del arreglo separado por comas. Es el mismo resultado que hacer un trace. La función toString() es útil ya que se puede modificar la salida y así imprimir el valor de la clase arbitrariamente.

unshift: Agrega uno ó más elementos al inicio de un arreglo.

//concat
trace("\nfunción concat:");
var listaTelefonica:Array = new Array("Juan", "Jose", "Maria", "Diego");
var numerosTelefonicos:Array = new Array(1111111, 2222222, 3333333, 4444444);
var agendaTelefonica:Array = listaTelefonica.concat(numerosTelefonicos);
trace(agendaTelefonica);

//join
trace("\nfunción join:");
trace(agendaTelefonica.join(" - "));

//length
trace("\nfunción length:");
trace(agendaTelefonica.length);

//pop
trace("\nfunción pop:");
var temp:Object = agendaTelefonica.pop();
trace(temp);
trace(agendaTelefonica);

//push
trace("\nfunción push:");
temp = agendaTelefonica.push(7777777);
trace(temp);
trace(agendaTelefonica);

//reverse
trace("\nfunción reverse:");
trace(agendaTelefonica.reverse());

//shift
trace("\nfunción shift:");
temp = agendaTelefonica.shift();
trace(temp);
trace(agendaTelefonica);

//slice
trace("\nfunción slice:");
var arregloTemp:Array = new Array();
//En este caso el rango de elementos va desde la posición
//0 hasta la 2
arregloTemp = agendaTelefonica.slice(0, 2);
trace(arregloTemp);
trace(agendaTelefonica);

//sort
trace("\nfunción sort:");
trace(agendaTelefonica.sort());

//splice
trace("\nfunción splice:");
//En este caso el rango de elementos va desde la posición
//1 hasta la 2
trace(agendaTelefonica.splice(1, 2));
trace(agendaTelefonica);

//toString
trace("\nfunción toString:");
trace(agendaTelefonica.toString());

//unshift
trace("\nfunción unshift:");
agendaTelefonica.unshift("7777777", "8888888", "9999999");
trace(agendaTelefonica);

admin's picture

muchas gracias me sirvio de

muchas gracias me sirvio de mucho esta info