Consider what happens when you divide 2 into 5. The value 2 divides evenly into 5 twice with a remainder of 1. If you've ever performed long division, the expression would look like this:


            

As you can see, the remainder is indeed 1. The Mod operator returns the remainder. In the expression

Result = 5 Mod 2

the return variable Result is equal to 1. The usefulness of this function will be explored further on Day 16. For now, just keep in mind that this is another arithmetic operator.

Negation (-)

The last of the arithmetic operators is the negation operator. Simply put, this operator changes the sign of a value contained in a variable or creates a negative number. For instance, the expression

Result = -2 * 3

results in assigning the value -6 to the variable Result. Likewise, the following lines of code produce the same result as the preceding line of code:

a = 2
b = 3
Result = -a * b

Notice that you can assign the negation operator to either a variable or a literal number. The negation operator is commonly used when you want to create a negative number or treat a positive number like a negative number.

Arithmetic Operator Precedence

Now that you have seen all the arithmetic operators that VBScript has to offer, you might be wondering how all the operators behave when put together in a single line of code. For instance, is the following line of code

2 * 3 + 6 / 2

equal to 9 or 6? When you combine arithmetic operators in an expression, you need to know the order of precedence of the operators. That is, what operations will the computer execute first as it moves from left to right across the expression? Table 5.1 summarizes the order of precedence for the arithmetic operators.

Notice that multiplication and division are on the same level of precedence. In this case, multiplication and division are executed in left-to-right order when it's their turn in the order of precedence. The expression

2 * 3 + 6 / 2

has three arithmetic operators: multiplication, addition, and division. As you can see in this table, multiplication is the first operation performed in the expression as you move from left to right. Both multiplication and division have the same order of precedence, so they are handled on a first-come, first-served basis. Because the multiplication is first, it gets executed first. As a result, the first operation in the expression is 2 * 3, which equals 6. This reduces the expression to

6 + 6 / 2

That leaves an addition operator and a division operator in the expression. Using Table 5.1, you can see that division has a higher order of precedence than addition does, so the division is handled next. The expression 6 / 2 equals 3, so the expression now becomes

6 + 3

Because only one operator remains, the choice is obvious-the result equals 9. VBScript follows this process of ordering an expression of multiple operators every time. When you are writing code, you must keep this order in mind.

One good way to maintain the order of expressions when writing and maintaining code is to designate subexpressions in parentheses. You can use parentheses freely in expressions, and they ensure that the subexpression will be fully evaluated first before it is evaluated as part of the larger expression. For example, you could write

c = 2 * 3 + 6 / 2

and c would evaluate to 9, as figured previously. You could also code the same expression as

c = (2 * 3) + 6 / 2

or

c = 2 * 3 + (6 / 2)

or even

c = (2 * 3) + (6 / 2)

and the results would still be the same: 9. However, with these statements, particularly the last one, the expression is much easier for a programmer to read and understand.

When using the parentheses approach, you must be aware of how subexpressions are evaluated. If you coded the statement as

c = (2 * 3 + 6) / 2

you get a result of 12 / 2 = 6 stored in c. The subexpression always gets evaluated first, which in turn affects the results of the overall expression. Because the human mind can digest information more easily by breaking it down into smaller pieces, subexpressions will make your code easier to follow and probably less error prone as well.

Comparison Operators

The first set of operators VBScript provides are arithmetic operators. This section discusses the second type: comparison operators. As the name implies, you use comparison operators to compare one or more variables, numbers, constants, or a combination of the three. VBScript has many different types of comparison operators, and each checks for a different comparison condition.

Equality (=)

You use the equality operator to see if a variable, constant, or number is equal to another. It's common to mistake the equality operator for the assignment operator, which is also represented by an equal sign. You use the assignment operator to set a variable equal to another variable, number, string, constant, or other data entity. For example, the statement

a = b

assigns the value contained in b to the variable a.

The equality operator, on the other hand, is used to test whether one value is equal to another. The syntax for the equality operator looks similar to that for the assignment operator:

a = b

