Essentials of Javascript - Cultural View

Client-side JavaScript 64
implementations include the handling of certain primitive values like "undefined", and the availability of methods
introduced in later versions of ECMAScript, such as the .pop(), .push(), .shift(), and .unshift() methods of arrays.
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
Mozilla family of browsers (Mozilla, Firefox and Netscape Navigator) 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 is less likely to work on browsers based on Internet Explorer. However, since
there are relatively few points of nonconformance, this is very unlikely.
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. As with HTML, it is thus advisable to write
standards-compliant code.
Combating incompatibilities
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.
function set_image_source ( imageName, imageURL )
{
if ( document.images ) // a test to discern if the 'document'
object has a property called 'images' which value type-converts to
boolean true (as object references do)
{
document.images[imageName].src = imageURL; // only executed if
there is an 'images' collection
}
}
A more complex example relies on using joined boolean tests:
if ( document.body && document.body.style )
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 minimal 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.