Basics of VBScript. VBScript. VBScript Basics WScript Root Class Methods and Properties

Something I completely ran ahead and did not tell you about two dialog box functions: MsgBox and InputBox. In this very short tutorial, I will tell you about all the stray to these two functions. There are also other ways to create dialog boxes, but this will require WSH objects, which will be discussed in the next lessons.

MsgBox Function

The most common function for displaying a message. Of course it is more difficult than Echo of a WScript object, but it doesn't need an object either.
Syntax: MsgBox (Prompt[, Buttons][, Title][, Helpfile, Context])

• Prompt- Message text.
• Buttons— Displayed buttons and window mode.
• Title- Name of the window.
• Helpfile— help file (*.hlp)
• Context— Help section number.

Parameter Buttons can take on multiple values ​​at the same time. In order to specify them, use the "+" sign or simply use the sum of the values. The values ​​of this parameter are given below.

Constants for dialog boxes (displayed buttons):

• vbOKOnly— Value 0. Display OK button.
• vbOKCancel- Value 1. Display buttons: OK and Cancel.
• vbAbortRetryIgnore- Value 2. Display buttons: Interrupt, Retry and Skip.
• vbYesNoCancel- Value 3. Display buttons: Yes, No and Cancel.
• vbYesNo- Value 4. Display buttons: Yes and No.
• vbRetryCancel- Value 5. Display buttons: Redo and Cancel.

Constants for dialog boxes (displayed icons):

• vbCritical- Value 16. Display the Stop Mark icon.
• vbQuestion- Value 32. Display the Question Mark icon.
• vbExclamation- Value 48. Display the Exclamation Mark icon.
• vbInformation- Value 64. Display the Information Mark icon.

Constants for dialog boxes (buttons by default):

• vbDefaultButton1— Value 0. The first button is selected by default.
• vbDefaultButton2— Value 256. The second button is selected by default.
• vbDefaultButton3— Value 512. The third button is selected by default.
• vbDefaultButton4- Value 768. The fourth button is selected by default.

Constants for Dialog Boxes (Window Mode):

• vbApplicationModal— Value 0. Displayed in modal mode.
• vbSystemModal- The value is 4096. It is displayed in modal mode and is located on top of all applications.

Other:

• Value 262144- Over all windows.
• Value 524288- The text in the window is displayed on the right edge.

It should be noted that the parameter Buttons cannot take multiple values ​​from the same category. These values ​​will simply add up. That is, you will not be able to install several sets of buttons or icons at the same time.

"VBScript Lesson #16: "Function MsgBox and InputBox "file_1.vbs"************************************** ********************** MsgBox "Hi", 5+16, "Name" MsgBox "Hi", vbRetryCancel+16, "Name" MsgBox "Hi" , vbRetryCancel+524288, "Name" MsgBox "Hi", vbAbortRetryIgnore + vbInformation + vbDefaultButton2 + vbSystemModal + 524288, "Name" MsgBox "Hi", 528706, "Name"

"******************************************************** "VBScript Lesson #16: "MsgBox and InputBox Function "file_1.vbs "******************************************************** MsgBox "Hi" , 5 + 16 , "Name" MsgBox "Hi" , vbRetryCancel + 16 , "Name" MsgBox "Hi" , vbRetryCancel + 524288 , "Name" MsgBox "Hello" , vbAbortRetryIgnore + vbInformation + vbDefaultButton2 + vbSystemModal + 524288 , "Name" MsgBox "Hi" , 528706 , "Name"

In addition, the MsgBox function can return the result of pressing buttons. You can assign it to a variable and in this way determine the pressed button.

Return result of pressed buttons (constants):

• vbOK— Value 1. OK button.
• vbCancel— Value 2. Cancel button.
• vbAbort— Value 3. Abort button.
• vbRetry— Value 4. Repeat button.
• vbIgnore— Value 5. Skip button.
• vbYes— Value 6. Yes button.
• vbNo— Value 7. No button.

"******************************************************* ******* "VBScript Lesson #16: "Function MsgBox and InputBox "file_2.vbs"*************************** ******************************* Dim Knopka Knopka = MsgBox("Press any button",2,"Title") If Knopka = 3 Then MsgBox "You pressed a button - Abort" ElseIf Knopka = 4 Then MsgBox "You pressed a button - Repeat" Else MsgBox "You pressed a button - Ignore" End If

