Category Archives: VbScript

Using VBScript with Objects

Using VBScript with Objects

Using Objects

Whether you use an ActiveX™ control (formerly called an OLE control) or a Java™ object, Microsoft Visual Basic Scripting Edition and Microsoft® Internet Explorer handle it the same way. If you’re using Internet Explorer and have installed the controls available in the ActiveX Gallery, you can see the page produced by the following code.

You include an object using the <OBJECT> tags and set its initial property values using <PARAM> tags. If you’re a Visual Basic programmer, you’ll recognize that using the <PARAM> tags is just like setting initial properties for a control on a form. For example, the following set of <OBJECT> and <PARAM> tags adds the ActiveX Label control to a page:

<OBJECT

	classid="clsid:99B42120-6EC7-11CF-A6C7-00AA00A47DD2"

	id=lblActiveLbl

	width=250

	height=250

	align=left

	hspace=20

	vspace=0

>

<PARAM NAME="Angle" VALUE="90">

<PARAM NAME="Alignment" VALUE="4">

<PARAM NAME="BackStyle" VALUE="0">

<PARAM NAME="Caption" VALUE="A Simple Desultory Label">

<PARAM NAME="FontName" VALUE="Verdana, Arial, Helvetica">

<PARAM NAME="FontSize" VALUE="20">

<PARAM NAME="FontBold" VALUE="1">

<PARAM NAME="FrColor" VALUE="0">

</OBJECT>

You can get properties, set properties, and invoke methods just as with any of the form controls. The following code, for example, includes <FORM> controls you can use to manipulate two properties of the Label control:

<FORM NAME="LabelControls">

<INPUT TYPE="TEXT" NAME="txtNewText" SIZE=25>

<INPUT TYPE="BUTTON" NAME="cmdChangeIt" VALUE="Change Text">

<INPUT TYPE="BUTTON" NAME="cmdRotate" VALUE="Rotate Label">

</FORM>

With the form defined, an event procedure for the cmdChangeIt button changes the label text:

<SCRIPT LANGUAGE="VBScript">

<!--

Sub cmdChangeIt_onClick

	Dim TheForm

	Set TheForm = Document.LabelControls

	lblActiveLbl.Caption = TheForm.txtNewText.Value

End Sub

-->

</SCRIPT>

The code qualifies references to controls and values inside the forms just as in the Simple Validation example.

Several ActiveX™ controls are available from the ActiveX Gallery for use with Internet Explorer. You can find complete information about the properties, methods, and events there, as well as the class identifiers (CLSID) for the controls on the programming reference pages. You can find more information about the <OBJECT> tag on the Internet Explorer 4.0 Author’s Guide and HTML Reference page.


Note Earlier releases of Internet Explorer required braces ({}) around the classid attribute and did not conform to the W3C specification. Using braces with the current release generates a “This page uses an outdated version of the <OBJECT> tag” message.

VBScript and Forms

VBScript and Forms

Simple Validation

You can use Visual Basic Scripting Edition to do much of the form processing that you’d usually have to do on a server. You can also do things that just can’t be done on the server.

Here’s an example of simple client-side validation. The HTML code is for a text box and a button. If you use Microsoft® Internet Explorer to view the page produced by the following code, you’ll see a small text box with a button next to it.

<HTML>

<HEAD><TITLE>Simple Validation</TITLE>

<SCRIPT LANGUAGE="VBScript"> 

<!--

Sub Submit_OnClick

  Dim TheForm

  Set TheForm = Document.ValidForm

  If IsNumeric(TheForm.Text1.Value) Then

    If TheForm.Text1.value < 1 Or TheForm.Text1.value > 10 Then

      MsgBox "Please enter a number between 1 and 10."

    Else

      MsgBox "Thank you."

    End If

  Else

    MsgBox "Please Enter a numeric value."

  End If

End Sub

-->

</SCRIPT>

</HEAD>

<BODY>

<H3>Simple Validation</H3><HR>

<FORM NAME="ValidForm">

Enter a value between 1 and 10: 

<INPUT NAME="Text1" TYPE="TEXT" SIZE="2">

<INPUT NAME="Submit" TYPE="BUTTON" VALUE="Submit">

</FORM>

</BODY>

</HTML>

The difference between this text box and the examples on A Simple VBScript Page is that the Value property of the text box is used to check the entered value. To get the Value property, the code has to qualify the reference to the name of the text box.

You can always write out the full reference Document.ValidForm.Text1. However, where you have multiple references to form controls, you’ll want to do what was done here. First declare a variable. Then use the Set statement to assign the form to the variable TheForm. A regular assignment statement, such as Dim, doesn’t work here; you must use Set to preserve the reference to an object.

Using Numeric Values

Notice that the example directly tests the value against a number: it uses the IsNumeric function to make sure the string in the text box is a number. Although VBScript automatically converts strings and numbers, it’s always a good practice to test a user-entered value for its data subtype and to use conversion functions as necessary. When doing addition with text box values, convert the values explicitly to numbers because the plus sign (+) operator represents both addition and string concatenation. For example, if Text1 contains “1″ and Text2 contains “2″, you see the following results:

A = Text1.Value + Text2.Value		' A is "12"

A = CDbl(Text1.Value) + Text2.Value	' A is 3



Validating and Passing Data Back to the Server

The simple validation example uses a plain button control. If a Submit control was used, the example would never see the data to check it—everything would go immediately to the server. Avoiding the Submit control lets you check the data, but it doesn’t submit the data to the server. That requires an additional line of code:

<SCRIPT LANGUAGE="VBScript"> 

<!--

Sub Submit_OnClick

  Dim TheForm

  Set TheForm = Document.ValidForm

  If IsNumeric(TheForm.Text1.Value) Then

    If TheForm.Text1.Value < 1 Or TheForm.Text1.Value > 10 Then

      MsgBox "Please enter a number between 1 and 10."

    Else

      MsgBox "Thank you."

      TheForm.Submit	' Data correct; send to server.

    End If

  Else

    MsgBox "Please enter a numeric value."

  End If

End Sub

-->

</SCRIPT>

To send the data to the server, the code invokes the Submit method on the form object when the data is correct. From there, the server handles the data just as it otherwise would—except that the data is correct before it gets there. You’ll find complete information about the Submit method and other methods on the Internet Explorer Scripting Object Model page.

So far, you’ve seen only the standard HTML <FORM> objects. Internet Explorer also lets you exploit the full power of ActiveX™ controls (formerly called OLE controls) and Java™ objects.

A Simple VBScript Page

A Simple VBScript Page

With Microsoft® Internet Explorer, you can view the page produced by the following HTML code. If you click the button on the page, you see VBScript in action.

<HTML>

<HEAD><TITLE>A Simple First Page</TITLE>

<SCRIPT LANGUAGE="VBScript">

<!--

Sub Button1_OnClick

        MsgBox "Mirabile visu."

End Sub

-->

</SCRIPT>

</HEAD>

<BODY>

<H3>A Simple First Page</H3><HR>

<FORM><INPUT NAME="Button1" TYPE="BUTTON" VALUE="Click Here"></form>

</BODY>

</HTML>

The result is a little underwhelming: a dialog box displays a Latin phrase (“Wonderful to behold”). However, there’s quite a bit going on.

When Internet Explorer reads the page, it finds the <SCRIPT> tags, recognizes there is a piece of VBScript code, and saves the code. When you click the button, Internet Explorer makes the connection between the button and the code, and runs the procedure.

The Sub procedure in the <SCRIPT> tags is an event procedure. There are two parts to the procedure name: the name of the button, Button1 (from the NAME attribute in the <INPUT> tag), and an event name, OnClick. The two names are joined by an underscore(_). Any time the button is clicked, Internet Explorer looks for and runs the corresponding event procedure, Button1_OnClick.

Internet Explorer defines the events available for form controls in the Internet Explorer Scripting Object Model documentation.

Pages can use combinations of controls and procedures, too. VBScript and Forms shows some simple interactions between controls.

Other Ways to Attach Code to Events

Although the preceding way is probably the simplest and most general, you can attach VBScript code to events in two other ways. Internet Explorer allows you to add short sections of inline code in the tag defining the control. For example, the following <INPUT> tag performs the same action as the previous code example when you click the button:

<INPUT NAME="Button1" TYPE="BUTTON"

       VALUE="Click Here" OnClick='MsgBox "Mirabile visu."'>

Notice that the function call itself is enclosed in single quotation marks, and the string for the MsgBox function is enclosed in double quotation marks. You can use multiple statements as long as you separate the statements with colons (:).

You can also write a <SCRIPT> tag so that it applies only to a particular event for a specific control:

<SCRIPT LANGUAGE="VBScript" EVENT="OnClick" FOR="Button1">

<!--

    MsgBox "Mirabile visu."

-->

</SCRIPT>

Because the <SCRIPT> tag already specifies the event and the control, you don’t use Sub and End Sub statements.

VBScript Coding Conventions

VBScript Coding Conventions

What Are Coding Conventions?

Coding conventions are suggestions that may help you write code using Microsoft Visual Basic Scripting Edition. Coding conventions can include the following:

  • Naming conventions for objects, variables, and procedures
  • Commenting conventions
  • Text formatting and indenting guidelines

The main reason for using a consistent set of coding conventions is to standardize the structure and coding style of a script or set of scripts so that you and others can easily read and understand the code. Using good coding conventions results in precise, readable, and unambiguous source code that is consistent with other language conventions and as intuitive as possible.

Constant Naming Conventions

Earlier versions of VBScript had no mechanism for creating user-defined constants. Constants, if used, were implemented as variables and distinguished from other variables using all uppercase characters. Multiple words were separated using the underscore (_) character. For example:

USER_LIST_MAX
NEW_LINE

While this is still an acceptable way to indentify your constants, you may want to use an alternative naming scheme, now that you can create true constants using the Const statement. This convention uses a mixed-case format in which constant names have a “con” prefix. For example:

conYourOwnConstant

Variable Naming Conventions

For purposes of readability and consistency, use the following prefixes with descriptive names for variables in your VBScript code.

