Aleenanne : Reference :Java Code

Reference JavaScript Code Library

JavaScript 1.2, which only works in Netscape 4.0, adds several fundamental methods to the array object. A few of these very useful methods are included here in a form that can be used by 3.0 browsers.

The methods added here are:

copy - Copies the contents of one array into another.
push - Adds an element to the end of an array.
pop - Removes an element from the end of an array and shortens the array.
shift - Removes an element from the beginning of an array and shortens the array.
unshift - Adds an element to the beginning of an array.
concat - Tacks the elements of an array onto the end of another array.
permute - Randomizes the order of elements in an array.

Usage: Each of the following usage examples assumes you're starting with an array called primates that begins with the elements human, chimp, ape. In other words:

var primates = new Array('human','chimp','ape');

copy

var primates = new Array('human','chimp','ape');
var copy_of_primates = primates.copy();

copy_of_primates will be an array containing the same elements as the primates array.
Be careful if the array contains references to objects instead of just strings or numbers. References to objects will be copied as references. This means that if you change an object in the original array, it will also be changed in the new array.

push

var primates = new Array('human','chimp','ape');
primates.push('lemur');

Now primates contains ('human','chimp','ape','lemur').

pop

var primates = new Array('human','chimp','ape');
var last_primate = primates.pop();

Now primates contains ('human','chimp') and last_primate is 'ape'.

shift

var primates = new Array('human','chimp','ape');
var first_primate = primates.shift();

Now primates contains ('chimp','ape') and first_primate is 'human'.

unshift

var primates = new Array('human','chimp','ape');
primates.unshift('gorilla');

Now primates contains ('gorilla','human','chimp','ape').

concat

var primates = new Array('human','chimp','ape');
var dogs = new Array('puli','pointer','collie');
var mammals = primates.concat(dogs);

Now mammals contains ('human','chimp','ape','puli','pointer','collie').
Concat uses copy, so be careful if the array contains references to objects instead of just strings or numbers. References to objects will be copied as references. This means that if you change an object in the original array, it will also be changed in the new array.

permute

var primates = new Array('human','chimp','ape');
var scrambled_primates = primates.permute();

Now scrambled_primates contains ('ape','human','chimp') or some other random ordering of its elements.
Permute uses copy, so be careful if the array contains references to objects instead of just strings or numbers. References to objects will be copied as references. This means that if you change an object in the original array, it will also be changed in the new array.

Cut, paste, and enjoy!

/*
Webmonkey Array Enhancements

JavaScript 1.2, which only works in Netscape 
4.0, adds several fundamental methods to the 
array object. A few of these very useful 
methods are included here in a form that 
can be used by 3.0 browsers.

Author: Thau!
*/

// copy
//
// Copies the contents of an array into a temp 
// array and returns the copy.
//
// It doesn't alter the original array, but be 
// careful if the array contains references to 
// objects instead of just strings or numbers. 
// References to objects will be copied as 
// references. This means that if you change 
// an object in the original array, it will 
// also be changed in the new array.
//
function copy()
{
  var loop;
  var temp_array = new Array();
  for (loop = 0; loop < this.length; loop++)
  {
    temp_array[loop] = this[loop];
  }
  return temp_array;
}

Array.prototype.copy = copy;

// pop
//
// Removes the last element of an array and 
// returns that element. 
//
function pop()
{
  var last_item = this[this.length-1];
  this.length--;
  return last_item;
}

Array.prototype.pop = pop;

// push
//
// Adds an element to the end of an array and 
// returns the new length of the array. This 
// method changes the length of the array. 
//
function push(the_item)
{
  this[this.length] = the_item;
  return this.length;
}

Array.prototype.push = push;

// concat
//
// Joins two arrays and returns a new array. 
// It doesn't alter the original arrays, but be 
// careful if the arrays contain references to 
// objects instead of just strings or numbers. 
// References to objects will be copied as 
// references. This means that if you change 
// an object in the original arrays, it will 
// also be changed in the new array.
//
function concat(second_array)
{
  var first_array = this.copy();
  
  for (loop = 0; loop<second_array.length; loop++)
  {
    first_array[first_array.length] = second_array[loop];
  }
  return first_array;
}

Array.prototype.concat = concat;

// shift
//
// Removes the first element of an array and 
// returns that element.
//
function shift()
{
  var new_value = this[0];
  var orig_length = this.length;
  for (loop = 0; loop<this.length-1; loop++)
  {
    this[loop] = this[loop+1];
  }
  this.length--;
  return new_value;
}

Array.prototype.shift = shift;

// unshift
//
// Adds an element to the beginning of an array and 
// returns the new length of the array.
//
function unshift(the_item)
{
  for (loop = this.length-1 ; loop >= 0; loop--)
  {
    this[loop+1] = this[loop];
  }
  this[0] = the_item;
  return this.length;
}

Array.prototype.unshift = unshift;

// permute
//
// Randomly reorders the elements of an 
// array and returns the new, reordered array. 
// The original array remains unchanged.
// 
function permute(the_array)
{

var temp_array = this.copy();
  var new_array = new Array();
  var random_num = 0;
  for (loop = 0; loop < this.length; loop++)
  {
    random_num = Math.round(Math.random() * (temp_array.length-1));
    new_array[loop] = temp_array[random_num];
    temp_array[random_num] = temp_array[temp_array.length-1];
    temp_array.length--;
  }
  return new_array;
}

Array.prototype.permute = permute;

// -->

</script>