Matrizes indexadas

É possível usar diversas técnicas para criar uma instância de Array ou Vector. No entanto, as técnicas para criação de cada tipo de matriz apresentam diferenças entre si.

A maneira mais simples de adicionar um elemento a uma matriz indexada é usar o operador de acesso à matriz ( [] ). Para definir um valor de um elemento de matriz indexada, use o nome de objeto Array ou Vector e o número de índice à esquerda de uma instrução de atribuição:

songTitles[5] = "Happy Birthday";

Se a matriz ou o vetor ainda não tiver um elemento no índice, esse índice será criado e o valor será armazenado nele. Se houver um valor no índice, o novo valor substituirá o existente.

Um objeto Array permite a criação de um elemento em qualquer índice. Entretanto, com um objeto Vector você somente poderá atribuir um valor a um índice existente ou ao próximo índice disponível. O próximo índice disponível corresponde à propriedade length do objeto Vector. A maneira mais segura de adicionar um novo elemento a um objeto Vector é usar um código como na listagem a seguir:

myVector[myVector.length] = valueToAdd;

Três métodos da classe Array e Vector - push() , unshift() e splice() - permitem inserir elementos em uma matriz indexada. O método push() anexa um ou mais elementos ao final de uma matriz. Em outras palavras, o último elemento inserido na matriz com o método push() terá o maior número de índice. O método unshift() insere um ou mais elementos no início de uma matriz, sempre no número de índice 0. O método splice() insere qualquer número de itens em um índice especificado na matriz.

O exemplo a seguir demonstra os três métodos. Uma matriz chamada planetas é criada para armazenar os nomes dos planetas de acordo com a proximidade ao Sol. Primeiro, o método push() é chamado para adicionar o item inicial, Marte . Segundo, o método unshift() é chamado para inserir o item que pertence ao início da matriz, Mercúrio . Finalmente, o método splice() é chamado para inserir os itens Vênus e Terra depois de Mercúrio , mas antes de Marte . O primeiro argumento enviado para splice() , o inteiro 1, direciona a inserção para começar no índice 1. O segundo argumento enviado para splice() , o inteiro 0, indica que nenhum item deve ser excluído. Finalmente, o terceiro e quarto argumentos enviados para splice() , Vênus e Terra , são os itens que devem ser inseridos.

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

Os métodos push() e unshift() retornam um inteiro sem sinal que representa o comprimento da matriz modificada. O método splice() retorna uma matriz vazia quando é usado para inserir elementos, o que pode parecer estranho, mas faz mais sentido de acordo com a versatilidade do método splice() . Você pode usar o método splice() não só para inserir elementos em uma matriz, mas também para remover elementos de uma matriz. Quando usado para remover elementos, o método splice() retorna uma matriz que contém os elementos removidos.

A maneira mais simples de recuperar o valor de um elemento de uma matriz indexada é usar o operador de acesso à matriz ( [] ). Para recuperar o valor de um elemento de matriz indexada, use o nome de objeto Array ou Vector e o número de índice à direita de uma instrução de atribuição:

var myFavoriteSong:String = songTitles[3];

Você pode tentar recuperar um valor de uma matriz ou vetor usando um índice onde não houver elementos. Nesse caso, um objeto Array retorna um valor indefinido e um vetor emite uma exceção RangeError.

Três métodos das classes Array e Vector - pop() , shift() e splice() - permitem a remoção de elementos. O método pop() remove um elemento do final da matriz. Em outras palavras, ele remove o elemento com o número de índice mais alto. O método shift() remove um elemento do início da matriz, ou seja, sempre remove o elemento com o número de índice 0. O método splice() , que também pode ser usado para inserir elementos, remove um número arbitrário de elementos começando no número de índice especificado pelo primeiro argumento enviado ao método.

O exemplo a seguir usa os três métodos para remover elementos de uma ocorrência de Array. Uma matriz chamada oceanos é criada para armazenar os nomes dos grandes corpos de água. Alguns nomes da matriz referem-se a lagos, não a oceanos, e precisam ser removidos.