Subtype Prefix Example
Boolean bln blnFound
Byte byt bytRasterData
Date (Time) dtm dtmStart
Double dbl dblTolerance
Error err errOrderNum
Integer int intQuantity
Long lng lngDistance
Object obj objCurrent
Single sng sngAverage
String str strFirstName

Variable Scope

Variables should always be defined with the smallest scope possible. VBScript variables can have the following scope.

Scope Where Variable Is Declared Visibility
Procedure-level Event, Function, or Sub procedure Visible in the procedure in which it is declared
Script-level HEAD section of an HTML page, outside any procedure Visible in every procedure in the script

Variable Scope Prefixes

As script size grows, so does the value of being able to quickly differentiate the scope of variables. A one-letter scope prefix preceding the type prefix provides this, without unduly increasing the size of variable names.

Scope Prefix Example
Procedure-level None dblVelocity
Script-level s sblnCalcInProgress

Descriptive Variable and Procedure Names

The body of a variable or procedure name should use mixed case and should be as complete as necessary to describe its purpose. In addition, procedure names should begin with a verb, such as InitNameArray or CloseDialog.

For frequently used or long terms, standard abbreviations are recommended to help keep name length reasonable. In general, variable names greater than 32 characters can be difficult to read. When using abbreviations, make sure they are consistent throughout the entire script. For example, randomly switching between Cnt and Count within a script or set of scripts may lead to confusion.

Object Naming Conventions

The following table lists recommended conventions for objects you may encounter while programming VBScript.

Object type Prefix Example
3D Panel pnl pnlGroup
Animated button ani aniMailBox
Check box chk chkReadOnly
Combo box, drop-down list box cbo cboEnglish
Command button cmd cmdExit
Common dialog dlg dlgFileOpen
Frame fra fraLanguage
Horizontal scroll bar hsb hsbVolume
Image img imgIcon
Label lbl lblHelpMessage
Line lin linVertical
List Box lst lstPolicyCodes
Spin spn spnPages
Text box txt txtLastName
Vertical scroll bar vsb vsbRate
Slider sld sldScale

Code Commenting Conventions

All procedures should begin with a brief comment describing what they do. This description should not describe the implementation details (how it does it) because these often change over time, resulting in unnecessary comment maintenance work, or worse, erroneous comments. The code itself and any necessary inline comments describe the implementation.

Arguments passed to a procedure should be described when their purpose is not obvious and when the procedure expects the arguments to be in a specific range. Return values for functions and variables that are changed by a procedure, especially through reference arguments, should also be described at the beginning of each procedure.

Procedure header comments should include the following section headings. For examples, see the “Formatting Your Code” section that follows.

Section Heading Comment Contents
Purpose What the procedure does (not how).
Assumptions List of any external variable, control, or other element whose state affects this procedure.
Effects List of the procedure’s effect on each external variable, control, or other element.
Inputs Explanation of each argument that isn’t obvious. Each argument should be on a separate line with inline comments.
Return Values Explanation of the value returned.

Remember the following points:

  • Every important variable declaration should include an inline comment describing the use of the variable being declared.
  • Variables, controls, and procedures should be named clearly enough that inline comments are only needed for complex implementation details.
  • At the beginning of your script, you should include an overview that describes the script, enumerating objects, procedures, algorithms, dialog boxes, and other system dependencies. Sometimes a piece of pseudocode describing the algorithm can be helpful.
Formatting Your Code

Screen space should be conserved as much as possible, while still allowing code formatting to reflect logic structure and nesting. Here are a few pointers:

  • Standard nested blocks should be indented four spaces.
  • The overview comments of a procedure should be indented one space.
  • The highest level statements that follow the overview comments should be indented four spaces, with each nested block indented an additional four spaces. For example:

‘*********************************************************
‘ Purpose:  Locates the first occurrence of a specified user
‘           in the UserList array.
‘ Inputs:   strUserList():   the list of users to be searched.
‘           strTargetUser:   the name of the user to search for.
‘ Returns:  The index of the first occurrence of the strTargetUser
‘           in the strUserList array.
‘           If the target user is not found, return -1.
‘*********************************************************

Function intFindUser (strUserList(), strTargetUser)
Dim i                     ‘ Loop counter.
Dim blnFound        ‘ Target found flag
intFindUser = -1
i = 0                     ‘ Initialize loop counter
Do While i <= Ubound(strUserList) and Not blnFound
If strUserList(i) = strTargetUser Then
blnFound = True   ‘ Set flag to True
intFindUser = i   ‘ Set return value to loop count
End If
i = i + 1             ‘ Increment loop counter
Loop
End Function

VBScript Procedures

VBScript Procedures

Kinds of Procedures

In VBScript there are two kinds of procedures; the Sub procedure and the Function procedure.

Sub Procedures

A Sub procedure is a series of VBScript statements, enclosed by Sub and End Sub statements, that perform actions but don’t return a value. A Sub procedure can take arguments (constants, variables, or expressions that are passed by a calling procedure). If a Sub procedure has no arguments, its Sub statement must include an empty set of parentheses ().

The following Sub procedure uses two intrinsic, or built-in, VBScript functions, MsgBox and InputBox, to prompt a user for some information. It then displays the results of a calculation based on that information. The calculation is performed in a Function procedure created using VBScript. The Function procedure is shown after the following discussion.