where a and b can be variables, constants, or numbers. It is the context in which you use the expression that determines whether it is treated as an assignment or an equality check. Equality is always used in the context of checking a condition. For example, a statement
such as:

if a = b then

is an example of the equality operator because it is a conditional check. As a rule of thumb, you can assume that if a = b appears in a statement by itself, it is an assignment statement. If you see a = b as part of any other expression, it is used in the equality context.

If a does indeed equal b, the expression is true; otherwise, it is false. We have already been using the equality operator a great deal in the guide so far. Refer to Listing 5.5, where you see the following section of code:

If TravelTime = 0 Then
    MsgBox "The speed cannot be calculated because the time is zero. Â
  Please enter a valid time."
Else
    Speed = Distance / TravelTime
    txtSpeed.Value = Speed
End If

This example uses the equality operator to see if the variable TravelTime is equal to 0. If it is, a set of instructions are executed, and if not, another set is similarly executed. You can also use the equality operator to check whether a variable is equal to a constant or even some other variable. You will see the equality operator used extensively throughout the guide and in virtually any program. Likewise, you will also see the = symbol used as an assignment operator, where it actually assigns data to a variable. These are two of the most common operations in programming.

Inequality (<>)

Another important comparison operator is the inequality operator. You use this operator to test whether a variable is not equal to another variable or some data element. The syntax for the inequality operator is

a <> b

where a and b are variables, constants, strings, or numbers. Again, the expression returns True if the condition is indeed true and False if it isn't. For example, you could have taken the following code

If TravelTime = 0 Then
    MsgBox "The speed cannot be calculated because the time is zero.
  Please enter a valid time."
Else
    Speed = Distance / TravelTime
    txtSpeed.Value = Speed
End If

and made the following change, using the inequality operator rather than the equality operator, with the same results:

If TravelTime <> 0 Then
    Speed = Distance / TravelTime
    txtSpeed.Value = Speed
Else
    MsgBox "The speed cannot be calculated because the time is zero.
  Please enter a valid time."
End If

Sometimes, the inequality operator is more convenient and sensible to use than the equality operator. You will see such cases throughout the rest of the guide.

Less Than and Greater Than (< and >)

You might have a condition where you don't care whether a variable is equal to another, but you do want to know whether it is greater than or less than another variable, number, or constant. In such a case, you need the greater-than and less-than operators. The syntax for these two operators is

a > b

and

a < b

where a and b are variables, constants, numbers, or strings, and the result is True if the expression is true. Otherwise, the expression returns False. For an example of its use, consider the following code:

If TravelTime > 0 Then
    Speed = Distance / TravelTime
    txtSpeed.Value = Speed
Else If TravelTime < 0 Then
    MsgBox "You cannot enter a negative value for the time!"
Else If TravelTime = 0 Then
    MsgBox "The time must be greater than zero!"
End If

Here, you see the greater-than, less-than, and equality operators all in use. If the variable TravelTime is greater than zero, a speed can be calculated, but if TravelTime is less than zero or equal to zero, the user must be notified-any such value would not be valid.

You could write the same code in another way if you carefully think about the conditions being satisfied. If a travel time is not greater than zero and not less than zero, you know it must be zero. Even without checking for this value, you can tell that is the only possibility left! You could therefore rewrite the code as

If TravelTime > 0 Then
    Speed = Distance / TravelTime
    txtSpeed.Value = Speed
Else If TravelTime < 0 Then
    MsgBox "You cannot enter a negative value for the time!"
Else
    MsgBox "The time must be greater than zero!"
End If

This code works just as well as the previous code. The first method was used to emphasize the purpose of the equality expression. The first method is also a better approach in some respects, because with the conditions explicitly named, the purpose of each branch of the code is more clearly defined and easier to read and debug. Code that is clearer is usually also easier to maintain and less subject to bugs.

Less Than or Equal To and Greater Than or Equal To (<= and >=)

Sometimes, you also might want to see whether a variable is greater than or equal to some other variable, constant, or number. Perhaps you want to know if it is less than or equal to the entity. Then, you can combine operators to use the less-than-or-equal and greater-than-or-equal operators, <= and >=. The syntax for these operators is

