周游世界

JavaScript™ (also known as ECMAScript or JScript) is an interpreted, object-oriented programming language commonly used throughout the web to provide interactive features to web pages. This article introduces JavaScript, outlines some of the basic principles behind programming using JavaScript and illustrates the differences between the different implementations available in Mozilla and Internet Explorer.

About this Article

Part I - Introduction to JavaScript

About JavaScript

JavaScript Implementations

Interpreted Programming Languages

Including JavaScript programs in Web Pages

Example JavaScript Programs

Part II - JavaScript (Pseudo) Reference

JavaScript Data Types

Type Conversions

Execution Contexts

JavaScript Expressions

JavaScript Operators

JavaScript Statements

JavaScript Native Objects

Links

Index

JavaScript Data Types

Data types in JavaScript are divided into two categories:

1. Primitive types whose members are primitive values. The primitive types in JavaScript consist of Undefined, Null, Boolean, Number and String.
2. Object types whose members are all objects. A JavaScript object is really just an unordered collection of properties which may have attributes governing how the properties behave.

Even though there is a one-one correspondence between some of the primitive types and some Object types, they are not the same.

Undefined

The Undefined primitive type has only one value: undefined which is used to represent the value a variable contains when it has not been initialized.

Null

The Null primitive type has only value: null. While null and undefined are used in similar circumstances, the primary difference is that if a variable which has value null has been intentionally initialized to contain a value whereas an undefined value can mean the variable is uninitialized or even does not exist at all.

Boolean

The Boolean primitive type has two values: true and false. Boolean primitive values are not the same as instances of Boolean Objects.

String

