This chapter will cover numerous VBScript topics. It opens with a discussion of VBScript statements and their syntax requirements and then describes how to correct and fix these types of errors. Statements that create VBScript comments and define constants and variables are also reviewed. In addition, the chapter will provide information regarding the use of built-in VBScript constants. Various topics related to variables, including variable naming rules and ways to limit variables' scope, will also be discussed.

VBScript Statements

VBScript is made up of a number of programming statements, each of which performs a specific function. Table 2.1 provides a list of the statements that make up the VBScript programming language. This chapter will cover the VBScript statements that deal with VBScript comments, constants, and variables.

VBScript Statement Syntax

Every VBScript statement has a unique syntax that must be carefully followed in order to perform a specific task when VBScripts execute. The chapters in this book will outline the specific syntax requirements of individual VBScript statements the first time that the statements are formally introduced and will provide examples of their use.

In addition to the syntax requirements specific to individual VBScript statements, there are a number of general rules that you must follow when writing your VBScript. These rules are outlined below.

• By default, all VBScript statements must be placed on one line.
• You may place two or more statements on a single line by ending each statement with the colon (:) character.
• You may spread a single statement over multiple lines by adding the underscore (_) character, known as the continuation character, to the end of each line.
• By default, VBScript is not case sensitive, meaning that different uses of case in the spelling of constants, variables, subroutine names, and function names are permitted.
• Strict enforcement of case sensitivity can be mandated by adding the Option Explicit statement to the beginning of a VBScript.

Syntax Errors

There are several types of errors that can occur during the execution of a VBScript. These errors include logical errors, in which the script produces unexpected results because of faulty logic on the part of the programmer, and run-time errors, which occur when a script attempts to do something that it cannot do. For example, run-time errors occur when scripts attempt to access objects that do not exist or are not available, which can be the case for both local and network disk drives. The third category of error is the syntax error, which occurs when programmers fail to use the proper syntax in the formulating of a VBScript statement. Unlike run-time errors, which occur during the execution of the script, syntax errors are flagged by the scripting engine during interpretation, thus preventing the script from even starting.

Run-time errors can be difficult to track down and find because they may be hidden in a seldom used portion of code within the script. On the other hand, a syntax error anywhere in a script will prevent its execution. Therefore, syntax errors should be easily discovered and fixed during initial script development and testing. For example, the following statement will produce the error shown in Figure 2.1 when run by the WSH.

Figure 2.1: Failure to follow a VBScript statement's syntax results in an error that terminates the script's execution

MsgBox "Text must be enclosed within a pair of double quotation marks"

MsgBox() is a built-in VBScript function that can be used to display text in a pop-up dialog box. It requires that the text to be displayed must be enclosed within a matching pair of double quotation marks. In the previous example, the second double quotation mark is missing.

Table 2.2 provides a list of VBScript errors that can occur as a result of not following the syntax rules for VBScript statements. An error number is assigned to every VBScript syntax error. Depending on the host environment in which VBScripts run, these error messages may be reported in either a hexadecimal or decimal format. Table 2.2 provides both the hexadecimal and decimal error numbers associated with each syntax error message.

Syntax errors are generally relatively easy to correct. The error messages that appear when syntax errors are discovered identify the error as well as the line number where the error occurred. Usually a quick review of the syntax for the offending statement is all that is required to identify and correct the error.

Displaying Syntax Errors within Internet Explorer

The WSH always displays errors when they occur. However, by default, Internet Explorer suppresses the display of error messages. This works well since most users will not understand the error messages or be able to do anything about them anyway. Instead, Internet Explorer displays a small yellow icon in the bottom left-hand corner of the browser's status bar whenever an error occurs.

For example, the following HTML page contains the same type of VBScript error as the previous WSH example did. If you save and run it, you will see that Internet Explorer flags the error as demonstrated in Figure 2.2.

Figure 2.2: Internet Explorer automatically suppresses the display of VBScript error messages

Script 2.2 - VBScript syntax error example

To view the error message that caused Internet Explorer to display the yellow icon, double-click on the icon and the error will be displayed as demonstrated in Figure 2.3.

Figure 2.3: Examining a typical script error within Internet Explorer

Documenting VBScripts with Comments

Comments provide the ability to make scripts self-documenting, making them easier for others to support. You can add comments to VBScripts using the Rem statement. The syntax for the Rem statement is shown below.

Rem comments

For example, the Rem statement can be used as demonstrated below.

Rem The VBScript MsgBox() function displays text messages MsgBox "Greetings!"

Alternatively, you can substitute the single quotation mark (‘) character for the Rem keyword as shown below.

' The VBScript MsgBox() function displays text messages MsgBox "Greetings!"

