JavaScript syntax

The syntax of JavaScript is a set of rules that defines what constitutes a valid program in the Javascript language.

Origin of Syntax

Brendan Eich summarized the ancestry of the syntax in the first paragraph of the JavaScript 1.1 specification as follows:

JavaScript borrows most of its syntax from Java, but also inherits from Awk and Perl, with some indirect influence from Self in its object prototype system.

Variables

Variables in standard JavaScript have no type attached, and any value can be stored in any variable. Variables can be declared with a var statement. These variables are lexically scoped and once a variable is declared, it may be accessed anywhere inside the function where it is declared. Variables declared outside any function, and variables first used within functions without being declared with 'var', are global. Here is an example of variable declarations and global values:

x = 0; // A global variable
var y = 'Hello!'; // Another global variable
 
function f(){
  var z = 'foxes'; // A local variable
  twenty = 20; // Global because keyword var is not used
  return x; // We can use x here because it is global
}
// The value of z is no longer available

Basic data types

Numbers

Numbers in JavaScript are represented in binary as IEEE-754 Doubles, which provides an accuracy to about 14 or 15 significant digits JavaScript FAQ 4.7. Because they are binary numbers, they do not always exactly represent decimal numbers, particularly fractions.

This becomes an issue when formatting numbers for output, which JavaScript has no built-in methods for. For example:

alert(0.94 - 0.01); // displays 0.9299999999999999

As a result, rounding should be used whenever numbers are formatted for output. The toFixed() method is not part of the ECMAScript specification and is implemented differently in various environments, so it can't be relied upon.

Numbers may be specified in any of these notations:

345;    // an "integer", although there is only one numeric type in JavaScript
34.5;   // a floating-point number
3.45e2; // another floating-point, equivalent to 345
0377;   // an [[octal]] integer equal to 255
0xFF;   // a [[hexadecimal]] integer equal to 255, the letters A-F may be upper- or lowercase

In some ECMAScript implementations such as ActionScript, RGB color values are sometimes specified with hexadecimal integers:

var colorful = new Color( '_root.shapes' );
colorful.setRGB( 0x003366 );

The Number constructor may be used to perform explicit numeric conversion:

var myString = "123.456";
var myNumber = Number( myString );

When used as a constructor, a numeric wrapper object is created, (though it is of little use):

myNumericWrapper = new Number( 123.456 );

Arrays

An Array is a map from integers to values. In JavaScript, all objects can map from integers to values, but Arrays are a special type of object 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:

myArray[1];
myArray["1"];

The above two are equivalent. It's not possible to use the "dot"-notation or strings with alternative representations of the number:

myArray.1;     // syntax error
myArray["01"]; // not the same as myArray[1]

Declaration of an array can use either an Array literal or the Array constructor:

myArray = [0,1,,,4,5];            // array with length 6 and 6 elements, including 2 undefined 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

Arrays are implemented so that only the elements defined use memory; they are "sparse arrays". Setting myArray[10] = 'someThing' and myArray[57] = 'somethingOther' only uses space for these two elements, just like any other object. The length of the array will still be reported as 58.

You can use the object declaration literal to create objects that behave much like associative arrays in other languages:

dog = {"color":"brown", "size":"large"};
dog["color"]; // this gives you "brown"

You can use the object and array declaration literals to quickly create arrays that are associative, multidimensional, or both.

cats = [{"color":"brown", "size":"large"},
        {"color":"black", "size":"small"}];
cats[0]["size"]; // this gives you "large"

dogs = {"rover":{"color":"brown", "size":"large"},
        "spot":{"color":"black", "size":"small"}};
dogs["spot"]["size"]; // this gives you "small"

Strings

Strings in Javascript are a sequence of characters. Strings in JavaScript can be created directly by placing the series of characters between double or single quotes.

var greeting = "Hello, world!";
var another_greeting = 'Greetings, people of Earth.';