Sub ConvertTemp()

    temp = InputBox("Please enter the temperature in degrees F.", 1)

    MsgBox "The temperature is " & Celsius(temp) & " degrees C."

 End Sub

Function Procedures

A Function procedure is a series of VBScript statements enclosed by the Function and End Function statements. A Function procedure is similar to a Sub procedure, but can also return a value. A Function procedure can take arguments (constants, variables, or expressions that are passed to it by a calling procedure). If a Function procedure has no arguments, its Function statement must include an empty set of parentheses. A Function returns a value by assigning a value to its name in one or more statements of the procedure. The return type of a Function is always a Variant.

In the following example, the Celsius function calculates degrees Celsius from degrees Fahrenheit. When the function is called from the ConvertTemp Sub procedure, a variable containing the argument value is passed to the function. The result of the calculation is returned to the calling procedure and displayed in a message box.

 Sub ConvertTemp()

     temp = InputBox("Please enter the temperature in degrees F.", 1)

     MsgBox "The temperature is " & Celsius(temp) & " degrees C."

 End Sub



 Function Celsius(fDegrees)

     Celsius = (fDegrees - 32) * 5 / 9

 End Function

Getting Data into and out of Procedures

Each piece of data is passed into your procedures using an argument. Arguments serve as placeholders for the data you want to pass into your procedure. You can name your arguments anything that is valid as a variable name. When you create a procedure using either the Sub statement or the Function statement, parentheses must be included after the name of the procedure. Any arguments are placed inside these parentheses, separated by commas. For example, in the following example, fDegrees is a placeholder for the value being passed into the Celsius function for conversion:

 Function Celsius(fDegrees)

    Celsius = (fDegrees - 32) * 5 / 9

 End Function

To get data out of a procedure, you must use a Function. Remember, a Function procedure can return a value; a Sub procedure can’t.

Using Sub and Function Procedures in Code

A Function in your code must always be used on the right side of a variable assignment or in an expression. For example:

 Temp = Celsius(fDegrees)

or

 MsgBox "The Celsius temperature is " & Celsius(fDegrees) & " degrees."



To call a Sub procedure from another procedure, you can just type the name of the procedure along with values for any required arguments, each separated by a comma. The Call statement is not required, but if you do use it, you must enclose any arguments in parentheses.

The following example shows two calls to the MyProc procedure. One uses the Call statement in the code; the other doesn’t. Both do exactly the same thing.

 Call MyProc(firstarg, secondarg)

 MyProc firstarg, secondarg

Notice that the parentheses are omitted in the call when the Call statement isn’t used.

Looping Through Code

Looping Through Code

Using Loops to Repeat Code

Looping allows you to run a group of statements repeatedly. Some loops repeat statements until a condition is False; others repeat statements until a condition is True. There are also loops that repeat statements a specific number of times.

The following looping statements are available in VBScript:

  • Do…Loop: Loops while or until a condition is True.
  • While…Wend: Loops while a condition is True.
  • For…Next: Uses a counter to run statements a specified number of times.
  • For Each…Next: Repeats a group of statements for each item in a collection or each element of an array.
Using Do Loops

You can use Do…Loop statements to run a block of statements an indefinite number of times. The statements are repeated either while a condition is True or until a condition becomes True.

Repeating Statements While a Condition is True

Use the While keyword to check a condition in a Do…Loop statement. You can check the condition before you enter the loop (as shown in the following ChkFirstWhile example), or you can check it after the loop has run at least once (as shown in the ChkLastWhile example). In the ChkFirstWhile procedure, if myNum is set to 9 instead of 20, the statements inside the loop will never run. In the ChkLastWhile procedure, the statements inside the loop run only once because the condition is already False.

Sub ChkFirstWhile()
Dim counter, myNum
counter = 0
myNum = 20
Do While myNum > 10
myNum = myNum – 1
counter = counter + 1
Loop
MsgBox “The loop made ” & counter & ” repetitions.”
End Sub

Sub ChkLastWhile()
Dim counter, myNum
counter = 0
myNum = 9
Do
myNum = myNum – 1
counter = counter + 1
Loop While myNum > 10
MsgBox “The loop made ” & counter & ” repetitions.”
End Sub

Repeating a Statement Until a Condition Becomes True

You can use the Until keyword in two ways to check a condition in a Do…Loop statement. You can check the condition before you enter the loop (as shown in the following ChkFirstUntil example), or you can check it after the loop has run at least once (as shown in the ChkLastUntil example). As long as the condition is False, the looping occurs

Sub ChkFirstUntil()
Dim counter, myNum
counter = 0
myNum = 20
Do Until myNum = 10
myNum = myNum – 1
counter = counter + 1
Loop
MsgBox “The loop made ” & counter & ” repetitions.”
End Sub

Sub ChkLastUntil()
Dim counter, myNum
counter = 0
myNum = 1
Do
myNum = myNum + 1
counter = counter + 1
Loop Until myNum = 10
MsgBox “The loop made ” & counter & ” repetitions.”
End Sub

Exiting a Do…Loop Statement from Inside the Loop