Comments can also be added to the end of a VBScript statement. In order to use the Rem statement to add the comment to the end of a VBScript statement, you must first precede it with a colon, as demonstrated below.

MsgBox "Greetings!" : Rem The VBScript MsgBox() function displays text messages

However, if you use the ‘ character in place of the Rem keyword, you can omit the colon, as shown below.

MsgBox "Greetings!" ' The VBScript MsgBox() function displays text messages

Another good use of comments is in the creation of a script template, as demonstrated below.

'************************************************************************* 'Script Name: ScriptName.vbs 'Author: Author Name 'Created: mm/dd/yyyy 'Description: Place a brief description of the script here '************************************************************************* 'Initialization Section 'Main Processing Section 'Procedure Section

You will see this template used to document all the WSH scripts that appear in the project sections of this book. The first part of the template provides a place for recording information about the script. The Initialization Section will contain VBScript statements that globally affect the entire script or that define constants, variables, arrays, and objects. The Main Processing Section will contain the VBScript statements that control the overall execution of the script, and the Procedure Section will be used to store all of the procedures that make up the script.

Only Internet Explorer and Internet Explorer compatible browsers are able to run VBScripts. Problems will therefore occur when visitors with non-Internet Explorer compatible browsers attempt to access Web pages that contain embedded VBScripts, resulting in the display of the text of the VBScripts statements as if they were part of the Web page's content. The VBScript statements are displayed as text because browsers that do not recognize or support VBScript to not know what else to do with the VBScript statements.

This undesirable behavior can be avoided by simply hiding VBScript statements from non-Internet Explorer compatible browsers. This trick is achieved using the HTML and –> comment tags along with the VBScript comment statement, as demonstrated below.

Note that the HTML comment tags have been inserted immediately after the first tag. All browsers, even those that do not support VBScript, know not to display text contained in the tags. Browsers that support VBScript will process the VBScript and ignore the first HTML comment. They will also ignore the VBScript comment, thus hiding the last HTML comment. On the other hand, browsers that do not support VBScript will ignore all the VBScript statements between the opening and closing HTML comment tags.

Storing and Retrieving Data from Memory

Like any programming language, VBScript needs to be able to store and retrieve data from memory as it executes. In support of this requirement, VBScript provides three statements that can be used to define constants, variables, and arrays. These statements are outlined in Table 2.3.

Using Constants

A constant is a value that does not change during the execution of a script. If a script has a known value that will never need to be changed during its execution, it can be stored as a constant. An example of a constant is the value of pi. Constants can be used in two different ways within VBScripts. First, you can define your own custom constants. Second, you can reference built-in VBScript run-time constants.

You cannot change the value assigned to a constant once it has been defined. This protects constants and prevents their accidental modification. Any attempt to change the value of a constant results in an "Illegal assignment xxxxxxxx" error, where xxxxxxxx is the name of the constant that the script attempted to modify.

Defining Constants

Constants are defined using the Const statement, which has the following syntax:

[Public | Private] Const cCONSTANT = expression

Public and Private are optional keywords. Public makes the constant available throughout the entire script. Private limits the ability to access a constant to the procedures where it is defined. cCONSTANT is the name assigned to the constant, and expression is the value to be assigned.

The following example demonstrates how to define a constant and assign it a numeric value.

Const cTOTAL_VALUE = 1000

To define a string, you must place the value assigned to the constant within quotes, as demonstrated below.

Const cCOMPANY_NAME = "XYZ Inc."

Similarly, to define a date, place the value inside a pair of matching pound signs, as shown below.

Const cPROJECT_DEADLINE = #03-30-03#

Constants can be used for a variety of purposes. For example, one use of constants is to establish a common title bar message in pop-up dialog boxes displayed by your scripts, as demonstrated below.

Const cTITLEBAR_MSG = "Data Collection Utility" MsgBox "Click on OK to continue.", , cTITLEBAR_MSG MsgBox "Click on OK to post saved data.", , cTITLEBAR_MSG

When executed, the previous example displays the pop-up dialog boxes shown in Figures 2.4 and 2.5.

Figure 2.4: Creating a standard title bar message using a constant

Figure 2.5: Using a constant instead of hard coding data to make scripts easier to maintain

Referencing VBScript Run-Time Constants

VBScript supplies programmers with a large collection of predefined constants. By adding references to these constants within your scripts, you can save time and simplify your code. For example, the following statement uses the vbOkCancel MsgBox() constant to display a pop-up dialog box that displays the OK and Cancel buttons.

MsgBox "Do you wish to continue?", vbOkCancel

The MsgBox() function is a built-in VBScript function that is used to display messages in pop-up dialog boxes. vbOkCancel is just one of a number of constants that you can use to specify the appearance of your pop-up dialog boxes. For more information on the constants associated with the MsgBox() function, refer to Chapter 6.

