JavaScript/Array

JavaScript
← Volver a Operadores	Array	Seguir con Boolean →

O obxecto Array refírese a unha lista de datos, sexan do tipo que sexan. É útil para gardar un conxunto de datos ordenados que teñen relación entre si. Hai varios xeitos de crealos, e de asignar valor aos seus índices. Ademais pódense aniñar creando estruturas de árbore complexas.

Para crear arrays pódese facer destes xeitos:

    nome_array=new Array(lonxitude);
    nome_array=new Array(elemento1, elemento2,..., elementok);
    nome_array=[];
    nome_array=[ elemento1, elemento2,..., elementok ];

Para acceder a un elemento do array podemos facelo así:

    alert( nome_array [ índice ] );

Onde índice será o número de elemento ao que queiramos acceder. Hai que ter en conta que os elementos empezan a contarse desde cero, é dicir, o primeiro elemento é nome_array[0], o segundo nome_array[1] e así sucesivamente.

Os arrays non teñen porqué ser dun só tipo; un array con moitos valores de diferentes tipos sería igualmente válido:

    meuarray=new Array("Ola","isto é", "un","array",3.1416, cont);

Ademais un array pode almacenar moitos elementos. Se creamos un elemento no posto 87 crearanse automaticamente todos os valores anteriores que non estean definidos cun valor baleiro. Pódese estender todo o que se queira, pero non se pode empequeñecer nin co delete, así que hai que procurar facelos compactos para aforrar memoria.

Como aniñar arrays

Un array pode estar contido dentro doutro array, é dicir, pode ser un elemento doutro array alleo sen ningún problema:

    var array1=new Array("a ,""b","c","d");
    var array2=new Array("plátano","pera","mazá","fresa");
    array1[4]=array2;

O elemento 4 de array1 é outro array. Para acceder ao elemento "pera" faremos:

    array2[1];
    array1[4][1];

As dúas opcións son válidas.

Propiedades dos arrays

length

Os arrays teñen como propiedade principal o length.

    meuarray.length;

A propiedade length dun array devolve un enteiro co número de elementos que contén o array. Nótese que o número de elementos é o índice do último elemento máis unha unidade, e non o índice do último elemento.

prototype

A propiedade prototype téñena moitos obxectos en JavaScript. Serve para crear métodos e propiedades dos arrays genéricamente. Por se a linguaxe quédallenos curto. Poderiamos implementar un método inexistente e propio para, por exemplo, alertar o contido dun array:

var array1=new Array("a ,""b","c","d");
var array2=new Array("plátano","pera","mazá","fresa");
array1[4]=array2;

Array.prototype.alertar=function() {
    alert(this.toString());
}

array1.alertar();
array2.alertar();

Así, genéricamente, todos os obxectos Array do noso script estarían dotados do método alertar().

Métodos dos arrays

join(elemento_enlace): Este método devolve un string resultado da unión de todos os elementos do array intercalando entre eles o string elemento_enlace.

var meuarray=new Array("plátano","pera","mazá","amorodo");
document.write( meuarray.join(" e ") ); //plátano e pera e mazá e amorodo

toString(): Devolve un string de todos os elementos separados por comas. É equivalente a un join(","), só que todos os obxectos en javascript teñen un método toString() asociado.

var meuarray=new Array("plátano","pera","mazá","amorodo");
var str=meuarray.toString(); //plátano, pera, mazá, amorodo

pop(): Elimina o último elemento do array e devolve ese elemento. Este método modifica a lonxitude total do array, así que hai que ter precaución con el en bucles ou repeticións.

var meuarray=new Array("plátano","pera","mazá","amorodo");
var long1=meuarray.length; // long1=4
var ultimo=meuarray.pop(); // ultimo="amorodo"
var long2=meuarray.length; // long2=3

shift(): É como o pop(), só que no canto de actuar no último elemento actúa no primeiro, devolvendo este elemento. Obviamente tamén modifica a lonxitude do array en cuestión.

var meuarray=new Array("plátano","pera","mazá","amorodo");
var long1=meuarray.length; // long1=4
var primeiro=meuarray.shift(); // primeiro="plátano"
var long2=meuarray.length; // long2=3

push(elemento1, elemento2,..., elementok): O método push engade os elementos pasados por parámetro ao final do array, e, xa que logo, modificando a súa lonxitude total. Devolve o total de elementos que resultan logo de engadir, coma se dun length fixésemos despois.