In Mozilla based browsers, individual characters within a string can be accessed (as strings with only a single character) through the same notation as arrays:

var h = greeting[0]; // Now h contains 'H' - Works in Mozilla based browsers

But, for Internet Explorer, you have to access the individual characters using the charAt() method (provided by String class). This is the preferred way when accessing individual characters within a string, as it also works in Mozilla based browsers:

var h = greeting.charAt(0); // Now h contains 'H' - Works in both Internet Explorer 
                            // and Mozilla based browsers

however, JavaScript strings are immutable:

greeting[0] = "H"; // ERROR

Applying the equality operator ("==") to two strings returns true if the strings have the same contents, which means: of same length and same cases (for alphabets). Thus:

var x = "world";
var compare1 = ("Hello, " + x == "Hello, world"); // Now compare1 contains true
var compare2 = ("Hello, " + x == "hello, world"); // Now compare2 contains false since the
                                                  // first characters of both operands are
                                                  // not of the same case

Objects

The most basic objects in JavaScript act as dictionaries. These dictionaries can have any type of value paired with a key, which is a string. Objects with values can be created directly through object literal notation:

var o = {name: 'My Object', purpose: 'This object is utterly without purpose.', answer: 42};

Properties of objects can be created, set, and read individually using the familiar dot ('.') notation or by a similar syntax to arrays:

var name = o.name; // name now contains 'My Object'
var answer = o['answer']; // answer now contains 42

Object literals and array literals allow one to easily create flexible data structures:

var myStructure = {
  name: {
    first: "Mel",
    last: "Smith"
  },
  age: 33,
  hobbies: [ "chess", "jogging" ]
};

This is the basis for JSON, which is a simple notation that uses JavaScript-like syntax for data exchange.

Operators

The '+' operator is overloaded; it is used for string concatenation and arithmetic addition and also to convert strings to numbers. It also has special meaning when used in a regular expression.

// Concatenate 2 strings
var a = 'This';
var b = ' and that';
alert(a + b);  // displays 'This and that'
  
// Add two numbers
var x = 2;
var y = 6;
alert(x + y); // displays 8

// Adding a string and a number results in concatenation
alert( x + '2'); // displays 22

// Convert a string to a number
var z = '4';   // z is a string (the digit 4)
alert( z + x); // displays 42
alert( +z + x);// displays 6

Arithmetic

Binary operators

+     Addition
-     Subtraction
*     Multiplication
/     Division (returns a floating-point value)
%     Modulus (returns the integer remainder)

Unary operators

-     Unary negation (reverses the sign)
++    Increment (can be prefix or postfix)
--    Decrement (can be prefix or postfix)

Assignment

=     Assign
+=    Add and assign
-=    Subtract and assign
*=    Multiply and assign
/=    Divide and assign
%=    Modulus and assign

var x = 1;
x *= 3;
document.write( x );  // displays: 3
x /= 3;
document.write( x );  // displays: 1
x -= 1;
document.write( x );  // displays: 0

Comparison

==    Equal
!=    Not equal
>     Greater than
>=    Greater than or equal to
<     Less than
<=    Less than or equal to

===   Identical (equal and of the same type)
!==   Not identical (since JavaScript is [[weakly typed]], != works as well)

Boolean

JavaScript has three logical boolean operators: && (logical AND), || (logical OR), and ! (logical NOT).

In the context of a boolean operation, all JavaScript values evaluate to true unless the value is the boolean false itself, the number 0, a string of length 0, or one of the special values null, undefined, or NaN. The Boolean function can be used to explicitly perform this conversion:

Boolean( false );     // returns false
Boolean( 0 );         // returns false
Boolean( 0.0 );       // returns false
Boolean( "" );        // returns false
Boolean( null );      // returns false
Boolean( undefined ); // returns false
Boolean( NaN );       // returns false
// ONLY empty strings return false
Boolean("false");     // returns true
Boolean("0");     // returns true