a <= b

and

a >= b

The expression returns True or False, depending on whether the expression is true. Suppose you take the code shown in the previous section and change it to

If TravelTime > 0 Then
    Speed = Distance / TravelTime
    txtSpeed.Value = Speed
Else If TravelTime <= 0 Then
    MsgBox "You cannot enter a negative value or zero for the time!"
End If

This code combines the conditions of a zero time and a negative time into one simple check. Because both cases are invalid, it makes the code simpler to perform one check. It is more useful to the user to know whether a zero or a negative value was entered, but because both are invalid, you might not consider that very important. In any case, these conditional checks can tell you whether a condition is True.

Again in this example, you could write the code to simply use an else as the last condition because you know if a time isn't greater than zero, it must be less than or equal to zero. However, as in the earlier example, the explicit approach helps illustrate the use of the <= operator and also makes clearer code.

Object Equivalence (Is)

The last comparison operator is designed for objects, which are discussed in more detail on Days 8, "Intrinsic HTML Form Controls," through 11, "More ActiveX Controls." For now, consider an object such as a command button that you can place on a Web page. The syntax of the Is operator is

result = object_reference1 Is object_reference2

where object_reference1 and object_reference2 are references to objects and result is either True or False, depending on whether the statement is true.

This operator does not compare one object to another, nor does it compare values. This special operator simply checks to see if the two object references in the expression refer to the same object. Suppose, for example, you have included a command button in your script you have defined as TestButton. You have another variable, myObject, that is set to reference different objects at different points in your program. Assume that a statement has been carried out that assigns the variable myObject to reference this button, such as

Set myObject = TestButton

If the script later carries out the expression

result = myObject Is TestButton

it will return the True in the variable result because TestButton is indeed the same object as that referred to by myObject. If, on the other hand, you were to enter

result = myObject Is SomeOtherTestButton

result would be False because the two objects are not the same.

As you can see from this discussion, there are some special rules for dealing with objects. You must use the Set statement to assign an object's value. And you cannot directly compare two objects with an equal statement, such as

if myObject = TestButton  ' illegal syntax

The sample page objcomp.asp on the CD-ROM that comes with this guide illustrates some of these concepts. You'll learn the nuances of objects in the days ahead. For now, it is just important to realize that among the full range of operators covered today, the Is operator is available for object equivalence checks.

Comparison Operator Precedence

Unlike arithmetic operators, comparison operators do not have a specific order of precedence. They are simply executed as they are found from left to right across an expression. When VBScript encounters an expression such as

If 3 > 5 < 10 Then

VBScript will evaluate the conditions in the order they appear from left to right. In this case, the part of the expression that comes first, 3 > 5, is evaluated first as False. False in VBScript is equivalent to 0, so the expression becomes

If 0 < 10 Then

Because 10 is greater than 0, the expression is True. As a result, the entire expression is True and whatever code follows this if-then expression will be executed. Conditional expressions will be discussed more fully on Day 6, "Controlling the Flow of VBScript Code."

Logical Operators

The last category of operators in VBScript is logical operators. The logical operators might require a more significant amount of understanding to appreciate. In some cases, the way you use logical operators seems to run counter to your intuitive thinking. If you've ever taken a course in logic, you have first-hand experience with this. Because logical operators are such an important part of VBScript, it's important to gain a good understanding, starting with the basics, so that you can use them effectively.

Logical operators use the binary number system to represent information. The part of the binary number system used in this lesson is very simple: Expressions evaluate to True or False, respectively. The logical operators discussed in this section are designed for binary numbers, not decimal numbers. The binary number system counts in units of two rather than ten, so it's quite different from the decimal system. It is beyond the scope of this guide to explore all the details of the binary number system. If you are interested in learning more about the binary system, you can refer to any introductory computer science principles textguide. If you are not familiar with binary numbers, simply remember that True and False are the only values used with logical operators. A logical expression, such as

5 > 3

