Simply stated, an array is a list. The size
of the list determines how many pieces of information, known as elements, can
be put into it. Any part of the list can be accessed, if you know where in the
list it is stored.
There are several ways of creating an
instance of an array, as follows:
x = new Array();
x = [];
x = new Array(size);
x = new Array (element1, element2, ...,
elementN);
x = [element1, element2, ..., elementN)];
The first two methods create an array that
has no elements. While this may not seem useful, it is possible to add new
elements to an array, which we will discuss later. The third method creates an
array with a specific number of elements. These elements are initially empty,
but new values can be assigned to them, as we will discuss later. The final two
methods creates a populated array. The size of the array will depend on the
number of elements that are declared, but in theory any number of elements can
be specified. This type of constructor is very useful in cases when you want to
have some type of table of predefined values that can be accessed.
The power of an array comes from the
ability to access and modify the elements of the array. Elements of an array
have an index number associated with them. The first element of an array is
referenced with the number 0, the second is 1, and so on. Some people find
using element 0 confusing, so will simply ignore that element and start storing
stuff in element 1. If you are going to do this, remember that the last element
of an array is one less than the size of the array.
To access the element, you simply use the
array variable's name, followed by the index number in square brackets. The
index does not have to be a number, but can be a variable that contains the
index number. For example, the following program adds the third and fourth
elements (index values 2 and 3) and places the result in the first (index 0)
element.
index = 3;
list = new Array(0, 1, 2, 3, 4, 5);
result = list[2] + list[index];
list[0] = result;
The Array class has functions for modifying
and getting information about the array. It also has a read-only property
variable named length that holds the current length of the array. Action Script
allows you to change the size of the array at any time. Many other programming
languages are not quite as flexible. The Action Script Dictionary that is
included with Macromedia Flash covers these functions in detail.
Now we come to a rather interesting
additional for statement that is included with Action Script, the for..in
statement. This is what is known as an iterative for function. It is used to
iterate through all the variables of the indicated object. The format for this
command is for (variable_holding_index in object) The variable_holding_index is
simply the name of the variable that holds the index. Here is a sample to
illustrate how this can be used.
var cntr;
testArray = new Array("A",
"B", "C", "D");
for (cntr in testArray) {
console.log("Element " + cntr +
" is " + testArray[cntr]);
}
No comments:
Post a Comment