The String primitive type are sequences of characters. String primitive values are not the same as instances of String Objects. Literal primitive string values are written as a sequence of characters surrounded either by single quotes (') or double quotes ("). For example, "this is primitive string" and 'this is primitive string' are both primitive string values. To include quotes in a string literal, you can alternate the type of quote as in "this contains a single ' quote" or you can use character escapes to temporarily change the quote to a normal character as in 'this contains a single \' quote'. Character escapes are a means of temporarily changing the meaning of a character and are used to describe control characters as well as all quotes to be included in literal string. A character is escaped by preceding it with a \ character, for example to escape the letter a, you would write it as \a. Section ECMAScript 7.8.4 String Literals describes the character escapes \' (escaped single quote), \" (escaped double quote), \\ (escaped escape character), \b (backspace), \f (form feed), \n (newline), \r (carriage return), \t (tab), \v (vertical tab) which allow special characters to be included in string literals.

MSIE does not support the \v vertical tab character in literal strings. Since \v is defined to be a white space character in Section 7.2 of the ECMAScript standard, MSIE also fails white space handling involving \v.

Example Character Escapes MSIE does not recognize vertical tab '\v' in strings.msg('\' supported ' + (String.fromCharCode(39) == '\'')); msg('\" supported ' + (String.fromCharCode(34) == '\"')); msg('\\ supported ' + (String.fromCharCode(92) == '\\')); msg('\b supported ' + (String.fromCharCode(8) == '\b')); msg('\f supported ' + (String.fromCharCode(12) == '\f')); msg('\n supported ' + (String.fromCharCode(10) == '\n')); msg('\r supported ' + (String.fromCharCode(13) == '\r')); msg('\t supported ' + (String.fromCharCode(9) == '\t')); msg('\v supported ' + (String.fromCharCode(11) == '\v'));

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Number

The Number primitive type are the lowest level representation of integers and floating point numbers. Number primitive values are not the same as instances of Number Objects. Literal primitive number values can be written as integers (123), as floating point with decimals (123.456), as floating point with exponents (123.456e10, the e may be either case), as hexadecimal integers (0xFF, the x or hex digits A-F may be either case)

Objects

As I already mentioned, objects in JavaScript are collections of unordered properties. Each property of an object has a set of internal (not directly accessible to JavaScript programs) attributes which control how the property can be accessed: DontDelete, ReadOnly, and DontEnum.

DontDelete

the property is permanent and can not be removed from the object using the delete operator. Any attempt to delete the property is ignored without error.

DontEnum

the property is not listed when the in operator is used in a for loop to enumerate properties of an object. For example, for (var propname in object) { … }

will not list the property if it is DontEnum. However the in operator can be used to test if the property exists. For example,('propname' in object)

will return true if object.propname exists and false otherwise.

ReadOnly

the property can not be changed through assignment and any attempt to assign to it is ignored without error.

When JavaScript1.1 or JavaScript1.2 are used in Mozilla, attempting to delete a {DontDelete} property or attempting to change a {ReadOnly} property will throw an error.

try { Math.PI = 3; msg('Math.PI == ' + Math.PI); } catch(e) { msg('Error assigning to a [ReadOnly] property. ' + e.name + ': ' + e.message); } try { delete Math.PI; msg('Math.PI == ' + Math.PI); } catch(e) { msg('Error deleting a [DontDelete] property. ' + e.name + ': ' + e.message); }

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Type Conversions

JavaScript automatically converts primitive values and object instances from one type to another depending upon the context. For example, as we have seen, when a number is added to a string using the + operator, JavaScript will determine that the appropriate operator is the string concatenation operator and will convert the number to a string before performing the operation.

input	To Boolean	To Number	To String	To Object
Undefined	false	NaN	'undefined'	throw TypeError
Null	false	+0	'null'	throw TypeError
Boolean	no conversion	1 if input is true, +0 if input is false	'true' if input is true, 'false' if input is false	new Boolean(input)
Number	false if input +0, -0, or NaN otherwise true	no conversion	'NaN' if input is NaN'0' if input is +0, -0'Infinity' if input is Infinityotherwise a string primitive value consisting of the literal representation of the input value	new Number(input)
String	false if string is empty, otherwise true	NaN if the input does not match a literal number value, otherwise the number represented by the equivalent literal number value.	no conversion	new String(input)
Object	true	convert the object's default value to a number	convert the object's default value to a string	no conversion

Type Conversions to primitive types can be performed by using the constructors of the Native Object types as functions rather than as constructors. For example:

// Convert undefined to primitive values msg('Boolean(undefined) is ' + Boolean(undefined)); msg('Boolean(null) is ' + Boolean(null)); msg('Boolean(10) is ' + Boolean(10)); msg('Boolean("42x") is ' + Boolean("42x")); msg('Number(undefined) is ' + Number(undefined)); msg('Number(null) is ' + Number(null)); msg('Number(10) is ' + Number(10)); msg('Number("42x") is ' + Number("42x")); msg('String(undefined) is ' + String(undefined)); msg('String(null) is ' + String(null)); msg('String(10) is ' + String(10)); msg('String("42x") is ' + String("42x"));

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

One surprising result of the Object to Boolean conversion is that an instance of the Boolean Object with value false evaluates to true in conditional expressions but the Object to String conversion of the instance is the string 'false'.

var bool = new Boolean(false); if (bool) { msg('new Boolean(false) is true'); } else { msg('new Boolean(false) is false'); } msg('String(new Boolean(false)) is ' + String(bool));

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

In Mozilla (JavaScript1.1, JavaScript1.2), new Boolean(false) is converted to false instead of true

When called as a function, the Number constructor attempts to convert its argument to a number value. Mozilla JavaScript1.2 converts an Array object to its length. Mozilla JavaScript1.1, JavaScript1.3-JavaScript1.5 converts an empty Array to 0, an Array with one element to 1 and a non-empty Array with length greater than 1 to NaN … Number(array) is like Number(array.toString()).

var empty = []; var one = [1]; var nonempty = [1,2,3]; msg('Number(empty) == ' + Number(empty)); msg('Number(one) == ' + Number(one)); msg('Number(nonempty) == ' + Number(nonempty));

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

MSIE converts all strings representing negative hexadecimal numbers to NaN.

msg('Number("0x10") == ' + Number("0x10")); msg('Number("-0x10") == ' + Number("-0x10"));

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Execution Contexts

Before any JavaScript code is executed, a unique Global object is created which has {DontEnum} properties for the standard built-in objects (Math, String, Date, etc.) and any properties created by the host environment. The environment in which a JavaScript program is executing is maintained in a stack of objects called execution contexts. A stack, also known as a Last in First Out (LIFO) list is a list of data items where items are added (pushed) or removed (popped) from one end called the top of the stack. The execution context at the top of the stack is used by the executing program as the current context. Each execution context maintains an internal object called the variable object which is used to hold references to the variables and functions created in that context. Each variable (or function) is stored in the variable object as a property with property name equal to the variable (or function) name. Each execution context also maintains a scope chain which is a list of objects which are searched when a variable or name needs to be resolved. Whenever JavaScript needs to resolve a reference to a name, it first looks in the current object in the scope chain for a property with the same name. If it is found, the data referenced by that propery is returned as the value of the name. If the name is not found, the next object in the scope chain is searched and so on until either the name has been resolved or all objects in the scope chain have been searched. Once created for a context, the scope chain is only effected by with statements and catch clauses.

Example Scope_Chain var v = 'global scope'; var o = {v: 'object scope'}; var e; msg('global this == ' + this); msg('global v == ' + v); msg('global e == ' + e); function test() { msg('function this == ' + this); msg('function v == ' + v); var v = 'function scope'; with (o) { msg('with this == ' + this); msg('with o v == ' + v); } try { throw 'string exception'; } catch(e) { msg('catch this == ' + this); msg('catch e == ' + e.name + ': ' + e.message); e = 'catch scope'; } msg('function e == ' + e); msg('function v == ' + v); } test(); msg('global v == ' + v); msg('global e == ' + e);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

MSIE creates the catch variable e containing the thrown exception in function scope. This means the variable e exists after the catch clause has finished executing but ceases to exist after the function where the catch clause was located exits. This is not the same as Mozilla which does not define the catch variable outside of the catch clause.

Both MSIE and Mozilla bind the initial scope to a function when it is created as a function expression. In the following example, function f1() is bound to a scope consisting of the global object while function f2() is defined inside a with clause which adds the object o to the beginning of the scope followed by the global object.

var v = 'value 1'; var o = {v: 'value 2'}; var f1 = function () { msg('v == ' + v); }; with (o) { var f2 = function () { msg('v == ' + v); }; } // call with the initial values f1(); f2(); // now modify the values v = 'modified value 1'; o.v = 'modified value 2'; f1(); f2();

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

However when the function is defined using a function declaration, MSIE differs from Mozilla and binds the function to the global scope regardless of any scope changes introduced by with clauses.

var v = 'value 1'; var o = {v: 'value 2'}; function f1() { msg('v == ' + v); }; with (o) { function f2() { msg('v == ' + v); }; } // call with the initial values f1(); f2(); // now modify the values v = 'modified value 1'; o.v = 'modified value 2'; f1(); f2();

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Each execution context maintains a special value called the this value which is determined by how the context was created and the type of code being executed. The this value can not be changed to point to a different object, although properties can be added or removed from it.

Global Execution Context

Whenever a JavaScript program begins, a Global execution context is created and pushed onto the top of the stack. The scope chain is initialized to contain just the global object and the this value is set to point to the global object. Variables are created as {DontDelete} properties of the global object.

Example Global_Execution_Context var globalVar = 'this is a global variable'; msg('globalVar = ' + globalVar); msg('this.globalVar = ' + globalVar); try { // it should not be possible delete the variable // but no error should be thrown. delete this.globalVar; msg('this.globalVar after delete = ' + this.globalVar); } catch(e) { msg('An unexpected error occured deleting a globalVar variable ' + e.name + ': ' + e.message); }

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Mozilla (JavaScript1.1, JavaScript1.2) will throw an error when deleting a global variable since it is defined as {DontDelete}. Note that Mozilla JavaScript1.3 and later do not have the behavior and that Mozilla JavaScript1.1, JavaScript1.2 do not throw errors when deleting function local variables even though they are also {DontDelete}.

Eval Code Context

Whenever JavaScript code is compiled using the eval function, an eval execution context is created and pushed onto the stack until the eval'd code completes when the eval execution context is removed from the stack. The calling execution context determines the scope chain, the variable object and the this value for the eval execution context. If there is no calling context, the scope chain, variable object and the this value are determined in the same way as for the global execution context.

Example Eval_Execution_Context eval("var evalVar = 'this is an eval variable'"); msg('evalVar = ' + evalVar); msg('this.evalVar = ' + evalVar); try { // it should be possible delete the variable // and no error should be thrown. delete this.evalVar; msg('this.evalVar after delete = ' + this.evalVar); } catch(e) { msg('An unexpected error occured deleting a global variable ' + e.name + ': ' + e.message); }

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Function Execution Context

Each time a function call is performed, a function execution context is created and pushed onto the top of the stack and then removed from the stack when the function call ends. An Activation Object is created in the execution context for each function call and is treated as the variable object for the execution context. The scope chain for the context is created by placing the activation object in front of the scope chain of the calling execution context. An arguments object is added as a {DontEnum} property to the variable. The arguments object is initialized with the following properties:

callee

a {DontEnum} property which points to the function object being executed.

caller (non-standard)

In Mozilla and MSIE, the non-standard caller property was used to point to the function which called the currently executing function. This property has been removed from recent releases of both browsers due to security considerations.

function Caller() { msg('Caller: Caller.arguments ' + Caller.arguments); Callee(); } function Callee() { msg('Callee: arguments.caller ' + arguments.caller); } Caller();

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

length

a {DontEnum} property which contains the number of actual arguments in the function call.

a property for each argument

For each argument supplied, a {DontEnum} property of the same name is created in the arguments.

Mozilla JavaScript1.1, JavaScript1.2 will allow function arguments to be enumerated as zero based indexes into the arguments list. This is not possible in Mozilla JavaScript1.3 or later.

In normal function calls, the this value remains unchanged from that of the calling context however in the context of a constructor call (new SomeFunction()), the this value is set to the newly created JavaScript object. An example of a normal function call… An example of a constructor function call…

JavaScript Expressions

Identifiers

An identifier is a sequence of characters beginning with either $ (dollar sign), _ (underscore) or a unicode letter followed by unicode letters, unicode digits, underscores (_) or dollar signs ($). The characters can also be written using unicode escape sequences. Note that identifiers are not restricted to the normal latin character set, but are instead allowed to have letters and digits from the unicode character set.

// Valid Identifiers // latin type variable identifiers var _foo123; var $foo123; var foo123; var foo_123$ // hindi variable identifier using unicode escapes var \u092F\u0942\u0928\u093F\u0915\u094B\u0921 = 'unicode'; msg('\u092F\u0942\u0928\u093F\u0915\u094B\u0921 == ' + \u092F\u0942\u0928\u093F\u0915\u094B\u0921); // hindi variable identifier using unicode characters var यूनिकोड = 'unicode'; msg('यूनिकोड == ' + यूनिकोड); msg('Test passed');

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

// Invalid Identifiers // Mozilla will fire a window.onerror or exception handler // for compile time errors, however MSIE will not. try { eval('var 0foo;'); // the next statement is an error // the next statement should not be executed msg('Test failed: invalid identifier 0foo == ' + 0foo); } catch(e) { msg('Test passed: 0foo is an invalid identifier ' + e.name + ': ' + e.message); }

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Reserved Words

Keywords are identifiers which have special meanings in JavaScript and should not be used as variable or property names. Reserved words are identifiers which may be used as keywords in future versions of JavaScript and should not be used as variable or property names.

Example 7.5.1 - Reserved Words// test if a word can be declared as var function testvar(words) { var e; for (var i = 0; i < words.length; i++) { var word = words[i]; try { eval('var ' + word + ';'); msg('test failed: ' + word + ' is declarable'); } catch(e) { msg('test passed: ' + word + ' is not declarable ' + e.name + ': ' + e.message); } } } // test if a word can be assigned to function testwrite(words) { var e; for (var i = 0; i < words.length; i++) { var word = words[i]; try { eval(word + ' = "foo";'); msg('test failed: ' + word + ' is writable'); } catch(e) { msg('test passed: ' + word + ' is not writable ' + e.name + ': ' + e.message); } } } // keywords var keywords = ['break', 'else', 'new', 'var', 'case', 'finally', 'return', 'void', 'catch', 'for', 'switch', 'while', 'continue', 'function', 'this', 'with', 'default', 'if', 'throw', 'delete', 'in', 'try', 'do', 'instanceof', 'typeof']; // future reserved words var reserved = ['abstract', 'enum', 'int', 'short', 'boolean', 'export', 'interface', 'static', 'byte', 'extends', 'long', 'super', 'char', 'final', 'native', 'synchronized', 'class', 'float', 'package', 'throws', 'const', 'goto', 'private', 'transient', 'debugger', 'implements', 'protected', 'volatile', 'double', 'import', 'public']; testvar(keywords); testvar(reserved); testwrite(keywords); testwrite(reserved);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

MSIE incorrectly allows the following to be declared as variables and assigned values: abstract, int, short, boolean, interface, static, byte, long, char, final, native, synchronized, float, package, throws, goto, private, transient, implements, protected, volatile, double, public. In Mozilla 1.7 (Firefox 1.0) JavaScript 1.1, JavaScript 1.2 instanceof, enum, export, debugger are declarable and writable however in Mozilla 1.7 (Firefox 1.0) for JavaScript 1.3 and later the other keywords and reserved words are not declarable or writable. Mozilla 1.8 (Firefox 1.1) and later (Bugzilla 240317) relax the declaration and assignment of reserved identifiers to improve MSIE compatibility. The following words will no longer throw errors but will still issue JavaScript warnings: abstract, enum, int, short, boolean, interface, static, byte, extends, long, super, char, final, native, synchronized, class, float, package, throws, goto, private, transient, implements, protected, volatile, double, public

Function Expressions

Mozilla can define functions in conditionals. If the code branch is not executed due to the conditional the function is not defined. MSIE however uses the definition of the last occurence of the function. Both Mozilla and MSIE can conditionally define function expressions.

// works in Mozilla, not MSIE if (true) { function f() { return 'true'; }; } else { function f() { return false; }; } msg('Conditional Function: ' + f());

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

// works in Mozilla and MSIE var f; if (true) { f = function () { return 'true'; }; } else { f = function () { return false; }; } msg('Conditional Function: ' + f());

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

MSIE violates the ECMSAcript standard since it can reference a function name outside of the function expression.f = function foo(){alert('foo');}; foo();

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Operators

Operator Precedence and Associativity

Description	Operator	Associativity
member of	[]   .	left to right
(grouping | function call), create instance	()   new	right to left
unary	!   ~   ++   --   +   -   typeof   void   delete	right to left
multiplicative	*   /   %	left to right
addition	+  -	left to right
bitwise shift	<<   >>   >>>	left to right
relational	<   <=   >   >=   in  instanceof	left to right
equality	==  ===   !=   !==	left to right
bitwise and	&	left to right
bitwise xor	^	left to right
bitwise or	|	left to right
logical and	&&	left to right
logical or	||	left to right
conditional	?:	right to left
assignment	=   *=   /=   %=   -=   <<=   >>=   >>>=   &=   ^=   |=	right to left
comma	,	left to right

Member of Operators

Mozilla has the ability to define getter and setter methods for user defined objects. Note that Mozilla introduced this feature in JavaScript 1.5, however it is available for all language versions in Mozilla.

• deprecated - can only create getters and setters as local properties.{_prop: stuff, get prop() {...}, set prop() {...}}
  
  or instance.propname getter = function(arglist) {...};
  
  or instance.propname setter = function(arglist) {...};
  

• recommended - can create getters and setters as shared properties.someObject.prototype.__defineGetter__('propname', function(arglist) ) someObject.prototype.__lookupGetter__('propname');
  
  and someObject.prototype.__defineSetter__('propname', function(arglist) ) someObject.prototype.__lookupSetter__('propname');
  

var deprecated_1 = { _prop: 'default value', get prop() { return this._prop; }, set prop(v) { return this._prop = v; } } msg('deprecated_1.prop == ' + deprecated_1.prop); deprecated_1.prop = 'foo'; msg('deprecated_1.prop == ' + deprecated_1.prop); var deprecated_2 = { _prop: 'default value' }; deprecated_2.prop getter = function() { return this._prop; }; deprecated_2.prop setter = function(v) { return this._prop = v; }; msg('deprecated_2.prop == ' + deprecated_2.prop); deprecated_2.prop = 'foo'; msg('deprecated_2.prop == ' + deprecated_2.prop); function NonDeprecated(v) { this.prop = v; } NonDeprecated.prototype.__defineGetter__('prop', function() { return this._prop; } ); NonDeprecated.prototype.__defineSetter__('prop', function (v) { return this._prop = v; } ); var nondeprecated = new NonDeprecated('initial value'); // call getter msg('nondeprecated.prop == ' + nondeprecated.prop); // call setter nondeprecated.prop = 'foo'; msg('nondeprecated.prop == ' + nondeprecated.prop); // lookup getter msg('nondeprecated.__lookupGetter__(\'prop\') == ' + nondeprecated.__lookupGetter__('prop')); // lookup setter msg('nondeprecated.__lookupSetter__(\'prop\') == ' + nondeprecated.__lookupSetter__('prop'));

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

The __noSuchMethod__ handler was introduced in Mozilla 1.6 in Bug 196097 '__noSuchMethod__' handler for trapping calls to undefined object methods.

// define on an object instance var obj = {}; obj.__noSuchMethod__ = function(id, args) { msg('Undefined method ' + id + ' called with arguments (' + args.join(', ') + ')'); }; obj.foo('bar'); // define on an object prototype Object.prototype.__noSuchMethod__ = function(id, args) { msg('Undefined method ' + id + ' called with arguments (' + args.join(', ') + ')'); }; var date = new Date(); date.baz('foobar');

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Member of ([]) Operator

Syntaxexpression[propertyexpression]

Access Object Properties

Returns the value of a property from an instance of an object. The result of evaluating expression must be or be convertable to an instance of an object, otherwise a TypeError is thrown. For example, it is a TypeError to attempt to access or set a property on undefined or null values.

try { null['prop'] = 'foo'; } catch(e) { msg(e.name + ': ' + e.message) }

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

The name of the property is obtained by evaluating propertyexpression and converting the result to a string primitive value. There is no restriction on the characters which can be used as part of the property name.

var object = {}; object['0' + Math.PI] = 'bar';

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

If the property exists in the object, the values is returned, otherwise undefined is returned.

var object = {foo: 'bar'}; msg('object["foo"] == ' + object["foo"]); msg('object["fu"] == ' + object["fu"]);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Access Array items

Instances of Array Objects treat the numeric index (position) values of items in the array as special object property values which must be less than 2³². If an item does not exist at the specified position in the array, undefined is returned.

Neither Mozilla nor MSIE appear to limit the index values to less than 2³².

var array = [0, 1, 2]; msg('array[0] == ' + array[0]); msg('array[1] == ' + array[1]); msg('array[2] == ' + array[2]); msg('array[3] == ' + array[3]); var exponents = [32, 64, 128, 256]; for (var i = 0; i < exponents.length; i++) { var exponent = exponents[i]; var index = Math.pow(2,exponent); try { array[index] = index; msg('array[' + index + '] == ' + array[index]); } catch(e) { msg('Exception attempting to set array item at index ' + index + ' ' + e.name + ': ' + e.message); } }

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Access characters in Strings

Mozilla extends the [] operator to allow it to access characters from string values as if the string were an array of characters. This is not supported in MSIE.

var string = "abc"; msg('string[0] == ' + string[0]); msg('string[1] == ' + string[1]); msg('string[2] == ' + string[2]); msg('string[3] == ' + string[3]);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Member of (.) Operator

.

Grouping (()) Operator

grouping and function call

Create instance (new) Operator

// new Operand, Operand must be an Object with Constructor else // throws TypeError try { var o = new 'foo'; } catch(e) { msg('Test passed : ' + e.name + ': ' + e.message); if (e instanceof TypeError) { msg('Error Object is a TypeError'); } else { msg('Error: Error Object is not a TypeError'); } }

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Unary Operators

.

>Unary Logical Not (!) Operator

Unary Logical Not (!) converts the value to boolean, then returns false if the value was true and true otherwise.

Unary Bitwise Complement (~) Operator

Unary Bitwise Complement ~ converts its operand to a 32-bit integer, then performs bitwise complement (switching 0 ↔ 1). Non-numeric values are converted to -1 (the complement of 0).

Example Unary_Bit_Negation msg('~(+1) == ' + ~(+1)) msg('~(-1) == ' + ~(-1)); msg('~0x0f) == ' + ~0x0f); msg('~(NaN) == ' + ~(NaN)); msg('~(0) == ' + ~(0)); msg('~(\'1\') == ' + ~('1')); msg('~(\'a\') == ' + ~('a'));

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Increment (++) Operator

The increment operator (++) is used to add the number 1 to a variable or object property. It can be applied either in prefix (++variable) or postfix (variable++) forms. When used as a prefix, ++variable, it first converts the value to a primitive number value, increments the value and then returns the new value as a primitive number value for use in the expression. When used as a postfix, variable++, it increments the value but returns the original value for use in the expression. ++ can only be used on named instances containing values which can be converted to number primitive values.

Example Increment_Operator var value = 0; msg('before: value == ' + value + ', during: ++value == ' + ++value + ', after: value == ' + value); value = 0; msg('before: value == ' + value + ', during: value++ == ' + value++ + ', after: value == ' + value); // instances of Number Objects are converted to primitive number values value = new Number(0); msg('before: typeof value == ' + typeof value + ', value == ' + value + ', during: value++ == ' + value++ + ', after: typeof value == ' + typeof value + ', value == ' + value); // instances of strings are converted to primitive number values value = '0'; msg('before: typeof value == ' + typeof value + ', value == ' + value + ', during: value++ == ' + value++ + ', after: typeof value == ' + typeof value + ', value == ' + value);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Example Increment_Operator_Errors try { // attempt to increment a literal is a compile time error // use eval to force runtime error. eval('++1;'); msg('Test failed. ++1 == ' + eval('++1')); } catch (e) { msg('The operand of ++ can not be a literal'); } try { // It is an error to increment a string if it can // not be converted to a primitive number value. var s = 'string'; eval('++s;'); msg('Test failed. ++s == ' + string); } catch (e) { msg('The operand of ++ must convertable to a number'); }

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Decrement (--) Operator

The increment operator (--) is used to subtract the number 1 from a variable or object property. It can be applied in prefix (--variable) or postfix (variable--) forms. When used as a prefix, --variable, it first converts the value to a primitive number value, increments the variable and then returns the new value as a primitive number value for use in the expression. When used as a postfix, variable--, it increments the value but returns the original value for use in the expression. -- can only be used on named instances containing values which can be converted to number primitive values.

Unary (+) Operator

unary + operator converts its single operand to a primitive number value. If the operand can not be converted to a number, the value NaN is returned.

var before = '1'; var after = +before; msg('typeof before == ' + typeof before + ', before == ' + before); msg('typeof after == ' + typeof after + ', after == ' + after); before = 'a'; after = +before; msg('typeof before == ' + typeof before + ', before == ' + before); msg('typeof after == ' + typeof after + ', after == ' + after);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Unary (-) Operator

unary - operator converts its single operand to a primitive number value and then returns the negative of that value. If the operand can not be converted to a number, the value NaN is returned.

var before = '1'; var after = -before; msg('typeof before == ' + typeof before + ', before == ' + before); msg('typeof after == ' + typeof after + ', after == ' + after); before = 'a'; after = -before; msg('typeof before == ' + typeof before + ', before == ' + before); msg('typeof after == ' + typeof after + ', after == ' + after);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Typeof (typeof) Operator

The typeof operator returns a string value representing the primitive type of its operand.

typeof operator results

Input Type	Output
undefined	'undefined'
null	'object'
primitive boolean	'boolean'
primitive number	'number'
primitive string	'string'
any native object	'object'
any native function	'function
host object	implementation-dependent

Example typeof Operator msg('typeof undefined == ' + typeof undefined); msg('typeof null == ' + typeof null); msg('typeof true == ' + typeof true); msg('typeof 1 == ' + typeof 1); msg('typeof \'s\' == ' + typeof 's'); msg('typeof new Boolean == ' + typeof new Boolean); msg('typeof new Number == ' + typeof new Number); msg('typeof new String == ' + typeof new String); msg('typeof new Object == ' + typeof new Object); msg('typeof function f(){} == ' + typeof function f(){});

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Void (void) Operator

The void operator evaluates an expression but discards any return value and returns undefined.

Example void Operator msg('void (1+2) == ' + void (1+2));

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Delete property (delete) Operator

The delete operator removes a property from an Object and returns true if the variable does not exist after being removed. Note that delete has no effect on JavaScript object properties which are defined to be {DontDelete}.

Example Delete Operator // attempt to delete a declared variable // which should fail without an error var value = 'a value'; var before = value; var result = delete value; var after = value; msg('before: value == ' + before + ' result: ' + result + ' after: value == ' + after); // attempt to delete an undeclared variable // which should succeed undeclared = 'a value'; var before = undeclared; var result = delete undeclared; var after = typeof(undeclared); msg('before: undeclared == ' + before + ' result: ' + result + ' after: undeclared == ' + after); // attempt to delete a property from a user defined object var object = {property: 'value'} var before = object.property; var result = delete object.property; var after = object.property; msg('before: object.property == ' + before + ' result: ' + result + ' after: object.property == ' + after); // attempt to delete a property that does not exist before = object.foo; result = delete object.foo; after = object.foo; msg('before: object.foo == ' + before + ' result: ' + result + ' after: object.foo == ' + after); // attempt to delete a {DontDelete} property before = Math.PI; result = delete Math.PI; after = Math.PI; msg('before: Math.PI == ' + before + ' result: ' + result + ' after: Math.PI == ' + after);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Multiplication (*) Operator

Multiplication * operator converts its operands to number values, then returns the product of the two values as the result. If the conversion results in NaN, the result is NaN.

Example Multiplication_Operator msg('2 * 2 == ' + (2*2)); msg('"2" * "2" == ' + ("2" * "2")); msg('"a" * "b" == ' + ("a" * "b"));

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Division (/) Operator

Division / operator converts its operands to number values, then returns the quotient of the two values as a result. If the divisor is 0, Infinity is returned. If the conversion results in NaN, the result in NaN.

Example Division_Operator msg('1 / 2 == ' + (1 / 2)); msg('1 / 0 == ' + (1 / 0)); msg('"1" / "2" == ' + ("1" / "2")); msg('"a" / "b" == ' + ("a" / "b"));

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Modulus (%) Operator

The Modulus % operator converts it operands to number values, then returns the remainder of a division of its left operand by its right. Unlike C, % can operate on non-integers.

• If the conversion of either operand results in NaN, the result in NaN.
• If the left operand is Infinity, or the right operand is 0, the result is NaN.
• If the left operand is 0 and the right operand is not Infinite, the result is 0.
• otherwise the sign of the result equals the sign of the left operand and the result is left*right*q for the largest integer q which has the same sign of left/right such that q <= left/right.

Example Modulus Operator msg('"a" % 2 == ' + "a" % 2); msg('2 % "a" == ' + 2 % "a"); msg('Infinity % 2 == ' + Infinity % 2); msg('0 % Infinity == ' + 0 % Infinity); msg('1 % Infinity == ' + 1 % Infinity); msg('3 % 0 == ' + 3 % 0); msg('3 % 2 == ' + 3 % 2); msg('(-3) % 2 == ' + (-3) % 2); msg('3 % (-2) == ' + 3 % (-2)); msg('3.5 % 2.5 == ' + 3.5 % 2.5); msg('Math.PI % 3 == ' + Math.PI % 3);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Addition (+) Operator

Depending on the types of its operands, + either performs numeric addition or string concatenation. If either operand is a string (or convertable to a string), the + operator performs string concatenation. If both operands are numbers (or convertable to numbers), the + operator performs numeric addition.

Example Addition Operator // string concatenation msg('"1" + "2" == ' + ("1" + "2")); msg('"1" + 2 == ' + ("1" + 2)); msg('1 + "2" == ' + (1 + "2")); msg('"a" + "2" == ' + ("a" + "2")); msg('"a" + 2 == ' + ("a" + 2)); msg('1 + "a" == ' + (1 + "a")); // numeric addition // note how the grouping operator () forces the intermediate result // of (1 + 2) to be calculated as a numeric addition msg('1 + 2 == ' + (1 + 2)); // without the grouping operator string concatenation would have // been performed msg('1 + 2 == ' + 1 + 2);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Subtraction (-) Operator

The subtraction - operator converts its operands to number values, then returns the result of subtracting the right operand from the left.

// subtract a number from a number msg('2 - 1 == ' + (2 - 1)); // note how the grouping operator forces the intermediate result // of ("2" - "1") to be calculated as numeric subtraction. msg('"2" - "1" == ' + ("2" - "1")); // without the grouping operator, the expression attempts // to subtract a string value from a string, resulting in NaN msg('"2" - "1" == ' + "2" - "1");

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Bit Operators

.

<" >Left Shift (<<) Operator

Left Shift << converts its operands to 32 bit integer values, then shifts the bits in the left operand to the left by the number of bits specified in the right operand and filling the new positions with 0.

Example Left Shift Operator msg('(1 << 1) == ' + (1 << 1)); msg('(-1 << 1) == ' + (-1 << 1)); msg('(2.6 << 2) == ' + (2.6 << 2)); msg('(Math.PI << 3) == ' + (Math.PI << 3)); msg('(NaN << 1) == ' + (NaN << 1)); msg('(Infinity << 1) == ' + (Infinity << 1)); msg('("a" << 1) == ' + ("a" << 1));

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

>" >Signed Right Shift (>>) Operator

Signed Right Shift >> converts its operands to 32 bit integer values, then shifts the bits in the left operand to the right by the number of bits specified in the right operand and filling the new positions with the bit in the left most position.

Example Signed Right Shift Operator msg('(1 >> 1) == ' + (1 >> 1)); msg('(-1 >> 1) == ' + (-1 >> 1)); msg('(2.6 >> 2) == ' + (2.6 >> 2)); msg('(Math.PI >> 3) == ' + (Math.PI >> 3)); msg('(NaN >> 1) == ' + (NaN >> 1)); msg('(Infinity >> 1) == ' + (Infinity >> 1)); msg('("a" >> 1) == ' + ("a" >> 1));

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

>>" >Unsigned Right Shift (>>>) Operator

UnSigned Right Shift >>> converts its operands to 32 bit integer values, then shifts the bits in the left operand to the right by the number of bits specified in the right operand and filling the new positions with 0.

Example Unsigned Right Shift Operator msg('(1 >>> 1) == ' + (1 >>> 1)); msg('(-1 >>> 1) == ' + (-1 >>> 1)); msg('(2.6 >>> 2) == ' + (2.6 >>> 2)); msg('(Math.PI >>> 3) == ' + (Math.PI >>> 3)); msg('(NaN >>> 1) == ' + (NaN >>> 1)); msg('(Infinity >>> 1) == ' + (Infinity >>> 1)); msg('("a" >>> 1) == ' + ("a" >>> 1));

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Relational and Logical Operators

.

<" >Less than (<) Operator

Performs either a numeric or string comparison returning true if the left operand is less than the right operand and false otherwise. If at least one of the operands is a string, then a string comparison is performed, otherwise a numeric comparison is performed. If during the numeric comparison, one of the operands evaluates to NaN, then undefined is returned which is equivalent to false.

Example Less Than Operator msg('1 < 2 == ' + (1 < 2)); msg('NaN < 1 == ' + (NaN < 1)); msg('1 < Infinity == ' + (1 < Infinity)); msg('"10" < 2 == ' + ("1" < 2)); msg('1 < "a" == ' + (1 < "a")); msg('"a" < "b" == ' + ("a" < "b"));

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

It appears that step 3 in ECMAScript 11.8.5 The Abstract Relational Comparison Algorithm is incorrect, since both Mozilla and MSIE appear to use or instead of and when deciding to perform string comparison.

" >Greater than (>) Operator

Performs either a numeric or string comparison returning true if the left operand is greater than the right operand and false otherwise. If at least one of the operands is a string, then a string comparison is performed, otherwise a numeric comparison is performed.

<=" >Less than or equal (<=) Operator

Performs either a numeric or string comparison returning true if the left operand is less than or equal to the right operand and false otherwise. If at least one of the operands is a string, then a string comparison is performed, otherwise a numeric comparison is performed.

=" >Greater than or equal (>=) Operator

Performs either a numeric or string comparison returning true if the left operand is greater than or equal to the right operand and false otherwise. If at least one of the operands is a string, then a string comparison is performed, otherwise a numeric comparison is performed.

Instanceof (instanceof) Operator

Tests if the left operand is an object instance which has the right operand as an ancestor object. In other words, tests if the left operand is an object instance which has the prototype of the right operand in its prototype chain.

Example instanceof Operator // all JavaScript Native Objects are instances of Object var date = new Date(); msg('date instanceof Object == ' + (date instanceof Object)); // throw a TypeError if the right operand is not an object try { msg('date instanceof "foo" == ' + (date instanceof "foo")); msg('Test failed. Should have thrown TypeError'); } catch(e) { msg('Right operand of instanceof must be an object ' + e.name + ': ' + e.message); }

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

instanceof is not supported in Mozilla JavaScript1.1, JavaScript1.2 but is supported in Mozilla JavaScript1.3 and later.

Not sure how to test ECMAScript 11.8.6 The instanceof operator step 6.

In (in) Operator

Tests if the left operand (after conversion to a primitive string value) is the name of a property in the object named in the right operand. The property can be a shared property which exists only in the right operands prototype chain. Throws a TypeError if the right operand is not an object.

Example in Operator // test local properties var object = { propname: "value" }; // test using primitive string name msg('"propname" in object == ' + ("propname" in object)); // test using String object msg('(new String("propname")) in object == ' + ((new String("propname")) in object)); // test TypeError try { msg('"propname" in "foo" == ' + ("propname" in "foo")); msg('Test Failed.'); } catch(e) { msg('Test Passed. Right operand of in must be an object. ' + e.name + ': ' + e.message); }

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Equals (==) Operator

Returns true if its two operands are equal as defined below.

The following discussion uses x == y as the example equality test expression.

• x != y is equivalent to !(x == y)
• x == y is equivalent to y == x (neglecting side effects of evaluation)
• "" + x == "" + y forces string comparison
• x - 0 == y - 0 forces numeric comparison
• !x == !y forces boolean comparison

undefined == undefined

return true

msg('undefined == undefined ' + (undefined == undefined));

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

null == null

return true

msg('null == null ' + (null == null));

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

null == undefined or undefined == null

return true

msg('null == undefined ' + (null == undefined)); msg('undefined == null ' + (undefined == null));

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

typeof x, typeof y are both "string"

return true if x and y consist of the exact same sequence of characters otherwise return false.

msg('"abc" == "abc" ' + ("abc" == "abc")); msg('"abc" == "abcd" ' + ("abc" == "abcd")); msg('"abc == "ABC" ' + ("abc" == "ABC"));

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

typeof x, typeof y both are "number"

• if x or y is NaN, return false
• if x is +0 and y is -0 (or vice-versa), return true
• if x and y is the same number, then return true otherwise return false

To determine if a number n is NaN, use the function isNaN(n).

msg('NaN == NaN ' + (NaN == NaN)); msg('NaN == 1 ' + (NaN == 1)); msg('1 == NaN ' + (1 == NaN)); msg('isNaN(NaN) ' + isNaN(NaN)); msg('+0 == -0 ' + (+0 == -0)); msg('-0 == +0 ' + (-0 == +0)); msg('12e5 == 12e5 ' + (12e5 == 12e5)); msg('1 == 2 ' + (1 == 2));

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

typeof x, typeof y are both "boolean"

return true if x and y are either both true or both false otherwise return false.

msg('true == true ' + (true == true)); msg('false == false ' + (false == false)); msg('true == false ' + (true == false)); msg('false == true ' + (false == true));

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

typeof x, typeof y are both "object"

return true if x and y refer to the same object. Note that different objects with the same value do not compare as equal thus == is not a transitive operator and == does not form an equivalence relation.

var o1 = new Object(); var o2 = o1; var o3 = new Object(); msg('o1 == o2 ' + (o1 == o2)); msg('o1 == o3 ' + (o1 == o3)); var s1 = "abc"; var s2 = new String("abc"); var s3 = new String("abc"); msg('s1 == s2 ' + (s1 == s2)); msg('s1 == s3 ' + (s1 == s3)); msg('s2 == s3 ' + (s2 == s3));

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

vice-versa" typeof x is "number" and typeof y is "string" or vice-versa

convert the "string" value to a primitive number value and return the result of comparing the two numbers.

msg('"1" == 1 ' + ("1" == 1)); msg('2 == "2" ' + (2 == "2"));

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

typeof x is "boolean" and typeof y is not "boolean" or vice versa

convert the "boolean" value to a primitive number value and compare the result.

msg('true == 1 ' + (true == 1)); msg('false == 0 ' + (false == 0)); msg('true == NaN ' + (true == NaN)); msg('false == NaN ' + (false == NaN)); msg('true == 10 ' + (true == 10)); msg('false == 10 ' + (false == 10)); msg('true == "1" ' + (true == "1")); msg('false == "0" ' + (false == "0")); msg('true == "10" ' + (true == "10")); msg('false == "10" ' + (false == "10")); msg('true == null ' + (true == null)); msg('false == null ' + (false == null)); msg('true == undefined ' + (true == undefined)); msg('false == undefined ' + (false == undefined)); msg('true == new Object() ' + (true == new Object())); msg('false == new Object() ' + (false == new Object()));

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

typeof x is either "string" or "number" and typeof y is "object" or vice-versa

convert the "object" value to a primitive value and compare the result.

var s1 = "abc"; var s2 = new String("abc"); var n1 = 123; var n2 = new Number(123); msg('s1 == n2 ' + (s1 == n2)); msg('n1 == s2 ' + (n1 == s2));

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Mozilla JavaScript 1.2 only behaves as if strict equality === specified

var result = (1 == "1"); msg ('Test ' + (result?'Passed':'Failed') + ': (1 == "1") == ' + result);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Does not equal (!=) Operator

return false if left == right is true otherwise return true

Mozilla JavaScript 1.2 only behaves as if strict in-equality !== specified

var result = (null != undefined); msg ('Test ' + (result?'Failed':'Passed') + ': (null != undefined) == ' + result);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Strict Equals (===) Operator

Performs a strict equality comparison on it operands as defined below.

The following discussion uses x === y as the example equality test expression.

if typeof x differs from typeof y

return false

undefined === undefined

return true

msg('undefined === undefined ' + (undefined === undefined));

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

null === null

return true

msg('null === null ' + (null === null));

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

typeof x, typeof y are "number"

• if x or y is NaN, return false
• if x is +0 and y is -0 (or vice-versa), return true
• if x and y is the same number, then return true otherwise return false

msg('NaN === NaN ' + (NaN === NaN)); msg('NaN === 1 ' + (NaN === 1)); msg('1 === NaN ' + (1 === NaN)); msg('isNaN(NaN) ' + isNaN(NaN)); msg('+0 === -0 ' + (+0 === -0)); msg('-0 === +0 ' + (-0 === +0)); msg('12e5 === 12e5 ' + (12e5 === 12e5)); msg('1 === 2 ' + (1 === 2));

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

typeof x, typeof y are both "boolean"

return true if x and y are either both true or both false otherwise return false.

msg('true === true ' + (true === true)); msg('false === false ' + (false === false)); msg('true === false ' + (true === false)); msg('false === true ' + (false === true));

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Strict Does not equal (!==) Operator

return false if left === right is true otherwise return true.

Binary And (&) Operator

Binary And & converts its operands to 32 bit integers, then performs a bitwise And & on the corresponding bits where 1 & 1 is 1 and 0 otherwise.

Example Binary And msg('1 & 3 == ' + (1 & 3)); msg('1 & 2 == ' + (1 & 2)); msg('0x0f & 0xf0 == ' + (0x0f & 0xf0)); msg('NaN & 1 == ' + (NaN & 1)); msg('Math.PI & Math.PI == ' + (Math.PI & Math.PI));

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Binary XOR (^) Operator

Binary XOR ^ converts its operands to 32 bit integers, then performs a bitwise XOR ^ on the corresponding bits where 1 ^ 1 and 0 ^ 0 is 0 and 1 otherwise.

Example Binary XOR msg('1 ^ 3 == ' + (1 ^ 3)); msg('1 ^ 2 == ' + (1 ^ 2)); msg('0x0f ^ 0xf0 == ' + (0x0f ^ 0xf0)); msg('NaN ^ 1 == ' + (NaN ^ 1)); msg('Math.PI ^ Math.PI == ' + (Math.PI ^ Math.PI));

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Binary Or (|) Operator

Binary Or | converts its operands to 32 bit integers, then performs a bitwise Or | on the corresponding bits where 0 ^ 0 is 0 and 1 otherwise.

Example Binary Or msg('1 | 3 == ' + (1 | 3)); msg('1 | 2 == ' + (1 | 2)); msg('0x0f | 0xf0 == ' + (0x0f | 0xf0)); msg('NaN | 1 == ' + (NaN | 1)); msg('Math.PI | Math.PI == ' + (Math.PI | Math.PI));

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Logical And (&&) Operator

returns true if both operands evaluate to true. Note that if the left operand evaluates to false, the right operand is not evaluated (short-circuit evaluation).

msg('true && true ' + (true && true)); msg('true && false ' + (true && false)); msg('false && true ' + (false && true)); // test short-circuit evaluation var v = 'before'; msg('v == ' + v); msg('false && ((v = "after") == "after") ' + (false && ((v = "after") == "after"))); msg('v == ' + v);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Logical Or (||) Operator

returns true if either operand evaluate to true. Note that if the left operand evaluates to true, the right operand is not evaluated (short-circuit evaluation).

msg('true || true ' + (true || true)); msg('true || false ' + (true || false)); msg('false || true ' + (false || true)); // test short-circuit evaluation var v = 'before'; msg('v == ' + v); msg('true || ((v = "after") == "after") ' + (true || ((v = "after") == "after"))); msg('v == ' + v);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Conditional (?:) Operator

The conditional operator takes three arguments:condition ? value1 : value2

and returns the value of the expression value1 if condition evaluates to true, otherwise it returns the value of the expression value2. The precedence of ?: is lower than all other operators except the assignment, compound assignment and the comma operators it is therefore important to properly use the grouping operators (()) to ensure the total expression is evaluated as intended.

// the conditional operator msg(' ( (0 % 2) ? true : false) ' + ( (0 % 2) ? true : false)); msg(' ( (1 % 2) ? true : false) ' + ( (1 % 2) ? true : false)); // the equivalent results using if..else var value; if (0 % 2) { value = true; } else { value = false; } msg('0 % 2 is ' + value); if (1 % 2) { value = true; } else { value = false; } msg('1 % 2 is ' + value);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Assignment Operators

.

Simple Assignment (=) Operator

The assignment operator = sets the value of its left operand to the value of its right operand. If the left operand has not already been declared or created, it is created at the time of the assigment. Variable created via an assignment without a var declaration do not have {DontDelete} and can be deleted via operator delete.

If the assignment operator is used in a conditional, e.g. if (a = b), Mozilla JavaScript 1.1 - JavaScript 1.2 will treat the = as if it were ==.

var a = 0; var b = 0; var result = false; if (a = b) { result = true; } msg('(a = b) when a == 0, b ==0 is ' + result); a = 0; b = 1; result = false; if (a = b) { result = true; } msg('(a = b) when a == 0, b == 1 is ' + result); msg('afterwards a == ' + a + ', b == ' + b);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Compound Assignment (op=) Operators

The compound assignment left op= right is the equivalent for the expressionleft = left op right

where op is one of *, /, %, -, <<, >>, >>>, &, ^ or |.

Comma (,) Operator

The comma operator , is used to evaluate a sequence of expressions, returning the value of the last expression as the value of the entire comma expression. For example, if the expression is expr1, expr2, expr3, expr1 is evaluated, expr2 is evaluated then expr3 is evaluated and the value of expr3 is returned.

var value = 0; msg('The value of (value += 1, value += 2, value += 3) is ' + (value += 1, value += 2, value += 3));

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

JavaScript Statements

• Block Statement
• var Statement
• const Statement
• Empty Statement
• Expression Statement
• Conditional Statements
  • if Statement
  • switch Statement
• Iteration Statements
  • while Statement
  • do-while Statement
  • for Statement
  • for-in Statement
• Labelled Statements
  • continue Statement
  • break Statement
• Exception Statements
  • try , catch and finally Statements
  • throw Statement

Block Statement

A Block statement is a set of one or more other statements which are surrounded by braces {} in order to be treated as a group of statements. Block statements can be used anywhere a single statement can be used.{ statement1 statement2 … }

Block statements are typically used as the bodies of for, while, or if statements. Note that unlike C or Java, there is no block scope in JavaScript. Variables declared inside of block statements do not hide variables declared outside of the block nor do variables declared inside of block statements cease to exist when the block statement is exited.

// declare and initialize a variable outside of the // block statement. var variable = 'outside'; if (true) { // declare the same variable inside of the block // statement. This does not hide the outside variable // which remains unchanged from the outside value. var variable; msg('variable inside block == ' + variable); }

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

var Statement

A var statement creates variables in the current execution scope. If the var statement occurs inside of a function, the declared variables are created in function scope with property attribute {DontDelete}, otherwise they are created in global scope with property attribute attribute {DontDelete}. Variables created via the eval function are created with empty property attributes. See delete Operator for implementation differences in the delete operator. Note that the with statement does not affect the scope when creating variables. The var statement is written as a comma-separated list of variable names and optional initializers which is terminated by a semi-colon (;).// simple variable declaration of name1, // initialized to undefined var name1; // simple variable declaration of name2, // initialized to 'value2' var name2 = 'value2'; // declaration of the variables name3, name4, name5 // with the value of name4 initialized to 'value4' var name3, name4 = 'value4', name5;

Example Delete Global Scope Variablevar globalVar = 'value'; msg('typeof globalVar == ' + (typeof globalVar)); msg('delete globalVar == ' + (delete globalVar)); msg('typeof globalVar == ' + (typeof globalVar));

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Global variables have property attribute {DontDelete} which means that they can not be deleted however any such attempt should not cause an error

Mozilla JavaScript1.1 and JavaScript1.2 will throw an error when attempting to delete a global variable.

Example Delete Function Scope Variablefunction testFunctionVarDelete() { var functionVar = 'value'; msg('typeof functionVar == ' + (typeof functionVar)); msg('delete functionVar == ' + (delete functionVar)); msg('typeof functionVar == ' + (typeof functionVar)); } testFunctionVarDelete();

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Variables created in function scope have property attribute {DontDelete} which means that they can not be deleted and any such attempt should not cause an error. Note that Mozilla JavaScript1.1 and JavaScript1.2 do not throw an error when an attempt to delete a function scope variable is made.

Example Delete Eval Scope Variableeval('var evalVar = "value";'); msg('typeof evalVar == ' + (typeof evalVar)); msg('delete evalVar == ' + (delete evalVar)); msg('typeof evalVar == ' + (typeof evalVar))

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Variables created in via eval have empty internal attributes which means that they can be deleted.

Note that Mozilla JavaScript1.1, JavaScript1.2 successfully delete eval scope variables however returns undefined for delete instead of boolean.

const Statement

Mozilla OnlyA const statement creates variables in the current execution scope with property attribute {ReadOnly} which means it can not be changed. If the const variable is created in global or function scope it also has property attribute {DontDelete} which means it can not be deleted.

Example Modifiy Consttry { eval('const a = 1;'); msg('const a == ' + a); try { a = 2; msg('a should still be 1, a == ' + a); } catch(e) { msg('Error assigning to const var.' + e.name + ': ' + e.message); } } catch(e) { msg('Error during const declaration.' + e.name + ': ' + e.message); }

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Note that Mozilla JavaScript1.1 and JavaScript1.2 will throw an error if a const is the target of an assignment however Mozilla JavaScript1.3 and later will not.

Example Delete Global Scope Const Variableconst globalVar = 'value'; msg('typeof globalVar == ' + (typeof globalVar)); msg('delete globalVar == ' + (delete globalVar)); msg('typeof globalVar == ' + (typeof globalVar));

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Global const variables have property attributes {ReadOnly} and {DontDelete} which means that they can not be changed or deleted however any such attempt should not cause an error however Mozilla JavaScript1.1 and JavaScript1.2 will throw an error.

Example Delete Function Scope Const Variablefunction testFunctionConstDelete() { const functionVar = 'value'; msg('typeof functionVar == ' + (typeof functionVar)); msg('delete functionVar == ' + (delete functionVar)); msg('typeof functionVar == ' + (typeof functionVar)); } testFunctionConstDelete();

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Constant Variables created in function scope have property attribute {ReadOnly} and {DontDelete} which means that they can not be changed or deleted and any such attempt should not cause an error. Note that Mozilla JavaScript1.1 and JavaScript1.2 do not throw an error when an attempt to delete a function scope variable is made.

Example Delete Eval Scope Const Variableeval('const constVar = "value";'); msg('typeof evalVar == ' + (typeof evalVar)); msg('delete evalVar == ' + (delete evalVar)); msg('typeof evalVar == ' + (typeof evalVar));

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Const variables created via eval have property attribute {ReadOnly} which means that they can not be changed but can be deleted. Note that Mozilla JavaScript1.1, JavaScript1.2 successfully delete eval scope variables however returns undefined for delete instead of boolean.

Empty Statement

The empty statement is written as a single semi-colon (;) and is used when a statement is required by the syntax but is unnecessary otherwise.;

Expression Statement

Expression statements are written as:Expression;

Where Expression can not begin with a brace { or function.

Conditional Statements

The if Statement

The if Statement is used to conditionally execute sections of code. The basic form is:if (conditional) Statement1

The conditional expression is evaluated and converted to a boolean value. If the result is true, Statement1 is executed otherwise Statement1 is skipped.

msg('test if true'); if (true) msg('this statement will be executed'); msg('test if false'); if (false) msg('this statement will not be executed');

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

The other form of the if Statement isif (conditional) Statement1 else Statement2

In this case, if conditional evaluates to true, then Statement1 is executed, otherwise Statement2 is executed.

msg('test if true'); if (true) msg('this statement will be executed'); else msg('this statement will not be executed'); msg('test if false'); if (false) msg('this statement will not be executed'); else msg('this statement will be executed');

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

if statements can be combined to create multi-level tests as in:if (conditional1) Statement1 else if (conditional2) Statement2 else if (conditional3) Statement3

In cases such where there is a dangling elseif (conditional0) if (conditional1) Statement1 else Statement2

The elsebinds to the closest if as in:if (conditional0) { if (conditional1) Statement1 else Statement2 }

Braces {} can be used to make it clear how a nested if statement should be executed and can make the code clearer for human readers as well.

msg('without braces'); if (true) if (false) msg('this statement will not be executed'); else msg('this statement will be executed'); msg('with braces'); if (true) { if (false) msg('this statement will not be executed'); else msg('this statement will be executed'); }

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

The switch Statement

The switch statement is used to execute one of a set of possible statements depending on the value of an expression and has the form:switch (switchexpression) { case caseexpression1: statement1 break; case caseexpression2: statement2 break; … default: defaultstatement break; }

switchexpression is evaluated then each case expression caseexpression is evaluated and compared to the switchexpression using strict equality until a match is found. Once a matching caseexpression is found, the statements following up to the following break statement are executed. If the break statement is not present, the statements following the case statement are executed until either a break is encountered or the switch statement is completed. The above example is equivalent to the following nested if statement (note the use of strict equality testing):if (switchexpression === caseexpression1) { statement1 } else if (switchexpression === caseexpression) { statement2 } … else { defaultstatement }

// illustrate a basic switch with strict equality switch (2 * 3) { case '6': msg('this statement will only be executed ' + 'if strict equality is not used'); break; case 6: msg('this statement should be executed'); break; default: msg('this statement is only executed ' + 'if no case expression is satified'); break; }

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

If you do not code a break statement, the execution will fall through continuing to execute case blocks until a break is encountered.

// illustrate a switch with fall through switch (2 * 3) { case '6': msg('this statement will only be executed ' + 'if strict equality is not used'); break; case 6: msg('this statement should be executed'); // no break means fall through to the next statement default: msg('this statement is executed ' + 'since no break was coded for case 6'); break; }

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

While the break statement is not strictly necessary when the default statement is the last block of the switch, it is good practice to code it in the event that at some future date, a programmer changes the switch by adding another case block after the default block.

Iteration Statements

Iteration statements are used to repeatedly execute a set of statements while a condition is true (the while, do while, for statements) to iterate over the properties of an object (for in statement). The special statements break and continue along with labelled statements allow transfers of control similar to that of the goto statement in other languages. Note that there is no goto statement in JavaScript.

The while Statement

while (conditional) Statement

The while statement is used to repeatedly execute a set of statements while a condition evaluates to true.

var i = 0; while (i < 5) { msg('while: i == ' + i + ', i < 5 == ' + (i < 5)); ++i; }

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

The do-while Statement

do Statement while (conditional);

The do while statement is used to repeatedly execute a set of statements until a condition evaluates to false.

var i = 0; do { msg('while: i == ' + i + ', i < 5 == ' + (i < 5)); ++i; } while (i < 5);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Note that unlike while, the do while will execute Statement at least once regardless of the value of conditional since the test occurs after Statement is executed.

do { msg('do while is always executed at least once'); } while (false);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

The for Statement

for (init; condition; increment) Statement

The for statement is a convenience statement for a commonly used form of while statement of the form:init; while(condition) { Statementincrement; }

and is particularly useful for iterating over the elements of an Array.

The for-in Statement

for (propname in object) Statement

for in is used to iterate over the enumerable properties in an object instance. The body of the for loop is executed with the variable propname set to each of the enumerable properties in the object. Properties with property attribute {DontEnum} are not discoverable using the for in statement.

var object = {a: 'a', b: 'b' }; for (var prop in object) { msg('object.[\'' + prop + '\'] == ' + object[prop]); }

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Labelled Statements

label : LoopStatement

label must be an identifier and LoopStatement must be one of the while, for or for-in interation statements. Labelled statements are used to mark loops which are the destination of continue or break statements.

The continue Statement

continue

orcontinue label;

A continue statement is used to restart a loop statement either at the beginning of the currently executing loop or at the beginning of a loop whose location is specified by the labelled statement marked by the label label.

msg('test basic continue'); for (var i = 0; i < 3; i++) { msg('before continue: i == ' + i); continue; msg('after continue: this statement will not be executed'); } msg('test labelled continue'); label0: for (var i = 0; i < 3; i++) { msg('loop0: i == ' + i); label1: for (var j = 0; j < 3; j++) { msg('loop1: i == ' + i + ', j == ' + j); if (i == j) { msg('continue from label0'); continue label0; } else { msg('continue from label1'); continue label1; } } }

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

The break Statement

break

or break label

A break statement is used to terminate either the currently executing loop or the loop whose location is specified by the labelled statement marked by the label label.

msg('test basic break'); for (var i = 0; i < 3; i++) { msg('before break: i == ' + i); break; msg('after break: this statement will not be executed'); } msg('test labelled break'); label0: for (var i = 0; i < 3; i++) { msg('loop0: i == ' + i); label1: for (var j = 0; j < 3; j++) { msg('loop1: i == ' + i + ', j == ' + j); if (i == j) { msg('break from label0'); break label0; } else { msg('break from label1'); break label1; } } }

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Exception Statements

JavaScript provides the ability to handle errors and other exceptions through the use of the exception handling statements try, catch and finally. When an error or other run-time exception occurs in JavaScript the interpreter unwinds the execution stack looking for a try block which contains the code which caused the error. If a try block is found, the interpreter transfers control of the program to the matching catch block of statements passing an exception object thereby allowing the program to investigate the error and possibly recover. If no containing try statement block is found, the program will terminate with an "uncaught exception" error.

Although try, catch, throw were not introduced until after ECMAScript 2, Mozilla JavaScript1.1 and JavaScript1.2 still support these statements.

Web browsers such as Mozilla and Internet Explorer also provide the ability to handle errors at the top level of a program through the use of the window.onerror handler which is a user-defined function which takes arguments message, line and page indicating the error message, the line number and file where the error occured. window.onerror is available in the earliest implementations of JavaScript in Web browsers however its inability to recover from errors gracefully limits its usefulness to handling errors that have not been caught by the techiniques available using try/catch error handling.

The try, catch and finally Statements

Example Try, Catch Reference Errortry { // cause reference error var a = b; } catch(e) { msg('Exception caught: ' + e.name + ': ' + e.message); }

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

In this example, the try block contains a statement var a = b; which attempts to assign an undefined variable b to the variable a. This will cause a Reference Error in JavaScript which would terminate the program if it were not contained in a try block. Once the error occurs, control is transferred to the catch block of statements and the variable e is initialized to reference the Error object describing the error.

Mozilla's implementation of the Error object provides a version of the toString() method which displays a human readable error message containing the type of error which occured and the error message as in ReferenceError: b is not defined however MSIE simply displays [object Error]. MSIE's implementation of the Error object can be modified to report a human readable error message similar to Mozilla's. For example,// override MSIE's Error.prototype.toString if (typeof (new Error).number == 'number') { // number is an MSIE only property Error.prototype.toString = function () { return this.name + ': ' + this.message; }; } try { var a = b; } catch(e) { msg(e); msg('e instanceof ReferenceError == ' + (e instanceof ReferenceError)); }

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Note the difference between Mozilla and MSIE: Mozilla returns a ReferenceError while MSIE returns a TypeError.

Note that there is no var declaration of the exception variable e in the above example. This due to the special scoping rules for catch clauses. In JavaScript, the exception variable passed to the catch block only exists inside of the catch block itself.

MSIE creates the exception object in the containing scope of the catch block and not as part of the catch block's scope.

function test() { var e = 'function scope'; msg('test() before try: e == ' + e); try { var a = b; } catch(e) { msg('test() catch: e == ' + e); } msg('test() after catch: e == ' + e); } var e = 'global scope'; msg('Before test(): e == ' + e); test(); msg('After test(): e == ' + e);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

As you can see, Mozilla sets the variable e to the Error object only inside of the catch block while MSIE sets e to the Error object even after the catch block has finished.

The finally block of statements is executed after the try or catch blocks regardless whether an error occured or not.

// no error try { var a = 1; } catch(e) { msg('Exception caught: ' + e); } finally { msg('Finally clause'); } // thrown exception try { throw 'exception'; } catch(e) { msg('Exception caught: ' + e); } finally { msg('Finally clause'); }

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Mozilla supports the use of conditionals to select the catch clause however Mozilla JavaScript1.1, JavaScript1.2 can not use the instanceof operator since it is not supported. MSIE does not support conditional catch clauses.

// Use conditional catch clauses without instanceof // This example will work in all versions of Mozilla JavaScript try { throw 'string exception'; } catch(e if typeof e == 'number') { msg('Number exception ' + e); } catch(e if typeof e == 'string') { msg('String exception ' + e); } catch(e) { msg('Exception caught: ' + e); } finally { msg('Finally clause'); }

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

// Use conditional catch clauses with instanceof // This example will work in all versions of Mozilla JavaScript1.3 and later try { var a = b; } catch(e if e instanceof String) { msg('String exception ' + e); } catch(e if e instanceof ReferenceError) { msg('ReferenceError caught: ' + e); } finally { msg('Finally clause'); }

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

The throw Statement

throw exception

The throw statement simulates an error condition and passes the value of the exception expression to the catch clauses as the value of the exception variable. The exception value can be any object including an instance of an Error object created via the new operator.

try { throw 'thrown exception'; } catch(e) { msg('Exception caught: ' + e); }

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Mozilla 1.7 and earlier allow an newline after throw and before exception in violation of the ECMA 262 Standard. See ECMA 262 - The throw statement. Mozilla 1.8 (Firefox 1.1) will correctly throw an error in this situation. MSIE correctly throws an error.

throw 'exception';

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

JavaScript Native Objects

• The Global Object
• Object Objects
• Function Objects
• Array Objects
• String Objects
• Boolean Objects
• Number Objects
• Date Objects
• RegExp Objects
• Math Object
• Error Objects

JavaScript provides a number of native (built-in) objects which serve as a standard library. These native objects are the global object and the initial (prior to programs creating new properties) properties of the global object. Native JavaScript objects come in two types:

Function type objects

Function type objects are those which have typeof object == 'function' and can be called as functions (object()). Function type objects have an internal prototype property which is initially set to the value of Function.prototype. This prototype property may or may not (depending on the function) be available as an accessible property prototype. Some Function type objects also have the ability to be used a constructors which when operated on by the new operator return instances of the object. Function type objects which can be used as constructors have an internal constructor property which may or may not be accessible as the constructor property. Every Function type object has a property length which is defined to be {ReadOnly}, {DontDelete} and {DontEnum}. length is defined to be the maximum number of properties for the Function type. This implies that the length property of Function type objects can not be modified or removed by a JavaScript program.

MSIE treats the length property of Function type objects as the number of non-optional arguments instead of the maximum number.

Object type objects

Object type objects are those which have typeof object == 'object' and which can not be called as functions. Object type objects can not be used as constructors.

Every other property of native JavaScript objects are specified to be {DontEnum} unless noted otherwise. This means that these properties can be removed, or redefined by an executing JavaScript program. Many of the native JavaScript objects are constructors which can be used to create instances of the objects. Some methods (as noted below) can be transferred to other objects and reused in different contexts. These methods are called generic methods. Non-generic methods are tied to their original types and will throw a TypeError if used with a different type object.

JavaScript Native Object constructor names are written with the initial letter capitalized. For example, Object, String and Date are all native Object contructors. In the following, any native and user-defined constructor names will be written as Object, String and Date, etc. When referring to instances of these constructors, they will be written using the constructor name in all lower case as object, string and date, etc.. For example, let Example be a constructor.

Example

the constructor object

example

an instance of Example, e.g. example = new Example().

Example.prototype.sharedProperty

some shared property of instances of Example, e.g. example.hasOwnProperty('sharedProperty') == false.

Example.localProperty

some local property of Example, e.g. Example.hasOwnProperty('localProperty') == true.

example .someProperty

some local property of example, e.g. example.hasOwnProperty('localProperty') == true.

The Global Object

The Global object is not accessible by name, can not be used in function calls or as a constructor. It is used as the root of the scope chain when resolving variable references. That means that variables created in global scope (outside of any function bodies) are created as properties of the global object.

In Web browsers such as Mozilla and Internet Explorer, the global object is the window object.

NaN

NaN is a special numeric value (typeof NaN == 'number') which respresents the Not a Number values in the IEEE Standard for binary numbers. NaN has property attributes {DontEnum} and {DontDelete} which means it will not appear in for-in loops and can not be deleted, but can be changed to another value.

Note that NaN compares as not equal to itself as well as any other number. In order to test a number for equality with NaN use the global isNaN(value) function which returns true if value is NaN.msg('typeof NaN == ' + typeof NaN); msg('(NaN == NaN) == ' + (NaN == NaN)); msg('(NaN === NaN) == ' + (NaN === NaN)); msg('isNaN(NaN) == ' + isNaN(NaN));

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Infinity

Infinity is a special numeric value (typeof NaN == 'number') which represents a numeric value which is greater than any other numeric value except NaN. Infinity has property attributes {DontEnum} and {DontDelete} which means it will not appear in for-in loops and can not be deleted, but can be changed to another value.

msg('typeof Infinity == ' + typeof Infinity); msg('(10000000000000000000 < Infinity) == ' + (10000000000000000000 < Infinity)); msg('(NaN < Infinity) == ' + (NaN < Infinity));

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

undefined

undefined is the single value of the type Undefined (typeof undefined == 'undefined') and it used to represent uninitialized values. undefined has property attributes {DontEnum} and {DontDelete} which means it will not appear in for-in loops and can not be deleted, but can be changed to another value.

eval(x)

eval(x) is a function property (method) of the Global Object which compiles and executes the string x as a JavaScript program. eval has property attributes {DontEnum} and {DontDelete} which means it will not appear in for-in loops and can not be deleted, but can be changed to another value. If x contains a syntax error, a SyntaxError will be thrown.

// compile an expression to add two numbers msg('eval(\'1 + 2\') == ' + eval('1 + 2')); // compile an expression with a syntax error try { eval('var 0 = 1;'); } catch(e) { msg('Error ' + e.name + ': ' + e.message + ' is an instance of SyntaxError: ' + (e instanceof SyntaxError)); }

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Mozilla and MSIE allow eval to be used indirectly and to be the object of an assignment. This is supported by the ECMA 262 Standard Section 16. Errors so long as EvalError is not thrown.

// test if implementation throws EvalError when // eval is used indirectly. try { var myeval = eval; msg('myeval(\'1+1\') == ' + myeval('1+1')); } catch(e) { msg('eval can not be used indirectly. ' + e.name + ': ' + e.message); } // test if implementation throws EvalError when // eval is used as a variable. try { var eval = function (s) { msg('redefined eval: ' + s); }; msg('eval(\'1+1\') == ' + eval('1+1')); } catch(e) { msg('eval can not be reassigned. ' + e.name + ': ' + e.message); }

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Mozilla JavaScript 1.2 generates an error "invalid label" when attempting to eval("({})").

try { eval( '({})' ); msg('No error'); } catch(e) { msg('Exception: ' + e.name + ': ' + e.message); }

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

parseInt(string, radix)

parseInt(string, radix) is a function property (method) of the Global Object which parses string converting it to a numeric integer value using base radix. Any leading whitespace in string is skipped. If radix is undefined or 0, then radix is assumed to be 10. If string is not parseable as an integer, NaN is returned. parseInt has property attributes {DontEnum} and {DontDelete} which means it will not appear in for-in loops and can not be deleted, but can be changed to another value.

function test(expr) { var value = eval(expr); msg('typeof ' + expr + ' == ' + (typeof value) + ', ' + expr + ' == ' + value); } test('parseInt(" 10")'); test('parseInt(" 10", 2)'); test('parseInt(" 20x")'); test('parseInt("y20x")')

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

parseFloat(string)

parseFloat(string) is a function property (method) of the Global Object which parses string converting it to a numeric value using base 10. Any leading whitespace in string is skipped. If string is not parseable as an floating point number, NaN is returned. parseFloat has property attributes {DontEnum} and {DontDelete} which means it will not appear in for-in loops and can not be deleted, but can be changed to another value.

function test(expr) { var value = eval(expr); msg('typeof ' + expr + ' == ' + (typeof value) + ', ' + expr + ' == ' + value); } test('parseFloat(" 10")'); test('parseFloat(" 10", 2)'); test('parseFloat(" 20x")'); test('parseFloat("y20x")') test('parseFloat("123.456")'); test('parseFloat("123e4")');

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

isNaN(number)

isNaN(number) is a function property (method) of the Global Object which returns true if number is NaN or convertable to NaN, false otherwise. isNaN has property attributes {DontEnum} and {DontDelete} which means it will not appear in for-in loops and can not be deleted, but can be changed to another value.

msg('isNaN(NaN) == ' + isNaN(NaN)); msg('isNaN("foo") == ' + isNaN("foo"));

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

isFinite(number)

isFinite(number) is a function property (method) of the Global Object which converts number to a numeric value then returns true if the value is not Infinity. number values which are NaN or are convertable to NaN return false. isFinite has property attributes {DontEnum} and {DontDelete} which means it will not appear in for-in loops and can not be deleted, but can be changed to another value.

msg('isFinite(10) == ' + isFinite(10)); msg('isFinite(Infinity) == ' + isFinite(Infinity)); msg('isFinite("NaN") == ' + isFinite("NaN")); msg('isFinite("foo") == ' + isFinite("foo"));

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

encodeURI(uri)and decodeURI(encodedURI)

encodeURI(uri) and decodeURI(encodedURI) are functions properties (methods) of the Global Object which are used encode and decode complete URI values by mapping special characters to their % escaped character equivalents. encodeURI and decodeURI have property attributes {DontEnum} and {DontDelete} which means they will not appear in for-in loops and can not be deleted, but can be changed to another value. Since the uri value is assumed to be a complete URI, the characters ;/?:@&=+$,-_.!~*'() which have special meanings in URIs are left unchanged.

function test(URI) { var encoded = encodeURI(URI); var decoded = decodeURI(encoded); msg('URI == "' + URI + '"'); msg('encoded == "' + encoded + '"'); msg('decoded == "' + decoded + '"'); msg('(URI == encoded) == ' + (URI == encoded)); msg('<br>'); } // test space, percent, backquote test(' %`'); // test unicode characters test('\u092F\u0942\u0928\u093F\u0915\u094B\u0921'); // test invariant special characters test(";/?:@&=+$,-_.!~*'()"); // test digits test('0123456789'); // test latin letters test('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ');

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

encodeURIComponent(uriComponent)and decodeURIComponent(encodedURIComponent)

encodeURIComponent(uriComponent) and decodeURIComponent(encodedURIComponent) are functions properties (methods) of the Global Object which are used encode and decode partial URI values by mapping special characters to their % escaped character equivalents. encodeURIComponent and decodeURIComponent have property attributes {DontEnum} and {DontDelete} which means they will not appear in for-in loops and can not be deleted, but can be changed to another value. Since the uriComponent value is assumed to be a a component of a URI, the characters ;/?:@&=+$, which have special meanings in URIs are not left unchanged and are mapped to their % escaped equivalents. The special characters -_.!~*'() are left unchanged.

function test(URI) { var encoded = encodeURIComponent(URI); var decoded = decodeURIComponent(encoded); msg('URI == "' + URI + '"'); msg('encoded == "' + encoded + '"'); msg('decoded == "' + decoded + '"'); msg('(URI == encoded) == ' + (URI == encoded)); msg('<br>'); } // test space, percent, backquote test(' %`'); // test unicode characters test('\u092F\u0942\u0928\u093F\u0915\u094B\u0921'); // test invariant special characters test("-_.!~*'()"); // test other special characters test(";/?:@&=+$,"); // test digits test('0123456789'); // test latin letters test('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ');

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Object(…)

Function(…)

Array(…)

String(…)

Boolean(…)

Number(…)

Date(…)

RegExp(…)

Math

Error(…)

EvalError(…)

RangeError(…)

ReferenceError(…)

SyntaxError(…)

TypeError(…)

URIError(…)

Object Objects

Object Objects can be created using the Object(value) constructor or using literal Object initializers.

Creating Object Objectsvar object; // create an instance of Object using the constructor object = new Object(); // create an instance of Object using a literal initializer object = {};

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

If Object(value) is called as a function, it performs a conversion of value to Object. Object Objects are special in that serve as the base class for all native and user-defined JavaScript objects.

var types = [Object, Function, Array, String, Boolean, Number, Date, RegExp, Error]; for (var i = 0; i < types.length; i++) { msg(types[i] instanceof Object); }

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

The fact that all native and user-defined objects inherit from Object means that they share Object's methods and if modifications are made to Object.prototype, then all native and user-defined objects automatically share those modifcations.

Example showing how methods are inherited from Object// add fooBar as a method to Object.prototype Object.prototype.fooBar = function () { msg('FOOBAR!'); }; var date = new Date(); date.fooBar();

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Object([value])

The Object function can be called either as a constructor or as a function. Object has property attribute {DontEnum} which means it does not appear in for-in loops, can be deleted and can be the target of an assignment.

Mozilla adds the {DontDelete} property attribute which means Mozilla will not delete it.

// attempt to delete Object msg('Before delete: typeof Object == ' + typeof Object); msg('(delete Object) == ' + (delete Object)); msg('After delete: typeof Object == ' + typeof Object);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

// attempt to assign to Object Object = 'foo'; msg('After Object = \'foo\': Object == ' + Object);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

When called as a constructor with no value argument it will create an empty instance of Object with prototype Object.prototype, with its internal Class property set to 'Object'. When called with a value which is not a native or user-defined JavaScript Object, the constructor returns the valueconverted to Object. When called with a value which is a native or user-defined Object, the constructor returns value without creating a new object instance.

var object1; var object2; // create an empty instance of Object object1 = new Object(); msg('typeof object1 == ' + typeof object1); // convert primitive values to Objects object1 = new Object('foo'); msg('typeof object1 == ' + typeof object1); msg('(object1 == "foo") == ' + (object1 == "foo")); // call with object value returns the same // object object2 = new Object(object1); msg('(object1 === object2) == ' + (object1 === object2));

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Object.prototype

Object.prototype defines the base properties and methods for all native and user-defined JavaScript objects. Although Object.prototype.toString() returns "[object Object]", Object.prototype is not an Object. Object.prototype.prototype is undefined which means it does not inherit properties or methods from any other object.

msg('Object.prototype == ' + Object.prototype); msg('Object.prototype instanceof Object ' + (Object.prototype instanceof Object)); msg('Object.prototype.prototype == ' + Object.prototype.prototype);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Object.prototype has property attributes {DontEnum}, {DontDelete} and {ReadOnly} which means it will not appear in for-in loops, can not be deleted and can not be changed by assignment although its properties may be modified.

Object.prototype.constructor

contains a reference to the constructor function Object used to create the instance.

Object.prototype.toString()

returns a string representing the instance. For instances of type Object, toString returns '[object Object]' however the actual value can vary depending on whether the instance is a native object, a user-defined object or a host object.

In Mozilla JavaScript1.2, toString()a behaves like toSource() below.

The ECMAScript standard specifies that for native JavaScript Objects, toString() should return a string of the form '[object Class]' where Class is the name of the object's constructor however MSIE generates "[object]" for host objects. You can get native built-in objects like Date, RegExp to report "[object Date]", "[object RegExp]" by Native.prototype.getClass = Object.prototype.toString; then calling getClass on an instance. This does not work for user defined objects however.

// define a getClass method based // on Object.prototype.toString. Note // Native JavaScript objects will inherit this // method but Host Objects will not. Object.prototype.getClass = Object.prototype.toString; // test native objects var d = new Date(); var s = new String(); msg('d.toString() == ' + d.toString() + ', d.getClass() == ' + d.getClass()); msg('s.toString() == ' + s.toString() + ', s.getClass() == ' + s.getClass()); // test host objects try { // this will cause an error since the host object // window does not inherit from Object msg('window.toString() == ' + window.toString() + ', window.getClass() == ' + window.getClass()); } catch(e) { msg('Error ' + e.name + ': ' + e.message); // set the getClass method directly on window window.getClass = Object.prototype.toString; msg('window.toString() == ' + window.toString() + ', window.getClass() == ' + window.getClass()); }

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Object.prototype.toSource()

Mozilla only function which returns a string representing the Object Initializer. This is overridden by child classes of Object to perform specialized source output.

var object = {prop1: 'value1', prop2: 'value2'}; try { msg('object.toSource() = ' + object.toSource()); } catch(e) { msg('Error object.toSource not supported ' + e.name + ': ' + e.message); }

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

When called on a function, toSource returns the source code of the function if it is user-defined and a dummy function with '[native code]' as the body when the function is native.function Object() { [native code] }

try { msg('Object.toSource() == ' + Object.toSource()); } catch(e) { msg('Error toSource not supported ' + e.name + ': ' + e.message); }

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Object.prototype.toLocaleString()

returns a localized string representing the instance.

Object.prototype.valueOf()

returns the this value for the instance.

Object.prototype.hasOwnProperty(property)

returns true if property is a local (unshared) property of the instance.

Object.prototype.isPrototypeOf(object)

returns true if the instance is the prototype of object.

Object.prototype.isEnumerable(property)

returns true if property is enumerated during a for (p in instance) loop.

Mozilla and MSIE do not support isEnumerable.

Object.prototype.eval(source)

Evaluates source placing the object instance at the front of the scope chain.

Object.prototype.eval is supported in Mozilla but not MSIE

try { var o = {v: 'object scope' }; msg('eval v in scope of object == ' + o.eval('v')); } catch(e) { msg('Error Object.prototype.eval not supported ' + e.name + ': ' + e.message); }

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Object.name

Mozilla provides a local property name on the Object constructor (as well as other native and user-defined constructors) which returns a string containing the name of the constructor function.

msg('Object.name == ' + Object.name);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Object.length

Object has one optional argument value, therefore Object.length is 1.

msg('Object.length == ' + Object.length);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

MSIE returns Object.length == 0 since it does not report optional arguments.

object.__proto__

Mozilla implements a local property __proto__ in each instance of an object which points to its prototype object. This allows easy access to an instance's prototype. This property is not supported by MSIE.

var object = new Object(); // Mozilla only msg('object.__proto__ == ' + object.__proto__); msg('object.__proto__.toString == ' + object.__proto__.toString); // cross browser emulation of __proto__ msg('getPrototype(object) == ' + getPrototype(object)); msg('getPrototype(object).toString == ' + getPrototype(object).toString); msg('getPrototype(object) == object.__proto__ == ' + (getPrototype(object) == object.__proto__)); function getPrototype(o) { try { return o.constructor.prototype; } catch(e) { } return null; }

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Function Objects

All JavaScript functions are instances of the Function Object and have typeof function == 'function'. Function objects can be created using the Function constructor, as function definitions, or as function expressions.

Creating Function Objects// create a function using function definition function funcdef(arg1, arg2) { return arg1 + arg2; } msg('typeof funcdef == ' + typeof funcdef); // create a function using a function expression var funcexpr = function _funcexpr(arg1, arg2) { return arg1 + arg2;}; msg('typeof funcexpr == ' + typeof funcexpr); // create a function using new Function var funcnew = new Function("arg1", "arg2", "return arg1 + arg2;"); msg('typeof funcnew == ' + typeof funcnew); // create a function using Function call var funccall = Function("arg1", "arg2", "return arg1 + arg2;"); msg('typeof funccall == ' + typeof funccall);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Function(arg1, arg2, …)

The Function constructor can be called equivalently as a constructor new Function(…) or as a simple function call Function(…). The return value of Function is a reference to a function instance which can be called like any other function. Function has property attribute {DontEnum} which means it does not appear in for-in loops, can be deleted and can be the target of an assignment.

Mozilla adds the {DontDelete} property attribute which means Mozilla will not delete it.

// attempt to delete Function msg('Before delete: typeof Function == ' + typeof Function); msg('(delete Function) == ' + (delete Function)); msg('After delete: typeof Function == ' + typeof Function);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

// attempt to assign to Function Function = 'foo'; msg('After Function = \'foo\': Function == ' + Function);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Function() takes any number of string arguments. The last argument is always considered to be a string containing the body of the function while the other arguments are considered to be the list of argument names for the function. Note that the arguments to the new function can be written separately as "arg1", "arg2", … or as a single string "arg1, arg2, …". For example, the following are equivalent:func = new Function("arg1", "arg2", "return arg1 + arg2;") func = new Function("arg1, arg2", "return arg1 + arg2;") function func(arg1, arg2) {return arg1 + arg2;}

Function.prototype

Function.prototype defines the shared properties and methods of all instances of Function inherit. Function.prototype is an instance of Object which means instances of Function inherit from Object.

msg('Function.prototype == ' + Function.prototype); msg('Function.prototype.prototype == ' + Function.prototype.prototype);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Function.prototype has property attributes {DontEnum}, {DontDelete} and {ReadOnly} which means it will not appear in for-in loops, can not be deleted and can not be changed by assignment although its properties may be modified.

Function.prototype.constructor

returns the Function constructor.

Function.prototype.toString()

Returns a string representing the source code of the function instance. For native functions, returns '[native code]' for the function body.

msg('Function.toString() == ' + Function.toString()); function userDefined(arg1, arg2) { return arg1 + arg2; } msg('userDefined.toString() == ' + userDefined.toString()); if ('toSource' in userDefined) { msg('userDefined.toSource() == ' + userDefined.toSource()); }

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Function.prototype.toSource()

Mozilla only function which returns the source code of the function instance. See Function.prototype.toString.

Function.prototype.apply(thisArg, argArray)

Calls the function as if it were a method of the thisArg instance with arguments argArray[0], argArray[1], …. If thisArg is undefined or null, the global object is passed as the value of thisArg.

Function.prototype.call(thisArg[, arg1 [, arg2, …]])

Calls the function as if it were a method of the thisArg instance with arguments arg1, arg2, …. If thisArg is undefined or null, the global object is passed as the value of thisArg.

Function.length

returns 1

msg('Function.length == ' + Function.length);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

function.length

Returns the number of defined arguments for the function instance.

Mozilla JavaScript1.1, JavaScript1.2 will report function.length to be the actual number of arguments passed to the function rather than the defined number of arguments. This is not the case for Mozilla JavaScript1.3 or later. See Example Function_Call_Context.

function.arity

A Mozilla extension function.arity returns the same value as function.length. This is not supported by MSIE

function f(arg0, arg1) { msg('f.length == ' + f.length + ' arguments.length == ' + arguments.length + ' f.arity == ' + f.arity); } f(1);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

function.prototype

The prototype property of function instances is used as the prototype object for objects created from using the function as a constructor.

function.name

Mozilla implements a property on instances of Function which returns the name of the function. Anonymous functions created via new Function() return 'anonymous' while Anonymous functions created by function expressions return ''. Note that Mozilla JavaScript1.1, JavaScript1.2 return '' for both types. Mozilla supports the name property of constructor objects in Function prototypes. This always returns 'Function'. MSIE does not support this property.

function myfunction() { } msg('myfunction.constructor.name ==' + myfunction.constructor.name); msg('myfunction.name == ' + myfunction.name); var myfunctionexpr = function myfunction() { }; msg('myfunctionexpr.constructor.name ==' + myfunctionexpr.constructor.name); msg('myfunctionexpr.name == ' + myfunctionexpr.name); var anonfunction = new Function(); msg('anonfunction.constructor.name ==' + anonfunction.constructor.name); msg('anonfunction.name == ' + anonfunction.name); var anonfunctionexpr = function () {}; msg('anonfunctionexpr.constructor.name ==' + anonfunctionexpr.constructor.name); msg('anonfunctionexpr.name == ' + anonfunctionexpr.name);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Array Objects

Array objects are a special kind of JavaScript object which contain ordered lists of items. Array indexes are special zero-based integer valued properties of the Array object by which items can be retrieved using the member of [] operator. Array objects have a local property length which contains the number of items in the array. Unlike arrays in C, JavaScript Arrays, can grow or shrink in size and it is impossible to have a buffer overrun using JavaScript arrays. If array is an Array, and lenArrays can be created either using array literal initializers of the form: var array = [item0, item1, …] or through the use of the Array constructor: var array = new Array().

Mozilla ignores empty element following trailing comma (,) in an array initializer. MSIE treats empty element following trailing comma (,) as an undefined element.a=[,]; a.length == 1 in Mozilla a.length == 2 in MSIE

var a = [,]; msg('a.length == ' + a.length); for (var i = 0; i < a.length; i++) { msg('a[' + i + '] == ' + a[i]); }

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Array(length)

Array can be called either as a constructor (new Array(len)) or as a function (Array(len)) to create a new instance of an Array with len items each initialized to undefined.

Mozilla JavaScript1.2 new Array(len) creates an array with one element consisting of the number len. Mozilla JavaScript1.1, JavaScript1.3 and later, MSIE will create an array of length len with undefined elements.

var array = new Array(100); msg('array.length == ' + array.length); msg('array[0] == ' + array[0]);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Array has property attribute {DontEnum} which means it does not appear in for-in loops, can be deleted and can be the target of an assignment.

Mozilla adds the {DontDelete} property attribute which means Mozilla will not delete it.

// attempt to delete Array msg('Before delete: typeof Array == ' + typeof Array); msg('(delete Array) == ' + (delete Array)); msg('After delete: typeof Array == ' + typeof Array);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

// attempt to assign to Array Array = 'foo'; msg('After Array = \'foo\': Array == ' + Array);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Array.prototype

Array.prototype has property attributes {DontEnum}, {DontDelete} and {ReadOnly} which means it will not appear in for-in loops, can not be deleted and can not be changed by assignment although its properties may be modified.

Array.prototype.constructor

Returns a reference to the Array constructor.

Array.prototype.toString()

Returns a string listing the string values of each element separated by , separator. The result is identical to the result returned by join(',')

Mozilla JavaScript1.2 will return a string representing an array literal initializer for the array instance. This is the same as the result of toString() with [ and ] surrounding the toString() value.var array = [1, 2]; msg('array.toString() == ' + array.toString());

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Array.prototype.toSource()

Mozilla will return a string representing an array literal initializer for the array instance. This is the same as the result of toString() with [ and ] surrounding the toString() value.

var array = [1, 2]; msg('array.toSource() == ' + array.toSource());

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Array.prototype.toLocaleString()

Returns a localized string representing the Array.

Array.prototype.concat([item1[, item2 [, …]]])

Return a new array instance consisting of the elements of array item1, item2 in the same order.

var array1 = [1,2]; var array2 = [3,4]; var array3 = [5,6]; var result = array1.concat(array2,array3); for (var i = 0; i < result.length; i++) { msg('result[' + i + '] == ' + result[i]); }

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Array.prototype.join(separator)

Returns a string value consisting of the concatenation of the string values of each element separated by the separator.

MSIE will not default the separator to , if the separator value is undefined however it will if the separator is not specified.

var array = [1, 2]; msg('array.join() == ' + array.join()); msg('array.join(undefined) == ' + array.join(undefined)); msg('array.join(\'-\') == ' + array.join('-'));

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Array.prototype.pop()

Removes the element at the end of the array and returns it as the value of the function call. If the array is empty, pop() returns undefined.

var stack = ['a', 'b', 'c']; msg('stack.pop() == ' + stack.pop()); msg('stack.toString() == ' + stack.toString()); msg('stack.pop() == ' + stack.pop()); msg('stack.toString() == ' + stack.toString()); msg('stack.pop() == ' + stack.pop()); msg('stack.toString() == ' + stack.toString()); msg('stack.pop() == ' + stack.pop()); msg('stack.toString() == ' + stack.toString());

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Array.prototype.push([item1[, item2[, …]]])

Inserts the item1, … at the end of the array and returns the new length of the array after the operation.

Mozilla JavaScript1.1, JavaScript1.2 return the pushed value rather than the new length of the array.

var stack = []; msg('stack.push(\'a\') == ' + stack.push('a')); msg('stack.toString() == ' + stack.toString()); msg('stack.push(\'b\') == ' + stack.push('b')); msg('stack.toString() == ' + stack.toString()); msg('stack.push(\'c\') == ' + stack.push('c')); msg('stack.toString() == ' + stack.toString());

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Array.prototype.reverse()

Returns a copy of the Array instance with the items in reversed order

var array = [0, 1, 2, 3, 4]; msg('array.reverse() == ' + array.reverse());

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Array.prototype.shift()

Removes the element at the 0^th position in the array moving the remaining elements lower in the array and returns it as the value of the function call. If the array is empty, shift() returns undefined. See Array.prototype.pop().

var stack = ['a', 'b', 'c']; msg('stack.shift() == ' + stack.shift()); msg('stack.toString() == ' + stack.toString()); msg('stack.shift() == ' + stack.shift()); msg('stack.toString() == ' + stack.toString()); msg('stack.shift() == ' + stack.shift()); msg('stack.toString() == ' + stack.toString()); msg('stack.shift() == ' + stack.shift()); msg('stack.toString() == ' + stack.toString());

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Array.prototype.slice(start, end)

Returns an Array instance consisting of the items from the Arrayarray from index start up to but not including end. If end is not specified or is undefined, it is treated as the length of the array. If start or end are negative, they are treated as array.length + start or array.length + end

var array = [0, 1, 2, 3, 4]; var length = array.length; msg('array == ' + array); msg('array.length == ' + length); // return an array without the first item msg('array.slice(1) == ' + array.slice(1)); // return an array consisting of the second and third items msg('array.slice(1, 3) == ' + array.slice(1, 3)); // return an array consisting of the last item msg('array.slice(-1, 5) == ' + array.slice(-1, 5)); msg('array.slice(length - 1, 5) == ' + array.slice(length - 1, 5)); // return an array without the first or last items msg('array.slice(1, -1) == ' + array.slice(1, -1)); msg('array.slice(1, length - 1) == ' + array.slice(1, length - 1)); // return an array consisting of the third and fourth items msg('array.slice(-3, -1) == ' + array.slice(-3, -1)); msg('array.slice(length - 3, length - 1) == ' + array.slice(length - 3, length - 1));

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Array.prototype.sort(comparefunc)

Returns an Array instance which has its items sorted according to the order defined by the comparison function comparefunc. comparefunc(left, right) determines the order by returning -1 if left should occur before right, +1 if left should occur after right or 0 if left and right have no preference as to order. If comparefunc is not specified or is undefined, the default order specified by < used.

// output an array of Things sorted by name // an object with a name function Thing(name) { this.name = name; } // allow Thing objects to be convertable to string values. Thing.prototype.toString = function() { return this.name; }; // an array of Things var array = [ new Thing('Ralph'), new Thing('john'), new Thing('george') ]; function compareThings(left, right) { // do case insenstive sort var lname = left.name.toLowerCase(); var rname = right.name.toLowerCase(); if (lname < rname) return -1; if (lname > rname) return +1; return 0; } msg('array.sort(compareThings) == ' + array.sort(compareThings));

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Array.prototype.splice(start, deleteCount[, item1 [, item2[, …]]])

Replaces deleteCount elements from the array beginning at array index start with item1 …. Returns the removed elements as an array.

var array = [1, 2, 3, 4, 5]; var result = array.splice(0, 1, 'a'); msg('array.splice(0, 1, \'a\') == ' + result.toString() + ' array.toString == ' + array.toString()); var array = [1, 2, 3, 4, 5]; result = array.splice(0, 2, 'b', 'c'); msg('array.splice(0, 2, \'b\', \'c\') == ' + result.toString() + ' array.toString() == ' + array.toString());

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Mozilla JavaScript1.2 will return a single removed element instead of an array containing the removed element.

Array.prototype.unshift([item1[, item2[, …]]])

Inserts the item1, … at the 0^th … position in the array, shifting existing elements higher in the array and returns the new length of the array after the operation. See Array.prototype.push().

MSIE does not return the new length of the array, instead returning undefined.

var stack = []; msg('stack.unshift(\'a\') == ' + stack.unshift('a')); msg('stack.toString() == ' + stack.toString()); msg('stack.unshift(\'b\') == ' + stack.unshift('b')); msg('stack.toString() == ' + stack.toString()); msg('stack.unshift(\'c\') == ' + stack.unshift('c')); msg('stack.toString() == ' + stack.toString());

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

array .length

Returns the length (number of items) in the array. length has property attributes {DontEnum} and {DontDelete} which means it can not be enumerated in a for-in loop, or deleted by can be the target of an assignment. If the new value of length is less than the existing length of the array, the items past the new end of the array are deleted. If the new value of length is greater than the existing length of the array, the length of the array is increased and the new items are initialized to undefined.

var array = [0, 1, 2, 3, 4]; msg('array == ' + array); // truncate array to length 2 array.length = 2; msg('array == ' + array); // increase array to length 6 array.length = 6; msg('array == ' + array);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

String Objects

String

String has property attribute {DontEnum} which means it does not appear in for-in loops, can be deleted and can be the target of an assignment.

Mozilla adds the {DontDelete} property attribute which means Mozilla will not delete it.

// attempt to delete String msg('Before delete: typeof String == ' + typeof String); msg('(delete String) == ' + (delete String)); msg('After delete: typeof String == ' + typeof String);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

// attempt to assign to String String = 'foo'; msg('After String = \'foo\': String == ' + String);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

String.prototype

String.prototype has property attributes {DontEnum}, {DontDelete} and {ReadOnly} which means it will not appear in for-in loops, can not be deleted and can not be changed by assignment although its properties may be modified.

String.prototype.constructor

Return a reference to the String constructor.

String.prototype.toString()

Returns the String converted to a string primitive value. (Same as String.prototype.valueOf)

msg('typeof (new String("foo")).toString() == ' + typeof (new String("foo")).toString());

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

String.prototype.valueOf()

Return the String converted to a string primitive value. (Same as String.prototype.toString)

msg('typeof (new String("foo")).valueOf() == ' + typeof (new String("foo")).valueOf());

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

String.prototype.charAt(pos)

Returns the character at index pos from the string.

var string = 'abcdefg'; msg('string.charAt(5) == ' + string.charAt(5));

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Mozilla supports the alternate [] member of syntax to return characters from a string. var string = 'abcdefg'; msg('string[5] == ' + string[5]);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

String.prototype.charCodeAt(pos)

Returns a 16-bit number representing the Unicode code point value of the character at position pos in the string.

String.prototype.concat([string1[, string2[, …]]])

Converts its arguments to primitive string values, then returns a primitive string value consisting of the the characters from each of the arguments string1, string2, … in the same order. String.prototype.concat and operator + are equivalent on string operands.

Example Concat a primitive string, instance of String Object and an instance of Array Objectvar s1 = '123'; var s2 = new String('456'); var s3 = ['789']; var result = s1.concat(s2, s3); msg('result = s1.concat(s2, s3)'); msg('result == ' + result); msg('typeof result == ' + typeof result);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Example Concat a primitive string, instance of String Object and an instance of Array Object using the string + operator.var s1 = '123'; var s2 = new String('456'); var s3 = ['789']; var result = s1.concat(s2, s3); msg('result = s1 + s2 + s3'); msg('result == ' + result); msg('typeof result == ' + typeof result);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

String.prototype.indexOf(searchString, position)

Converts the this value and the searchString argument to primitive string values and position to a number value, then searches the this string value beginning at position, returning the position in the string where searchString appears or -1 if it is not found. If position is undefined, searching begins at position 0.

// get the first occurrence of 'Bar' var string = 'FooBarfoobarFooBarBaz'; var result = string.indexOf('Bar'); msg("string = 'FooBarfoobarFooBarBaz'"); msg("result = string.indexOf('Bar');"); msg('result == ' + result); // get the next occurrence of 'Bar' result = string.indexOf('Bar', result + 'Bar'.length); msg("result = string.indexOf('Bar', result + 'Bar'.length');"); msg('result == ' + result);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

String.prototype.lastIndexOf(searchString, position)

Converts the this value and the searchString argument to primitive string values and position to a number value, then searches the this string value backwards beginning at position, returning the position in the string where searchString appears or -1 if it is not found. If position is undefined, searching begins at the last position in the string.

// get the last occurrence of 'Bar' var string = 'FooBarfoobarFooBarBaz'; var result = string.lastIndexOf('Bar'); msg("string = 'FooBarfoobarFooBarBaz'"); msg("result = string.lastIndexOf('Bar');"); msg('result == ' + result); // get the next to last occurrence of 'Bar' result = string.lastIndexOf('Bar', result - 1); msg("result = string.lastIndexOf('Bar', result - 1);"); msg('result == ' + result);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

String.prototype.localeCompare(that)

Converts the this value and the that argument to primitive string values, then returns a number representing how this compares to that in the current locale:

-1

this compares less than that

+1

this compares greater than that

0

this and that compare as equal

String.prototype.match(regexp)

Converts this to a primitive string value, and if regexp is not an instance of RegExp converts it to a regular expression via new RegExp(regexp), then returns an array containing the matches. The actual result array depends upon whether the regular expression is global or not. If regexp is a non global regular expression, then the result array is the same as returned by RegExp.prototype.exec.

In this example using a non global regular expression, match will return an array instance whose first element is the substring which was matched ('aa' in this case) and whose second element contains the part of the string which matched the capturing parentheses ('aa') in this case).var string = 'aabbbccccdddd'; var regexp = /(a*)/; var result = string.match(regexp); msg('result == ' + result); msg('result.length == ' + result.length); // compare to the result of calling RegExp.prototype.exec msg('regexp.exec(string) == ' + regexp.exec(string));

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

If regexp is a global regular expression (has the g flag), then regexp.lastIndex is set to 0, then RegExp.prototype.exec is repeatedly called until there are no more matches each time updating regexp.lastIndex. The result array is constructed from the matched substrings of each of the exec calls. If any of the calls to exec match the empty string '', then lastIndex is incremented to start the next search at the next character in the string. XXX: Compatibility issues described in Bug 225094"

In this example using a global regular expression, match will return an array whose first element is the substring which was first matched ('aa' in this case). The remainder of the result array contains the subsequent matches where (a*) was matched to the empty string at each position.var string = 'aabbbccccdddd'; var regexp = /(a*)/g; var result = string.match(regexp); msg('test String.prototype.match'); msg('result == ' + result); msg('result.length == ' + result.length); // compare to the result of repeatedly calling // RegExp.prototype.exec on the regular expression regexp.lastIndex = 0; result = []; var temp; while (regexp.lastIndex <= string.length) { temp = regexp.exec(string); result[result.length] = temp[0]; if (!temp[0]) { regexp.lastIndex++; } } msg('test repeated calls to RegExp.prototype.exec'); msg('result == ' + result); msg('result.length == ' + result.length);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

String.prototype.replace(searchValue, replaceValue)

In its simplest form, replace replaces the first occurence of the string searchValue with the string replaceValue.

var string = 'The situation is all fubar which is fundamental.'; var result = string.replace('fu', 'foo'); msg('result == ' + result);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Mozilla JavaScript 1.1, 1.2, 1.3, 1.4 will attempt to convert the first argument to String.prototype.replace to a regular expression. If the first argument is a string which does not contain a valid regular expression, an error will be thrown. In Mozilla JavaScript 1.5, if the first argument is a string, no conversion is attempted and no error is thrown. bug 280546try { msg("f?oo".replace('?oo','ee')); } catch(e) { msg(e.name + ': ' + e.message); }

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

When searchValue is a regular expression, replaces the match in the string by replaceValue. If the regular expression has its global property set, replace will replace all matches. The following special strings can be used in the replaceValue string which will be replaced as follows:

Characters	Result
$$	$
$&	the matched substring
$`	the portion of string preceding the match
$'	the portion of the string following the match
$n	the nth element from the capture array where n is a single digit 1-9.
$$	the nnth element from the capture array where nn is a 2 digit number 01-99

var string = 'The situation is all fubar which is fundamental.'; var result = string.replace(/fu/g, 'foo'); msg('result == ' + result); result = string.replace(/fu/g, "(match=$&, prefix=$`, suffix=$')"); msg('result == ' + result);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

When searchValue is a string and replaceValue is a function, then for each match of searchValue, the function is called with the first argument containing the matched string, the second argument containing the offset of the match in the string followed by the value of the string itself.

var string = 'The situation is all fubar which is fundamental.'; var result = string.replace('fu', myreplace); msg('result == ' + result); function myreplace(string) { msg('myreplace: arguments.length == ' + arguments.length); for (var i = 0; i < arguments.length; i++) { msg('arguments[' + i + '] == ' + arguments[i]); } return ' myreplace-foo-myreplace '; }

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

When searchValue is a regular expression and replaceValue is a function, then for each match of searchValue, the function is called with the first argument containing the matched string, and the remaining arguments are the elements of the match array, followed by the offset in the string where the match occured, and the final argument is the value of the string itself.

var string = 'The situation is all fubar which is fundamental.'; var result = string.replace(/((f)(u))/g, myreplace); msg('result == ' + result); function myreplace(string) { msg('myreplace: arguments.length == ' + arguments.length); for (var i = 0; i < arguments.length; i++) { msg('arguments[' + i + '] == ' + arguments[i]); } return ' myreplace-foo-myreplace '; }

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

String.prototype.search(regexp)

Converts the this value to a primitive string and if regexp is not an instance of RegExp, converts it to a regular expression via new RegExp(regexp), then returns the position in the this value which first matches regexp or -1 is no match is found.

// search 'FooBar' for a letter var string = 'FooBar'; var regexp = /[a-zA-Z]/; var result = string.search(regexp); msg('A letter occurs in ' + string + ' at position ' + result); // search 'FooBar' for a number regexp = /[0-9]/; result = string.search(regexp); msg('A number occurs in ' + string + ' at position ' + result);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

String.prototype.slice(start,end)

Converts the this value to a primitive string and the arguments start, end to integers, then returns a string value consisting of the characters in the this value from position start up to but not including position end. If end is undefined, then end is treated as the length of the this string. If start or end are less than zero, they are treated as this.length + start and this.length + end respectively.

var string = '01234'; var length = string.length; msg('string == ' + string); msg('string.length == ' + length); // return an string without the first item msg('string.slice(1) == ' + string.slice(1)); // return an string consisting of the second and third items msg('string.slice(1, 3) == ' + string.slice(1, 3)); // return an string consisting of the last item msg('string.slice(-1, 5) == ' + string.slice(-1, 5)); msg('string.slice(length - 1, 5) == ' + string.slice(length - 1, 5)); // return an string without the first or last items msg('string.slice(1, -1) == ' + string.slice(1, -1)); msg('string.slice(1, length - 1) == ' + string.slice(1, length - 1)); // return an string consisting of the third and fourth items msg('string.slice(-3, -1) == ' + string.slice(-3, -1)); msg('string.slice(length - 3, length - 1) == ' + string.slice(length - 3, length - 1));

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

String.prototype.split(separator,limit)

Returns an array of length at most limit consisting of elements containing the substrings of the this input string which were separated by separator. separator can be either a string or regular expression. Note that an empty string "" can be returned as the prefix of the separator at the beginning of the this input string or as a suffix of the separator at the end of the this input string. If separator is an empty string, an empty regular expression or a regular expression matching an empty string, the returned array consists of an element for each character in the this input string.

// empty string as separator msg('"ab".split("") == ' + "ab".split("")); // empty regular expression as separator msg('"ab".split(/(?:/)) == ' + "ab".split(/(?:)/));

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Mozilla JavaScript1.2 emulates Perl4 when the separator is a single space it will skip leading whitespace and splits on whitespace instead of on each space character.

var string = " 123 456 "; msg('string.split(" ").join() == ' + string.split(" ").join());

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

If separator is a regular expression, only the first match is considered. For example, "ab".split(/a*/) uses a greedy match for a maximum length match for zero or more a characters, therefore the first match consists of the a which results in the empty string "" as its prefix and the b as the remainder of the string. Thus the return value would be ["","b"] The empty string result is not rejected even though another possible match could have been the leading empty string matching zero a characters. By contrast "ab".split(/a*?/) uses a non-greedy match for the minimum length match for zero or more characters, therefore the first match consists of the empty string "" at the beginning of the string. The second match is the zero length string separating the a and b characters resulting in a return value of ["a","b"].

msg('"ab".split(/a*/) == ' + "ab".split(/a*/)); msg('"ab".split(/a*?/) == ' + "ab".split(/a*?/));

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

If the this input string is empty, and the separator matches the empty string, then there are no substrings and the result is the empty array. If the this input string is empty and the separator does not match the empty string, then the result is an array of one element consisting of the empty string.

msg('"".split(""/).length == ' + "".split("").length); msg('"".split(/a/).length == ' + "".split(/a/).length);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

If separator is a reqular expression containing capturing parentheses, then the results of the capturing parentheses (including undefined are spliced into the resulting array.

var string = "Abold and<CODE>coded</CODE>"; var regexp = /<(\/)?([^<>]+)>/; var result = string.split(regexp); for (var i = 0; i < result.length; i++) { msg('typeof result[' + i + '] == ' + typeof result[i] + ', ' + 'result[' + i + '] == ' + result[i]); }

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Note that neither Mozilla nor MSIE reproduce the output listed in the ECMA 262 3^rd edition. Mozilla outputs empty strings instead of undefined and MSIE fails to output the elements of the capturing array, instead ignoring the capturing parentheses altogether.

ECMA 262 3^rd

["A", undefined, "B", "bold", "/", "B", "and", undefined, "CODE", "coded", "/", "CODE", ""]

Mozilla

["A", "", "B", "bold", "/", "B", "and", "", "CODE", "coded", "/", "CODE", ""]

MSIE

["A", "bold", "and", "coded"]

Trying the previous example with non-capturing parentheses shows that MSIE definitely ignores capturing parentheses in split regular expressions. Note that Mozilla has one extra empty string element at the end of the array.var string = "Abold and<CODE>coded</CODE>"; var regexp = /<(?:\/)?(?:[^<>]+)>/; var result = string.split(regexp); for (var i = 0; i < result.length; i++) { msg('typeof result[' + i + '] == ' + typeof result[i] + ', ' + 'result[' + i + '] == ' + result[i]); }

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Finally, if separator is undefined, the result is an array with one element consisting of the this string value.

var string = "regular expressions are foonderbar"; // separator is not passed to split var result = string.split(); for (var i = 0; i < result.length; i++) { msg('typeof result[' + i + '] == ' + typeof result[i] + ', ' + 'result[' + i + '] == ' + result[i]); } // separator is specified to be undefined var result = string.split(undefined); for (var i = 0; i < result.length; i++) { msg('typeof result[' + i + '] == ' + typeof result[i] + ', ' + 'result[' + i + '] == ' + result[i]); }

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

String.prototype.substring(start, end)

Returns a string value (not Object) consisting of the characters in the this string value from index position start up to but not including end. If end is not specified or is undefined, end is treated as the length of the string value. If start > end, they are swapped. If start is greater than or equal to the this string length, the null string is returned.

Mozilla JavaScript1.2, will not swap the arguments start, end if start > end however Mozilla JavaScript1.3 and later will.

var string = "abcdef"; msg('string.substring(1,2) == ' + string.substring(1,2)); msg('string.substring(1) == ' + string.substring(1)); msg('string.substring(2,1) == ' + string.substring(2,1)); msg('string.substring(200) == ' + string.substring(200));

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

String.prototype.substr(start, length)

Not standard but available in Mozilla and MSIE. Returns a string value (not Object) of length length consisting of the characters in the this string value from index position start. If start + length > this.toString().length, or if length is not specified the remainder of the this string is returned. If start is greater than or equal to the this string length, the null string is returned.

var string = "abcdef"; msg('string.substr(1,2) == ' + string.substr(1,2)); msg('string.substr(1) == ' + string.substr(1)); msg('string.substr(2,1) == ' + string.substr(2,1)); msg('string.substr(200) == ' + string.substr(200));

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

String.prototype.toLowerCase()

Returns a string value consisting of the original this string value with all upper case characters converted to lower case.

var s = 'This is a String.'; msg('s.toLowerCase() == ' + s.toLowerCase());

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

String.prototype.toLocaleLowerCase()

Returns a string value consisting of the original this string value with all upper case upper characters converted to lowercase using a locale specific mapping of upper to lower case characters.

var s = 'This is a String.'; msg('s.toLocaleLowerCase() == ' + s.toLocaleLowerCase());

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

String.prototype.toUpperCase()

Returns a string value consisting of the original this string value with all lower case characters converted to upper case.

var s = 'This is a String.'; msg('s.toUpperCase() == ' + s.toUpperCase());

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

String.prototype.toLocaleUpperCase()

Returns a string value consisting of the original this string value with all lower case characters converted to upper case using a locale specific mapping of upper to lower case characters.

var s = 'This is a String.'; msg('s.toLocaleUpperCase() == ' + s.toLocaleUpperCase());

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

String.fromCharCode([char0[, char1[, …]]])

Converts its arguments to 16-bit integers, then returns a string which consists of the characters with those values as their Unicode code point values.

var result = ''; for (var charCode = 32; charCode < 256; charCode++) { result += String.fromCharCode(charCode); } msg('result == ' + result);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

string.length

length is a local property of String instances which returns the number of characters in the string. string.length has property attributes {DontEnum}, {DontDelete} and {ReadOnly}.

// attempt to delete string.length var string = '01234'; msg('Before delete: typeof string.length == ' + typeof string.length); msg('(delete string.length) == ' + (delete string.length)); msg('After delete: typeof string.length == ' + typeof string.length);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

// attempt to assign to string.length var string = '01234'; string.length = 2; msg('After string.length = 2: string.length == ' + string.length);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Boolean Objects

Boolean objects are objects which represent boolean (true and false) values but are not the same as the primitive values true and false. The fact that any instance of Boolean evaluates to true when used in conditional expressions, means that care must be taken when using instances of Boolean in conditional expressions.

Boolean(value)

When called as a constructor (new Boolean(value) creates an instance of a Boolean object with value value. When called as a function, Boolean(value)convertsvalue to a Boolean Object. Boolean has property attribute {DontEnum} which means it does not appear in for-in loops, can be deleted and can be the target of an assignment.

Mozilla adds the {DontDelete} property attribute which means Mozilla will not delete it.

// attempt to delete Boolean msg('Before delete: typeof Boolean == ' + typeof Boolean); msg('(delete Boolean) == ' + (delete Boolean)); msg('After delete: typeof Boolean == ' + typeof Boolean);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

// attempt to assign to Boolean Boolean = 'foo'; msg('After Boolean = \'foo\': Boolean == ' + Boolean);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Boolean.prototype

Boolean.prototype has property attributes {DontEnum}, {DontDelete} and {ReadOnly} which means it will not appear in for-in loops, can not be deleted and can not be changed by assignment although its properties may be modified.

Boolean.protototype.constructor

Returns a references to the Boolean constructor.

Boolean.protototype.toString()

Returns the value of the Boolean object converted to a string.

msg('typeof (new Boolean(true)).toString() == ' + typeof (new Boolean(true)).toString()); msg('(new Boolean(true)).toString() == ' + (new Boolean(true)).toString()); msg('typeof (new Boolean(false)).toString() == ' + typeof (new Boolean(false))); msg('(new Boolean(false)).toString() == ' + (new Boolean(false)).toString());

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Boolean.protototype.valueOf()

Returns the primitive boolean value of the Boolean instance.

msg('typeof (new Boolean(false)).valueOf() == ' + typeof (new Boolean(false)).valueOf()); msg('(new Boolean(true)).valueOf() == ' + (new Boolean(true)).valueOf()); msg('typeof (new Boolean(false)).valueOf() == ' + typeof (new Boolean(false)).valueOf()); msg('(new Boolean(false)).valueOf() == ' + (new Boolean(false)).valueOf());

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Number Objects

Number(value)

When called as a constructor (new Number(value)) creates an instance of a Number object with value value. When called as a function, Number(value)convertsvalue to a Number Object. Number has property attribute {DontEnum} which means it does not appear in for-in loops, can be deleted and can be the target of an assignment.

Mozilla adds the {DontDelete} property attribute which means Mozilla will not delete it.

// attempt to delete Number msg('Before delete: typeof Number == ' + typeof Number); msg('(delete Number) == ' + (delete Number)); msg('After delete: typeof Number == ' + typeof Number);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

// attempt to assign to Number Number = 'foo'; msg('After Number = \'foo\': Number == ' + Number);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Number.prototype

Number.prototype has property attributes {DontEnum}, {DontDelete} and {ReadOnly} which means it will not appear in for-in loops, can not be deleted and can not be changed by assignment although its properties may be modified.

Number.prototype.constructor

Returns a reference to the Number constructor.

Number.prototype.toString(radix)

Returns a string value representing the value of the Number object in base radix. If radix is either 10 or undefined, the result is the number in base 10 notation. Otherwise, if radix is a number from 2 to 36, the resulting string is an implementation dependent representation of the number in base radix.

var theanswer = 42; msg('theanswer.toString() == ' + theanswer.toString()); msg('theanswer.toString(2) == ' + theanswer.toString(2)); msg('theanswer.toString(8) == ' + theanswer.toString(8)); msg('theanswer.toString(16) == ' + theanswer.toString(16)); msg('theanswer.toString(36) == ' + theanswer.toString(36)); // try an invalid radix try { msg('theanswer.toString(100) == ' + theanswer.toString(100)); } catch(e) { msg('Invalid Radix Error: ' + e.name + ': ' + e.message); }

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

When an invalid radix value is used, Mozilla will throw a generic Error object with message illegal radix value while MSIE will throw a TypeError object with message Invalid procedure call or argument.

Number.prototype.toLocaleString()

Returns a locale specific string representation of the number value in base 10.

Number.prototype.valueOf()

Returns the this value for the Number instance converted to a primitive number value.

var number = new Number(42); msg('typeof (new Number(42)).valueOf() == ' + typeof (new Number(42)).valueOf()); msg('(new Number(42)).valueOf() == ' + (new Number(42)).valueOf());

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Number.prototype.toFixed(fractionDigits)

Returns a string value representing the number value with fractionDigits places after the decimal point. If fractionDigits is undefined, then 0 is used.

Mozilla does not throw a RangeError if fractionDigits is greater than 20 or less than 0. MSIE throws a RangeError in both cases. Mozilla's behavior is allowed under ECMAScript 15.7.4.5 Number.prototype.toFixed(fractionDigits).

var number = 123.456; msg('number.toFixed(2) == ' + number.toFixed(2)); // check for RangeError for fractionDigits > 20 try { msg('number.toFixed(21) == ' + number.toFixed(21)); msg('Test failed. Should have thrown a RangeError.'); } catch(e) { msg('Expected Exception thrown. ' + e.name + ': ' + e.message); try { msg('Exception is a RangeError: ' + (e instanceof RangeError)); } catch(e2) { msg('Error using instanceof ' + e2.name + ': ' + e2.message); } } // check for RangeError for fractionDigits < 0 try { msg('number.toFixed(-1) == ' + number.toFixed(-1)); msg('Test failed. Should have thrown a RangeError.'); } catch(e) { msg('Expected Exception thrown. ' + e.name + ': ' + e.message); try { msg('Exception is a RangeError: ' + (e instanceof RangeError)); } catch(e2) { msg('Error using instanceof ' + e2.name + ': ' + e2.message); } }

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Number.prototype.toExponentional(fractionDigits)

Returns a string value representing the number value in exponential form with one digit before the decimal point and with fractionDigits places after the decimal point. If fractionDigits is undefined, then as many digits after the decimal as are required to specify the number uniquely are used.

Mozilla does not throw a RangeError if fractionDigits is greater than 20 but does if it is less than 0. MSIE throws a RangeError in both cases. Mozilla's behavior is allowed under ECMAScript 15.7.4.6 Number.prototype.toFixed(fractionDigits).

var number = 123.456; msg('number.toExponential(2) == ' + number.toExponential(2)); // check for RangeError for fractionDigits > 20 try { msg('number.toExponential(21) == ' + number.toExponential(21)); msg('Test failed. Should have thrown a RangeError.'); } catch(e) { msg('Expected Exception thrown. ' + e.name + ': ' + e.message); try { msg('Exception is a RangeError: ' + (e instanceof RangeError)); } catch(e2) { msg('Error using instanceof ' + e2.name + ': ' + e2.message); } } // check for RangeError for fractionDigits < 0 try { msg('number.toExponential(-1) == ' + number.toExponential(-1)); msg('Test failed. Should have thrown a RangeError.'); } catch(e) { msg('Expected Exception thrown. ' + e.name + ': ' + e.message); try { msg('Exception is a RangeError: ' + (e instanceof RangeError)); } catch(e2) { msg('Error using instanceof ' + e2.name + ': ' + e2.message); } }

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Number.prototype.toPrecision(precision)

Returns a string value representing the number value using precision number of significant digits. If precision is undefined, Number.prototype.toString() is used to return the string value.

Mozilla does not throw a RangeError if fractionDigits is greater than 21 but does if it is than 1. MSIE throws a RangeError in both cases. Mozilla's behavior is allowed under ECMAScript 15.7.4.7 Number.prototype.toPrecision(fractionDigits).

var number = 123.456; msg('number.toPrecision(2) == ' + number.toPrecision(2)); // check for RangeError for fractionDigits > 21 try { msg('number.toPrecision(22) == ' + number.toPrecision(22)); msg('Test failed. Should have thrown a RangeError.'); } catch(e) { msg('Expected Exception thrown. ' + e.name + ': ' + e.message); try { msg('Exception is a RangeError: ' + (e instanceof RangeError)); } catch(e2) { msg('Error using instanceof ' + e2.name + ': ' + e2.message); } } // check for RangeError for fractionDigits < 1 try { msg('number.toPrecision(0) == ' + number.toPrecision(0)); msg('Test failed. Should have thrown a RangeError.'); } catch(e) { msg('Expected Exception thrown. ' + e.name + ': ' + e.message); try { msg('Exception is a RangeError: ' + (e instanceof RangeError)); } catch(e2) { msg('Error using instanceof ' + e2.name + ': ' + e2.message); } }

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Number.MAX_VALUE

Returns the maximum value of a number representable in JavaScript.

msg('Number.MAX_VALUE == ' + Number.MAX_VALUE);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Number.MIN_VALUE

Returns the minimum value of a number representable in JavaScript.

msg('Number.MIN_VALUE == ' + Number.MIN_VALUE);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Number.NaN

Returns the same value as the global property NaN.

Number.NEGATIVE_INFINITY

Returns -Infinity

msg('Number.NEGATIVE_INFINITY == ' + Number.NEGATIVE_INFINITY);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Number.POSITIVE_INFINITY

Returns +Infinity

msg('Number.POSITIVE_INFINITY == ' + Number.POSITIVE_INFINITY);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

The Math Object

The Math object which, unlike the other JavaScript objects, is a static object which can not be used as a constructor or as a function. It is used to contain a number of numeric constants which otherwise would require computation as well as a number of functions which perform common mathematics operations. All of the numeric constants have property attributes {DontEnum}, {DontDelete} and {ReadOnly}.

Math.E

The value for the number e which is the base of the natural logarithms.

msg('Math.E == ' + Math.E); msg('Math.log(Math.E) == 1 ' + (Math.log(Math.E) == 1)) msg('Math.E == Math.exp(1) ' + (Math.E == Math.exp(1)));

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Math.LN10

The value for the natural logarithm of 10.

msg('Math.LN10 == ' + Math.LN10); msg('1/Math.LOG10E == ' + 1/Math.LOG10E); msg('Math.LN10 == 1/Math.LOG10E ' + (Math.LN10 == 1/Math.LOG10E));

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Math.LN2

The value for the natural logarithm of 2.

msg('Math.LN2 == ' + Math.LN2); msg('Math.exp(Math.LN2) == ' + Math.exp(Math.LN2)); msg('Math.exp(Math.LN2) == 2 ' + (Math.exp(Math.LN2) == 2));

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Math.LOG2E

The value for the base 2 logarithm of e.

msg('Math.LOG2E == ' + Math.LOG2E); msg('1/Math.LN2 == ' + 1/Math.LN2); msg('Math.LOG2E == 1/Math.LN2 ' + (Math.LOG2E == 1/Math.LN2));

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Math.LOG10E

The value for the base 10 logarithm of e.

msg('Math.LOG10E == ' + Math.LOG10E); msg('1/Math.LN10 == ' + 1/Math.LN10); msg('Math.LOG10E == 1/Math.LN10 ' + (Math.LOG10E == 1/Math.LN10));

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Math.PI

The value for Π.

msg('Math.PI == ' + Math.PI);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Math.SQRT1_2

The value for the square root of ½.

msg('Math.SQRT1_2 == ' + Math.SQRT1_2); msg('1/Math.SQRT2 == ' + 1/Math.SQRT2); msg('Math.SQRT1_2 == 1/Math.SQRT2 ' + (Math.SQRT1_2 == 1/Math.SQRT2));

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Math.SQRT2

The value for the square root of 2.

msg('Math.SQRT2 == ' + Math.SQRT2); msg('Math.SQRT2 * Math.SQRT2 == ' + (Math.SQRT2 * Math.SQRT2)); msg('Math.SQRT2 * Math.SQRT2 == 2 ' + (Math.SQRT2 * Math.SQRT2 == 2));

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Math.abs(x)

Returns the absolute value of x.

msg('Math.abs(-1) == ' + Math.abs(-1));

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Math.acos(x)

Returns the arc cosine (cos^-1) of x

msg('Math.acos(Math.cos(Math.PI))) == ' + Math.acos(Math.cos(Math.PI)));

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Math.asin(x)

Returns the arc sine (sin^-1) of x

msg('Math.asin(Math.sin(Math.PI))) == ' + Math.asin(Math.sin(Math.PI)));

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Math.atan(x)

Returns the arc tangent (tan^-1) of x

msg('Math.atan(Math.tan(Math.PI/2))) == ' + Math.atan(Math.tan(Math.PI/2)));

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Math.atan2(y,x)

Returns the arc tangent (tan^-1) of the ratio of y/x with the return value in the property quadrant.

msg('Math.atan2(1,-1) == ' + Math.atan2(1,-1));

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Math.ceil(x)

Returns the smallest integer value less than or equal to x.

msg('Math.ceil(NaN) == ' + Math.ceil(NaN)); msg('Math.ceil(+0) == ' + Math.ceil(+0)); msg('Math.ceil(-0) == ' + Math.ceil(-0)); msg('Math.ceil(+Infinity) == ' + Math.ceil(+Infinity)); msg('Math.ceil(-Infinity) == ' + Math.ceil(-Infinity)); msg('Math.ceil(-0.5) == ' + Math.ceil(-0.5)); msg('Math.ceil(1.6) == ' + Math.ceil(1.6)); msg('-Math.floor(-1.6) == ' + (-Math.floor(-1.6)));

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Math.cos(x)

Converts x to a numeric value in radians and returns the cosine of x.

msg('Math.cos(Math.PI) == ' + Math.cos(Math.PI));

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Math.exp(x)

Converts x to a numeric value, then returns the result of raising e to the x^th power (e^x).

Math.floor(x)

Returns the largest integer value less than or equal to the numeric value of x.

msg('Math.floor(NaN) == ' + Math.floor(NaN)); msg('Math.floor(+0) == ' + Math.floor(+0)); msg('Math.floor(-0) == ' + Math.floor(-0)); msg('Math.floor(+Infinity) == ' + Math.floor(+Infinity)); msg('Math.floor(-Infinity) == ' + Math.floor(-Infinity)); msg('Math.floor(-0.5) == ' + Math.floor(-0.5)); msg('Math.floor(1.6) == ' + Math.floor(1.6)); msg('-Math.floor(-1.6) == ' + (-Math. ceil(-1.6)));

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Math.log(x)

Converts x to a numeric value, then returns the natural logarithm of x.

Math.max([value1 [, value2 [, …]]])

Converts each argument value1, value2, … to a numeric value, then returns the maximum value.

Math.min([value1 [, value2 [, …]]])

Converts each argument value1, value2, … to a numeric value, then returns the minimum value.

Math.pow(x,y)

Converts x and y to numeric values, then returns the value raising x to the y^th power (y^x).

Math.random()

Returns a random number between 0 and 1.

Math.round(x)

Converts x to a numeric value and returns the result of rounding x to the nearest integer.

Math.sin(x)

Converts x to a numeric value in radians and returns the sine of x.

Math.sqrt(x)

Converts x to a numeric value and returns the square root of x.

Math.tan(x)

Converts x to a numeric value in radians and returns the tangent of x.

Date Objects

Instances of the Date Object represent time values to within a millisecond for dates 100,000 days before or after January 1, 1970. Time 0 is defined to be January 1, 1970 UTC. This works out to be from April 20, -271821 through September 13, 275760 which should be enough for most purposes.

Date(…)

The Date constructor creates a new instance of a Date Object when called in a new expression but returns a string when used as a function call when it returns the same value a (new Date()).toString(). Date has two forms: Date(value) and Date(year, month, …). Date has property attribute {DontEnum} which means it does not appear in for-in loops, can be deleted and can be the target of an assignment.

Mozilla adds the {DontDelete} property attribute which means Mozilla will not delete it.

// attempt to delete Date msg('Before delete: typeof Date == ' + typeof Date); msg('(delete Date) == ' + (delete Date)); msg('After delete: typeof Date == ' + typeof Date);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

// attempt to assign to Date Date = 'foo'; msg('After Date = \'foo\': Date == ' + Date);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Date(value)

Date(value) creates a new instance of Date by parsingvalue as a date string in IETF format or as the number of milliseconds since January 1, 1970.

Example Date Ranges using Date(milliseconds )var msDay = 86400000; // milliseconds per day var maxRange = 100000000 * msDay; var datemin = new Date(-maxRange); var date0 = new Date(0); var datemax = new Date(maxRange); msg('datemin == ' + datemin.toUTCString()); msg('date0 == ' + date0.toUTCString()); msg('datemax == ' + datemax.toUTCString()); try { // try a longer range var date = new Date(maxRange + 1); msg('date == ' + date.toUTCString()); } catch(e) { msg(e.name + ': ' + e.message); }

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Note that Mozilla will report 'Invalid Date' for dates out of range while MSIE will report 'NaN'.

The IETF date format is defined in RFC 822, Section 5. JavaScript is more lenient in the date strings it will accept in that some of the required values in RFC 822 can be omitted in JavaScript and other values can be written in abbreviated form or in full. In general JavaScript date strings look like:[dayofweek] dayofmonth month year [time [timezone][offset]]

where commas (,) in between the values will be ignored and [optional] indicates optional can be omitted. dayofweek is the name of the day of the week such as Monday or Mon; dayofmonth is a number representing the day of the month ranging from 1 to the number of days in the month, month is the name of the month such as January or Jan; year is a number representing the year; time is of the form hh:mm or hh:mm:ss (where hh, mm and ss are two digit numbers representing the hours, minutes and seconds); and timezone is optionally one of UTC, GMT, EST, EDT, CST, CDT, MST, MDT, PST, PDT; and offset is a positive or negative 4 digit number representing the difference in time between the local time and that given in the timezone. JavaScript will convert some invalid dates with an incorrect dayofmonth value by shifting the date into the next month.

function test(datestring) { msg('new Date("' + datestring + '") == ' + new Date(datestring)); } // create Date using date string var datestring; msg('Valid Dates'); test("Jan 12 2005 11:57 PM EST"); test("January 12 2005"); test("01/12/2005"); test("Wed January 12, 2005"); test("12, Jan, 2005, 11:57, PM, EST"); test("Wed Jan 12 2005 23:57:00 GMT-0500 (Eastern Standard Time)"); msg('Invalid dates'); test("01 2005"); test("01 12 2005"); test("Feb 31, 2005"); test("Jan 12, 2005 13:30 AM");

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Note that both Mozilla and MSIE will flag "01 12 2005" as an invalid date and that both will convert "Feb 31, 2005" to "Mar 3, 2005", but they disagree when a 24 hour time is used with an AM or PM indicator. Mozilla flags a 24 hour time with AM or PM as an invalid date while MSIE ignores the AM/PM indicator. Care must be taken to generate only valid date strings in order for your code to be interoperable between browsers.

Date([year[, month[, date[, hours[, minutes[, seconds[, ms]]]]]]]) (Function Call)

All arguments are optional and are ignored. The result of calling the Date constructor is always the same as (new Date()).toString() regardless of the arguments passed.

Calling Date as a function should always return the current date as a string.msg('Date(1970, 01, 01) == ' + Date(1970, 01, 01));

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Date(year, month[, day[, hours[, minutes[, seconds[, ms]]]]]) (Constructor Call)

Constructs an instance of Date corresponding to the date specified in the arguments. Each argument is first converted to a Number. If the value is greater than the allowed value (e.g. if month is greater than 11, hour is greater than 23, etc.) then the excess is carried into the previous value and the value is treated as modulo the maximum value. For example if month is greater than 11, year is treated as year + floor(month/12) and month as month % 12.

year

If year is in the range 0 to 99, it is treated as year + 99 otherwise is it treated as the full year of the date.

month

The number of the month from 0 (January) to 11 (December).

day

The number of the day in the month from 1 to the number of days in the month

hours

The number of hours from 0 to 23.

minutes

The number of minutes from 0 to 59.

seconds

The number of seconds from 0 to 59.

ms

The number of milliseconds from 0 to 999.

msg(' two digit year'); msg('new Date(0, 0) == ' + new Date(0, 0)); msg('year, month') msg('new Date(2000, 11) == ' + new Date(2000, 11)); msg('year, month with carry'); msg('new Date(2000, 12) == ' + new Date(2000, 12)); msg('year, month, day'); msg('new Date(2000, 11, 7) == ' + (new Date(2000, 11, 7))); msg('year, month, day with carry'); msg('new Date(2000, 11, 32) == ' + (new Date(2000, 11, 32))); msg('year, month, day, hours'); msg('new Date(2000, 11, 7, 23) == ' + (new Date(2000, 11, 7, 23))); msg('year, month, day, hours with carry'); msg('new Date(2000, 11, 7, 24) == ' + (new Date(2000, 11, 7, 24))); msg('year, month, day, hours, seconds'); msg('new Date(2000, 11, 7, 23, 59) == ' + (new Date(2000, 11, 7, 23, 59))); msg('year, month, day, hours, seconds with carry'); msg('new Date(2000, 11, 7, 23, 60) == ' + (new Date(2000, 11, 7, 23, 60))); msg('year, month, day, hours, seconds, ms'); msg('new Date(2000, 11, 7, 23, 59) == ' + (new Date(2000, 11, 7, 23, 59, 999))); msg('year, month, day, hours, seconds, ms with carry'); msg('new Date(2000, 11, 7, 23, 59, 1000) == ' + (new Date(2000, 11, 7, 23, 59, 1000)));

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Date.prototype

Date.prototype has property attributes {DontEnum}, {DontDelete} and {ReadOnly} which means it will not appear in for-in loops, can not be deleted and can not be changed by assignment although its properties may be modified.

Date.prototype.constructor

Returns a reference to the Date constructor.

Date.prototype.toString()

Returns a string representing the date, time value.

Mozilla and MSIE differ in how date/time format string.

Mozilla Thu Jul 04 1776 12:30:00 GMT-0500 (Eastern Standard Time)

MSIE Thu Jul 4 12:30:00 EDT 1776

var date = new Date('7/4/1776 12:30 PM'); msg('date.toString() == ' + date.toString());

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Date.prototype.toDateString()

Returns a string representing only the date. Mozilla and MSIE agreed on Date string format.

var date = new Date('7/4/1776 12:30 PM'); msg('date.toString() == ' + date.toDateString());

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Date.prototype.toTimeString()

Returns a string representing only the time.

Mozilla and MSIE disagree on Time String format.

Mozilla 12:30:00 GMT-0500 (Eastern Standard Time)

MSIE 12:30:00 EDT

var date = new Date('7/4/1776 12:30 PM'); msg('date.toString() == ' + date.toTimeString());

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Date.prototype.toLocaleString()

Returns a string representing a locale specific version of the date and time.

Date.prototype.toLocaleDateString()

Returns a string representing a locale specific version of the date.

Date.prototype.toLocaleTimeString()

Returns a string representing a locale specific version of the time.

Date.prototype.valueOf()

Returns a number representing the internal time value of the date.

Date.prototype.valueOf() - MSIE returns 0 instead of NaN

// call the prototyped valueOf() directly msg('Date.prototype.valueOf() == ' + Date.prototype.valueOf()); // call valueOf on a real date instance var date = new Date(); msg('date == ' + date); msg('date.valueOf() == ' + date.valueOf()); msg('new Date(date.valueOf()) == ' + (new Date(date.valueOf())));

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Date.prototype.getTime()

Return the time value. Identical to Date.prototype.valueOf.

var date = new Date(2000, 12, 7, 11, 30, 45); msg('date.getTime() == ' + date.getTime()); msg('date.valueOf() == ' + date.valueOf());

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Date.prototype.getYear()

Returns a number value representing the number of years after1900.

Deprecated in ECMA 262 1^st. Mozilla JavaScript1.2 and MSIE treat getYear as if it were getFullYear.

var date = new Date('12/22/2004'); msg('date.getYear() == ' + date.getYear());

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Date.prototype.getFullYear()

Returns a number value representing the number of years in the date value when considered in the local time zone.

var date = new Date('12/22/2004'); msg('date.getFullYear() == ' + date.getFullYear());

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Date.prototype.getUTCFullYear()

Returns a number value representing the number of years in the date value when considered in the UTC time zone.

var date = new Date('12/31/2004 11:59 PM'); msg('date.getUTCFullYear() == ' + date.getUTCFullYear());

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Date.prototype.getMonth()

Returns the month number in the local time zone.

var date = new Date(2000, 11, 31, 23, 59); msg('date.getMonth() == ' + date.getMonth());

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Date.prototype.getUTCMonth()

Returns the month number in the UTC time zone.

var date = new Date(2000, 11, 31, 23, 59); msg('date.getUTCMonth() == ' + date.getUTCMonth());

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Date.prototype.getDate()

Returns the day of the month in the local time zone.

var date = new Date(2000, 12, 7, 23, 59); msg('date.getDate() == ' + date.getDate());

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Date.prototype.getUTCDate()

Returns the day of the month in the UTC time zone.

var date = new Date(2000, 12, 7, 23, 59); msg('date.getUTCDate() == ' + date.getUTCDate());

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Date.prototype.getDay()

Returns the day of the week in the local time zone.

var date = new Date(2000, 12, 7, 23, 59); msg('date.getDay() == ' + date.getDay());

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Date.prototype.getUTCDay()

Returns the day of the week in the UTC time zone.

var date = new Date(2000, 12, 7, 23, 59); msg('date.getUTCDay() == ' + date.getUTCDay());

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Date.prototype.getHours()

Returns the hour of the day in the local time zone.

var date = new Date(2000, 12, 7, 23, 59); msg('date.getHours() == ' + date.getHours());

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Date.prototype.getUTCHours()

Returns the hour of the day in the UTC time zone.

var date = new Date(2000, 12, 7, 23, 59); msg('date.getUTCHours() == ' + date.getUTCHours());

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Date.prototype.getMinutes()

Returns the minutes of the hour in the local time zone.

var date = new Date(2000, 12, 7, 23, 59); msg('date.getMinutes() == ' + date.getMinutes());

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Date.prototype.getUTCMinutes()

Returns the minutes of the hour in the UTC time zone.

var date = new Date(2000, 12, 7, 23, 59); msg('date.getUTCMinutes() == ' + date.getUTCMinutes());

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Date.prototype.getSeconds()

Returns the seconds of the minute in the local time zone.

var date = new Date(2000, 12, 7, 23, 59, 59); msg('date.getSeconds() == ' + date.getSeconds());

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Date.prototype.getUTCSeconds()

Returns the seconds of the minute in the UTC time zone.

var date = new Date(2000, 12, 7, 23, 59, 59); msg('date.getUTCSeconds() == ' + date.getUTCSeconds());

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Date.prototype.getMilliseconds()

Returns the milliseconds of the second in the local time zone.

var date = new Date(2000, 12, 7, 23, 59, 59, 999); msg('date.getMilliseconds() == ' + date.getMilliseconds());

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Date.prototype.getUTCMilliseconds()

Returns the milliseconds of the second in the UTC time zone.

var date = new Date(2000, 12, 7, 23, 59, 59, 999); msg('date.getUTCMilliseconds() == ' + date.getUTCMilliseconds());

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Date.prototype.getTimezoneOffset()

Return the difference between the local time zone and the UTC time zone in minutes.

var date = new Date(); msg('date.getTimezoneOffset() == ' + date.getTimezoneOffset());

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Date.prototype.setTime(time)

Sets the date value to the number of milliseconds in time.

var date0 = new Date(0); var datenow = new Date(); msg('date0 == ' + date0); msg('datenow == ' + datenow); date0.setTime(datenow.getTime()); msg('date0 == ' + date0);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Date.prototype.setYear(year)

Sets the year value of the date to year. If year is 0 to 99, it is treated as if year + 1900 were specified.

Deprecated. Use setFullYear instead.

var date = new Date('12/22/2004'); msg('date.toDateString() == ' + date); msg('date.setYear(2003) == ' + date.setYear(2003) + ', ' + date); msg('date.setYear(20) == ' + date.setYear(20) + ', ' + date);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Date.prototype.setFullYear(year[, month[, day]])

Set the year value to corresponding to local time zone values of year, month and day with no conversion if year is 0 to 99. If month is not specified, the value of date.getMonth() is used instead. If day is not specified, date.getDate() is used instead.

var date = new Date('12/22/2004 23:59:59'); msg('date.toDateString() == ' + date); msg('date.getMonth() == ' + date.getMonth()); msg('date.getDate() == ' + date.getDate()); msg('date.setFullYear(2003) == ' + date.setFullYear(2003) + ', ' + date); msg('date.setFullYear(2002, 1) == ' + date.setFullYear(2002, 1) + ', ' + date); msg('date.setFullYear(2001, 1, 1) == ' + date.setFullYear(2001, 1, 1) + ', ' + date);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Date.prototype.setUTCFullYear(year[, month[, date]])

Set the year value to corresponding to local time zone values of year, month and day with no conversion if year is 0 to 99. If month is not specified, the value of date.getUTCMonth() is used instead. If day is not specified, date.getUTCDate() is used instead.

var date = new Date('12/31/2004 23:59:59'); msg('date.toDateString() == ' + date); msg('date.getUTCMonth() == ' + date.getUTCMonth()); msg('date.getUTCDate() == ' + date.getUTCDate()); msg('date.setUTCFullYear(2003) == ' + date.setUTCFullYear(2003) + ', ' + date); msg('date.setUTCFullYear(2002, 1) == ' + date.setUTCFullYear(2002, 1) + ', ' + date); msg('date.setUTCFullYear(2001, 1, 1) == ' + date.setUTCFullYear(2001, 1, 1) + ', ' + date);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Date.prototype.setMonth(month[, day])

Sets the month and day values of the date using the local time zone.

Date.prototype.setUTCMonth(month[, day])

Sets the month and day values of the date using the UTC time zone.

Date.prototype.setDate(day)

Sets the day value of the date using the local time zone.

Date.prototype.setUTCDate(date)

Sets the day value of the date using the UTC time zone.

Date.prototype.setHours(hour[, min[, sec[, ms]]])

Sets the hour and optionally minute, second and millisecond of the date using the local time zone.

Date.prototype.setUTCHours(hour[, min[, sec[, ms]]])

Set the hour and optionally minute, second and millisecond of the date using the UTC time zone.

Date.prototype.setMinutes(min[, sec[, ms]])

Sets the minutes and optionally the seconds and milliseconds of the date using the local time zone.

Date.prototype.setUTCMinutes(min[, sec[, ms]])

Sets the minutes and optionally the seconds and milliseconds of the date using the UTC time zone.

Date.prototype.setSeconds(sec[, ms])

Sets the seconds and optionally milliseconds of the date using the local time zone.

Date.prototype.setUTCSeconds(sec[, ms])

Sets the seconds and optionally milliseconds of the date using the UTC time zone.

Date.prototype.setMilliseconds(ms)

Sets the milliseconds of the date using the local time zone.

Date.prototype.setUTCMilliseconds(ms)

Sets the milliseconds of the date using the UTC time zone.

Date.prototype.toGMTString()

Deprecated. Mozilla and MSIE disagree on Date string format and the effects of old dates on daylight savings time.

Date	Mozilla toUTCString	MSIE toUTCString	Note
7/4/1776 12:30 PM	Thu, 04 Jul 1776 17:30:00 GMT	Thu, 4 Jul 1776 16:30:00 UTC	Mozilla uses GMT while MSIE uses UTC. MSIE problem with Daylight Savings Time in old dates
7/4/2004 12:30 PM	Sun, 04 Jul 2004 16:30:00 GMT	Sun, 4 Jul 2004 16:30:00 UTC	GMT vs UTC but otherwise the same.
12/25/2004 12:30 PM	Sat, 25 Dec 2004 17:30:00 GMT	Sat, 25 Dec 2004 17:30:00 UTC	ditto

var date = new Date('7/4/1776 12:30 PM'); msg('date.toGMTString() == ' + date.toGMTString()); date = new Date('7/4/2004 12:30 PM'); msg('date.toGMTString() == ' + date.toGMTString()); date = new Date('12/25/2004 12:30 PM'); msg('date.toGMTString() == ' + date.toGMTString());

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Date.prototype.toUTCString()

Mozilla and MSIE disagree on Date string format and the effects of old dates on daylight savings time.

Date	Mozilla toUTCString	MSIE toUTCString	Note
7/4/1776 12:30 PM	Thu, 04 Jul 1776 17:30:00 GMT	Thu, 4 Jul 1776 16:30:00 UTC	Mozilla uses GMT while MSIE uses UTC. MSIE problem with Daylight Savings Time in old dates
7/4/2004 12:30 PM	Sun, 04 Jul 2004 16:30:00 GMT	Sun, 4 Jul 2004 16:30:00 UTC	GMT vs UTC but otherwise the same.
12/25/2004 12:30 PM	Sat, 25 Dec 2004 17:30:00 GMT	Sat, 25 Dec 2004 17:30:00 UTC	ditto

var date = new Date('7/4/1776 12:30 PM'); msg('date.toUTCString() == ' + date.toUTCString()); date = new Date('7/4/2004 12:30 PM'); msg('date.toUTCString() == ' + date.toUTCString()); date = new Date('12/25/2004 12:30 PM'); msg('date.toUTCString() == ' + date.toUTCString());

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Date.parse(string)

Parses string and returns the corresponding time value in milliseconds. See Date(value) for more details on the format of the date string.

Mozilla will accept invalid dates with the incorrect number of days in a month or months in a year however will return NaN in cases where the time value is inconsistent, for example when the time implies PM but the string contains AM. MSIE will accept invalid dates with the incorrect number of days in a month or months in a year or the time value is inconsistent with the AM/PM values.var s = '7/4/1776 12:30 PM'; var date = Date.parse(s); msg('Date.parse(s) == ' + date + ', ' + (isNaN(date)?'-':new Date(date))); s = '1/1/1999 13:30 AM'; date = Date.parse(s); msg('Date.parse(s) == ' + date + ', ' + (isNaN(date)?'-':new Date(date))); s = '2/29/2001'; date = Date.parse(s); msg('Date.parse(s) == ' + date + ', ' + (isNaN(date)?'-':new Date(date))); s = '13/29/2001'; date = Date.parse(s); msg('Date.parse(s) == ' + date + ', ' + (isNaN(date)?'-':new Date(date)));

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Date.prototype.UTC(year, month[, day[, hours[, minutes[, seconds[, ms]]]]])

Returns a time value in milliseconds corresponding to the arguments. Unlike Date() called as a function, the return value is not an instance of Date and the arguments use the UTC time zone.

RegExp Objects

Regular Expressions are a means of describing and processing patterns in text using a special pattern language called a regular expression language. In JavaScript, regular expressions are used to describe patterns in string values. If you have ever performed a directory listing using wild cards (dir *.txt) you have used a kind of regular expression. The actual language used to express the patterns depends upon the program. In JavaScript, regular expressions are patterned after those found in the Perl programming language. Regular Expressions can be created either using the RegExp constructor or by using regular expression literal expressions. A regular expression literal has the form /pattern/flags where pattern is some sequence of characters and flags are a possibly empty combination of g, i or m. Without the flags, the regular expression will only find the first matching occurence in a string, will be case-sensitive and will not consider newline characters as special. If the global flag (g) is used, then the regular expression will find all matching occurences in the string. If the case-insensitive flag (i) is used, the regular expression will ignore case when performing matches. If the multiline flag (m) is used, the pattern ^ will match the beginning of any embedded line and $ will match the end of any embedded line. Some examples of regular expression patterns are:

/foo/

search for the first occurence of foo.

/foo/g

search for all occurences of foo.

/foo/i

search for the first occurence of foo ignoring the case of the letters.

/foo$/m

search for the first occurence of foo which is followed by a newline character or the end of the string.

Regular Expression Patterns

\

The backslash character \ is used to escape characters by either removing any special meaning they might otherwise have or to change their meaning. For example, the letter v can be used to represent the vertical tab character by escaping it as \v. Other characters which have special meanings in a regular expression, such as $ which represents the end of a string, can be escaped \$ so that they lose their special meaning and simply represent themselves; in this case the dollar sign. If you wish to match the literal \ character, you must escape it as \\.

Regular Expression Boundary Patterns

Boundary patterns are special patterns which do not match any actual text in a string, but instead match a location. Note that boundary matches have zero size.

^

^ is used to match the boundary at the beginning of the string which is being searched. If the multiline flag is set, ^ also matches the boundary after the newline \n character in a string. If you wish to match the literal character ^ in a string, you must code it as \^ in the pattern.

var string = 'this is one line\nThis is another Line'; /* Without the multiline flag, ^ will only match the beginning of the input */ msg('/^this/.test(string) == ' + /^this/.test(string)); msg('/^This/.test(string) == ' + /^This/.test(string)); /* With the multiline flag, ^ will match the beginning of any line */ msg('/^this/m.test(string) == ' + /^this/m.test(string)); msg('/^This/m.test(string) == ' + /^This/m.test(string));

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

$

$ is used to match the boundary at the end of the string which is being searched. If the multiline flag is set, $ also matches the boundary before the newline character \n in a string. If you wish to match the literal character $ in a string, you must code it as \$ in the pattern.

var string = 'this is one line\nThis is another Line'; /* Without the multiline flag, $ will only match the end of the input */ msg('/line$/.test(string) == ' + /line$/.test(string)); msg('/Line$/.test(string) == ' + /Line$/.test(string)); /* With the multiline flag, $ will match the end of any line */ msg('/line$/m.test(string) == ' + /line$/m.test(string)); msg('/Line$/m.test(string) == ' + /Line$/m.test(string));

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

\b

\b matches the boundary between words where a word is defined as an identifier. Note that boundaries have zero size. \b can be confusing since in regular expression patterns it represents a word boundary however in string values it represents the backspace character.

var string = 'abc.def + 123'; var regexp = /\b/g; // match any boundary between words msg('regexp.test(string) == ' + regexp.test(string)); msg('regexp.lastIndex == ' + regexp.lastIndex + ', ' + 'RegExp.leftContext == ' + RegExp.leftContext + ', ' + 'RegExp.rightContext == ' + RegExp.rightContext); msg('regexp.test(string) == ' + regexp.test(string)); msg('regexp.lastIndex == ' + regexp.lastIndex + ', ' + 'RegExp.leftContext == ' + RegExp.leftContext + ', ' + 'RegExp.rightContext == ' + RegExp.rightContext);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Note that Mozilla returns the location of the match in the regexp.lastIndex for zero-width matches using \b but that MSIE will return the location following the match.

\B

\B matches a non-word boundary, that is an artificial boundary inside of a word.

var string = 'abc_def_123'; var regexp = /\B/g; // match a non-word boundary msg('regexp.test(string) == ' + regexp.test(string)); msg('regexp.lastIndex == ' + regexp.lastIndex + ', ' + 'RegExp.leftContext == ' + RegExp.leftContext + ', ' + 'RegExp.rightContext == ' + RegExp.rightContext); msg('regexp.test(string) == ' + regexp.test(string)); msg('regexp.lastIndex == ' + regexp.lastIndex + ', ' + 'RegExp.leftContext == ' + RegExp.leftContext + ', ' + 'RegExp.rightContext == ' + RegExp.rightContext);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Note that Mozilla returns the location of the match in the regexp.lastIndex for zero-width matches using \B but that MSIE will return the location following the match.

Regular Expression Character Patterns

Character patterns are used to match specific characters as well as classes of characters. The characters \^$*+?.()|{}[] have special meanings in regular expression patterns. If you wish to match a literal occurence of a special character you must escape it using \. Other characters can be written in a pattern normally.

.

. matches any character except the newline character.

[class]

[class] describes a character class. class is composed of one or more pairs of characters separated by the - and represent the set of characters bounded by the pair. For example, [a-z] represents the set of characters abcdefhijklmnopqrstuvwxyz. The ^ character has a different meaning inside of a character class. When ^ occurs immediately following the opening [ of a character class, it means that the class consists of all characters which do not match the class. For example, [^a-z] represents the set of characters which are not lower case latin letters. If ^ is not the first character in a character class, it acts simply as the character ^.

var string = "abc^def"; var regexp; regexp = /[a-z]+/; msg('regexp.exec(string) == ' + regexp.exec(string)); regexp = /[^a-z]+/; msg('regexp.exec(string) == ' + regexp.exec(string)); regexp = /[^^]+/; msg('regexp.exec(string) == ' + regexp.exec(string));

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

[\b]

[\b] matches the backspace character. Since \b is defined to match the boundary between words, it can not be used to match the back space character \b in strings. Instead, a hack is used by writing the backspace character as a character class using [].

var string = 'this has a backspace character: \b'; var regexp = /[\b]/; msg('regexp.test(string) == ' + regexp.test(string));

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

\cC

\cC matches the control character controlC.

var string = '\x01\x02\x03\x04\x05'; var regexp = /\cA/g; msg('regexp.test(string) == ' + regexp.test(string)); msg('regexp.lastIndex == ' + regexp.lastIndex + ', ' + 'RegExp.leftContext == ' + RegExp.leftContext + ', ' + 'RegExp.rightContext == ' + RegExp.rightContext);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Mozilla fails to match a control character while MSIE succeeds.

\d

Matches a digit 0, 1, 2, 3, 4, 5, 6, 7, 8 or 9

var string = 'abc123def'; var regexp = /\d/g; msg('regexp.test(string) == ' + regexp.test(string)); msg('regexp.lastIndex == ' + regexp.lastIndex + ', ' + 'RegExp.leftContext == ' + RegExp.leftContext + ', ' + 'RegExp.rightContext == ' + RegExp.rightContext);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

\D

Matches a non-digit.

var string = 'abc123def'; var regexp = /\D/g; msg('regexp.test(string) == ' + regexp.test(string)); msg('regexp.lastIndex == ' + regexp.lastIndex + ', ' + 'RegExp.leftContext == ' + RegExp.leftContext + ', ' + 'RegExp.rightContext == ' + RegExp.rightContext);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

\f

Matches a form feed character.

var string = 'abc\fdef'; var regexp = /\f/g; msg('regexp.test(string) == ' + regexp.test(string)); msg('regexp.lastIndex == ' + regexp.lastIndex + ', ' + 'RegExp.leftContext == ' + RegExp.leftContext + ', ' + 'RegExp.rightContext == ' + RegExp.rightContext);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

\n

Matches a newline character.

var string = 'abc\ndef'; var regexp = /\n/g; msg('regexp.test(string) == ' + regexp.test(string)); msg('regexp.lastIndex == ' + regexp.lastIndex + ', ' + 'RegExp.leftContext == ' + RegExp.leftContext + ', ' + 'RegExp.rightContext == ' + RegExp.rightContext);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

\r

Matches a carriage return character.

var string = 'abc\rdef'; var regexp = /\r/g; msg('regexp.test(string) == ' + regexp.test(string)); msg('regexp.lastIndex == ' + regexp.lastIndex + ', ' + 'RegExp.leftContext == ' + RegExp.leftContext + ', ' + 'RegExp.rightContext == ' + RegExp.rightContext);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

\s

Matches a whitespace character. In JavaScript, whitespace characters are the space, tab, form feed, vertical form feed, newline, carriage return, and \u00A0, \u2028 and \u2029.

var whitespacechars = [' ', '\t', '\f', String.fromCharCode(11), '\n', '\r', '\u00A0', '\u2028', '\u2029']; var whitespacenames = [' ', '\\t', '\\f', '\\v', '\\n', '\\r', '\\u00A0', '\\u2028', '\\u2029']; var regexp = /\s/; for (var i = 0; i < whitespacechars.length; i++) { var string = whitespacechars[i]; var name = whitespacenames[i]; msg('/\\s/.test("' + name + '") == ' + regexp.test(string)); msg('regexp.lastIndex == ' + regexp.lastIndex + ', ' + 'RegExp.leftContext == ' + RegExp.leftContext + ', ' + 'RegExp.rightContext == ' + RegExp.rightContext); }

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Note MSIE does not recognize \v as the vertical form feed character in strings however does recognize it in regular expression patterns. MSIE does not recognize no break space \u00A0, or the unicode line separator \u2028 or the unicode paragraph separator \u2029 as whitespace characters.

\S

Matches any non-whitespace character.

MSIE will incorrectly match no break space \u00A0, or the unicode line separator \u2028 or the unicode paragraph separator \u2029 as non-whitespace characters.

\t

Matches a tab.

\v

Matches the vertical tab character.

MSIE does support \v in regular expression patterns but does not support \v in string literals. You must code \v in strings as String.fromCharCode(11) in MSIE.

\w

Matches any word character consisting of a letter, number, underscore or digit.

\W

Matches any non-word character.

\0

Matches the NUL character.

\xHH

Matches the character whose hexadecimal character code is 0xHH. where H is a hexadecimal digit.

\uHHHH

Matches the character whose unicode character code is \uHHHH. where H is a hexadecimal digit.

Regular Expression Quantifying Patterns

X*

Matches zero or more occurences of the regular expression X. * is the same as {0,}. * by itself is greedy which means it will match as many characters in the input as possible. If modified via the ?, it becomes non-greedy meaning it will match as few characters as possible.

var regexp; var string = 'aabbbcccdddd'; // match zero or more a characters greedily // which will match the leading aa regexp = /a*/; msg('regexp.test(string) == ' + regexp.test(string)); msg('RegExp.lastMatch == ' + RegExp.lastMatch); // match zero or more a characters non-greedily // which will match the empty string before the leading aa regexp = /a*?/; msg('regexp.test(string) == ' + regexp.test(string)); msg('RegExp.lastMatch == ' + RegExp.lastMatch);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

X+

Matches one or more occurences of the regular expression X. + is the same as {1,}. + by itself is greedy which means it will match as many characters in the input as possible. If modified via the ?, it becomes non-greedy meaning it will match as few characters as possible.

var regexp; var string = 'aabbbcccdddd'; // match one or more a characters greedily // which will match the leading aa regexp = /a+/; msg('regexp.test(string) == ' + regexp.test(string)); msg('RegExp.lastMatch == ' + RegExp.lastMatch); // match one or more a characters non-greedily // which will match the leading a regexp = /a+?/; msg('regexp.test(string) == ' + regexp.test(string)); msg('RegExp.lastMatch == ' + RegExp.lastMatch);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

X?

Matches zero or one occurences of the regular expression X. ? is the same as {0,1}. ? modifies a greedy quantifier into a non-greedy one. characters as possible.

var regexp; var string = 'aabbbcccdddd'; // match zero or one a characters greedily // which will match the leading a regexp = /a?/; msg('regexp.test(string) == ' + regexp.test(string)); msg('RegExp.lastMatch == ' + RegExp.lastMatch); // match zero or one a characters non-greedily // which will match the leading empty string regexp = /a??/; msg('regexp.test(string) == ' + regexp.test(string)); msg('RegExp.lastMatch == ' + RegExp.lastMatch);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

{N}

Matches exactly N occurences of the previous item.

var regexp; var string = 'aabbbcccdddd'; // match exactly 2 characters // which will match the aa regexp = /a{2,}/; msg('regexp.test(string) == ' + regexp.test(string)); msg('RegExp.lastMatch == ' + RegExp.lastMatch); // match exactly two characters non-greedily // which will match the same as the greedy expression regexp = /a{2,}?/; msg('regexp.test(string) == ' + regexp.test(string)); msg('RegExp.lastMatch == ' + RegExp.lastMatch);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

{N,}

Matches at least N occurences of the previous items. {N,} by itself is greedy which means it will match as many characters in the input as possible. If modified via the ?, it becomes non-greedy meaning it will match as few characters as possible.

var regexp; var string = 'aabbbcccdddd'; // match one or more a characters greedily // which will match the leading a regexp = /a{1,}/; msg('regexp.test(string) == ' + regexp.test(string)); msg('RegExp.lastMatch == ' + RegExp.lastMatch); // match one or more a characters non-greedily // which will match the leading a regexp = /a{1,}?/; msg('regexp.test(string) == ' + regexp.test(string)); msg('RegExp.lastMatch == ' + RegExp.lastMatch);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

{N, M}

Matches from N to M occurences of the previous item. {N,M} by itself is greedy which means it will match as many characters in the input as possible. If modified via the ?, it becomes non-greedy meaning it will match as few characters as possible.

var regexp; var string = 'aabbbcccdddd'; // match 2 to 3 b characters greedily // which will match the leading all three b characters regexp = /b{2,3}/; msg('regexp.test(string) == ' + regexp.test(string)); msg('RegExp.lastMatch == ' + RegExp.lastMatch); // match 2 to 3 b characters non-greedily // which will match the first two b characters regexp = /b{2,3}?/; msg('regexp.test(string) == ' + regexp.test(string)); msg('RegExp.lastMatch == ' + RegExp.lastMatch);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Regular Expression Logical Patterns

XY

XYmatches regular expression X followed by the match for regular expression Y.

var regexp = /XY/; msg('regexp.exec("XY") == ' + regexp.exec("XY")); msg('regexp.exec("XZ") == ' + regexp.exec("XZ")); msg('regexp.exec("ZY") == ' + regexp.exec("ZY"));

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

X|Y

X|Y matches regular expression X or regular expression Y.

var regexp = /X|Y/; msg('regexp.exec("XY") == ' + regexp.exec("XY")); msg('regexp.exec("XZ") == ' + regexp.exec("XZ")); msg('regexp.exec("ZY") == ' + regexp.exec("ZY"));

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

X(?= Y)

X(?=Y) matches regular expression X if it is followed by a match for regular expression Y. This is called a lookahead pattern.

var regexp = /X(?=Y)/; msg('regexp.exec("XY") == ' + regexp.exec("XY")); msg('regexp.exec("XZ") == ' + regexp.exec("XZ"));

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

X(?! Y)

X(?!Y) matches regular expression X if it is not followed by a match for regular expression Y. This is called a negative lookahead pattern.

var regexp = /X(?!Y)/; msg('regexp.exec("XY") == ' + regexp.exec("XY")); msg('regexp.exec("XZ") == ' + regexp.exec("XZ"));

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Regular Expression Grouping Patterns

(X)

(X) matches the same pattern as the regular expression X alone but introduces the concept of capturing parentheses. Matching pairs of parentheses () are used in regular expressions to group parts of a regular expression into a single unit which can treated as a single pattern. Parentheses capture the matches into a captures array which can be used to retrieve sub matches. If no matches are found, the captures array is null. See Capture Arrays.

(?:X)

(?:X) matches the same pattern as regular expression X but does not create an entry in the captures array. These non-capturing parentheses are useful when it is necessary to group items together in the regular expression but you do not wish to record the submatch in the capturing array.

// modify Array.prototype.toString to // wrap strings in quotes and to show undefined values Array.prototype.toString = function() { var s = ''; for (var i = 0; i < this.length; i++) { if (s) { s += ','; } switch (typeof this[i]) { case 'string': s += "'" + this[i] + "'"; break; case 'undefined': s += 'undefined'; break; default: s += this[i]; break; } } return s; } var regexp = /((?:a)|(?:ab))((?:c)|(?:bc))/; msg('regexp.exec("abc") == ' + regexp.exec("abc"));

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

\N

When N is a positive integer, \N is a back reference to the N^th matching capturing parentheses match. Back references are particularly useful for matching pairs of strings such as the start and end tags of markup.

var string = '<tag>content</tag>' var regexp = /<(\w+)>(.*)<\/\1>/; msg('regexp.test(string) == ' + regexp.test(string)); msg('tag name == ' + RegExp.$1 + ', contents == ' + RegExp.$2);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

RegExp(pattern[, flags])

If the RegExp(pattern) constructor is called (without the flags argument), and pattern is an instance of RegExp, then it returns the instance unchanged. Otherwise, the function call creates a new instance of RegExp and returns the result. When creating an instance of a RegExp using the new operatorregexp = new RegExp(pattern, flags)

• If pattern is a RegExp and flags is defined, then a TypeError will be thrown.
• If pattern is undefined, pattern is treated as the empty string otherwise pattern is converted to a string.
• If flags is undefined, flags is treated as the empty string otherwise flags is converted to a string.

If pattern is not a string representing a regular expression, or if flags contains characters other than g m i or if flags has repeated characters, a SyntaxError is thrown. regexp.global is set to true if flags contains g otherwise false. regexp.ignoreCase is set to true if flags contains i otherwise false. regexp.global is set to true if flags contains g otherwise false. RegExp has property attribute {DontEnum} which means it does not appear in for-in loops, can be deleted and can be the target of an assignment.

Mozilla adds the {DontDelete} property attribute which means Mozilla will not delete it.

// attempt to delete RegExp msg('Before delete: typeof RegExp == ' + typeof RegExp); msg('(delete RegExp) == ' + (delete RegExp)); msg('After delete: typeof RegExp == ' + typeof RegExp);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

// attempt to assign to RegExp RegExp = 'foo'; msg('After RegExp = \'foo\': RegExp == ' + RegExp);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

RegExp.prototype

RegExp.prototype has property attributes {DontEnum}, {DontDelete} and {ReadOnly} which means it will not appear in for-in loops, can not be deleted and can not be changed by assignment although its properties may be modified.

RegExp.prototype.constructor

Returns a reference to the RegExp constructor.

RegExp.prototype.exec(string)

Performs a regular expression match on the string argument returning a capturing array containing the results of the match or null if there was no match.

var regexp; var string = 'abc'; var result; msg('exec returns null when no match is found'); regexp = /nomatch/; result = regexp.exec(string); msg('result == ' + result); msg('exec returns a captures array when matches are found'); regexp = /abc/; result = regexp.exec(string); msg('result == ' + result); msg('result instanceof Array: ' + (result instanceof Array)); msg('result.length == ' + result.length); msg('exec returns submatches in the captures array ' + 'when capturing parentheses appear in the ' + 'regular expression'); regexp = /(a)/; result = regexp.exec(string); msg('result == ' + result); msg('result instanceof Array: ' + (result instanceof Array)); msg('result.length == ' + result.length);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Capture ArraysConsider the following regular expression:/((a)|(ab))((c)|(bc))/

The matches are placed into the captures array according to the position of the left parenthesis containing the sub patterns. To illustrate this example, let captures represent the captures array returned from a call to RegExp.prototype.exec() and number the capturing left parentheses in the regular expression from the left starting at 1 as follows:/(1 (2 a)|(3 ab)) (4 (5 c)|(6 bc))/

1. The captures[0] item will contain the substring which matched the entire pattern.
2. The captures[1] item will contain the characters matching the capturing parenthesis labelled 1. It will contain the leading characters matching either a or ab or undefined if there was no match.
3. The captures[2] item will contain the characters matching the capturing parenthesis labelled 2. It will contain the leading characters matching a or undefined if there was no match.
4. The captures[3] item will contain the characters matching the capturing parenthesis labelled 3. It will contain the leading characters matching ab or undefined if there was no match.
5. The captures[4] item will contain the characters matching the capturing parenthesis labelled 4. It will contain the characters matching either c or bc which follow the characters which matched parenthesis 1 or undefined if there is no match.
6. The captures[5] item will contain the characters matching the capturing parenthesis labelled 5. It will contain the c which follows the characters which matched parenthesis 1 or undefined if there is no match.
7. The captures[6] item will contain the characters matching the capturing parenthesis labelled 6. It will contain the characters matching bc which follows the characters which matched parenthesis 1 or undefined if there is no match.

// modify Array.prototype.toString to // wrap strings in quotes and to show undefined values Array.prototype.toString = function() { var s = ''; for (var i = 0; i < this.length; i++) { if (s) { s += ','; } switch (typeof this[i]) { case 'string': s += "'" + this[i] + "'"; break; case 'undefined': s += 'undefined'; break; default: s += this[i]; break; } } return '[' + s + ']'; } var regexp = /((a)|(ab))((c)|(bc))/; msg('regexp.exec("abc") == ' + regexp.exec("abc"));

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Mozilla: ['abc','a','a',undefined,'bc',undefined,'bc']

MSIE: ['abc','a','a','', 'bc','', 'bc']

Note that Mozilla correctly returns undefined for capturing parentheses which were not matched, however MSIE incorrectly returns the empty string '' instead.

MSIE only MSIE adds a property lastIndex to the captures array. captures.lastIndex returns the next position in the string following the match.

var regexp = /a/; var string = 'dcba'; var result = regexp.exec(string); msg('result.lastIndex == ' + result.lastIndex);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

The ECMAScript Standard provides a number of illustrative examples which can help in understanding how regular expressions work and how capture arrays are populated./* * examples from the ecma 262 3rd edition */ // modify Array.prototype.toString to // wrap strings in quotes and to show undefined values Array.prototype.toString = function() { var s = ''; for (var i = 0; i < this.length; i++) { if (s) { s += ','; } switch (typeof this[i]) { case 'string': s += "'" + this[i] + "'"; break; case 'undefined': s += 'undefined'; break; default: s += this[i]; break; } } return '[' + s + ']'; } function test(regexp, string, expected) { var result = regexp.exec(string); msg( 'Test ' + ((result.toString() == expected) ? 'Passed' : 'Failed') + ' : ' + regexp + '.exec("' + string + '")' ); msg('e == ' + expected); msg('r == ' + result); msg('<br>'); } msg('ECMA 262 3rd Section 15.10.2.3 Disjunction<br>'); test(/a|ab/, 'abc', ['a']); // MSIE returns empty strings instead of undefined test(/((a)|(ab))((c)|(bc))/, 'abc', ['abc', 'a', 'a', undefined, 'bc', undefined, 'bc']); msg('ECMA 262 3rd Section 15.10.2.5 Term<br>'); test(/a[a-z]{2,4}/, 'abcdefghi', ['abcde']); test(/a[a-z]{2,4}?/, 'abcdefghi', ['abc']); test(/(aa|aabaac|ba|b|c)*/, 'aabaac', ['aaba', 'ba']); // MSIE fails Step 4 of Repeat Matcher // to clear the Atom's captures each time Atom is repeated. test(/(z)((a+)?(b+)?(c))*/, 'zaacbbbcac', ['zaacbbbcac', 'z', 'ac', 'a', undefined, 'c']); // MSIE returns empty strings instead of undefined test(/(a*)*/, 'b', ['', undefined]); test(/(a*)b\1+/, 'baaaac', ['b', '']); msg('ECMA 262 3rd Section 15.10.2.8 Atom<br>'); test(/(?=(a+))/, 'baaabac', ['', 'aaa']); test(/(?=(a+))a*b\1/, 'baaabac', ['aba', 'a']); test(/(.*?)a(?!(a+)b\2c)\2(.*)/, 'baaabaac', ['baaabaac', 'ba', undefined, 'abaac']);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

MSIE differences MSIE fails to record undefined in the capturing array and instead uses the empty string ''. MSIE fails (z)((a+)?(b+)?(c))*/.exec("zaacbbbcac") since it appears to not follow the ECMA 262 standard and does not clear the captures array of an atom each time it is repeated.

RegExp.prototype.test(string)

Performs a regular expression match on the string argument returning true if a match was found or false if none found.

msg('/foo/.test("This is foo bar!") == ' + /foo/.test("This is foo bar!"));

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

RegExp.prototype.toString()

Returns a string representing the source of the regular expression.

var regexp; // test empty regular expression regexp = new RegExp(); msg('regexp.toString() == ' + regexp.toString()); // test a regular expression with flags regexp = new RegExp('foo', 'mig'); msg('regexp.toString() == ' + regexp.toString());

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

regexp.toString() and empty regular expressions Mozilla correctly returns /(?:)/ for an empty regular expression. MSIE incorrectly returns // for an empty regular expression which is problem since // begins a JavaScript line comment.

regexp.toString() and flags Note that for regular expresison /foo/mig, Mozilla returns /foo/gim with the flags in gim order while MSIE returns /foo/igm with the flags in igm order.

RegExp.index

MSIE only read only property that returns index in string of last match.

msg('typeof RegExp.index == ' + typeof RegExp.index); msg('RegExp.index == ' + RegExp.index); msg('"foobar".match(/bar/) == ' + "foobar".match(/bar/)); msg('RegExp.index == ' + RegExp.index);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

RegExp.input, RegExp.$_

Non-Standard, but supported by Mozilla and MSIE RegExp.input is a non-standard property of the RegExp constructor. $_ is a synonym for input. Mozilla and MSIE both will set the value of RegExp.input to the string value last searched by a regular expression. Mozilla also allows RegExp.input to be be set, so that any call to the exec() or test() methods of a regular expression instance will use the input value as the string to be searched if there is no argument specified. MSIE does not support this extension.

msg('check the initial type and value of RegExp.input'); msg('typeof RegExp.input == ' + typeof RegExp.input); msg('RegExp.input == ' + RegExp.input); msg('RegExp.$_ == ' + RegExp.$_); msg('perform a search on a string and check RegExp.input'); msg('"foobar".match(/bar/) == ' + "foobar".match(/bar/)); msg('RegExp.input == ' + RegExp.input); msg('RegExp.$_ == ' + RegExp.$_); msg('attempt to set RegExp.input then perform a search using'); msg('instance.exec(). This works in Mozilla, but not MSIE'); msg('RegExp.input = "barfoo" ' + (RegExp.input = "barfoo")); msg('/bar/.exec() == ' + /bar/.exec()); msg('RegExp.input == ' + RegExp.input); msg('RegExp.$_ == ' + RegExp.$_); msg('cross browser/standard approach. works in Mozilla and MSIE'); msg('/bar/.exec("barfoo") == ' + /bar/.exec("barfoo")); msg('RegExp.input == ' + RegExp.input); msg('RegExp.$_ == ' + RegExp.$_);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

RegExp.lastIndex

MSIE only RegExp.lastIndex returns the next position in the string following the match or -1 if there is no match, -1 if lastIndex exceeds the length of the string.

var s; // search string var r; // search regular expression msg('check the initial type and value of RegExp.lastIndex'); msg('typeof RegExp.lastIndex == ' + typeof RegExp.lastIndex); msg('RegExp.lastIndex == ' + RegExp.lastIndex); msg('set search string: s = ' + (s = "foobarfoobar")); msg('set RegExp.lastIndex = ' + (RegExp.lastIndex = 8)); msg('perform a non global search on a string and check RegExp.lastIndex'); msg('for non global searches lastIndex should be ignored'); msg('set regular expression: r = ' + (r = /bar/)); msg('r.exec(s) == ' + r.exec(s)); msg('RegExp.lastIndex == ' + RegExp.lastIndex); msg('repeat a non global search on a string and check RegExp.lastIndex'); msg('r.exec(s) == ' + r.exec(s)); msg('RegExp.lastIndex == ' + RegExp.lastIndex); msg('perform a global search on a string and check RegExp.lastIndex'); msg('set regular expression: r = ' + (r = /bar/g)); msg('r.exec(s) == ' + r.exec(s)); msg('RegExp.lastIndex == ' + RegExp.lastIndex); msg('repeat a non global search on a string and check RegExp.lastIndex'); msg('r.exec(s) == ' + r.exec(s)); msg('RegExp.lastIndex == ' + RegExp.lastIndex); msg('attempt to set RegExp.lastIndex then perform a search'); msg('MSIE treats RegExp.lastIndex as readonly'); msg('RegExp.lastIndex = ' + (RegExp.lastIndex = 2)); msg('r.exec(s) == ' + r.exec(s)); msg('RegExp.lastIndex == ' + RegExp.lastIndex);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

RegExp.lastMatch, RegExp['$&']

Non standard, but supported by Mozilla and MSIE. Returns the last match made by a regular expression.

var string = "this is a test."; var regularexpression = /\w+/; regularexpression.test(string); msg('RegExp.lastMatch == ' + RegExp.lastMatch + ', RegExp[\'$&\'] == ' + RegExp['$&']);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

RegExp.lastParen, RegExp['$+']

Non standard, but supported by Mozilla and MSIE. Returns the last item in the capturing array, if any.

var string = "this is a test."; var regexp = /(\w+) (\w+)/; var result = regexp.exec(string); msg('RegExp.lastMatch == ' + RegExp.lastMatch + '<br>' + 'RegExp.lastParen == ' + RegExp.lastParen + '<br>' + 'RegExp[\'$+\'] == ' + RegExp['$+'] + '<br>' + 'result[result.length - 1] == ' + result[result.length -1]);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

RegExp.leftContext, RegExp.$`

Non standard, but supported by Mozilla and MSIE. Returns the leading portion of the string before the match.

var string = "this is a test."; var regularexpression = / is (\w+) (\w+)/; regularexpression.test(string); msg('RegExp.lastMatch == ' + RegExp.lastMatch + ', ' + 'RegExp.leftContext == ' + RegExp.leftContext + ', ' + 'RegExp[\'$`\'] == ' + RegExp['$`']);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

RegExp.rightContext, RegExp.$'

Non standard, but supported by Mozilla and MSIE. Returns the trailing portion of the string after the match.

var string = "this is a test."; var regularexpression = /(\w+)/; regularexpression.test(string); msg('RegExp.lastMatch == ' + RegExp.lastMatch + ', ' + 'RegExp.rightContext == ' + RegExp.rightContext + ', ' + 'RegExp[\'$\'\'] == ' + RegExp['$\'']);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

RegExp.$1 - RegExp.$9

Non standard, but supported by Mozilla and MSIE. RegExp.$N where N is a digit from 1 to 9 returns the corresponding item from the captures array.

var string = "this is a test."; var regexp = /((\w+) (\w+) (\w+) (\w+)(.*))/; var result = regexp.exec(string); msg('RegExp.lastMatch == ' + RegExp.lastMatch); for (var i = 1; i < result.length; i++) { msg('RegExp[\'$' + i + '\'] == ' + RegExp['$' + i] + '; ' + 'result[' + i + '] == ' + result[i]); }

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

regexp.source

Returns a string representing the source of the regular expression (without the bounding /. This is the same value as would have been passed to RegExp(pattern) during construction.

var regexp; var string = "this is a Test."; msg('test regexp.toSource() for an empty regular expression'); regexp = new RegExp(); msg('regexp.source == ' + regexp.source); msg('test /([A-Z]\w+)/'); regexp = /([A-Z]\w+)/; msg('regexp.source == ' + regexp.source); msg('test if regexp.source is readonly'); try { regexp.source = '/(\w+)/'; msg('Test regexp.source is readonly ' + (regexp.source == '([A-Z]\\w+)' ? 'passed.' : 'failed.')); } catch(e) { msg('regexp.source should be readonly ' + 'but not cause an error. ' + e.name + ': ' + e.message ); }

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

regexp.global

Read only property which returns true if the regular expression has the global g flag is set.

var regexp; var string = "this is a Test."; msg('test /(\w+ )*/'); regexp = /(\w+ )*/; msg('regexp.global == ' + regexp.global); msg('string.match(regexp) == ' + string.match(regexp)); msg('test /(\w+ )*/g'); regexp = /(\w+ )*/g; msg('regexp.global == ' + regexp.global); msg('string.match(regexp) == ' + string.match(regexp)); msg('test if regexp.source is readonly'); try { regexp.global = false; msg('Test regexp.global is readonly ' + (regexp.global == true ? 'passed.' : 'failed.')); } catch(e) { msg('regexp.global should be readonly ' + 'but not cause an error. ' + e.name + ': ' + e.message); }

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

regexp.ignoreCase

Read only property which returns true if the reqular expression has the ignore case i flag set.

var regexp; var string = "this is a Test."; msg('test /test/'); regexp = /test/; msg('regexp.ignoreCase == ' + regexp.ignoreCase); msg('string.match(regexp) == ' + string.match(regexp)); msg('test /test/i'); regexp = /test/i; msg('regexp.ignoreCase == ' + regexp.ignoreCase); msg('string.match(regexp) == ' + string.match(regexp)); msg('test if regexp.ignoreCase is readonly'); try { regexp.ignoreCase = false; msg('Test regexp.ignoreCase is readonly ' + (regexp.ignoreCase == true ? 'passed.' : 'failed.')); } catch(e) { msg('regexp.ignoreCase should be readonly ' + 'but not cause an error. ' + e.name + ': ' + e.message); }

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

regexp.multiline

Read only property which returns true if the multiline m flag is set.

var string = "this is a test.\r\nThis is another test."; msg('test $ without multiline'); var regexp = /a test.$/; msg('regexp.multiline == ' + regexp.multiline); msg('string.match(regexp) == ' + string.match(regexp)); msg('test $ with multiline'); regexp = /a test.$/m; msg('regexp.multiline == ' + regexp.multiline); msg('string.match(regexp) == ' + string.match(regexp)); msg('test if regexp.multiline is readonly'); try { regexp.multiline = false; msg('Test regexp.multline is readonly ' + (regexp.multiline == true ? 'passed.' : 'failed.')); } catch(e) { msg('regexp.multiline should be readonly ' + 'but not cause an error. ' + e.name + ': ' + e.message); }

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

regexp.lastIndex

If the global flag is set on the regular expression regexp, regexp.lastIndex is used to report and set the position in the string where the next match will begin. If the regular expression does not have the global flag set, then lastIndex should have no effect on matches.

var s; // search string var r; // search regular expression msg('create a regular expression without a global flag'); msg('set search string: s = ' + (s = "foobarfoobar")); msg('set regular expression: r = ' + (r = /bar/)); msg('<br>'); msg('check the initial type and value of r.lastIndex'); msg('typeof r.lastIndex == ' + typeof r.lastIndex); msg('r.lastIndex == ' + r.lastIndex); msg('<br>'); msg('perform a non global search on a string and check r.lastIndex'); msg('r.exec(s) == ' + r.exec(s)); msg('r.lastIndex == ' + r.lastIndex); msg('<br>'); msg('repeat a non global search on a string and check RegExp.lastIndex'); msg('for non global searches lastIndex should be ignored'); msg('r.exec(s) == ' + r.exec(s)); msg('r.lastIndex == ' + r.lastIndex); msg('<br>'); msg('attempt to set lastIndex on a non-global'); msg('regular expression then perform a search.'); msg('r.lastIndex = ' + (r.lastIndex = 2)); msg('r.exec(s) == ' + r.exec(s)); msg('r.lastIndex == ' + r.lastIndex); msg('<br>'); msg('create a regular expression with a global flag'); msg('set regular expression: r = ' + (r = /bar/g)); msg('r.lastIndex == ' + r.lastIndex); msg('<br>'); msg('perform a global search on a string and check RegExp.lastIndex'); msg('r.exec(s) == ' + r.exec(s)); msg('r.lastIndex == ' + r.lastIndex); msg('<br>'); msg('repeat a non global search on a string and check r.lastIndex'); msg('r.exec(s) == ' + r.exec(s)); msg('r.lastIndex == ' + r.lastIndex); msg('<br>'); msg('attempt to set r.lastIndex then perform a search'); msg('r.lastIndex = ' + (r.lastIndex = 2)); msg('r.exec(s) == ' + r.exec(s)); msg('r.lastIndex == ' + r.lastIndex);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

MSIE differs from the ECMAScript Standard and Mozilla on non global regular expressions. MSIE allows regexp.lastIndex to be used in non global regular expressions. MSIE will return the position in the string following the match for a non global regular expression, but on repeated searches will begin searching at the beginning of the string rather than at the position contained in lastIndex. MSIE also allows lastIndex to be set in non global regular expressions.

Error Objects

Whenever a runtime error occurs, an Error object is thrown which describes the error condition. Error serves as the base class for the other native Error objects: EvalError, RangeError, ReferenceError, SyntaxError and TypeError. Error and its child Objects can serve as the base class for user-defined error classes as well.

Error(message)

The Error constructor creates new instances of the Error Object when called as a part of a new expression or when called as a function.

var error = new Error('this is an error message'); msg('error.name == ' + error.name); msg('error.message == ' + error.message);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Error has property attribute {DontEnum} which means it does not appear in for-in loops, can be deleted and can be the target of an assignment.

Mozilla adds the {DontDelete} property attribute which means Mozilla will not delete it.

// attempt to delete Error msg('Before delete: typeof Error == ' + typeof Error); msg('(delete Error) == ' + (delete Error)); msg('After delete: typeof Error == ' + typeof Error);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

// attempt to assign to Error Error = 'foo'; msg('After Error = \'foo\': Error == ' + Error);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Error.prototype

Error.prototype has property attributes {DontEnum}, {DontDelete} and {ReadOnly} which means it will not appear in for-in loops, can not be deleted and can not be changed by assignment although its properties may be modified.

Error.prototype.constructor

Returns a reference to the Error constructor.

Error.prototype.name

Error.prototype.name is initially set to 'Error' however can be overwritten in instances.

msg('Error.prototype.name == ' + Error.prototype.name); // create an Error instance var error = new Error('foo'); msg('error.name == ' + error.name); // attempt to change name error.name = 'MyError'; msg('error.name == ' + error.name);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Error.prototype.message

Error.prototype.message is initially set to the null string but in instances is initialized to the message argument passed in the constructor however it can be overwritten in instances.

msg('Error.prototype.message == ' + Error.prototype.message); // create an Error instance var error = new Error('foo'); msg('error.message == ' + error.message); // attempt to change message error.message = 'bar!'; msg('error.message == ' + error.message);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Error.prototype.toString()

Error.prototype.toString returns a string representation of an Error instance.

Mozilla's version of Error.prototype.toString will return a string consisting of the errorname, a colon and space : following the errormessage. MSIE's version of Error.prototype.toString will return the default value '[object Error]' which is much less use however it can be overridden to produce the same result as Mozilla.

// default Error.prototype.toString var error = new Error('this is an error'); msg('error == ' + error); // override MSIE's Error.prototype.toString // override MSIE's Error.prototype.toString if (typeof (new Error).number == 'number') { // number is an MSIE only property Error.prototype.toString = function () { return this.name + ': ' + this.message; }; } msg('error == ' + error);

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

error.stack

error.lineNumber

Mozilla Only Mozilla provides additional properties on Error objects:

stack

contains an encoded description of the function call stack where the error was initially thrown. stack contains a line (string terminated via a newline \n) for each stack frame encoded as: function(argumentvalues)@pageurl:linenumber\n

The stack frame beginning at the global scope will have an empty function(argumentvalues).

lineNumber

contains the line number where the error occured.

/* * Illustrate the use of additional error properties in Mozilla * f1() calls f2('foo') which throws a runtime error. * * this example parses the stack obtaining the names, * arguments, and line numbers of the functions on the * stack when the error occured. */ function f1() { f2('foo'); } function f2(v) { try { // cause a reference error v = b; } catch(e) { msg('name: ' + e.name); msg('message: ' + e.message); msg('lineNumber: ' + e.lineNumber); msg('stack:<br>' + e.stack + '<br>'); var lines = e.stack.split('\n'); var regexpstack = /((\w+)\((.*)\))?@(.*):(\d+)/; for (var i = 0; i < lines.length; i++) { if (lines[i]) { msg(''); msg('frame ' + i + ' == ' + lines[i]); var capture = regexpstack.exec(lines[i]); if (capture) { msg('function call == ' + capture[1]); msg('function name == ' + capture[2]); msg('function args == ' + capture[3]); msg('function url == ' + capture[4]); msg('function line == ' + capture[5]); } } } } } f1();

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

EvalError

Mozilla and MSIE do not throw EvalError for indirect uses of eval or assignments to eval which is allowed by ECMAScript 16. Errors.

RangeError

Thrown by Number.prototype.toFixed(fractionDigits), Number.prototype.toExponentional(fractionDigits) and Number.prototype.toPrecision(fractionDigits). Supported by both Mozilla and MSIE however Mozilla extends the valid range of fractionDigits.

ReferenceError

MSIE fails to detect e instanceof ReferenceError when a reference error occurs even though it defines ReferenceError as a function.

try { var a = b; } catch(e) { msg('Exception is ' + ((e instanceof ReferenceError) ? '' : 'not ') + ' an instance of ReferenceError ' + e.name + ': ' + e.message ); }

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

SyntaxError

A SyntaxError occurs when an error occurs parsing the source of a JavaScript program.

When a syntax error occurs outside of an eval context, MSIE throws the error before running and can not capture it via a window.onerror error handler,. Mozilla can capture the error via window.onerror but not via a try catch block.

try { // cause a SyntaxError var a * b = c; } catch(e) { msg('Exception is ' + ((e instanceof SyntaxError) ? '' : 'not ') + ' an instance of SyntaxError ' + e.name + ': ' + e.message); }

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Both Mozilla and MSIE will throw SyntaxError when eval is called with invalid syntax.try { eval('var a * b = c;'); } catch(e) { msg('Exception is ' + ((e instanceof SyntaxError) ? '' : 'not ') + ' an instance of SyntaxError ' + e.name + ': ' + e.message ); }

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

TypeError

A TypeError is thrown when the type of an operand is incompatible with the operation.

try { // Math does not have a constructor // so this will fail. // According to 8.6.2 Internal Properties and Methods, // this should throw a TypeError var math = new Math(); } catch(e) { msg('Exception is ' + ((e instanceof TypeError) ? '' : 'not ') + ' an instance of TypeError ' + e.name + ': ' + e.message ); }

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

URIError

A URIError is thrown when one of the global URI functions decodeURI, encodeURI, decodeURIComponent or encodeURIComponent encounters an error.

// invalid character for URI functions var invalidchar = String.fromCharCode(0xDC00 + 1) try { msg('encodeURIComponent(invalidchar) == ' + encodeURIComponent(invalidchar)); } catch(e) { msg('Exception: ' + e.name + ': ' + e.message); }

javascript default1.11.21.31.41.5execute

javascript default1.11.21.31.41.5execute

Links

• Bugzilla 240317
• Bugzilla 255895
• ECMAScript Language Specification 4^th Editition (Proposed)
• ECMAScript for XML (E4X) Specification
• ECMAScript Language Specification ECMA-262 3rd Edition
• ECMAScript Language Specification ECMA-262 3rd Edition (Unofficial HTML version)
• HTML 4.01 - Notes on invalid documents
• HTML body tag
• HTML head tag
• HTML script tag
• Internet Explorer History
• Internet Explorer JavaScript References
• Internet Explorer JScript Features
• JavaScript Test Results
• JavaScript Test Suite
• mozilla.org
• mozilla.org's JavaScript Project
• mozilla.org's JavaScript Test Library
• mozilla.org's JavaScript 2.0
• Netscape DevEdge
• Regular Expressions
• RFC 822
• Rodney Dangerfield

Index

• About JavaScript
• About this Article
• Access Array items
• Access Object Properties
• Array Objects
• Array(length)
• array.length
• Array.prototype
• Array.prototype.concat([item1[, item2 [, …]]])
• Array.prototype.constructor
• Array.prototype.join(separator)
• Array.prototype.pop()
• Array.prototype.push([item1[, item2[, …]]])
• Array.prototype.reverse()
• Array.prototype.shift()
• Array.prototype.slice(start, end)
• Array.prototype.sort(comparefunc)
• Array.prototype.splice(start, deleteCount[, item1 [, item2[, …]]])
• Array.prototype.toLocaleString()
• Array.prototype.toSource()
• Array.prototype.toString()
• Array.prototype.unshift([item1[, item2[, …]]])
• Assignment Operators
• Bit Operators
• Boolean Objects
• Boolean(value)
• Boolean.protototype.constructor
• Boolean.protototype.toString()
• Boolean.protototype.valueOf()
• Boolean.prototype
• Conditional Statements
• Date Objects
• Date(value)
• Date(year, month[, day[, hours[, minutes[, seconds[, ms]]]]]) (Constructor Call)
• Date([year[, month[, date[, hours[, minutes[, seconds[, ms]]]]]]]) (Function Call)
• Date(…)
• Date.parse(string)
• Date.prototype
• Date.prototype.constructor
• Date.prototype.getDate()
• Date.prototype.getDay()
• Date.prototype.getFullYear()
• Date.prototype.getHours()
• Date.prototype.getMilliseconds()
• Date.prototype.getMinutes()
• Date.prototype.getMonth()
• Date.prototype.getSeconds()
• Date.prototype.getTime()
• Date.prototype.getTimezoneOffset()
• Date.prototype.getUTCDate()
• Date.prototype.getUTCDay()
• Date.prototype.getUTCFullYear()
• Date.prototype.getUTCHours()
• Date.prototype.getUTCMilliseconds()
• Date.prototype.getUTCMinutes()
• Date.prototype.getUTCMonth()
• Date.prototype.getUTCSeconds()
• Date.prototype.getYear()
• Date.prototype.setDate(day)
• Date.prototype.setFullYear(year[, month[, day]])
• Date.prototype.setHours(hour[, min[, sec[, ms]]])
• Date.prototype.setMilliseconds(ms)
• Date.prototype.setMinutes(min[, sec[, ms]])
• Date.prototype.setMonth(month[, day])
• Date.prototype.setSeconds(sec[, ms])
• Date.prototype.setTime(time)
• Date.prototype.setUTCDate(date)
• Date.prototype.setUTCFullYear(year[, month[, date]])
• Date.prototype.setUTCHours(hour[, min[, sec[, ms]]])
• Date.prototype.setUTCMilliseconds(ms)
• Date.prototype.setUTCMinutes(min[, sec[, ms]])
• Date.prototype.setUTCMonth(month[, day])
• Date.prototype.setUTCSeconds(sec[, ms])
• Date.prototype.setYear(year)
• Date.prototype.toDateString()
• Date.prototype.toGMTString()
• Date.prototype.toLocaleDateString()
• Date.prototype.toLocaleString()
• Date.prototype.toLocaleTimeString()
• Date.prototype.toString()
• Date.prototype.toTimeString()
• Date.prototype.toUTCString()
• Date.prototype.UTC(year, month[, day[, hours[, minutes[, seconds[, ms]]]]])
• Date.prototype.valueOf()
• decodeURI(encodedURI)
• decodeURIComponent(encodedURIComponent)
• encodeURI(uri)
• encodeURIComponent(uriComponent)
• Error Objects
• Error(message)
• error.lineNumber
• Error.prototype
• Error.prototype.constructor
• Error.prototype.message
• Error.prototype.name
• Error.prototype.toString()
• error.stack
• eval(x)
• EvalError
• Example JavaScript Programs
• Exception Statements
• Execution Contexts
• Function Expressions
• Function Objects
• Function(arg1, arg2, …)
• function.arity
• Function.length
• function.length
• function.name
• Function.prototype
• function.prototype
• Function.prototype.apply(thisArg, argArray)
• Function.prototype.call(thisArg[, arg1 [, arg2, …]])
• Function.prototype.constructor
• Function.prototype.toSource()
• Function.prototype.toString()
• Grouping (()) Operator
• Identifiers
• Including JavaScript programs in Web Pages
• Infinity
• Interpreted Programming Languages
• Introduction to Objects
• isFinite(number)
• isNaN(number)
• Iteration Statements
• JavaScript Data Types
• JavaScript Expressions
• JavaScript Implementations
• JavaScript Native Objects
• JavaScript Statements
• Labelled Statements
• Links
• Math.abs(x)
• Math.acos(x)
• Math.asin(x)
• Math.atan(x)
• Math.atan2(y,x)
• Math.ceil(x)
• Math.cos(x)
• Math.E
• Math.exp(x)
• Math.floor(x)
• Math.LN10
• Math.LN2
• Math.log(x)
• Math.LOG10E
• Math.LOG2E
• Math.max([value1 [, value2 [, …]]])
• Math.min([value1 [, value2 [, …]]])
• Math.PI
• Math.pow(x,y)
• Math.random()
• Math.round(x)
• Math.sin(x)
• Math.sqrt(x)
• Math.SQRT1_2
• Math.SQRT2
• Math.tan(x)
• Member of (.) Operator
• Member of Operators
• NaN
• Number Objects
• Number(value)
• Number.MAX_VALUE
• Number.MIN_VALUE
• Number.NaN
• Number.NEGATIVE_INFINITY
• Number.POSITIVE_INFINITY
• Number.prototype
• Number.prototype.constructor
• Number.prototype.toExponentional(fractionDigits)
• Number.prototype.toFixed(fractionDigits)
• Number.prototype.toLocaleString()
• Number.prototype.toPrecision(precision)
• Number.prototype.toString(radix)
• Number.prototype.valueOf()
• Object Objects
• Object([value])
• Object.length
• Object.name
• Object.prototype
• Object.prototype.constructor
• Object.prototype.eval(source)
• Object.prototype.hasOwnProperty(property)
• Object.prototype.isEnumerable(property)
• Object.prototype.isPrototypeOf(object)
• Object.prototype.toLocaleString()
• Object.prototype.toSource()
• Object.prototype.toString()
• Object.prototype.valueOf()
• object.__proto__
• Operator Precedence and Associativity
• Operator: !==
• Operator: !=
• Operator: !
• Operator: %
• Operator: &&
• Operator: &
• Operator: *
• Operator: + (addition)
• Operator: + (unary)
• Operator: ++
• Operator: ,
• Operator: - (subtraction)
• Operator: - (unary)
• Operator: --
• Operator: /
• Operator: <<
• Operator: <=
• Operator: <
• Operator: ===
• Operator: ==
• Operator: =
• Operator: >=
• Operator: >>>
• Operator: >>
• Operator: >
• Operator: ?:
• Operator: delete
• Operator: in
• Operator: instanceof
• Operator: new
• Operator: op=
• Operator: typeof
• Operator: void
• Operator: []
• Operator: ^
• Operator: |
• Operator: ||
• Operator: ~
• Operators
• parseFloat(string)
• parseInt(string, radix)
• Part I - Introduction to JavaScript
• Part II - JavaScript (Pseudo) Reference
• RangeError
• ReferenceError
• RegExp Objects
• RegExp(pattern[, flags])
• RegExp.$1 - RegExp.$9
• regexp.global
• regexp.ignoreCase
• RegExp.index
• RegExp.input, RegExp.$_
• RegExp.lastIndex
• regexp.lastIndex
• RegExp.lastMatch, RegExp['$&']
• RegExp.lastParen, RegExp['$+']
• RegExp.leftContext, RegExp.$`
• regexp.multiline
• RegExp.prototype
• RegExp.prototype.constructor
• RegExp.prototype.exec(string)
• RegExp.prototype.test(string)
• RegExp.prototype.toString()
• RegExp.rightContext, RegExp.$'
• regexp.source
• Regular Expresion Pattern: \d
• Regular Expression Character Patterns
• Regular Expression Grouping Patterns
• Regular Expression Logical Patterns
• Regular Expression Pattern {N}
• Regular Expression Pattern: $
• Regular Expression Pattern: (?:X)
• Regular Expression Pattern: (X)
• Regular Expression Pattern: .
• Regular Expression Pattern: X(?!Y)
• Regular Expression Pattern: X(?=Y)
• Regular Expression Pattern: X*
• Regular Expression Pattern: X+
• Regular Expression Pattern: X?
• Regular Expression Pattern: XY
• Regular Expression Pattern: X|Y
• Regular Expression Pattern: [X-Y]
• Regular Expression Pattern: [\b]
• Regular Expression Pattern: \0
• Regular Expression Pattern: \b
• Regular Expression Pattern: \B
• Regular Expression Pattern: \cC
• Regular Expression Pattern: \D
• Regular Expression Pattern: \f
• Regular Expression Pattern: \n
• Regular Expression Pattern: \N
• Regular Expression Pattern: \r
• Regular Expression Pattern: \s
• Regular Expression Pattern: \S
• Regular Expression Pattern: \t
• Regular Expression Pattern: \uHHHH
• Regular Expression Pattern: \v
• Regular Expression Pattern: \w
• Regular Expression Pattern: \W
• Regular Expression Pattern: \xHH
• Regular Expression Pattern: \
• Regular Expression Pattern: ^
• Regular Expression Pattern: {N,M}
• Regular Expression Pattern: {N,}
• Regular Expression Patterns
• Regular Expression Patterns: Boundaries
• Regular Expression Quantifying Patterns
• Regular Expressions: Capture Arrays
• Relational and Logical Operators
• Reserved Words
• Statement: Block
• Statement: break
• Statement: const
• Statement: continue
• Statement: do while
• Statement: Empty
• Statement: Expression
• Statement: for in
• Statement: for
• Statement: if
• Statement: switch
• Statement: throw
• Statement: try, catch, finally
• Statement: var
• Statement: while
• String
• String Objects
• String.fromCharCode([char0[, char1[, …]]])
• string.length
• String.prototype
• String.prototype.charAt(pos)
• String.prototype.charCodeAt(pos)
• String.prototype.concat([string1[, string2[, …]]])
• String.prototype.constructor
• String.prototype.indexOf(searchString, position)
• String.prototype.lastIndexOf(searchString, position)
• String.prototype.localeCompare(that)
• String.prototype.match(regexp)
• String.prototype.replace(searchValue, replaceValue)
• String.prototype.search(regexp)
• String.prototype.slice(start,end)
• String.prototype.split(separator,limit)
• String.prototype.substr(start, length)
• String.prototype.substring(start, end)
• String.prototype.toLocaleLowerCase()
• String.prototype.toLocaleUpperCase()
• String.prototype.toLowerCase()
• String.prototype.toString()
• String.prototype.toUpperCase()
• String.prototype.valueOf()
• SyntaxError
• The Global Object
• The Math Object
• Type Conversions
• TypeError
• Unary Operators
• undefined
• URIError