Table 3.6
Logical operators
|
Operator
|
Usage
|
Description
|
|
&&
|
expr1 && expr2
|
(Logical AND) Returns
expr1
if it can be converted to false; otherwise,
returns expr2.
Thus, when used with Boolean values, &&
returns true if both operands are true;
otherwise, returns false.
|
|
||
|
expr1 || expr2
|
(Logical OR) Returns
expr1
if it can be converted to true; otherwise,
returns expr2.
Thus, when used with Boolean values, || returns
true if either operand is true; if both are
false, returns false.
|
|
!
|
!expr
|
(Logical NOT) Returns false if
its single operand can be converted to true;
otherwise, returns true.
|
Examples of expressions that can be
converted to false are those that evaluate to null, 0, the
empty string (""), or undefined.
The following code shows examples of
the && (logical AND) operator.
a1=true && true
// t && t
returns true
a2=true && false //
t && f returns false
a3=false && true //
f && t returns false
a4=false && (3 == 4) // f && f
returns false
a5="Cat" && "Dog" // t
&& t returns Dog
a6=false && "Cat" // f
&& t returns false
a7="Cat" && false // t
&& f returns false
The following code shows examples of
the || (logical OR) operator.
o1=true || true
// t || t returns
true
o2=false || true // f || t
returns true
o3=true || false // t || f
returns true
o4=false || (3 == 4) // f || f returns false
o5="Cat" || "Dog" // t || t
returns Cat
o6=false || "Cat" // f || t
returns Cat
o7="Cat" || false // t || f
returns Cat
The following code shows examples of
the ! (logical NOT) operator.
n1=!true
//
!t returns false
n2=!false
//
!f returns true
n3=!"Cat"
//
!t returns false
Short-Circuit Evaluation
As logical expressions are evaluated
left to right, they are tested for possible "short-circuit"
evaluation using the following rules:
-
-
false
&& anything is short-circuit evaluated to
false.
-
true ||
anything is short-circuit evaluated to true.
The rules of logic guarantee that these
evaluations are always correct. Note that the anything
part of the above expressions is not evaluated, so any side
effects of doing so do not take effect.
String Operators
In addition to the comparison
operators, which can be used on string values, the
concatenation operator (+) concatenates two string values
together, returning another string that is the union of the
two operand strings. For example, "my " + "string"
returns the string "my string".
The shorthand assignment operator +=
can also be used to concatenate strings. For example, if
the variable mystring has
the value "alpha," then the expression mystring += "bet"
evaluates to "alphabet" and assigns this value to
mystring.
Special Operators
JavaScript provides the following
special operators:
conditional operator
The conditional operator is the only
JavaScript operator that takes three operands. The operator
can have one of two values based on a condition. The syntax
is:
condition ? val1 :
val2
If condition is
true, the operator has the value of val1.
Otherwise it has the value of val2. You can
use the conditional operator anywhere you would use a
standard operator.
For example,
status = (age >= 18) ? "adult" :
"minor"
This statement assigns the value
"adult" to the variable status if
age is
eighteen or more. Otherwise, it assigns the value "minor"
to status.
comma
operator
The comma operator (,) simply
evaluates both of its operands and returns the value of the
second operand. This operator is primarily used inside a
for loop, to
allow multiple variables to be updated each time through
the loop.
For example, if a is a
2-dimensional array with 10 elements on a side, the
following code uses the comma operator to increment two
variables at once. The code prints the values of the
diagonal elements in the array:
for (var i=0, j=9; i <= 9; i++,
j--)
document.writeln("a["+i+","+j+"]= " +
a[i*10 +j])
Note that two-dimensional arrays are
not yet supported. This example emulates a two-dimensional
array using a one-dimensional array.
delete
The delete operator deletes an object,
an object's property, or an element at a specified index in
an array. The syntax is:
delete objectName
delete
objectName.property
delete
objectName[index]
delete property // legal only within a with
statement
where objectName is
the name of an object, property is
an existing property, and index is an
integer representing the location of an element in an
array.
The fourth form is legal only within a
with
statement, to delete a property from an object.
You can use the delete
operator to delete variables declared implicitly but not
those declared with the var
statement.
If the delete
operator succeeds, it sets the property or element to
undefined. The
delete operator returns true if the operation is
possible; it returns false if the operation is not
possible.
x=42
var y= 43
myobj=new Number()
myobj.h=4 // create property
h
delete x // returns
true (can delete if declared implicitly)
delete y // returns
false (cannot delete if declared with var)
delete Math.PI // returns false (cannot delete predefined
properties)
delete myobj.h // returns true (can delete user-defined
properties)
delete myobj // returns true (can delete if
declared implicitly)
Deleting array elements
When you delete an array element, the
array length is not affected. For example, if you delete
a[3], a[4] is still a[4] and a[3] is undefined.
When the delete
operator removes an array element, that element is no
longer in the array. In the following example, trees[3] is
removed with delete.
trees=new
Array("redwood","bay","cedar","oak","maple")
delete trees[3]
if (3 in trees) {
// this does not get executed
}
If you want an array element to exist
but have an undefined value, use the undefined
keyword instead of the delete
operator. In the following example, trees[3] is assigned
the value undefined, but the array element still exists:
trees=new
Array("redwood","bay","cedar","oak","maple")
trees[3]=undefined
if (3 in trees) {
// this gets executed
}
in
The in operator
returns true if the specified property is in the specified
object. The syntax is:
propNameOrNumber in
objectName
where propNameOrNumber
is a string or numeric expression representing a property
name or array index, and objectName is
the name of an object.
The following examples show some uses
of the in operator.
// Arrays
trees=new Array("redwood","bay","cedar","oak","maple")
0 in
trees //
returns true
3 in
trees //
returns true
6 in
trees //
returns false
"bay" in trees // returns false
(you must specify the index number,
//
not the value at that index)
"length" in trees // returns true (length is an Array
property)
// Predefined objects
"PI" in
Math //
returns true
myString=new String("coral")
"length" in myString // returns true
// Custom objects
mycar = {make:"Honda",model:"Accord",year:1998}
"make" in mycar // returns true
"model" in mycar // returns true
instanceof
The instanceof
operator returns true if the specified object is of the
specified object type. The syntax is:
objectName instanceof
objectType
where objectName is
the name of the object to compare to objectType,
and objectType is
an object type, such as Date or Array.
Use instanceof
when you need to confirm the type of an object at runtime.
For example, when catching exceptions, you can branch to
different exception-handling code depending on the type of
exception thrown.
For example, the following code uses
instanceof to
determine whether theDay is a
Date object.
Because theDay is a
Date object,
the statements in the if statement
execute.
theDay=new Date(1995, 12, 17)
if (theDay instanceof Date) {
// statements to execute
}
new
You can use the new operator
to create an instance of a user-defined object type or of
one of the predefined object types Array,
Boolean,
Date,
Function,
Image,
Number,
Object,
Option,
RegExp, or
String. On
the server, you can also use it with DbPool,
Lock,
File, or
SendMail. Use
new as
follows:
objectName = new
objectType ( param1 [,param2]
...[,paramN] )
You can also create objects using
object initializers, as described in "Using Object Initializers" on
page 93.
See new in the
Core JavaScript Reference for more information.
this
Use the this keyword
to refer to the current object. In general,
this
refers to the calling object in a method. Use
this as
follows:
this[.propertyName]
Example 1. Suppose a function
called validate
validates an object's value
property, given the object and the high and low values:
function validate(obj, lowval, hival)
{
if ((obj.value < lowval) ||
(obj.value > hival))
alert("Invalid
Value!")
}
You could call validate in
each form element's onChange
event handler, using this to pass
it the form element, as in the following example:
<B>Enter a number between 18 and
99:</B>
<INPUT TYPE = "text" NAME = "age" SIZE = 3
onChange="validate(this, 18, 99)">
Example 2. When combined with
the form
property, this can
refer to the current object's parent form. In the following
example, the form myForm
contains a Text object
and a button. When the user clicks the button, the value of
the Text object
is set to the form's name. The button's onClick event
handler uses this.form to
refer to the parent form, myForm.
<FORM NAME="myForm">
Form name:<INPUT TYPE="text" NAME="text1"
VALUE="Beluga">
<P>
<INPUT NAME="button1" TYPE="button" VALUE="Show Form
Name"
onClick="this.form.text1.value=this.form.name">
</FORM>
typeof
The typeof
operator is used in either of the following ways:
1. typeof operand
2. typeof
(operand)
The typeof
operator returns a string indicating the type of the
unevaluated operand. operand is
the string, variable, keyword, or object for which the type
is to be returned. The parentheses are optional.
Suppose you define the following
variables:
var myFun = new Function("5+2")
var shape="round"
var size=1
var today=new Date()
The typeof
operator returns the following results for these variables:
typeof myFun is function
typeof shape is string
typeof size is number
typeof today is object
typeof dontExist is undefined
For the keywords true and
null, the
typeof
operator returns the following results:
typeof true is boolean
typeof null is object
For a number or string, the
typeof
operator returns the following results:
typeof 62 is number
typeof 'Hello world' is string
For property values, the
typeof
operator returns the type of value the property
contains:
typeof document.lastModified is
string
typeof window.length is number
typeof Math.LN2 is number
For methods and functions, the
typeof
operator returns results as follows:
typeof blur is function
typeof eval is function
typeof parseInt is function
typeof shape.split is function
For predefined objects, the
typeof
operator returns results as follows:
typeof Date is function
typeof Function is function
typeof Math is function
typeof Option is function
typeof String is function
void
The void operator is used in either of
the following ways:
1. void (expression)
2. void expression
The void operator specifies an
expression to be evaluated without returning a value.
expression is
a JavaScript expression to evaluate. The parentheses
surrounding the expression are optional, but it is good
style to use them.
You can use the void operator
to specify an expression as a hypertext link. The
expression is evaluated but is not loaded in place of the
current document.
The following code creates a hypertext
link that does nothing when the user clicks it. When the
user clicks the link, void(0)
evaluates to undefined, which has no effect in JavaScript.
<A
HREF="javascript:void(0)">Click here to do
nothing</A>
The following code creates a hypertext
link that submits a form when the user clicks it.
<A
HREF="javascript:void(document.form.submit())">
Click here to submit</A>
Operator Precedence
The precedence of operators
determines the order they are applied when evaluating an
expression. You can override operator precedence by using
parentheses.
The following table describes the
precedence of operators, from lowest to highest.
Table 3.7
Operator precedence
|
Operator type
|
Individual operators
|
|
comma
|
,
|
|
assignment
|
= += -= *= /= %= <<=
>>= >>>= &= ^= |=
|
|
conditional
|
?:
|
|
logical-or
|
||
|
|
logical-and
|
&&
|
|
bitwise-or
|
|
|
|
bitwise-xor
|
^
|
|
bitwise-and
|
&
|
|
equality
|
== != === !==
|
|
relational
|
< <= > >= in
instanceof
|
|
bitwise shift
|
<< >> >>>
|
|
addition/subtraction
|
+ -
|
|
multiply/divide
|
* / %
|
|
negation/increment
|
! ~ - + ++ -- typeof void delete
|
|
call / create instance
|
() new
|
|
member
|
. []
|
Values, Variables, and Literals
Contents