Learning VBScript for QTP

We can learn the VBScript without QTP also. You need Notepad and command prompt on your system and follow below steps:

1. Create a notepad file.
2. Write a small VBScript in the notepad file.

e.g.

Option Explicit
Dim myResponse
myResponse = MsgBox(“Do you wish to quit?”, 1, “What do you wish to do?”)

1. Save the above Notepad file as Test.vbs.
2. Run above file from the command prompt using CScript.exe.
3. C:\>CScript.exe Test.vbs
4. You will be getting the result of your script.

Descriptive programming in QTP
Whenever QTP records any action on any object of an application, it adds some description on how to recognize that object to a repository of objects called object repository. QTP cannot take action on an object until unless its object description is in the Object Repository. But descriptive programming provides a way to perform action on objects which are not in Object repository

Object Identification:
To identify an object during the play back of the scripts QTP stores some properties which helps QTP to uniquely identify the object on a page. Below screen shots shows an example Object repository:Now to recognize a radio button on a page QTP had added 2 properties the name of the radio button and the html tag for it. The name the left tree view is the logical name given by QTP for the object. This can be changed as per the convenience of the person writing the test case. QTP only allows UNIQUE logical name under same level of hierarchy. As we see in the snapshot the two objects in Browser->Page node are “WebTable” and “testPath”, they cannot have the same logical name. But an object under some other node can have the same name. Now with the current repository that we have, we can only write operation on objects which are in the repository. Some of the example operations are given below

Browser(“Browser”).Page(“Page”).WebRadioGroup (“testPath”).Select “2″
cellData = Browser(“Browser”).Page(“Page”).WebTable (“WebTable”).GetCellData (1,1)
Browser(“Example2″).Page(“Page”).WebEdit(“testPath”).Set “Test text” When and

Why to use Descriptive programming?
Below are some of the situations when Descriptive Programming can be considered useful:
The objects in the application are dynamic in nature and need special handling to identify the object. The best example would be of clicking a link which changes according to the user of the application, Ex. “Logout <<UserName>>”.
When object repository is getting huge due to the no. of objects being added. If the size of Object repository increases too much then it decreases the performance of QTP while recognizing a object.
When you don’t want to use object repository at all. Well the first question would be why not Object repository? Consider the following scenario which would help understand why not Object repository

Scenario 1: Suppose we have a web application that has not been developed yet. Now QTP for recording the script and adding the objects to repository needs the application to be up, that would mean waiting for the application to be deployed before we can start of with making QTP scripts. But if we know the descriptions of the objects that will be created then we can still start off with the script writing for testing

Scenario 2: Suppose an application has 3 navigation buttons on each and every page. Let the buttons be “Cancel”, “Back” and “Next”. Now recording action on these buttons would add 3 objects per page in the repository. For a 10 page flow this would mean 30 objects which could have been represented just by using 3 objects. So instead of adding these 30 objects to the repository we can just write 3 descriptions for the object and use it on any page.Modification to a test case is needed but the Object repository for the same is Read only or in shared mode i.e. changes may affect other scripts as well.
When you want to take action on similar type of object i.e. suppose we have 20 textboxes on the page and there names are in the form txt_1, txt_2, txt_3 and so on. Now adding all 20 the Object repository would not be a good programming approach.

How to use Descriptive programming?

There are two ways in which descriptive programming can be used
By creating properties collection object for the description.
By giving the description in form of the string arguments.By creating properties collection object for the description.To use this method you need first to create an empty description

Dim obj_Desc ‘Not necessary to declare
Set obj_Desc = Description.Create

Now we have a blank description in “obj_Desc”. Each description has 3 properties “Name”, “Value” and “Regular Expression”.

obj_Desc(“html tag”).value= “INPUT”

When you use a property name for the first time the property is added to the collection and when you use it again the property is modified. By default each property that is defined is a regular expression. Suppose if we have the following description

obj_Desc(“html tag”).value= “INPUT
” obj_Desc(“name”).value= “txt.*”

This would mean an object with html tag as INPUT and name starting with txt. Now actually that “.*” was considered as regular expression. So, if you want the property “name” not to be recognized as a regular expression then you need to set the “regularexpression” property as FALSE

obj_Desc(“html tag”).value= “INPUT”
obj_Desc(“name”).value= “txt.*”
obj_Desc(“name”).regularexpression= “txt.*”

This is how of we create a description. Now below is the way we can use it

Browser(“Browser”).Page(“Page”).WebEdit(obj_Desc).set “Test”

When we say .WebEdit(obj_Desc) we define one more property for our description that was not earlier defined that is it’s a text box (because QTPs WebEdit boxes map to text boxes in a web page).If we know that we have more than 1 element with same description on the page then we must define “index” property for the that descriptionConsider the HTML code given below

<INPUT type=”textbox” name=”txt_Name”>
<INPUT type=”textbox” name=”txt_Name”>

Now the html code has two objects with same description. So distinguish between these 2 objects we will use the “index” property. Here is the description for both the object

For 1st textbox:
obj_Desc(“html tag”).value= “INPUT”
obj_Desc(“name”).value= “txt_Name
” obj_Desc(“index”).value= “0”

For 2nd textbox:
obj_Desc(“html tag”).value= “INPUT”
obj_Desc(“name”).value= “txt_Name”
obj_Desc(“index”).value= “1”

Consider the HTML Code given below:

<INPUT type=”textbox” name=”txt_Name”>
<INPUT type=”radio” name=”txt_Name”> We can use the same description for both the objects and still distinguish between both of themobj_Desc(“html tag”).value= “INPUT”
obj_Desc(“name”).value= “txt_Name”

When I want to refer to the textbox then I will use the inside a WebEdit object and to refer to the radio button I will use the description object with the WebRadioGroup object.Browser(“Browser”).Page(“Page”).WebEdit(obj_Desc).set “Test” ‘Refers to the text box
Browser(“Browser”).Page(“Page”).WebRadioGroup(obj_Desc).set “Test” ‘Refers to the radio button

But if we use WebElement object for the description then we must define the “index” property because for a webelement the current description would return two objects.

Hierarchy of test description:
When using programmatic descriptions from a specific point within a test object hierarchy, you must continue to use programmatic descriptions from that point onward within the same statement. If you specify a test object by its object repository name after other objects in the hierarchy have been described using programmatic descriptions, QuickTest cannot identify the object.For example, you can use Browser(Desc1).Page(Desc1).Link(desc3), since it uses programmatic descriptions throughout the entire test object hierarchy. You can also use Browser(“Index”).Page(Desc1).Link(desc3), since it uses programmatic descriptions from a certain point in the description (starting from the Page object description).However, you cannot use Browser(Desc1).Page(Desc1).Link(“Example1″), since it uses programmatic descriptions for the Browser and Page objects but then attempts to use an object repository name for the Link test object (QuickTest tries to locate the Link object based on its name, but cannot locate it in the repository because the parent objects were specified using programmatic descriptions).Getting Child Object:
We can use description object to get all the objects on the page that matches that specific description. Suppose we have to check all the checkboxes present on a web page. So we will first create an object description for a checkboxe and then get all the checkboxes from the pageDim obj_ChkDesc
Set obj_ChkDesc=Description.Create
obj_ChkDesc(“html tag”).value = “INPUT”
obj_ChkDesc(“type”).value = “checkbox”

