VBScript Features by Category
|
|
Category
|
Keywords
|
Array handling
|
Array, Dim, Erase, IsArray, LBound, Private, Public, ReDim, UBound
|
Assignments
|
Set
|
Comments
|
Comments using ' or Rem
|
Constants/Literals
|
Empty, False, Nothing, Null, True
|
Control flow
|
Do...Loop, For...Next, For Each...Next, If...Then...Else, Select Case, While...Wend, With
|
Conversions
|
Abs, Asc, AscB, AscW, CBool, CByte, CCur, CDate, CDbl, Chr, ChrB, ChrW, CInt, CLng, CSng, CStr, DateSerial, DateValue, Fix, Hex, Int, Oct, Sgn, TimeSerial, TimeValue
|
Dates/Times
|
Date, DateAdd, DateDiff, DatePart, DateSerial, DateValue, Day, Hour, Minute, Month, MonthName, Now, Second, Time, TimeSerial, TimeValue, Weekday, WeekdayName, Year
|
Declarations
|
Class, Const, Dim, Function, Private, Property Get, Property Let, Property Set, Public, ReDim, Sub
|
Error Handling
|
Err, On Error
|
Expressions
|
Eval, Execute, RegExp, Replace, Test
|
Formatting Strings
|
FormatCurrency, FormatDateTime, FormatNumber, FormatPercent
|
Input/Output
|
InputBox, LoadPicture, MsgBox
|
Literals
|
Empty, False, Nothing, Null, True
|
Math
|
Atn, Cos, Exp, Log, Randomize, Rnd, Sin, Sqr, Tan
|
Miscellaneous
|
Eval Function, Execute Statement, RGB Function
|
Objects
|
CreateObject, Err Object, GetObject, RegExp
|
Operators
|
Addition (+), And, Division (/), Equality (=), Eqv, Exponentiation (^), Greater Than (>), Greater Than or Equal To (>=), Imp, Inequality (<>), Integer Division (\), Is, Less Than (<), Less Than or Equal To (<=), Modulus arithmetic (Mod), Multiplication (*), Negation (-), Or, String concatenation (&), Subtraction (-), Xor
|
Options
|
Option Explicit
|
Procedures
|
Call, Function, Property Get, Property Let, Property Set, Sub
|
Rounding
|
Abs, Fix, Int, Round, Sgn
|
Script Engine ID
|
ScriptEngine, ScriptEngineBuildVersion, ScriptEngineMajorVersion, ScriptEngineMinorVersion
|
Strings
|
Asc, AscB, AscW, Chr, ChrB, ChrW, Filter, InStr, InStrB, InStrRev, Join, LCase, Len, LenB, Left, LeftB, LTrim, Mid, MidB, Replace, Right, RightB, RTrim, Space, Split, StrComp, String, StrReverse, Trim, UCase
|
Variants
|
IsArray, IsDate, IsEmpty, IsNull, IsNumeric, IsObject, TypeName, VarType
|
Variants Sub Types
Subtype
|
Description
|
Empty
|
Variant is uninitialized. Value is 0 for numeric variables or a zero-length string ("") for string variables.
|
Null
|
Variant intentionally contains no valid data.
|
Boolean
|
Contains either True or False.
|
Byte
|
Contains integer in the range 0 to 255.
|
Integer
|
Contains integer in the range -32,768 to 32,767.
|
Currency
|
-922,337,203,685,477.5808 to 922,337,203,685,477.5807.
|
Long
|
Contains integer in the range -2,147,483,648 to 2,147,483,647.
|
Single
|
Contains a single-precision, floating-point number in the range -3.402823E38 to -1.401298E-45 for negative values; 1.401298E-45 to 3.402823E38 for positive values.
|
Double
|
Contains a double-precision, floating-point number in the range -1.79769313486232E308 to -4.94065645841247E-324 for negative values; 4.94065645841247E-324 to 1.79769313486232E308 for positive values.
|
Date (Time)
|
Contains a number that represents a date between January 1, 100 to December 31, 9999.
|
String
|
Contains a variable-length string that can be up to approximately 2 billion characters in length.
|
Object
|
Contains an object.
|
Error
|
Contains an error number.
|
VBScript Data Types:
VBScript has only one data type called a Variant. At its simplest, a Variant can contain either numeric or string information. A Variant behaves as a number when you use it in a numeric context and as a string when you use it in a string context. You can always make numbers behave as strings by enclosing them in quotation marks (" ").
Variant Subtypes:
Beyond the simple numeric or string classifications, a Variant can make further distinctions about the specific nature of numeric information. You can have a rich variety of numeric information ranging in size from Boolean values to huge floating-point numbers. These different categories of information that can be contained in a Variant are called subtypes.
VBScript Variables:
A variable is a convenient placeholder that refers to a computer memory location where you can store program information that may change during the time your script is running. For example, you might create a variable called ClickCount to store the number of times a user clicks an object on a particular Web page. You only have to refer to a variable by name to see or change its value. In VBScript, variables are always of one fundamental data type, Variant.
You declare variables explicitly in your script using the
Dim statement,
Public statement, and
Private statement.
For example:
Dim DegreesFahrenheit
You declare multiple variables by separating each variable name with a comma. For example:
Dim Top, Bottom, Left, Right
You could misspell the variable name in one or more places, causing unexpected results when your script is run. For that reason, the Option Explicit statement is available to require explicit declaration of all variables. The Option Explicit statement should be the first statement in your script.
Variable names follow the standard rules for naming anything in VBScript. A variable name:
· Must begin with an alphabetic character.
· Cannot contain an embedded period.
· Must not exceed 255 characters.
· Must be unique in the scope in which it is declared.
If you declare a variable within a procedure, only code within that procedure can access or change the value of that variable. It has local scope and is a procedure-level variable. If you declare a variable outside a procedure, you make it recognizable to all the procedures in your script. This is a script-level variable, and it has script-level scope.
The lifetime of a script-level variable extends from the time it is declared until the time the script is finished running. At procedure level, a variable exists only as long as you are in the procedure. When the procedure exits, the variable is destroyed. Local variables are ideal as temporary storage space when a procedure is executing. You can have local variables of the same name in several different procedures because each is recognized only by the procedure in which it is declared.
Assigning Values to Variables: Values are assigned to variables creating an expression as follows: the variable is on the left side of the expression and the value you want to assign to the variable is on the right. For example: B = 200
CutoffDate = #06/18/2008#
CutoffTime = #3:36:00 PM#
A variable containing a single value is a scalar variable. Other times, it is convenient to assign more than one related value to a single variable. Then you can create a variable that can contain a series of values. This is called an array variable. Array variables and scalar variables are declared in the same way, except that the declaration of an array variable uses parentheses ( ) following the variable name. In the following example, a single-dimension array containing 11 elements is declared:
Dim A(10)
Although the number shown in the parentheses is 10, all arrays in VBScript are zero-based, so this array actually contains 11 elements. In a zero-based array, the number of array elements is always the number shown in parentheses plus one. This kind of array is called a fixed-size array.
You assign data to each of the elements of the array using an index into the array. Beginning at zero and ending at 10, data can be assigned to the elements of an array as follows:
A(0) = 256
A(1) = 324
A(2) = 100
. . .
A(10) = 55
Similarly, the data can be retrieved from any element using an index into the particular array element you want. For example:
SomeVariable = A(8)
Arrays aren't limited to a single dimension. You can have as many as 60 dimensions, although most people can't comprehend more than three or four dimensions. You can declare multiple dimensions by separating an array's size numbers in the parentheses with commas. In the following example, the MyTable variable is a two-dimensional array consisting of 6 rows and 11 columns:
Dim MyTable(5, 10)
In a two-dimensional array, the first number is always the number of rows; the second number is the number of columns.
You can also declare an array whose size changes during the time your script is running. This is called a dynamic array. The array is initially declared within a procedure using either the Dim statement or using the ReDim statement. However, for a dynamic array, no size or number of dimensions is placed inside the parentheses. For example:
Dim MyArray()
ReDim AnotherArray()
To use a dynamic array, you must subsequently use ReDim to determine the number of dimensions and the size of each dimension. In the following example, ReDim sets the initial size of the dynamic array to 25. A subsequent ReDim statement resizes the array to 30, but uses the Preserve keyword to preserve the contents of the array as the resizing takes place.
ReDim MyArray(25)...
ReDim Preserve MyArray(30)
There is no limit to the number of times you can resize a dynamic array, although if you make an array smaller, you lose the data in the eliminated elements.
Creating Constants:
You create user-defined constants in VBScript using the Const statement. Using the Const statement,
you can create string or numeric constants with meaningful names and assign them literal values.
For example:
Const MyString = "This is my string."
Const MyAge = 49
Note that the string literal is enclosed in quotation marks (" ").
Quotation marks can be used to differentiate string values from numeric values.
You represent Date literals and time literals by enclosing them in number signs (#). For example:
Const CutoffDate = #06/18/2008#; (or) Const CutoffTime = #3:36:00 PM#
Operator Precedence:
When several operations occur in an expression, each part is evaluated and resolved in a predetermined order called operator precedence. You can use parentheses to override the order of precedence and force some parts of an expression to be evaluated before others. Operations within parentheses are always performed before those outside. Within parentheses, however, standard operator precedence is maintained.
When expressions contain operators from more than one category, arithmetic operators are evaluated first, comparison operators are evaluated next, and logical operators are evaluated last. Comparison operators all have equal precedence; that is, they are evaluated in the left-to-right order in which they appear. Arithmetic and logical operators are evaluated in the following order of precedence.
Arithmetic
Description
|
Symbol
|
| Exponentiation | ^ |
| Unary negation | - |
| Multiplication | * |
| Division | / |
| Integer division | \ |
| Modulus arithmetic | Mod |
| Addition | + |
| Subtraction | - |
| String concatenation | & |
Comparison
Description
|
Symbol
|
| Equality | = |
| Inequality | <> |
| Less than | < |
| Greater than | > |
| Less than or equal to | <= |
| Greater than or equal to | >= |
| Object equivalence | Is |
Logical
Description
|
Symbol
|
| Logical negation | Not |
| Logical conjunction | And |
| Logical disjunction | Or |
| Logical exclusion | Xor |
| Logical equivalence | Eqv |
| Logical implication | Imp |
When multiplication and division occur together in an expression, each operation is evaluated as it occurs from left to right. Likewise, when addition and subtraction occur together in an expression, each operation is evaluated in order of appearance from left to right.
The string concatenation (&) operator is not an arithmetic operator, but in precedence it falls after all arithmetic operators and before all comparison operators. The Is operator is an object reference comparison operator. It does not compare objects or their values; it checks only to determine if two object references refer to the same object.
Conditional Statements:
Using conditional statements, you can write VBScript code that makes decisions and repeats actions. The following conditional statements are available in VBScript:
· If...Then...Else statement
· Select Case statement
Making Decisions Using If...Then...Else
The If...Then...Else statement is used to evaluate whether a condition is True or False and, depending on the result, to specify one or more statements to run. Usually the condition is an expression that uses a comparison operator to compare one value or variable with another.
Running Statements if a Condition is True
To run only one statement when a condition is True, use the single-line syntax for the If...Then...Else statement. The following example shows the single-line syntax. Notice that this example omits the Else keyword.
Sub FixDate()
Dim myDate
myDate = #2/13/95#
If myDate < Now Then myDate = Now
End Sub
To run more than one line of code, you must use the multiple-line (or block) syntax. This syntax includes the End If statement, as shown in the following example:
Sub AlertUser(value)
If value = 0 Then
AlertLabel.ForeColor = vbRed
AlertLabel.Font.Bold = True
AlertLabel.Font.Italic = True
End If
End Sub
Running Certain Statements if a Condition is True and Running Others if a Condition is False
You can use an If...Then...Else statement to define two blocks of executable statements: one block to run if the condition is True, the other block to run if the condition is False.
Sub AlertUser(value)
If value = 0 Then
AlertLabel.ForeColor = vbRed
AlertLabel.Font.Bold = True
AlertLabel.Font.Italic = True
Else
AlertLabel.Forecolor = vbBlack
AlertLabel.Font.Bold = False
AlertLabel.Font.Italic = False
End If
End Sub
Deciding Between Several Alternatives
A variation on the If...Then...Else statement allows you to choose from several alternatives. Adding ElseIf clauses expands the functionality of the If...Then...Else statement so you can control program flow based on different possibilities. For example:
Sub ReportValue(value)
If value = 0 Then
MsgBox value
ElseIf value = 1 Then
MsgBox value
ElseIf value = 2 then
Msgbox value
Else
Msgbox "Value out of range!"
End If
You can add as many ElseIf clauses as you need to provide alternative choices. Extensive use of the ElseIf clauses often becomes cumbersome. A better way to choose between several alternatives is the Select Case statement.
Making Decisions with Select Case
The Select Case structure provides an alternative to If...Then...ElseIf for selectively executing one block of statements from among multiple blocks of statements. A Select Case statement provides capability similar to the If...Then...Else statement, but it makes code more efficient and readable.
A Select Case structure works with a single test expression that is evaluated once, at the top of the structure. The result of the expression is then compared with the values for each Case in the structure. If there is a match, the block of statements associated with that Case is executed, as in the following example.
Select Case Document.Form1.CardType.Options(SelectedIndex).Text
Case "MasterCard"
DisplayMCLogo
ValidateMCAccount
Case "Visa"
DisplayVisaLogo
ValidateVisaAccount
Case "American Express"
DisplayAMEXCOLogo
ValidateAMEXCOAccount
Case Else
DisplayUnknownImage
PromptAgain
End Select
Notice that the Select Case structure evaluates an expression once at the top of the structure. In contrast, the If...Then...ElseIf structure can evaluate a different expression for each ElseIf statement. You can replace an If...Then...ElseIf structure with a Select Case structure only if each ElseIf statement evaluates the same expression.
The following looping statements are available in VBScript:
· Do...Loop: Loops while or until a condition is True.
· While...Wend: Loops while a condition is True.
· For...Next: Uses a counter to run statements a specified number of times.
· For Each...Next: Repeats a group of statements for each item in a collection or each element of an array.
Using Do Loops:
You can use Do...Loop statements to run a block of statements an indefinite number of times. The statements are repeated either while a condition is True or until a condition becomes True.
Repeating Statements While a Condition is True
Use the While keyword to check a condition in a Do...Loop statement. You can check the condition before you enter the loop (as shown in the following ChkFirstWhile example), or you can check it after the loop has run at least once (as shown in the ChkLastWhile example). In the ChkFirstWhile procedure, if myNum is set to 9 instead of 20, the statements inside the loop will never run. In the ChkLastWhile procedure, the statements inside the loop run only once because the condition is already False.
Sub ChkFirstWhile()
Dim counter, myNum
counter = 0
myNum = 20
Do While myNum > 10
myNum = myNum - 1
counter = counter + 1
Loop
MsgBox "The loop made " & counter & " repetitions."
End Sub
Sub ChkLastWhile()
Dim counter, myNum
counter = 0
myNum = 9
Do
myNum = myNum - 1
counter = counter + 1
Loop While myNum > 10
MsgBox "The loop made " & counter & " repetitions."
End Sub
Repeating a Statement Until a Condition Becomes True
There are two ways to use the Until keyword to check a condition in a Do...Loop statement. You can check the condition before you enter the loop (as shown in the following ChkFirstUntil example), or you can check it after the loop has run at least once (as shown in the ChkLastUntil example). As long as the condition is False, the looping occurs.
Sub ChkFirstUntil()
Dim counter, myNum
counter = 0
myNum = 20
Do Until myNum = 10
myNum = myNum - 1
counter = counter + 1
Loop
MsgBox "The loop made " & counter & " repetitions."
End Sub
Sub ChkLastUntil()
Dim counter, myNum
counter = 0
myNum = 1
Do
myNum = myNum + 1
counter = counter + 1
Loop Until myNum = 10
MsgBox "The loop made " & counter & " repetitions."
End Sub
Exiting a Do...Loop Statement from Inside the Loop
You can exit a Do...Loop by using the Exit Do statement. Because you usually want to exit only in certain situations, such as to avoid an endless loop, you should use the Exit Do statement in the True statement block of an If...Then...Else statement. If the condition is False, the loop runs as usual.
In the following example, myNum is assigned a value that creates an endless loop. The If...Then...Else statement checks for this condition, preventing the endless repetition.
Sub ExitExample()
Dim counter, myNum
counter = 0
myNum = 9
Do Until myNum = 10
myNum = myNum - 1
counter = counter + 1
If myNum < 10 Then Exit Do
Loop
MsgBox "The loop made " & counter & " repetitions."
End Sub
Using While...Wend
The While...Wend statement is provided in VBScript for those who are familiar with its usage. However, because of the lack of flexibility in While...Wend, it is recommended that you use Do...Loop instead.
Using For...Next
You can use For...Next statements to run a block of statements a specific number of times. For loops, use a counter variable whose value increases or decreases with each repetition of the loop.
The following example causes a procedure called MyProc to execute 50 times. The For statement specifies the counter variable x and its start and end values. The Next statement increments the counter variable by 1.
Sub DoMyProc50Times()
Dim x
For x = 1 To 50
MyProc
Next
End Sub
Using the Step keyword, you can increase or decrease the counter variable by the value you specify. In the following example, the counter variable j is incremented by 2 each time the loop repeats. When the loop is finished, the total is the sum of 2, 4, 6, 8, and 10.
Sub TwosTotal()
Dim j, total
For j = 2 To 10 Step 2
total = total + j
Next
MsgBox "The total is " & total
End Sub
To decrease the counter variable, use a negative Step value. You must specify an end value that is less than the start value. In the following example, the counter variable myNum is decreased by 2 each time the loop repeats. When the loop is finished, total is the sum of 16, 14, 12, 10, 8, 6, 4, and 2.
Sub NewTotal()
Dim myNum, total
For myNum = 16 To 2 Step -2
total = total + myNum
Next
MsgBox "The total is " & total
End Sub
You can exit any For...Next statement before the counter reaches its end value by using the Exit For statement. Because you usually want to exit only in certain situations, such as when an error occurs, you should use the Exit For statement in the True statement block of an If...Then...Else statement. If the condition is False, the loop runs as usual.
A For Each...Next loop is similar to a For...Next loop. Instead of repeating the statements a specified number of times, a For Each...Next loop repeats a group of statements for each item in a collection of objects or for each element of an array. This is especially helpful if you don't know how many elements are in a collection.
In the following HTML code example, the contents of a Dictionary object is used to place text in several text boxes.
<HTML>
<HEAD><TITLE>Forms and Elements</TITLE></HEAD>
<SCRIPT LANGUAGE="VBScript">
<!--
Sub cmdChange_OnClick
Dim d 'Create a variable
Set d = CreateObject("Scripting.Dictionary")
d.Add "0", "Athens" 'Add some keys and items
d.Add "1", "Belgrade"
d.Add "2", "Cairo"
For Each I in d
Document.frmForm.Elements(I).Value = D.Item(I)
Next
End Sub
-->
</SCRIPT>
<BODY>
<CENTER>
<FORM NAME="frmForm"
<Input Type = "Text"><p>
<Input Type = "Text"><p>
<Input Type = "Text"><p>
<Input Type = "Text"><p>
<Input Type = "Button" NAME="cmdChange" VALUE="Click Here"><p>
</FORM>
</CENTER>
</BODY>
</HTML>
In VBScript, there are two kinds of procedures; the Sub procedure and the Function procedure.
Sub Procedures:
A Sub procedure is a series of VBScript statements (enclosed by Sub and End Sub statements) that perform actions but don't return a value. A Sub procedure can take arguments (constants, variables, or expressions that are passed by a calling procedure). If a Sub procedure has no arguments, its Sub statement must include an empty set of parentheses ().
The following Sub procedure uses two intrinsic, or built-in, VBScript functions, MsgBox and InputBox, to prompt a user for information. It then displays the results of a calculation based on that information. The calculation is performed in a Function procedure created using VBScript. The Function procedure is shown after the following discussion.
Sub ConvertTemp()
temp = InputBox("Please enter the temperature in degrees F.", 1)
MsgBox "The temperature is " & Celsius(temp) & " degrees C."
End Sub
Function Procedures:
A Function procedure is a series of VBScript statements enclosed by the Function and End Function statements. A Function procedure is similar to a Sub procedure, but can also return a value. A Function procedure can take arguments (constants, variables, or expressions that are passed to it by a calling procedure). If a Function procedure has no arguments, its Function statement must include an empty set of parentheses. A Function returns a value by assigning a value to its name in one or more statements of the procedure. The return type of a Function is always a Variant.
In the following example, the Celsius function calculates degrees Celsius from degrees Fahrenheit. When the function is called from the ConvertTemp Sub procedure, a variable containing the argument value is passed to the function. The result of the calculation is returned to the calling procedure and displayed in a message box.
Sub ConvertTemp()
temp = InputBox("Please enter the temperature in degrees F.", 1)
MsgBox "The temperature is " & Celsius(temp) & " degrees C."
End Sub
Function Celsius(fDegrees)
Celsius = (fDegrees - 32) * 5 / 9
End Function
Getting Data into and out of Procedures:
Each piece of data is passed into your procedures using an argument . Arguments serve as placeholders for the data you want to pass into your procedure. You can name your arguments any valid variable name. When you create a procedure using either the Sub statement or the Function statement, parentheses must be included after the name of the procedure. Any arguments are placed inside these parentheses, separated by commas. For example, in the following example, fDegrees is a placeholder for the value being passed into the Celsius function for conversion.
Function Celsius(fDegrees)
Celsius = (fDegrees - 32) * 5 / 9
End Function
To get data out of a procedure, you must use a Function. Remember, a Function procedure can return a value; a Sub procedure can't.
Using Sub and Function Procedures in Code:
A Function in your code must always be used on the right side of a variable assignment or in an expression. For example:
Temp = Celsius(fDegrees)
-or-
MsgBox "The Celsius temperature is " & Celsius(fDegrees) & " degrees."
To call a Sub procedure from another procedure, type the name of the procedure along with values for any required arguments, each separated by a comma. The Call statement is not required, but if you do use it, you must enclose any arguments in parentheses.
The following example shows two calls to the MyProc procedure. One uses the Call statement in the code; the other doesn't. Both do exactly the same thing.
Call MyProc(firstarg, secondarg)
MyProc firstarg, secondarg
Notice that the parentheses are omitted in the call when the Call statement isn't used.
ByRef and ByVal Parameters
When you call a subroutine or function, each argument can be passed by reference or by value. When an argument is passed by reference, the called procedure can change the value of the variable. The change persists after the procedure is called. When an argument is passed by value, any changes that the called procedure makes to the value of the variable do not persist after the procedure is called.
In a Sub or Function declaration, each parameter can be specified as ByRef or ByVal. If neither is specified, the default is ByRef.
If ByVal is specified, the corresponding argument is always passed by value when the subroutine is called.
If ByRef (or neither) is specified, the argument can be passed by reference or by value when the subroutine is called. The argument is passed by value if it is enclosed in parentheses, and if the parentheses do not apply to the parameter list. The argument is also passed by value if the variable sent as an argument is in a class. Otherwise, it is passed by reference.
The following table summarizes this.
Keyword specified
|
Argument is passed by
|
| ByVal | Value. |
| ByRef (default) | Reference or value, depending on other factors. |
In the following example, the ByRef keyword is specified for the MyParam variable. When the subroutine is called, a reference is passed to the variable MyArg. When the subroutine changes the value of MyParam, this also changes the value of MyArg. The local variable MyParam becomes an alias for MyArg.
Sub TestSub(ByRef MyParam)
MyParam = 5
End Sub
Dim MyArg
MyArg = 123
TestSub MyArg
' MyArg in changed in TestSub to 5.
In the following example, the ByVal keyword is used. Therefore, the argument is passed by value. The subroutine changes the value of MyParam. However, the value of MyArg remains unchanged.
Sub TestSub(ByVal MyParam)
MyParam = 5
End Sub
Dim MyArg
MyArg = 123
TestSub MyArg
' MyArg is still 123.
The default is ByRef if ByRef or ByVal is not specified. In this example, ByRef applies to the MyParam variable because neither ByRef nor ByVal is specified.
Sub TestSub(MyParam)
MyParam = 5
End Sub
Dim MyArg
MyArg = 123
TestSub MyArg
' MyArg is changed in TestSub to 5.
If the parameter is specified as ByRef, the argument can still be passed by value. This occurs if one of the following is true:
· The argument is in parentheses, and the parentheses do not apply to the argument list.
· The variable sent as an argument is in a class.
· The argument being passed is not a variable, for example, 12.
Argument in Parentheses
If the parameter is specified as ByRef, the argument can be passed by value if it is enclosed in parentheses. This is shown in the following example.
Sub TestSub(ByRef MyParam)
MyParam = 5
End Sub
Dim MyArg
MyArg = 123
TestSub (MyArg)
' MyArg is still 123.
A ByRef parameter is passed by value if the argument is enclosed in parentheses and the parentheses do not apply to the argument list.
The parentheses apply to the argument list if one of the following is true:
· The statement is a function call that has an assignment to the returned value.
· The statement uses the Call keyword. (The Call keyword can optionally be used for a subroutine call, or for a function call without an assignment.)
In the following example, the second call to TestFunction has an assignment to the returned value. For that call, the parentheses enclosing the argument list do not cause the ByRef parameter to be passed by value.
Function TestFunction(ByRef MyParam)
TestFunction = MyParam * 2
MyParam = 5
End Function
Dim MyArg, Result
MyArg = 123
TestFunction (MyArg)
' MyArg is still 123.
Result = TestFunction (MyArg)
' MyArg is changed in TestSub to 5.
In the following example, a Call keyword is used. The parentheses that enclose the argument list do not cause the ByRef parameter to be passed by value.
Sub TestSub(ByRef MyParam)
MyParam = 5
End Sub
Dim MyArg
MyArg = 123
Call TestSub ((MyArg))
' MyArg is still 123.
Call TestSub (MyArg)
' MyArg is changed in TestSub to 5.
In the following example, the function has two ByRef parameters. In the function call, one argument is passed by value and the other argument is passed by reference.
Function TestFunction(MyParam1, MyParam2)
' Both parameters are ByRef, because neither ByRef nor ByVal
' is specified for either parameter.
TestFunction = MyParam1 * MyParam2
MyParam1 = 5
MyParam2 = 6
End Function
Dim MyArg1, MyArg2, Result
MyArg1 = 123
MyArg2 = 124
Result = TestFunction ((MyArg1), MyArg2)
' MyArg1 is still 123.
' MyArg2 is changed in TestFunction to 6.
Argument in a Class
If the parameter is specified as ByRef, the argument is passed by value if the variable sent as an argument is in a class.
In the following example, the MyParam parameter is specified as ByRef. The method is called by using the cust.MyValue argument. Because cust.MyValue is inside a class, the argument is passed by value.
Class Customer
Public MyValue
End Class
Sub TestMethod (ByRef MyParam)
MyParam = 5
End Sub
Dim cust
Set cust = New Customer
cust.MyValue = 123
TestMethod cust.MyValue
' cust.MyValue is still 123.
*** Please refer software testing notebook for more details.***
