Chapter 2

JScript: The Language

• JScript Syntax
• Variables and Values
  • Implicit Data Types in JScript
  • Type Conversion
• Statements and Operators
  • The Structure of JScript Statements
  • Operators
  • Comments in JScript Code
• Control Structures
  • The if Statement
  • The while Statement
  • The for Statement
• Functions and Objects
  • Functions
  • Objects

There are many, many different computer programming languages in use today. Each has its own set of special features, which are highly praised by its fans and vigorously panned by its detractors. If you have worked in more than one language, you are aware that there is a continuum of language styles, ranging from highly structured languages, such as Ada, to more freewheeling ones, such as LISP. Many are associated with specific settings or applications. Ada, for example, is often found in military projects, while LISP is often associated with artificial intelligence. Some languages, such as HTML, the language used to describe the layout of World Wide Web pages, have a well-defined organizational structure, but have very little in the way of traditional program structure (there are no data types, for example).

In trying to understand a new language, it is not only important to master its syntax, it is also vital to appreciate its style-the way in which that language can be used to accomplish specific goals. We have already reviewed the basic goals of JScript in Chapter 1 "What Is JScript?" as well as contrasting it to the more structured Java language. This chapter describes the JScript language from both perspectives. A thorough description of its syntax is given, and some initial concepts on how to structure a JScript program are also introduced. Anyone who has programming experience in almost any modern declarative language, such as C, C++, Perl, or Pascal, will immediately feel at home. In addition, HTML authors who have never programmed will be able rapidly to acquire JScript proficiency.

JScript Syntax

JScript is based on an action-oriented model of the World Wide Web. Elements of a Web page, such as a button or check box, may trigger actions or events. When one of these events occurs, a corresponding piece of JScript code, usually a JScript function, is executed. That function, in turn, is composed of various statements which perform calculations, examine or modify the contents of the Web page, or perform other tasks in order to respond in some way to that event. For example, pressing the Submit button on an online order form might invoke a JScript function that validates the contents of that form to ensure that the user entered all the required information.

In this section, we examine the syntax of JScript from the bottom up. We begin with the most basic concepts of how to write a JScript statement and what that statement does, and progress upward through more complex and powerful structures in subsequent sections, culminating in a detailed discussion of JScript functions and related concepts. Chapter 3 "Events and JScript," explores in greater detail how these elements are tied into Web pages through events.

In general, the elements of a JScript program can be divided into five categories, as follows:

• Variables and their values
• Expressions, which manipulate those values
• Control structures, which modify how statements are performed
• Functions, which execute a block of statements
• Objects and arrays, which are ways of grouping related pieces of data together

This set of categories is very similar to many other languages. As we examine each of these elements in subsequent sections, we will discover that JScript is somewhat minimalist in its approach. Many familiar elements, such as explicit data types (int, String, REAL), are missing or have been substantially simplified. However, JScript also provides a number of powerful object-oriented constructs which greatly simplify program organization. In this way, JScript has the expressive power of languages such as C or Java, while also having fewer rules to remember.

Variables and Values

One of the main differences between JScript and most other languages is that it does not have explicit data types. There is no way to specify that a particular variable represents an integer, a string, or a floating-point (real) number. Any JScript variable can be any of these-in fact, the same variable can be interpreted differently in different contexts.

All JScript variables are declared using the keyword var. A variable may be initialized, meaning that it is given a value when it is declared, or it may be uninitialized. In addition, multiple variables can be declared on the same line by separating their names with commas. For example, the statements:

var x = 7
var y,z = "19"
var lk = "lucky"

declare a variable named x with initial value 7, an uninitialized variable y and variables named z and lk whose initial values are "19" and "lucky," respectively. It might seem that x is an integer, z and lk are strings, and y is some undefined quantity. In fact, the real story is a little more complicated than this. The value of each variable depends on the context in which it is used. This context is related to the order in which the variables are seen. As you might guess, the expressions:

5 + x
lk + z

evaluate to 12 and "lucky19," seemingly confirming our suspicions about what they really are. However, it is also possible to form the expressions:

lk + x
x + z