is a true statement and would return True if evaluated. If you inspect the value of True, you would see that it contains the true indicator of -1. It turns out that -1 is a convenient way to represent True internally in the binary system upon which your computer and VBScript are based. If you need to convince yourself that this is really the representation, you can try a quick test within a Web page script. Simply insert code like the following:

<SCRIPT LANGUAGE="VBScript">
' True condition, this will display "True"
msgbox (3 = 3)
' VBScript integer representation of True condition, this will display "-1"
msgbox cint(3 = 3)
' False condition, this will display "False"
msgbox (3 = 2)
' VBScript integer representation of False condition, this will display "0"
msgbox cint(3 = 2)
</SCRIPT>

As soon as your page is loaded, this script code will be launched. You will see a series of four message boxes. The first two expressions, based on (3 = 3), are true statements, of course. The first message box displays the VBScript text indicator of a true condition, True. The second message box uses the Cint function to obtain the integer equivalent of this condition, which shows up as -1. Similarly, the next two statements display False and 0 because the condition (3 = 2) is false. You can always use the intrinsic VBScript constant True to represent the true condition. Likewise, you can always use the intrinsic constant False to represent the false condition. If you were to display the integer value of the constants, you would see that they are similarly associated with -1 and 0, respectively. With that understanding of how Visual Basic handles true and false conditions, take a look at the suite of logical operators.

Negation (Not)

The first operator is called the negation operator. This operator has the following syntax:

result = Not expression

Table 5.2 shows the result variable in relation to expression.

If you enter the expression

a = Not 1 > 2

where the expression is 1 > 2, the result is stored in the variable a. The value stored in variable a will be True. The expression 1 > 2 is false because 1 is not greater than 2. Not simply flips a false over to true or a true over to false. Because the expression is false, the Not operator makes the result true. As a result, the VBScript value for true, True or -1, will be stored in variable a. If the expression is null, the Not operator will return a null when applied to the expression.

Where might you use the Not operator? It is often used when working with if-then conditionals. Consider, for instance, the following code segment:

If GetZip(City, State, Zip) = False Then
     MsgBox "The zip code could not be determined."
Else
     MsgBox "The zip code is " & Zip
End If

This simple example calls the function GetZip. The arguments for this function are the city, state, and zip code. The function returns a Boolean value that indicates whether the function has succeeded. This return variable is often called a return code. The function loads the variable Zip with the zip code and returns True if it is successful. If the function fails, it returns False. The function could fail, for example, if an invalid state or city was passed as an argument to the function.

The conditional statement checks the return code. If it is true, the function has succeeded and the code proceeds to show the user the zip code. You could use the Not operator instead, in which case the code would look like this:

If Not GetZip(City, State, Zip) Then
     MsgBox "The zip code could not be determined."
Else
     MsgBox "The zip code is " & Zip
End If

The only difference is that you use the Not operator instead of the equality operator. In some cases, this makes the code easier to read. In other cases, such as the following:

GetZipFailure = Not GetZip(City, State, Zip)

the Not operator is necessary. If GetZipFailure is a variable that contains the failure status of the call, Not is the most convenient way to map the return value of the function to the variable. More uses for this operator will become apparent as you see more code examples.

Conjunction (And)

The conjunction operator compares two or more variables in some type of test. The syntax for the conjunction operator is

result = expression1 And expression2

Table 5.3 shows the result variable in relation to expression1 and expression2.

In order to obtain True in the result variable, both expression1 and expression2 must be true. You often use this operator to make sure two or more conditions are true before performing some action. Suppose you have a Web page for making airline reservations. You have several functions in your code: one to get the customer's name and address, one for the origination point, one for the destination, and one for the day he wants to travel. In order to guide the reservation, each function must succeed. If any of them fail, the reservation cannot be made. The following statement is an example of what could appear in a VBScript code segment:

OkayToReserve = _
GetCustomer(Name, Address, Phone) And _
GetDepartureCity(DepartCity) And _
GetDestinationCity(DestinationCity) And _
GetTravelDate(TravelDate)

