JavaScript – Miscellaneous Operators

JavaScript supports a number of other miscellaneous operators,
described in the following sections.

The Conditional Operator (?:)

The conditional operator is the only ternary operator (three
operands) in JavaScript and is sometimes actually called the ternary
operator. This operator is sometimes written ?:, although it does not appear quite that
way in code. Because this operator has three operands, the first
goes before the ?, the second
goes between the ? and the
:, and the third goes after the
:. It is used like
this:

x > 0 ? x : -x     // The absolute value of x

The operands of the conditional operator may be of any type.
The first operand is evaluated and interpreted as a boolean. If the
value of the first operand is truthy, then the second operand is
evaluated, and its value is returned. Otherwise, if the first
operand is falsy, then the third operand is evaluated and its value
is returned. Only one of the second and third operands is evaluated,
never both.

While you can achieve similar results using the if statement (if), the ?:
operator often provides a handy shortcut. Here is a typical usage,
which checks to be sure that a variable is defined (and has a
meaningful, truthy value) and uses it if so or provides a default
value if not:

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

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

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

The typeof Operator

typeof is a unary operator
that is placed before its single operand, which can be of any type.
Its value is a string that specifies the type of the operand. The
following table specifies the value of the typeof operator for any JavaScript
value:

x typeof x
undefined "undefined"
null "object"
true or false "boolean"
any number or NaN "number"
any string "string"
any function "function"
any nonfunction native object "object"
any host object

An implementation-defined string, but not
“undefined”, “boolean”, “number”, or “string”.

You might use the typeof
operator in an expression like this:

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

The typeof operator is also
useful when used with the switch
statement (switch). 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)

Note that typeof returns
“object” if the operand value is null. If you want to distinguish null from objects, you’ll have to
explicitly test for this special-case value. typeof may return a string other than
“object” for host objects. In practice, however, most host objects
in client-side JavaScript have a type of “object”.

Because typeof evaluates to
“object” for all object and array values other than functions, it is
useful only to distinguish objects from other, primitive types. In
order to distinguish one class of object from another, you must use
other techniques, such as the instanceof operator (see The instanceof Operator), the class attribute
(see The class Attribute), or the constructor property (see The prototype Attribute and The constructor Property).

Although functions in JavaScript are a kind of object, the
typeof operator considers
functions to be sufficiently different that they have their own
return value. JavaScript makes a subtle distinction between
functions and “callable objects.” All functions are callable, but it
is possible to have a callable object—that can be invoked just like
a function—that is not a true function. The ECMAScript 3 spec says
that the typeof operator returns
“function” for all native object that are callable. The ECMAScript 5
specification extends this to require that typeof return “function” for all callable
objects, whether native objects or host objects. Most browser
vendors use native JavaScript function objects for the methods of
their host objects. Microsoft, however, has always used non-native
callable objects for their client-side methods, and before IE 9 the
typeof operator returns “object”
for them, even though they behave like functions. In IE9 these
client-side methods are now true native function objects. See Callable Objects for more on the distinction between
true functions and callable objects.

The delete Operator

delete is an unary operator
that attempts to delete the object property or array element
specified as its operand.[3] Like the assignment, increment, and decrement
operators, delete is typically
used for its property deletion side effect, and not for the value it
returns. Some examples:

var o = { x: 1, y: 2}; // Start with an object
delete o.x;            // Delete one of its properties
"x" in o               // => false: the property does not exist anymore

var a = [1,2,3];       // Start with an array
delete a[2];           // Delete the last element of the array
2 in a                 // => false: array element 2 doesn't exist anymore
a.lenth                // => 3: note that array length doesn't change, though

Note that a deleted property or array element is not merely
set to the undefined value. When
a property is deleted, the property ceases to exist. Attempting to
read a nonexistent property returns undefined, but you can test for the actual
existence of a property with the in operator (The in Operator). Deleting an array element leaves a “hole”
in the array and does not change the array’s length. The resulting
array is sparse.

delete expects its operand
to be an lvalue. If it is not an lvalue, the operator takes no
action and returns true.
Otherwise, delete attempts to
delete the specified lvalue. delete returns true if it successfully deletes the
specified lvalue. Not all properties can be deleted, however: some
built-in core and client-side properties are immune from deletion,
and user-defined variables declared with the var statement cannot be deleted. Functions
defined with the function
statement and declared function parameters cannot be deleted
either.

In ECMAScript 5 strict mode, delete raises a SyntaxError if its operand
is an unqualified identifier such as a variable, function, or
function parameter: it only works when the operand is a property
access expression (Property Access Expressions). Strict mode
also specifies that delete raises
a TypeError if asked to delete any nonconfigurable property (see
Property Attributes). Outside of strict mode, no
exception occurs in these cases and delete simply returns false to indicate that the operand could
not be deleted.

Here are some example uses of 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.
                     // Would raise an exception in strict mode.
delete 1;            // Argument is not an lvalue: returns true
this.x = 1;          // Define a property of the a global object without var
delete x;            // Try to delete it: returns true in non-strict mode
                     // Exception in strict mode. Use 'delete this.x' instead
x;                   // Runtime error: x is not defined

We’ll see the delete
operator again in Deleting Properties.

The void Operator

void is a unary operator
that appears before its single operand, which may be of any type.
This operator is unusual and infrequently used: it evaluates its
operand, then discards the value and returns undefined. Since the operand value is
discarded, using the void
operator makes sense only if the operand has side effects.

The most common use for this operator is in a client-side
javascript: URL, where it allows
you to evaluate an expression for its side effects without the
browser displaying the value of the evaluated expression. For
example, you might use the void
operator in an HTML <a> tag
as follows:

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

This HTML could be more cleanly written using an onclick event handler rather than a
javascript: URL, of course, and
the void operator would not be
necessary in that case.

The Comma Operator (,)

The comma operator is a binary operator whose operands may be
of any type. It evaluates its left operand, evaluates its right
operand, and then returns the value of the right operand. Thus, the
following line:

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

evaluates to 2 and is basically equivalent to:

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

The left-hand expression is always evaluated, but its value is
discarded, which means that it only makes sense to use the comma
operator when the left-hand expression has side effects. The only
situation in which the comma operator is commonly used is with a
for loop (for) that has multiple loop variables:

// The first comma below is part of the syntax of the var statement
// The second comma is the comma operator: it lets us squeeze 2
// expressions (i++ and j--) into a statement (the for loop) that expects 1.
for(var i=0,j=10; i < j; i++,j--)
    console.log(i+j);


[3] If you are a C++ programmer, note that the delete keyword in JavaScript is
nothing like the delete
keyword in C++. In JavaScript, memory deallocation is handled
automatically by garbage collection, and you never have to worry
about explicitly freeing up memory. Thus, there is no need for a
C++-style delete to delete
entire objects.

Comments are closed.