which evaluates to "lucky7" and 26, respectively. In the first expression, x has been interpreted as a string, while in the second, z has been interpreted as an integer.

These examples illustrate two critically important points about the JScript language. First, while JScript does not have explicit data types, it does have implicit data types. Second, JScript has a set of conversion rules that allow it to decide how to treat a value based on the context in which it is used. The context is established by reading the expression from left to right. In the expression x + z, for example, x is implicitly a numerical value, so that JScript also attempts to view z as a number and perform the sum numerically. It succeeds, and the expected 26 results.

What would have happened if we had tried x + lk? The x variable occurs first on the left, and is really a number at heart. JScript thus tries to interpret the variable lk as a number, too. This is extremely unlucky, in fact, because "lucky" cannot be converted to a number (while z, the string "19" could). JScript reports an error if asked to evaluate x + lk. To understand JScript variables and values, therefore, it is necessary to understand its set of implicit types and how they may be converted to one another.

Before we enter into these details, let us consider one final example. In all the preceding cases, the uninitialized variable y was never used. What would be the value of an expression such as:

x = z + y

Of course, as in all other programming languages, the result of using an uninitialized variable is never good. Since y has never been given a value, there is no way this expression can be evaluated. It may result in something seemingly innocent, such as x being assigned the value of z, as if y were zero. It may also result in something much more serious, such as the value of x becoming something strange, or, more likely, a JScript error occurring. This leads to the following commonsense rule.

Implicit Data Types in JScript

There are five major implicit data types in JScript. A JScript value may be as follows:

• A number, such as -5, 0, or 3.3333
• A string, such as "Click Here" or "JScript"
• One of the logical values true or false
• A "nonatomic" JScript element, such as a function or object
• The special value null

Actually, it would be more correct to say that there are five categories of data type, because it is possible to distinguish two different types of numbers (integers and floating-point numbers), and many different types of JScript objects, functions, and other structured types. In fact, Part II of this book, "JScript Objects," is entirely devoted to explaining the many different JScript objects.

Variables and Variable Names. It is very important to distinguish between variables and their values. The statement x = 10 contains two components: the variable x and the literal value 10. A literal refers to anything that is referred to directly by its actual value. A variable is just an abstraction that provides a way of giving names to values. Thus, the statement x = 10 says, "I am going to refer to the concrete (literal) quantity 10 by the abstract (variable) name x," just as you might say, "I am going to call this lumpy thing I'm sitting on a chair." This also leads to the following important piece of advice.

Thus, because we have started out with x = 10, we should make sure that x always has some numeric value. There is no rule that prohibits us from later saying x = "Fortran," but this will generally lead to confusion or programming errors in most cases. No one will stop you from calling that lumpy thing you are sitting on "bacon and eggs," but many of your guests may become confused if you do so.

One final rule about variable names: A valid JScript variable name must begin with a letter or with the underscore character (_). Case is important, so that norl, NoRl, NORL, and _NORL are all valid JScript variable names that refer to different variables.

Numerical Values. There are two numeric types in JScript: integers and floating-point numbers. The rules for specifying both types are almost identical to those of C or C++ or Java. Integers may be specified in base 10 (decimal), base 8 (octal), or base 16 (hexadecimal) formats. The three forms are distinguished as follows, based on the first one or two characters:

• 1-9 followed by any set of digits is a decimal integer.
• 0 followed by any set of the digits 0-7 is an octal integer.
• 0x or 0X followed by any of 0-9, a-f, or A-F is a hexadecimal integer.

if ( ( x < 10 ) && ( -10 < x ) ) {             // if test
     y = ( x * x * x );                        // 1: cube of x
     ystr = "The cube of " + x + " is " + y;   // 2: informative string
}

In this example, the value of x is tested to see whether it is less than 10 and also greater than -10. If the result of this test is true, then the variable y is set equal to the expression x * x * x, known mathematically as the cube of x, in the statement 1 (labeled 1:). The variable ystr is then set to a string that expresses this cubic relationship between x and y, in statement 2. If x fails either of the two tests in the if test, neither of the two statements in the if block is executed.