If the function that gets the destination city from the customer, for example, does not succeed for whatever reason, your program will not accept the reservation.

This example is simple, but you get the point. Each of these functions must return True. If any one of them fails, the variable OkayToReserve will be false. You can then make a simple check to determine whether to make the reservation:

If OkayToReserve = True Then MakeReservation( Name, Address, Phone, _
DepartCity, DestinationCity, TravelDate )

You can use the conjunction operator for a lot of other purposes. As you progress through the guide, you will see more examples of its use.

Disjunction (Or)

Another frequently used logical operator is the disjunction operator. This operator has the same syntax as the conjunction operator:

result = expression1 Or expression2

Table 5.4 shows the result variable in relation to expression1 and expression2.

This operator behaves quite a bit differently from the conjunction operator! In this case, any of the expressions can be true for the result to be true. The result is false only if all the expressions are false. You typically use this operator when you have to make a decision where any of a number of activities could occur, but only one must occur for the operation to proceed. Suppose you want to call a function on your Web page that processes an order for flowers. If you have five varieties of flowers, the customer could order one or more types. You simply want to see if any of them are on order. All it takes to process an order is a request for one type. The following code segment would handle this for you:

If Order1 Or Order2 Or Order3 Or Order4 Or Order5 Then
   OrderFlowers()
End If

In this case, five variables exist that are true or false, depending on whether the user wants to order flowers of that type. If the user wants to order flowers of any type, the script calls the OrderFlowers function. That function can then determine the specifics of the flower order.

Exclusion (Xor)

The exclusion operator is another in the family of logical operators that you can use to make decisions based on the contents of one or more expressions. It checks whether one and only one condition is exclusively true. The syntax of the exclusion operator is

result = expression1 Xor expression2

Table 5.5 shows the result variable in relation to expression1 and expression2.

If you compare Table 5.5 to 5.4, you'll see that these operators differ in only one way. With the Or operator, if either or both expressions are true, the result is true. With the exclusion operator, however, if all the expressions in the statement are the same-that is, all true or false-the result is false. Only when they are different is the result true.

Logical Equivalence (Eqv) and Implication (Imp)

The remaining two logical operators are Eqv and Imp. The equivalence operator checks whether two expressions are bitwise equivalent to each other. The syntax is

result = expression1 Eqv expression2

The Imp operator performs a logical implication on two expressions. The syntax for that operation is

result = expression1 Imp expression2

If you're a very experienced programmer, you know what Imp and Eqv do, and you're probably glad to see them in the VBScript repertoire. However, if you're a beginner, you might be thinking at this moment, "What on earth is bitwise equivalence and logical implication?"

Like all the logical operators covered here, the Imp and Eqv comparisons are performed on a bit-by-bit basis and the results are set on a bit-by-bit basis. For the other operators, the functionality it provides and the expected results are intuitively obvious. For Imp and Eqv, the results are less intuitive. Of course, any expression is ultimately represented in bits on a computer, and to understand these operators, you must think in terms of these bits. Picture a comparison on two numbers, analyzing them each bit-by-bit and setting the result expression bit-by-bit according to the rules in Tables 5.6 and 5.7.

Most types of programs use these operations infrequently, so they are typically the realm of advanced programmers. I do not outline them here in detail. You can refer to any computer science text for more details on the binary numbering system and bitwise operations to gain a full appreciation of how to use Imp and Eqv. It is important to realize that the language does provide the capability to carry such operations in case you sometime need to analyze data at this level.

Logical Operator Precedence

Like arithmetic operators, logical operators have an order of preference, shown in Table 5.8.

Any type of operator is evaluated from left to right in an expression. For an example of logical operator precedence, consider the following code statement:

If a Xor b And c Or d Then

For this example, suppose a is true, b is false, c is false, and d is false. Moving from left to right, you have the operators Xor, And, and Or. Because And gets first precedence, the expression b And c is evaluated first. The result of False And False is False. As a result, the expression becomes

If a Xor False or d Then

Now, moving from left to right, the two operators are Xor and Or. Or is next in the line of precedence, so the next expression up for evaluation is False Or d. Because d is false, False Or False equals False. The expression becomes

