Jargon Software
Getting Started with Jargon Writer
Writing Scripts


What is a Scripting Language?

A scripting language is an easy-to-use programming language that is used to manipulate, customize, and automate the facilities of an existing system, such as a Web browser or the Jargon Reader deployment engine.

In such systems, useful functionality is already available through a graphical user interface (GUI), and the scripting language is a way to control that functionality. In this way, the existing system is said to provide an environment of objects and facilities which completes the capabilities of the scripting language.

A scripting language is designed for both professional and non-professional programmers, and so it normally has a number of informalities built into the language.

ECMAScript Overview

ECMAScript is a standard Internet scripting language formally known as ECMA-262 (ECMAScript), sanctioned by the European Computer Manufacturers Association (ECMA). The language spec was based on an early version of JavaScript. This specification was then used by Microsoft, Netscape, Opera, and other browser venders who have provided support for it in later JavaScript and JScript versions.

ECMAScript is an interpreted, object-based scripting language. Although it has fewer capabilities than full-fledged object-oriented languages like C++, JScript is more than sufficiently powerful for its intended purposes. ECMAScript is not a cut-down version of another language (it is only distantly and indirectly related to Java, for example), nor is it a simplification of anything.

JavaScript and JScript include the core ECMAScript language plus many extensions that deal specifically with browser objects such as document, window, frame, form, etc. The methods for these browser-related objects can be ignored if you look at JavaScript documentation, since the scripting engine is being run within the context of the Jargon Reader engine, not within the context of a web browser. Only the core ECMAScript language features are used in Jargon Reader, not JavaScript or JScript extensions.

The scripting engine used by Jargon Software supports primarily the core ECMAScript language features, plus a few other useful methods from JavaScript and/or JScript that are generic methods (not related to browser objects). This scripting has been extended by Jargon Software to provide support for methods used by graphical components, host tasks, and other features of the Jargon Reader run-time environment.

ECMAScript is object-based. The basic language and host facilities are provided by objects, and an ECMAScript program is a cluster of communicating objects. An ECMAScript object is an unordered collection of properties each with 0 or more attributes which determine how each property can be used.

Properties are containers that hold other objects, primitive values, or methods. A primitive value is a member of one of the following built-in types: Undefined, Null, Boolean, Number, and String; an object is a member of the remaining built-in type Object; and a method is a set of programming statements associated with an object via a property.

ECMAScript defines a collection of built-in objects which round out the definition of ECMAScript entities. These built-in objects include the Global object, the Object object, the Function object, the Array object, the String object, the Boolean object, the Number object, the Math object, and the Date object.

ECMAScript also defines a set of built-in operators which may not be, strictly speaking, functions or methods. ECMAScript operators include various unary operations, multiplicative operators, additive operators, bitwise shift operators, relational operators, equality operators, binary bitwise operators, binary logical operators, assignment operators, and the comma operator.

ECMAScript syntax intentionally resembles Java syntax. ECMAScript syntax is relaxed to enable it to serve as an easy-to-use scripting language. For example, a variable is not required to have its type declared nor are types associated with properties, and defined functions are not required to have their declarations appear textually before calls to them.

ECMAScript is a loosely typed language. This means you do not have to declare the data types of variables explicitly. In fact, you cannot explicitly declare data types. Moreover, in many cases ECMAScript performs conversions automatically when needed. For instance, if you add a number to an item consisting of text (a string), the number is converted to text.


A function contains some code that will be executed by an event or a call to that function. A function is a set of statements. To create a function you define its function name, any calling parameters ("arguments"), and one or more statements to be executed. A function may not be declared within another function. All functions may be called from anywhere in a script.

Functions have the following structure:

  • FUNCTION_NAME is user-assigned (see User Tips below)

  • PARAM_LIST is a comma-separated list of user-assigned names for any input parameters (arguments) that will be supplied to this function. These names are scoped for use only within the function where they are declared. Their values will be the values passed on by the statement that calls the function.

  • STATEMENT_BLOCK is a set of one or more methods or other statements to be executed. Each statement should be on a separate line and should be ended with a semi-colon (;). Statements are often indented for readability.
