In JScript, a simple expression is any part of a program statement that can be interpreted as a single value. JScript allows you to create complex expressions by combining simple expressions using one or more operators. JScript also supports several types of operators: the assignment operators, comparison operators, calculation operators, increment and decrement operators, and logical operators. In this section, you'll find out how to use these operators effectively in your scripts.

Earlier, we used the assignment operator (=) in a variable
definition. The following statement declares a variable and assigns the
value *17*:

var tax = 17; |

In the upcoming section "Increment and Decrement Operators," you'll find out how to combine the assignment operator with other operators (as in +=).

The *if* statement uses comparison operators (for example, to
check two values), which return a Boolean value (*true* or
*false*). The JScript comparison operators are listed in Table
5-2.

**Table 5-2** *Comparison Operators*

Operator | Description |
---|---|

== | Equal to |

!= | Not equal to |

>= | Greater than or equal to |

<= | Less than or equal to |

< | Less than |

> | Greater than |

The following statement uses a comparison operator:

if (tax == 17) flag = 1; |

If the variable *tax* is equal to *17*, the variable
*flag* is set to *1.*

NOTE

The operators = = and != sometimes cause an automatic type conversion. If you want to suppress automatic type conversion, you must write the operators as = = = and ! = =.

The simplest calculation operator is the + operator (which we used earlier). The following statements use the calculation operators +, -, *, and /:

var price = 10 + 1; end_price = net * (1.0 + tax); net = price - discount; var res = 100 / 25; |

JScript follows the commonly used rules for evaluating expressions with several operators. (The operators * and / have higher priority than + and -.) But you can use parentheses to group subexpressions, which are evaluated first. The JScript calculation operators are listed in Table 5-3.

**Table 5-3** *Calculation Operators*

Operator |
Description |
Example |
---|---|---|

+ | Addition | a = a + b |

- | Subtraction | a = a - b |

* | Multiplication | a = a * b |

/ | Division | a = a / b |

% | Modulo division | a = a % b |

You can combine these operators with the assignment operator = (as
you can in the C programming language). It is valid, for example, to
write *+=* (as you'll see in upcoming samples).

NOTE

You must use the + operator for string concatenation in JScript (as invar name = "Günter" + " Born";). This requirement is different from VBScript, in which it's better to use the & operator for concatenation (even though the + operator works). JScript doesn't have a built-in exponentiation operator, such as the VBScript ^ operator. Instead, JScript provides this functionality through theMath.pow(base, exponent)method.

To add or subtract 1 from a variable, you can use the increment operator (++) or the decrement operator (--), respectively; Table 5-4 lists these and other JScript incrementation operators.

**Table 5-4** *Increment and Decrement Operators*

Operator |
Description |
---|---|

++i, i++ | Increments i by 1 |

--i, i-- | Decrements i by 1 |

+= | Addition incrementation |

-= | Subtraction incrementation |

*= | Multiplication incrementation |

/= | Division incrementation |

%= | Modulo division incrementation |

The operators in Table 5-4 are unfamiliar to many Pascal and Basic
programmers but are much loved by C programmers because they save you
time when you write code. I recommend, however, that you use the more
familiar operators to assign and add a value (as in *i = i + 1*).
The following two columns contain equivalent code; the statement in the
left column uses the increment or decrement operator, and the statement
or statements in the right column use the standard calculation
operators:

a += b; | a = a + b; |

a -= b; | a = a - b; |

a *= b; | a = a * b; |

a /= b; | a = a / b; |

a %= b; | a = a % b; |

a = ++i; | i = i + 1; a = i; |

a = i++ | a = i; i = i + 1; |

a = --i | i = i - 1; a = i; |

a = i-- | a = i; i = i - 1; |

The increment and decrement operators also come in handy within loops.

NOTE

The position of the ++ or -- operator determines when the value is incremented or decremented. In the statementa = ++b;,the ++ operator precedes a variable, which means that the variable is incremented before the rest of the expression is evaluated. In this case,bis incremented and then its value is assigned to the variablea. In the statementa = b++;,the increment operator follows the variable, which means that the expression is evaluated before the increment operator is applied. In the second example, the value ofbis assigned toa, and then the value ofbis incremented.

Sometimes you need logical operators (in bit operations, for example). Table 5-5 lists the logical operators that JScript supports.

**Table 5-5** *Logical Operators*

Operator |
Description |
---|---|

&& | Logical And |

|| | Logical Or |

! | Logical Not |

>> | Bits shift right |

<< | Bits shift left |

>>> | Unsigned bits shift right |

& | Bitwise And |

| | Bitwise Or |

~ | Bitwise Not |

^ | Bitwise exclusive Or (Xor) |

NOTE

See Chapter 4 for a discussion of how the bit operatorsAnd,Or, andXorwork in VBScript.

If a statement contains several operators that aren't set in parentheses, JScript follows a predefined precedence list. The operator precedences are shown in Table 5-6, listed in ascending order.

**Table 5-6** *Operator Precedence in JScript*

Operator | Symbols |
---|---|

Comma | , |

Assignment | = += _= *= /= %= <<= >>= >>>= &= ^= |= |

Conditional | ? : |

Logical Or |
|| |

Logical And |
&& |

Bitwise Or |
| |

Bitwise Xor |
^ |

Bitwise And |
& |

Equal to, not equal to | == != === !== |

Relational | < <= > >= |

Bitwise shift | << >> >>> |

Addition, subtraction, string concatenation | + - + |

Multiplication, division | * / % |

Negation, increment | ! ~ - ++ -- |

Call, member | () [] . |