Arrays / Colecciones en javascript. Nuevos métodos...

Arrays sencillos Arrays de objetos Arrays asociativos Colecciones

Para empezar vamos a mostrar la ordenación de objetos en base a uno de sus atributos.

Se ordenan según el elemento que se seleccione. Puede probar pinchando sobre la cabecera de la siguiente tabla...



Array_de_prueba:
Nuevos métodos: params:
Llamada resultado = Array_de_prueba.seleccione Método
resultado

Debe seleccionar un elemento de la lista desplegable para ver su descripción.


Esta página se ha desarrollado a partir de un par de mensajes de foros del web: Manipular array y Métodos de Arrays. Donde hemos participado: furoya, kepawe, Beakdan y yo (caricatos).

cambiar:

Recibe 2 parámetros que indican los elementos que serán cambiados dentro del orden del array.
Código:
Array.prototype.cambiar = function(a, b)	{
	var yo = this;
	if (a < 0 || a >= yo.length || b < 0 || b >= yo.length) return yo;
	var temp = yo[a];
	yo[a] = yo[b];
	yo[b] = temp;
	return yo;
}
moverPrimeroA:

Recibe 1 parámetro que indican el sitio donde será movido el primer elemento del array.
Código:
Array.prototype.moverPrimeroA = function(b)	{
	var yo = new Array();
	yo = this;
	var longitudArray = yo.length;
	
	if (b == yo.length - 1)	
		return yo.rotarI();
	else	{
		if (b < (longitudArray))	{
			principio = new Array();
			principio = yo.slice(0, parseInt(b) + 1);
			principio.length = parseInt(b) + 1;
			fin = new Array();
			fin = this.slice(parseInt(b) + 1, longitudArray);
			principio = principio.rotarI().concat(fin);
			return principio;
		}
		else
			return yo;
	}
}
moverAlFinal:

Recibe 1 parámetro que indican el elemento que será movido al final del array.
Código:
Array.prototype.moverAlFinal = function(b)	{
	var yo = this;
	var longitudArray = yo.length;
	if (b == 0)	
		return yo.rotarI();
	else	{
		if (b < (yo.length - 1))	{
			principio = yo.slice(0, b);
			fin = yo.slice(b, longitudArray).rotarI();
			yo = principio.concat(fin);
			return principio.concat(fin);
		}
		else
			return yo;
	}
}
Mover:

Recibe 2 parámetros que indican el elemento que será movido y la ubicación donde se moverá dentro del orden del array. Los elementos se desplazan (o rotan).
Código:
Array.prototype.mover = function(a, b)	{
	var rotar = "rotarI";
	var yo = this;
	var longitudArray = yo.length;
	if (a < 0 || b < 0)
		return yo;
	if (a == 0)
		return yo.moverPrimeroA(b);
	if (b == (yo.length - 1))
		return yo.moverAlFinal(a);
	if (a > b)	{temp = a; a = b; b = temp; rotar = "rotarD";}
	if (a > 0 && b < longitudArray)	{
		principio = yo.slice(0, parseInt(a));
		mitad = yo.slice(parseInt(a), parseInt(b) + 1)[rotar]();
		fin = yo.slice(parseInt(b) + 1, longitudArray);
		return principio.concat(mitad, fin);
	}
	return yo;
}
Move1:

Recibe 2 parámetros que indican el elemento que será movido y la ubicación donde se moverá dentro del orden del array. Versión implementada por furoya (foros del web).
Código:
function move1(alfa,bravo){
if(alfa=0 && bravo=0 ){
 foxtrot = this.slice(alfa,alfa+1);

 if(alfa < bravo){
 charly = this.slice(0,alfa);
 delta = this.slice(alfa+1,bravo+1);
 eco = this.slice(bravo+1,this.length);
 golf = charly.concat(delta.concat(foxtrot.concat(eco)));
 }

 else if(alfa > bravo){
 charly = this.slice(0,bravo);
 delta = this.slice(bravo,alfa);
 eco = this.slice(alfa+1,this.length);
 golf = charly.concat(foxtrot.concat(delta.concat(eco)));
 }
 else golf = this;
}
return golf;
}
Array.prototype.move1 = move1;
Move_to:

Recibe 2 posibles parámetros que indican el elemento que será movido y la ubicación donde se moverá dentro del orden del array. También puede recibir una sola cadena "left"/"right" que euivale a la rotación del array en el sentido que se indica: (left=izquierda, right=derecha. Versión implementada por kepawe (foros del web).
Código:
Array.prototype.move_to = function()	{
	// rota los elementos a la derecha
	if (arguments[0] == "right")	{
		a = this.length - 1;
		b = 0;
	}
	// rota los elementos a la izquierda 
	else
		if(arguments[0] == "left")	{
			a = 0;
			b = this.length - 1;
		}
		// mueve un elemento a una posición
		else	{
			a = arguments[0];
			b = arguments[1];
		} 
	a = a >= this.length ? this.length - 1 : a < 0 ? 0: a;
	b = b >= this.length ? this.length - 1 : b < 0 ? 0: b;
	var element_move = this[a];
	if(a < b)	{
		for(var ctr = a; ctr < b; ctr++)	{
			this[ctr] = this[ctr+1];
		}
	}
	if(a > b)	{
		for(var ctr = a; ctr > b; ctr--)	{
			this[ctr] = this[ctr-1];
		}
	}
	this[b] = element_move;
	return this;
}
Invertir:

Equivale a reverse(). Invierte el orden del array.
Código:
Array.prototype.invertir = function()	{// reverse()
	for (var i = 0, mayor = parseInt(this.length / 2); i < mayor; i ++)
		this.cambiar(i, this.length - 1 - i);
	return this;
}
Reverse:

Equivale a invertir(), descrito anteriormente. Es un método "nativo" de los objetos "Array".
Código:
// es código nativo
rotarI:

Rotar a la izquierda. Pone al final del array el primer elemento.
Código:
Array.prototype.rotarI = function()	{
	var yo = this;
	var primero = yo.desapilarPrimero();
	yo[yo.length] = primero;
	return yo;
}
nuevoRotarD:

Rotar a la derecha. Pone al principio del array el último elemento.
Código:
Array.prototype.rotarD = function()	{
	var yo = this;
	var primero = new Array();
	primero[0] = yo.desapilarUltimo();
	primero = primero.concat(yo);
	return primero;
}
RotarD:

Rotar a la derecha. Pone al principio del array el último elemento.
Código:
Array.prototype.RotarD = function() { 
	if(this.length > 0) {
		var last_element = this[this.length-1];
		for(var ctr = this.length -1; ctr > 0; ctr--)
			this[ctr] = this[ctr-1];
		this[0] = last_element;
	}
	return this;
}
slice:

Devuelve un subarray comprendido entre los valores que se pasan como parámetros.
Código:
// es código nativo
concat:

Devuelve una concatenación del array actual y los que se pasan como parámetros.
Código:
// es código nativo
Shuffle:

Devuelve el array actual desordenado.
Código:
Array.prototype.shuffle = function(){
	romeo = this;
	papa = romeo.length;
	for (sierra = 0;sierra < papa; sierra ++)	{
		quebec = romeo[sierra];
		tango = Math.floor(Math.random()*papa);
		romeo[sierra] = romeo[tango];
		romeo[tango] = quebec;
	}
	return romeo;
}
random_array:

Devuelve el array actual desordenado.
Código:
Array.prototype.random_array = function()	{
	var ctr = 0;
	while(ctr < this.length)	{
		var a = Math.floor(this.length* Math.random());
		var b = Math.floor(this.length* Math.random());
		this.move_to(a,b);
		ctr++;
	}
	return this;
} 
pop:

Devuelve el último elemento.
Código:
// es código nativo
desapilarUltimo:

Devuelve el último elemento.
Código:
Array.prototype.desapilarUltimo = function()	{//pop()
	devolver = this[this.length - 1];
	this.length--;
	return devolver;
}

La verdad es que sobre los arrays asociativos, no hay mucho que decir, ya que se trata de una forma de tratar los mismos arrays sencillos, pero especialmente el tratamiento de arrays de objetos.

La verdad es que el tratamiento habitual de un array es "asociativo", pero con respecto a su índice en el orden de los elementos.

Por ejemplo, si tenemos en cuenta estas 2 imágenes (las únicas declaradas en esta página) , tienen el nombre "emoticoncito1" y "emoticoncito2"... y sus respectivos stributos id son: "_emoticoncito1" y "_emoticoncito2" (se parecen a sus respectivos nombre, pero difieren).

Podemos referenciar a la primera tanto por su orden dentro del array de imágenes (document.images) del documento, como por el valor de su atributo name.

Por ejemplo, si queremos saber cual es el atributo src de la primera imagen podemos usar esta línea: alert(document.images[0].src)... pero también podemos saber cuál es el mismo atributo de la imagen cuyo atributo name es emoticoncito2 así: alert(document.images['emoticoncito1'].src). Y afinando más, podemos seleccionar los objetos a través de cualquier atributo: onclick="alert(document.images[id='_emoticoncito2'].name)


Entenderemos por colecciones, a los elementos iguales que se encuentran en una página web.

Los básicos serían: imágenes (images), formularios (forms), enlaces (links), anclas o puntos de anclaje (anchors), elementos incrustados -suelen ser multimedia- (embeds), aplicaciones java (applets), elementos de formulario ([el_formulario].elements), opciones de los selects [el_select].options), las filas de las tablas ([la_tabla].rows ...

Y otra calificación especial se correspondería con las colecciones de etiquetas iguales [base].getElementsByTagName(nombre_de_etiqueta), los nodos que "cuelgan" de un nodo "padre" ([el_nodo].childNodes)...

Zona de comentarios

Esta pagina aún no tiene comentarios.

Evaluación

Valoración de esta página: (pagina.Arrays) valor

Valoración evaluar evaluar evaluar evaluar evaluar evaluar evaluar evaluar evaluar evaluar

Respuesta: Zona de mensajes (proceso de evaluación)

Copyright © 2002-2017 www.pepemolina.com
RSS rss | Ver Mapa del sitio