eSignal Formula Script (EFS) Tutorial Series

INTRODUCTORY TUTORIAL 2

Commonly Used Core JavaScript

Summary: The following items in this tutorial will cover the main aspects of Core JavaScript that
are most commonly used in EFS formula development. This tutorial does not cover all aspects
of Core JavaScript because there are many topics that are rarely or never used in EFS formula
development. The intent of this tutorial is to give the new user a solid start to understanding
JavaScript specifically for developing EFS formulas.

Topic List:

1. Description of JavaScript
2. Variables
3. JavaScript Syntax
4. Most commonly used Statements
5. Most commonly used Operators
6. Function Parameters
7. Core JavaScript Resources

1
2.1 Description of JavaScript

JavaScript is a lightweight, object-oriented programming language invented by Netscape,

which was initially used for their Internet browser. JavaScript is not a stand-alone
language for developing software. It’s designed to be embedded into applications such as
web browsers and eSignal to give control over certain elements of the host application to
the end user. In the case of eSignal, this element is the formula studies feature of the
Advanced Chart.

2.2 Variables

2.2.1 The Keyword: var

The var keyword is used to initialize, or declare, variables in JavaScript. Variables are
simply user-defined containers for storing values. You will see many examples of var
used in the examples throughout this tutorial.

An important characteristic of JavaScript that often lead to coding errors for beginners is
that the language is a soft-typed, or untyped, programming language. What this means is
that you are not required to declare a variable with a specific data type. You are also
allowed to use, or recycle, the same variable to store different data types throughout your
code as needed. Also, the var keyword is not required to declare variables. It’s not a
recommended practice, but you can simply type a new variable name and assign a value
to it anywhere in your code.

2.2.2 Variable Scope

There are two types of scope, global and local. What determines the scope of a variable
is the location in the formula where the variable is declared. The area of a formula that is
outside any user-defined functions is called the global scope. The area inside a user-
defined function is called the local scope. The difference between the two is the life of the
variable. Variables declared in the global scope will exist for the life of the formula. Use
global variables when you need to store a value between executions of your formula or
you want other user-defined functions to use the variable. Variables declared inside a
user-defined function, such as main(), will only exist for that single execution of the
function where the variable was declared.

As we mentioned in the previous section, using the var keyword to declare your variables
is optional. It’s highly recommended that you always use the var keyword to declare
variables. It becomes helpful when reading through your code during the
development/debugging process. More importantly, if you create all your variables as
globals, your formula will require more resources, which makes the formula less efficient.
Using local variables whenever possible is one way to help keep your formulas running
efficiently.

-2-
2.3 JavaScript Syntax

2.3.1 Case Sensitivity

JavaScript is a case sensitive language. We touched on this topic in the previous tutorial
when we discussed the capitalization of the preMain() and main() user-defined functions.
However, case sensitivity applies to everything you’ll code in JavaScript, not just function
names. Always keep in mind that the capitalization of function names, variable names,
etc. must be coded with consistency throughout your formula. The lack of attention to this
issue leads to one of the common pitfalls for new users. For example, let’s say we’ve
created a variable, nNumber
and set it equal to 10. Then,
later in the formula, we add 2 to
nnumber (note the lower case
“n”), followed by an if() statement
checking for the value of
nNumber to see if it is equal to
12. Figure 1 is a code example
(CaseSensitivity.efs) illustrating
this problem. Because we
mistyped the variable name on
line 8, our nNumber variable
never gets changed to the value
of 12. Therefore the conditional
statement on line 10 never
evaluates to true. The end result
is that the code on line 11 will
never be executed. The solution
of course is to change “nnumber”
to “nNumber.”

You might be wondering why the formula doesn’t generate an error on line 8. Remember,
the var keyword used to declare variables is optional in JavaScript. JavaScript is a
flexible language when it comes to variable declaration. Essentially, what happens on line
8 is that the EFS engine creates a new variable, nnumber, with an initial value of 12. Our
formula example really has two variables at this point. There isn’t any facility in the EFS
engine that will catch and alert you of this of type of error. It can’t make any decisions for
you and assume you meant to use nNumber. All the EFS engine sees is that you are
using two variables. It’s up to you to catch this type of mistake, which is referred to as a
logic error. This is where formula debugging will become an important part of your tool
set. We won’t go into this now, but there will be an entire tutorial dedicated to debugging
formulas later in the series.