You can exit a Do…Loop by using the Exit Do statement. Because you usually want to exit only in certain situations, such as to avoid an endless loop, you should use the Exit Do statement in the True statement block of an If…Then…Else statement. If the condition is False, the loop runs as usual.

In the following example, myNum is assigned a value that creates an endless loop. The If…Then…Else statement checks for this condition, preventing the endless repetition.

Sub ExitExample()
Dim counter, myNum
counter = 0
myNum = 9
Do Until myNum = 10
myNum = myNum – 1
counter = counter + 1
If myNum < 10 Then Exit Do
Loop
MsgBox “The loop made ” & counter & ” repetitions.”
End Sub

Using While…Wend

The While…Wend statement is provided in VBScript for those who are familiar with its usage. However, because of the lack of flexibility in While…Wend, it is recommended that you use Do…Loop instead.

Using For…Next

You can use For…Next statements to run a block of statements a specific number of times. For loops, use a counter variable whose value is increased or decreased with each repetition of the loop.

For example, the following procedure causes a procedure called MyProc to execute 50 times. The For statement specifies the counter variable x and its start and end values. The Next statement increments the counter variable by 1.

 Sub DoMyProc50Times()

     Dim x

     For x = 1 To 50

         MyProc

     Next

 End Sub

Using the Step keyword, you can increase or decrease the counter variable by the value you specify. In the following example, the counter variable j is incremented by 2 each time the loop repeats. When the loop is finished, total is the sum of 2, 4, 6, 8, and 10.

Sub TwosTotal()
Dim j, total
For j = 2 To 10 Step 2
total = total + j
Next
MsgBox “The total is ” & total
End Sub

To decrease the counter variable, you use a negative Step value. You must specify an end value that is less than the start value. In the following example, the counter variable myNum is decreased by 2 each time the loop repeats. When the loop is finished, total is the sum of 16, 14, 12, 10, 8, 6, 4, and 2.

 Sub NewTotal()

     Dim myNum, total

     For myNum = 16 To 2 Step -2

         total = total + myNum

     Next

     MsgBox "The total is " & total

 End Sub

You can exit any For…Next statement before the counter reaches its end value by using the Exit For statement. Because you usually want to exit only in certain situations, such as when an error occurs, you should use the Exit For statement in the True statement block of an If…Then…Else statement. If the condition is False, the loop runs as usual.

Using For Each…Next

A For Each…Next loop is similar to a For…Next loop. Instead of repeating the statements a specified number of times, a For Each…Next loop repeats a group of statements for each item in a collection of objects or for each element of an array. This is especially helpful if you don’t know how many elements are in a collection.

In the following HTML code example, the contents of a Dictionary object is used to place text in several text boxes:

 <HTML>

 <HEAD><TITLE>Forms and Elements</TITLE></HEAD>

 <SCRIPT LANGUAGE="VBScript">

 <!--

 Sub cmdChange_OnClick

    Dim d                   'Create a variable 

    Set d = CreateObject("Scripting.Dictionary")

    d.Add "0", "Athens"     'Add some keys and items

    d.Add "1", "Belgrade"

    d.Add "2", "Cairo"



    For Each I in d

        Document.frmForm.Elements(I).Value = D.Item(I)

    Next

 End Sub

 -->

 </SCRIPT>

 <BODY>

<CENTER>

 <FORM NAME="frmForm"



 <Input Type = "Text"><p>

 <Input Type = "Text"><p>

 <Input Type = "Text"><p>

 <Input Type = "Text"><p>

 <Input Type = "Button" NAME="cmdChange" VALUE="Click Here"><p>

 </FORM>

 </CENTER>

 </BODY>

 </HTML>

Using Conditional Statements

Using Conditional Statements

Controlling Program Execution

You can control the flow of your script with conditional statements and looping statements. Using conditional statement, you can write VBScript code that makes decisions and repeats actions. The following conditional statements are available in VBScript:

  • If…Then…Else statement
  • Select Case statement
Making Decisions Using If…Then…Else

The If…Then…Else statement is used to evaluate whether a condition is True or False and, depending on the result, to specify one or more statements to run. Usually the condition is an expression that uses a comparison operator to compare one value or variable with another. For information about comparison operators, see Comparison Operators. If…Then…Else statements can be nested to as many levels as you need.

Running Statements if a Condition is True

To run only one statement when a condition is True, use the single-line syntax for the If…Then…Else statement. The following example shows the single-line syntax. Notice that this example omits the Else keyword.

Sub FixDate()

     Dim myDate

     myDate = #2/13/95#

     If myDate < Now Then myDate = Now

 End Sub

To run more than one line of code, you must use the multiple-line (or block) syntax. This syntax includes the End If statement, as shown in the following example:

 Sub AlertUser(value)

     If value = 0 Then

         AlertLabel.ForeColor = vbRed

         AlertLabel.Font.Bold = True

         AlertLabel.Font.Italic = True

     End If

 End Sub

Running Certain Statements if a Condition is True and Running Others if a Condition is False

You can use an If…Then…Else statement to define two blocks of executable statements: one block to run if the condition is True, the other block to run if the condition is False.

