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

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