2.3.2 The Semicolon ;

3
The semicolon ( ; ) is used in JavaScript to tell the program it has reached the end of a
complete statement. This character is optional, however, we recommend that you get in
the habit of using it. It will help you avoid another common mistake in coding EFS
formulas. The issue is that JavaScript allows you to put more than one completed
statement on a single line of code. However, they must be separated by a semicolon,
otherwise you’ll get a syntax error. If you are already in the habit of using semicolons to
end your statements, you’ll be less likely to make this coding error. Consider the example
in Figure 2. On line 9, we have put two statements on the same line but left out the
semicolon after “nNumber = 12.” You can see the syntax error generated in the Formula

Output window (ToolsÆEFSÆFormula Output Window) when we try to apply this formula
to a chart. The EFS engine would know what to do if the two statements were on
separate lines. Without the semicolon, the engine tries to interpret line 9 as a single
statement, which by itself, is not proper syntax. After adding the semicolon after the “12”
on line 9, the formula will execute properly and print the result of nNumber (24) to the
formula output window. Try typing the code from this example into your EFS Editor
(ToolsÆEFSÆEditor) and make the correction to see the result for yourself.

2.3.3 The Braces { }

More specifically, the begin brace ( { ) and end brace ( } ). You will never have one
without the other. They are markers for the beginning and end of a code block and are
used with many functions in JavaScript. From the previous examples, you’ve seen them
used at the beginning and end of user defined functions such as preMain() and main().
As you learn more about various EFS and core JavaScript functions you will see many
instances of the braces. If you do happen to leave one out by mistake, the EFS engine
will generate a syntax error (see Figure 3.). The code example is the same code as in
Figure 2 except we removed the end brace for the if() statement that was on line 11. The
error message in the Formula Output window indicates line 14. We know that this isn’t the
offending line of code. The EFS engine uses the last line of code in the formula for the
error message (14 in this case) because it is not able to make a guess as to what line the
missing end brace should be added. This one can be a little tricky to find if you have a lot
of code and multiple defined functions in your formula. You will have to start at the top of

4
your code and check it line by line to find the proper location for the missing brace. It’s a
good idea to save your work often and perform syntax checks as you go.

2.3.4 Commented Code // and /* */

The EFS engine ignores commented code. You may want to include some notes for
yourself or others that may be reading your code to help explain or remind yourself what
various parts of the code is supposed to do. Many programmers include a section of
comments at the top of the formula for descriptions of the study, version numbers, contact
info etc. Another common use for commented code is to temporarily disable a line or lines
of code during the development process. This is a quick way to save some of your
previous work just in case you want to go back to a previous method you were using
without having to retype the code.

There are two ways to comment code. You

can comment a single line of code with two
forward slashes, //. Or you can comment
an entire block of code by placing a forward
slash followed by an asterisk, /*, at the front
of code block and another asterisk followed
by a forward slash at the end of the code
block, */ (see Figure 4). These multi-line
comment symbols do not have to be on a
separate line. They can be on the same
line in front of some code or at the end of a
line.

The multi-line comment symbols can also be used to comment a section of code that’s in
the middle of a line of code (see Figure 5). Using our previous code example for
nNumber, the result of
nNumber would now
equal 20. The
nNumber = 12;
statement is now

5
ignored. nNumber was initialized with a value of 10. Therefore, nNumber is now only
multiplied by 2.

2.3.5 Identifiers
Identifiers are nothing more than the names you use for your formula variables and any
user-defined elements. The general rule to follow when designing your naming
conventions for identifiers is to never start them with a number. Doing so will generate a
syntax error indicating that there is a missing variable name. Using special characters at
the beginning of an identifier will also generate errors, except for underscores (_) and
dollars signs ($). The following are examples of valid identifiers.

_myPrice cntr1 nNumberVar

$myVariableName cntr2 sStringVar
I cntr3 bBooleanVar

As you read through other user’s formula code you may notice that many programmers
use a naming convention where the first letter is lower case and the second is capitalized.
The first character typically indicates the intended data type for the variable where “n”
indicates a Number, “s” for String and “b” for Boolean. This is not a requirement but it
helps you and those reading your code understand what the code was intended to
perform.

2.3.6 Reserved Words

In JavaScript, there is a list of words reserved for specific purposes that you cannot use in
your naming conventions for your identifiers. These words are used as part of the core
JavaScript language itself and will generate syntax errors if you try to use them as
identifiers. This following list is referred to as the Reserved Words.