Sub AlertUser(value)

     If value = 0 Then

         AlertLabel.ForeColor = vbRed

         AlertLabel.Font.Bold = True

         AlertLabel.Font.Italic = True

     Else

         AlertLabel.Forecolor = vbBlack

         AlertLabel.Font.Bold = False

         AlertLabel.Font.Italic = False

     End If

 End Sub

Deciding Between Several Alternatives

A variation on the If…Then…Else statement allows you to choose from several alternatives. Adding ElseIf clauses expands the functionality of the If…Then…Else statement so you can control program flow based on different possibilities. For example:

 Sub ReportValue(value)

     If value = 0 Then

         MsgBox value

     ElseIf value = 1 Then

         MsgBox value

     ElseIf value = 2 then

         Msgbox value

     Else

         Msgbox "Value out of range!"

     End If

You can add as many ElseIf clauses as you need to provide alternative choices. Extensive use of the ElseIf clauses often becomes cumbersome. A better way to choose between several alternatives is the Select Case statement.

Making Decisions with Select Case

The Select Case structure provides an alternative to If…Then…ElseIf for selectively executing one block of statements from among multiple blocks of statements. A Select Case statement provides capability similar to the If…Then…Else statement, but it makes code more efficient and readable.

A Select Case structure works with a single test expression that is evaluated once, at the top of the structure. The result of the expression is then compared with the values for each Case in the structure. If there is a match, the block of statements associated with that Case is executed:

Select Case Document.Form1.CardType.Options(SelectedIndex).Text

    Case "MasterCard"

        DisplayMCLogo

        ValidateMCAccount

    Case "Visa"

        DisplayVisaLogo

        ValidateVisaAccount

    Case "American Express"

        DisplayAMEXCOLogo

        ValidateAMEXCOAccount

    Case Else

        DisplayUnknownImage

        PromptAgain

End Select

Notice that the Select Case structure evaluates an expression once at the top of the structure. In contrast, the If…Then…ElseIf structure can evaluate a different expression for each ElseIf statement. You can replace an If…Then…ElseIf structure with a Select Case structure only if each ElseIf statement evaluates the same expression.

VBScript Operators

VBScript Operators

VBScript has a full range of operators, including arithmetic operators, comparison operators, concatenation operators, and logical operators.

Operator Precedence

When several operations occur in an expression, each part is evaluated and resolved in a predetermined order called operator precedence. You can use parentheses to override the order of precedence and force some parts of an expression to be evaluated before others. Operations within parentheses are always performed before those outside. Within parentheses, however, standard operator precedence is maintained.

When expressions contain operators from more than one category, arithmetic operators are evaluated first, comparison operators are evaluated next, and logical operators are evaluated last. Comparison operators all have equal precedence; that is, they are evaluated in the left-to-right order in which they appear. Arithmetic and logical operators are evaluated in the following order of precedence.

Arithmetic Comparison Logical
Description Symbol Description Symbol Description Symbol
Exponentiation ^ Equality = Logical negation Not
Unary negation - Inequality <> Logical conjunction And
Multiplication * Less than < Logical disjunction Or
Division / Greater than > Logical exclusion Xor
Integer division \ Less than or equal to <= Logical equivalence Eqv
Modulus arithmetic Mod Greater than or equal to >= Logical implication Imp
Addition + Object equivalence Is
Subtraction -
String concatenation &

When multiplication and division occur together in an expression, each operation is evaluated as it occurs from left to right. Likewise, when addition and subtraction occur together in an expression, each operation is evaluated in order of appearance from left to right.

The string concatenation (&) operator is not an arithmetic operator, but in precedence it does fall after all arithmetic operators and before all comparison operators. The Is operator is an object reference comparison operator. It does not compare objects or their values; it checks only to determine if two object references refer to the same object.

VBScript Constants

VBScript Constants

What Is a Constant?

A constant is a meaningful name that takes the place of a number or string and never changes. VBScript defines a number of intrinsic constants. You can get information about these intrinsic constants from the VBScript Language Reference.

Creating Constants

You create user-defined constants in VBScript using the Const statement. Using the Const statement, you can create string or numeric constants with meaningful names and assign them literal values. For example:

Const MyString = "This is my string."

Const MyAge = 49