"******************************************************* ******* "VBScript Lesson #16: "Function MsgBox and InputBox "file_4.vbs"*************************** ******************************* Dim Dict, AboutBomb Set Dict = CreateObject("Scripting.Dictionary") Dict.CompareMode = 1 Dict .Add "Yellow", "Bomb exploded!" Dict.Add "Red", "You have defused the bomb!" Dict.Add "Blue", "Bomb exploded!" Dict.Add "Green", "Bomb exploded!" AboutBomb = InputBox("Bomb detected!!! Which wire to cut: yellow, red, blue or green??","Bomb detected!!!","Enter wire color here...") If Dict.Exists(AboutBomb) then MsgBox Dict.Item(AboutBomb) else MsgBox "You're visually impaired! There is no such wire! The bomb exploded!!!" end if

"********************************************************

Data types

The VBScript language uses a single data type - Variant (Variant), which allows you to store in variable number, string, date, boolean value, object reference and other information. You can determine the content type of a variable using a set of functions: VarType , TypeName, IsArray, IsDate, IsEmpty, IsNull, IsNumeric, IsObject, which will be discussed below. The type of information contained is also called a variant subtype. For a complete list of subtypes, see following table:

Subtype	Description
Empty	The variable has not been assigned a value. When using an uninitialized variable in numeric expressions, 0 will be substituted, and in string expressions, an empty string.
Null	The variable contains no data.
Boolean	Boolean variable can take values ​​True or False.
bytes	An integer in the range 0 to 255.
Integer	An integer in the range -32768 to 32767.
Currency	A fixed-point number in the range -922337203685477.5808 to 922337203685477.5807.
Long	An integer in the range -2147483648 to 2147483647.
Single	A single precision floating point number. For negative values, valid range from -3.402823E38 to -1.401298E-45. For positive ones - from 1.401298E-45 to 3.402823E38.
Double	A double-precision floating-point number. For negative values, the valid range is from 79769313486232E308 to -4.94065645841247E-324. For positive ones, from 4.94065645841247E-324 to 1.79769313486232E308.
Date (Time)	Contains a number representing a date between January 1, 100, and December 31, 9999.
String	A sequence of characters. The maximum length is around 2 billion characters.
Object	An object.
error	Error number.

Depending on the expression in which the variable participates, its contents will be automatically cast to the desired type. Consider this example:

Option Explicit Sub TestVBScript Dim A, B A = 5 B = "12" Application.MessageBox A + B, "", vbOkOnly End Sub

Since the expression involves a numeric variable A, the interpreter converts the value of the variable B from string "12" into a number and sum them up:

Let's change the macro so that the variable A also contained the line:

Option Explicit Sub TestVBScript Dim A, B A = "5" B = "12" Application.MessageBox A + B, "", vbOkOnly End Sub

Let's run it for execution. Now the result of the concatenation (concatenation) of two strings will appear on the screen, and not the sum of their numerical representations:

To avoid confusion with automatic type conversion, it is recommended to use the conversion functions: CBool, CByte, CCur, CDate, CDbl, CInt, CLng, CSng, CStr.

If the result of an expression should be exactly the confluence of strings, and not the sum of their numeric representations, then the & operator should be used instead of +.

Variables

A variable is a convenient symbol for a memory location where an application stores some data. During the execution of the application, the value of a variable can change. A variable must be declared with the Dim statement before it can be used.

With the help of one operator, you can declare several variables at once, if you list their names separated by commas:

Left, Right, Top, Bottom

When declaring, there is no need to specify a data type, since all variables are of type Variant.

If Option Explicit is not specified in the first line of the script text, then variables can be used without declaration. But, this way can lead to hard-to-detect errors. It is enough to make a mistake in writing the variable name once in the program text to get an unpredictable result. We recommend that you always specify Option Explicit and declare variables.

The variable name must meet the following requirements:

1. Start with a Latin alphabet character;
2. Consist only of Latin alphabet characters or of Latin alphabet characters and numbers;
3. Do not exceed 255 characters in length;
4. Be unique within its scope.

