Should I use Call keyword in VB/VBA?
Solution 1
Ah ha. I have long wondered about this and even reading a two inch thick book on VBA basically says don't use it unless you want to use the Find feature of the VBE to easily find calls in large projects.
But I just found another use.
We know that it's possible to concatenate lines of code with the colon character, for example:
Function Test(mode as Boolean)
if mode = True then x = x + 1 : Exit Sub
y = y - 1
End Sub
But if you do this with procedure calls at the beginning of a line, the VBE assumes that you're referring to a label and removes any indents, aligning the line to the left margin (even though the procedure is called as intended):
Function Test()
Function1 : Function2
End Function
Using the Call statement allows concatenation of procedure calls while maintaining your code indents:
Function Test()
Call Function1 : Call Function2
End Function
If you don't use the Call statement in the above example, the VBE will assume that "Function1" is an label and left align it in the code window, even though it won't cause an error.
Solution 2
For VB6, if there is any chance it will be converted to VB.NET, using Call
means the syntax doesn't change. (Parentheses are required in VB.NET for method calls.) (I don't personally think this is worth the bother -- any .NET converter will at least be able to put in parentheses when required. I'm just listing it as a reason.)
Otherwise it is just syntactic sugar.
Note the Call
keyword is likely not to be faster when calling some other method/function because a function returns its value anyway, and VB didn't need to create a local variable to receive it, even when Call
is not used.
Solution 3
I always use Call
in VBA. To me, it just looks cleaner. But, I agree, it's just syntactic sugar, which puts it squarely the realm of personal preference. I've come across probably a dozen full time VBA guys in the past few years, and not one of them used Call
. This had the added advantage that I always knew which code was mine. :p
Solution 4
No, it'll just add 7 characters per call with no given benefit.
Solution 5
No one covered this important distinction: in some (common) situations, Call prevents parentheses around function (and sub) arguments from causing the arguments to be strictly interpreted as ByVal
.
The big takeaway for you is that if you DO use parentheses around arguments to a routine, perhaps by rote or habit, even though they are not required, then you SHOULD USE Call
to ensure that the routine's implicit or explicit ByRef
is not disregarded in favor of ByVal
; or, instead, you should use an "equal sign" assignment of the return value to prevent the disregard (in which case you would not use Call
).
Again, that is to protect you from unfavorably getting ByVal
from a routine. Conversely, of course, if you WANT ByVal
interpretation regardless of the routine's declaration, then LEAVE OFF the Call
(and use parentheses).
Rationale: summarizing "ByRef and ByVal Parameters"
If
1. there is an assignment of a function call retval, e. g.
iSum = myfunc(myArg)
or
2. "Call
" is used, e. g.
call myFunc(myArg)
or
call mySub(myArg)
then the parentheses strictly delineate the calling argument list; the routine declaration determines ByVal or ByRef. OTHERWISE the parentheses force ByVal to be used by the routine - even though ByVal was not specified in the routine. Thus,
mySub(myArg) 'uses ByVal regardless of the routine's declaration, whereas
Call mySub(myArg) 'uses ByRef, unless routine declares ByVal
Also note that Call syntactically mandates use of parentheses. You can go
mySub myArg
but you can't go
call mySub myArg
but you CAN go
call mySub(myArg)
(and parentheses are syntactically required for assignment of Function return value)
NOTE however that ByVal
on the routine declaration overrides all of this. And FYI, ByRef
is always implied in the declaration if you are silent; thus TMK ByRef
has no apparent value other than documentary.
Repeating from above: The big takeaway for you is that if you DO use parentheses around arguments to a routine, perhaps by rote or habit, even though they are not required, then you SHOULD USE Call
to ensure that the routine's implicit or explicit ByRef
is not disregarded in favor of ByVal
; or, instead, you should use an "equal sign" assignment of the return value to prevent the disregard (in which case you would not use Call
).
Again, that is to protect you from unfavorably getting ByVal
from a routine. Conversely, of course, if you WANT ByVal
interpretation regardless of the routine's declaration, then LEAVE OFF the Call
(and use parentheses).
Related videos on Youtube
Fred Loyant
Updated on January 21, 2020Comments
-
Fred Loyant over 4 years
I use the
Call
keyword when calling subs in VB/VBA. I know it's optional, but is it better to use it or leave it off? I've always thought it was more explicit, but maybe it's just noise.Also, I read this on another forum: Using the
Call
keyword is faster because it knows that it is not going to return any values, so it doesn't need to set up any stackspace to make room for the return value.-
yu_ominae over 11 yearsIn some cases using the call keyword is pretty useful, like when you just want to use a class once. I use it today to generate a random salt
Call New RNGCryptoServiceProvider().GetBytes(salt)
withoutCall
I would have had to a variable as anRNGCryptoServiceProvider
first -
Pillgram about 9 yearsThat is easily the best (if not the only) reason to use to use call that I have ever heard of.
-
Mathieu Guindon almost 5 years@Pillgram except
RNGCryptoServiceProvider
inheritsRandomNumberGenerator
, which implementsIDisposable
, so this "pretty useful" use ofCall
is actually allocating unmanaged resources, and leaves them dangling, sinceDispose
is never invoked. In some contexts, the consequences of this can be catastrophic. Bad, bad idea IMO. -
Mathieu Guindon almost 5 years@yu_ominae I meant to ping you on this one as well ^
-
yu_ominae almost 5 years@MathieuGuindon That's a very good point, thanks!
-
6diegodiego9 over 2 years@yu_ominae it doesn't work in VBA ("Syntax error")
-
-
Mathieu Guindon about 9 years+1 for a legitimage case... although I'd argue that having multiple instructions / function calls on a single line is a bad practice.
-
Patrick Wynne about 7 yearsYou can simply use
SupportTasks SomeArgument
and it compiles just fine without the use ofCall
. -
FCastro about 7 yearsThat's true. It just ignores the return value. Guess that renders my essay slightly off then, no?...
-
SlowLearner over 6 yearsFun! Part of me wants to try this out, the other part of me is scared of learning another bad habit :-)
-
Brandon Hood over 6 years@SlowLearner I suggest just keeping it in your hat as trivia. VB creates enough bad habits as it is :)
-
SlowLearner over 6 yearsYup. I'm actually using VBA and intriguing as it was (AFAICT) it just doesn't come close to working in VBA but was interesting to explore none the less. Cheers,
-
MicrosoftShouldBeKickedInNuts over 5 yearsHowever since you're not doing an "equal sign" assignment when you use Call, you can just omit the assignment anyway and get to the same place (that the retval is disregarded). Thus, "as such", Call is only valuable from a documentary standpoint. I.e., the following may behave functionally identically: 1. call myfunc(i) 2. myfunc(i) ( BUT see my top level reply to this thread below!! Depending on the function declaration, this may produce different ByVal or ByRef treatment of variable i !! So there's yet another meaningful value to Call vs. its omission)
-
Mathieu Guindon almost 5 yearsThis argumentation is slightly off. Parentheses don't magically turn
ByRef
intoByVal
. Parentheses force the evaluation of an expression, like they do in every single other expression context. So what happens is, the expression is evaluated, and its result is passed to the invoked procedure, which receives itByRef
as advertised - only, nothing on the caller's side is holding on to a reference to the value of the argument expression, so the net effect is similar to it being passedByVal
. I invite you to read this answer. -
Mathieu Guindon almost 5 yearsEvery single
MsgBox "foo"
instruction ever written is discarding the function's return value. I've yet to seeCall MsgBox("foo")
in code written by someone that claims to consistently useCall
. -
MicrosoftShouldBeKickedInNuts almost 5 yearsThat's an excellent dissection of the process. Nonetheless, from a mechanical perspective, from the user's perspective, if you add "unrequired" parentheses, the argument will be treated ByVal, even if you state "ByRef" on the function itself. And that is bizarrely unintuitive to those who don't know the intricacies you pointed out. What I said was "parentheses force ByVal to be used by the routine" - which is a true statement, even though as you point out, the parentheses instigate an intermediate process, and the upshot of that process is that a ByVal treatment ensues.
-
MicrosoftShouldBeKickedInNuts almost 5 yearsAs to the link you provided, it argues that Call does nothing (except facilitate certain single line multi-commands). I simply reject that as false, because myfunc(foo) and Call myfunc(foo) strictly produce two different results whenever MyFunc changes the foo argument (unless MyFunc says "ByVal").
-
Mathieu Guindon almost 5 yearsyou're missing the entire point.
myFunc(foo)
cannot exist, it'smyFunc (foo)
(that space matters!), and the correct syntax for an implicit call statement ismyFunc foo
, without the parentheses. You are usingCall
as a surrogate to proper understanding of the language's syntax. -
MicrosoftShouldBeKickedInNuts almost 5 yearsI'm only saying that if anyone uses superfluous parentheses - and millions of people do, whether we like it or not - then Call defends them against unexpected results. OBVIOUSLY you shouldn't use parentheses when they are not required. The fact is that people do so anyway, and in those cases Call does affect foo. Anyway, congratulations for pointing out the omitted space.
-
Mathieu Guindon almost 5 yearsThe VBE (nothing to do with Excel) turns
myFunc(foo)
intomyFunc (foo)
and will keep adding that space no matter how hard you try. You're talking about a different instruction,bar = myFunc(foo)
, where the parentheses delimit the argument list, whereas inmyFunc (foo)
they enclose an argument expression.