In VBScript, there are two ways values can be passed: ByVal and ByRef. Using ByVal, we can pass arguments as values whereas with the use of ByRef, we can pass arguments are references. This is the obvious bit, but, how do these 2 differ in practice?

Let’s find out!

Passing Parameters By Value
Consider the following code snippet:

Function GetValue( ByVal varVariable )
   varVariable = varVariable + 1
End Function
 
Dim x: x = 5
 
'Pass the variable x to the GetValue function ByVal
GetValue x
 
MsgBox "x = " & x

When you run the block of code above, you will get the following output:

Passing Parameter By Value

In other words, when we passed the variable ‘x’ (ByVal) to the function ‘GetValue’, we were simply passing a copy of the variable ‘x’. When GetValue executes, ‘varVariable’ stores a copy of the variable ‘x’ and increments itself by 1. Therefore, because what we are passing to GetValue is a copy of ‘x’, it cannot be modified.

Now, let’s look at another way of passing variables: By Reference.

Passing Parameters By Reference
Consider the following code snippet that takes arguments ByReference:

Function GetReference( ByRef varVariable )
   varVariable = varVariable + 1
End Function
 
Dim x: x = 5
 
'Pass the variable x to the GetReference function ByRef
GetReference x
 
MsgBox x

I think you must already be aware what’s going to happen when the above code is executed. Let’s see the snapshot:

Passing Parameter By Reference

Yes, variable ‘x’ was increment by 1. But why was ‘x’ incremented? Only ‘varVariable’ must have incremented by 1, and not ‘x’? Well, that is the core concept behind passing variables by reference.

When the function ‘getReference’ executes, ‘varVariable’ becomes a reference of ‘x’, and therefore, any changes made to ‘varVariable’ would impact ‘x’. So if varVariable increments itself by 1, so would x. If varVariable becomes 0 (zero), so would x.

Let’s see another example:

Function GetReference( ByRef arrArray )
   ReDim Preserve arrArray(UBound(arrArray)+1)
   arrArray(UBound(arrArray)) = 2
End Function
 
Dim newArray: newArray = Array(0, 1)
GetReference newArray

Will the size of ‘newArray’ increase? Let’s see:

' new size: 2
MsgBox UBound(newArray)
 
' new elements: 0, 1, 2
For x = LBound(newArray) To UBound(newArray)
   MsgBox newArray(x)
Next

Since ‘newArray’ was passed as a reference to the GetReference function, the change made to ‘arrArray’ was reflected upon ‘newArray’ as well. Thus, sizes of both arrays incremented by 1.

Is there a way to pass variables byRef and still avoid this? Yes, there is. The answer lies in passing temporary variables (see footnotes below).

ByRef & Temporary Variables
The advantage of using this approach is that you can pass temporary variables to n number of functions accepting arguments as reference, without having the base (original) variables modified. This is a good (and recommended) approach, since your original variables stay intact and you do not lose track of them when working with extensive function libraries. Please see a simple demonstration of this approach below:

Function GetReference( ByRef varVariable )
 varVariable = varVariable + 1
End Function
 
Dim x: x = 5
Dim y: y = x
GetReference y
 
MsgBox x   'Returns 5 (x remains unchanged)
MsgBox y   'Returns 6

Above, you will notice that as y became a temporary variable and was passed to GetReference, only it was modified. The variable x was unchanged. Thus, it’s recommended to use temporary variables when passing variables as reference.

Summary

• (ByVal) Arguments do not change when passed by value.
• (ByRef) If the function parameter is modified, it will have the same impact on the parameter that was passed by reference.
• (ByRef) Because the passed parameters can be changed, we can pass multiple values from functions.
• (ByRef) In a huge function library, it can be hard to tell where the value was changed and what function the variable was supposed to perform.

* Credits go to Christopher J. Schärer for pointing out the error in this statement.
** This section has been modified and updated. Previously, it was “Constants and ByReference”, which is a valid technique, but as Christopher J. Schärer pointed out, a better approach is to pass temporary variables as ByRef arguments.

If you have any questions, please ask them in the comments section. If your query is confidential, please use the Contact Form to send me an e-mail instead.

Tagged as: ByRef, ByVal, ByVal ByRef, Functions, QTP, QTP ByVal ByRef, VBScript, VBScript ByVal ByRef