Dim allCheckboxes, singleCheckBox
Set allCheckboxes = Browse(“Browser”).Page(“Page”).ChildObjects(obj_ChkDesc)
For each singleCheckBox in allCheckboxessingleCheckBox.Set “ON”

Next
The above code will check all the check boxes present on the page. To get all the child objects we need to specify an object description i.e. we can’t use the string arguments that will be discussed later in the 2nd way of using the programming description.Possible Operation on Description Object Consider the below code for all the solutions
Dim obj_ChkDesc Set obj_ChkDesc=Description.Create
obj_ChkDesc(“html tag”).value = “INPUT”
obj_ChkDesc(“type”).value = “checkbox”

Next Step – Variable Declaration

Managing Files and Folders
As you have already seen this afternoon the FileSystemObject is actually fairly easy to work with. All that you have to do is establish an instance of it and you can start using its properties and methods. In the sections that follow you’ll see examples of how to use this object to create, copy, move, and delete files and folders.
Copying Files
Using the FileSystemObject object’s CopyFile() method you can copy one or more files. For example, you might want to copy all the files in the folder on your computer to a network drive at the end of each day. I’ll show you how to work with network drives this evening. For now let’s just focus on how the CopyFile() method works.The first step in copying a file is to set up an instance of the FileSystemObject. Then you can execute its CopyFile() method as shown here.

Set fsoObject = CreateObject("Scripting.FileSystemObject")
fsoObject.CopyFile("d:\ displayText.txt", "d:\myDocs\ displayText.txt")

In this example, a file named myFile.txt is copied from the root folder on the C: drive to a folder named myDocs located on the computer’s D: drive. You can modify this example to copy more than one file using wildcard characters as shown in the next example. Here all files in the root directly with a filename of myFile are copied to the destination folder regardless of their file extension.

Set fsoObject = CreateObject("Scripting.FileSystemObject")
fsoObject.CopyFile("d:\ displayText.*", "d:\Docs")

Moving Files

Moving files is similar to copying them except that instead of leaving the original file in place and placing a duplicate copy in the destination location, the original file is moved leaving only one copy of the file. You can move one or more files using the FileSystemObject object’s MoveFile() method.For example, you can move all files with a .txt file extension found in the root of the C: drive to a myDocs folder on the D: drive using the following VBScript statements.

Set fsoObject = CreateObject("Scripting.FileSystemObject")
fsoObject.MoveFile("c:\*.txt", "c:\Docs")

Deleting Files
You can use the FileSystemObject object’s DeleteFile() method to delete one or more files. For example, you might want to write a script that cleans out a folder at the end of each day or that deletes files after reading and processing them. You can delete one or more files as demonstrated here.

Set fsoObject = CreateObject("Scripting.FileSystemObject")
fsoObject.DeleteFile("d:\*.txt")

Here all files that have a .txt file extension located in the root of the C: drive will be deleted.
Creating a Folder
Working with folders is similar to working with files. You can use the FolderExists() method of the FileSystemObject to determine if a folder exists. If the folder does not exist, you can create it using the FileSystemObject object’s CreateFolder() method as demonstrated here.

Set fsoObject = CreateObject("Scripting.FileSystemObject")
If (fsoObject.FolderExists("d:\Docs") = false) Then
Set myFolder = fsoObject.CreateFolder("d:\Docs")
End If

The first thing that this example does is check to see if a folder named myDocs already exists on the computer’s D: drive. If it does not exist, then the folder is created. Otherwise nothing happens.
Copying Folders
Copying a folder is pretty much the same as copying a file. The folder and all its contents are copied to a new location leaving the original copy still in place. You can copy folders using the FileSystemObject object’s CopyFolder() method.Take a look at the following example. It copies a folder named myDocs located on the computer’s D: drive to its C: drive.

Set fsoObject = CreateObject("Scripting.FileSystemObject")
fsoObject.CopyFolder("c:\Docs", "d:\Docs")

As you can see the CopyFolder() methods requires two arguments, the source and destination folder names, including their complete paths. By changing the name assigned to the destination folder, you can rename the folder as part of the copy operation as demonstrated here.

Set fsoObject = CreateObject("Scripting.FileSystemObject")
fsoObject.CopyFolder("c:\Docs", "d:\NewDocs")

If the destination folder already exists, then the contents of the source folder are copied into it alongside its current contents. The CopyFolder() method supports an additional third parameter that allows you to tell it what to do if the destination folder contains files with duplicate filenames of those found in the source folder. This parameter is set to either a value of true or false. Setting it to true causes any matching files to be overridden. Setting it to false prevents this from happening. Let’s look at a couple examples. The first example prevents files with duplicate filenames from being overridden.

Set fsoObject = CreateObject("Scripting.FileSystemObject")
fsoObject.CopyFolder("c:\Docs", "d:\Docs", "False")

The second example allows files with duplicate names to be overridden in the destination folder.

Set fsoObject = CreateObject("Scripting.FileSystemObject")
fsoObject.CopyFolder("c:\Docs", "d:\Docs", "True")

Moving Folders
Moving a folder works pretty much the same as copying one except that moving the folder leaves you with only the one copy. You can move folders using the FileSystemObject object’s MoveFolder() method. This method moves a folder and all its contents, including subfolders, to a new destination.For example, the following VBScript statements move a folder called myDocs from the computer’s D: drive to its C: drive.

Set fsoObject = CreateObject("Scripting.FileSystemObject")
fsoObject.MoveFolder("c:\Docs", "d:\Docs")

If a folder with the same name already exists at the root of the computer’s D: drive, then the contents of the source folder will be copied into the existing destination along side its current contents.

Deleting Folders

You can delete one or more folders using the FileSystemObject object’s DeleteFolder() method. This method deletes a folder and all its contents, including subfolders. For example, the following VBScript statements can be used to delete a folder named myDocs located on a computer’s D: drive.

Set fsoObject = CreateObject("Scripting.FileSystemObject")
fsoObject.DeleteFolder("d:\Docs")

Managing Files with the File Object

The File Object allows you to work with one file at a time as opposed to the FileSystemObject, which lets you manage multiple files. Using the File object instead of the FileSystemObject requires a little more work. You still have to create an instance of the FileSystemObject to interact with the file system. You also need to use the FileSystemObject object’s GetFile() method to retrieve a File object that represents the file that your script will be managing. Once these two things are set up you can execute any of the File object’s methods.

Copying a File

Using the File object’s Copy() method you can copy a file from one location to another. This method does not support the use of wildcard characters and cannot therefore be used to copy multiple files.The following example demonstrates how to use the File object’s Copy() method to copy a file named myFile.txt from the myDocs folder on the computer’s D: drive to the root of the C: drive.