It is easy to see even in this simple example that it is often desirable to have a contingency plan in case the if test is false. This leads to the second form of the if statement, the if...else control structure. In this form, one block of code is executed if the if test passes, and a second block is executed if it fails. The format of this type of if statement is as follows:

if ( condstmt ) {
     ifblock of statements
} else {
     elseblock of statements
}

In this form of the if statement, the if block is still executed if condstmt is true. However, in this case, the block of code following the else is executed if condstmt is false. Listing 2.2 shows an enhanced version of the code from Listing 2.1 using the if...else form.

Listing 2.2  The if...else Control Structure

if ( ( x < 10 ) && ( -10 < x ) ) {                // if test
     y = ( x * x * x );                           // 1: cube of x
     ystr = "The cube of " + x + " is " + y;      // 2: informative string
} else {                                          // false case
     y = null;                                    // 3: be paranoid; give y a Âvalue
     ystr = "Cannot compute the cube of " + x;    // 4: explain the failure
}

In this example, statements 1 and 2 are still executed if x meets both tests in the if test. If either test fails, statements 3 and 4 in the else block are executed instead. Statement 3 is another example of defensive programming. The variable y is given a value, albeit a meaningless value. This is done so that if y is used later, it will be guaranteed to have some value (even if we forgot to initialize it) regardless of whether the code flowed through the true part of the if (the if block) or the false part of the if (the else block).

Observe that ystr also gets a value no matter which of the two blocks is used. In the true case, it has the informative string documenting the cube of x; in the false case, it has a string indicating that the cube of x could not be computed. Because ystr will presumably be displayed to the user at some point, it is worthwhile to provide an error message. This is an example of parallel code design. Each conditional path modifies the same set of variables. For a simple case, such as Listing 2.2, it is easy to ensure that this happens. There are only two variables, y and ystr, and we can see exactly where they are set in every case. For more complicated, nested conditional expressions, it can become almost impossible to observe every variable in every case. Parallel code design is a good goal to strive for nonetheless.

The while Statement

The while statement is used to execute a block of code while a certain condition is true. The format of the while statement is as follows:

while ( condstmt ) {
     zero of more statements
     }

The condition clause condstmt is evaluated as a logical expression. If it is true, the block of statements between the braces is executed. The flow of control then loops back to the top of the while statement, and condstmt is evaluated again. This process continues until the condstmt becomes false, or until some statement within the block forces it to terminate. Each pass through the block of code is called an iteration. Figure 2.4 illustrates the basic structure of a while statement.

Figure 2.4 : JScript's while control structure executes a block of statements conditionally.

The first fundamental difference between a while statement and an if statement is that the while block may be executed many times, while the if or else blocks are executed once at most. You might well wonder how a while statement ever terminates. The code shown in Listing 2.3 illustrates a simple situation in which the while block eventually leads to the condstmt becoming false.

Listing 2.3  A while Loop which Adds a Sequence of Numbers

var x = 1;
var xsum = 0;

while ( x <= 10 ) {           // loop until x is greater than 10
     xsum += x;               // add x to the running sum xsum
     x++;                     // increment x
}

This code accumulates the sum of all the integers between 1 and 10, inclusive, in a variable called xsum. x starts out as 1, so that xsum initially becomes 1 as well. x is then incremented to 2 by the x++ statement. That value is then added to xsum, so that it becomes 1 + 2 = 3. This process continues until x finally becomes 11 and the x <= 10 condition is false. xsum at this point has the value 1 + 2 +…+ 9 + 10 = 55. Thus, the loop terminates. Note that it is critically important to initialize xsum to 0. If xsum is not initialized at all, then the statement xsum += x, which is just shorthand for xsum = xsum + x, gives an error. If xsum is initialized to something other than 0, the final result contains that initial value and is not just the sum of the integers from 1 through 10.

Listing 2.3 shows one way in which a while loop can terminate. Statements within the block may cause the conditional statement to become false. It could also happen that the conditional statement at the top of the while was never true, so that the statements within the block are not executed even once. If x had started with the value 20 in this example, the while test would have been immediately false, and the statements xsum += x and x++ would have never been executed. In this event, xsum would retain its initial value of 0.

