Object Creation

Objects are created using the new operator in conjunction with a special constructor function.

[var] instance = new Constructor(arguments);

Instance Properties

Once an instance of an object is created, setting properties is similar to a standard assignment,

instance.property = value;

and accessed using the standard dot (.) operator.

instance.property

The this Statement

The this statement refers to the “current” object, that is, the object inside of which this is invoked. Its syntax is

this.property

and it is typically used inside of a function (for example, to access the function’s length property) or inside of a constructor in order to access the new instance being created. Used in the global context, this refers to the current Window.

ECMAScript Built-In Objects

Table A-16 lists the built-in objects found in ECMAScript-based languages such as JavaScript. These objects are part of the language itself, as opposed to host (or browser) objects that are provided by the browsers. Note that you cannot instantiate Global or Math objects. The Global object is not even explicitly addressable. It is defined as the outermost enclosing scope (so its properties are always addressable). Chapter 7 as well as Appendix B provide details and examples of these objects and their methods and properties.

The Global object in particular contains a variety of useful utility properties and methods. Aspiring JavaScript programmers should become very familiar with the features of Global summarized in Table A-17.

Array Literals

JavaScript supports arrays both in an object and literal style. Array literals are used with the following syntax (the brackets are “real” brackets and do not indicate optional components):

[element1, element2, …]

Each elementN is optional, so you use an array with “holes” in it, for example:

var myArray = ["some data", , 3.14, true ];

You can also use the Array() constructor:

var variable = new Array(element1, element2, …);

but be aware that if only one numeric argument is passed, it is interpreted as the initial value for the length property. It is important to note the close relationship between arrays and objects in JavaScript. Object properties can be accessed not only as objectName.propertyName but as objectName['propertyName']. However, this does not mean that array elements can be accessed using an object style; arrayName.0 would not access the first element of an array.

Function Literals

Function literals are used with the following syntax,

function ([ args ]) 
 { 
    statements
 }

where args is a comma-separated list of identifiers for the function arguments and statements is zero or more valid JavaScript statements.

Although not strictly a literal, you can also use the Function() constructor:

new Function(["arg1", ["arg2"], … ,] "statements");

The argN’s are the names of the parameters the function accepts and statements is the body of the function. For example:

myArray.sort(new Function("name", "alert('Hello there ' + name)"));

Object Literals

Object literals are used with the following syntax:

{ [ prop1: val1 [, prop2: val2, … ]] }

For example:

var myInfo = {
   city: "San Diego", 
   state: "CA" ,
   province: null, 
   sayHi = function() { alert("Hello there") }
}

Regular Expression Literals

Regular expression literals (actually RegExp literals) have the following syntax:

/exp/flags

where exp is a valid regular expression and flags is zero or more regular expression modifiers (e.g., “gi” for global and case-insensitive).

Although not strictly a literal, you can use the RegExp() constructor:

new RegExp("exp" [, "flags"])