var meuarray=new Array("plátano","pera","mazá","amorodo");
var long1=meuarray.length; // long1=4
var nuevaLong=meuarray.push("sandía","melon","kiwi"); //nuevaLong=7
var long2=meuarray.length; // long2=7

unshift(elemento1, elemento2,..., elementok): Igual que o push, só que engade os elementos especificados ao principio do array, e devolve a nova lonxitude do array.

var meuarray=new Array("plátano","pera","mazá","amorodo");
var long1=meuarray.length; // long1=4
var nuevaLong=meuarray.unshift("sandía","melón","kiwi"); //nuevaLong=7
var long2=meuarray.length; // long2=7

reverse(): Inviste os índices dos elementos do array. O primeiro será o último e o último o primeiro; o segundo será o penúltimo e o penúltimo será o segundo; e así sucesivamente.

var meuarray=new Array("plátano","pera","mazá","amorodo");
var meuarrayAlReves=meuarray.reverse(); // meuarrayAlReves=["amorodo","mazá","pera","plátano"];

slice(limite_inf, limite_sup): slice extrae (sen modificalo) unha porción do array orixinal. Así limite_inf é o índice do primeiro elemento que se debe extraer e limite_sup é o índice do último elemento que se debe extraer máis unha unidade.

var meuarray=new Array("plátano","pera","mazá","amorodo","uva","sandía","melón","kiwi");
var meuarray2=meuarray.slice(2,5); //mazá,fresa, uva

splice(indice_inicial, num_elementos[, elemento1, elemento2,..., elementok]): Este é probablemente o método máis complexo dos arrays. É capaz de eliminar elementos e de engadir novos elementos tamén. Modificará polo xeral a lonxitude do array (a non ser que engadamos o mesmo número de elementos que eliminemos).
- indice_inicial: É un número enteiro que indica a partir de que elemento comezamos ou a borrar ou a inserir elementos no array.
- num_elementos: É un número que indica cantos elementos do array eliminamos a partir de indice_inicial. Se é un 0 debemos especificar novos elementos obrigatoriamente e splice non devolve nada. Se é 1 splice devolverá ese elemento eliminado, e se é maior de 1 splice devolverá un array cos elementos eliminados.
- elemento1, elemento2,..., elementok: Son os parámetros (opcionais) que especifican os novos elementos do array que se engadirán na posición indice_inicial.

var meuarray=new Array("plátano","pera","mazá","amorodo","uva","sandía","melón","kiwi");

meuarray.splice(0,0,"laranxa","mandarina","pomelo");
// meuarray=laranxa, mandarina, pomelo, plátano, pera, mazá, fresa, uva, sandía, melon, kiwi

var elementoPera=meuarray.splice(4,1); // elementoPera=pera
//meuarray=laranxa, mandarina, pomelo, plátano, mazá, fresa, uva, sandía, melon, kiwi

var fresa_uva_sandia=meuarray.splice(5,3); // amorodo_uva_sandía=amorodo, uva, sandía
//meuarray=laranxa, mandarina, pomelo, plátano, mazá, melón, kiwi

meuarray.splice(2,3,"linguado","pescada","sardiña","xarda");
//meuarray=laranxa, mandarina, linguado, pescada, sardiña, xarda, melón, kiwi

sort([funcion_comparacion]): Un dos poucos métodos por defecto que recibe unha función como parámetro. Ordena o array segundo o criterio que conteña funcion_comparacion. Podemos ordenar de menor a maior números, alfabeticamente letras... etc. O parámetro é opcional; por defecto sort() ordena de menor a maior e alfabeticamente, antepondo os números ás letras e as maiúsculas.
- funcion_comparacion: É unha función que contén dous parámetros obrigados, que serán os elementos do array a comparar. Segundo o que devolva esta función, sort interpretase unha cousa ou outra:
  - funcion_comparacion(a, b)<0 --> a lt;b.&
  - funcion_comparacion(a, b)=0 --> a=b
  - funcion_comparacion(a, b)>0 --> a gt;b.&

Para ordenar elementos existen outros algoritmos, algúns máis legibles outros máis eficaces: O Ordenamento por mestura, Ordenamento de burbulla, Shell sort e o Quicksort son algúns deles.

JavaScript
← Volver a Operadores	Array	Seguir con Boolean →