Scope and lifetime

The scope of a variable is determined by where it was declared. If inside the body of the procedure, then such a variable is called local and is available only within this procedure. If a variable is declared in the text of a script, then it will be visible to all procedures or functions defined in this script. Local variables can have the same name if they are declared in different procedures.

In the Explorer tree of the Script Object Editor window, there is a special section - Constants and Variables - for declaring global variables visible to all project script functions.

The interpreter allocates memory for local variables at the time they are declared and releases them when the procedure exits. Global variables exist from the moment they are declared until the script finishes its execution. As applied to Gedymin, this means that global variables exist throughout the entire execution of the program.

Assigning a value to a variable

The value of a declared variable is assigned using the = operator. The variable name is specified to the left of the operator, the new value to the right. For example:

A = 200 B = "Name"

Scalar variables and arrays

A variable containing a single value is called a scalar variable. Sometimes, it becomes necessary to store several values ​​in one variable. In this case, you should declare an array. The declaration syntax is identical to the declaration of a scalar variable, except that after the name in parentheses, we specify the size of the array. The following declaration will create an array of 12 elements:

Dim Monthes(11)

In VBScript, the left end of an array index is always 0. Thus, the size of an array is calculated as the number in parentheses plus one. When assigning a value to an array element, you must specify its index in parentheses:

Monthes(0) = "January" Monthes(1) = "February" Monthes(2) = "March" ... Monthes(10) = "November" Monthes(11) = "December"

Similarly, when accessing the value of an element, we use its index:

MonthName = Monthes(5)

The array does not have to be one-dimensional. VBScript allows us to specify up to 60 dimensions when declaring an array. For example, the following statement will create a two-dimensional array with 12 rows and two columns:

DimMonthDays(11, 1)

When accessing elements of a multidimensional array, all indices must be specified:

MonthDays(0, 0) = "January" MonthDays(0, 1) = 31 MonthDays(1, 0) = "February" MonthDays(1, 1) = 28 ...

Above, we declared arrays, the size of which does not change during the course of the program. If it is not known in advance how many elements will be needed, then you can declare a dynamic array:

Before use, you should set the size of a dynamic array using the ReDim operator:

ReDim A(25)

During execution, you can call the ReDim statement multiple times, each time changing the size of the array. The Preserve option preserves the values ​​of the array elements when resizing. For example, the following code will increase the array declared above by five elements, leaving the existing ones intact:

ReDim Preserve A(30)

Remember that when the array size is reduced, the values ​​of the removed elements will be irretrievably lost. With the Erase operator, you can clear the elements of a fixed array or free the memory occupied by a dynamic array.

Dim A ReDim A(25) ... Erase A

Constants

It is a good practice to declare constants for values ​​that are used repeatedly in the program text. A well-named constant improves readability, and the use itself makes it easier to make changes to the code. Unlike variables, the value of a constant cannot be changed during program execution. A constant is created using the Const operator:

Const CountryName = "Belarus" Const CountryCode = 375

Several constants can be declared within one statement, separated by commas. Like a variable, a constant has its own scope, depending on where (in a procedure or outside it) and how (Public or Private) it was declared. Constants created by the Const statement without specifying Public or Private are public by default.

In the Explorer tree of the Script Object Editor window, there is a special section - Constants and Variables - for declaring global constants visible to all project script functions.

String constant values ​​are enclosed in double quotes.

