Skip to main content.

Web Based Programming Tutorials

Homepage | Forum - Join the forum to discuss anything related to programming! | Programming Resources

Web Programming Desktop Reference 6in1

Chapter 22 -- JavaScript Statements

Chapter 22

JavaScript Statements Java




The statements used to control program flow in JavaScript are similar to those used in Java and C. A statement can span several lines if needed or several statements can be placed on the same line.

There are a couple of important items to remember. First, blocks of statements, such as a function definition, must be enclosed in curly braces. This is how JavaScript delineates blocks of code. Second, a semicolon must be placed between all statements. Without a semicolon, script behavior is unpredictable.

Since JavaScript is not strict in its formatting, you must provide the line breaks and indentation to make sure the code is readable and easy to understand later.

break

break terminates the current for or while loop and passes control to the first statement after the loop.

Usage

The following example adds elements on a form, assuming that all the elements contain numeric values. If a 0 is encountered, the adding stops:

function checkValues(form) {
        var total
        for (I=0; I<=form.elements.length; I++) {
               if (element[I].value = "0") {
                       break; }
               else {
                       total += I;
                       document.write("The running total is  
        }
        return total
}

comment

These are notes from the script author that are ignored by the interpreter. Single line comments are preceded by //. Multiple line comments begin with /* and end with */.

Usage
/* These comments could start here
and
end
down here. */
...statements...
// This comment is limited to this line only.

continue

continue passes control to the condition in a while loop and to the update expression in a for loop. The important difference from break is that the loop is not terminated.

Usage

The following example adds elements on a form, assuming that all the elements contain numeric values. If a value less than 0 is encountered, it is not included in the running total:

function checkValues(form) {
        var total
        for (I=0; I<=form.elements.length; I++) {
               if (element[I].value < 0) {
                       continue; }
               else {
                       total += I;
                       document.write("The running total is "+total); }
        }
        return total

}

for

for creates a loop with three optional expressions enclosed in parentheses and separated by semicolons, followed by a set of statements to be executed during the loop:

for (initialExpression; condition; updateExpression) {
           statements...
}

The initial expression is used to initialize the counter variable, which can be a new variable declared with var.

The condition expression is evaluated on each pass through the loop. If the condition is true, the loop statements are executed. If the condition is omitted, then it defaults to true, and the loop continues until an error or break is reached.

The update expression is used to increment the counter variable. It is also optional and can be updated programatically within the loop statements.

Usage

for creates a loop that continues until an error occurs or a break statement is executed. The increment variable is increased by two each time through the loop:

for (var increment=0; ; increment+=2) {
...statements...
}

The following example is a loop that does not update its counter. If the counter is never updated in the course of the statements, then the value will remain ten:

for (var increment=10; increment<101; ) {
...statements...
}

for…in

This iterates a variable for all of properties of an object. For each property, for...in
executes the statement block:

for (objectVariable) {
...statements...
}
Usage

for...in is a useful function for debugging because of its ability to display all of the properties of an object in one loop:

function objectDisplay (obj) {
        var displayLine;
        for (var prop in obj) {
               displayLine = obj.name + "." + prop + " = " + obj[prop];
               document.write(displayLine + "<BR>")
        }
        document.write("End of object " + obj.name)
}

function

This declares a JavaScript function with a name and parameters. To return a value, the function must include a return statement. A function definition cannot be nested within another function:

function name ([parameter [...,parameter]]) {
          statements...
}

if…else

A conditional statement that executes the first set of statements if the condition is true and the statements following else if false. if...else statements can be nested to any level. If single statements are used after the statements, curly braces are not needed:
if (condition) {
        ...statements...
} [else {
        ...statements...
}]
Usage

The following example converts minutes to a two-digit number for use in a clock display:

function makeMinutes() {
var minString = "";
var now = new Date();
var min = Date.getMinutes();
if (min < 10) {
minString += ":0" + min; }
else {
minString += ":" + min; }
return minString
}

return

return specifies a value to be returned by a function:

return expression;

Usage

The following example takes three strings and puts them together, separated by commas:

function stringAssemble (string1, string2, string3) {
       return string1 + ", " + string2 + ", " + string3
}

var

var declares a variable and optionally initializes it to a value. The scope of a variable is the current function or-when declared outside a function-the current document:

var variableName [=value] [..., variableName [=value]]
Usage

The globalString variable can be used in any function or script in the current document, where