Using the break Statement. There is a third way for a while loop to terminate. If the special statement break is encountered inside the while block, the loop is forced to terminate immediately. No further statements are executed, and the condstmt is not retested. Execution continues with the first statement after the end of the while block. Listing 2.4 gives an example of the use of the break statement.

Listing 2.4  A while Loop with an Internal break Statement

var x = 1;
var xoddsum = 0;
var xtmp = 0;
var lastx = 0;

while ( true ) {             // 1: loop forever (well, almost)
     xtmp = xoddsum + x;     // 2: compute a trial sum
     if ( xtmp > 100 )       // 3: if it is too large, then...
          break;             // 4: we are done
     xoddsum += x;           // 5: add x to the running sum xoddsum
     x += 2;                 // 6: increment x by 2
}
lastx = x;               // 7: save the final value of x in the variable
 lastx

The test clause of this while (statement 1) is true, which, you might well suspect, is always true. This means that there is no way for this loop to terminate unless it is forced to do so by a break statement. In statement 2, a temporary sum is formed in the variable xtmp. This sum is tested against the limit 100 in statement 3; if xtmp exceeds it, then statement 4, the break statement, is executed, and the loop terminates. If the test fails (xtmp is still less than 100), then the real sum is formed in statement 5. (Note that it would have been equivalent, and slightly more efficient, if we had written statement 5 as xoddsum = xtmp.) In statement 6, x is incremented by 2.

What does this while loop do? It keeps adding up numbers, odd numbers in fact, until the sum is less than 100. When the next sum would have exceeded 100, the if test succeeds, the break is executed, and the flow of control of the program reaches the first statement after the entire while block, namely statement 7. This statement saves the last value of x in a different variable, lastx. This construction computes the largest sequence of odd numbers that can be added without having the sum exceed 100. You can easily determine for yourself that the value of lastx must be 21, since 1 + 3 + … + 21 = 100 exactly, while 1 + 3 + … + 21 + 23 = 123 > 100.

The Perils of Infinite Loops. Listing 2.4 not only illustrates the use of break, it also shows two other elements worth noting. First, Listing 2.4 contains a nested conditional: There is an if statement inside the while block. This sort of construct is extremely common, and many levels of nesting are not at all unusual. Second, this example has another very common but somewhat troublesome feature. Since the while test is always true, there is no way for the while to terminate unless the break statement is executed. In the preceding example, it was quite quickly. Suppose, however, that statement 6 had been incorrectly entered as x -= 2. In this case, xoddsum would be getting constantly smaller and xtmp would never exceed 100. This type of error is known as an infinite loop. Listing 2.3 is not immune either, even though it has a conditional test rather than a blanket true. If the final statement of that example had been mistyped as x--, it would never terminate either.

Naturally, infinite loops must be vigorously avoided. They will terminate only when some kind of internal error happens (such as an arithmetic overflow when something becomes too large) or as a result of user intervention. Unfortunately, there is no foolproof way to write a while statement (or a for statement, as we shall see shortly) that is guaranteed to be correct. JScript is no different from any other programming language in this respect. However, the following general principles will reduce the opportunity for error:

• Avoid while ( true ) whenever possible.
• Have at least one way of exiting the loop body.

If the while ( true ) construction is used, then the logic that exercises the break statement must be correct. If this logic isn't correct, the loop will never terminate. If you restrict your use of while ( true ), you will have fewer infinite loops. The second suggestion is based on the observation that the more chances there are to exit the loop, the less likely it is that the loop will last forever. Listing 2.5 shows a modified version of Listing 2.4 in which we have moved the test on the sum to the while clause itself, and have also added a very paranoid test on the number of times through the loop (the variable loopcount).

Listing 2.5  An Improved Form of Listing 2.4

var x = 1;
var xoddsum = 0;
var lastx = 0;
var loopcount = 0;

while ( ( xoddsum + x ) < 100 ) {     // 1: loop while sum is < 100
     xoddsum += x;                    // 2: add x to the sum xoddsum
     x += 2;                          // 3: increment x by 2
     if ( ++loopcount > 1000 )        // 4: if we're working too late..
          break;                      // 5: quit
}
lastx = x;                         // 6: save the final value of x in lastx