Values ​​of the Date type should be framed with hash marks (#) and use the US format: month/day/year. For example:

Const Public IndependenceDay = #03/25/1918#

To avoid confusion between constants and variables, it is recommended to use a single prefix for all constants, such as "con", or to type the name of the constant in uppercase.

To make the programmer's job easier, VBScript contains a set of predefined constants.

Operators

VBScript operators fall into five categories: arithmetic, comparison, merge, boolean, and assignment.

Arithmetic operators

Operator	Usage example	Description
^	number ^ exponent	Raises number to the exponent power. Number can only be less than zero if it is an integer power. If one of the operands is Null, the entire expression evaluates to Null. If multiple exponentiations are performed in a row, the result is calculated from left to right.
*	number1 * number2	The product of two numbers. If the operand is Empty, then it is assumed to be zero. If at least one of the operands is Null, the entire expression evaluates to Null.
/	number1 / number2	Real division of two numbers. Operands are governed by the same rules as the multiplication operator.
\	number1\number2	Integer division. Both operands are cast to Byte, Integer, or Long before evaluation. Otherwise, the same rules apply as for the division operator.
Mod	number1 Mod number2	The remainder of an integer division. Casting operands to an integer, as well as the rules for handling Empty and Null, as in integer division.
+	expression1 + expression2	If both operands are numbers, the result is their arithmetic sum. If both operands are strings - merge (concatenation) of two strings. If one operand is a number and the other is a string, then the string operand will be converted to a number and added to the numeric. If at least one of the operands is Null, the entire expression evaluates to Null. If both operands are Empty, the result is an integer value of 0. If only one operator is Empty, the value of the second operand is returned as the result.
-	number1 - number2 or - number	In the first case, it returns the difference of two numbers. In the second, it inverts the sign of the number. Rules for operands with Null and Empty values, as for the multiplication operator.

Comparison Operators

The format for using comparison operators is:

Result = expression1 comparisonoperator expression2

where the following comparison operators are used:< (меньше), <= (меньше или равно), >(greater than), >= (greater than or equal to), = (equal to),<>(not equal).

Depending on the types and values ​​of the operands, the comparison is carried out as follows:

If	That
Both operands are numbers.	The two numbers are compared.
Both operands are strings.	The two strings are compared.
One of the operands is a number and the second is a string.	The string operand is cast to a number and the two numbers are compared.
One of the operands is Empty, and the second is a number.	An operand with the value Empty is assumed to be 0.
One of the operands is Empty, and the second is a string.	The operand with the value Empty is taken equal to the empty string "". The two strings are compared.
Both operands are Empty.	The operands are considered equal.
At least one of the operands is Null.	The result is Null.

The special Is operator is used to compare two object variables and returns True if both variables refer to the same object instance.

Concatenation Operators

Result = expression1 & expression2

If the operand is not a string, it is cast to a string type. If both operands are Null, then the result is also Null, however, unlike the other operators, if only one operand is Null, then it is taken equal to the empty string. An operand that has the value Empty is also treated as the empty string "".

Logical operators

VBScript provides us with the following logical operators:

1. Boolean exception (Xor);
2. Logical equivalent (Eqv);
3. Logical implication (Imp).

Boolean expressions or numeric values ​​can act as operands of logical operators. In the first case, the result will be a boolean constant, in the second, a number. Depending on the operator, giving one or two Null values ​​as input may result in a Null result. The Not operator is unary and returns the logical negation of the expression. On a numeric operand, the Not operator performs a bitwise inversion. The rest of the logical operators are binary. The table below shows the results of executing each of the operators depending on the value of the operands Exp1 and Exp2:

Exp1	Exp2	And	Or	Xor	Equv	imp
True	True	True	True	False	True	True
True	False	False	True	True	False	False
False	True	False	True	True	False	True
False	False	False	False	False	True	True
True	Null	Null	True	Null	Null	Null
False	Null	False	Null	Null	Null	True
Null	True	Null	True	Null	Null	True
Null	False	False	Null	Null	Null	Null
Null	Null	Null	Null	Null	Null	Null

In real life, And and Or operators are most often used, and Xor is much less common. We have not encountered the use of the Eqv and Imp operators in practice. If you find it difficult to understand the above table, we summarize the action of these operators:

• And is True only if both operands are True. In any other case, it is either False or Null.
• Or evaluates to True if at least one of its operands is True.
• Xor is True if the operands are different and False if they are the same.

When executed bitwise on numeric operands, the result of a logical operator is determined by the following table:

Exp1	Exp2	And	Or	Xor	Equv	imp
0	0	0	0	0	1	1
0	1	0	1	1	0	1
1	0	0	1	1	0	0
1	1	1	1	0	1	1

assignment operator

The assignment operator (=) is described in detail in the "Variables" section.

Order of Application of Operators

If an expression contains multiple operators, they are applied according to a set order called operator precedence. You can change the default order using parentheses. The expression inside the parentheses is always evaluated first.

In an expression containing operators of different categories, the arithmetic operations are performed first, then the comparison operators, and finally the logical operators. All comparison operators have the same precedence and are evaluated from left to right. Arithmetic and logical operators are evaluated in the following order:

1. Exponentiation (^);
2. Number change sign, unary minus (-);
3. Multiplication (*) and division (/);
4. Integer division (\);
5. Remainder of integer division (Mod);
6. Addition (+) and subtraction (-);
7. String concatenation (&).

If multiplication and division occur in the same expression, then the operations are performed in left-to-right order. A similar rule applies in the case of the simultaneous presence of addition and subtraction operators.

The string concatenation operator (&) is not arithmetic and takes precedence between arithmetic and comparison operators.

The order for logical operators is as follows:

1. Logical negation, inversion (Not);
2. Logical multiplication, conjunction (And);
3. Logical addition, disjunction (Or);
4. Boolean exception (Xor);
5. Logical equivalent (Eqv);
6. Logical implication (Imp).

Conditional expressions

Conditional expressions are used to control the order of execution of program commands and allow you to organize transitions (branching) and repetition of commands. Typically, comparison operators are used in conjunction with conditional expressions.

If..Then..Else expression

The conditional jump expression If allows you to execute one or another group of commands depending on the result of a logical expression or the value of a Boolean variable.

To execute a single command when a given condition is met, use the single-line expression syntax:

Dim S If DatePart("w", Now) = vbMonday Then S = "Monday" Application.MessageBox S, "", vbOkOnly

Note that the Else section is omitted in this case. To execute a group of statements, enclose them between the Then and End If keywords.

Dim S If DatePart("w", Now) = vbMonday Then S = "Today is Monday" Application.MessageBox S, "", vbOkOnly End If

If one code is required when the condition is met, and another code is required when the condition is not met, then the syntax of the expression with the Else section is used:

Dim S If DatePart("w", Now) = vbMonday Then S = "Today is Monday" Else S = "Today is not Monday" End If Application.MessageBox S, "", vbOkOnly

If you need to choose from several alternatives, the syntax with the ElseIf construct is suitable:

Dim S, D D = DatePart("w", Now) If D = vbMonday Then S = "Monday" ElseIf D = vbTuesday Then S = "Tuesday" ElseIf D = vbWednesday Then S = "Wednesday" ... End If Application. MessageBox S, "", vbOkOnly

If expressions can be nested:

Dim S, D D = DatePart("w", Now) If D = vbMonday Then S = "Monday" Else If D = vbTuesday Then S = "Tuesday" Else If D = vbWednesday Then S = "Wednesday" Else ... End If End If End If

While there is no limit to the number of ElseIf sections in a conditional expression, extensive use of them can lead to confusing, unreadable code. In the case of choosing one alternative out of many possible, depending on the value of some selector, it is recommended to use the Select Case expression.

Select..Case expression

Let's rewrite the example with days of the week using a select expression:

Dim S Select Case DatePart("w", Now) Case vbMonday S = "Monday" Case vbTuesday S = "Tuesday" Case vbWednesday S = "Wednesday" ... Case Else Err.Raise 32000, "", "Unknown day of the week End Select

Since the selector expression is evaluated only once, using Select..Case results in more efficient code. It is recommended that you always use the Case Else section to catch invalid or raw selector values.

Loop statements

Quite often there is a situation when the code needs to be re-run. To do this, write a loop statement that repeats certain commands over and over again. Loop statements are used in many situations: when calculating a grand total over a list of numbers, moving through the records of a dataset, or running a block of code on multiple objects. There are several cycles described in the following sections. Some of them are executed while the condition is True, some of them are False. And, finally, there are those that are executed a given number of times.

Do..Loop statement

This statement is intended to execute a group of commands until the specified condition is True or until it becomes True. The condition check can be carried out as at the beginning of the loop:

Do [(While | Until) condition] Loop

so at the end:

Do Loop [(While | Until) condition]

The Exit Do command can occur an unlimited number of times in the loop body. It is usually used in conjunction with the If..Then conditional statement and allows control to be transferred to the statement immediately following the loop. When using Exit Do inside a nested loop, control will jump to the outer loop.

The following code allows you to replace the dice:

Dim Resp, Num Do Num = Int(6 * Rnd + 1) Resp = Application.MessageBox(Num & " Another number?", "",_ vbYesNo or vbQuestion) Loop Until Resp = vbNo

While..Wend

It is a truncated version of the Do..Loop operator and allows you to execute a group of commands while the condition is True. Operator syntax:

While condition Wend

Note that Exit Do has no effect inside this loop. While..Wend loops can be nested.

For..Next

This loop repeats a given set of commands a specified number of times. The operator syntax is:

For counter = start To end Next

Before the loop starts, the variable counter is assigned the value start. Next, the condition counter is checked<= end, при step >= 0, or counter >= end, with a negative step. After executing the command block, the counter variable is incremented by the step value and everything repeats from the beginning.

Changing the counter in the loop body is not prohibited, but it is strongly discouraged, as it makes it difficult to understand the program logic and debug it.

Exit For can occur any number of times in the loop body. Loops can be nested. For example, this loop initializes a three-dimensional array:

Dim A(9, 9, 9) Dim I, J, K For I = 0 To 9 For J = 0 To 9 For K = 0 To 9 A(I, J, K) = 1 Next Next Next

For Each..Next

The For Each..Next loop statement repeats a given set of commands for each element of an array or collection and has the following syntax:

For Each element In group Next

The loop is executed if there is at least one element in the array or collection. Exit For can occur any number of times in the loop body.

Illustrate using For Each..Next using the following code as an example, which displays a list of files from the root directory of the drive c:\

Dim fso, f, f1, fc, s Set fso = CreateObject("Scripting.FileSystemObject") Set f = fso.GetFolder("c:\") Set fc = f.Files For Each f1 in fc s = s & f1 .name & vbNewLine Next Application.MessageBox s, "Files on c:\", vbOkOnly

Procedures

To save memory and structure the program, a code fragment that is called repeatedly in different places can be formatted as a procedure. There are two types of procedures in VBScript: subroutines (Sub) and functions (Function). A subroutine is a sequence of statements surrounded by the keywords Sub and End Sub. A subroutine can take parameters as input, but does not return a value. A function - a sequence of statements between Function and End Function -- returns a result and can therefore be used in an expression. Each procedure must have a name that is unique within the module. The names of procedures declared in a global module must be unique throughout the project.

The definition of a subroutine and a function has the following syntax:

| Private] Sub name [(arglist)] End Sub | Private] Function name [(arglist)] End Function