If a Xor False Then

Now, Xor is the only operator left. Because a is true, True Xor False is True. As a result, the expression reduces to

If True Then

which means the code that follows the if-then statement will be executed. It is very important to understand the order of precedence when you have more than one expression connected together in a single statement. Make sure you walk through your code and know what it's doing before you turn your attention from this kind of code statement.

Working with Strings

One special operator does not fit in any of the other classes. This operator, called the string concatenation operator, is represented by the & symbol. You have already seen strings at work on Day 4, and you will learn more about them in this section. For complete coverage of how strings work, Day 15, "Extending Your Web Pages with Strings," describes all the essentials of string creation, manipulation, and use. We also cover the string concatenation operator here so that you learn all the operators in the VBScript suite.

String Concatenation (&)

You use the string concatenation operator to merge two strings together. If, for example, one variable holds the string

First_Name = "Buddy"

and the second holds the string

Last_Name = "Bird"

to form a complete name, you would want to concatenate these two strings together. You could accomplish this with the concatenation operator. The syntax for this operator is

result = string1 & string2 & ... & stringn

Note that you can concatenate any number of strings on the same line of code. If you want to concatenate the first and last names, your first instinct would be to enter

Name = First_Name & Last_Name

Oops! If you check the name, you find that the string becomes "BuddyBird". You need to insert a space. No problem-you can simply add the space string right into the expression:

Name = First_Name & " " & Last_Name

Note that you can concatenate strings contained in variables as well as literal strings in one, single expression. Now, if you check the Name variable, the stored result should be

"Buddy Bird"

String Concatenation Using the + Operator

You should know one more thing about string concatenation. As you begin to see examples of VBScript code on the Internet, you might from time to time see strings concatenated using the + operator rather than the & operator. For example, you can build a name with this code:

Name = First_Name + " " + Last_Name

This statement would correctly build the string "Buddy Bird" for you. Although you can indeed use the addition operator to concatenate strings, you're not always guaranteed a correct result because the addition operator is designed for numeric values. It can handle strings, but when strings are mixed with numbers, VBScript can get into an ambiguous state, not knowing exactly how you want to concatenate the values. If, for example, one of the expressions is a number and the other is a string, the + operator gives you an error:

Dim a, b, c
a = 10
b = " Apples"
c = a + b
MsgBox c

When VBScript encounters the expression c = a + b, a type mismatch error will result. You're trying to add a number and a string that cannot be translated into a number. Instead, you should use

Dim a, b, c
a = 10
b = " Apples"
c = a & b
MsgBox c

and you will store "10 Apples" in the variable c. Table 5.9 shows you the rules for whether the + operator concatenates or adds, depending on the subtype of the variable or variables in question.

Notice that you must enclose literal numbers in quotes if you want to treat them as strings when you concatenate them to other strings. Because this is not very convenient and requires extra thought, it's safer and better to use the & operator whenever you're concatenating strings. This helps reduce potential errors in your code-always a wise decision.

You can do a great deal more with strings in VBScript. On Day 15, you will learn even more about strings, along with many supporting functions that let you handle strings in flexible, powerful ways. Until then, I'll just show you string concatenation and save the more advanced concepts for later.

Operator Precedence

Now you have seen all the operators VBScript has to offer. For each type of operator-arithmetic, comparison, and logical-you have seen the order of precedence. What happens when operators from different categories are all combined in the same statement? What is executed first?

VBScript first attends to the arithmetic operators, followed by the string concatenation operator, the comparison operators, and the logical operators, as summarized in Table 5.10.

When an expression has more than one operation, each part of that expression is evaluated in this order from left to right across the expression.

If you want to force VBScript to target a specific part of a code statement, you can use parentheses as discussed earlier today. For example, suppose you have the statement

x = 6 * 5 / 2 - 5 + r

in your code. In normal circumstances, the variable x would be expressed as

x = 10 + r

where the expressions would be evaluated in the following order:

