JavaScript

JavaScript (JS) is the dominant client-side scripting language of the Web. JS is a dynamic (or interpreted: Executes somethings at run-time instead of at compiling), weakly-typed (or loosely-typed: A variable may change its data type), prototype-based (object oriented but instead of classes, the .prototype of an instance affects all other instances) programming language with first-class functions (functions can be first-class objects which allows their creation and modification at run-time) and closures (functions can enclosed as a parameter of another function AND can refer to bound variables, i.e. variables visible at the time the enclosing function was defined).

History

JavaScript was developed by Brendan Eich at Netscape Communications Corporation, first as Mocha, then as LiveScript, then as JavaScript as part of the Netscape browser v2.0B3 in 1995-12. JavaScript has no relation to Java other than they both use a syntax similar to the c language and that Java was the hot new language at the time. EG: c is a procedural language, while c++ is class-based object oriented language, while JavaScript is a prototype-based object oriented language (like the language Self). JavaScript became widely popular and Microsoft implemented it as JScript in Internet Explorer 3.0 in 1996-08. Netscaped submitted JavaScript to Ecma International for standardization, which resulted in ECMA-262 or ECMAScript in 1997-06. Since then ECMAScript is the standard and it has various dialects, some with their own extensions, and some (EG: Flash's ActionScript) that are quite different. The main dialects includes Netscape's/Mozilla's JavaScript and Microsoft's JScript.

Variations

JavaScript is famous for its "client-side" use, i.e. on the user's browser.There are several major rendering engines or application frameworks (each used by one or more browsers), and each rendering engine has its own JavaScript engine. JavaScript may also be used on the "server-side" and other scenarios.

• ActionScript. The Adobe dialect of the ECMAScript. Especially for Flash and Flex applications.
• Gecko layout engine. Developed by Mozilla but started by Netscape in 1997. Used by browsers like Firefox (cross platform), Camino (for Mac OS), Flock (cross platform), Netscape Navigator 9 (cross paltform), Galeon (GNOME/Linux), Epiphany (GNOME/Linux),and K-Meleon (for Windows), as well as the SeaMonkey (cross platform) Internet suite.
  • SpiderMonkey JavaScript engine. Written in c. Used server-side and client-side. The original JavaScript written by Brendan Eich for Netscape, but now managed by Mozilla where Eich is CTO (2008).
    • SpiderMonkey [mozilla.org/js/spidermonkey]. Official site.
    • Resources for JavaScript/ECMAScript [http://research.nihonsoft.org/javascript/index.nsp]. It's possible to find archived references for older version of JavaScript still out there! This stuff (1.0, 1.1, 1.2, 1.3, 1.4, and 1.5) was from the old developer.netscape.com site.
    • JavaScript [http://developer.mozilla.org/en/docs/JavaScript]. JavaScript as maintained by the Mozilla Development Center (MDC). Includes JavaScript versions 1.5, 1.6, 1.7, and 1.8.
• KHTML layout engine. Written in c++. Used by the Konqueror browser for Unix-like systems.
  • KDE's JavaScript (KJS) engine.
• Presto layout engine. Used by the Opera browser. Replaced the Elektra layout engine.
  • linear_b JavaScript engine. Used in Opera 7-9.27.
  • futhark JavaScript engine. Used in Opera 9.5+.
• Rhino JavaScript engine. Developed by Sun but managed by Mozilla. Open source and written in Java. Used especially on the server-side.
  • Rhino [mozilla.org/rhino]. Official site.
• Trident (aka MSHTML) layout engine. Developed by Microsoft. Used by the Internet Explorer (cross platform) browser version 4+.
  • JScript. The Microsoft dialect of ECMAScript. Includes three variations of JScript: "Classic JScript" (which is very much like JavaScript), Managed JScript, and JScript .NET.
    • JScript [http://msdn.microsoft.com/en-us/library/hbxc2t98(VS.85).aspx]. Official site for "Classic JScript". (Note that MSDN changes their links often.) Used both client-side via Internet Explorer browser and server-side via IIS.
    • JScript .NET [http://msdn.microsoft.com/en-us/library/72bd815a(VS.71).aspx]. Official site for JScript .NET. (Note that MSDN changes their links often.)
• WebKit application framework. An open source fork from the KHTML layout engine. Written in c++. Used by the browsers like Apple Safari (for MacOS and Windows), Google Chrome (for Windows but MacOS and Unix coming), OmniWeb (for MacOS), Shiira (for MacOS), and iCab (for MacOS), as well as the Adobe Integrated Runtime (Adobe AIR) runtime environment.
  • WebKit [webkit.org]. Official site.
  • WebCore rendering engine
  • JavaScriptCore JavaScript engine. Later versions called SquirrelFish. Derived from KDE's JavaScript (KJS) engine.
  • V8 JavaScript engine. Used in the Chrome browser. Written in c++. Open source.
    • Google V8 JavaScript Engine [code.google.com/p/v8/]. Official site. Used especially in the Chrome browser.
  • Drosera JavaScript debugger. Comes with WebKit.

Libraries

Except for the simplest of sites, it seems that the days are slipping when you could make a site with your own HTML, CSS, AJAX, and JavaScript on the client-side, plus whatever on the server-side. See http://www.surveymonkey.com/sr.aspx?sm=fXLiKcnKlD6cO5bRe961aBB6NCCWytRyY3rParAYmwA_3d. Now it seems that you have to use a library, as in the old build v buy argument. It's not simply for pretty stuff but for serious business stuff like data grids. They're calling them {AJAX | Widget | Web App} {Toolkits | Frameworks} these days. You can simply call them JavaScript libraries on the client-side, but on the server-side it's usually some other language generating JavaScript, CSS, and HTML for the client-side.

The top client-side JavaScript libraries are (in rough order):

• Prototype JavaScript Framework
• jQuery
• Ext
• Script.aculo.us
• Yahoo! User Interface (YUI)
• Dojo Toolkit
• Midori
• MochiKit
• qooxdoo
• Rialto
• Spry

The top server-side "JavaScript" libraries include:

• Backbone. Java.
• Web Toolkit (GWT). Java
• Echo. Java
• ASP.NET AJAX. .Net. Will incorporate jQuery soon: "jQuery, Microsoft, and Nokia" [http://jquery.com/blog/2008/09/28/jquery-microsoft-nokia/].

There are libraries with more specific uses that are often included. Here are a few arbitrary ones:

• Datejs. For dates.
• Some Lightbox [W] variation for pretty pictures.

Miscellany

Here are some miscellaneous items regarding JavaScript.

• Special characters can be inserted into literal strings, including the following that correspond with the escaped characters in Regular Expressions: \b\t\n\v\r\e\"\'\cx\on\xn\un.
• JS uses the try ... catch ... finally and throw statements for error handling.VBS uses On Error and Next for error handling.
• JS is case sensitive. VBS is not.
• JS allows implicit or explicit variable declarations.
  • JS has no way of requiring explicit decarations like the Option Explicit feature of VBS.
  • There are general two scopes in JS: function scope and application/global scope.
  • If a variable is used that has not been explicitly declared with var, then JS assumes implicit variable declaration and that the variable is of the application/global scope.
  • The delete operator can be used on an implicitly declared variable but not an explicitly declared one or those part of the JS language.
• JS is available for client-side scripting on most browsers, whereas VBS is usually available only for Microsoft Internet Explorer.
• JS probably has a larger body of resources and code out there than VBS because JS has been around longer.
• There are two types of JavaScript comments:

  //This is a single line comment.

  /* This is the start of a multi-line comment. 
  This is the end of a multi-line comment. */

• An HTML <a> tag can call a JS function directly with this syntax: <a href="javascript:functionName()">.
• Script within a <script> tag is often enclosed in an SGML comment declaration so that non-script using browsers can ignore the script. The close of the SGML comment is often commented out with a JS comment. EG:

  <script type="text/JavaScript">
  <!-- //Hide script from no-script browsers.
      Multiple lines of script may go here.
  //End with a JS comment. -->
  </script>

• JS is weakly-typed (loosely-typed): A variable may change its data type. This is powerful but can be a common source of errors so a clear understanding of this is needed and developers must be keenly aware of any automatic type-conversions (type-castings).
  • Here are only 6 types in JS: boolean, function, number, object (includes null, arrays, and regexps), string, and undefined. In an ideal world null, array, and regexp would be their own types in order to match the JS Standard objects.
  • For evaluating expressions as a boolean in JS: If expression is omitted or evaluates to 0, -0, null (not 'null'), false (not 'false'), NaN (not 'NaN'), undefined (not 'undefined'), or an empty string ("" or ''), then the object has an initial value of false. All other values will evaluate to true. EG:

    null==undefined;   //auto type-conversion, so true
    null===undefined;  //strict or no type-conversion, so false

  • For evaluating expressions as numbers in JS: Literal integers (EGs: 13, 07 (octal), 0xF7 (hexadecimal)) and floating-point literals (EGs: 3, 3.1, -3.2e-7) have the value stated, but others depend on context. undefined variables get treated as NaN. null variables get treated as 0. Empty string can be 0 (EG: Number("")) or can auto type-convert its neighbors (EG: 8+""+8 yields 88 not 16).
  • A mixture of types can only occur for binary operators. If a given binary operator only supports one type, then both pieces of data for that operator must either be of that type, or convertible to that type, otherwise an error results.
    • For + operators, if either argument is a String or converts preferentially to one, then it does string concatenation, not numeric addition. Otherwise, if neither argument prefers to be a string, then it does numeric addition. (Short version: "+ is either string")
    • For >, >=, <, <= operators, if neither argument can be converted to a number, then it does string comparison, not numeric comparison. Otherwise, if at least one argument can be converted to a number, then it does numeric comparison. (Short version: "compare is neither number")
    • For ==, != operators, first convert any Objects to their preferred primitive types. If the types are still different, convert any Boolean to a Number. If the types are still different, convert the non-Number argument to Number and compare as Numbers. Exception: null==undefined without any conversion defined.
  • Force the conversion if mixed types must be compared. EG:

    x = ( a+'' == b+'')  //String comparison forced  
    x = ( a -0 == b -0)  //Number comparison forced  
    x = ( !a   == !b  )  //Boolean comparison forced

  • Avoid comparing things with null, instead trust that the conversion to the Boolean type will work. EG:

    if ( a != null) { ...}   //may be buggy
    if ( a        ) { ...}   //better

  • On the other hand, the variable you get may have been explicitly converted into a string at some point, in which case then you can check for literal "null", "undefined", "true", "false", etc.
• JS can only handle event procedures by explicitly linking an object with a function. EG: <img .... onmouseover="RunMe()">. VBS on the other hand can also handle event procedures by making procedures whose name follows this syntax: Object_Event(). Multiple JS statements can be included in the explicit event link.

Page Modified: (Hand noted: 2008-03-17 22:30:42Z) (Auto noted: 2008-10-16 20:50:59Z)