Public procedures are global and available in all program scripts. Private procedures are only available in the script where they are declared. Unless otherwise noted, a declared procedure is public. The Default keyword can only be used in the body of a class and is used to specify the default method of that class.

The parameter list has the following syntax:

Varname[, ...]

Parameters can be passed by value (ByVal) or by reference (ByRef). By default, all parameters are passed by value. Constants, expression evaluation results can only be passed by value. Changing a parameter passed by reference will change the value of the external variable. Let us explain the passing of parameters into a procedure using the following example:

Sub DoCalculation(ByRef A, ByVal B, ByVal C) A = C * 2 B = C / 2 End Sub Sub TestVar Dim V1, V2 V1 = 1 V2 = 2 DoCalculation V1, V2, 10 20" V2 = 2 End Sub

Variables declared inside the body of a procedure are local and are destroyed when the procedure ends. The values ​​of local variables are not saved.

The parameter list is specified in parentheses when a function is called or when a subroutine is called using the Call statement. So, we could write the call to the DoCalculation procedure in the example above as follows:

Call DoCalculation(V1, V2, 10)

Execute expression

VBScript classes

VBScript allows you to create new classes, which we will refer to as VB classes from now on. Generally speaking, they are not full-fledged classes in the understanding of object-oriented programming, since they do not support inheritance and, accordingly, polymorphism. So, of the three pillars on which the object-oriented paradigm is based, only encapsulation remains - the ability to combine data and methods within one entity.

