5.10.1. The Conditional Operator (?:)

x > 0 ? x*y : -x*y

The first operand of the conditional operator must be (or be convertable to) a boolean value -- usually this is the result of a comparison expression. The second and third operands may have any value. The value returned by the conditional operator depends on the boolean value of the first operand. If that operand is true, the value of the conditional expression is the value of the second operand. If the first operand is false, the value of the conditional expression is the value of the third operand.

greeting = "hello " + (username != null ? username : "there"); 

This is equivalent to, but more compact than, the following if statement:

greeting = "hello ";
if (username != null)
    greeting += username;
else
    greeting += "there"; 

5.10.2. The typeof Operator

The typeof operator evaluates to "number", "string", or "boolean" if its operand is a number, string, or boolean value. It evaluates to "object" for objects, arrays, and (surprisingly) null. It evaluates to "function" for function operands and to "undefined" if the operand is undefined.

typeof evaluates to "object" when its operand is a Number, String, or Boolean wrapper object. It also evaluates to "object" for Date and RegExp objects. typeof evaluates to an implementation-dependent value for objects that are not part of core JavaScript but are provided by the context in which JavaScript is embedded. In client-side JavaScript, however, typeof typically evaluates to "object" for all client-side objects, just as it does for all core objects.

You might use the typeof operator in expressions like these:

typeof i
(typeof value == "string") ? "'" + value + "'" : value 

Note that you can place parentheses around the operand to typeof, which makes typeof look like the name of a function rather than an operator keyword:

typeof(i) 

Because typeof evaluates to "object" for all object and array types, it is useful only to distinguish objects from other, primitive types. In order to distinguish one object type from another, you must use other techniques, such as the instanceof operator or the constructor property (see the "Object.constructor" entry in the core reference section).

The typeof operator is defined by the ECMAScript v1 specification and is implemented in JavaScript 1.1 and later.

5.10.3. The Object Creation Operator (new)

new constructor(arguments) 

constructor must be an expression that evaluates to a constructor function, and it should be followed by zero or more comma-separated arguments enclosed in parentheses. As a special case, for the new operator only, JavaScript simplifies the grammar by allowing the parentheses to be omitted if there are no arguments in the function call. Here are some examples using the new operator:

o = new Object;    // Optional parentheses omitted here
d = new Date( );  // Returns a Date object representing the current time
c = new Rectangle(3.0, 4.0, 1.5, 2.75);  // Create an object of class Rectangle
obj[i] = new constructors[i]( ); 

5.10.4. The delete Operator

var o = {x:1, y:2};  // Define a variable; initialize it to an object
delete o.x;          // Delete one of the object properties; returns true
typeof o.x;          // Property does not exist; returns "undefined"
delete o.x;          // Delete a nonexistent property; returns true
delete o;            // Can't delete a declared variable; returns false
delete 1;            // Can't delete an integer; returns true
x = 1;               // Implicitly declare a variable without var keyword
delete x;            // Can delete this kind of variable; returns true
x;                   // Runtime error: x is not defined

var my = new Object( );    // Create an object named "my"
my.hire = new Date( );     // my.hire refers to a Date object
my.fire = my.hire;          // my.fire refers to the same object
delete my.hire;             // hire property is deleted; returns true
document.write(my.fire);    // But my.fire still refers to the Date object 

5.10.5. The void Operator

For example, you might use the void operator in an HTML tag as follows:

<a href="javascript:void window.open( );">Open New Window</a> 

5.10.6. The Comma Operator (,)

i=0, j=1, k=2; 

evaluates to 2, and is basically equivalent to:

i = 0;
j = 1;
k = 2; 

5.10.7. Array and Object Access Operators

frames[1]
document.forms[i + j]
document.forms[i].elements[j++] 

If the first operand to the [] operator is a reference to an object, the second operand should be an expression that evaluates to a string that names a property of the object. Note that in this case, the second operand is a string, not an identifier. It should be a constant in quotes or a variable or expression that refers to a string. For example:

document["lastModified"]
frames[0]['length']
data["val" + i] 

for (f in o) {
    document.write('o.' + f + ' = ' + o[f]);
    document.write('<br>');
} 

5.10.8. The Function Call Operator

document.close( )
Math.sin(x)
alert("Welcome " + name)
Date.UTC(2000, 11, 31, 23, 59, 59)
funcs[i].f(funcs[i].args[0], funcs[i].args[1])