Literals

Keywords

The table lists the keyword literals of JSX. In contrary to JavaScript, there is no distinction between undefined and null.

Table 1. List of Keyword Literals
Keyword	Description
`null [: type]`	declares null, may have the type annotated. The type is deducted (if possible) if the type annotation does not exist.
`false`	a boolean constant
`true`	a boolean constant

Number Literal

Identical to JavaScript in strict mode.

var a = 10;
var b = 3.14;
var c = 0xCafe;

String Literal

Identical to JavaScript.

var a = "foo\n";
var b = 'bar\n';
var c = "\x5c";   // ascii escape
var d = "\u005C"; // unicode escape

RegExp Literal

var a = /foo/;
var b = /[a-zA-Z0-9]+/;

Identical to JavaScript.

Function Literal

Type annotations against arguments and return types are required for function declaration, unless the type can be deducted by the surrounding expression.

// a function that takes no arguments, and returns void
var f = function () : void {};

// a function that takes one argument (of number),
// and returns a number that in incremented by one
var g = function (n : number) : number {
    return n + 1;
};

// the argument types and return types may be omitted
// (if it is deductable from the outer expression)
var sum = 0;
[ 1, 2, 3 ].forEach(function (e) {
    sum += e;
});
log sum; // 6

// short-handed
var sum = 0;
[ 1, 2, 3 ].forEach((e) -> { sum += e; });
log sum; // 6

// short-handed, single-statement function expression
var s = "a0b1c".replace(/[a-z]/g, (ch) -> ch.toUpperCase());
log s; // A0B1C

A statement starting with function is parsed as an inner function declaration, as is by JavaScript. Surround the function declaration with () if your intention is to create an anonymous function and call it immediately.

// inner function declaration (when used within a function declaration)
function innerFunc() : void {
    ...;
}

// create an anonymous function and execute immediately
(function () : void {
    ...;
})();

See also: Member Function in Class, Interface, and Mixin.

Array Literal

Array literal is identical to JavaScript except that it may have type annotations if its value type is not deduced.

// empty array literals require an explicit type
var a = [] : string[];
// the type is clear; you can omit type declaration
var b : string[] = [];

function f(a : string[]) : void { }
// the type is also clear
f([]);

// the type is number[] because it has a number as an element
var c = [1];

// trailing commas are allowed
var d = [
  "foo",
  "bar",
  "baz",
];

Map Literal

Map literal is identical to JavaScript except that it may have type annotations if its value type is not deduced.

// empty array literals require an explicit type
var a = {} : Map.<string>;
// the type is clear; you can omit type declaration
var b : Map.<string> = {};

function f(a : string[]) : void { }
// the type is also clear
f({});

// the type is Map.<number> because it has a number as an element
var c = { foo: 1 };

// trailing commas are allowed
var d = {
  foo: "foo",
  bar: "bar",
  baz: "baz",
};