6
 Abstract enum isFinite super
arguments Error isNaN switch
Array escape long synchronized
boolean export Math SyntaxError
Boolean extends NaN this
break eval native throw
byte EvalError new throws
case false null transient
catch final Number true
char finally Object try
class float package typeof
const for parseFloat TypeError
continue function parseInt undefined
Date Function private unescape
debugger goto protected URIError
decodeURI if public var
decodeURIComponent implements rangeError void
default import ReferenceError volatile
delete in RegExp while
do Infinity rturn with
double instanceof short
else int static
encodeURI interface String

2.3.7 Data Types

At the heart of any programming language, there are certain data types the language is
allowed to manipulate to produce some end result. In JavaScript, there are three basic
data types, Numbers, Strings and Boolean values.

Numbers are self-explanatory. The important thing to know about numbers in JavaScript
is that they are all treated as floating-point values.

Strings are a series of characters made up of letters, digits or special characters

enclosed by single or double quotes (‘ or “). In EFS, strings are most commonly used for
drawing text labels on the chart or printing debugging information to the Formula Output
Window. The following are examples of valid strings.

“”
‘’
“buy at market”
“123”

7
There are many core JavaScript functions used for manipulating strings. However, they
aren’t heavily used for EFS development so we’ll cover these methods later in the
Advanced tutorial series. For now, the important functionality of Strings that you should
be aware of is the ability to concatenate them to make larger strings. To concatenate, or
join, strings together we use the + symbol in the same way we would add two numbers
together. In figure 6, for example, the result of sString on line 15 creates the string, “Buy
100 IBM at Market!” when printed to the formula output window. Notice also that you can

incorporate numbers into string concatenations. The numbers may be a constant, such
as the 100 used in this example, or variables that store a number data type.

Boolean data types only have two values, true and false. These values are constants,
which are also represented as 1 or 0, 1 being true. Boolean variables in EFS
development are commonly used to keep track of events or conditions to control the
execution of specific code blocks within the formula. This type of Boolean variable is also
commonly referred to as a flag.

One example using a flag can be found in our EFS Library under Help Examples,
AlertOncePerBar.efs. In figure 7, the Boolean flag, vFlag, is used to prevent an alert from
signaling more than once per bar. The formula uses some made-up data for the sake of
demonstration, but you could easily modify the conditional statement on line 14 to detect a
particular event to suite your
needs. What happens with
this code is an audible alert
will sound on the first trade of
each bar in real time. If you
want to see the formula in
action, apply it to a chart with
a 1-minute interval. The
trade that triggers the alert
happens to be the first trade
of the bar because that is the
only instance where vFlag is
equal to (==) false and (&&)
vData1 is greater than (>)
vData2. The first time the
conditional statement on line
14 evaluates to true, vFlag

8
 subsequently get set to true indicating that the alert has occurred for the current bar. So
for every trade after that during the 1-minute interval, the portion of the conditional
statement, vFlag == false, evaluates to false, which prevents the code block from lines 15-
17 from executing. Once the bar state of NEWBAR is detected again, vFlag is then reset
to false, which allows the condition on line 14 to evaluate to true again and so on.

2.4 Most Commonly Used Statements

Statements are a group of Core JavaScript keywords that are used to perform specific
behaviors or actions. Statements are the essential elements used that inevitably
determine the logic for a set of code. Each statement has a unique syntax that must be
followed. For beginning EFS development, the following statements, if(), else, function
and return are the most commonly used.

2.4.1 The if() Statement

The if() statement is used to evaluate a
statement or condition and then executes a
block of code if that condition evaluates to true.
If the condition evaluates to false, the code
inside the if() statement block will be ignored.
In figure 8, the if() statement is checking to see
if the value of the bTest variable is equal to a
Boolean true. The bTest variable is initialized
as true, therefore the if() statement evaluates
to true. As a result, the code on line 10 will be
executed every time main() is called by the
Advanced Chart.

2.4.2 The else Statement

The else statement is used in conjunction
with the if() statement. When an if()
statement evaluates to false and it has an
else statement present, the code block
within the else statement will be executed.
In figure 9, we’ve added an else statement
for the if() statement on line 9. Because
bTest was initialized as true, the else block
will never be executed. Try changing the
initialization value for bTest on line 5 to false
and reload the formula. You will see strings
of “goodbye” printed in the formula output
window instead of “hello.”