Note that the string literal is enclosed in quotation marks (” “). Quotation marks are the most obvious way to differentiate string values from numeric values. Date literals and time literals are represented by enclosing them in number signs (#). For example:

Const CutoffDate = #6-1-97#

You may want to adopt a naming scheme to differentiate constants from variables. This will prevent you from trying to reassign constant values while your script is running. For example, you might want to use a “vb” or “con” prefix on your constant names, or you might name your constants in all capital letters. Differentiating constants from variables eliminates confusion as you develop more complex scripts.

VBScript Variables

VBScript Variables

What Is a Variable?

A variable is a convenient placeholder that refers to a computer memory location where you can store program information that may change during the time your script is running. For example, you might create a variable called ClickCount to store the number of times a user clicks an object on a particular Web page. Where the variable is stored in computer memory is unimportant. What’s important is that you only have to refer to a variable by name to see its value or to change its value. In VBScript, variables are always of one fundamental data type, Variant.

Declaring Variables

You declare variables explicitly in your script using the Dim statement, the Public statement, and the Private statement. For example:

 Dim DegreesFahrenheit

You declare multiple variables by separating each variable name with a comma. For example:

 Dim Top, Bottom, Left, Right

You can also declare a variable implicitly by simply using its name in your script. That’s not generally a good practice because you could misspell the variable name in one or more places, causing unexpected results when your script is run. For that reason, the Option Explicit statement is available to require explicit declaration of all variables. The Option Explicit statement should be the first statement in your script.

Naming Restrictions

Variable names follow the standard rules for naming anything in VBScript. A variable name:

  • Must begin with an alphabetic character.
  • Cannot contain an embedded period.
  • Must not exceed 255 characters.
  • Must be unique in the scope in which it is declared.
Scope and Lifetime of Variables

A variable’s scope is determined by where you declare it. When you declare a variable within a procedure, only code within that procedure can access or change the value of that variable. It has local scope and is called a procedure-level variable. If you declare a variable outside a procedure, you make it recognizable to all the procedures in your script. This is a script-level variable, and it has script-level scope.

How long a variable exists is its lifetime. The lifetime of a script-level variable extends from the time it’s declared until the time the script is finished running. At procedure level, a variable exists only as long as you are in the procedure. When the procedure exits, the variable is destroyed. Local variables are ideal as temporary storage space when a procedure is executing. You can have local variables of the same name in several different procedures because each is recognized only by the procedure in which it is declared.

Assigning Values to Variables

Values are assigned to variables creating an expression as follows: the variable is on the left side of the expression and the value you want to assign to the variable is on the right. For example:

 B = 200
Scalar Variables and Array Variables

Much of the time, you just want to assign a single value to a variable you’ve declared. A variable containing a single value is a scalar variable. Other times, it’s convenient to assign more than one related value to a single variable. Then you can create a variable that can contain a series of values. This is called an array variable. Array variables and scalar variables are declared in the same way, except that the declaration of an array variable uses parentheses ( ) following the variable name. In the following example, a single-dimension array containing 11 elements is declared:

 Dim A(10)

Although the number shown in the parentheses is 10, all arrays in VBScript are zero-based, so this array actually contains 11 elements. In a zero-based array, the number of array elements is always the number shown in parentheses plus one. This kind of array is called a fixed-size array.

You assign data to each of the elements of the array using an index into the array. Beginning at zero and ending at 10, data can be assigned to the elements of an array as follows:

 A(0) = 256

 A(1) = 324

 A(2) = 100

 . . .

 A(10) = 55

Similarly, the data can be retrieved from any element using an index into the particular array element you want. For example:

 . . . 

 SomeVariable = A(8)  

 . . . 

Arrays aren’t limited to a single dimension. You can have as many as 60 dimensions, although most people can’t comprehend more than three or four dimensions. Multiple dimensions are declared by separating an array’s size numbers in the parentheses with commas. In the following example, the MyTable variable is a two-dimensional array consisting of 6 rows and 11 columns:

 Dim MyTable(5, 10)

In a two-dimensional array, the first number is always the number of rows; the second number is the number of columns.

You can also declare an array whose size changes during the time your script is running. This is called a dynamic array. The array is initially declared within a procedure using either the Dim statement or using the ReDim statement. However, for a dynamic array, no size or number of dimensions is placed inside the parentheses. For example:

 Dim MyArray()

 ReDim AnotherArray()

To use a dynamic array, you must subsequently use ReDim to determine the number of dimensions and the size of each dmension. In the following example, ReDim sets the initial size of the dynamic array to 25. A subsequent ReDim statement resizes the array to 30, but uses the Preserve keyword to preserve the contents of the array as the resizing takes place.

 ReDim MyArray(25)

 . . . 

 ReDim Preserve MyArray(30)

There is no limit to the number of times you can resize a dynamic array, but you should know that if you make an array smaller than it was, you lose the data in the eliminated elements.

VBScript Data Types

VBScript Data Types

What Are VBScript Data Types?

VBScript has only one data type called a Variant. A Variant is a special kind of data type that can contain different kinds of information, depending on how it’s used. Because Variant is the only data type in VBScript, it’s also the data type returned by all functions in VBScript.

At its simplest, a Variant can contain either numeric or string information. A Variant behaves as a number when you use it in a numeric context and as a string when you use it in a string context. That is, if you’re working with data that looks like numbers, VBScript assumes that it is numbers and does the thing that is most appropriate for numbers. Similarly, if you’re working with data that can only be string data, VBScript treats it as string data. Of course, you can always make numbers behave as strings by enclosing them in quotation marks (” “).

Variant Subtypes

Beyond the simple numeric or string classifications, a Variant can make further distinctions about the specific nature of numeric information. For example, you can have numeric information that represents a date or a time. When used with other date or time data, the result is always expressed as a date or a time. Of course, you can also have a rich variety of numeric information ranging in size from Boolean values to huge floating-point numbers. These different categories of information that can be contained in a Variant are called subtypes. Most of the time, you can just put the kind of data you want in a Variant, and the Variant behaves in a way that is most appropriate for the data it contains.

The following table shows the subtypes of data that a Variant can contain.

Subtype Description
Empty Variant is uninitialized. Value is 0 for numeric variables or a zero-length string (“”) for string variables.
Null Variant intentionally contains no valid data.
Boolean Contains either True or False.
Byte Contains integer in the range 0 to 255.
Integer Contains integer in the range -32,768 to 32,767.
Currency -922,337,203,685,477.5808 to 922,337,203,685,477.5807.
Long Contains integer in the range -2,147,483,648 to 2,147,483,647.
Single Contains a single-precision, floating-point number in the range -3.402823E38 to -1.401298E-45 for negative values; 1.401298E-45 to 3.402823E38 for positive values.
Double Contains a double-precision, floating-point number in the range -1.79769313486232E308 to -4.94065645841247E-324 for negative values; 4.94065645841247E-324 to 1.79769313486232E308 for positive values.
Date (Time) Contains a number that represents a date between January 1, 100 to December 31, 9999.
String Contains a variable-length string that can be up to approximately 2 billion characters in length.
Object Contains an object.
Error Contains an error number.

You can use conversion functions to convert data from one subtype to another. In addition, the VarType function returns information about how your data is stored within a Variant.

VbScript Basics

You can use the SCRIPT element to add VBScript code to an HTML page.

The <SCRIPT> Tag

VBScript code is written within paired <SCRIPT> tags. For example, a procedure to test a delivery date might appear as follows:



<SCRIPT LANGUAGE="VBScript"> 

<!--

   Function CanDeliver(Dt)

      CanDeliver = (CDate(Dt) - Now()) > 2

   End Function

-->

</SCRIPT>

Beginning and ending <SCRIPT> tags surround the code. The LANGUAGE attribute indicates the scripting language. You must specify the language because browsers can use other scripting languages. Notice that the CanDeliver function is embedded in comment tags (<!– and –>). This prevents browsers that don’t understand the <SCRIPT> tag from displaying the code.

Since the example is a general function—it isn’t tied to any particular form control—you can include it in the HEAD section of the page:



<HTML>

<HEAD>

<TITLE>Place Your Order</TITLE>

<SCRIPT LANGUAGE="VBScript">

<!--

   Function CanDeliver(Dt)

      CanDeliver = (CDate(Dt) - Now()) > 2

   End Function

-->

</SCRIPT>

</HEAD>

<BODY>

...

You can use SCRIPT blocks anywhere in an HTML page. You can put them in both the BODY and HEAD sections. However, you’ll probably want to put all general-purpose scripting code in the HEAD section in order to keep all the code together. Keeping your code in the HEAD section ensures that all code is read and decoded before it’s needed by any calls from within the BODY section.

One notable exception to this rule is that you may want to provide inline scripting code within forms to respond to the events of objects in your form. For example, you can embed scripting code to respond to a button click in a form:



<HTML>

<HEAD>

<TITLE>Test Button Events</TITLE>

</HEAD>

<BODY>

<FORM NAME="Form1">

   <INPUT TYPE="Button" NAME="Button1" VALUE="Click">

   <SCRIPT FOR="Button1" EVENT="onClick" LANGUAGE="VBScript">

      MsgBox "Button Pressed!"

   </SCRIPT>

</FORM>

</BODY>

</HTML>

Most of your code will appear in either Sub or Function procedures and will be called only when code you have written causes it to execute. However, you can write VBScript code outside procedures, but still within a SCRIPT block. This code is executed only once, when the HTML page loads. This allows you to initialize data or dynamically change the look of your Web page when it loads

What is Vbscript ?

What is Vbscript  ?

Microsoft Visual Basic Scripting Edition, the newest member of the Visual Basic family of programming languages, brings active scripting to a wide variety of environments, including Web client scripting in Microsoft Internet Explorer and Web server scripting in Microsoft Internet Information server.

Easy to Use and Learn

If you already know Visual Basic or Visual Basic for Applications, VBScript will be very familiar. Even if you don’t know Visual Basic, once you learn VBScript, you’re on your way to programming with the whole family of Visual Basic languages. Although you can learn about VBScript in just these few Web pages, they don’t teach you how to program. To get started programming, take a look at Step by Step books available from Microsoft Press.

ActiveX Scripting

VBScript talks to host applications using ActiveX™ Scripting. With ActiveX Scripting, browsers and other host applications don’t require special integration code for each scripting component. ActiveX Scripting enables a host to compile scripts, obtain and call entry points, and manage the namespace available to the developer. With ActiveX Scripting, language vendors can create standard language run times for scripting. Microsoft will provide run-time support for VBScript. Microsoft is working with various Internet groups to define the ActiveX Scripting standard so that scripting engines can be interchangeable. ActiveX Scripting is used in Microsoft® Internet Explorer and in Microsoft® Internet Information Server.

VBScript in Other Applications and Browsers

As a developer, you can license VBScript source implementation at no charge for use in your products. Microsoft provides binary implementations of VBScript for the 32-bit Windows® API, the 16-bit Windows API, and the Macintosh®. VBScript is integrated with World Wide Web browsers. VBScript and ActiveX Scripting can also be used as a general scripting language in other applications.