This version satisfies both rules. Of course, the test in statement 4 is completely unnecessary. The code is simple enough that we can reassure ourselves that it is correct and will not go into an infinite loop. Once you are writing slightly more complicated while loops, you will find that there are usually multiple possible error conditions that arise. Every time you test for an error, you should consider using a break statement.

You will often see while ( true ) written as while ( 1 ). These are equivalent, since true has the numerical value 1, but the latter form is sloppy. The conditional portion of a while, if, or for statement should always be a true logical expression.

Using the continue Statement. There is another special statement that may be used inside while loops: the continue statement. The continue statement is used to force the flow of control back to the top of the while loop. When a continue statement is seen, all statements between it and the end of the while block are skipped, and execution continues at the top of the while. Listing 2.6 shows a simple use for the continue statement.

Listing 2.6  A continue Statement Returns to the Top of a while

var x = 0;
var xsum = 0;
var loopcount = 0;

while ( loopcount++ < 100 ) {   // 1: loop 100 times
     x++;                       // 2: increment x
     if ( ( x % 5 ) == 0 )      // 3: if x is divisible by 5
          continue;             // 4: skip it
     xsum += x;                 // 5: otherwise, add x to xsum
}

This example adds up every number between 1 and 100 that is not divisible by 5. The numbers that are divisible by 5 are skipped by virtue of statements 3 and 4. Statement 3 computes the remainder when x is divided by 5. If that remainder is 0, then x must be evenly divisible by 5. In that case, the conditional in statement 3 is true, and statement 4 is executed. The continue statement causes execution to continue back to the top of the loop at statement 1. This means that statement 5 is not executed, so the sum always misses those values of x which are divisible by 5, and only those values.

Many programmers would write line 3 as if ( ! ( x%5 ) ). While this style is very common, it is also confusing and a potential source of error. One problem with this form is that it confuses JScript types by using the numerical value x%5 as if it were a logical value. This form also hides the explicit test for zero of Listing 2.6. While this ! form is more compact, it is also more error-prone, and should be avoided.

One striking difference between this listing and previous ones is that x is initialized to 0, not 1, and x is incremented at the top of the loop, not at the bottom. If the x++ were at the bottom, what would happen? The values 1, 2, 3, and 4 would all be gleefully added into xsum. When x reached 5, however, statement 3 would be true, the continue in statement 4 would be executed, and both xsum += x and x++ would be skipped. x would stay equal to 5 forever! Since the x++ statement is critical to the correct functioning of the loop, it must occur before the continue. If it occurs after the continue, it will be skipped.

The for Statement

The for statement is the most powerful and complex of the three flow control constructions in JScript. The primary purpose of the for statement is to iterate over a block of statements for some particular range of values. The for statement has the following format:

for ( initstmt; condstmt; updstmt ) {
     forblock
}

The for clause, as shown, has three parts, separated by two mandatory semicolons. The initstmt is typically used to initialize a variable, although any valid statement may be used in this position. The initstmt is always executed exactly once, when the for statement is first encountered. The condstmt is a conditional test, and serves exactly the same function as in the while statement. It is tested at the top of each loop. The for statement terminates when this condition evaluates to false. The updstmt is executed at the bottom of each loop, as if it were placed immediately after the last statement in the for block. It is typically used to update the variable that is initialized by the initstmt.

Listing 2.7 shows a simple example of a for statement. In fact, the code in this listing accomplishes exactly the same task as the code in Listing 2.3. Note that this code does not bother to initialize x when it is declared. This is because the initstmt part of the for loop sets it equal to 1 immediately.

Listing 2.7  Adding Up a Sequence of Numbers Using for

var xsum = 0;
var x;

for ( x = 1; x <= 10; x++ ) {    // 1: loop while x is <= 10
     xsum += x;                  // 2: add x to xsum
}

