3 Environment
The Internet media type for JavaScript source code is application/x-javascript, but the unregistered text/javascript is more commonly used.
To embed JavaScript code in an HTML document, it must be preceded with:
Older browsers typically require JavaScript to begin with:
The comment markup is required in order to ensure that the code is not rendered as text by very old browsers which do not recognize the ('//' At the start of a line marks a Javascript comment, which prevents the '' from being parsed by the 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.
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.
There are two primary techniques for handling incompatibilities: browser sniffing and object detection. When there were only two browsers that had scripting capabilities (Netscape and Internet Explorer), browser sniffing was the most popular technique. By testing a number of "client" properties, that returned information on computer platform, browser, and versions, it was possible for a scripter's code to discern exactly which browser the code was being executed in. Later, the techniques for sniffing became more difficult to implement, as Internet Explorer began to "spoof" its client information, that is, to provide browser information that was increasingly inaccurate, (the reasons why Microsoft did this are often disputed). Later still, browser sniffing became something of a difficult art form, as other scriptable browsers came onto the market, each with its own platform, client, and version information.
Object detection relies on testing for the existence of a property of an object.
A more complex example relies on using joined boolean tests:
In the above, the statement "document.body.style" would ordinarily cause an error in a browser that does not have a "document.body" property, but using the boolean operator "&&" ensures that "document.body.style" is never called if "document.body" doesn't exist. This technique is called Lazy evaluation.
Today, a combination of browser sniffing, object detection, and reliance on standards such as the ECMAScript specification and Cascading Style Sheets are all used to varying degrees to try to ensure that a user never sees a JavaScript error message.
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.
Everything in JavaScript is either a primitive value or an object. Objects
are entities that have an identity (they are only equal to themselves) and that map property names to values.
That is, an object is an associative array similar to hashes in the Perl programming language, or dictionaries in Python, PostScript and Smalltalk.
JavaScript has several kinds of built in objects, namely Array, Boolean, Date, Function, Math, Number, Object, RegExp and String.
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. This means
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
Object hierarchy can be emulated in JavaScript. For example:
will result in the display:
A typical data structure is the Array, which is a map from integers to values. In Javascript, all objects can map from integers to values, but
Arrays are a special type of objects that has extra behavior and methods specializing in integer indices (e.g., join, slice, and
push).
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:
These two are equivalent. Its not possible to use the "dot"-notation or strings with alternative representations of the number:
Declaration of an array can use either an Array literal or the Array constructor:
This loop goes through all properties of an object (or elements of an array).
A function is a block with a (possibly empty) argument list that is normally given a name.
A function may give back a return value.
Example: Euclid's original algorithm of finding the greatest common divisor. (This is a geometrical solution which subtracts the longer segment from the shorter):
The number of arguments given when calling a function must not necessarily accord to the number of arguments in the function definition. Within the function the arguments may as well be accessed through the Every function is an instance of Function, a type of base object. Functions can be created and assigned like any other objects:
results in the display:
Most interaction with the user is done by using HTML form s which can be accessed through the HTML DOM.
However there are as well some very simple means of communicating with the user:
Text elements may be the source of various events which can cause an action if a ECMAScript event handler is registered. In HTML these event handler functions are often defined as anonymous functions directly within the HTML tag.
List of events
1 Blur is when the object is deselected or something else is selected instead. See also http://tech.irt.org/articles/js058/
Newer versions of JavaScript (as used in Internet Explorer 5 and Netscape 6) include a try ... catch error handling statement.
The Initially, the statements within the try block execute. If an exception is thrown, the script's control flow immediately transfers to the statements in the catch block, with the exception available as the error argument. Otherwise the catch block is skipped. Once the catch block finishes, or the try block finishes with no exceptions thrown, the statements in the finally block execute. This figure summarizes the operation of a try...catch...finally statement:
Here's a script that shows The finally part may be omitted:
JavaScript may be used for all aspects of client-side scripting of a web browser, however, some uses have become more ubiquitous than others. Common examples include image replacement, the creation of pop-up windows, and the validating of form content.
In most modern browsers, the following snippet of XHTML source code shows one way in which an image can be made to swap out with another image when a user moves their cursor over it (often called a rollover or mouse over effect). However similar behaviour can be achieved using only pure CSS.
A novel example of the use of JavaScript are Bookmarklets, small sections of code within web browser Bookmarks or Favorites.
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.
JavaScript for OSA (JavaScript OSA, or JSOSA), is a Macintosh scripting language based on the Mozilla 1.5 JavaScript implementation. It is a freeware component made available by Late Night Software. Interaction with the operating system and with third-party applications is scripted via a MacOS object. Otherwise, the language is virtually identical to the core Mozilla implementation. It was offered as an alternative to the more commonly used AppleScript language.
4 Incompatibilities
4.1 Combating Incompatibilities
5 Language elements
5.1 Variables
Variables are generally dynamically typed.
5.2 Objects
5.3 Data structures
5.4 Control structures
5.4.1 If ... else
if (condition) {
statements
}
[else {
statemesnts
}]
5.4.2 While loop
while (condition) {
statements
}
5.4.3 Do ... while
do {
statements
} while (condition);
5.4.4 For loop
for ([initial-expression]; [condition]; [increment-expression]) {
statements
}
5.4.5 For ... in loop
5.4.6 Switch statement
switch (expression) {
case label1 :
statements;
break;
case label2 :
statements;
break;
default :
statements;
}
5.5 Functions
arguments array.
5.6 User interaction
5.7 Events
2 Focus is when the object is selected, usually in a form.
5.8 Error handling
try ... catch ... finally statement catches exceptions resulting from an error or a throw statement . Its syntax is as follows:
try ... catch ... finally in action step by step.
6 Common Uses in Web Browsers
http://en.wikipedia.org/'"
onmouseover = "this.src='rollover.png'"
onmouseout = "this.src='normal.png'" />
7 Offspring
8 See also
9 References
10 External links
Major programming languages ( more)
Ada |
ALGOL |
APL |
AWK |
BASIC |
C |
C++ |
C# |
COBOL |
Delphi |
Eiffel |
Fortran |
Haskell |
IDL |
Java |
JavaScript |
Lisp |
LOGO |
ML |
Objective-C |
Pascal |
Perl |
PHP |
PL/I |
Prolog |
Python |
Ruby |
SAS |
Scheme |
sh |
Simula |
Smalltalk |
SQL |
Visual Basic
<Hide>