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, but application/x-javascript is an unofficial MIME type which is also used.

To put JavaScript code in an HTML page, it must be preceded with

 <script type="text/javascript">

 </script>

 <script language="JavaScript" type="text/javascript">
 <!--

 // -->
 </script>

 <script type="text/javascript">
 //<![CDATA[

 //]]>
 </script>

HTML elements[1] may contain intrinsic events to which you can associate a script handler. To write valid HTML 4.01, the web server should return a 'Content-Script-Type' with value 'text/javascript'. If the web server cannot be so configured, the website author can optionally insert the following declaration for the default scripting language in the header section of the document.

  <meta http-equiv="Content-Script-Type" content="text/javascript" />

Javascript, like HTML, is often not compliant to standards, instead being built to work with specific webbrowser quirks. The current ECMAScript standard should be the base for all Javascript implementations in theory, but in practice the Netscape (and Mozilla) browsers use JavaScript, Microsoft Internet Explorer uses JScript, and other browsers like Opera and Safari use an ECMAScript implementation with additional nonstandard properties.

JavaScript and JScript contain several properties which are not part of the official ECMAScript standard, and also miss several properties. As such, they are in points incompatible, which requires script authors to work around these bugs.

This also means every browser may treat the same script differently, and what works for one browser may fail in another browser, or even in a different version of the same browser. Like with HTML, it is thus advisable to write standards-compliant code.

MSIE's VBScript is NOT JavaScript, and it is incompatible with the ECMA standard.

Language elements

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