The else statement can also be immediately followed by another if() statement. This is
referred to as an else if() statement. This allows you to test collection of conditions in a
specific order and only execute the first one that is found to be true. Figure 10 illustrates a
simple example where a variable, sSymbol, is set to a specific value. In main, the tree of

9
if() and else if() statements check to see if that variable is equal to a particular symbol.
Since sSymbol is initialized with the value of “IDC,” the first two if() statements evaluate to
false. The third if() statement evaluates to true and prints “Symbol is Interactive Data
Corp.” to the formula output window.

2.4.3 The function Statement

The function statement is used to create custom functions, or user-defined functions
within your formula code. main() and preMain() are both examples of a user-defined
function. Functions are useful for organizing your code and also help you write more
efficient code. If, for example, you have a routine that you need to execute multiple times,
you can eliminate writing repetitive lines of code within main to perform the routine by
placing the routine in its own function outside of main. This allow you to call that function
from within main to execute that routine as many times as you need. Figure 11 uses the
previous code example from Figure 10, which moves the routine that checks for the value
of sSymbol into a user-defined function named, CheckSymbol().

10
This code example performs the exact same process as figure 10. Also make note of the
open and close parentheses ( () )after the name of the CheckSymbol function on line 14.
These characters used together is called the Function Call Operator, which is required
when defining the function and also when calling the function from within another function
such as main() (see line 9). The function call operator is explained in greater detail later in
this tutorial.

2.4.4 The return Statement

The return statement is used to return a value from a user-defined function or to
terminate its execution. Many user-defined
functions used in EFS are designed to return
the result of a calculation. These values are
passed back to the calling function from the
return statement. In Figure 12, we have a
user-defined function that returns the result of
2 * 2. The variable, nNumber, on line 7 in
main() is being assigned to the returned value
of the calcNumber() function. On line 13, the
nRet variable is assigned to the expression of
2 * 2. This variable that now contains the
value of 4 is returned to main() from line 15,
which in turn get assigned to the nNumber
variable.

When the return statement is used to terminate the execution of a function, no value gets
returned. Any code in the function body that exists after a return statement that has been
executed will not be executed, thus terminating the rest of the function execution. Return
statements are often used in this manner when a function needs to validate a piece of

11
 data before executing a routine. If a function does not have its required set of valid data
for the routine, there is no need to allow the function to continue to execute. This not only
helps improve the efficiency of your code, but also may prevent the calculation of
erroneous data due to the lack of valid components that a function may require. Figure 13
illustrates a basic example of this process. The code on line 8 is referred to as a null
check. This is a good programming practice
to use because it’s a good way to validate that
an expected return value exists before you try
to manipulate that data later in your code. In
this example, we did not return the nRet
variable from our calcNumber() function by
mistake. The result is that the if() statement
on line 8 will evaluate to true and execute the
return statement. Try adding some code
after the return statement, such as a
debugPrintln(“hello”) statement. You will see
that it does not execute. To correct the
formula, add the nRet variable back to the
return statement in the calcNumber() function.

There is one very important exception to the return statement behavior that is specific to
the EFS environment and not part of the core JavaScript. The return statement in main()
will always be the last line of code to be executed in an EFS formula. Therefore, the
eSignal application has been designed to receive this returned data, which allows the
Advanced Chart to display the results. There will be many examples of this return used
throughout the tutorial series as it is the primary purpose of EFS formula development. In
our example in Figure 13, the result of nNumber gets plotted in the Advanced Chart as a
non-price study (or indicator), which displays a horizontal line at 4.

2.5 Most Commonly Used Operators

In simple terms, operators are just special characters or words used for many purposes,
such as concatenating strings, performing math, or checking for equality or inequality to
name a few. This topic could be significantly large, so for the purposes of this tutorial we
will only cover the operators that you will use most often for EFS formula development.
For a complete list of operators, visit Chapter 5 Operators in the Core JavaScript 1.5
Reference of the EFS KnowledgeBase.

2.5.1 Arithmetic Operators

Arithmetic operators are used to compute math operations. Math operators applied to
variables that are strings will convert the string to a number and then perform the math.
The result will return a number. However, the Addition operator is an exception to this
rule. The (+) symbol is also used for string concatenation, so if at least one element of the
equation is a string, the (+) operator will perform string concatenation. You shouldn’t run
into this issue in EFS formula development very often. As long as you ensure that the
data types of your variables intended for math operations are always numbers you’ll avoid
any problems here.