The class is defined using the following construct:

Class name statements End Class

where name is the name of the class, and statements are one or more definitions of variables, properties, procedures, or functions, also called class members. Please note that unlike Delphi, where the class definition code contains only declarations of procedures and functions, in the VB class, the member code is written directly in the class text.

Class members can be declared as Private or Public. The first ones are visible only inside the code of this class, while the second ones are available both for the internal code and outside. If a variable or function (procedure) does not contain an explicit definition of Public or Private, then they are considered public. Procedures or functions declared as Public inside a class block become methods of that class.

Variables declared as public become class properties along with properties declared directly using the Property Get, Property Let, Property Set constructs.

Defining class properties

Above, we have already said that the fields of a class, explicitly or implicitly declared as Public, become its properties. In addition, you can create a class property by defining special functions for reading the value of the property (Property Get), as well as for assigning it (Property Let or Property Set).

The syntax for defining such functions is as follows:

| Private] Property Get name [(arglist)] [ name = expression] [ name = expression] End Property Property Let name ( value) End Property Property Set name( reference) End Property

By defining only one function, read or set, you can create a property, respectively, read-only or write-only. The Property Let procedure is used to assign simple data types, and the Property Set procedure is used to pass a reference to an object. Note that all three functions can accept an arbitrary list of parameters as input. In this way, you can organize, for example, array properties, passing the element index as an argument.

