JavaScript

Table of contents

1 Java and JavaScript 2 Usage 3 Environment 4 Language elements 4.1 Variables 4.2 Data structures 4.3 Objects 4.4 Control structures 4.4.1 If ... else 4.4.2 While loop 4.4.3 Do ... while 4.4.4 For loop 4.4.5 For ... in loop 4.4.6 Switch expression 4.5 Functions 4.6 User interaction 4.7 Events 4.8 Error handling 5 Offspring 6 External links

Java and JavaScript

Usage

One major use of JavaScript is to write little functions that are embedded in HTML pages and interact with the DOM of the browser to perform certain tasks not possible in static HTML alone, such as opening a new window, checking input values, changing images as the mouse cursor moves over etc. Unfortunately, the DOMs of browsers are not standardized, different browsers expose different objects or methods to the script, and it is therefore often necessary to write different variants of a JavaScript function for the various browsers.

JavaScript/ECMAScript is implemented by:

• KJS
• Rhino
• SpiderMonkey
• NJS
• NGS

The Internet media type for JavaScript source code is text/javascript. To put JavaScript code in an HTML page, precede it with

HTML elements[1] may contain intrinsic events to which you can associate a script handler. To write valid HTML 4.01, insert the following declaration for the default scripting language in the header section of the document.

Variables

Variables are generally dynamically typed. Variables are defined by either just assigning them a value or by using the var statement. Variables declared outside of any function are in "global" scope, visible in the entire web page; variables declared inside a function are local to that function. To pass variables from one page to another, a developer can set a cookie or use a hidden frame or window in the background to store them.

Data structures

The primary data structure is an associative array similar to hashes in the Perl programming language, or dictionaries in Python, PostScript and Smalltalk.

Elements may be accessed by numbers or associative names (if defined with them). Thus the following expressions may all be equivalent:

  myArray[1], 
  myArray.north, 
  myArray["north"].

 myArray = new Array(365);

Objects

JavaScript has several kinds of built in objects, namely Object, Array, String, Number, Boolean, Function, Date and Math. Other objects belong to the DOM (window, form, links etc.).

By defining a constructor function it is possible to define objects. JavaScript is a prototype based object-oriented language. One can add additional properties or methods to individual objects after they have been created. To do this for all instances of a certain object type one can use the prototype statement.

Example: Creating an object

// constructor function
function MyObject(attributeA, attributeB) {
  this.attributeA = attributeA
  this.attributeB = attributeB
}

// create an Object
obj = new MyObject('red', 1000)

// access an attribute of obj
alert(obj.attributeA)

// access an attribute with the associative array notation
alert(obj["attributeA"])

function Base()
{
  this.Override = _Override;
  this.BaseFunction = _BaseFunction;
  function _Override()
  {
    alert("Base::Override()");
  }
  function _BaseFunction()
  {
    alert("Base::BaseFunction()");
  }
}

function Derive()
{
   this.Override = _Override;
   function _Override()
   {
     alert("Derive::Override()");
   }
}
Derive.prototype = new Base();

d = new Derive();
d.Override();
d.BaseFunction();

Derive::Override()
Base::BaseFunction()

If ... else

  if (condition) {
     statements
  }
  [else {
     statements
  }]

  while (condition) {
     statements
  }

  do {
     statements
  } while (condition);

  for ([initial-expression]; [condition]; [increment-expression]) {
     statements
  }

  for (variable in object) {
     statement
  }

  switch (expression) {
     case label1 :
        statements;
        break;
     case label2 :
        statements;
        break;
     default :
        statements;
  }

  function(arg1, arg2, arg3) {
     statements;
     return expression;
  }

  function gcd(segmentA, segmentB) {
     while(segmentA!=segmentB) { 
        if(segmentA>segmentB) {
           solution = segmentA - segmentB;
           }
        else {
           solution = segmentB - segmentA;
           }
        }
     return(solution);
     }

Every function is an instance of Function, a type of base object. Functions can be created and assigned like any other objects:

   var myFunc1 = new Function("alert('Hello')");
   var myFunc2 = myFunc1;
   myFunc2();

   Hello

See also http://tech.irt.org/articles/js058/

Error handling

Newer versions of JavaScript (as used in Internet Explorer 5 and Netscape 6) include a try ... catch error handling statement.

The try ... catch ... finally statement catches exceptions resulting from an error or a throw statement. Its syntax is as follows:

  try {
     // Statements in which exceptions might be thrown
  } catch(error) {
     // Statements that execute in the event of an exception
  } finally {
     // Statements that execute afterward either way
  }

Here's a script that shows try ... catch ... finally in action step by step.

  try {
     statements
  }

  catch (err) {
     // handle error
  }
  finally {
     statements
  } 

  try {
     statements
  }
  catch (err) {
     // handle error
  }

A novel example of the use of JavaScript are Bookmarklets, small sections of code within browser Bookmarks or Favorites.

A similar programming language like JavaScript is used in Macromedia Flash. There it is called ActionScript.

External links

• The ECMAScript Language Specification is available from http://www.ecma-international.org/publications/standards/ECMA-262.HTM
• Proposal for Javascript 2.0
• Reference for JavaScript 1.5
• Reference for JavaScript 1.4
• Reference for JavaScript 1.3
• Microsoft JScript resources in the MSDN Library
• W3Schools.com JavaScript Tutorials
• JavaScript Search Engine