VBScript also provides an extensive collection of constants that reference dates and times. Table 2.4 displays a list of these constants.

The date and time constants shown in Table 2.4 can be used as demonstrated below.

TodaysDate = Weekday(Date()) If TodaysDate = vbMonday then MsgBox "Please reset time clocks."

In this example, a pop-up dialog box is displayed only if the script is executed on a Monday. Another example of built-in constants is VBScript's collection of string constants, shown in Table 2.5.

You can use string constants to format script output, as demonstrated in the following example.

Const cTITLEBAR_MSG = "VBScript String Constant Example" MsgBox "This example demonstrates how to use VBScript" & vbCrLf & _ "string constants to format text output." & vbCrLf & vbCrLf & _ vbTab & "End of Example", , cTITLEBAR_MSG

As you can see from the previous example, the vbCrLf constant can be used to execute a carriage return and a line feed while the vbTab constant executes a tab operation.

Figure 2.6 shows the pop-up dialog box that is displayed by the previous code.

Figure 2.6: Using VBScript string constants to exercise control over the output displayed in pop-up dialog boxes

Creating Variables

While constants are certainly the right mechanism for storing data that will not change during a script's execution, in most cases, you will find that you need to manipulate the data used by your scripts. In this case, the data should be defined as a variable.

VBScript supports a single type of variable known as a variant. However, variants are flexible and can be used to store many different types of data, as listed in Table 2.6.

Variants recognize the type of data assigned to them and behave accordingly. However, you can exercise some control over how VBScript views the data that you assign to variables. For example, you can define a numeric value to a variable as follows:

intTotalCount = 100

To assign a string to a variable, enclose it inside a matching pair of quotation marks, as demonstrated in both of the following examples.

strName = "William Ford" Age = "4"

To explicitly assign data to a variable, place the data inside a pair of matching pound signs, as demonstrated below.

dtmDateOfBirth = #03/24/99#

You can use built-in VBScript functions to convert data from one type to another, as demonstrated below.

varDateOfBirth = #03/24/99# varDateOfBirth = CStr(varDateOfBirth)

In this example, the type of value stored by varDateOfBirth is converted from a date to a string.

Variable Naming Rules

VBScript has a number of rules that must be followed when assigning names to variables. These rules include:

• Variables must be unique within their scope.
• Variable names must be less than 256 characters long.
• Variable names must begin with an alphabetic character.
• Variable names cannot contain spaces.
• Variable names can only consist of alphabetic and numeric characters and the _ character.
• Variable names cannot consist of VBScript reserved words.

Variable names are not case sensitive, meaning the capitalization does not affect the way that VBScript sees a variable's name. Therefore, VBScript sees all three of the following variable names as the same:

strUnitColor strUNITCOLOR strunitcolor

Mixing capitalization styles makes for confusing code and is highly discouraged. Stick with a consistent case throughout your VBScripts and develop a variable naming scheme. For example, many programmers use descriptive words or abbreviations as components of variable names. In addition, capitalizing the first letter of each word or abbreviation helps to make variable names more readable. Another good technique to use when naming variables is to append a three-character prefix identifying the type of data stored in a variable. This is known as Hungarian Notation. Table 2.7 lists prefixes commonly used to name variables.

The following examples demonstrate the use of variables that follow the conventions stated above.

strUserName = "Molly Ford" intUnitCount = 100

Defining Variables

VBScript allows variables to be defined dynamically or formally. To dynamically define a variable, you simply begin using it, as demonstrated below.

intTotalCount = intTotalCount + 1

Dynamically creating variables is considered to be bad form. Formal variable declaration is strongly preferred. Formal variable declaration makes scripts easier to read and support. VBScript provides the Dim statement as a means of formally defining a variable. The syntax of this statement is shown below.

Dim variablename

Variablename is the name of the variable being defined. For example, the following example defines a new variable called intTotalCount and then begins working with the variable.

Dim intTotalCount intTotalCount = intTotalCount + 1

To reduce the number of lines of code required to define variables, VBScript permits you to define more than one variable at a time using a single Dim statement, as demonstrated below.

Dim intTotalCount, intAvgCount, intFinalCount

Even if you formally define all your variables, there is always the possibility that you may mistype the name of a variable somewhere in your script. When this happens, VBScript simply sees the mistyped variable as a new variable. VBScript allocates memory to it, assigns it a value of empty, and continues running.

For example, take a look at the following script.

Dim intUnitCount intUnitCount = 5 intUnitCount = intUnitCoun + 1 MsgBox intUnitCount