The unary NOT operator ! first evaluates its operand in a boolean context, and then returns the opposite boolean value:

var a = 0;
var b = 9;
!a; // evaluates to true,  same as (Boolean( a ) == false)
!b; // evaluates to false, same as (Boolean( b ) == true)

A double use of the ! operator can be used to normalize a boolean value:

var arg = null;
arg = !!arg; // arg is now the value false, rather than null

arg = "finished"; // non-empty string
arg = !!arg; // arg is now the value true

In the earliest implementations of JavaScript and JScript, the && and || operators behaved in the same manner as their counterparts in other C derived programming languages, in that they always returned a boolean value:

x && y; // returns true if x AND y evaluate to true: (Boolean( x ) == Boolean( y ) == true), false otherwise
x || y; // returns true if x OR y evaluates to true, false otherwise

In the newer implementations, these operators return one of their operands:

expr1 && expr2; // returns expr1 if it evaluates to false, otherwise it returns expr2
expr1 || expr2; // returns expr1 if it evaluates to true, otherwise it returns expr2

This novel behavior is little known even among experienced JavaScripters, and can cause problems if one expects an actual boolean value.

• Short-circuit logical operations means the expression will be evaluated from left to right until the answer can be determined. For example:

a || b is automatically true if a is true. There is no reason to evaluate b. a && b is false if a is false. There is no reason to evaluate b.

&&    and
||    or
!     not (logical negation)

Bitwise

Binary operators

&     And
|     Or
^     Xor

<<    Shift left  (zero fill)
>>    Shift right (sign-propagating); copies of the leftmost bit (sign bit) are shifted in from the
      left.
>>>   Shift right (zero fill)

      For positive numbers, >> and >>> yield the same result.

Unary operators

~     Not (inverts the bits)

String

=     Assignment
+     Concatenation
+=    Concatenate and assign

Examples

str = "ab" + "cd";   // "abcd"
str += "e";          // "abcde"

Control structures

If ... else

 if (expr)
 {
   //statements;
 }
 else if (expr2)
 {
   //statements;
 }
 else
 {
   //statements;
 }

Conditional operator

The conditional operator creates an expression that evaluates as one of two expressions depending on a condition. This is similar to the if statement that selects one of two statements to execute depending on a condition. I.e., the conditional operator is to expressions what if is to statements.

 var result = (condition) ? expression : alternative;

is the same as:

 if (condition)
 {
   result = expression;
 }
 else
 {
   result = alternative;
 }

Unlike the if statement, the "else-branch" of the conditional operator cannot be omitted.

Switch statement

 switch (expr) {
   case SOMEVALUE: 
     //statements;
     break;
   case ANOTHERVALUE: 
     //statements;
     break;
   default:
     //statements;
     break;
 }

• break; is optional; however, it's recommended to use it in most cases, since otherwise code execution will continue to the body of the next case block.
• Add a break statement to the end of the last case as a precautionary measure, in case additional cases are added later.
• Strings can be used for the case values.
• Braces are required.

For loop

 for (initial;end-condition;loop statement) {
   /*
     statements will be executed every time
     the for{} loop cycles, until the ending
     condition is satisfied
   */
 }

or

 for (initial;end-condition;loop statement) // one line of statements

For ... in loop

 for (var property-name in object-name) {
   //statements using object-name[property-name];
 }

• Iterates through all enumerable properties of an object.
• Not usable for arrays. It would iterate not only through the array indices, but also through other visible properties.
• There are differences between the various web browsers with regard to which properties will be reflected with the for...in loop statement. In theory, this is controlled by an internal state property defined by the ECMAscript standard called "DontEnum", but in practice each browser returns a slightly different set of properties during introspection.

While loop

 while (condition) {
   statements;
 }

Do ... while

 do {
   statements;
 } while (condition);

With

 with(document) {
   var a = getElementById('a');
   var b = getElementById('b');
   var c = getElementById('c');
 };