Set fsoObject = CreateObject("Scripting.FileSystemObject")
Set source_file = fsoObject.GetFile("c:\Docs\ displayText.txt")
source_file.Copy("d:\")

In this example, the FileSystemObject object’s GetFile() method is used to establish a reference to the file that is to be copied. Then the Copy() method is used to set the destination where the file is to be copied.

Moving a File

As you probably expect by now, moving a file using the File object’s Move() method works almost exactly like copying it using the Copy() method. For example, the following VBScript statements demonstrate how to move a file from one location to another.

Set fsoObject = CreateObject("Scripting.FileSystemObject")
Set source_file = fsoObject.GetFile("c:\Docs\ displayText.txt")
source_file.Move("d:\")

Deleting a File

You can delete an individual file using the File Object’s Delete() method. Like the File object’s other methods, the Delete() method does not support wildcard characters limiting it to being able to delete just one file at a time.Take a look at the following example. Here a file named myFile.txt is deleted from a folder named myDocs located on the computer’s D: drive.

Set fsoObject = CreateObject("Scripting.FileSystemObject")
Set source_file = fsoObject.GetFile("c:\Docs\ displayText.txt ")
source_file.Delete()

Managing Folders with the Folder Object
The Folder object is similar to the File object only it works with one folder at a time instead of one file at a time. Like the File object, it requires a little more work to set up than does simply using the FileSystemObject. First, you’ll need to instantiate the FileSystemObject. Then you must use the FileSystemObject object’s GetFolder() method to retrieve a Folder object that represents the folder that your script will be working with. Once these two things are set up you can execute any of the Folder object’s methods.

Copying a Folder

Like the File object, the Folder object supports the Copy() method. Because it doesn’t support wildcard characters it is useful only when you want to work with a single folder at a time. The Copy() method copies the folder and all its contents, including any subfolders, to a new location.For example, the following VBScript statements demonstrate how to use the Copy() method. In this case a folder named myDocs is copied from the root of the computer’s D: drive to the root of the computer’s C: drive.

Set fsoObject = CreateObject("Scripting.FileSystemObject")
Set source_folder = fsoObject.GetFolder("d:\Docs")
source_folder.Copy("c:\")

Moving a Folder
The Folder object’s Move() method lets you move a folder from one location to another. This method recursively copies a folder and all its contents. Because it does not support wildcard characters, this method can only move one folder at a time, as opposed to the FileSystemObject object’s MoveFolder() method, which can move any number of folders in a single operation.The following example demonstrates how to use this method to move a folder. In this case the folder is named myDocs and it is moved from the computer’s D: drive to its C: drive.

Set fsoObject = CreateObject("Scripting.FileSystemObject")
Set source_folder = fsoObject.GetFolder("d:\Docs")
source_folder.Move("c:\")

Deleting a Folder

You can delete a folder using the Folder object’s Delete() method. Wildcard character matching is not supported so it only works with one folder at a time. If you need to delete more than one folder you can use the FileSystemObject object’s DeleteFolder() method, discussed earlier in this chapter.This method deletes the specified folder and all its contents, including subfolders. Its use is demonstrated here.

Set fsoObject = CreateObject("Scripting.FileSystemObject")
Set source_folder = fsoObject.GetFolder("d:\Docs")
source_folder.Delete()

Next Step – QTP Script Examples

Working with File System
The main runtime object is the FileSystemObject from which all other runtime objects are derived (except for the dictionary object, which is independent of the FileSystemObject). lists of VBScript runtime objects.

To use the FileSystemObject within your VBScripts you must first establish an instance of it. You can do this using the WScript object’s CreateObject() method and by referencing it as Scripting. FileSystemObject. This is demonstrated in the following example.

Set fsoObject = WScript.CreateObject ("Scripting.FileSystemObject")

Here fsoObject is just the name that I assigned to a variable that can now be used by the rest of the script to reference the properties and methods of the FileSystemObject. With this instance of the FileSystemObject now established the script is read to interact with the Windows file system.Let’s put this previous FileSystemObject example to work in a few quick examples to see how it really works.
Displaying Drive Free Space

This first example demonstrates how to use a number of methods and properties of the VBScript runtime objects to access drive information. Specifically the example shown here displays the amount of free space on a computer’s C: and D: drives.

' * Script Name: Script 5.vbs       *  

Option Explicit  

On Error Resume Next  

dim fsoObject, drive1, drive2  

set fsoObject = WScript.CreateObject("Scripting.FileSystemObject")  

set drive1 = fsoObject.GetDrive(fsoObject.GetDriveName("c:"))  

set drive2 = fsoObject.GetDrive(fsoObject.GetDriveName("d:"))  

   

' ********* Main processing section **********  

' Call a function that displays drive information  

Free_Space()  

   

' *********** Procedures go here *************  

' This function displays the amount of free space on drive 1 and drive 2  

   

Function Free_Space()  

 WScript.Echo( "Free Space on drive 1 is: " _  

  & FormatNumber(drive1.FreeSpace / 1024 , 0) & " KB")  

 WScript.Echo( "Free Space on drive 2 is: " _  

  & FormatNumber(drive2.FreeSpace / 1024 , 0) & " KB")  

End Function

The script begins by defining three variables. The first variable is fsoObject. It will be used to create an instance of the FileSystemObject as discussed earlier. The next two variables will be used to set up references to the computer’s C: and D: drives.The two statements that set up the values of these two variables for the computer’s drives probably look a little complex to you at first. So let’s take a moment and break them down. First, the GetDriveName() method of the FileSystemObject is used by appending it to the variable fsoObject (for example, fsoObject.GetDriveName()). Remember that the fsoObject variable provides the script with a reference to the FileSystemObject and its properties and methods. The GetDriveName() method returns the name of the drive associated with the specified driver letter (that is, C: or D:). Next, the FileSystemObject object’s GetDrive() method is used to retrieve the Drive object associated with the specified drive name. The reason that we need to establish a reference to the Drive object is because we are going to want to use its Freespace property a little later in the script. After executing the statements in the script’s initialization section, the VBScript statement in the main processing section executes. There is only one VBScript statement in this section and it calls a function named Display_Msg(). The function then executes. Its job is to display the amount of free space on each drive. This is accomplished by taking the amount of free space left on a given drive as contained by the Drive object’s FreeSpace property and dividing it by 1024 (1 kilobyte or 1 KB). The results are then formatted using the Drive object’s FormatNumber() method, which in this case formats the number with zero trailing decimal spaces (that is, as whole number).When I ran this script on my computer, I got the following results.

C:\>CScript "Script 5.vbs"  

Microsoft (R) Windows Script Host Version 5.6  

Copyright (C) Microsoft Corporation 1996-2001. All rights reserved.  

Free Space on drive 1 is: 11,116 KB  

Free Space on drive 2 is: 15,784 KB  

C:\>

Examining File System Types
Let’s look at another example of how to work with the methods and properties of the VBScript runtime objects. This time we’ll write a VBScript example that displays the type of file system that the computer’s C: and D: drives have been formatted with.

' * Script Name: Script 6.vbs*  

Option Explicit  

On Error Resume Next  

dim fsoObject, drive1, drive2  

set fsoObject = WScript.CreateObject("Scripting.FileSystemObject")  

set drive1 = fsoObject.GetDrive("C:")  

set drive2 = fsoObject.GetDrive("D:")  

' ********* Main processing section **********  

' Call a function that displays drive information  

Used_Disk()  

' *********** Procedures go here *************  

' This function displays the file system used to format drive 1 and drive 2  

Function Used_Disk()  

 WScript.Echo("The file system used on drive 1 is: " & drive1.FileSystem)  

 WScript.Echo("The file system used on drive 2 is: " & drive2.FileSystem)  

End Function

As you can see this VBScript is similar to the previous example. The same variables are defined in the initialization section. In addition, the same instance of the FileSystemObject is set up and once again its GetDrive() method is used to retrieve Drive object references to each drive on the computer.Next, a single VBScript statement in the main processing section calls a function that displays a file system type for each drive. This is accomplished by using Drive object’s FileSystem property.When I ran this script on my computer I received the following results.

C:\>CScript "Script 6.vbs"  

Microsoft (R) Windows Script Host Version 5.6  

Copyright (C) Microsoft Corporation 1996-2001. All rights reserved.  

The file system used on drive 1 is: NTFS  

The file system used on drive 2 is: NTFS  

C:\>

Examining File Properties
Let’s look at one final example before we rush off and begin to master the art of reading from and writing to text files. This example starts off like the previous two examples by defining its variables and instantiating an instance of the FileSystemObject. This time the FileSystemObject object’s GetFile() method is used. This method is used to retrieve the File object associated with the specified file, which in this example is c:\winzip.log.Again, a VBScript statement in the main processing section calls on a function named Display_Msg(). The function contains a number of WScript.Echo statements each of which displays a different property associated with the File object.

' ********************************************  

' * Script Name: Script 7.vbs       *  

' * Author: Kuldeep            *  

' * Created: 03/02/08            *  

' ********************************************  

' **** Perform script initialization here ****  

Option Explicit  

On Error Resume Next  

dim fsoObject, targetFile  

set fsoObject = WScript.CreateObject("Scripting.FileSystemObject")  

set targetFile = fsoObject.GetFile("d:\Test.vbs")  

   

' ********* Main processing section **********  

' Call a function that displays drive information  

Details()  

   

' *********** Procedures go here *************  

' This function displays file properties  

Function Details()  

 WScript.Echo("File properties of d:\Test.vbs")  

 WScript.Echo("-----------------------------------")  

 WScript.Echo("Created on:  " & targetFile.DateCreated)  

 WScript.Echo("Last Modified: " & targetFile.DateLastModified)  

 WScript.Echo("Last Accessed: " & targetFile.DateLastAccessed)  

 WScript.Echo("File Name:   " & targetFile.Name)  

 WScript.Echo("File Path:   " & targetFile.Path)  

 WScript.Echo("File Type:   " & targetFile.Type)  

 WScript.Echo("File Size:   " & targetFile.Size)  

End Function

The following output was displayed when I ran this script.

C:\>CScript "Script 7.vbs"  

Microsoft (R) Windows Script Host Version 5.6  

Copyright (C) Microsoft Corporation 1996-2001. All rights reserved.  

File properties of d:\Test.vbs  

-----------------------------------  

Created on:  2/4/2008 11:23:36 PM  

Last Modified: 2/4/2008 10:38:52 AM  

Last Accessed: 2/4/2008  

File Name:   Test.vbs  

File Path:   D:\Test.vbs  

File Type:   VBScript Script File   

File Size:   1081  

C:\>  

Creating Documents, Reports, and LogsBy this point you should have a fairly good understanding of what the VBScript runtime objects are and what they can do. Now let’s look at how you can use them to generate reports, logs, and other types of text documents.To work with files and their contents you must first establish an instance of the FileSystemObject within your VBScript as shown here.

set fsoObject = WScript.CreateObject("Scripting.FileSystemObject")

Next, you should always check to see if the file that you want to work with already exists. If it does, you can open it. If it does not already exist, you can create it and then open it. You can check to see if a file exists using the FileSystemObject object’s FileExists property as shown here.

If (fsoObject.FileExists("C:\displayText.txt" ) ) Then

You must open a file before you can work with it. You can use the FileSystemObject object’s OpenTextFile() method to open files. To use this method you need to supply a few pieces of information including the following. 
·         The name and path of the file to be opened
·         Whether you want the file to be opened for reading, writing, or appending
·         Whether to create the file if it does not existTable defines constants that are used to tell the OpenTextFile() method what you want to do once the file is opened. 

Table defines two options that govern what the OpenTextFile() method should do when the file to be opened does and does not exist. 

Opening and Closing Files

It is very important that you correctly specify the type of operation that you are opening a file for (reading, writing, or appending). If you open a file to write to it and the file exists, then the file will be reinitialized. In other words, any data that is already in the file is lost and the file pointer is placed at the beginning of the new file (in the first row and column of the file).By appending to a file, you are able to preserve its contents and add to it. In other words, the file is opened and the file pointer is placed at the end of the file in the last row and column position.The file pointer is used to identify where the next character of data will be placed with a file. In a newly initialized file, the pointer would automatically be positioned in the upper-left corner (row 0, column 0). If one new character of information were added, the pointer would be moved over one position to column 1 in row 0. If a carriage return were added (indicating an end-of-line marker), then the file pointer would move to column 0 row 1. Knowing the location of the file pointer and how it is moved around is important, especially if you will be writing to or reading from files that have fixed record formats with data fields starting and ending in specified column positions. Okay, enough about the file pointer. Let’s look at an example that ties together everything that we have talked about. In this example, I’ve written a VBScript that opens a file named myFile.txt, which resides in the root directory of my C: drive. If the file already exists, then the script opens it but if it does not already exist it will be created and opened.

' * Script Name: Script 8.vbs       *  

Option Explicit  

On Error Resume Next  

Dim fsoObject, open_File, target_File  

Set fsoObject = WScript.CreateObject("Scripting.FileSystemObject")  

target_File = "D:\ displayText.txt"  

' ********* Main processing section **********  

' Call a function that displays drive information  

Open_File()  

open_File.WriteLine "This line of data should be written to the text file."  

Close_File()  

' *********** Procedures go here *************  

' This function opens a file  

Function Open_File()  

 If (fsoObject.FileExists(target_File ) ) Then  

  Set open_File = fsoObject.OpenTextFile(target_File, 8 )  

 Else  

  Set open_File = fsoObject.OpenTextFile(target_File, 2, "True" )  

 End If  

End Function  

   

' This function closes a file  

Function Close_File()  

 open_File.Close()  

End Function

The file is opened using the forWriting constant ( with a value of 2 ) if it already exists. If the file does not exist, then the forAppending constant (with a value of 8 ) is specified to open the file and place the file pointer at the end of the file.If you take at look at the script’s main processing section you will see the following statement between a pair of function calls, which open and close the file.

open_File.WriteLine "This line of data should be written to the text file."

This statement writes one line of data to the file and executes a carriage return placing the file pointer in the first column of the following line. I’ll talk more about the use of this and other methods that are used to write data to files in just a bit. The last statement in the main processing section calls a function that executes the following statement.

open_File.Close()

This statement executed the FileSystemObject object’s close() method i to close the opened file. You must remember to close any file that you open before allowing your script to end. Failing to do so may cause an error the next time that you open the file because the end-of-file marker will not have been created.Run this script and open the myFile.txt file and you’ll see the following line of data.
This line of data should be written to the text file.

Writing to Files

As you just learned, you should always check for the existence of a file before creating it. Once opened, you have several different ways in which you can write text data to your files.One option is to write a specific number of characters at a time. This technique is best used when you need to write carefully formatted data to your files such as when you write reports with data that appears in columns. Another option for writing to a file is to write an entire line of data at a time. This technique is best used when your documents are more free-formed and is probably the option that you’ll use most often, especially if you plan to create log files in which you record error messages and other types of event information as your scripts execute.Finally, you might want to add blank lines to your files. Blank lines are especially useful for formatting your documents to improve their presentation and make them easier to read.
Adding Characters to a File
You can write a specific number of characters to a file at a time using the FileSystemObject object’s Write() method. This method does not automatically append a carriage return at the end of each write operation. Therefore, the next time a write operation occurs additional text is inserted immediately following the text written by the previous write operation.The following example demonstrates how you can use the Write() method to append text to an existing file.

Set fsoObject = WScript.CreateObject("Scripting.FileSystemObject")  

Set open_file = fsoObject.OpenTextFile("d:\ displayText.txt", 8 )  

open_file.Write("Welcome to ")  

open_file.Write("KR Testing Solutions!")  

open_file.Close()

As you can see even though two separate write operations occurred, the text for both write operations was placed on the same line.
Adding a Line to a File

By replacing the Write() method with the FileSystemObject object’s WriteLine() method in the previous example, you can change the previous script to write data to the file a line at a time.

Set fsoObject = WScript.CreateObject("Scripting.FileSystemObject")  

Set open_file = fsoObject.OpenTextFile("d:\ displayText.txt", 8 )  

open_file.WriteLine("Welcome to KR Testing Solutions!")  

open_file.Close()

The WriteLine() method automatically adds a carriage return to the end of each line returning the file pointer to the first column of the next line.
Adding Blank Lines to a File

If you want to format your text files with blank lines to create better looking reports or make them easier to read you can use the FileSystemObject object’s WriteBlankLines() method. When executed, this method writes a blank line to the file and executes a carriage return.The following example demonstrates how to use the WriteBlankLines() method to format the data in a small report.

Set fsoObject = WScript.CreateObject("Scripting.FileSystemObject")  

Set myCDrive = fsoObject.GetDrive("d:")  

Set open_file = fsoObject.OpenTextFile("d:\ displayText.txt", 8 )  

   

open_file.WriteLine("------------------------------")  

open_file.WriteBlankLines(1)  

open_file.WriteLine("   My d: Drive Report   ")  

open_file.WriteBlankLines(1)  

open_file.WriteLine("------------------------------")  

   

open_file.WriteBlankLines(2)  

   

open_file.WriteLine("File System - " & myCDrive.FileSystem)  

open_file.WriteLine("Total Size - " & myCDrive.TotalSize)  

open_file.WriteLine("Free Space - " & myCDrive.AvailableSpace)  

   

open_file.Close()Reading from Files

Reading the contents of a file is handled in much the same way as writing to it. First, be sure that the file exists. If it does, then your script may open it. The next thing your script should do is use the TextStream object’s AtEndOfStream property to find out if the file has any data in it. After all, there is no point to trying to read an empty file. In fact, you should check the value of the AtEndOfStream property just before each read operation to be sure that your script has not reached the end of file marker (e.g., the end of the file). The first thing that you need to do to begin reading a text file is create an instance of the FileSystemObject and then use the FileSystemObject object’s OpenTextFile() method as shown here.

Set fsoObject = CreateObject("Scripting.FileSystemObject")  

Set open_file = fsoObject.OpenTextFile("d:\ displayText.txt", 1 )

As you can see the forReading constant has been specified. Next you could set up a loop that runs until the AtEndOfStream property has a value of true (the end of the file is reached). During each iteration of the loop your script should read a line of text using the FileSystemObject object’s ReadLine() method as shown here.

Do while False = open_file.AtEndOfStream  

 WScript.Echo(open_file.ReadLine())     

Loop   

 

The preceding VBScript statements will process every line in the file, terminating when the end of file marker is reached. After your script is done reading the file, it can close it as shown here.
open_file.Close
If you put these lines of code together and ran them as a script using the CScript execution host you’d see output similar to the following.

C:\>CScript test.vbs  

Microsoft (R) Windows Script Host Version 5.6  

Copyright (C) Microsoft Corporation 1996-2001. All rights reserved.  

------------------------------  

   My d: Drive Report  

------------------------------  

File System - NTFS  

Total Size - 2146631554  

Free Space - 234554452  

C:\>  

 

In this example we read an entire file by reading it one line at a time. There are a number of other techniques for reading files. These include 
·         Skipping lines when reading a file
·         Reading a specified number of characters from a file
·         Reading an entire file in one operation
Skipping Portions of a File

If a file has headers or other information that you are not interested in reading you can always skip them and read only the portion of the file that interests you. For example, the file that we have been working with contains a five-line header followed by two blank lines after which the data in the report begins.You can use either of the following methods, both of which belong to the FileSystemObject, to skip text in a file. 
·         Skip(). Skip a specific number of characters
·         SkipLine(). Skips a lineThe Skip() method lets you supply a number indicating how many characters should be skipped. For example, the following statement would skip 25 characters in a file referenced as open_file.

open_file.Skip(25)

Unfortunately, the SkipLine() method does not allow you to pass it a number, indicating how many lines to skip. If you want to skip more than one line, you can wrap the method up inside a loop as demonstrated here.

For i = 1 to 7open_file.SkipLine()Next

Here the first seven lines of the file referenced as open_file would be skipped.
Reading Formatted Data

If your file has been formatted to contain fixed length data, then you have the option of reading it by character instead of by line. To do so you will use the FileSystemObject object’s Read() method.The following example demonstrates how to use this method. Here a reference is set up for a file named myfile.txt. Then a For loop is set up to skip the first seven lines of the file using the SkipLine() method. Next the Skip() method is used to skip the first fourteen characters on the eighth line. Finally the next four characters, beginning with the twenty-third character are read and then displayed. Then the file is closed.

Set fsoObject = CreateObject("Scripting.FileSystemObject")  

Set open_file = fsoObject.OpenTextFile("d:\ displayText.txt", 1 )  

For i = 1 to 7  

 open_file.SkipLine()  

Next  

   

open_file.Skip(14)  

WScript.Echo("The file system in use on this drive is: "  

& open_file.Read(4))open_file.Close

Reading Entire Files

Another way in which you can read files is to read the entire file all at once using the FileSystemObject object’s ReadAll() method as demonstrated in the following example.

Set fsoObject = CreateObject("Scripting.FileSystemObject")  

Set open_file = fsoObject.OpenTextFile("d:\ displayText.txt", 1 )  

read_rpt = open_file.ReadAll()open_file.Close()MsgBox(read_rpt)

In this example, the entire file is read using a single statement, which assigns the data read by the ReadAll() method to a variable named read_rpt. The file is then closed and the value of read_rpt displayed using the VBScript MsgBox() function.

Performing File and Folder Administration
z
Managing your files and folders can involve a lot of work. Using VBScript and the WSH you can automate much of this work. For example, typical file and folder tasks involve copying or moving files and folders from one location to another in order to create backups or better organize them. Administration may also include deleting files once they have been processed or after they have reached a certain age.You can use methods belonging to the FileSystemObject to manage one or more files or folders at a time. FileSystemObject methods for handling files include 
· CopyFile(). Copies one or more files.
·         MoveFile(). Moves one or more files to a different location.
·         DeleteFile(). Delete one or more files.
·         FileExists(). Provides verification of whether a file contains data.The FileSystemObject also provides a number of methods that you can use to manage Windows folders, including 
·         CopyFolder(). Copies one or more folders.
·         MoveFolder(). Moves one or more folders to a different location.
·         DeleteFolder(). Deletes one or more folders.
·         FolderExists(). Provides verification of whether a folder exists.
·         CreateFolder(). Creates a new folder.Alternatively, you can also use the File and Folder objects to manage your files and folders instead of the FileSystemObject. These two objects share many of the same methods, including 
·         Copy(). Copies a file or folder to the specified location.
·         Delete(). Removes the specified file or folder.
·         Move(). Moves a file or folder to the specified location.

Next Step – File System Object

Files and Folders related Functions

VBScript Runtime Properties

Like the objects in the WSH core object model, VBScript runtime objects provide an extensive supply of properties. You can use the properties to view or change numerous file system attributes. These properties are listed here. 
·         AtEndOfLine. Returns a value of either true or false depending on whether the file pointer precedes the TextStream file’s end-of-line marker.
·         AtEndOfStream. Returns a value of either true or false depending on whether the end of a TextStream file has been reached.
·         Attributes. Retrieves or sets file and folder attributes.
·         AvailableSpace. Retrieves the amount of free space available on a drive.
·         Column. Retrieves the current column position within a
TextStream file.
·         CompareMode. Retrieves or sets the comparison mode used to compare a Dictionary object’s string keys.
·         Count. Returns a count of the items in a collection or Dictionary object.
·         DateCreated. Returns a file or folder’s creation date and time.
·         DateLastAccessed. Returns the date and time that a file or folder was last accessed.
·         DateLastModified. Returns the date and time that a file or folder was last modified.
·         Drive. Returns the drive letter representing the drive where a file or folder is stored.
·         DriveLetter. Returns a drive’s drive letter.
·         Drives. Creates a Drives collection representing the computer’s Drive objects.
·         DriveType. Returns a value indicating a drive’s type.
·         Files. Creates a Files collection representing the File objects stored inside a folder.
·         FileSystem. Returns the file system type implemented on a drive.
·         FreeSpace. Returns the amount of free space available to the user on a drive.
·         IsReady. Returns a value of either true or false depending on whether a drive is available.
·         IsRootFolder. Returns a value of either true or false identifying whether a folder is the root folder.
·         Item. Retrieves or sets an item based on the specified Dictionary object key.
·         Key. Sets a Dictionary object key.
·         Line. Returns the current line number in the TextStream file.
·         Name. Retrieves or sets a file or folder’s name.
·         ParentFolder. Retrieves a file or folder’s parent folder object.
·         Path. Retrieves the path associated with a file, folder, or drive.
·         RootFolder. Retrieves the Folder object associated with the root folder on the specified drive.
·         SerialNumber. Retrieves a disk volume’s serial number.
·         ShareName. Retrieves a network drive’s share name.
·         ShortName. Retrieves a file’s or folder’s 8.3 character short name.
·         ShortPath. Retrieves the short path associated with a file’s or folder’s 8.3 character name.
·         Size. Retrieves a file’s or folder’s byte size.
·         SubFolders. Establishes a Folders collection consisting of all the folders located inside a specified folder.
·         TotalSize. Returns the total number of bytes left on a drive.
·         Type. Retrieves information about a file’s or folder’s type.
·         VolumeName. Retrieves or sets a drive’s volume name.

VBScript Runtime Methods

The methods that belong to the VBScript runtime objects are listed here.

VBScript Run-time Methods
·         Add (Dictionary). Adds a key and item pair to a Dictionary object.
·         Add (Folders). Adds a Folder to a collection.
·         BuildPath. Appends a name to the path.
·         Close. Closes an open TextStream file.
·         Copy. Copies a file or folder.
·         CopyFile. Copies one or more files.
·         CopyFolder. Recursively copies a folder.
·         CreateFolder. Creates a new folder.
·         CreateTextFile. Creates a file and a TextStream object that can be used to read and write to the file.
·         Delete. Deletes a file or folder.
·         DeleteFile. Deletes a file.
·         DeleteFolder. Deletes a folder’s contents.
·         DriveExists. Returns either true or false depending on the existence of a drive.
·         Exists. Returns either true or false depending on whether a key exists in a Dictionary object.
·         FileExists. Returns either true or false depending on whether a file can be found.
·         FolderExists. Returns a value of true or false depending on whether a folder can be found.
·         GetAbsolutePathName. Returns a complete path name.
·         GetBaseName. Retrieves a filename less its file extension.
·         GetDrive. Returns the Drive object associated with the drive in the specified path.
·         GetDriveName. Retrieves the name of a drive.
·         GetExtensionName. Retrieves a file’s extension.
·         GetFile. Retrieves a File object.
·         GetFileName. Retrieves the last filename or folder of the specified path.
·         GetFileVersion. Retrieves a file’s version number.
·         GetFolder. Retrieves the Folder object associated with the folder in the specified path.
·         GetParentFolderName. Retrieves the name of the parent folder.
·         GetSpecialFolder. Retrieves a special folder’s name.
·         GetTempName. Retrieves the name of a temporary file or folder.
·         Items. Returns an array containing the items in a Dictionary object.
·         Keys. Returns an array containing the keys in a Dictionary object.
·         Move. Moves a file or folder.
·         MoveFile. Moves one or more files.
·         MoveFolder. Moves one or more folders.
·         OpenAsTextStream. Opens a file and returns a TextStream object that can be used to reference the file.
·         OpenTextFile. Opens a file and returns a TextStream object that can be used to reference the file.
·         Read. Returns a string containing x number of characters from a TextStream file.
·         ReadAll. Reads the whole TextStream file and returns its contents.
·         ReadLine. Reads a line in a TextStream file.
·         Remove. Deletes a Dictionary object’s key, item pair.
·         Skip. Skips x number of character positions when processing a TextStream file.
·         SkipLine. Skips a line when processing a TextStream file.
·         Write. Places a string in the TextStream file.
·         WriteBlankLines. Writes x number of newline characters to the TextStream file.
·         WriteLine. Writes a string in the TextStream file

Next Step – File Scripting

VBScript Pop-Up Dialogs
VBScript provides two built-in functions that allow you to add pop-up dialogs that you can use in your VBScripts to communicate with users. You can call on these functions to execute within your scripts just like you would any function that you wrote yourself.These two functions are available regardless of whether you are embedding your VBScripts into HTML pages or writing WSH scripts. Both of these functions are described here. 
·         MsgBox(). A procedure that executes and then returns a result to the statement that called it.
·         InputBox(). A procedure that executes but that does not return a result.

The VBScript MsgBox Function

The MsgBox function provides a way for you to display a pop-up dialog and ask the user to respond by clicking the appropriate button. The syntax of the MsgBox function is shown here.

MsgBox(prompt [, buttons] [, title] [, helpfile, context])

Prompt is the text message displayed by the dialog and can be as many as 1,024 characters long. Button is a numeric expression or value that is the sum of a number of other values that specify.
§                    The types of buttons to display
§                    The type of icon to be displayed in the dialog
§                    The button to be selected by default
§                    The modality of the dialog

Option Explicit 

Dim myResponse 

myResponse = MsgBox("Do you wish to quit?", 1, "What do you wish to do?")

The VBScript InputBox Function

The InputBox() function provides a way for you to display a pop-up dialog that prompts the user to supply text input. The InputBox allows you to ask the user questions and collect text input. The syntax of the InputBox() function is shown here.

InputBox(prompt [, title] [, default] [, xpos] [, ypos] [, helpfile, context])

For example, the following statements prompt the user to type the name of the country in which he or she resides.

Option ExplicitDim myInput 

myInput = InputBox("What country do you reside in?")

Next Step – File and Folder Functions

Arrays
VBScript allows you to store data in variables that you can then reference and manipulate. While there is no limit to the number of variables that you can create in a single VBScript, you’ll find that trying to manage too many of them can become difficult.VBScript provides another storage structure for managing large groups of related data known as an array. An array is an indexed collection of values that are managed as a unit. For example, rather than creating a whole series of individual variables to store a list of values such as people’s names, you can create an array and assign each name as an array element.VBScript supports the creation of single dimensional and multidimensional arrays. In fact, VBScript allows for the creation of arrays with as many as 60 dimensions, although you’ll probably never need to work with anything bigger than one or two dimensions.VBScript allows you to create an array using the Dim statement. The syntax of the Dim statement when used to establish an array is

  Dim arrayname(dimensions)

Dimensions is a comma-separated list specifying the length of each of an array’s dimensions. For example, the following statement defines a single dimension array called myArray that can hold up to four elements.

Dim myArray(2)

An array is an indexed list. The first value stored in the array is automatically assigned an index value 0. The second element stored in an array has an index value of 1, and so on. Because an array’s index always begins with zero the actual length of an array dimension is equal to the number supplied in the declaration statement plus one. So the array defined above can hold up to 4 elements.Once you have defined and array you can populate it as demonstrated here.

myArray(0) = "Welcome"myArray(1) = "To"  

myArray(2) = "KR Testing Solution"

After you have populated an array you can reference its contents. For example, you could use the following statement to display the value stored as the third element in the array.

WScript.Echo myArray(2)

The following examples show how to create an array with more than one dimension. In this case, a two-dimensional array is created using the Dim statement that can store its data in a spreadsheet like format.

Dim myArray (4,4)

You can think of the array created by this example as having five rows by five columns. Remember, the length of any array dimension equals 1 plus the value that specified its length. Similarly, your could define a three-dimensional array by adding additional comma separated values in the Dim statement as shown here.

Dim myArray (4,4,4)

Next Step – Message Dialogs

Functions
VBScript provides two different types of procedures.
§                    Function. A procedure that executes and then returns a result to the statement that called it.
§                    Subroutine. A procedure that executes but does not return a result.

Functions

VBScript functions are collections of related VBScript statements that are called and executed as a unit. Functions can also return a result to calling statements. The syntax for creating a function is

[Public | Private] Function name [(arglist)]  statements End Function

Private and Public are optional keywords. The Private keyword is used to set up a function that can only be called from within the script where it has been defined. When used, the Public keyword allows the function to be called by other scripts. Name identifies the function’s name. Arglist is used to specify one or more arguments that that can be passed to the function.To return a result to the statement that called the functions you must be sure that the subroutine has a variable of the same name as the subroutine. The value that the subroutine assigned to this variable is what will be returned.The following example shows a WSH VBScript that has two functions.

' * Script Name:   Script 3.vbsOption Explicit

Const Message = “Welcome to KR Testing Solutions”
Dim string1
Dim string2
‘ *********** Main processing section ****************
‘ Collect the First String
string1 = GetFirstString()
‘ Collect the Second String
string2 = GetSecondString()
‘ Display message
WScript.Echo Message & ” ” & string1 & ” ” & string2
‘ ********* Subroutines & Functions go here **********
function GetFirstString()
GetFirstString = InputBox(“What is your 1^st String?”)
End Function

function GetSecondString()
GetSecondString = InputBox(“What is your 2^nd String?”)
End Function

Subroutines

Subroutines work almost exactly like functions except that they are unable to return any results to the calling statement. The syntax for creating a subroutine is shown here.

[Public | Private] Sub name [(arglist)]  statements End Sub

Next Step – Array Decleration

Loops

Like any advanced programming language VBScript provides a number of statements that allow VBScripts to loop or iterate repeatedly to quickly and efficiently process large amounts of data. These statements make it possible to write small scripts that are capable of processing enormous amounts of data.VBScript provides five different types of loops, summarized here, each of which has its own unique purpose and advantages. 
·         Do While. Sets up a loop that iterates as long as a specified condition remains true.
·         Do Until. Sets up a loop that iterates until a specified condition becomes true.
·        For…Next. Sets up a loop to execute a specified number of time
·         While…Wend. Sets up a loop that executes as long as a condition remains true.
·         For…Each…Next. Creates a loop that iterates through an object’s properties.

Do While

The VBScript Do While statement is used to create loops that run while a condition remains true. There are two ways that you can set up Do While loops in your VBScripts. The syntax for the first method is

Do While condition  statements Loop

You can insert as many programming statements as you want to between the opening Do and closing Loop keywords. The While keyword is included at the beginning of the loop. Therefore if the condition being tested is already false, the loop will never execute. For example, the following VBScript statement shows a VBScript Do While loop that counts to 10. In this example, a variable called myCount is initialized with a value of 0 and then incremented by 1 each time the loop is executed. When the value of the variable finally exceeds 10 the loop terminates and processing continues with the next statement in the script. Therefore myCount is used to control the execution and termination of the loop.

' * Script Name:  Script 2.vbs
Option Explicit
Dim Counter 'Counter used to control loop termination
Counter = 0  
Dim crlf ' Contains carriage return and linefeed instructions
crlf = Chr(13) & Chr(10) 
' *********** Main processing section ****************
WScript.Echo "Counting to 5 with a Do While loop" & crlf
Do While Counter < 5
 Counter = Counter + 1
WScript.Echo(Counter) & crlf Loop

Do Until

The VBScript Do Until statement is used to create loops that run as long as the tested condition remains false. Like the Do While statement there are two versions of the Do Until statement. The syntax for the first form is

Do Until condition  statements Loop

For example, the following VBScript statements create a Do Until loop that sets up a loop that executes until the value assigned to a variable named myCount exceeds 9.

 Option ExplicitDim Counter
myCount = 0
 
WScript.Echo "Counting to 10 with a Do Until loop"
Do Until Counter > 6
 Counter = Counter + 1
WScript.Echo(Counter) Loop 

If you save this example as a WSH VBScript and run it using the CScript execution host you will see the following output.

Counting to 5 with a Do Until loop 1 2 3 4 5

 For example, the following VBScript statements set up a Do loop that will always execute at least one time.  

Do statements Loop Until condition

The following VBScript statements set up a loop that executes as long as the value of a controlling variable is not greater than 9.

Option ExplicitDim Counter
Counter = 0
WScript.Echo "Counting to 5 with a Do Until loop"
Do Counter = Counter + 1
 WScript.Echo(Counter)
Loop Until Counter > 4

If you execute the statements exactly as shown previously, you’ll see the same output that was generated in the previous example. However, try changing the initial value of the myCount variable to 10. You’ll see that, unlike the previous example, the loop will execute and display the following output.

Counting to 10 with a Do Until loop 6

For…Next

The VBScript For…Next statement is used to create loops that will execute for a specific number of operations. The syntax for the first method is

For counter = begin To end [Step step_value]   statementsNext

Counter specifies the controlling variable. Begin specifies its initial value and end sets its ending value. Step_value is an optional parameter that specifies the value that will be used to increment the variable after each iteration.For example, the following For…Next loop sets up a loop that will execute 10 times and display the value of the controlling variable i for each iteration. The variable i us used to control loop execution and is automatically incremented by 1 at then end of each execution of the loop.

Option ExplicitDim iFor i = 1 To 5
 WScript.Echo i
Next

By adding the Step keyword you can control the value used to increment the counter.

Option ExplicitDim iFor i = 1 To 5 Step 2 WScript.Echo i
Next

In this example, the number of times that the loop will execute is cut in half. Instead of seeing the output display the number 1 through 10 you see the following.

C:\>CScript.exe test.vbs

Microsoft (R) Windows Script Host Version 5.6
Copyright (C) Microsoft Corporation 1996-2001. All rights reserved.
 
1
3
 

While…Wend
The VBScript While…Wend statement is used to create loops that will execute as long as the tested condition remains true. The syntax for the first method is shown below.

While condition statements Wend

The functionality provided by the While…Wend statement is duplicated by the Do loop. It is generally recommended that you use Do loops in place of it. However, just in case I’ll give you an example of how to use it.

Option Explicit

Dim i
WScript.Echo "Counting to 10 with a While Wend loop"
i = 1
While i < 6
 WScript.Echo i
 i = i + 1
Wend

If you insert the preceding statements into a WSH VBScript and run it with the CScript execution host you see the following output.

Counting to 10 with a While Wend loop 1 2 3 4 5

For…Each…Next

VBScript allows you to work with objects such as disk drives and printers. Each object has a unique set of properties that describe and control its characteristics. For example, a file has a name as does a printer. Using the For…Each…Next statement you can create a loop that can process all the properties associated with an object.The syntax of the For…Each…Next statement is  

For Each element In collection  statements Next [element]

Element is a variable representing a property associated with the collection (or object). You can also use For…Each…Next statements to process the contents of arrays. An array is a related connection of index data that provides a more efficient way than using variables to store large amounts of related information. You will learn more about arrays a little later in the morning and will find examples of how to work with the For…Each…Next loop then.

Next Step – Functions

Conditional Logic

VBScript provides two statements that allow you to add logic that can alter the logical execution of scripts. This way your scripts can make decisions based on user or environmental criteria. These statements are listed below.
 ·       If…Then…Else. Guides the logical execution of a script based on one or more tested conditions.
·         Select…Case. Guides the logical execution of a script based on multiple tests performed against the same condition.

If…Then…Else

If condition Then statement [Else statement]

If you need to execute more than one VBScript statement as a result of your comparisons, then you’ll need to use the following syntax for the If…Then…Else statement.

If condition Then  

  statements  

ElseIf condition-n Then  

statements  

.  

.  

Else  

    

statements  

End If

For example, you could modify the IF…Then…Else statement in the previous example as shown here.

If  rupeesSent = rupeesReceived Then  

MsgBox "No rupess remaining now"  

rupeesOnhand = 0  

Else  

MsgBox "This rupess is balance"  

unitsOnhand = rupeesSent - rupeesReceived  

End If

Select Case

The Select…Case statement provides functionality that is very similar to the If…Then…Else statement. However, although the If…Then…Else statement can test a large number of different conditions, the Select… Case statement is better equipped to test a large number of criteria against a single condition. The syntax of the Select…Case statement is

Select Case value  

Case expression  

  statements  

  .  

  .  

Case expression  

  statements  

Case Else  

  statements  

End Select

Select…Case evaluates a single value as specified in the Select…Case statement and compares it against the values stored in each of the
Case statements that follows as demonstrated in the following example.

Select Case myNumber

Case “1″
  MsgBox “The matching color is 1″
Case “2″
  MsgBox “The matching color is 2″
Case “3″
  MsgBox “The matching color is 3″
Case Else
  MsgBox “No Number matches”
End Select

Next Step – Looping Statements

Manipulating VBScript Variables with Operators
As you have already seen the VBScript = assignment operator is used to assign a value to a variable. When you are working with variables that contain numeric values, you can use any of the VBScript arithmetic operators, shown in Table, to change the value assigned to variables.

The following VBScript statements show how you can apply some of the operators.

Option Explicit   

Dim myExp   

myExp = 37   

WScript.Echo " myExp= " & myAge   

 myExp = myExp + 3   

WScript.Echo " myExp = " & myAge   

  myExp = myExp - 10   

WScript.Echo " myExp = " & myExp   

    

myExp = myExp * 2   

WScript.Echo " myExp = " & myExp

If you were to save this script as part of a WSH VBScript and run it from the CScript.exe execution host then you’d see the output shown here.

myExp = 37   

myExp = 40   

myExp = 30   

myExp = 60

VBScript performs arithmetic operations using a strict set of rules known as the order of operator precedence.

Comparison Operators

VBScript provides a collection of operators that you can use to compare the values of expressions within your VBScripts. These operators are listed inTable.  

Testing the values of variables in your scripts is something that you’ll find yourself doing again and again. When combined with conditional execution logic, which I’ll cover in just a bit, you’ll be able to write scripts that can test for certain conditions and then switch between multiple execution paths based on the results of those tests.Unlike arithmetic operators, there is no order of precedence to the execution of comparison operators. They are executed in the order in which they appear in a statement (e.g., they are evaluated starting from left to right).For example, the following statement tests to see if values of two variables are equal.

Option Explicit Dim myExp, yourExpIf myExp = yourExp Then   

 WScript.Echo "Congrates!!!"   

End If

Similarly, you can test for greater than or less than values.

If myExp > yourExp Then WScript.Echo "May I Check it?"   

End If   

If myExp < yourExp Then   

 WScript.Echo "Would you like to Check it?"   

End If

Next Step – Conditional Statements