Primeiro, o método splice() é usado para remover os itens Aral e Superior , e inserir os itens Atlântico e Índico . O primeiro argumento enviado para splice() , o inteiro 2, indica que a operação deve começar com o terceiro item da lista, que está no índice 2. O segundo argumento, 2, indica que dois itens devem ser removidos. Os argumentos restantes, Atlântico e Índico , são os valores que devem ser inseridos no índice 2.

Segundo, o método pop() é usado para remover o último elemento da matriz, Huron . Finalmente, o método shift() é usado para remover o primeiro item da matriz, Vitória .

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

Os métodos pop() e shift() retornam o item que foi removido. Para uma ocorrência de Array, o tipo de dados do valor de retorno é Object porque as matrizes podem armazenar valores de qualquer tipo de dados. Para uma ocorrência de Vector, o tipo de dados do valor de retorno é o tipo base do vetor. O método splice() retorna uma matriz ou um vetor que contém os valores removidos. Você pode alterar o exemplo de matriz oceanos para que a chamada do método splice() atribua a matriz retornada a uma nova variável Array, como mostra o exemplo a seguir:

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

Talvez apareça um código que usa o operador delete em um elemento de objeto Array. O operador delete define o valor de um elemento Array como undefined , mas não remove o elemento da matriz. Por exemplo, o código a seguir usa o operador delete no terceiro elemento da matriz oceanos , mas o comprimento da matriz continua sendo 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

Você pode truncar uma matriz ou um vetor usando uma propriedade de matriz length . Se a propriedade length de uma matriz indexada for definida como um comprimento menor do que o atual, a matriz será truncada, o que remove os elementos armazenados nos números de índice maiores do que o novo valor de length menos 1. Por exemplo, se a matriz oceanos fosse classificada de modo que todas as entradas válidas estivessem no início da matriz, a propriedade length poderia ser usada para remover as entradas no final da matriz, como mostra o código a seguir:

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

Existem três métodos - reverse() , sort() e sortOn() - que permitem alterar a ordem de uma matriz indexada, classificando-a ou invertendo-a. Todos esses métodos modificam a matriz existente. A tabela a seguir resume esses métodos e seus respectivos comportamentos para objetos Array e 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 
*/

Quatro métodos das classes Array e Vector - concat() , join() , slice() e toString() - consultam a matriz em busca de informações, mas não a modificam. Os métodos concat() e slice() retornam novas matrizes, enquanto os métodos join() e toString() retornam strings. O método concat() pega uma nova matriz ou lista de elementos como argumentos e a combina com a matriz existente para criar uma nova. O método slice() tem dois parâmetros, devidamente chamados de startIndex e endIndex , e retorna uma nova matriz que contém uma cópia dos elementos "fatiados" a partir da matriz existente. A fatia começa com o elemento em startIndex e termina com o elemento bem antes de endIndex . A máxima é a mesma: O elemento em endIndex não é incluído no valor de retorno.

O exemplo a seguir usa concat() e slice() para criar novas matrizes com elementos de outras matrizes:

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

Você pode usar os métodos join() e toString() para consultar a matriz e retornar seu conteúdo como uma string. Se nenhum parâmetro for usado para o método join() , os dois métodos terão o mesmo comportamento: eles retornarão uma string que contém uma lista delimitada por vírgulas de todos os elementos da matriz. O método join() , diferente do método toString() , aceita um parâmetro chamado delimiter , que permite escolher o símbolo a ser usado como separador entre cada elemento na string retornada.

O exemplo a seguir cria uma matriz chamada rios e chama join() e toString() para retornar os valores na matriz como uma string. O método toString() é usado para retornar valores separados por vírgula ( riverCSV ), enquanto o método join() é usado para retornar valores separados pelo caractere + .

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

Um problema do método join() que deve ser levado em consideração é o fato de as ocorrências de Array ou Vector aninhadas sempre serem retornadas com valores separados por vírgula, independentemente do separador especificado para os elementos principais da matriz, como mostra o exemplo a seguir:

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