If you've worked through the first three days, you should have a pretty good feel for what VBScript is and how it's used in a Web page to enhance its capabilities. Today begins a series of lessons that will teach you how to write VBScript code. Today, I will teach you how to create and use variables. Variables are necessary to create useful code with VBScript. You will learn how a variable is created, what can be stored within it, and how long a variable can remain in existence once you've created it. Variables are a fundamental part of any programming language, and this lesson will teach you everything you need to know about them.
I begin by explaining to you what a variable is, and then I show you how to create one. You will also learn what a variable can store, as well as how long a variable remains in existence. Then you will work with collections of variables, called arrays, which will round out your exposure to variables in VBScript. After today, you will be well versed in this fundamental concept, and you'll be ready to begin exploring more of the fundamentals of this exciting, new language.
When users interact with computers, they usually get to some point where the computer asks them for information. That information is stored or manipulated by the computer in some way. Suppose, for example, that you want to keep a record of whether a user has clicked a button on your Web page. To keep track of this, you need to be able to store the indicator in the computer's memory so that whenever you want to see if the user has clicked on the button, you can simply check the indicator. Perhaps you want to store the number of times the user has clicked the button. In that case, you would want to store a value in memory. In any case, you need a "container" in which to store information. Programmers commonly call these containers variables.
A variable is a virtual container in the computer's memory that's used to hold information. In concept, it is much the same as a notepad. You can jot down information on the page of a notepad and return to that specific page later to remember what you wrote or modify the information. A computer program can store information in a variable and then access that information later by referring to the variable's name.
If you've ever done any programming using a language such as Visual Basic, Fortran, C, or C++, or if you've ever taken an algebra or a math class in school, you should already be somewhat familiar with variables. In most programming languages, when you create a variable, you have to tell the computer what kind of information you are going to store in it. Because some computer languages aren't very smart or don't want to risk making the wrong assumptions for you, they need to know exactly what kind of information you'd like to store. It's not enough to say, "I don't know…I just want to put stuff in this variable!" Usually, you have to say, "I want to store numbers in this variable," or "I want to store text." This means that you usually have to know ahead of time what you're going to store when you write the program. If you want to use a variable to store a person's age, for instance, you would probably first create a variable that stores numbers.
Fortunately, VBScript is very flexible about the type of information you can store. What's even better, the language is "smart" enough to let you store in the variable almost anything you want without telling it the kind of information ahead of time. There are, of course, limits to what and how much you can store (you can't store the Library of Congress in a variable because you'd run out of space), but VBScript is capable of letting you store a variety of types of information. When you create a variable in VBScript, you can assign to it numbers with or without decimal points, text, dates and times, and even objects such as ActiveX controls, which are discussed on Day 10, "An Introduction to Objects and ActiveX Controls," and Day 11, "More ActiveX Controls."
An object, in the context used in this book, is an entity that provides specialized function to a program or Web page. You can easily manipulate object behavior by setting well-defined characteristics of the object called properties. You can also cause the object to take specific actions by calling to action specific object orders called methods. By using an object's properties and methods, you can benefit from all the capabilities an object provides without having to worry about the internal rules of how the object itself works.
When you create a variable, you have to give it a name. That way, when you need to find out what's contained in the variable, you use its name to let the computer know which variable you are referring to. You have two ways to create a variable. The first way, called the explicit method, is where you use the Dim keyword to tell VBScript you are about to create a variable. You then follow this keyword with the name of the variable. If, for example, you want to create a variable called Quantity, you would enter
Dim Quantity
and the variable will then exist. It's that simple! If you want to create more than one variable, you can put several on the same line and separate them by commas, such as
Dim X, Y, Z
The second way to create a variable is called the implicit method. In this case, you don't need to use the Dim statement to create a variable. You can just start using it in your code and VBScript creates it automatically. If, for example, you want to store the quantity of an item the user is ordering, you can simply enter
Quantity = 10
using the implicit method. You don't have to create the variable explicitly using a Dim statement.
If you take no special steps, you can freely intermix the implicit and explicit methods of declaring variables. When you want to, you can choose to set aside a named storage space before you use it by giving it a name in advance through the Dim statement. On the other hand, you can also just rely on the fact that when you refer to something by name in a statement and space hasn't yet been reserved for storing that variable, it will be created for you on-the-fly.
This method of intermixing implicit and explicit declarations can lead to programs that are confusing to follow, to say the least. Fortunately, VBScript gives you a way to force a consistent explicit declaration approach. To make the explicit method a requirement and prevent the implicit allocation of names, you must place the command
Option Explicit
in the first line of the first code in your HTML document, as shown in the following segment:
<SCRIPT LANGUAGE="VBScript">
<!--
Option Explicit
[the rest of your code]
-->
</SCRIPT>
| Note |
With the beta Internet Explorer, Option Explicit was not yet fully implemented and had to be placed in the first line next to the HTML comment tag to be included without errors. The beta implementation of Option Explicit did not always explicitly force variable declaration as specified. In some samples you may see, Option Explicit is placed next to the comment tag to prevent errors with early versions. In the final version of Internet Explorer, however, Option Explicit is fully implemented and should appear on its own line. |
The Option Explicit statement therefore makes explicit declarations a requirement, and you will have to define every variable with a declaration such as Dim. With Option Explicit, if you haven't defined the variable before you use it, you can't use it! This means you need to enter the command
Dim Quantity
before you enter
Quantity = 10
In the explicit method, if you assign Quantity with a value of 10 before creating it, you will get an error.
You might be wondering why you'd use the explicit method when you can just start using variables. This is certainly more convenient while you are writing the code-that is, until you spell a variable wrong. What will happen? VBScript will go ahead and create another variable based on your misspelling, and you will not get the correct result. Consider, for example, the following code segment:
<SCRIPT LANGUAGE="VBScript">
<!--
Quantity = 2
Quantity = Quantity + 3
-->
</SCRIPT>
You would expect the result to be 5, right? And it would be. Suppose you misspelled Quantity in the second line of code:
<SCRIPT LANGUAGE="VBScript">
<!--
Quantity = 2
Quantity = Quantite + 3
-->
</SCRIPT>
In this case, the variable Quantite would be created on-the-fly, and because it's first created, it would have a value of 0. The result variable Quantity, then, would wind up being 3, not 5. If, on the other hand, you were using the explicit method of creating variables, you would enter the code as
<SCRIPT LANGUAGE="VBScript">
<!--
Option Explicit
Quantity = 2
Quantity = Quantite + 3
-->
</SCRIPT>
which would give you a run-time error if you spelled Quantity wrong because you had not declared it first. The run-time error that results from using Option Explicit typically makes it very clear that there is a problem and leads you right away to correcting the error. On the other hand, if you didn't use Option Explicit and therefore didn't receive the run-time error, you have a much more subtle problem. You might not even notice the incorrect result, and even if you did, it would be more difficult to immediately target the source of the problem.
The other reasons that the explicit method is better are discussed later today. Almost any seasoned programmer would recommend that you use the explicit method exclusively.
When you create a variable, you must think of a name for the variable. In most cases, the name you assign to the variable makes it easy for you to recall what the variable is used for. For example, a variable named Age is much easier to recognize than a variable named X.
VBScript lets you be quite creative when you name variables, but you can't name them just anything; you have to follow a few naming rules. The first rule is that the name must begin with a letter. A variable name of 1ToMany, for example, is not allowed. Second, the variable name cannot contain a period or space. A variable named Customer Name is illegal and will produce an error. You can't use a period either because a period is used to reference properties of objects (which will be discussed on Day 10). Third, the length of a variable name cannot exceed 255 characters. Anyone adventurous enough to supply 255 characters or more to name a variable is living life a bit on the wild side anyway! You should keep the size of your variables down to a meaningful, but acceptable, level, or else your fingers are bound to get very sore.
VBScript is a new product, but it is a language derived from its parent product, Microsoft Visual Basic. VBScript is essentially a subset of Visual Basic. When you create variables in Visual Basic, you have the opportunity to specify what type of data you want to store in a variable. If, for example, you want to store integers in a variable, you can declare the variable as an integer variable using the integer data type. As a result, if you try to store anything other than an integer in the variable, Visual Basic either converts the data automatically into integer format or tells you the assignment cannot be made. If you can be specific about the type of data you are storing, your code has the potential to be less error prone because you make fewer mistakes when assigning data to variables. On the other hand, it is advantageous not to worry about restricting a variable to specific types of data. Visual Basic also gives you the choice of creating variables where it doesn't matter what kind of data you want to store. This special type of variable is called a variant.
A variant is a type of variable that can store a wide variety of data types. In many programming languages, variables can only contain a specific predeclared type of information, such as integers or strings. Variants are not restricted to one type of data (such as integers, for example). You could assign an integer value to a variant in one statement and then replace that with a string value in a subsequent statement.
VBScript uses the variant as the basis for variables you create. The variant is used most often to store numbers and strings, but it can store a variety of other types of data. These data types are often called subtypes because the variant can represent them all internally. VBScript keeps track of these subtypes on its own; you usually just store whatever you want in the variable. VBScript matches the data to the best subtype and behaves accordingly. You can also override VBScript's decision of what subtype to use-you'll learn more about that later.
To better understand what the variant actually is, you should understand all the other data types that the variant can represent. These data types are taken from VBScript's parent, Visual Basic. By learning about these data types, you will begin to see how the variant works and what you can and cannot store in a VBScript variable. Here is a list of all the subtypes that the variant uses to represent the data you store in a variable:
When considering how data is stored in a variable, think of a closet full of shoe boxes. Every type of shoe has a certain type of box that can store the shoe. In addition to the boxes that store specific types of shoes, other larger, generic-looking boxes are on hand. These generic boxes can be used to store any of the different types of shoes. The shoe boxes that store specific types of shoes represent the subtypes, whereas the boxes that can store any kind of shoe represent the variant. The variant is a "fit-all" data type that any of the "shoes," or subtypes, can fit into.
All of the subtypes mentioned previously are summarized in the following sections so you can see what type of data can be stored in VBScript variables.
You can set the Boolean data type to either True or False, which are represented by -1 and 0, respectively, in VBScript. This subtype is useful when working with variables where you want to determine or set a condition.
The byte data type can store an integer value between 0 and 255. It is used to preserve binary data and store simple data that doesn't need to exceed this range.
The integer data type is a number that cannot contain a decimal point. Integers can range from -32,768 to +32,767. The integer is one of the most common subtypes because programmers often create variables that fit the integer best. Variables used for counting, for example, are represented internally as integers. Because a great many quantities can be expressed without a decimal point and the number itself can fit within the specified range of the integer, VBScript often chooses this subtype.
Variables of the long data type are also integers, but they have a much higher range, -2,147,483,648 to 2,147,683,647 to be exact. Because this data type is also an integer, you cannot use decimal points with it. Long integers are also quite common and are usually used in cases where the range of the number exceeds the smaller range of the integer. In some cases, however, the range might even exceed that of the long. Perhaps a decimal point is needed in the number. In that case, you must use the single or double data types.
The single subtype represents floating-point, or decimal, values, which means that numbers represented by this subtype include decimal points. The range jumps to a whopping -1.4E-45 to -3.4E38 for negative numbers and 1.4E-45 to 3.4E38 for positive numbers (these numbers are expressed in scientific notation).
Scientific notation is a way to represent very small or very large numbers. A number is expressed as x.xxEyyy where x.xx is a number and yyy represents how many places to shift the decimal point over in the number. If yyy is positive, move the decimal to the right. If yyy is negative, move the decimal to the left. Thus, the expression 3.45E02 becomes 345 and 2.34E-03 becomes 0.00234.
Double is another floating-point data type, but this one has an even larger range than the single data type. The range for the double is -4.9E-324 to -1.8E308 for negative numbers and 4.9E-324to 1.8E308 for positive numbers.
The date subtype is often used because it places the date in a predefined format that other functions in VBScript can act on. If, for example, you have a date variable named HireDate and you want to know what year is in the date, you can simply use the function Year(HireDate) to find it. HireDate is represented by the date subtype so that the function can retrieve the year from the variable.
The string data type is used to store alphanumeric data-that is, numbers, letters, and symbols. The string is another one of the most commonly used subtypes that VBScript uses to represent a variable.
The object data type is a subtype used to reference entities such as control or browser objects within a VBScript application or another application. This concept will be explored further on Day 12, "Advanced Objects: ActiveX, Java, and ActiveVRML."
The error subtype is used for error handling and debugging purposes. Day 17, "Exterminating Bugs from Your Script," discusses this subject.
The empty subtype is used for variables that have been created but not yet assigned any data. Numeric variables are assigned 0 and string variables are assigned "" in this uninitialized condition.
The null subtype refers to variables that have been set to contain no data. Unlike the empty subtype, the programmer must specifically set a variable to null. Later in this lesson, I show you examples using the null subtype.
In many languages, you can allocate a variable to accept a specific type of data-say, integer data. As stated earlier, you cannot directly create a variable in VBScript that "knows" ahead of time it will contain just integer data. Instead, you can create a variable that can take on integer values along with any of the other subtypes listed previously. How is this possible? As mentioned earlier, VBScript does this for you automatically. Suppose, for example, that you declare a variable in VBScript as
Dim Item
Then, suppose that you set the variable Item equal to an integer value:
Item = 23
VBScript stores the value 23 in the Item variable as an integer. If, on the other hand, you were to set Item with a string, as
Item = "Tacoma, Washington"
the text you place in the variable Item gets stored internally as a string. What's great about the variant is that you don't have to worry about placing the wrong type of data in a variable. In Visual Basic 4.0, for example, you can declare an integer value with the statement
Dim Distance as Integer
You could enter a distance in miles easily by using the statement
Distance = 6
Suppose, however, that you have a distance of 6.5 miles that you want to enter. If you enter the statement
Distance = 6.5
Visual Basic 4.0 will store the distance as 7. This happens because you told Visual Basic that the variable was based on the integer data type, which cannot store decimal points. As a result, Visual Basic 4.0 obediently stores it as an integer by rounding the value, in this case, up to an even 7 miles. This problem is automatically solved for you in VBScript, where you simply enter the declaration
Dim Distance
and then set the distance using
Distance = 6.5
or
Distance = 6
or even
Distance = "6 Miles"
It doesn't really matter what you set the Distance variable to. Because the variant data type is used, VBScript automatically converts the data into the best possible subtype internally. The first assignment is converted into a single-precision value, the second to an integer, and the third to a string. As you can see, the variant gives you complete flexibility in entering data because you aren't limited by predeclared data types. Furthermore, the variant can auto-matically convert data from one type to another. If, for example, you have two variables assigned as
Distance = 6.75
Units = " feet"
you can put the two variables together into a third variable using
Result = Distance & Units
which makes Result equal to the string 6.75 feet. (Day 5, "Putting Operators to Work in VBScript," discusses working with strings in more detail.) Now suppose you were using Visual Basic 4.0. If the Distance variable were defined using the single data type and Units were defined as a string, the command
Results = Distance & Units
would result in a Type Mismatch error. This simply means that Visual Basic 4.0 isn't able to concatenate a string to a number. It can add strings to strings and numbers to numbers, but not strings to numbers. Visual Basic 4.0 doesn't automatically add a string to a number because the two are incompatible. When using variants, however, VBScript makes some assumptions for you. On its own, it determines that when you're adding a number to a string, you're going to get a string result. Because the variant can take on any of the data types, it simply stores the result in the variable as a string result.
Because the variants choose the best way to represent data, you usually don't need to be concerned with what subtype is used to store data in a variable. Sometimes, however, you might want to inquire of the subtype being used or perhaps change it from one data type to another.
If, for example, you set a variable equal to a decimal value, VBScript will assign the double subtype to that variable. It would not choose the integer subtype because even though an integer would take less memory than a double, the integer would chop off the decimal and would not be the most accurate representation of the number. Why doesn't VBScript choose the single subtype rather than the double? VBScript chooses the double subtype because the double data type can more accurately represent the value than the single data type. Because the double data type uses more memory and you might not need the extra accuracy that the double data type gives you, you might want to override this decision and use the single data type instead. To begin with, you need a way to determine the variable's subtype. Then you need a way to change it.
In order to inquire about the subtype of a variable, you need
to use the VarType function.
This function takes one argument: the variable name. The function
then returns an integer value that corresponds to the type of
data storage VBScript is using for that variable. Table 4.1 shows
you the return values for each data type.
| Internal Representation | |
| Empty | |
| Null | |
| Integer | |
| Long | |
| Single | |
| Double | |
| Currency* | |
| Date/time | |
| String | |
| OLE automation object | |
| Error | |
| Boolean | |
| Variant** | |
| Non-OLE automation object | |
| Byte | |
| Array** | |
| * The currency data type is not supported in VBScript, but a space is reserved for it in the ordering for consistency with Visual Basic 4.0. | |
| **The return type 8192 is used to represent arrays. In VBScript, you can only create an array of variants. If you have an array of variants, the return type would be 8192 + 12 = 8204. Arrays of other data types are not supported in VBScript, but the array is treated in this manner for consistency with Visual Basic 4.0 (where an array of integers would evaluate to 8192 + 2, for example). | |
Recall the earlier example that defined a variable called Distance. The example first sets the value of Distance to 6, an integer. Consider the code in Listing 4.1, which belongs to the vartype.htm Web page that can be found on this book's CD-ROM. Notice the return values each time the VarType function is called.
Listing 4.1. Determining the internal data type of a variant.
Sub cmdTest_OnClick()
Dim Result
Dim Distance
Distance = 6
Result = VarType(Distance) ' Result returns 2 (integer)
MsgBox "The subtype for the variable representing 6 is " & Result
Distance = 65535
Result = VarType(Distance) ' Result returns 3 (long)
MsgBox "The subtype for the variable representing 65535 is " & Result
Distance = 6/95
Result = VarType(Distance) ' Result returns 4 (single)
MsgBox "The subtype for the variable representing 6/95 is " & Result
Distance = 6.5
Result = VarType(Distance) ' Result returns 5 (double)
MsgBox "The subtype for the variable representing 6.5 is " & Result
Distance = "6"
Result = VarType(Distance) ' Result returns 8 (string)
MsgBox "The subtype for the variable representing ""6"" is " & Result
End Sub
As you can see, the internal representation of the variable changes as the variable is assigned new data. By using the VarType function, you can find out the variable's internal data type, or subtype. In each case, the message box displays the data being stored and the subtype of the variant variable being used to store the information.
The MsgBox statement simply displays a window with the specified message to the user, like the one shown in Figure 4.1.
Figure 4.1 : A message notifying the user of a problem.
| Note |
Message boxes are useful for presenting information to the user that he or she needs to see immediately. The MsgBox function requires at least one argument: the string that is contained inside the message box. Day 14, "Working with Documents and User Interface Functions," covers the MsgBox function in detail. |
In addition to the VarType function, VBScript provides several other functions that return True or False based on the function and the data type of the argument passed to it. The following is a list of those functions:
These functions are often more convenient to use than the VarType function if you're looking for a specific data type that is listed in one of these functions. The following sections contain a brief explanation of each of the functions.
The IsDate function requires the variable as an argument and returns the True value if the variable is a date. This function is often used to make sure the user has entered a valid date. For example, you might want to check the string a user has entered in a text box to see if the string is a valid date. The code in Listing 4.2, taken from the CD-ROM Web page isdate.htm, shows an example of one way you might use this function.
Listing 4.2. Using the IsDate function.
Sub cmdTest_OnClick()
Dim TestDate
TestDate = "4/1/96"
If IsDate(TestDate) = True Then
MsgBox TestDate & " is a valid date", 0, "Date Test"
Else
MsgBox TestDate & " is not a valid date.", 0, "Date Test"
End If
TestDate = "4/45/96"
If IsDate(TestDate) = True Then
MsgBox TestDate & " is a valid date", 0, "Date Test"
Else
MsgBox TestDate & " is not a valid date.", 0, "Date Test"
End If
TestDate = "Not a date"
If IsDate(TestDate) = True Then
MsgBox TestDate & " is a valid date", 0, "Date Test"
Else
MsgBox TestDate & " is not a valid date.", 0, "Date Test"
End If
This example creates a variable to store the start date. First, the code stores a valid date in the variable, and the IsDate function checks to see if the date is indeed valid. The IsDate function returns True, and a message box appears, telling the user that the expression is a valid date. This case is shown in Figure 4.2.
Figure 4.2 : The IsDate function in action, showing a valid date.
Next, the program places an invalid date of "4/45/96" in the variable. Because April doesn't have 45 days, the date is not valid, and the function returns False. The user is told that the date is invalid. Finally, the code stores the variable with an ordinary string that is not a date, and the test is conducted once more. In this case, the variable does not contain data representing a date, and the function again returns False. The value -1 is VBScript's internal value for the True condition, and 0 is the internal value for False. However, you can refer to True and False rather than the corresponding internal values in your programs. VBScript provides these expressions for you through a special type of keyword constant. The constant is True for -1, the true condition, and False for 0, the false condition. You can use true and false to represent -1 and 0 to make your code more readable. General-purpose constants are discussed later today.
| Note |
A date must fall within acceptable limits to be valid, and you must use one of several predetermined formats for the date to be acceptable, such as 7/4/96, 7-4-96, July 4, 1996, and so on. The expression 7496, for example, would not be in an acceptable format for a date. When you assign a date in quotes, such as "7/6/62", this assigns it as a string variant in valid date format. If you want it to be represented internally directly with the date sub-type, you can instead assign it using the date # delimiters, as #7/6/62#. |
The IsNumeric function returns True if the variable is storing a number and False otherwise. Again, this function is often useful to make sure the user has entered a number. If the user has entered something other than a valid number, you can use this function to check for that condition. The example shown in Listing 4.3, isnumeric.htm, illustrates the use of IsNumeric.
Listing 4.3. Using the IsNumeric function.
Sub cmdTest_OnClick()
Dim Value
Value = 23
If IsNumeric(Value) = True Then
MsgBox Value & " is a number."
Else
MsgBox Value & " is not a number."
End If
Value = "Twenty-Three"
If IsNumeric(Value) = True Then
MsgBox Value & " is a number."
Else
MsgBox Value & " is not a number."
End If
End Sub
In this example, the first value is indeed a number. The second case shows the variable assigned a string. Strings that spell out numbers are just that-strings. They are not interpreted as numeric values. As a result, the second test returns False.
IsEmpty determines if a variable has never been assigned any values. It might be useful to use this function to see if a variable has never been used in your code. If a variable has never been used, IsEmpty returns True. The example shown in Listing 4.4, isempty.htm on the CD-ROM, demonstrates the use of this function.
Listing 4.4. Using the IsEmpty function.
Sub cmdTest_OnClick()
Dim Value
If IsEmpty(Value) = True Then
MsgBox "The variable is empty."
Else
MsgBox "The variable contains data."
End If
Value = 23
If IsEmpty(Value) = True Then
MsgBox "The variable is empty."
Else
MsgBox "The variable contains data."
End If
End Sub
In the first test, the IsEmpty function will return True because the variable has been created but not yet used. Because it hasn't been used yet, the variable is empty. Once the variable is assigned a value, the function will return False because the variable will have data assigned to it. To take a variable that has already been assigned data and wipe it from existence, you can enter the command
variable_name = Nothing
where variable_name is the name of the variable. The Nothing literal not only deletes the contents of the container, but it also eliminates the container entirely. If, after setting a variable equal to Nothing, you apply IsEmpty to the variable, the function will return True.
Another useful condition to check is whether a variable is set to a Null value. If the Null literal has been assigned to a variable, IsNull returns True. Null empties the contents of a variable container, but it does not wipe out the container like the Nothing literal does. The example in Listing 4.5, isnull.htm on the CD-ROM, shows a useful example of this function.
Listing 4.5. Using the IsNull function.
Sub cmdTest_OnClick()
Dim TestString
If IsEmpty(TestString) = True Then
MsgBox "The variable is empty."
Else
MsgBox "The variable is not empty."
End If
If IsNull(TestString) = True Then
MsgBox "The variable is Null."
Else
MsgBox "The variable is not Null."
End If
TestString = "This is a test."
If IsEmpty(TestString) = True Then
MsgBox "The variable is empty."
Else
MsgBox "The variable is not empty."
End If
If IsNull(TestString) = True Then
MsgBox "The variable is Null."
Else
MsgBox "The variable is not Null."
End If
TestString = Null
If IsEmpty(TestString) = True Then
MsgBox "The variable is empty."
Else
MsgBox "The variable is not empty."
End If
If IsNull(TestString) = True Then
MsgBox "The variable is Null."
Else
MsgBox "The variable is not Null."
End If
End Sub
In this example, the variable TestString is first created. The first check is to see whether the variable is empty. Because nothing has been stored in it yet, the condition returns True, and the user sees the message box explaining that the variable is empty. Likewise, it has not been assigned a Null value at this point, so the message indicates that the variable is not Null.
Then the variable is assigned a string. The next check is to see whether the variable is empty by calling the IsEmpty function. Because the variable has been assigned data, it is not empty, and the IsEmpty function returns False. Furthermore, because the variable has been assigned a string, it is not Null either.
Finally, the string is set to Null. Even though the string has been set to Null, it is not empty, so IsEmpty returns False again. This time, the string is Null, so the IsNull function returns True.
These functions are useful in determining whether a variable has been loaded with data. The program can then make a decision based on whether a variable contains data. You will see how to do this on Day 6, "Controlling the Flow of VBScript Code."
You use the IsObject function to see if a variable has been set to reference an object. A variable can be assigned to refer to an object with a statement such as
Set myVariable = document.MyForm
The line of code refers to document.myform. This specifies a user input form called myform contained on the current-page document. This form object is then assigned to the variable myVariable. Then subsequent statements can use the variable IsObject to verify that the variable myVariable does indeed refer to an object, as opposed to, for example, an integer or a string. You will learn more about object concepts on Days 8 through 10, beginning with "Intrinsic HTML Form Controls" on Day 8.
Consider once again the example of assigning a decimal value to
the Distance variable. Suppose
that when you assign Distance
a value of 6.5, you don't
want it to take on the double data type because the single data
type is faster and uses less memory. As a result, you might want
to change the internal representation of the data type. You can
use the set of functions shown in Table 4.2 to convert variables
from one internal representation to another.
| CBool | Converts data to the Boolean type |
| CByte | Converts data to the byte type |
| CDate | Converts data to the date type |
| CDbl | Converts data to the double type |
| CInt | Converts data to the integer type |
| CLng | Converts data to the long type |
| CSng | Converts data to the single type |
| CStr | Converts data to the string type |
Suppose, for example, the user enters a value with a decimal point, but you want VBScript to convert the value to an integer instead. When the user enters the decimal value, VBScript will automatically assign the value to the double data type. You need to explicitly tell VBScript to convert the value to an integer so you use the CInt function. The example shown in Listing 4.6, called cint.htm on the CD-ROM that accompanies the book, shows you how you could use this function to accomplish that goal.
Listing 4.6. Using CInt to make sure a value is an integer.
Sub cmdTest_OnClick()
Dim Result
Result = 5.2
MsgBox "You have entered a floating-point value of " & Result
Result = CInt(Result)
MsgBox "Your floating-point value has been converted to an integerÂ
value of " & Result
End Sub
In this example, the variable named Result is stored with a value-in this case, 5.2. (Obviously, in anything other than a sample program, you'd probably obtain the result from a calculation or user input, but for simplicity, the value is assigned directly here.) The CInt function then converts the value to an integer, and the result is stored in the variable. The result displayed from the first message box is You have entered a floating-point value of 5.2. The second message box, as you probably anticipated, displays Your floating-point value has been converted to an integer value of 5, as shown in Figure 4.3.
Figure 4.3 : The Cint function in action, converting a floating-point number to an integer number.
In this sample program, the result isn't used any further. In a more realistic program, the new result would typically be used elsewhere in VBScript code or it would be presented to the user.
Each of the related conversion functions is described briefly in the sections that follow. You will see numerous examples of these functions throughout the book.
The CBool function takes a variable and converts its subtype into the Boolean data type. Boolean values can be either True or False. Any number except zero is automatically converted to True, and zero is always converted to False. You cannot pass a string as an argument to this function. If you do, you'll get a run-time error.
The CByte function takes a variable and converts its subtype into the byte data type. In order for this function to work, the value to be converted must be a number in the acceptable range for a byte-between 0 and 255. If the number falls outside this range, a run-time error results. In addition, you cannot use strings as arguments for this function.
The CDate function takes a variable and converts its subtype into a date data type. The argument must be a string in an acceptable format for dates. If it's not, a run-time error results.
The CInt function takes a variable and converts its internal subtype into the integer format. It requires a number for its argument, and it rounds the value to the closest integer representation. If the number falls outside the range of the integer data type, a run-time error results.
The CLng function takes a variable and converts its internal subtype into the long integer format. It requires a number for its argument, and it rounds the value to the closest integer representation. If the number falls outside the range of the long data type, a run-time error results.
The CSng function takes a variable and converts the internal subtype into the single data type. The variable cannot be a string; it must be a number. Furthermore, the number must fall within the range of the single data type.
The CDbl function takes a variable and converts the internal subtype into the double datatype. The variable cannot be a string; it must be a number. In addition, the number must fall within the range of the double data type.
The CStr function converts the subtype of a variable into the string data type. The function can take any argument, whether it's a number or even a string, and convert it automatically to a string. This function is useful when you need to create a string that contains a number and insert that number into the string.
Sometimes in writing code, you will want to refer to values that never change. The values for True and False, for example, are always -1 and 0, respectively. Values that never change usually have some special meaning, such as defining True and False. These values that never change are called constants. The constants True and False are sometimes referred to as implicit constants because you do not need to do anything to reference their constant names. They are immediately available in any code you write.
A constant is a variable within a program that never changes in value. Users can create their own constants by initializing variables accordingly and then not changing their value. VBScript defines the special True and False constants, as well.
Throughout this lesson, you have seen the True and False constants in action. Keep in mind that it is illegal to change the value of one of VBScript's intrinsic constants. Therefore, the statement
False = 10
would result in an error because VBScript has already defined False to be 0. VBScript won't let you change a constant even though you can change a variable.
Unfortunately, you cannot create true constants with VBScript. The language will still allow you to change the value of any constant variable you define. Many languages have ways to declare a constant so that you cannot alter its value anywhere in the program. VBScript does not offer this level of strictly enforced true constant declaration. You can simulate a constant, however, by following two rules:
If you wanted to create, for instance, a constant that contains your company name so you can use it throughout your code, you can use the following statements to define the constant:
Dim COMPANY
COMPANY = "Acme Enterprises"
Then use the variable throughout your code, never setting the variable COMPANY to any other value. This convention will make it easier to work with and recognize simulated constants.
Special constants you supply to VBScript functions, methods, and
statements should be prefixed with vb,
as previously mentioned. Table 4.3 shows these constants and the
values you should assign to them.
| vbOKOnly | MsgBox buttons desired | |
| vbOKCancel | MsgBox buttons desired | |
| vbAbortRetryIgnore | MsgBox buttons desired | |
| vbYesNoCancel | MsgBox buttons desired | |
| vbYesNo | MsgBox buttons desired | |
| vbRetryCancel | MsgBox buttons desired | |
| vbCritical | MsgBox icon desired | |
| vbQuestion | MsgBox icon desired | |
| vbExclamation | MsgBox icon desired | |
| vbInformation | MsgBox icon desired | |
| vbDefaultButton1 | MsgBox default button desired | |
| vbDefaultButton2 | MsgBox default button desired | |
| vbDefaultButton3 | MsgBox default button desired | |
| vbOK | Return code: selected MsgBox button | |
| vbCancel | Return code: selected MsgBox button | |
| vbAbort | Return code: selected MsgBox button | |
| vbRetry | Return code: selected MsgBox button | |
| vbIgnore | Return code: selected MsgBox button | |
| vbYes | Return code: selected MsgBox button | |
| vbNo | Return code: selected MsgBox button | |
| vbCrLf | Causes line break in text |
These constants can be defined in your VBScript code and used when needed. For example, suppose you want to use the vbCrLf constant in your program to break up your text. You could enter the code as follows:
Dim vbCrLf : vbCrLf = chr(13) & chr(10) ' Causes line break in text
Dim svResponse
svResponse = "The password is less than twelve characters. " & vbCrLf & _
"Please enter the password again."
In this case, the first line of code declares and defines the constant (note the vb prefix). Then, another variable is declared and stored with the string shown above. Because the constant vbCrLf is used by VBScript to break a line of text and is not a "homemade" constant, the vb prefix is used rather than uppercase letters.
| Note |
A complete listing of the values shown in Table 4.3 is presented on the CD-ROM that accompanies the book. The file constant.txt, which is located in Code\Shared\Tools, contains the declarations and assignments of each of these constants. You can then simply copy and paste the constants you want to use into your Web page. One of the advantages of using the vb naming convention for your constants-in addition to improved maintainability-is that it will make your code more compatible with standard Visual Basic for Applications code, if you ever need to move code between environments. |
You'll learn more about constants on Day 13, "VBScript Standards and Conventions." For more useful conventions, refer to Day 13.
With VBScript you can create variables that are shared throughout your code, or you can create variables that are used only with code blocks called procedures. A procedure is a block of code that accomplishes a specific goal. For example, you might have a procedure that calculates the total cost of an item. Perhaps you have a procedure that is executed when the user clicks a command button. VBScript has three types of procedures: subroutines, functions, and events. Each of these will be defined and discussed on Day 7, "Building a Home for Your Code." For now, just think of a procedure as a body of code that gets executed for some reason. This section discusses a procedure that gets executed whenever the user clicks a button.
A procedure is a body of code that is called from within VBScript to be executed.
When a variable is created, you can either use it within a specific procedure or share it among all the procedures in the script. The availability a variable has within its environment is referred to as the scope of a variable. Variables in VBScript can have two different kinds of scope. When a variable is declared inside a procedure, it has local scope and can be referenced only while that procedure is executed. Local-scope variables are often called procedure-level variables because they exist only in procedures. When you declare a variable in a procedure, it automatically has local scope, which means only the code within that procedure can access or change the value of that variable. You might want to share a variable among more than one procedure. If you declare a variable outside a procedure, it automatically has script-level scope and is available to all the procedures in your script.
Scope refers to where within a script, such as a local procedure or globally across the script, a given variable is available for use based on the declaration.
Variables not only have a scope, but they also exist for different amounts of time depending on their scope. This property of a variable is often referred to as its lifetime. Script-level variables are created outside of any procedures using the Dim keyword. They exist from the time the variable is declared until the time the script is finished running. Listing 4.7 shows an example of a script-level variable. This Web page, named scrptlvl.htm, is on the CD-ROM that accompanies the book.
Listing 4.7. Using script-level variables.
<HTML>
<TITLE>Using Script-Level Variables</TITLE>
<H1><A HREF="http://www.mcp.com"><IMG ALIGN=BOTTOM
SRC="../shared/jpg/samsnet.jpg" BORDER=2></A>
Using Script-Level Variables</H1>
<BODY>
<HR>
<CENTER><INPUT TYPE=BUTTON VALUE="Click Me" NAME="cmdTest"></CENTER>
<HR>
<center>
from <em>Teach Yourself VBScript in 21 Days</em> by
<A HREF="../shared/info/keith.htm">Keith Brophy</A> and
<A HREF="../shared/info/tim.htm">Tim Koets</A><br>
Return to <a href="..\default.htm">Content Overview</A><br>
Copyright 1996 by SamsNet<br>
</center>
<SCRIPT LANGUAGE="VBScript">
<!--
Option Explicit
Dim Counter
Sub cmdTest_OnClick()
SetCaption
cmdTest.Value = Counter
End Sub
Sub SetCaption()
Counter = Counter + 1
End Sub
-->
</SCRIPT>
</BODY>
</HTML>
| Note |
The code in Listing 4.7 makes use of the following HTML button control definition: <INPUT TYPE=BUTTON VALUE="Click Me" NAME="cmdTest"> HTML form controls are one of several types of controls you can place on a Web page and manipulate using VBScript. These controls will be discussed in detail on Day 8. In this example, all you need to know about the button declaration is that it results in the display of a button on the form. This internal name of the button, which is visible to the VBScript application, is cmdTest. VBScript can assign or retrieve values from this button by referencing its caption with a statement like the following: Variable1 = cmdTest.Value When the user clicks the button, the browser informs VBScript that an OnClick event has occurred for that given button. VBScript will begin the routine cmdTest_OnClick if that procedure exists. |
In Listing 4.7, the variable, which is called Counter, is declared outside all the procedures in the script. As a result, any of the procedures within the script can use it. When the user clicks the cmdTest button in the Web page, the browser must handle the OnClick event that occurs. The procedure cmdTest_OnClick is called because it is associated with the button by virtue of its name. The first action of this procedure is to call SetCaption. The SetCaption procedure increments the counter variable by 1 and ends. Then the procedure that called SetCaption continues by setting the text on the command button equal to Counter. This, in effect, increments the number on the command button each time it is clicked, as shown in Figure 4.4.
Because the variable is shared among all the procedures in the script, SetCaption doesn't need to be told the value of Counter; it can simply look for it itself.
What would happen if the variable were moved inside the calling procedure rather than outside, as is the case in the Web page incorvar.htm on the CD-ROM, shown in Listing 4.8?
Listing 4.8. Using procedure-level variables incorrectly.
<SCRIPT LANGUAGE="VBScript">
<!--
Option Explicit
Sub cmdTest_OnClick()
Dim Counter
SetCaption
cmdTest.Value = Counter
End Sub
Sub SetCaption()
Counter = Counter + 1
End Sub
-->
</SCRIPT>
Because of the Option Explicit command at the beginning of the script, running this code would result in an error! The Counter variable has been moved from outside the procedures into the cmdTest_OnClick procedure, so it is only available to that procedure. The SetCaption procedure no longer has access to the variable, so it would have to declare Counter before it could use it. Because Option Explicit is being used, VBScript does not recognize the variable without an explicit declaration, and an error results. Listing 4.9, inappvar.htm, shows the fix for this error condition.
Listing 4.9. Using procedure-level variables inappropriately.
<SCRIPT LANGUAGE="VBScript">
<!--
Option Explicit
Sub cmdTest_OnClick()
Dim Counter
SetCaption
cmdTest.Value = Counter
End Sub
Sub SetCaption()
Dim Counter
Counter = Counter + 1
End Sub
<--
</SCRIPT>
Now the code will run, but it still won't work right. Because each procedure has its own copy of the variable, they can't share with each other. When the SetCaption procedure is called, it creates the Counter variable and sets it equal to 1. Then, when the calling function resumes, it uses its own copy of Counter, which has never been set. The result is that nothing at all is displayed in the command button when it is clicked, as can be seen in Figure 4.5.
Sometimes, you might want to use two different copies of a variable. Consider Listing 4.10, dim.htm, for example.
Listing 4.10. Creating procedure-level variables with Dim.
<HTML>
<TITLE>Script-Level Variables</TITLE>
<H1>
<A HREF="http://www.mcp.com"><IMG ALIGN=BOTTOM
SRC="../shared/jpg/samsnet.jpg" BORDER=2></A>
Script-Level Variables
</H1>
<BODY>
<HR>
<CENTER><H2>Using a script-level variable properly</H2>
<INPUT TYPE=BUTTON VALUE="Go!" NAME="GoButton">
<INPUT TYPE=BUTTON VALUE="You haven't clicked on Go yet!"
NAME="TestButton"></CENTER>
<HR>
<center>
from <em>Teach Yourself VBScript in 21 Days</em> by
<A HREF="../shared/info/keith.htm">Keith Brophy</A> and
<A HREF="../shared/info/tim.htm">Tim Koets</A><br>
Return to <a href="..\default.htm">Content Overview</A><br>
Copyright 1996 by SamsNet<br>
</center>
<SCRIPT LANGUAGE="VBScript">
<!--
Option Explicit
Dim Action
Sub GoButton_OnClick()
Action = 1
End Sub
Sub TestButton_OnClick()
If Action = 1 Then
SetCaptionA
Else
SetCaptionB
End If
End Sub
Sub SetCaptionA()
Dim MyString
MyString = "You've clicked on Go!"
TestButton.Value = MyString
End Sub
Sub SetCaptionB()
Dim MyString
MyString = "You haven't clicked on Go yet!"
TestButton.Value = MyString
End Sub
-->
</SCRIPT>
</BODY>
</HTML>
In this example, you have two command buttons on a Web page, as
shown in
Figure 4.6.
Figure 4.6 : The initial state of the dim.htm Web page.
When the first command button, called GoButton, is clicked, a procedure runs that sets a script-level variable called Action equal to 1. When the second button, TestButton, is clicked, a procedure runs that checks the value of Action and calls either SetCaptionA or SetCaptionB, depending on the value of Action. Figure 4.7 shows what happens after the user clicks the GoButton command button.
Figure 4.7 : The dim.htm Web page after the user has clicked on the Go! command button.
Both SetCaptionA and SetCaptionB create their own local copies of MyString and set the caption of TestButton with their respective strings. Both strings have the same name, but they are separate copies. As soon as each procedure ends, its own copy of MyString is destroyed.
You have seen that the lifetime of a script-level variable is equal to the entire life of the Web page. On the other hand, when you declare a procedure-level variable using Dim, the variable exists only while the procedure is run. Once the procedure ends, the variable is destroyed.
You should know one more thing about variables. Suppose you create a script-level variable called MyVariable, and then you create a procedure-level variable with the same name, as shown in Listing 4.11! This Web page is named dupvar.htm and, like the others, is on the CD-ROM that comes with this book.
Listing 4.11. Creating duplicate variables at different scopes.
<HTML>
<TITLE>Variable Scope</TITLE>
<H1><A HREF="http://www.mcp.com"><IMG ALIGN=BOTTOM
SRC="../shared/jpg/samsnet.jpg" BORDER=2></A>
Variable Scope</H1>
<BODY>
<HR>
<CENTER><H2>Creating duplicate variables with different scopes</H2>
<INPUT TYPE=BUTTON VALUE="Click Me" NAME="cmdTest"></CENTER>
<HR>
<center>
from <em>Teach Yourself VBScript in 21 Days</em> by
<A HREF="../shared/info/keith.htm">Keith Brophy</A> and
<A HREF="../shared/info/tim.htm">Tim Koets</A><br>
Return to <a href="..\default.htm">Content Overview</A><br>
Copyright 1996 by SamsNet<br>
</center>
<SCRIPT LANGUAGE="VBScript">
<!--
Option Explicit
Dim MyVariable
Sub cmdTest_OnClick()
Dim MyVariable
MyVariable = MyVariable + 1
cmdTest.Value = MyVariable
End Sub
-->
</SCRIPT>
</BODY>
</HTML>
If you create duplicate variables, VBScript will create two copies and use only the procedure-level variable in the procedure. It will not use the script-level variable. In Listing 4.11, two copies of MyVariable are created. Unfortunately for this programmer, the copy that gets used inside the procedure is not the one he would like to see used. If he removes the second Dim MyVariable that is inside the procedure, the code will increment the value every time the button is clicked. As it is now, MyVariable will be created locally every time the procedure is executed and will always be equal to 1, as shown in Figure 4.8.
Figure 4.8 : The dupvar.htm Web page with a button caption always set to 1.
VBScript uses the variable with the smallest scope whenever there are duplicates. This might seem confusing, and it is. The best way to avoid this situation is to make sure you never give variables in your program the same name unless they are procedure-level variables residing in two separate procedures, as in the example in Listing 4.10.
So far today, you've learned what a variable is, how to create one, and what you can store inside one. You might be wondering if there is some easy way to group variables together in a set. For example, you may have a Web page that requests many of the same things-such as a list of screen coordinates-and you want to store those coordinates together. Rather than create ten separate variables, you can instead create one variable that holds all ten pieces of data. This type of container is called an array.
An array is a type of variable that ties together a series of data items and places them in a single variable.
Arrays are useful when you're storing sets of similar data because they often make it easier to manipulate the data together. If you wanted to manipulate a list of ten coordinates, you would have to execute ten different statements to handle each one. Besides, how can you be sure you have ten? What if you have only six at the moment? How can your code handle this kind of situation where you really don't know ahead of time how many pieces of information you have? Here is where the array comes to the rescue!
The beauty of an array is that it enables you to store and use a series of data using one variable name and an index to distinguish the individual items. By using an index, you can often make your code simpler and more efficient so that it's easier for you to put a script together and change it later. With VBScript, the elements inside your array can hold any kind of data. The elements don't have to be all integers or all strings, for example. The array can hold a combination of data types.
You create arrays using the same keyword you use when creating variables-the Dim keyword. An array created with the Dim keyword exists as long as the procedure does and is destroyed once the procedure ends. If you create the array in the main script, outside the procedure, the values will persist as long as the page is loaded. You can create two types of arrays using VBScript: fixed arrays and dynamic arrays. Fixed arrays have a specific number of elements in them, whereas dynamic arrays can vary in the number of elements depending on how many are stored in the array. Both types of arrays are useful, and both have advantages and disadvantages.
You can create fixed-length arrays using the following syntax:
Dim Array_Name(count - 1)
where Array_Name is the name of the array and count is an integer value representing the number of containers you want the array to contain. The statement
Dim Names(19)
creates an array called Names that consists of 20 containers, often called elements. You can store 20 different names in this array of data called Names. Consider the shoe box analogy discussed earlier in this lesson. Creating an array is like having 20 shoe boxes that you can store shoes in. Rather than naming each box separately, you can give them all the same name and refer to them using an index, such as ShoeBox(0), ShoeBox(1), Shoebox(2), and so on.
The index of the array always starts at 0 and ends at count -1. In the case of the Names array, the number of containers, or elements, in the array ranges from Names(0) to Names(19) for a total of 20 elements. To see how this works, look at the code in Listing 4.12. The complete Web page that executes this code is on the CD-ROM with the title index.htm. This simple code listing sets every element of the Names array equal to the string "Unknown". This is similar to putting the same type of shoe in every shoe box in your closet.
Listing 4.12. Working with the index of an array.
Dim Names(19)
Dim i
For i = 0 to 19
Names(i) = "Unknown"
Next
This code listing uses a loop to set each element. Essentially, the program treats the variable i like a counter and keeps incrementing it by 1 all the way from 0 to 19. The Names(i) = "Unknown" code statement is executed 20 times, and each time the i value is different. Day 6 covers loops in depth.
It's important to remember that the first container in your array has an index of 0, not 1. In this example, the first element in the array is Names(0), not Names(1). If you forget this and start with Names(1), you'll only be able to use 19 of the containers, not 20.
The second type of array you can create is the dynamic array. The benefit of a dynamic array is that if you don't know how large the array will be when you write the code, you can create code that sets or changes the size while the VBScript code is running. A dynamic array is created in the same way as a fixed array, but you don't put any bounds in the declaration. As a result, your statement becomes
Dim Names()
Eventually, you need to tell VBScript how many elements the array will contain. You can do this with the ReDim function. ReDim tells VBScript to "re-dimension" the array to however many elements you specify. ReDim takes dimensions the same way Dim can. The syntax is
ReDim Array_Name(Count - 1)
So, if you enter
ReDim Names(9)
you will create an array that has room to store ten elements. This way, you can set the size of the array while the code is running rather than when you write the code. This can be useful when the user gets to decide how many names he will enter. For example, he might type the number of names he's going to give you into a text control. In that case, you could use code like what's shown in Listing 4.13. This Web page is called dynamic.htm and is on the CD-ROM that comes with the book.
Listing 4.13. Working with a dynamic array.
Dim Names()
Dim i
Dim Count
Count = txtCount.Value
ReDim Names(Count - 1)
For i = 0 to Count - 1
Names(i) = "Unknown"
Next
MsgBox "The Names array has just been dimensioned to " & _
Count & " elements and set with the string ""Unknown""."
In this case, the number of elements is set using the variable Count instead of some fixed number. This code isn't very safe, of course, because the user might not enter a valid number, or for that matter, he might type in something strange like the name of his dog. In Day 17, you will see how to handle those kinds of situations by making your scripts as "dummy proof" as possible.
Suppose that you dimension an array in your code, and later on, you need to increase the size of the array. No problem, right? You just use ReDim again and increase the number of elements in the array. That will certainly work, but the entire array will be erased in the process. This is like adding more shoe boxes to your closet by taking out all the shoe boxes, emptying them, and putting the total number you want back in empty. Do not despair; VBScript contains a keyword called Preserve that comes to the rescue.
The Preserve keyword is very important when using ReDim. Suppose, for example, that you create a dynamic array, specifying its storage space by using ReDim, fill it with data, and then later decide to make it larger so you can fill it with more information without losing your original data. (See Listing 4.14.) The Web page is saved on the CD-ROM as nopresrv.htm.
Listing 4.14. Resizing a dynamic array without Preserve.
Dim Names()
Dim i
Dim Count
Count = txtCount.Text
ReDim Names(Count -1)
For i = 0 to Count - 1
Names(i) = "Unknown"
Next
ReDim Names( Count + 49)
For i = Count to Count + 49
Names(i) = "Extra Names"
Next
MsgBox "The Names array has just been dimensioned to " & Count & _
" elements and redimensioned with an additional 50 elements."
In this example the programmer has declared an array of size Count and then resized the array to 50 plus the original size. (You probably noticed that 49 is used instead of 50 in the ReDim statement. Keep in mind that because the array index starts at 0 rather than 1, you set the size to be the desired Count - 1.) The problem is that without the Preserve keyword after the ReDim statement, the first Count elements are erased.
Now consider the code in Listing 4.15. This listing is based on the Web page titled preserve.htm located on the CD-ROM that accompanies the book.
Listing 4.15. Resizing a dynamic array with the use of Preserve.
Dim Names()
Dim i
Dim Count
Count = txtCount.Text
ReDim Names(Count-1)
For i = 0 to Count - 1
Names(i) = "Unknown"
Next
ReDim Preserve Names(Count + 49)
For i = Count to Count + 49
Names(i) = "Extra Names"
Next
MsgBox "The Names array has just been dimensioned to " & Count & _
" elements and redimensioned with an additional 50 elements. _
All items retain their original values."
If you use Preserve after the second ReDim statement, as shown in Listing 4.15, VBScript will still retain the first Count elements. This is like adding shoe boxes to a closet without emptying the boxes already in the closet.
If you want to erase whatever is in the array when you resize it, leave off the Preserve keyword. If you want to keep what you've got, make sure to include it when you re-dimension an array.
You can use the ReDim statement again and again in your procedure. Suppose you want to change the size of the array twice in the procedure. You might have a Web page where the user enters two sets of names for a couple sports teams. You could have code similar to the Web page redim.htm, whose VBScript code is shown in Listing 4.16.
Listing 4.16. Working with a dynamic array and ReDim.
Sub cmdTest_OnClick()
Dim Names()
Dim i
Dim Green_Count
Dim Red_Count
' Initialize the values
Green_Count = 0
Red_Count = 0
Green_Count = txtGreenCount.Value
ReDim Names(Green_Count - 1)
For i = 0 to Green_Count - 1
Names(i) = "Green Team Player"
Next
Red_Count = txtRedCount.Value
ReDim Preserve Names(Green_Count + Red_Count - 1)
For i = Green_Count to Green_Count + Red_Count - 1
Names(i) = "Red Team Player"
Next
MsgBox Green_Count & " Green team members and " & Red_Count & _
" Red Team members have been created."
End Sub
As you can see, ReDim is used here (along with Preserve) to dimension the array the first time and then later to make it larger.
In the course of working with arrays, you might want to find out how large an array is. VBScript provides you with a function called UBound, which gives you the information you need. UBound tells you how many boxes of shoes you have set aside in the closet. This function returns an integer value and requires one argument-the array:
size = UBound(array_name)
where size is a variable that will contain the bound value of the array and array_name is the name of the array. To see how you can take advantage of these functions, compare Listing 4.12 to the Web page named ubound.htm, whose VBScript code is shown in Listing 4.17.
Listing 4.17. Using UBound on a fixed-length array.
Dim Names(19)
Dim i
For i = 0 to UBound(Names)
Names(i) = "Unknown"
Next
MsgBox "The upper bound of the Names() array is " & UBound(Names)
In this example, you use UBound(Names) instead of 19. This might seem trivial, but what happens if you want to change the size of your array from 20 elements to 40? You would not only have to change the declaration of the array, but you'd also have to find every place in your code where you reference the size of the array and change the values. By using the bounding function, you only have to make one change, which makes your code easier to maintain.
The arrays you have seen so far today have had only one dimension. Using the shoe box analogy, it's like having a closet full of shoe boxes. Suppose that you not only want to put your shoes on shelves, but you also want to put your work shoes on one specific shelf, your dress shoes on another, and so on. If you did that, each shoe box "address" would first refer to the shelf and then to the particular box on that shelf.
When writing VBScript code, you might want to create an array in a similar way. You can do this by creating an array with more than one dimension, making it a multi-dimensional array. With VBScript, you can define up to 60 dimensions for a single array. How could this be useful? Suppose that you have a grid like a spreadsheet on your Web page, and you want to give the user the ability to enter data in each cell. You could keep track of the grid using a two-dimensional array by declaring the array as
Grid(rows - 1, columns - 1)
where rows is the number of rows on the spreadsheet and columns is the number of columns. If you wanted to obtain the value stored in row two, column three, you could use the statement
Value = Grid(2 - 1, 3 - 1)
to obtain the information. Notice that you have to decrease the index by 1 because the index starts with 0. Also, when you use the ReDim statement to re-dimension a multi-dimensional array, you can change the limit of any of the dimensions, but you cannot change the number of dimensions. For example, if you have declared the array
Dim Grid()
and you dimension the array as
ReDim Grid(10, 30)
you can execute another ReDim statement like
ReDim Grid(5, 100)
but you cannot add another dimension:
ReDim Grid(5, 10, 20)
The first ReDim statement you enter in a procedure sets the number of the dimensions of the array. After that, you cannot change the number of dimensions; you can change only the number of elements for that dimension.
One final word about arrays: You can clear the contents of an array entirely by using the Erase function. This function takes one parameter, the name of the array. If you want to erase an array out of memory, simply enter
Erase Array_Name
Not only will this erase the array's contents, but with dynamic arrays (those declared with ReDim), it will also free the memory that was used by the array. Because variables and large arrays in particular can take a lot of memory, it is wise to use the Erase statement whenever you're finished with an array in a procedure.
Today, you got the information you need to create and use variables within your VBScript code. It is one of several key lessons that get you up to speed on the basics of VBScript. If you've used Visual Basic or some other programming language, parts of this lesson might seem quite elementary to you. It is important, however, to get a survey of variable use in VBScript because each language has a different way of approaching variable creation and use.
Today's lesson begins by giving a definition of what a variable actually is-a container in which to store information. Then you saw how easy it is to create a variable by simply entering Dim followed by the name of the variable in your code. This lesson also describes all the various kinds of data you can place in a variable.
You have seen how VBScript figures out what kind of data you have stored in a variable. This is important because you sometimes need to know what VBScript thinks you have stored just in case you want to change its mind. You have learned about a series of functions you can use, if necessary, to ask VBScript about the internal representation of a variable. In this way, you can make sure the user has entered data correctly, or you can decide how to handle data based on how it is being stored. You then saw a group of functions that convert the internal data representation from one type to another. This is often useful when you want to change the format of the data in order to manipulate it with other variables.
Today's lesson also discusses the scope and lifetime of variables, pointing out that you can use Dim to create a procedure-level variable whose contents are erased once a procedure ends or you can declare a variable outside a procedure, making it a script-level variable that all the procedures can share within a script. That way, a variable can exist no matter what code the VBScript procedure is executing.
Having discussed simple variables, the lesson concludes by discussing arrays. Arrays are useful, powerful, and time-saving. You have seen how to create both a fixed-size array and a dynamic array. You have also seen how to re-dimension a dynamic array and preserve the contents of the array while doing so, how to create arrays of more than one dimension, and how you might use such arrays.
You've made it through the first day that teaches you how to write VBScript code! As you learn more about VBScript and its capabilities, all the concepts you are learning now will not only start to make more sense, but you will also begin to use VBScript in increasingly more powerful ways. A few days from now you'll be well along your way, developing powerful and fun Web pages. You can't get there without first learning the fundamentals, and this is the first lesson where you do just that. In tomorrow's lesson, you will learn how to put variables to use with operators. Day 5 is also when you will learn how to use arithmetic with your variables, compare one variable to another, set the contents of variables, and work with strings. Then, on Day 6, you will learn how to control the flow of your code and create procedures. Day 7 gets into more details on procedures, and on Days 8 and 9, you'll learn about the intrinsic HTML controls. Then, when you reach Day 10, you'll be ready to learn the powerful ActiveX controls.
| Why doesn't VBScript support all the other data types that Visual Basic supports? | |
| I can't speak for Microsoft, but they probably dropped the other data types to keep the language simple. A likely goal for the VBScript design team was to make the language as flexible, easy to learn, and safe to use as possible. The variant type is definitely the easiest to use, and it reduces the size and complexity of the VBScript run-time interpreter. This makes VBScript faster and more efficient at what it does. | |
| Why would I ever need to figure out the subtype of a variable? | |
| Usually, you won't have to worry about variable subtypes. On occasion, however, you may need to inquire as to a variables subtype so you can convert it into another format or carry out a certain action depending on the variable. For example, you may want to execute code differently if the user enters None in a text box versus a value. | |
| Arrays look pretty complicated. Will I ever need to use them? | |
| They might seem complicated to you now, but you will see as you work through this book that not only are they easy to use, but they can also save you a great deal of extra code and make your program a lot easier to write and understand later. |
Today you saw a Web page that makes use of simple variables. Take one of the code examples in this lesson and create your own Web page. Once you've got it running, create several variables and assign data to them. Practice displaying the contents of those variables on the Web page using MsgBox and the form button control I have discussed.
| Note |
Refer to Appendix C, "Answers to Quiz Questions," for the answers to these questions. |