var myObject = 
new anObject();
var myOtherObject = new anObject();

THE "THIS" KEYWORD
Inside our constructor function, you'll notice the "this" keyword. The "this" keyword simply refers to the object that is being created by the "new" keyword. The names that appear after the "this" keyword tell JavaScript what the names of our instance variables and methods should be. (Instance variable and method names are also sometimes referred to as slots.)

So, in our example, we are saying, "Inside this object that I am creating right now, I want two slots for instance variables and/or methods. The first slot will hold an instance variable called 'greeting.' And the second slot will be a method called 'sayHello'."

INSTANCE VARIABLES AND METHODS
What's the difference between defining an instance variable and a method? First, let's look at the line that defines our instance variable slot:

this.greeting = "Hi there!";

Methods are a bit more complicated. The last line of our constructor function creates a method for our object:

this.sayHello = doSayHello;

That function is defined on the next few lines:

function doSayHello() {
	alert( this.greeting)
	}

myObject.sayHello();

METHODS AND PARAMETERS
Parameters are passed to methods in the standard way, but methods that accept parameters are defined in a slightly odd fashion. When you are defining a method that takes parameters, you do not list those parameters in the constructor function. Instead, you list them in the implementation function.

Listing 2 shows our simple object after changing it so that the "sayHello" method takes a parameter. Using this method definition, we must now pass a name string to the "sayHello" method when we invoke it. However, notice that the parameter information does not appear anywhere in our constructor function! Instead, the parameter information only appears in the implementation function for the method, the "doSayHello" function.

So, if we executed the following statements:

myObject = new anObject();
myObject.sayHello( "Steven");

"Hi there! Nice to meet you Steven!"

Perhaps the biggest difference between JavaScript and other OOP languages is that JavaScript objects have no inheritance mechanism. This makes it rather difficult to reuse objects as the basis for new objects. About the best you can do is to include your old object in the definition of your new object as an instance variable. For example, if you wanted to create a new object "based" on our sample object, you might code a constructor function that looked like this:

function aNewObject() {
	this.baseObj = new anObject();
	this.var1 = 0;
	}

myNewObj = new aNewObject();
myNewObj.baseObj.sayHello("Steven");

A simple stack is one of the most useful objects to have in your programming toolbox. Like many languages, JavaScript doesn't have a built-in stack data type. Even worse, JavaScript doesn't support pointers of any kind. So, at first glance, adding a stack data type to JavaScript might appear difficult. However, if you can envision a stack in terms of objects sitting on top of one another, it's easy to add a stack object to JavaScript. But, instead of a single type of object, we'll need two: a stack element object and a stack object.

THE STACK ELEMENT OBJECT
Our stack will be made up of individual elements that we will "stack" on top of each other. Each of these individual elements is actually an object, the constructors for which are shown in Listing 3 (available at Java Report Online).

The instance variables and methods in the "oStackElement" object are straightforward:

• data—This is the actual data that this stack element holds. This can be a simple scalar value or another object. (It could even be another stack object!)

• next—This holds the next "oStackElement" object in our stack.

• setData—This method sets the "data" instance variable for this "oStackElement" object.

• getData—This method returns the "data" instance variable for this "oStackElement" object.

• setNext—This method sets the "next" instance variable for this "oStackElement" object.

• getNext—This method returns the "next" instance variable for this "oStackElement" object.

THE STACK OBJECT
After we've defined what our stack elements look like we need to define our stack object. The code for this object, the "oStack" object, is also shown in Listing 3.

This is a simple object, with just two instance variables and three methods.

• top—This instance variable will hold the object that sits at the top of our stack.

• length—This instance variable tells us how many objects are in our stack.

• isEmpty—This method tells us if the stack is empty.

• push—This method pushes a new object onto the top of the stack.

• pop—This method pulls the top object off of the stack and returns it.

The "push" and "pop" methods (shown in Listing 3) are a bit more interesting.

When we "push" an item onto our stack, the first thing we do is create a new "oStackElement" object to hold it. Then we place our data in this new object using the "setData" method. We then take the current top of the stack and assign it to the "next" field of the new item using the "setNext" method. Finally, we make our new item the top of the stack, and increment the "length" variable to show that our stack has increased in size by one element.

Popping an element off the stack is even simpler. All we need to do is capture the current top of the stack in a temporary variable and then reset the top to the next stack element (using the "getNext" method). After this is done, we decrement the "length" variable and return the former top element to the caller.

Note that when we return this top element, it's an "oStackElement" object! It's up to the caller to retrieve the data out of this object.

So, how do we use this object in a Web page? Listing 3 gives one answer. In this case, I've created a stack object and filled it with the names of my cats. I then retrieve the size of the stack and print out it's contents using a simple for loop and the "document.write()" method. Of course, you don't have to put cat names in the stack. Thanks to JavaScript's loose data typing, your stacks can contain strings, numbers, other objects, or whatever else you might want.

Quantity reprints of this article can be purchased by phone: 717.560.2001, ext.39 or by email: [email protected].