• Note the absence of document. before each getElementById() invocation.

Functions

A function is a block with a (possibly empty) parameter list that is normally given a name. A function may give back a return value.

 function function-name(arg1, arg2, arg3) {
   statements;
   return expression;
 }

Functions can also be declared into variables:

 var fn = function(arg1, arg2) {
   statements;
   return expression;
 };

Example: Euclid's original algorithm of finding the greatest common divisor. (This is a geometrical solution which subtracts the shorter segment from the longer):

function gcd(segmentA, segmentB) {
  while (segmentA != segmentB) {
    if (segmentA > segmentB) {
      segmentA -= segmentB;
    } else {
      segmentB -= segmentA;
    }
  }
  return segmentA;
}

The number of arguments given when calling a function may not necessarily correspond to the number of arguments in the function definition; a named argument in the definition that does not have a matching argument in the call will have the value undefined. Within the function the arguments may also be accessed through the arguments list; this provides access to all arguments using indices (e.g. arguments[0], arguments[1], ... arguments[n]), including those beyond the number of named arguments. Note that while the arguments list has a .length property, it is not an instance of Array; it does not have methods such as .slice(), .sort(), etc.

Basic data types (strings, integers, ...) are passed by value whereas objects are passed by reference.

Objects

For convenience, Types are normally subdivided into primitives and objects. Objects are entities that have an identity (they are only equal to themselves) and that map property names to values, ("slots" in prototype-based programming terminology). JavaScript objects are often mistakenly described as associative arrays or hashes, but they are neither.

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. For example, in a browser, typical host objects belong to the DOM (window, form, links etc.).

Creating objects

Objects can be created using a constructor or an object literal. The constructor can use either the built-in Object function or a custom function. It is a convention that constructor functions are given a name that starts with a capital letter:

// Constructor
var anObject = new Object();

// Object literal
var objectA = {};
var objectB = {index1:'value 1', index2:'value 2'};

// Customr constructor (see below)

Constructors

Constructor functions are a way to create multiple instances or copies of the same object. JavaScript is a prototype-based object-based language. This means that inheritance is between objects, not between classes (JavaScript has no classes). Objects inherit properties from their constructor's prototype.

Properties and methods can be added by the constructor, or they can be added and removed after the object has been created. To do this for all instances created by a single constructor function, the prototype property of the constructor is used to access the prototype object. Object deletion is not mandatory as the scripting engine will garbage collect any variables that are no longer being referenced.

Example: Manipulating 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 using square bracket notation
alert(obj["attributeA"]);

// add a new property
obj.attributeC = new Date();

// remove a property of obj
delete obj.attributeB;

// remove the whole Object
delete obj;

Inheritance

JavaScript supports inheritance hierarchies through prototyping. For example: (note: this example makes liberal use of the way methods and properties of objects are the same, called "slots" in Prototype-based programming)

function Base() {
  this.Override = function() {//create a new slot in this object (Base) with the identifier Override containing a method with a single command
    alert("Base::Override()");
  }

  this.BaseFunction = function() {//create a new slot just like Override, except with the identifier BaseFunction and a slightly different command
    alert("Base::BaseFunction()");
  }
}

function Derive() {
  this.Override = function() {//create a new slot in this object (Derive) similar to the slot Override in Base, but with a slightly different command
    alert("Derive::Override()");
  }
}

Derive.prototype = new Base();//set Derives prototype to be a new instance (really more of a clone) of Base

d = new Derive();
d.Override();
d.BaseFunction();

will result in the display:

Derive::Override()
Base::BaseFunction()

Another way to implement the override method is:

// Base class.

function Base(paramA) {
  this.paramA = paramA;//new slot named paramA, set the value to paramA passed when Base() is called
}

Base.prototype.Override = function() {//new slot in Base's prototype named Override
  alert("Base::Override()");
}

