by Matthew Roberts (26 Submissions)
Category: Coding Standards
Compatability: Visual Basic 3.0
Difficulty: Beginner
Date Added: Wed 3rd February 2021
Rating: 
(4 Votes)
Explains the concepts of Subs, Functions, and Parameters. If you are a little fuzzy on the difference, take a look.
VBcoders
xmlns="http://www.w3.org/TR/REC-html40">
Sometimes we miss the obvious
Using Subs and Functions in VB
Sometimes we miss the obvious. I know there are a lot of
things I was doing in Visual Basic that I thought were not only right, but
extremely clever. What I eventually discovered was that the reason I was having
to dream up such clever “work abounds” was that I was basing my code on
incorrect assumptions about how VB works.
One area that I had trouble with, as have several people I
have taught coding to is parameters and return values. This article is in the
Beginner category, but I didn’t learn
some of this stuff until long after I was working as a VB programmer and
considered myself a “professional”. If there is one thing I have learned about
programming, it is that you NEVER know everything, and there is always another
way to do something. My goal is to show programmers the correct way to use
these features before they go off and invent ways that will cause problems
later. Nothing is worse than realizing that you have been doing something the
wrong way for the last three years.
Is this tutorial for you? Let’s find out. Consider the
following questions:
·
Can you explain the difference between a Sub and a
Function in one sentence?
·
Can you explain the difference between a PUBLIC Sub and
a PRIVATE sub?
·
Do you know how to get a return value from a procedure without
using global variables?
If you answered “Yes” to all of
the questions above, you probably don’t need this tutorial. But before you
close it out, you should be sure you really understand how to do these
things. Why? Because these skills are fundamental to good coding. You simply
cannot write good complex code without them.
If the questions above left you
scratching your head in confusion, hang in there. You are not alone. If you read
this entire tutorial, I promise they will be answered in a way that you can
understand them (or your money back!)
To understand what a sub or
function is and why we need them, we should go back a few years. For the
moment, we will concentrate on Subs, since they are easier to understand. I
will then show you how Functions extend the capability of Subs.
If there are any old line
programmers out there, you may remember what we now call “spaghetti code”. Of course,
when we were writing it, we didn’t call it that. We called it sheer genius. The
term “spaghetti code” refers to the logic path of an application written in a
language such as BASIC or BASICA. In these languages, each line had a line
number, and you controlled program flow by referring to the associated line
number of the command you wanted to execute. (Boy, I am suddenly feeling old
here!)
For example:
10 CLS
20 LN$=INPUT$ “What is your last
name?:”
30 FN$=INPUT$ “What is your first
name?
40 IF LN$=”” Then
50 IF FN$=”” THEN
60 PRINT “You entered “ + LN$ + “
“ + FN$
70 END
This is a complete (albeit simple)
program for BASIC. It prompts for a last name and a first name, then forces you
to re-enter it if you didn’t enter a value for one or the other.
GOTO statement. You may have seen this command used in VB in error handling,
and if you have been around any VB programmers very long, you have heard them
harp on how evil the GOTO command is.
In BASIC, GOTO redirected program
flow to a specific line number. Otherwise, programs started at line 0 (or 10 in
most cases) and executed sequentially until they met an END statement, which
terminated the program. The problem with this concept was that once you got
about 2000 lines of code, it became difficult to track where the program would
jump to in any situation. For example, the statement GOTO 20150 meant that to
track execution, you had to scroll all the way down to line 20150. Of course,
it may contain an IF THEN statement that sent it back to line number 1220. It
isn’t hard to imagine why this type of code earned its nickname. Eventually it
reached “critical mass” and became unmanageable.
Most BASIC programmers eventually
discovered the GOSUB statement. This was a pretty big leap in program control.
Like GOTO, it redirected program execution to a line number somewhere in the
thousands of lines of code, but unlike GOTO, GOSUB knew where it was redirected
from and could return to that point in the program when it completed its
task. It told BASIC “GOTO A BLOCK OF SUB-CODE”. Here is how it was used:
10 CLS
20 X$=INPUT$ “Choose a Menu Item”
30 IF X$=”A” THEN
40 IF X$=”B” THEN
50 IF X$=”C” THEN END
60 ’
2000 CLS
2010 …..DO STUFF….
…
2520
3000 CLS
3010 …..DO STUFF….
…
3520
In this example, we not only use
the GOSUB keyword, but we also use
the RETURN keyword. What this told
BASIC was “Go back to the last GOSUB statement that you executed. “ To
programmers, this was pure gold. It allowed recursion (calling a piece of code
within the same piece of code) and much better program flow control. In
essence, this is the origin of the Visual Basic “Sub” procedure.
OK…enough nostalgia for now. Back
to VB. What this history lesson has shown you is that things could be much
worse. But with Visual Basic, some obvious improvements have been made. Line
numbers have been dropped (a tough concept for us old timers…QuickBasic helped
ease us into this concept). This allowed the programmer to name blocks of code
with a name instead of a number. Now instead of GOSUB 2000, we can say “Call
GetCustomerID” to call a piece of code that will find a customer ID for us.
First, you need to know what your
sub will be doing. There are some basic criteria to determine whether or not
you need to place code into a sub. They are:
Is this code used in more than one place (are you writing
duplicate code in your application)?
Does this code perform a specialized function independent of
the rest of the code?
Can you effectively create this as a “stand-alone” piece of
code?
Of the three criteria above,
number three is the toughest. For example, if you have a piece of code to find
state that a customer is located in based on their zip code, do you write that
same piece of code for every customer? Obviously, that would be impractical if
not impossible. What you need is a way to find the state any zip code.
Here is the way most beginners handle this problem:
First, create public variables to
hold the values we will be working with:
Public
ZIP As String
Public
State As String
Public
Sub GetState()
Then
End Sub
This code works. Using this
method, you can get the state of any of the zip codes contained in the GetState
sub. But there are problems with this code as well. The main one is that you
are now relying on public variables. This is because you have to be able to
access the values in from your form or calling code
consider that you may need to use the name “state” for a variable many times in
an application. You are then forced to create MANY public variables with odd
names like GetStateFromZip_State and GetStateFromZip_Zip to insure that you
don’t accidentally overwrite your values from other places in your program.
This is just a really bad way to code. The solution?
In order to get your values safely
to your Sub without having to create public variables, you can instead create
Sub Parameters. These are really just variables that only your calling code and
your sub can see. They look like this:
If ZIP > 32501 AND ZIP
<34205 Then
ElseIf ZIP >45102 AND ZIP < 53210 Then
……
End If
Now this code does the exact same thing, but without
having to rely on the public variable ZIP. You can also pass multiple
parameters:
Integer, Number2 As Integer, Number3 As Integer)
…
All three of these values will be
available from within your sub, but will not exist outside of it. Getting
pretty neat, isn’t it?
But we still have a problem. We passed the variable
IN , but how do we get a value back OUT of a sub? I mean, it’s nice that we
averaged these numbers, but we still have to use a public variable to get the
return value, right? Wrong.
There are three ways to get return
values from a piece of code:
Public Variables (ugly!)
By making a “return value” parameter.
By making your sub into a function.
We have already established that public variables
are not the answer we are seeking, so lets examine option #2. This is more of a
“hack” than a feature of VB. It takes advantage of the fact that both the
calling code and the sub code have access to parameter values. You could do
this to get a return value:
Integer, Number2 As Integer, Number3 As Integer, ReturnValue As Integer)
ReturnValue = (Number1 + Number2 + Number3) /3
Again, this would
work. But it creates problems on the calling side now. In order to use it, you
have to use code similar to this:
Call
AverageNumbers(10, 20, 50,0)
Msgbox “Average =
“ & ReturnValue
It is technically returning a value, but it looks (and is) rather
clunky. You have to pass in a “0” for the return value or you will get an
error. Then, to make matters worse, you
have to then refer to that variable when the sub completes. What would be nice
is if you could use it just like a VB command.
Consider the Ucase() command in Visual Basic. It is
straightforward:
MsgBox Ucase(“this is
a test”)
Results is a
message box being displayed with the words “THIS IS A TEST” in it.
So how does Microsoft do that? How do they get a return
value from the Ucase command? Surely it is some secret code that you don’t have
the power to duplicate. Wrong! The
way they do it is by making the command Ucase() into a
A function can return
a value through its name variable.
What does that mean “through its name variable”?
Let’s look at a function declaration:
Integer, Number3 As Integer)
You should notice two things different about this
declaration compared to the sub declaration:
·
It has no return parameter.
·
It has “As Integer” stuck on the end. What is
So how in the world does the value of Ucase() (or
AverageNumbers for that matter), find its way back to the calling code “MsgBox
Well, that is the difference between Subs and
Functions. Functions act as a return value
AverageNumber function exactly as you would the Ucase() function:
Here is the complete
function:
Integer, Number3 As Integer) As Integer
AverageNumbers = (Number1 + Number2 + Number3) /3
Notice that the line:
ReturnValue = (Number1 + Number2 + Number3) /3
has now been
modified to read:
AverageNumbers = (Number1 + Number2 + Number3) /3
This is where the “magic” happens. VB performs the
calculations, and when it gets the results, it pipes it back into the
AverageNumbers variable which was created when this function was
declared. From there, it can be assigned back to a variable in the calling
code. So to see the whole picture:
MsgBox “Average =” &
AverageNumbers(10,20,50)
Integer, Number3 As Integer) As Integer
AverageNumbers = (Number1 + Number2 + Number3) /3