Programming Objects

Although this chapter isn’t a programming primer per se, we’d like to take some time now to run through a few quick notes about programming objects. This will serve you well throughout the rest of the chapter as we take you on a tour of a few Windows Script Host objects.

Note

If you’re new to VBScript, see the following MSDN site for some language tutorials:

http://msdn.microsoft.com/library/en-us/script56/html/vbstutor.asp

The following MSDN site has a VBScript language reference:

http://msdn.microsoft.com/library/en-us/script56/html/vbscripttoc.asp

The dictionary definition of an object is “anything perceptible by one or more of the senses, especially something that can be seen and felt.” In scripting, an object is an application element that exposes an “interface” to the programmer, who can then perform the programming equivalent of seeing and feeling:

• You can make changes to the object’s properties (this is the seeing part).

• You can make the object perform a task by activating a method associated with the object (this is the feeling part).

Working with Object Properties

Every programmable object has a defining set of characteristics. These characteristics are called the object’s properties, and they control the appearance and position of the object. For example, the WScript object (the top-level Windows Script Host object) has an Interactive property that determines whether the script runs in interactive mode or batch mode.

When you refer to a property, you use the following syntax:

 Object.Property 

Object	This is the name of the object.
Property	This is the name of the property you want to work with.

For example, the following expression refers to the Interactive property of the WScript object:

WScript.Interactive

Setting the Value of a Property

To set a property to a certain value, you use the following syntax:

 Object.Property = value 

Here, value is an expression that specifies the value to which you want to set the property. As such, it can be any of the scripting language’s recognized data types, which usually include the following:

• A numeric value.

• A string value, enclosed in double-quotation marks (such as “My Script Application”).

• A logical value: True or False.

For example, the following VBScript statement tells the Windows Script Host to run the script using interactive mode:

WScript.Interactive = True

Returning the Value of a Property

Sometimes you need to know the current setting of a property before changing the property or performing some other action. You can find out the current value of a property by using the following syntax:

 variable = Object.Property. 

Here, variable is a variable name or another property. For example, the following statement stores the current script mode in a variable named currentMode:

currentMode = WScript.Interactive

Working with Object Methods

An object’s properties describe what the object is, whereas its methods describe what the object does. For example, the WScript object has a Quit method that enables you to stop the execution of a script.

How you refer to a method depends on whether or not the method requires any arguments. If it doesn’t, the syntax is similar to that of properties:

 Object.Method 

Object	This is the name of the object.
Method	This is the name of the method you want to work with.

For example, the following statement shuts down a script:

WScript.Quit

If the method requires arguments, you use the following syntax:

 Object.Method (Argument1, Argument2, ...) 

For example, the WshShell object has a RegWrite method that you use to write a key or setting to the registry. (We discuss this object and method in detail later in this chapter; see “Working with Registry Entries.”) Here’s the syntax:

WshShell.RegWrite strName, anyValue, [strType]

strName	The name of the registry key or setting.
anyValue	The value to write. If strName is a key, enter the null string (""); if strName is a registry setting, enter the value of the setting.
strType	The data type of anyValue.

Our Naming Conventions

When presenting method arguments in this chapter, we’ll follow Microsoft’s naming conventions, including the use of the following prefixes for the argument names:

Prefix	Data type
any	Any type
b	Boolean
int	Integer
n	Natural number
obj	Object
str	String

For many object methods, not all the arguments are required. In the RegWrite method, for example, the strName and anyValue arguments are required, but the strType argument is not. Throughout this chapter, we differentiate between required and optional arguments by surrounding any optional arguments with square brackets—for example, [strType].

For example, the following statement creates a new registry value named Test and sets it equal to Foo:

WshShell.RegWrite “HKCU\Software\Microsoft\Windows Script Host\” & _“Test\", “Foo", “REG_SZ”

Tip

In VBScript, parentheses around the argument list are necessary only if you’ll be storing the result of the method in a variable or object property. For example, later in this chapter you’ll learn how to use the WshShell object’s Popup method to display a dialog box to the user. This method returns an integer value that tells you which button the user clicked to close the dialog box. One way to capture that result is to store it in a variable, as in this example:

intResult = objWshShell.Popup("Test Dialog Box")

Assigning an Object to a Variable

In VBScript, you assign an object to a variable by using a Set statement. Set has the following syntax:

 Set variableName = ObjectName 

variableName	The name of the variable.
ObjectName	The name of the object you want to assign to the variable.

You may find that you must often use a programming technology called Automation to access external objects (see “Scripting and Automation,” later in this chapter, for details). For example, if you want to work with files and folders in your script, you must access the scripting engine object named FileSystemObject (see “Programming the VBScript FileSystemObject,” later in this chapter). To get this access, you use the CreateObject method and store the resulting object in a variable, like so:

Set fs = CreateObject(“Scripting.FileSystemObject”)

Working with Object Collections

A collection is a set of similar objects. For example, WScript.Arguments is the set of all the arguments specified on the script’s command line. Collections are objects, too, so they have their own properties and methods, and you can use the properties and methods to manipulate one or more objects in the collection.

The members of a collection are called the elements of the collection. You can refer to individual elements by using an index. For example, the following statement refers to the first command line argument (collection indexes always begin at 0):

WScript.Arguments(0)

If you don’t specify an element, the Windows Script Host assumes you want to work with the entire collection.

VBScript provides the For...Next loop to enable you to cycle through a chunk of code a specified number of times. For example, the following code loops 10 times:

For counter = 1 To 10     ’Code entered here is repeated 10 times Next counter

A useful variation on this theme is the For Each...Next loop, which operates on a collection of objects. You don’t need a loop counter because VBScript just loops through the individual elements in the collection and performs—on each element—whatever operations are inside the loop. Here’s the structure of the basic For Each...Next loop:

For Each element In collection
[statements]
Next

element	A variable used to temporarily hold the name of each element in the collection.
collection	The name of the collection.
statements	The statements to be executed for each element in the collection.

The following code loops through all the arguments specified on the script’s command line and displays each argument:

For Each arg In WScript.Arguments
WScript.Echo arg
Next