Base.prototype.BaseFunction = function() {//ditto but named BaseFunction
  alert("Base::BaseFunction()");
}

// Derived class.

function Derive(paramA, paramB) {
  this.parent = Base;//new slot named parent, set to be the function Base()
  this.parent(paramA);//call parent() with the argument paramA, which is the same as calling Base(paramA) since parent was just set to Base

  this.paramB = paramB;//new slot called paramB, set to paramB passed when Derive() is called
}

Derive.prototype = new Base();//Derive's prototype is new instance/clone of Base

Derive.prototype.Override = function() {//new slot in Derive's prototype named Override, value of slot is a function
  alert("Derive::Override()");
}

d = new Derive();
d.Override();
d.BaseFunction();

Exceptions

Newer versions of JavaScript (as used in Internet Explorer 5 and Netscape 6) include a try ... catch ... finally exception handling statement to handle run-time errors.

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
}

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, then the statements in the finally block execute. This is generally used to free memory that may be lost if a fatal error occurs—though this is less of a concern in JavaScript. This figure summarizes the operation of a try...catch...finally statement:

try {
  /*
      Create an array. Note: you can also use an:
      arr=[];
  */
  arr = new Array();
  // Call a function that may not succeed
  func(arr);
}
catch (...) {
  // Recover from error
  logError();
}
finally {
  // Even if a fatal error occurred, we can still free our array
  delete arr;
}

The finally part may be omitted:

 try {
   statements
 }
 catch (err) {
   // handle errors
 }

In fact, the catch part may also be omitted:

 try {
   statements
 }
 finally {
   // ignore potential errors and just go directly to finally
 }

Note that at least one of catch and finally are required. It is an error to simply use the try block alone, even if you don't need to handle the error:

 try { statement; } // ERROR

The catch argument is also required, even if you don't need to use it:

 try { statement; } catch(   ) { statement; } // ERROR

The Mozilla implementation allows for multiple catch statements, as an extension to the ECMAScript standard. They follow a syntax similar to that used in Java:

try { statement; }
catch ( e if e == "InvalidNameException"  ) { statement; }
catch ( e if e == "InvalidIdException"    ) { statement; }
catch ( e if e == "InvalidEmailException" ) { statement; }
catch ( e ) { statement; }

Miscellaneous

Case sensitivity

JavaScript is case sensitive. It is common to start object names with a capitalised letter and functions or variables with a lower-case letter.

Whitespace and semicolons

Spaces, tabs and newlines used outside of string constants are called whitespace. Unlike C, whitespace in JavaScript source can directly impact semantics. Because of a technique called "semicolon insertion", any statement that is well formed when a newline is parsed will be considered complete (as if a semicolon were inserted just prior to the newline). Programmers are advised to supply statement-terminating semicolons explicitly to enhance readability and lessen unintended effects of the automatic semicolon insertion.

Comments

Comment syntax is the same as in C++.

// comment

/* multi-line
   comment */

See also

• JavaScript
• Comparison of Javascript-based source code editors

References

• David Flanagan, Paula Ferguson: JavaScript: The Definitive Guide, O'Reilly & Associates, ISBN 0-596-10199-6
• Danny Goodman: JavaScript Bible, Wiley, John & Sons, ISBN 0-7645-3342-8
• Thomas A. Powell, Fritz Schneider: JavaScript: The Complete Reference, McGraw-Hill Companies, ISBN 0-07-219127-9
• Emily Vander Veer: JavaScript For Dummies, 4th Edition, Wiley, ISBN 0-7645-7659-3
• Kevin Applesauce: JavaScript Syntax,KND publishers, ISBN 0-213-26453-8

External links

Reference Material

• Core References for JavaScript versions 1.5, 1.4, 1.3 and 1.2

Resources

• Mozilla JavaScript Language Documentation
• A re-introduction to JavaScript - Mozilla Developer Center
• Interactive JavaScript Lessons - example-based