12
 + Addition
var nNum = 1 + 1 nNum is 2
var nNum = “1” + “1” nNum is “11”
var nNum = “1” + 1 nNum is “11”
var nNum = "1" + ("1" - 2) nNum is “1-1”
- Subtraction
var nNum = 1 - 1 nNum is 0
var nNum = “1” - 1 nNum is 0
var nNum = “1” - “1” nNum is 0
* Multiplication
var nNum = 2 * 2 nNum is 4
var nNum = “2” * 2 nNum is 4
var nNum = “2” * “2” nNum is 4
/ Division
var nNum = 4 / 2 nNum is 2
var nNum = “4” / 2 nNum is 2
var nNum = “4” / “2” nNum is 2

2.5.2 Equality Operators

There are two Equality Operators that you will use in almost every formula you write, the
Equality operator (==) and the Inequality Operator (!=). These two operators simply
perform a comparison between two values and returns a Boolean (true or false) result.
You will most often use these in conjunction with the if() statement.

== Equality
if (5 == 5) Evaluates to true.
if (“5” == 5) Evaluates to true.
if (5 == 0) Evaluates to false.
if (“true” == true) Evaluates to false.
!= Inequality
if (5 != 5) Evaluates to false.
if (“5” != 5) Evaluates to false.
if (5 != 0) Evaluates to true.
if (“true” != true) Evaluates to true.

2.5.3 Comparison Operators

There are four Comparison Operators that are frequently used in EFS formula
development. These are the operators that allow you to compare two values to check if
one is Less than (<), Greater than (>), Less than or equal (<=), or Greater than or equal
(>=) to the other.

< Less Than

if (5 < 5) Evaluates to false.
if (“5” < 5) Evaluates to false.
if (0 < 5) Evaluates to true.

13
 > Greater Than
if (5 > 5) Evaluates to false.
if (“5” > 5) Evaluates to false.
if (5 > 0) Evaluates to true.
<= Less or Equal
if (5 <= 5) Evaluates to true.
if (“5” <= 5) Evaluates to true.
if (5 <= 0) Evaluates to false.
>= Greater Than or Equal
if (5 >= 5) Evaluates to true.
if (“5” >= 5) Evaluates to true.
if (0 >= 5) Evaluates to false.

Make note also that the Comparison Operators can be used with Strings as well. The
difference is that the comparison is based on alphabetical order. However, this is rarely
used in EFS formula development.

2.5.4 String Operators

The primary String Operator that is used in EFS formula development is the
Concatenation Operator (+). You’ve seen some examples of this already, but here’s a few
more. Note that you can also include numbers and Boolean values within the
concatenation. This comes in handy when debugging formulas with the debugPrintln()
function.

+ Concatenation
“buy” + “ “ + “here” Evaluates to “buy here”
“sell ” + 100 + “ at Market” Evaluates to “sell 100 at Market”

2.5.5 Logical Operators

There are three Logical Operators, AND (&&), OR (||), and NOT (!). These operators are
primarily used within if() statements when incorporating conditions or rules into your
formulas. They allow you design more complex combinations of comparisons within an
if() statement. The NOT operator is less utilized, so let’s look at some examples of the
AND and OR operators first.

&& Logical AND

if (5 > 4 && 10 < 20)
If (5 < 4 && 10 < 20)
If (5 < 4 && 10 > 20)
|| Logical OR
if (5 > 4 || 10 < 20)
If (5 < 4 || 10 < 20)
If (5 < 4 || 10 > 20)
Evaluates to true.
Evaluates to false.
Evaluates to false.
Evaluates to true.
Evaluates to true.
Evaluates to false.

When using these two logical operators, the expressions on either side converts to a
Boolean value. With the AND operator, both sides must evaluate to true in order for the
if() statement to evaluate to true. With the OR operator, only one side has to evaluate to

14
true. You can incorporate multiple logical operators into a single if() statement.
Depending on what you need to do, you may need to organize the expressions into
groups by enclosing them inside a set of parentheses like in the following example.

if (5 > 4 && (10 < 20 || 10 < 5) ) Evaluates to true.

The Logical NOT operator simply inverts the value of a Boolean expression. For example,
if an expression evaluates to true and you then place the logical NOT operator in front of
that expression, it will evaluate to false.