In this example, a variable called intUnitCount is defined. It is then assigned a value of 5. The third statement was supposed to add 1 to this value, but a typo was made, creating a new variable called intUnitCoun. As a result, when the value of intUnitCount is displayed, it shows a value of 1 instead of 6. This is because VBScript assigned a value of 0 to intUnitCoun. To prevent this from happening, you can add the Option Explicit statement to the beginning of your VBScripts. This statement forces the explicit declaration of all variables within the script. For example, if you modify the previous example as shown below and run it, you'll see the error shown in Figure 2.7 appear.

Figure 2.7: The Option Explicit statement flags all undefined variables, allowing you to fix them during script development

Option Explicit Dim intUnitCount intUnitCount = 5 intUnitCount = intUnitCoun + 1 MsgBox intUnitCount

Variable Scope and Lifetime

Variable scope refers to the locations within a script where a variable can be referenced. Lifetime refers to the period of time that a variable exists. Any variables defined at the beginning of a script have a global scope, meaning that they can be accessed by any location within the script. In addition, they exist for as long as the script executes.

A variable with a local scope is one that is defined within a procedure. A procedure is a collection of statements that are called and processed as a unit. VBScript supports two types of procedures, subroutines and functions. Procedures are covered in detail in Chapter 4. Variables defined within procedures cannot be accessed from outside of the procedure. In addition, the variable's lifetime is limited to the period of time that the procedure executes.

Other Sources of Data

So far, all the examples that you have seen in this chapter have assumed that any data that the script will need to work with will be hard coded within the script. In reality, scripts are seldom written this way. Instead, data is collected for processing from numerous sources. These sources include:

• The InputBox() function. This function provides the ability to display a pop-up dialog box that displays an input text field, which the user can use to provide input data to the script. This function is covered in Chapter 6.
• Data read from input files. Chapter 17, "Using Configuration Files to Control Script Execution," demonstrates how to collect script input from files.
• Data read from the Windows registry. Chapter 22, "Developing the Setup Script," demonstrates the techniques involved in using the registry as a data source.
• Data passed to the script as arguments. Chapter 7, "VBScript Objects," describes the process involved in setting up a script to accept arguments passed to it at run time.

Using Operators to Manipulate Variables

To assign a value to a variable or to change the value assigned to a variable, you simply need to assign it a value using the equal sign (=) as follows.

intUnitCount = 10

Using the equal sign in conjunction with the VBScript arithmetic operators listed in Table 2.8, you can modify the values assigned to variables in a variety of ways. For example, the following script defines a variable named intUnitCount, assigns it an initial value of 10, and then proceeds to change its assigned value several times.

Dim intUnitCount intUnitCount = 9 'intUnitCount = 9 intUnitCount = intUnitCount + 1 'intUnitCount = 10 intUnitCount = intUnitCount * 10 'intUnitCount = 100 intUnitCount = intUnitCount / 2 'intUnitCount = 50 intUnitCount = intUnitCount / 2 + 1 * 5 'intUnitCount = 30 MsgBox "intUnitCount = " & intUnitCount

When executed, this script displays the results shown in Figure 2.8.

Figure 2.8: Using VBScript operators to manipulate the value assigned to a variable

When an expression consists of more than one calculation, VBScript resolves the value of the expression by performing calculations based on a strict order of precedence. Exponentiation is performed first. Then negation occurs, followed by multiplication and division and so on. Table 2.9 outlines VBScript's order of precedence.

You can alter the order in which VBScript performs calculations when resolving an expression by enclosing parts of the expression inside parentheses. For example, examine the following expression:

intUnitCount = 10 intUnitCount = intUnitCount / 2 + 1 * 5

When resolving this expression, VBScript begins by dividing 10 by 2, getting a result of 5. Next it multiplies 1 by 5, getting a result of 5. Finally, it adds 5 plus 5, getting a final result of 10. Now look at how adding parentheses to the expression changes the results produced when VBScript resolves the value of the expression.

intUnitCount = 10 intUnitCount = ((intUnitCount / 2) + 1) * 5

In the case of this example, VBScript first divides 10 by 2, getting 5. It then adds 1 to 5, getting 6. Finally it multiplies 5 by 6 for a final result of 30.

VBScript Reserved Words

Like all programming languages, VBScript sets aside a collection of words, called reserved words, for its own use. You are not permitted to use these words as variable, procedure, constant, or other type or identifier names. When used, these words must be applied exactly as intended by VBScript, as outlined in its documentation. A list of VBScript's reserved words is displayed in Table 2.10.

Summary

This chapter reviewed VBScript syntax errors and provided examples of how to identify and correct them. The chapter provided a complete list of VBScript language statements and provided coverage of the statements that define comments, constants, and variables. Also discussed was how to store data in and reference constants and variables. This discussion included a look at built-in VBScript constants and ways to limit the scope of VBScript variables.

Chapter 3 Conditional Logic and Iterative Structures