Core Language Types

This document describes the Number, Boolean, Function and String types. Also see the Objects and Arrays document and the Class Library Reference.

References

These references contain extensive material about the JavaScript core language types.

Standard JavaScriptData Types

JavaScript (ECMA-262 3.X) supports the following data types.

Array
Boolean
Date
Error, RangeError, ReferenceError, SyntaxError, TypeError and URIError
Function
Math
Number (can be configured to be: int, int64, float or double)
Object
RegExp
String

Ejscript also supports the E4X (ECMA-357) XML extensions which add the following data types.

XML
XMLList

Ejscript System Library

Ejscript enhances the standard types with some extension methods and an extensive system library of classes and types. The Ejscript Web Framework provides additional classes to implement a Model / View / Controller framework for web applications.

Numbers

Standard JavaScript numbers are stored and manipulated as double floating point quantities, but for embedded applications, this is often less than ideal. Consequently, Ejscript allows the default numeric type to be selected at build time to be either: float, double, int or int64.

Numeric Literals

Numeric literals may be specified as octal values by prefixing with a 0, or hexadecimal by prefixing with 0x or 0X. If Number is configured to be based on a double floating point type, then numeric literals can use an exponential notation of the form: floating number followed by 'e' or 'E', followed by an optional sign '+' or '-', followed by an integer exponent. I.e.

[digits] [.digits] [E|e] [(+|-)digits]

For example:

var pi = 3.14e1
pi = 314.0e-2

Useful Constants

JavaScript defines some useful floating point constants. The global variable NaN is set to the "not a number" value. This value is the result when a math operation gives an undefined value or error. For example, divide by zero will result in the NaN value. The Infinity constant is set to the largest possible floating number, the result is equal to the Infinity value.

Number.MAX_VALUE
Number.MIN_VALUE
Number.Nan or Nan
Number.POSITIVE_INFINITY or Infinity
Number.NEGATIVE_INFINITY

Booleans

A boolean value can be either true or false. Assigning either true or false to a variable or the result of a conditional expression will set the type of a variable to boolean. The following example will set x to true.

var y = 1
var x = (y == 1)

Ejscript defines two immutable global variables true and false with the appropriate boolean values.

Strings

Strings are immutable sequences of Unicode letters or escaped literals. String literals may be enclosed in either single or double quotes.

Ejscript strings are easy to work with due to the inbuilt ability to append strings via the + operator. For example:

var str = "Happy Birthday " + name
var greek = "&lambda expression"

JavaScripts supports the following escaped characters inside string literals:

Escape Sequence	Description
\b	Backspace (0x8)
\f	Form feed (0xc)
\n	New line (0xa)
\r	Carriage return (0xd)
\t	Horizontal tab (0x9)
\v	Vertical tab (0xb)
\uNNNN	Unicode character (0xNNNN)
\xNN	Hexadecimal character (0xNN)
\NNN	Octal character (ONNN)
\'	Literal single quote
\"	Literal double quote
\\	Literal backslash

Functions

A function is a script that can be executed by name with supplied arguments. Functions are declared via the function keyword followed by optional arguments and a function body contained within braces. For example:

function myPoint(x, y: Number): Number {
    return x + y
}

Functions can use a return statement to return an arbitrary value or object.

To invoke a function, the function name is used with the () operator following. The actual arguments are supplied within the "()" . The arguments to the function are evaluated left to right. For example:

var x = myPoint(1, y + 7)

Functions are values in JavaScript and may also be assigned to other variables or properties. They can also be passed as parameters into other functions. When a function is assigned to a property of an object it becomes a method for that object. When invoked via an object, the function's this property is set to the object.

Bound This

It is often useful to be able to pass functions as parameters without having to also pass an object on which to later invoke the method. Ejscript provides an enhancement such that if a function is read from an object without invoking it, Ejscript will capture the object reference and bind it to the function reference. When the function is later run, the this property of the function will be set to the object automatically.

    var run = obj.run
    after(10, run)

Objects and Arrays

See the Objects and Arrays document for further details.

Null and Undefined

JavaScript defines two special values: null and undefined. The null value means the property exists but either has not any assigned value or the null value has been assigned explicitly. The undefined value means the requested property does not exist.

Type Conversions

JavaScript supports a set of idioms that greatly eases the conversion of types from one type to another.

Adding a string to a number will cause the number to be converted to a string. Subtracting zero from a string will convert it to a number.

Initial Type	Target Type	Initial Value	Final Value
Boolean	Number	true	1
Boolean	Number	false	0
Boolean	String	true	"true"
Boolean	String	false	"false"
Number	Boolean	0, NaN	false
Number	Boolean	all other values	0
Number	String	NaN	"NaN"
Number	String	any number	"string equivalent"
Object	Boolean	object	true
Object	Number	object	NaN
Object	String	object	"[object Object]"
String	Boolean	""	false
String	Boolean	all other values	true
String	Number	Number string	numeric equivalent
String	Number	Non-numeric string	NaN
undefined	Boolean	undefined	false
undefined	Number	undefined	NaN
undefined	String	undefined0	"undefined"
null	Boolean	null	false
null	Number	null	NaN
null	String	null	"null"

Implicit Conversion Idioms

To explicitly force a type conversion, use the following idioms.

Initial Type	Target Type	Action	Example
Number	Boolean	Negate twice	!!num
Number	String	Add a string on the right	num + ""
String	Boolean	Negate twice	!!string
String	Number	Add a numeric on the right	string - 0
Object	String	Invoke the toString method	o.toString()
Object	Boolean	Negate twice	!!obj

Implicit Conversions via Type Annotations

Ejscript adds support for optional type annotations on variable declarations and function parameters. If used, these type annotations can greatly simplify your code by automatically converting types.

If a variable is defined and contains a number and is then assigned a string value, JavaScript will normally assign the string, and the type of the variable will change from number to string. This can be the cause of subtle errors. However, if the number has an optional type annotation of "Number", then the compiler and VM will automatically convert the string to a number and ensure the variable only ever contains numbers.

var num: Number = 77
num = "1234"
print(typeof num)
/* Emits */
number

Similarly if a function can only take numeric arguments, the function often has to do costly type checking to ensure the args are of the required type.

function square(n) {
    if (typeof n != "number) {
        throw new Error("Bad Arg")
    }
    return n * n
}

But if optional type annotation is used on the args, then things are much simpler. The VM will cast the argument to a number before invoking the function. The function guarantees that the arguments will always be of the correct type.

function square(n: Number) {
    return n * n
}

For the exact semantics, please consult the ECMAScript-262 specification.

Explicit Conversion

While implicit conversion is very convenient, you sometimes need to explicitly control the type conversion.

You can use the explicit constructor functions: Boolean(), String() and Number() to force a conversion.

var num = Number("1234")

Ejscript also adds a cast operator for convenient control over casting.

Cast Operator

The cast operator is similar in syntax to instanceof, but allows you to cast an object explicitly to any other type.

var str = 1234 cast String

The cast operator is faster than using the conversion constructor functions as the compiler often knows if the type is compatible and can generate more optimal code.

Type Conversion Rules

If the left operand is a string, the right hand operand will be converted to a string. If both operands are numeric, a numeric operation is done.
If either operand is an object, it is converted to a string.
If both operands are boolean and the operation is ==, !=, then proceed without a type conversion.
If one operand is a string and the other is a numeric, try to convert the string to a number. Otherwise, try to convert the numeric to a string.