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.

Working with Constants

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:

• When you create the simulated constant, name the constant with uppercase letters if the constant represents a value unique to your program. If the constant is a special value expected by VBScript, prefix the constant name with the letters vb. This naming convention is not required, but it will help you distinguish the constant from all the other variables.
• After you assign the initial value to the variable, don't change the variable. VBScript will not enforce this for you, so you'll have to make sure you don't change the value of a simulated constant in your code.

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.

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.

You'll learn more about constants on Day 13, "VBScript Standards and Conventions." For more useful conventions, refer to Day 13.

The Scope and Lifetime of a Variable

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.asp, is on the CD-ROM that accompanies the guide.

Listing 4.7. Using script-level variables.

<HTML>

<TITLE>Using Script-Level Variables</TITLE>

<H1><A HREF="http://w3.softlookup.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.asp">Keith Brophy</A> and
<A HREF="../shared/info/tim.asp">Tim Koets</A><br>
Return to <a href="..\default.asp">Content Overview</A><br>
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>

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.

Figure 4.4 : Script-level variables are used here to increment a value that appears on the button on the Web page.

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.asp 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.asp, 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.

Figure 4.5 : Here, a procedure-level variable is used and results in an unintended loss of data-the caption of the button is empty!

Sometimes, you might want to use two different copies of a variable. Consider Listing 4.10, dim.asp, for example.

Listing 4.10. Creating procedure-level variables with Dim.

<HTML>

<TITLE>Script-Level Variables</TITLE>

<H1>
<A HREF="http://w3.softlookup.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.asp">Keith Brophy</A> and
<A HREF="../shared/info/tim.asp">Tim Koets</A><br>
Return to <a href="..\default.asp">Content Overview</A><br>
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.asp 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.asp 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.asp and, like the others, is on the CD-ROM that comes with this guide.

Listing 4.11. Creating duplicate variables at different scopes.

<HTML>

<TITLE>Variable Scope</TITLE>

<H1><A HREF="http://w3.softlookup.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.asp">Keith Brophy</A> and
<A HREF="../shared/info/tim.asp">Tim Koets</A><br>
Return to <a href="..\default.asp">Content Overview</A><br>
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.asp 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.

Working with Arrays

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.

Creating Arrays

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.

Fixed-Length Arrays

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.aspl. 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.

Dynamic Arrays

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.asp and is on the CD-ROM that comes with the guide.

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.asp.

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.asp located on the CD-ROM that accompanies the guide.

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.asp, 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.

Determining the Size of the Array

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.asp, 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.

Multi-Dimensional Arrays

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.

Changing the Contents of the Array

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.

Summary

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.

Q&A

Workshop

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.

Quiz

1. What data type are VBScript variables based on? Can you remember the data types you can store inside a variable?
2. Write the code required within a procedure to create a variable for storing your name with VBScript code. Assign your name to that variable.
3. Assume you have a variable called Age that contains an age provided by the user. Write the code that ensures that the user has entered a number as her age. If the user hasn't entered a number, tell her she needs to enter her age correctly.