Creating and Destroying an Instance of a VB Class

Creating an instance of a VB class is done using the New operator.

Dim X Set X = New classname

The destruction of the previously created instance occurs automatically upon completion of the block of code where the corresponding variable was declared and provided that there are no external references to it. If you need to destroy the instance manually, you must assign the Nothing value to the variable.

‘ Declaring a variable and creating a class instance Dim X Set X = New classname ... ‘ Using a class instance ... ‘ Destroying a class instance Set X = Notning ...

Initialize and Terminate events

The Initialize event occurs when an instance of a class is created, and the Terminate event occurs when it is destroyed. The developer can define his own event handlers. The following is an example of using object creation and deletion events:

Class TestClass " Define an Initialize event handler. Private Sub Class_Initialize MsgBox("TestClass started") End Sub " Define a Terminate event handler. Private Sub Class_Terminate MsgBox("TestClass terminated") End Sub End Class " Create an instance of the TestClass class. " The message "TestClass started" will be displayed. Set X = New TestClass " The instance is destroyed. " The message "TestClass terminated" will be displayed. Set X = Nothing

Continuation

Visual Basic Script

Why VBS scripts are needed

VBS script is a powerful solution for automating user actions in Windows family systems. This type of script is commonly used for:

• creating complex scenarios;
• using objects from other applications and libraries;
• hiding windows during script execution;
• script logic encryption.

Basically, VBS scripts are used for data processing, system management, work with user and computer accounts, interaction with office applications, work with databases, and other complex tasks.

Key points

Depending on the script language, content and encryption, there are the following types of scripts:

• vbs - Visual Basic Script
• vbe - encrypted Visual Basic Script
• js - JavaScript
• jse - encrypted Java Script
• wsh - script settings
• wsf - XML ​​Integrated Script

In this article, I will be looking at scenarios like vbs.

Scripts are usually edited in Windows Notepad, but I recommend using Notepad2, which highlights Visual Basic language keywords and helps format the body of the script. So, a vbs script is a plain text file named *.VBS, which is easy to edit in notepad, and run for execution by double-clicking or calling by name in the console.

As described above, scripts are not compiled, but interpreted. That is, to process the script, the system must have a VBS language interpreter, and there are even two such interpreters in Windows: windowed WScript and console CScript - both interpreters are Windows script host(WSH).

By default, all scripts are executed through WScript, so no settings are required, but to execute a script in a console window, you must run it through CScript, or set CScript as the default interpreter. To do this, run the following on the command line:

CScript //H:CScript

After that, all scripts will be executed in console mode. Returning to windowed mode is done with the following command:

CScript //H:WScript

The following rules work in Visual Basic:

• string length is not limited;
• characters are case insensitive;
• the number of spaces between parameters is not taken into account;
• the command line can be broken, and at the break point you need to insert the symbol "_";
• the maximum length of a variable name is 255 characters;
• comments are marked with " " ".

" === Script Information Header === " Script Name: " script name; " Date: " modification date; " Author: " author; " Description: " description; " === Initialization Block === Option Explicit " directive , which prevents automatic creation of " variables; Dim " variable declaration; Dim () "declaration of arrays; Set