In many ways, the for statement is very much like a fancy version of the while statement. Many of the observations that were made for while also hold true for the for statement. In particular, it is possible to use the break and continue statements within a for loop. One of the advantages of a for loop is that its update statement is executed on every pass through the loop, even those passes that are cut short by a continue. The continue skips every statement in the block, but it does not cause the update statement to be skipped. The for statement may also be used unwisely, just like the while statement. If the condstmt portion of the for clause is omitted, it is as if a true conditional had been used, so that something within the for block must force looping to terminate. You will occasionally see the construction for(;;), which is identical in meaning to while ( true ). The two semicolons are mandatory.

The for statement also has some unique features that are not shared by while. The first is that variables may actually be declared and initialized within the initstmt portion. In Listing 2.7, we could have dispensed with the external declaration of x and put var x = 1; as the initialization portion of the for loop. This is often very convenient, since the loop variable (x in this case) is often used only within the loop itself, making an external declaration pointless.

A second useful feature of the for statement is that both the initialization portion and the update portion of the for clause may contain multiple statements separated by the comma operator (,). Listing 2.8 shows another version of the code in Listing 2.6, rewritten so that both x and lcnt become loop variables.

Listing 2.8  A for Loop with Multiple Initialization and Update Statements

var xsum = 0;

for ( var x = 1, lcnt = 0; lcnt < 100; x++, lcnt++ ) {
     if ( ( x % 5 ) == 0 )          // if x is divisible by 5
          continue;                 // skip it
     xsum += x;                     // otherwise, add x to xsum
}

This usage underlines the fact that both x and lcnt are used only within the body of the for loop. It is also much more compact than its counterpart in Listing 2.6. In this example, we need not worry about the logical effect of the continue; we know that both x++ and lcnt++ will always be executed. This is also the most common and useful way to use the comma operator.

Finally, there is another form of the for statement that is used exclusively with objects and arrays in JScript: the for...in statement. We will see how this is used in Chapter 4 "JScript Objects." Figure 2.5 shows the basic structure of the for, while, and if statements, and the use of the break and continue statements within them.

Figure 2.5 : Control statements determine the flow of execution in JScript.

Functions and Objects

The basic statements, expressions, and operators that were discussed at the beginning of this chapter are what computer scientists usually call primitives. Primitives are the building blocks from which more complex elements of a program are constructed. The for, while, and if control structures represent the next higher level of organization in JScript. Each of these control structures deals with blocks of code whose execution is controlled by the various conditional tests and other clauses. The for, while, and if statements are all block-structured.

Functions and objects represent the highest level of organization within the JScript language. We will spend many chapters learning how to make effective use of these concepts. The purpose of this section is to introduce them and describe their basic features.

Functions

A function is a block of code that has a name. Whenever that name is used, the function is called, which means that the code within that function is executed. Functions may also be called with values, known as parameters, which may be used inside the body of the function. Functions serve two purposes. A function is an organizational tool, in the sense that it permits you to perform the same operation without simply copying the same code.

The second purpose of JScript functions is to link actions on a Web page with JScript code. Mouse clicks, button presses, text selections, and other user actions can call JScript functions by including suitable tags in the HTML source for the page.

The syntax for a function statement in JScript is as follows:

function Name ( listofparams ) {
     body
}

The function's Name is given immediately after the function keyword. All function names should be unique, and also should not conflict with any of the statement names which JScript itself uses. You cannot have a function named while, for example, and you should not have two functions both named UserHelp. The listofparams is a comma-separated list of the values that are passed into the function. These are referred to as the function's parameters, or arguments. This list may be empty, indicating that the function does not use any arguments (often called a void function). The function's body is the set of statements that make up the function. Listing 2.9 shows a function that adds up all the integers, starting at 1 and ending at a value given as the sole argument.

Listing 2.9  A Summation function

function summation ( endval ) {

     var thesum = 0;               // this variable will hold the sum

     for ( var iter = 1; iter <= endval; iter++ ) {
          thesum += iter;          // add the integer into the sum
     }                             // end of the for loop
     return( thesum );             // return the sum
}