Functions that are linked to events on components cannot have any calling parameters. A function with no arguments must still include an empty set of parentheses:
    function ElvisHasLeftTheBuilding() {  // function linked to "Exit" button
    User Tip: You may wish to establish a naming convention that will make function, variable and parameter names consistent and easily recognizable and understandable.
When writing the statements within a function, it is good practice to put semicolons at the end of statements, although they are not required. Each statement is usually written on a separate line, with or without semicolons, to make scripts easier to read and edit.

A statement block is a group of statements enclosed in curly braces, "{}", which indicate that the enclosed individual statements are a group and are to be treated as one statement. A block can be used anywhere that a single statement can.

Here are some general guidelines for writing the statements within a function:

  • ECMAScript is case-sensitive, so be careful to use upper/lower case letters carefully in the names of functions, variables, components and methods.
  • Open symbols, like  ( { [ " ', must have a matching closing symbol, like  ' " ] } ).
  • Extra spaces are ignored by the script engine. You can add spaces to your script to make it more readable. Avoid tabs since different programs may interpret their size differently.
  • You can break up a long line onto several lines, however do not split a function or method name from its arguments (don't start the split line with a left parenthesis).
  • You can insert special characters with a backslash (\), as shown in the next section.
Escape sequences for characters
Some characters, such as a quotation mark, have special meaning to the interpreter and must be indicated with special character combinations when used in strings. This allows the interpreter to distinguish between a quotation mark that is part of a string and a quotation mark that indicates the end of the string. The table below lists the characters indicated by escape sequences:
\a Audible bell
\b Backspace
\f Formfeed
\n Newline
\r Carriage return
\t Horizontal Tab
\v Vertical tab
\' Single quote
\" Double quote
\\ Backslash character
\0 Null character        (e.g. "\0" is the null character)
\### Octal number    (0-7) (e.g. "\033"   is the escape character)
\x## Hex number      (0-F) (e.g. "\x1B"   is the escape character)
\u#### Unicode number  (0-F) (e.g. "\u001B" is the escape character)

Reserved Words
The following words have special meaning for the interpreter and cannot be used as identifiers for variable, component or function names:

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


A variable is a "container" for information you want to store. A variable's value can change during the script. You can refer to a variable by name to see its value or to change its value.

Rules for Variable names:

  • Variable names are case sensitive
  • Contain only letters (upper and lower case), digits 0-9 and underscores (_).
  • Must begin with a letter or underscore character. It is best to start names with a letter.
  • Do NOT use dashes (-) or any other special characters in user-defined names for functions, variables and parameters.
Variables may be defined "on the fly", or they may be more formally declared with the "var" statement. No data type specification is needed, the script automatically determines or converts a variable to the appropriate data type when it is used, based on context. It is the responsibility of the developer to make sure that correct values are supplied.

For example, both of the following statements are valid ways to create a variable and assign it a value.

    two_squared = 2 * 2;
    var three_squared = 3 * 3;
When you declare a variable within a function, the variable can only be accessed within that function. When you exit the function, the variable is destroyed. These variables are called local variables. You can have local variables with the same name in different functions, because each is recognized only by the function in which it is declared.

A special type of variable is an array, which is an instance of the standard ECMAScript Array object. An Array is a special class of object that refers to its properties with numbers rather than with variable names. Properties of an Array object are called elements of the array. The number used to identify an element is called an index in brackets which follows an array name. Array indices must be either numbers or strings. Array elements can be of any data type. The elements in an array do not all need to be of the same type, and there is no limit to the number of elements an array may have.

Arrays use square brackets to specify the element number within the set of array values, normally starting with [0] for the first. Arrays are dynamic, and any index, positive or negative, into an array is always valid. If an element of an array is referenced, then the script engine ensures that such an element exists. For example, if a statement in a script is:

    var foo[4] = 7;
then an array of 5 integers referenced by the variable foo will be created. If a later statement refers to foo[6], then foo is expanded, if necessary, to ensure that the element foo[6] exists. The same is true for negative indices. When foo[-10] is referenced, foo is grown in the negative direction if necessary, but foo[4] still refers to the initial 7. Arrays can be of any order of dimensions, thus foo[6][7][34][-1][4] is a valid variable or array.

Arrays can be defined in two ways, by specifying the number of elements, or by specifying a set of element values. Examples:

    var bakersDozen = new Array(13); // creates the array 'bakersDozen' with 13 elements
    var carName = new Array("Corvette", "Mustang", "SVX"); // carName[1] == "Mustang"
To find the number of elements in an array that was defined with the new Array statement, use the array.length property. The length will be one greater than the highest element number.

Sorting an Array
To sort the elements of an array, use the array.sort method. This is a very flexible sort routine which will (by default) sort strings in alphabetical order. However, you can optionally provide a compare function that the sort method will use to compare each pair of elements as it is sorting, to handle date and numeric values.

SYNTAX: array.sort([compareFunction])
WHERE:  compareFunction - identifier for a function which expects two parameters x and y,
and returns a negative value if x < y, zero if x = y, or a positive value if x > y.
RETURN: object - this Array object after being sorted.
DESCRIPTION: This method sorts the elements of the array. The sort is not necessarily stable (that is, elements which compare equal do not necessarily remain in their original order).
The comparison of elements is done based on the supplied compareFunction. If compareFunction is not supplied, then the elements are converted to strings and compared. Non-existent elements are always greater than any other element, and consequently are sorted to the end of the array. Undefined values are also always greater than any defined element, and appear at the end of the Array before any empty values. Once these two tests are performed, then the appropriate comparison
is done.

If a compare function is supplied, the array elements are sorted according to the return value of the compare function. If a and b are two elements being compared, then:

  • If compareFunction(a, b) is less than zero, sort b to a lower index than a.
  • If compareFunction(a, b) returns zero, leave a and b unchanged to each other.
  • If compareFunction(a, b) is greater than zero, sort b to a higher index than a.
By specifying the following function as a sort function, you will get the desired result when comparing numbers:
function compareNumbers(a, b)
return a > b
EXAMPLE:  Consider the following code, which sorts based on numerical values, rather than the default string comparison.
function compare( x, y )
   x = ToNumber(x);
   y = ToNumber(y);
   if( x < y )
      return -1;
   else if ( x == y )
      return 0;
      return 1;
var array = new Array( 3, undefined, "4", -1 );
// The sorted array is "-1,3,4,,"
// Notice the undefined value at the end of the array.

Special values

If a variable is created or accessed with nothing assigned to it, it is of type undefined. An undefined variable merely occupies space until a value is assigned to it. When a variable is assigned a value, it is assigned a type according to the value assigned. Though variables may be of type undefined, there is no literal representation for undefined. Since an undefined variable will cast to a boolean value as false, it can be tested as follows (although other values such as zero or an empty string will also cast to false so it is an ambiguous test):

var test;
if (!test)
   myMessage = "test is undefined or has some other value that casts to false";
The value null is a special data type that indicates that a variable is empty, a condition that is different from being undefined. A null variable holds no value, though it might have previously. The null type is represented literally by the identifier, null.
    var test;
    if (test == null)
       myMessage = "test is null";
Since null has a literal representation, assignments like the following are valid:
    var test = null;
Any variable that has been assigned a value of null can be compared to the null literal.

The NaN type means "Not a Number". NaN is an acronym for the phrase. However, NaN does not have a literal representation. To test for NaN, the global function isNaN() must be used, for example:

    var Test = "a string";
    if (isNaN(parseInt(Test)))
       myMessage = "Test is Not a Number";
When the global.parseInt() function tries to parse the string "a string" into an integer, it returns NaN, since "a string" does not represent a number like the string "22" does.


Comments may be of two types: single-line or multi-line. In a single-line comment, all text following a pair of slashes ("//") to the end of that line is treated as a comment and ignored. In a multi-line comment, all text between a starting "/*" and ending "*/" is treated as a comment and ignored. Multi-line comments may not be nested within multi-line comments, but single-line comments can exist within multi-line comments.

    thirty_six = two_squared * three_squared; // this is a single-line comment
    /* This is a multi-line comment that
       also contains a single-line comment // like this one
Control Statements

The standard ECMAScript statements include variable definitions and control commands for looping and conditional execution. The CONDITION in "if" and "while" tests can be anything that evaluates to a boolean value. For an explanation of how various data values convert ("cast") to a Boolean value, see the discussion in the Boolean Properties and Methods section.
Statement that terminates the current while or for loop and transfers program control to the statement following the terminated loop.
Statement that terminates execution of the block of statements in a while or for loop, and continues execution of the loop with the next iteration. 
Executes its statements until the test condition evaluates to false. Statements are executed at least once. 
    do {
    while (CONDITION);
Creates a loop that consists of three optional expressions, enclosed in parentheses and separated by semicolons, followed by a block of statements executed in the loop. 
    for (var i = 0; i < 9; i++) {
       n += i
Statement that executes a set of statements if a specified condition is true. If the condition is false, another set of statements can be executed. Note that the "else" clause is optional. Also, the statement blocks can in turn contain nested "if" statements, to any level. 
    if (CONDITION) {
    [else {
    if (n1 == n2) {
    else {
Statement that exits a function and optionally specifies the value to be returned from running it.
Allows a program to evaluate an expression and attempt to match the expression's value to a case label. 
    switch (EXPRESSION){
       case LABEL: 
       case LABEL: 
       default : STATEMENT_BLOCK;
    switch (my_code) {
      case "B" :
         my_color = "Blue";
      case "R" :
         my_color = "Red";
      default :
         my_color = "Unknown";
Statement that declares a variable, optionally initializing it to a value. 
Statement that creates a loop that evaluates an expression, and if it is true, executes a block of statements. If the condition is initially false, no statements will be executed (unlike "do...while"). 
    while (CONDITION) {


ECMASCript provides a rich set of operators for arithmetic, string, logical and bit-level operations, value assignments, value comparisons, and other special operations.
Operator Description
(Addition) Adds 2 numbers.
(Increment) Adds one to a variable representing a number (returning either the new or old value of the variable)
(Unary negation, subtraction) As a unary operator, negates the value of its argument. As a binary operator, subtracts 2 numbers.
(Decrement) Subtracts one from a variable representing a number (returning either the new or old value of the variable)
(Multiplication) Multiplies 2 numbers.
(Division) Divides 2 numbers.
(Modulus) Computes the integer remainder of dividing 2 numbers.
String + (String addition) Concatenates 2 strings.
+= Concatenates 2 strings and assigns the result to the first operand.
Logical && (Logical AND) Returns true if both logical operands are true. Otherwise, returns false.
|| (Logical OR) Returns true if either logical expression is true. If both are false, returns false.
! (Logical negation) If its single operand is true, returns false; otherwise, returns true.
(Bitwise AND) Returns a one in each bit position if bits of both operands are ones.
(Bitwise XOR) Returns a one in a bit position if bits of one but not both operands are one.
(Bitwise OR) Returns a one in a bit if bits of either operand is one.
(Bitwise NOT) Flips the bits of its operand.
(Left shift) Shifts its first operand in binary representation the number of bits to the left specified in the second operand, shifting in zeros from the right.
(Sign-propagating right shift) Shifts the first operand in binary representation the number of bits to the right specified in the second operand, discarding bits shifted off.
(Zero-fill right shift) Shifts the first operand in binary representation the number of bits to the right specified in the second operand, discarding bits shifted off, and shifting in zeros from the left.
Assigns the value of the second operand to the first operand.
Adds 2 numbers and assigns the result to the first.
Subtracts 2 numbers and assigns the result to the first.
Multiplies 2 numbers and assigns the result to the first.
Divides 2 numbers and assigns the result to the first.
Computes the modulus of 2 numbers and assigns the result to the first.
Performs a bitwise AND and assigns the result to the first operand.
Performs a bitwise XOR and assigns the result to the first operand.
Performs a bitwise OR and assigns the result to the first operand.
Performs a left shift and assigns the result to the first operand.
Performs a sign-propagating right shift and assigns the result to the first operand.
Performs a zero-fill right shift and assigns the result to the first operand.
Comparison == Returns true if the operands are equal.
!= Returns true if the operands are not equal.
> Returns true if left operand is greater than right operand. 
>= Returns true if left operand is greater than or equal to right operand. 
< Returns true if left operand is less than right operand. 
<= Returns true if left operand is less than or equal to right operand. 
Lets you perform a simple "if...then...else"
Evaluates two expressions and returns the result of the second expression.
Lets you delete an object property or an element at a specified index in an array. 
Lets you create an instance of a user-defined object type or of one of the built-in object types.
Keyword that you can use to refer to the current object. 
Returns a string indicating the type of the unevaluated operand. 
The void operator specifies an expression to be evaluated without returning a value.

Standard Methods

The built-in String, Boolean, Number, Date and Global objects include a variety of standard properties and methods that may be used on literal or variables of the appropriate data type. There is also a full set of math functions for use in scientific or financial applications. The following tables show the most commonly used methods. For a complete list, refer to the complete ECMAScript or JavaScript documentation.

String Properties and Methods

A string is an ordered series of characters. The most common use for strings is to represent text. To indicate that text is a string, it is enclosed in quotation marks. You can declare a string with single quotes instead of double quotes. There is no difference between the two ways. Note that a String is both a primitive data type and an object. For most practical purposes, this distinction makes no difference.
Property Name Description
length Returns the number of characters in the target string
    var myString = "abcde";
    myLength = myString.length; // returns 5 (Note: no parentheses)

Method Name Description
Returns the character at the given position in a string, where position starts at zero for the first character.
    var myString = "abcde";
    myChar = myString.charAt(2); // returns "c"
    // get the last character in the string
    lastChar = string.charAt(string.length - 1); // "e"
(string[, offset])
Searches and (if found) returns the index number of the search string within the target string. The search begins at offset if specified, otherwise the search begins at the beginning of the string. If no match is found, "-1" is returned instead.
    var myString = "abcde";
    myPos = myString.indexOf("cd"); // returns 2
    myPos = myString.indexOf("CD"); // returns -1 (case!!)
(string[, offset])
Like above, but searches the string backwards, starting from the right end, so it finds the last occurrence of the search string.
The target string is searched using the regular expression pattern defined by pattern. If a match is found, it is replaced by the substring defined by repl_exp, and returns the original string with replacements in it made according to pattern and repl_exp. The parameter repl_exp may be:
• a simple string
• a string with special regular expression replacement elements in it
• a function that returns a value that may be converted into a string
A full explanation of the powerful features of regular expressions is beyond the scope of this document. See any unix scripting manual.
Simple examples:
    var rtn;
    var str = "aa bb cc bb dd";
    var pat = /b(b)/g;  // the "(b)" is $1 below
    rtn = str.replace(pat, "zz"); // rtn = "aa zz cc zz dd"
    rtn = str.replace(pat, "B$1"); // rtn = "aa Bb cc Bb dd"
Spits a string into multiple substring values according to the specified delimiter, and returns the split values as an array which is typically assigned to an array variable, starting with element [0] and on for as many elements as are found.
    var message="Now you too can learn to parse text"
    var word=message.split(" ")
    //word[0] contains "Now", word[1] contains "you",  etc
(start, length)
Returns a substring starting at position start and including the next number of characters specified by length. If start is positive, the position is relative to the beginning of the string. If start is negative, the position is relative to the end of the string.
    var str = ("0123456789");
    str.substr(0, 5)  // == "01234"
    str.substr(2, 5)  // == "23456"
    str.substr(-4, 2) // == "56"
(from, up_to)
Returns a substring of a string starting at position start and going to, but not including, position up_to.
    var str = "0123456789";
    str.substring(0, 5) // == "01234"
    str.substring(2, 5) // == "234"
    str.substring(0, 10) // == "0123456789"
toLowerCase() Returns a copy of a string with all of the letters changed to lower case.
    var myName = "John Smith";
    eecummingsname = myName.toLowerCase(); // john smith
toUpperCase() Returns a copy of a string with all of the letters changed to upper case.
    var myName = "John Smith";
    ShoutingName = myName.toUpperCase(); // JOHN SMITH

Boolean Properties and Methods

A Boolean data type may have only one of two possible values: false or true. Since values are automatically converted when appropriate, Booleans can be used as they are in languages such as C. Namely, false is zero, and true is non-zero. A script is more precise when it uses the actual values (false and true), but it will work using the concepts of zero and not zero. When a Boolean is used in a numeric context, it is converted to 0, if it is false, and 1, if it is true.

Conversely, when a non-Boolean data type is converted to a Boolean value (as in an "if" test), the value is converted as follows:

  • Buffer    - same as for String
  • null      - false
  • Number    - false if value is 0, +0, -0 or NaN, else true
  • Object    - true
  • String    - false if empty string (""), else true
  • undefined - false
Method Name Description
new Boolean(value) Returns a Boolean object with the parameter value converted to a boolean value.
    var name = "Peter";
    var isRocky = new Boolean( name == "Peter" );
    // The Boolean object "isRocky" is now true.
toString() Returns the string "true" or "false" according to the value of the Boolean object.
    var nn = "Peter";
    var aa = new Boolean( nn == "Peter" ); // comparison returns true
    var bb = false;
    myMsg1 = aa.toString();  // "true"
    myMsg2 = bb.toString();  // "false"

Number Properties and Methods

A Number data type may be an integer or a floating point (exponential) value.

Integers are whole numbers. Decimal integers, such as 1 or 10, are the most common numbers encountered in daily life. There are three notations for integers: decimal, hexadecimal, and octal.

Decimal notation is the way people write numbers in everyday life and uses base 10 digits from the set of 0-9. Examples are:

1, 10, 0, and 999
var a = 101;
Hexadecimal notation uses base 16 digits from the sets of 0-9, A-F, and a-f. These digits are preceded by 0x. Scripts are not case sensitive when it comes to hexadecimal numbers. Examples are:
0x1, 0x01, 0x100, 0x1F, 0x1f, 0xABCD
var a = 0x1b2E;
Octal notation uses base 8 digits from the set of 0-7. These digits are preceded by 0. Examples are:
00, 05, and 077
var a = 0143;
Floating point
Floating point numbers are numbers with fractional parts which are often indicated by a period, for example, 10.33. Floating point numbers are often referred to as floats.

Decimal floats use the same digits as decimal integers but allow a period to indicate a fractional part. Examples are:

0.32, 1.44, and 99.44
var a = 100.55 + .45;
Scientific floats are often used in the scientific community for very large or small numbers. They use the same digits as decimals plus exponential notation. Scientific notation is sometimes referred to as exponential notation. Examples are:
4.087e2, 4.087E2, 4.087e+2, and 4.087E-2
var a = 5.321e33 + 9.333e-2;
Method Name Description
toFixed(decimals) Returns a string representation of this number in fixed-point notation. This method returns a string containing the number represented in fixed-point notation with decimals digits after the decimal point.
    var fraction = 10 / 3;
    var dollarAmt = fraction.toFixed(2);  // "3.33"
toString() Returns a string representation of this number. This method converts a number to a string using a standard format for numbers.
    var n = 8.9;
    var s = n.toString();

Date Properties and Methods
ECMAScript shines in its ability to work with dates. All standard ECMAScript date methods are supported, with the important exception that all month references start at 1 (for January) instead of 0, so you do not have to constantly remember to add 1 to the month value when using these methods.

To create a Date object which is set to the current date and time, use the new operator, as you would with any object.

var currentDate = new Date();
There are several ways to create a Date object which is set to a date and time. The following lines all demonstrate ways to get and set dates and times.
var aDate = new Date(milliseconds);
var bDate = new Date(datestring);
var cDate = new Date(year, month, day);
var dDate = new Date(year, month, day, hours, minutes, seconds);
Method Name Description
getDate() Returns the day of the month, as a number from 1 to 31, of a Date
object. The first day of a month is 1, and the last is 28, 29, 30, or 31.
getDay() Returns the day of the week, as a number from 0 to 6, of a Date object.
Sunday is 0, and Saturday is 6.
getFullYear() Returns the year, as a number with four digits, of a Date object.
getMonth() Returns the month, as a number from 1 to 12, of a Date object. January
is 1, and December is 12.
toDateString() Returns the Date portion of the current date as a string. This string is formatted to read "Month Day, Year", for example, "May 1, 2000". This method uses the local time, not UTC time.
getTime() Gets time information in the form of an integer representing the number of milliseconds from midnight on January 1, 1970, GMT, to the date and time specified by a Date object.
getHours() Returns the hour, as a number from 0 to 23, of a Date object. Midnight is 0, and 11 p.m. is 23.
getMinutes() Returns the minute, as a number from 0 to 59, of a Date object. The first minute of an hour is 0, and the last is 59.
getSeconds() Returns the second, as number from 0 to 59, of a Date object. The first second of a minute is 0, and the last is 59.
getMilliseconds() Returns the millisecond, as a number from 0 to 999, of a Date object. The first millisecond in a second is 0, and the last is 999.

Global Properties and Methods
The properties and methods of the global object may be thought of as global values and functions. The object identifier global is not required when invoking a global method or function. Indeed, the object name generally is not used.
Method Name Description
eval(expression) Evaluates whatever is represented by the parameter expression. If expression is not a string, it will be returned. For example, calling eval(5) returns the value 5.
If expression is a string, the interpreter tries to interpret the string as if it were an ECMAScript statement and execute it. If successful, the method returns the last variable with which it was working, for example, the return variable. If the method is not successful, it returns the special value, undefined.
getArrayLength(array) Returns the length (number of elements) of an array. This function should be used with dynamically created arrays, that is, with arrays that were not created using the new Array() operator and constructor. When working with arrays created using the new Array() operator and constructor, use the length property of the Array object.


    var arr = {4,5,6,7};
    arr_Len = getArrayLength(arr);  // 4
isNaN(value) Returns a boolean value: true if value is not a number, else false.
    function testNumber(numValue) {
       if (isNan(numValue)) 
          return "Not a number"
          return "OK";
parseInt(str[, radix]) Returns the integer to which the target string converts, else NaN. This method converts an alphanumeric string to an integer number. The first parameter, str, is the string to be converted, and the second parameter, radix, is an optional number indicating which base to use for the number. If the radix parameter is not supplied, the method defaults to base 10 which is decimal. If the first digit of string is a zero, radix defaults to base 8 which is octal. If the first digit is zero followed by an "x", that is, "0x", radix defaults to base 16 which is hexadecimal.

White space characters at the beginning of the string are ignored. The first non-white space character must be either a digit or a minus sign (-). All numeric characters following the string will be read, up to the first non-numeric character, and the result will be converted into a number, expressed in the base specified by the radix variable. All characters including and following the first non-numeric character are ignored. If the string is unable to be converted to a number, the special value NaN is returned.


    var i = parseInt("9");
    var i = parseInt("9.3");
    // In both cases, i == 9
parseFloat(str) Returns the floating point number to which the string converts, else NaN. This method is similar to global.parseInt() except that it reads decimal numbers with fractional parts. In other words, the first period, ".", in the parameter string is considered to be a decimal point, and any following digits are the fractional part of the number.

Other Standard Methods

For details on other standard ECMASCript methods not covered here, such as methods for the Math object, consult any comprehensive JavaScript or JScript manual, or see any of the following Web sites:

Netscape JavaScript Reference:

Microsoft JScript Reference:

Web Developers Virtual Library (WDVL) - Authoring JavaScript

DevGuru JavaScript Quick Reference

Using ODBC with Local SQL Databases

Scripts can now use ODBC connections and SQL statements to read and update local databases, such as a Microsoft Access database on a Windows PC, or an Oracle 9i Lite database on a Pocket PC handheld device. For a complete list of the currently supported properties and methods, see these documents:

ODBC Table of Contents

ODBC Index

ODBC Example

Jargon Software Methods

Jargon Reader supports a variety of properties and methods that have been developed by Jargon Software for host calls, graphical components and other specialized features. For a complete list of the currently supported properties and methods, see these documents:

Component Properties

Client Methods

<-- Previous Section      Up to Top      Return to Help Index      Next Section -->