x = 6 * 5 / 2 - 5 + r
  =    30 / 2 - 5 + r
  =        15 - 5 + r
  =            10 + r
x = 10 + r

If r is 5, the answer is

x = 10 + 5
x = 15

Suppose you wanted to treat the expression 5 + r as a single entity. You would simply put parentheses around 5 + r:

x = 6 * 5 / 2 - ( 5 + r )

which would result in the following order:

x = 6 * 5 / 2 - ( 5 + r )
  =    30 / 2 - ( 5 + r )
  =        15 - ( 5 + r )
  =
x = 15 - ( 5 + r )

If r is 5, the answer is

x = 15 - ( 5 + 5 )
x = 15 - 10
x = 5

The difference in results is due to the parentheses around part of the expression, which can have a dramatic impact on the results. For another example, suppose you had to calculate the sales tax on a customer's order where you had the cost of two items. Call the cost of the first item x and the cost of the second item y, and say the sales tax is 6 percent of the total cost. You could write this expression as

tax = x + y * 0.06

but it would be incorrect. If you follow the order of precedence, y * 0.06 would be evaluated, and the result would be added to x. This is not what you want. Rather, you first want x and y to be added and then multiplied by 0.06. The order of precedence is getting in your way, preventing you from obtaining a correct result. In this case, you have to force VBScript to do the addition first and then the multiplication. To do this, you simply enter the
expression as

tax = (x + y) * 0.06

which will give you the correct result. Because the expression x + y is in parentheses, VBScript will evaluate it first and then multiply the total cost by the sales tax. The order of precedence is a very important part of handling expressions.

Summary

Today's lesson presents you with the entire suite of VBScript operators. Operators are the workhorses for variables; they put variables to work by making decisions and changing their contents. A fundamental knowledge of operators is necessary in understanding VBScript from top to bottom.

Operators fit into three separate categories: arithmetic operators, comparison operators, and logical operators. Each of these categories has a special use in a VBScript program. Today you have learned about all the operators in these three categories and saw examples of how to use each of the operators in your programs. You have also seen how operators can work together to accomplish a result. Operators are executed in a specific order when they are combined. Programmers must take this order into account when they write code. Today's lesson clearly lays out this order of precedence so that you know what to expect when using the operators presented today.

Today you have been introduced to concepts that will be addressed more thoroughly in upcoming days. As you venture deeper into the realm of VBScript programming, each day will build on the previous. Carefully consider the quiz questions because they will help prepare you for the exciting lessons to come.

Q&A

Q	What are operators?
A	Operators are symbols used in VBScript that perform some specific task. Operators come in three varieties: arithmetic, comparison, and logical. Arithmetic operators handle math operations such as addition and multiplication. Comparison operators help in comparing one variable to another. Logical operators are used in making decisions based on expressions that are either true or false.
Q	What do operators operate on?
A	Operators can operate on variables, literal numbers, constants, or entire expressions.
Q	Why are operators important?
A	Operators are important to programmers because they are used to make decisions, assign data to variables, and control the flow of programs.
Q	Are some operators more important than others?
A	VBScript ranks the operators in a specific order, called the order of precedence. The order of precedence helps determine how a code statement is executed when it has more than one operator.

Workshop

Design a Web page that asks the user for a series of values. Store those values in variables and write code that exercises every one of the operators discussed today. Which ones are you the most familiar with? Which ones do you anticipate using the most in your Web pages?

Quiz

1. Write a program that converts feet to inches. Hint: There are 12 inches in a foot.
2. Write a program that sells concert tickets to your customers. Get from the customer her name, how many tickets she wants, and whether or not she wants front-row tickets. Use the following formula in calculating the cost: Ticket cost equals $20.00 plus $4.00 for front row tickets plus a 3% commission. Add 8% sales tax to the total cost of the ticket plus the commission.
3. Determine the result of the following expressions using the order-of-
   precedence rules:
   a.    5 * 9 - 3 ^ 2
   b.     (72 - 3) / 3 Mod 3
   c.     7 + 2 - 5 * 2
   d.     True Or False And True
   e.     False Or Not True