Lexical structure

Identifiers

Identifiers start with an alphabetic character or '_' or '$' or '@', followed by any number of alphabetic characters, '_', '$', '@' or digits ([0-9]).
"Foo", "foo" and "FOO" are three distinct and valid identifiers.

Keywords

Here is a full list of keywords used by the language. These cannot be used as identifiers:

function,   var,      if,       else,     while,     return,   for,
break,      continue, do,       switch,   case,      default,  null,
super,      new,      try,      catch,    finally,   throw,    typeof,
instanceof, in,       property, const,    get,       set,      include,
like,       yield,    type,     class,    namespace, assert,   debug
otherwise

Operators

Operators used by the language:

<     >     =     !     ~     ^     *     /     %
+     -     &     |     <=    ==    !=    >=    <<
>>    &&    ||    ++    --    +=    -=    *=    /=
%=    &=    |=    ^=    <<=   >>=   ..    ===   !==
<<<   >>>   <<<=  >>>=  ~/    ~%    /~    %~

Special symbols are:

[ ] { } # " '

Comments

A multi line comment is text enclosed in /* and  */ brackets.

A single line comment starts with // and spans everything until the end of that line.

Literals

Integer literals

Float literals

String literals

String literals are sequences of characters, enclosed by double quotes - ", or back ticks (grave accent, character with code 0x60) - `

"Hello world" and `Hello world` are valid string literals. The escapement symbol in string literals is the back slash - \.

Escapement rules:

Two or more string literals, separated by whitespaces or EOL characters, constitute a single string literal. Thus, the following two strings:

var str1 = "The quick brown "
           "fox jumps over "
           "the lazy dog";

var str2 = "The quick brown fox jumps over the lazy dog";

are equivalent.

Special literals

Array literals

Array literals allow to define (construct) arrays inline. The array literal is a list of expressions-initializers, separated by comma , and enclosed in [ and ] brackets (square brackets):

var a = [ 1, 2, 3, "four", 5 ];

In the statement above, variable a gets the reference to the newly defined array with five elements.

Any , (comma) appearing between the last element, and the ] (closing square bracket) is ignored. Therefore, this is also a valid array declaration:

var a = [ 1, 2, 3, "four", 5, ];

The kind-of-formal definition of the array literal:

[ ( <rs-expr> , )*  ]

Where <rs-expr> is the so-called right side expression - the expression that can appear on the right side of the = (assignment) operator.

Object literals

Object literals allow to define (construct) objects inline. The object literal is a list of key-value pairs separated by , (comma) or ; (semicolon), and enclosed in { and } brackets (curled brackets). Each key-value pair consists of the key expression-initializer, and the value expression-initializer, separated by : (colon).

var obj = { one: 1, two: 2, three: "three", four:4 };

If the key is presented as a name token, it is interpretted as a symbol name. Thus, the following statement:

var obj = { #one: 1, #two: 2, #three: "three", #four:4 };

is a precise equivalent of the statement above.

If the first token after the opening { bracket  is : (semicolon),  the expression that follows is treated as a class name. This allows to define objects of user-defined classes in literal form:

var myObj = {:MyClass one:1, two:2, three: "three", four:4 };

The formal definition of the object literal:

{ [ : <class-name>  ] ( <rs-expr> : <rs-expr> [ ,; ] )*  ( <rs-expr> : <rs-expr> )?  }

RegExp literals

The RegExp literal is a sequence of regular expression components, enclosed by / (forward slash) :

var re = /^[ \t]*$/ ; // RE expression for matching blank lines.

The kind-of-formal definition of RE literal:

/ <re-expression> /[i][g]

where i means case-insensitive match, and g enables "global" matching. When using the RegExp.exec() method, specify this modifier to return all matches, rather than the first one.

Macro variables

There are three macro variables that can be used for logging and debugging purposes:

• __FILE__ - name of current file;
• __LINE__ - current line number in the file;
• __TRACE__ - actually is an instruction that creates current call trace snapshot as a vector of triplets. Each triplet is a vector of three elements where:
• [0] - integer, line number;
• [1] - symbol, function name;
• [2] - symbol, file name.