This function does the same task that came up in the discussions of the while and for statements earlier in this chapter. Now that it has been written as a function, this code never needs to be repeated again. Anytime you want to form the sum 1 + 2 + … + N, you can simply call the function, as summation(N), and it will perform the task. Notice that the endval parameter is used as the argument to the function.

When the function is called, as summation(14) for example, the actual value 14 is used for endval within the function. The function then executes the for statement, with iter <= 14 as its termination condition, adding in each successive value into the variable thesum. When the for loop is done, the function executes the return statement. This causes the function to give the value inside the return statement back to the caller. This means that if we write:

var sum14;
sum14 = summation(14);

the variable sum14 is set to the value returned by the summation function when endval is given the value 14, namely 105. Functions can return any type of value, and are not restricted to returning integers.

There are several things to notice about this example. First of all, the variables thesum and iter, which are declared within the body of this function, are local variables. This means that they are known only within the body of this function, and are therefore completely unknown outside it. It is quite possible, even likely, that there are many functions all of which have a local variable named iter. All these various iters are unrelated. Changing the value of one of these iters would not affect any of the others. This is why the return statement is necessary; it is the only way to communicate the work of the function back to the caller.

This same restriction applies to the parameter endval as well. The arguments to a function may not be changed within that function. We could well have written endval = 15 just before the return statement in Listing 2.9. This statement would do nothing; It certainly would not change the caller's 14 into a 15. It might seem that every function would always have a return statement. This is not the case, however, because it is possible for a function to have side effects without actually returning a value. This happens by referencing external objects, which are our next topic.

Objects

Functions are used to provide a uniform method for organizing code. Objects serve the same purpose for data. Up to this point, the only data items we have seen are simple variables declared with var. Each of these typeless quantities can hold only a single value of some sort at a time. Objects provide the ability to hold multiple values, so that a group of related data elements can be associated with one another.

What JScript calls an object is called a data structure (or class) in many other languages. As with JScript functions, there are two aspects to JScript objects: creating them and using them. For the moment, we will defer the question of how to create objects and concentrate on how they are used. We will also see that a JScript-capable browser will provide a number of its own, built-in objects.

A JScript object is made up of a set of component parts, which are called its properties, or members. Suppose you have an object named appt which you are using to organize your appointments. The appointment object might have properties that specify the date and time of the appointment, as well as the name of the person with whom the appointment will take place. It might also have a general description field to remind you of the purpose of this meeting. Thus, you can imagine that the appt object will have the following properties:

• day
• month
• time
• who
• why

Each of the properties of the appt object is referenced using the dot operator (.). Thus, appt.month refers to the month property and appt.why gives us the reason for the appointment. These references may appear on both the right and left sides of an expression; we may get their values and also set them. Listing 2.10 shows a code fragment that tests the value of appt and displays a message about a current appointment.

Listing 2.10  Using the appt Object

if ( appt.day == Today ) {
     document.write('<BR>You have an appointment today<BR>');
     document.write('See ' + appt.who + ' at ' + appt.time + '<BR>');
     document.write(appt.why + '<BR>');
}

This example assumes that the variable Today has somehow been initialized with today's date, so that the equality test with appt.day is true only for today's appointments. If the test does succeed, then the three statements in the if block are executed. Each of these references document.write. The document object is a built-in object of the browser. This object has a member known as write, which is actually a function. Functional members of JScript objects are known as methods. This particular method takes a string and displays it on the current Web page.

Each of the three strings that are passed to document.write are constructed using + as a string concatenation operator. Each of them references one or more properties of the appt object in order to provide meaningful messages to the user. Each also includes <BR>, the HTML construction for a line break. This ability directly to issue HTML directives is one of the most powerful aspects of JScript, as it allows the programmer dynamically to modify the contents of Web pages using JScript functions and objects.

Once you learn more about the Date object, in "The Date Object" section of Chapter 5 you will be able to construct a much more satisfying version of this example. Even at this stage, however, the advantage of object-based programming should be apparent. Rather than carrying about many variables, you can use objects instead. Each object can contain all the variables of interest to a particular idea. It can also contain method functions that perform related work. Objects can even contain other objects, so that you can organize your data in a hierarchical structure. Subsequent chapters explore these ideas in much greater detail.