! Logical NOT
if (5 > 4) Evaluates to true.
If !(5 > 4) Evaluates to false.

2.5.6 Assignment Operators

Assignment operators are simply used to assign values to variables. The most commonly
used assignment operator is the = (equals) operator. This operator expects a variable
name on the left side and the value to be assigned to it on the right side.

= Equals
var nNum = 5;
The variable “nNum” is assigned to the value of 5.

There are also some assignment operators that perform arithmetic and assignment at the
same time. They are simply short cuts for basic math operations. For example,

+=
nNum += 10;
This is a shortcut for nNum = nNum + 10;
-=
nNum -= 10;
This is a shortcut for nNum = nNum - 10;
*=
nNum *= 10;
This is a shortcut for nNum = nNum * 10;
/=
nNum /= 10;
This is a shortcut for nNum = nNum / 10;

2.5.7 The Function Call Operator ()

The Function Call operator, (), is used to invoke a function. Whenever you see this
operator, you know that it is a function that is performing some built-in operation or
function, which may also be a user-defined function as illustrated in figure 11 in section
2.4.3. Many functions do not require any arguments (or parameters). In that case, you
will use the Function Call operator just as you’ve seen it being used up to this point.
However, functions may also have a set of required or optional parameters that need to
be specified, which is discussed in detail in the following topic.

15
2.6 Function Parameters

This is a very important topic to understand because EFS formula development is highly
dependant on the use of function parameters. When you start making requests for data, it
is the parameters passed to the EFS functions that tell the EFS engine what to return to
your formula.

2.6.1 Function Parameter Basics

To illustrate the basic concept using
function parameters, we’ll first use the
code example from figure 13 and pass
the two numbers used in the
calcNumber() function as parameters
from the call within main(). On line 7, we
have now added two parameters to the
calcNumber() function call. Notice they
are separated by commas. Passing
multiple function parameters requires that
the list of parameters is separated by
commas so that each parameter can be
assigned to a unique variable in the
function they are being passed to. On line 13, we have added those two variable names
that will be assigned to the values of the parameters passed to it from main(). The
assignments will be done in the same order as the parameters that were passed. In this
case nNum1 and nNum2 will both be assigned a value of 2. Now take a look at line 14.
You will notice that we used our two new variables in place of the hard coded 2s that we
were using in figure 13. If we did not make this change, then the parameters passed to
the function would never be used by the function and it would always return the result of 2
* 2. Try changing the parameters passed on line 7 to see different results.

An important note to make about the parameter variables of a user-defined function such
and nNum1 and nNum2 become local variables to the function. They do not need to be
declared anywhere in your formula code with the var keyword. Remember also that local
variables are only available to the function where they were created. You will not be able
to access those variable in any other function unless they are passed as parameters to a
function call within calcNumber().

16
 2.6.2 Variables as Function Parameters
Variables may also be used as function parameters. In figure 14, we used constants, or
hard-coded values as parameters. Let’s consider an example where we create a new
variable and pass it as a parameter to the calcNumber() function. On line 7 we created a
new variable, nFirst, which is
assigned to our original
calcNumber() call with
constant parameters. On line
9, we’ve replaced the
constants with our nFirst
variable. nFirst gets
assigned to a value of 4,
which results in nNumber
receiving the value of 16.
This code example is also a
basic illustration of recycling
code through the use of a
function that we previously
discussed.

2.7 Core JavaScript Resources

The core JavaScript topics discussed in this tutorial only highlight the most commonly
used aspects of the language for the new EFS developer. To learn more about the topics
discussed here and more elements of the JavaScript language please check out some of
the following resources.

• JavaScript for EFS Video Series – Nearly 6 hours of video tutorials that also covers
the core JavaScript concepts discussed in this tutorial plus many tips and tricks for
programming with JavaScript.
• Core JavaScript 1.5 Reference – This on-line book is the complete reference
manual for the core JavaScript language for version 1.5 located in our EFS
KnowledgeBase.
• Core JavaScript 1.5 Guide – This on-line book is a comprehensive guide that
covers all aspects of JavaScript 1.5 located in our EFS KnowledgeBase.

What’s Next?

In the next tutorial, Introductory Tutorial 3 – Introduction to preMain() and main(), we

will introduce the specific EFS functions used in preMain(). We will also discuss the
usage of main() in greater detail.

17