• Programming perl

JavaScript

Table of contents

1 Java and JavaScript 2 Usage 3 Environment 4 Incompatibilities 5 Language elements 5.1 Variables 5.2 Objects 5.3 Data structures 5.4 Control structures 5.4.1 If ... else 5.4.2 While loop 5.4.3 Do ... while 5.4.4 For loop 5.4.5 For ... in loop 5.4.6 Switch statement 5.5 Functions 5.6 User interaction 5.7 Events 5.8 Error handling 6 Offspring 7 See also 8 References 9 External links

Java and JavaScript

Usage

JavaScript embedded in a Web browser connects through interfaces called Document Object Models (DOMs) to applications, especially to the server side (web servers) and the client side web browser of internet applications. Many web sites use client-side JavaScript technology to create powerful dynamic web applications. It may use Unicode and can evaluate regular expressions (introduced in version 1.2 in Netscape Navigator 4 and Internet Explorer 4). JavaScript expressions contained in a string can be evaluated using the eval function.

One major use of Web-based 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.

Outside of the Web, JavaScript interpreters are embedded in a number of tools. The ActionScript interpreter inside PDF document readers such as Adobe's Acrobat Reader is JavaScript. The Mozilla platform, which underlies several common Web browsers, uses JavaScript to implement the user interface and transaction logic of its various products. JavaScript interpreters are also embedded in proprietary applications that lack scriptable interfaces. Finally, Microsoft's WSH technology supports JavaScript (via JScript) as an operating system scripting language.

When used outside a Web browsers, the interaction between JavaScript and the host system can be expressed in a number of ways. DOM standards might still be implemented, but other access techniques like COM, XPCOM, Java intefaces and Application Object Models are also equally possible.

JavaScript/ECMAScript is implemented by:

• KJS
• Rhino
• SpiderMonkey
• Narcissus
• NJS
• NGS
• Resin
• FESI
• SEE
• DMDScript

To embed JavaScript code in an HTML document, 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 web browsers. 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 such as Opera and Safari use other ECMAScript implementations, often with additional nonstandard properties to allow compatibility with JavaScript and JScript.

JavaScript and JScript contain several properties which are not part of the official ECMAScript standard, and may also miss several properties. As such, they are in points incompatible, which requires script authors to work around these bugs. JavaScript is more standards-compliant than Microsoft's JScript, which means that a script file written according to the ECMA standards will work for most browsers, except those based on Internet Explorer.

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

Objects

JavaScript has several kinds of built in objects, namely object, Array, string, Number, Boolean, Function, Date and Math. Other objects are "host objects", defined not by the language but by the runtime environment. In a browser, typical host 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. That mean that inheritance is between objects, not between classes (Javascript has no classes). Objects inherit properties from their prototypes.

One can add additional properties or methods to individual objects after they have been created. To do this for all instances created by a single constructor function, one can use the prototype property of the constructor to access the prototype object.

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()

Arrays have a length property that is guaranteed to always be larger than the largest integer index used in the array. It is automatically updated if one creates a property with an even larger index. Writing a smaller number to the length property will remove larger indices. This length property is the only special feature of Arrays, that distinguishes it from other objects.

Elements of Arrays may be accessed using normal object property access notation:

  myArray[1]
  myArray["1"]

  myArray.1 (syntax error)
  myArray["01"] (not the same as myArray[1])

 myArray = [0,1,,,4,5]; (array with length 6 and 4 elements)
 myArray = new Array(0,1,2,3,4,5); (array with length 6 and 6 elements)
 myArray = new Array(365); (an empty array with length 365)

Control structures

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

While loop

  while (condition) {
     statements
  }

  do {
     statements
  } while (condition);

For loop

  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)
           segmentA -= segmentB;
        else
           segmentB -= segmentA;
     return(segmentA);
  }

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

• Alert dialog box
• Confirm dialog box
• Prompt dialog box
• Status bar
• Console

List of events

• onAbort
• onBlur¹
• onChange
• onClick
• onDblClick
• onDragDrop
• onError
• onFocus²
• onKeyDown
• onKeyPress
• onKeyUp
• onLoad
• onMouseDown
• onMouseMove
• onMouseOut
• onMouseOver
• onMouseUp
• onMove
• onReset
• onResize
• onSelect
• onSubmit
• onUnload

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

Error handling

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
  }

The programming language used in Macromedia Flash (called ActionScript) bears a strong resemblance to JavaScript due to their shared relationship with ECMAScript. ActionScript has nearly the same syntax as JavaScript, but the object model is dramatically different.

See also

• CorbaScript
• LiveConnect
• DHTML

• ECMAScript Language Specification
• Proposal for Javascript 2.0
• Reference for JavaScript 1.5
• Reference for JavaScript 1.4
• Reference for JavaScript 1.3
• Useful JavaScript Collection
• Free JavaScript tutorials, reference, code, and help
• Reference for JavaScript 1.3
• Microsoft JScript resources in the MSDN Library
• W3Schools.com JavaScript Tutorials
• JavaScript Search Engine
• Crockford on Private Member Variables
• Tips & Tricks - "... studying and defeating browser incompatibilities. ..."
• JavaScript Test Page - see if your browser supports JavaScript
• Newsgroup

• Cooperation with ...
  • PHP
  • TCL
  • Perl

Source | Copyright