Array Indexing

Arrays in JavaScript are sparse. That is, if you have an array with three elements that are numbered 0, 1, and 2, you can create element 50 without worrying about elements 3 through 49. If the array has an automatic length variable (see Intrinsic Objects for an explanation of automatic monitoring of array length), the length variable is set to 51, rather than to 4. You can certainly create arrays in which there are no gaps in the numbering of elements, but you aren't required to. In fact, in JavaScript, your arrays don't have to have numbered subscripts at all.

In JavaScript, objects and arrays are essentially identical to each other. The real difference is not in the data, but rather in the way you address the members of an array or the properties and methods of an object.

Addressing Arrays

There are two main ways to address the members of an array. Ordinarily, you address arrays by using brackets. The brackets enclose either a numeric value or an expression that evaluates to a nonnegative integer. The following example assumes that the entryNum variable is defined and assigned a value elsewhere in the script.

theListing = addressBook[entryNum];
theFirstLine = theListing[1];

This method of addressing is equivalent to the method for addressing objects, though in object addressing, what follows the period must be the name of an actual property. If there is no such property, your code generates an error.

The second way to address an array is to make an object/array that contains properties that are numbered, and then generate the numbers in a loop. The following example generates two arrays, one for the name and one for the address, from a listing in addressBook. Each of these contains four properties. An instance of theName, for example, built from the [Name1] through [Name4] properties of theListing, might contain "G." "Edward" "Heatherington" "IV", or "George" "" "Sand" "".

theListing = addressBook[entryNum];
for (i = 1; i < 4; i++)  {
theName[i] = theListing["Name" + i];
theAddress[i] = theListing["Address" + i];
}

While this particular instance is short, and could easily have been written in the "dot" style of notation, (that is, addressing theListing, theName, and theAddress as objects rather than as arrays), that is not always possible. Sometimes the particular property may not exist until run time, or there may be no way to know which one it will be in advance. For example, if the addressBook array were arranged by last name instead of by numbered listings, the user would probably be entering names "on the fly," while the script is running, to look people up. The following example assumes the existence of appropriate function definitions elsewhere in the script.

theListing = addressBook[getName()];
theIndivListing = theListing[getFirstName()];

This is associative addressing of the array, that is, addressing by means of fully arbitrary strings. Objects in JavaScript are actually associative arrays. Although you can (and frequently do) use the "dot" style of addressing, you are not by any means required to. Because the members of any JavaScript object can be accessed using array notation, a JavaScript object can be used as an associative array.

The following code creates and initializes the most familiar form of an array:

var myArray = new Array("Athens", "Belgrade", "Cairo");

Each element of this array is addressed using its element number; in this case 0, 1, or 2. Using the for...in statement, the array can be iterated starting at 0 and ending at 2. For example:

for (key in myArray)
  response.write("Element value is " + MyArray[key] + "<BR>);

The following code creates and initializes an associative array containing three elements:

var MyArray = {"a" : "Athens", "b" : "Belgrade", "c" : "Cairo" };

In this array, elements are addressed using the key strings("a", "b", or "c") instead of an array element number (0, 1, or 2). This allows you to create and use arrays with more intuitive addressing schemes. The same for...in statement code shown above can be used to iterate this array as well.