Excel vba sub return

VBA Return Statement

In this article, we will see an outline on Excel VBA Return. It is a statement in VBA which is used for the user-defined functions with the GoSub statement. This statement can also be used outside of a subprocedure when we are using a user-defined function. And when we are using the GoSub statement with the return statement then both GoSub and return statements should be in the same procedure. Now let us discuss what the difference between these two procedures is. First, we will begin with the GoSub statement. In this statement, we stay in the same procedure but move to another statement and get a result with some lines execution of code and then return to the original procedure.

The next is the use of the return statement in a user-defined function. In the user-defined function, a function is created which is returns a value through return statement. We will discuss both types of use of the return statement through some examples.

How to Use Go Sub Return Statement in VBA?

We will learn how to use Go Sub Return Statement in Excel by using the VBA Code.

You can download this VBA Return Excel Template here – VBA Return Excel Template

Example #1 – VBA Return Statement

Let us first discuss how Return with GoSub Statement works in VBA. How do we execute them and what we will learn in this example?. For this, follow the below steps:

Step 1: Insert a new module inside Visual Basic Editor (VBE). Click on Insert tab > select Module.

Step 2: Once we have a module in the Editor now let us begin with the procedure of declaring a sub-function.

Code:

Sub Example1()

End Sub

Step 3: Now let us send the execution to another line by the GoSub Statement but within the same procedure.

Code:

Sub Example1()

GoSub Sample

End Sub

Step 4: Now let us exit the subprocedure, for now, let us keep this in mind exit sub and end sub are two different.

Code:

Sub Example1()

GoSub Sample
Exit Sub

End Sub

Step 5: Now we can perform some execution of lines of code for the subroutine.

Code:

Sub Example1()

GoSub Sample
Exit Sub
Sample:
MsgBox "This is a sample document"

End Sub

Step 6: Now we will use the return statement to move back to the original procedure.

Code:

Sub Example1()

GoSub Sample
Exit Sub
Sample:
MsgBox "This is a sample document"
Return

End Sub

Step 7: When we press F8 we can see how this procedure works step by step.

Now we can see in the steps that process moved to the line of Sample subroutine when the compiler was on the Gosub Statement and it again moved back to exit sub after giving us the result to Exit substatement.

Example #2 – VBA Return Statement

In the above example, we use a single subroutine and what happens if there are multiple subroutines with multiple GoSub and multiple Return statements. Let us find out in example 2. For this, follow the below steps:

Step 1: We will proceed with the same module just with another subprocedure.

Code:

Sub Example2()

End Sub

Step 2: Similar to above let us declare multiple subroutines with the GoSub statement.

Code:

Sub Example2()

GoSub Sample1
GoSub Sample2

End Sub

Step 3: Now let us exit the sub and define what those subroutines will do.

Code:

Sub Example2()

GoSub Sample1
GoSub Sample2
Exit Sub
Sample1:
MsgBox "This is first Execution"
Return
Sample2:
MsgBox "This is second Execution"
Return

End Sub

Step 4: Run this code by hitting F5 or Run button.

In this example, Code worked in the same way, the compiler went to GoSub Sample1 and executed the lines of code for sample1 then it returned it to GoSub Sample2 and then again went to execute the lines of code for sample2 and then the return statement took it back to the exit substatement.

Example #3 – VBA Return Statement

Let us use a somewhat realistic example for the GoSub statement such as for addition. For this, follow the below steps:

Step 1: Declare a subprocedure for example 3.

Code:

Sub Example3()

End Sub

Step 2: Define two integer variables and ask the user to provide input as integers.

Code:

Sub Example3()

Dim i As Integer, b As Integer
i = InputBox("Enter first number")
b = InputBox("Enter second number")

End Sub

Step 3: Now let us use the GoSub statement and perform the addition operation as follows.

Code:

Sub Example3()

Dim i As Integer, b As Integer
i = InputBox("Enter first number")
b = InputBox("Enter second number")
GoSub Addition
MsgBox "Execution Complete"
Exit Sub
Addition:
MsgBox i + b

End Sub

Step 4: Now we can use the return statement to go back and inform that execution is complete.

Code:

Sub Example3()

Dim i As Integer, b As Integer
i = InputBox("Enter first number")
b = InputBox("Enter second number")
GoSub Addition
MsgBox "Execution Complete"
Exit Sub
Addition:
MsgBox i + b
Return

End Sub

Step 5: Run this code by hitting F5 or Run button placed at the uppermost ribbon of Visual Basic Editor.

Example #4 – VBA Return Statement

For this example look at the below example of code as follows.

Code:

Sub Example4()
Dim i As Integer, k As Integer, area1 As Integer
i = 2
k = 3
area1 = area(i, k)
MsgBox area1
End Sub
Public Function area(x As Integer, y As Integer) As Integer
area = x * y
End Function

In this code, there is no return statement used but it still returns the function with a value.

Explanation of VBA Return

• We have seen why we use the return statement,  in both of the cases with the use of GoSub statement and User-defined functions. However, there is a slight difference. In the GoSub function, we used a Return statement so that the compiler can return to the next code after the subroutine, and in user-defined functions return statement returned the value to be generated by the function.
• We have seen two different methods of using the Return statement through the examples above.

Method 1: The first method is the use of GoSub statement with the return statement.

Method 2: The second method is to use return values in a user-defined function.

Things to Remember

There are few things that we need to remember about the Return statement in VBA and they are as follows:

• The return statement is placed where the execution of codes for the procedures is completed.
• For the GoSub statement, the GoSub and return statement should be in the same procedure.
• For User-defined functions, the values are returned using the function name.
• There can be more than one return statement in the same procedure.

Recommended Articles

This is a guide to the VBA Return. Here we discuss how to Use Go Sub Return Statement in Excel VBA along with practical examples and a downloadable excel template. You can also go through our other suggested articles –

1. VBA SendKeys (Examples with Excel Template)
2. How to Change Name Worksheet in Excel VBA?
3. VBA On Error Goto (Examples)
4. VBA Input | Excel Templates

As You may know, in general in programming to return a result from function there is Return statement. Even Visual Basic has it. Unfortunately there is no such thing in VBA. In this article I’m going to show You how to return a result from VBA function.

Let’s start with function

For the purpose of this article I’ve created functionModulo, which is very similar to the Mod function.

Function functionModulo(x As Integer, y As Integer) As Boolean

Dim divisionRest As Double, divisionRestStatus As Integer
Let divisionRest = x / y - Fix(x / y)

If divisionRest > 0 Then
    divisionRestStatus = 0
Else
    divisionRestStatus = 1
End If

If divisionRestStatus = 1 Then
    functionModulo = True
Else
    functionModulo = False
End If

End Function

This function allows You to check if there is a divisibility between two numbers. If there is a rest from division the function returns False, if there is no any – function returns True.

So to describe the work of this function, I was using return word. But not as a statement in code. To return the result in VBA function You need to use the function name itself and put it a value.

functionModulo = True

Unfortunately the function not stops there and exits. It just go further.

As close as possible

I decided to modify this function to make it as similar to Return statement schema as possible.

So first of all I cut it a little bit.

Function functionModulo(x As Integer, y As Integer) As Boolean

Dim divisionRest As Double
Let divisionRest = x / y - Fix(x / y)

If divisionRest > 0 Then
    functionModulo = False
Else
    functionModulo = True
End If

End Function

Then I wanted to have the same effect after returning the result from function as Return statement brings.

Function functionModulo(x As Integer, y As Integer) As Boolean

Dim divisionRest As Double
Let divisionRest = x / y - Fix(x / y)

If divisionRest > 0 Then functionModulo = False: Exit Function
If divisionRest = 0 Then functionModulo = True

End Function

That’s why after returning the value I added Exit Function.

If divisionRest > 0 Then functionModulo = False: Exit Function

I was almost done, but also figured out that we can only check for valid values. This means that I could set False value at the beginning as default. One conditional less in code. Cleaner the code.

Function functionModulo(x As Integer, y As Integer) As Boolean

functionModulo = False

Dim divisionRest As Double: Let divisionRest = x / y - Fix(x / y)

If divisionRest = 0 Then functionModulo = True

End Function

Having nothing after the conditional for True value I decided to erase Exit Function statement. In this case it is not needed, but in general it is really good approach to simulate Return statement as from other programming languages.

To sum up

To avoid unnecessary conditionals put the default value at the beginning of the function. You can also do that in the end of the code, only if You simulate the Return statement in VBA – pass the result in the function name and Exit Function just right after that line.

Excel VBA Function Tutorial: Return, Call, Examples

Updated January 20, 2023

What is a Function?

A function is a piece of code that performs a specific task and returns a result. Functions are mostly used to carry out repetitive tasks such as formatting data for output, performing calculations, etc.

Suppose you are developing a program that calculates interest on a loan. You can create a function that accepts the loan amount and the payback period. The function can then use the loan amount and payback period to calculate the interest and return the value.

Why use functions

The advantages of using functions are the same as the ones in the above section on why use subroutines.

Rules of naming functions

The rules for naming functions as the same as the ones in the above section on rules for naming subroutines.

VBA Syntax for declaring Function

HERE in the syntax,

Code	Action
“Private Function myFunction(…)”	Here the keyword “Function” is used to declare a function named “myFunction” and start the body of the function. The keyword ‘Private’ is used to specify the scope of the function
“ByVal arg1 As Integer, ByVal arg2 As Integer”	It declares two parameters of integer data type named ‘arg1’ and ‘arg2.’
myFunction = arg1 + arg2	evaluates the expression arg1 + arg2 and assigns the result to the name of the function.
“End Function”	“End Sub” is used to end the body of the function

Function demonstrated with Example:

Functions are very similar to the subroutine. The major difference between a subroutine and a function is that the function returns a value when it is called. While a subroutine does not return a value, when it is called. Let’s say you want to add two numbers. You can create a function that accepts two numbers and returns the sum of the numbers.

1. Create the user interface
2. Add the function
3. Write code for the command button
4. Test the code

Step 1) User interface

Add a command button to the worksheet as shown below

Set the following properties of CommanButton1 to the following.

S/N	Control	Property	Value
1	CommandButton1	Name	btnAddNumbers
2	Caption	Add Numbers Function

Step 2) Function code.

1. Press Alt + F11 to open the code window
2. Add the following code

HERE in the code,

Code	Action
“Private Function addNumbers(…)”	It declares a private function “addNumbers” that accepts two integer parameters.
“ByVal firstNumber As Integer, ByVal secondNumber As Integer”	It declares two parameter variables firstNumber and secondNumber
“addNumbers = firstNumber + secondNumber”	It adds the firstNumber and secondNumber values and assigns the sum to addNumbers.

Step 3) Write Code that calls the function

1. Right click on btnAddNumbers_Click command button
2. Select View Code
3. Add the following code

HERE in the code,

Code	Action
“MsgBox addNumbers(2,3)”	It calls the function addNumbers and passes in 2 and 3 as the parameters. The function returns the sum of the two numbers five (5)

Step 4) Run the program, you will get the following results

Источник

Writing and Using Functions in Excel Visual Basic

Most programs you write will begin with the word Sub — but not all:

When you choose Insert —> Procedure. from the VBA code editor menu, you can insert a Sub or a Function (the word Property is discussed in a later blog on classes).

There are two reasons that you might create a function:

• To help make code easier to write, read and maintain; or
• To supplement the list of built-in Excel functions.

This blog will show how to do each of these in turn, but first let’s look at the syntax of a function.

How to Write Functions in VBA

The difference between a subroutine and a function in VBA is that a function returns a value. Consider the following very simple function to square a number:

Function Square(AnyNumber As Integer) As Long

‘return the square of any integer

Square = AnyNumber * AnyNumber

There are 3 differences between this and a normal subroutine:

The numbered differences are explained below.

The differences are:

1. A function begins with Function and ends with End Function (rather than Sub and End Sub).
2. A function has a data type (this one is of type Long, since we don’t know how big an integer we’ll have to return).
3. Within a function, you have to set the name of the function equal to something (here, the square of the number contained in the argument).

VB, C# and many other programmers should note that — irritatingly — there is no RETURN statement to return the value of a function in VBA.

You can call functions from Excel (shown in more detail in the final part of this blog), from another subroutine or from the Immediate window. Examples of each follow!

Calling Functions from Another Subroutine

One way to call a function is from another program, or procedure:

The program above (stripped of any error-checking) might read:

Dim n As Integer

‘get the number user wants to square

n = CInt(InputBox(«Type in a number»))

‘show this square

MsgBox «The square of » & n & » is » & _

As you see, you can use Square just as if it were a built-in function in VBA.

Displaying the Value of a Function in the Immediate Window

You can do this in the usual way:

Here we’ve called our Square function 3 times, with a different argument each time.

Again, you can treat your function as if it were one of the built-in ones in VBA.

Calling a Function from Excel

One other way to call a function — and perhaps the sexiest — is to type it into Excel:

The formula for the cell shown above might look like this:

The function takes a single argument, which must be an integer. Here it is the value of cell C2.

One slight annoyance is that when you type the start of a function — in the case above, =Square( — Excel doesn’t suggest possible arguments for it. You can get round this by using the function wizard, as shown in the final part of this blog.

Now that we’ve seen what a function is and how to run one, let’s look at how you might incorporate them into Excel.

Источник

Excel VBA Tutorial – #10 Using built-in Excel functions

Last updated on February 1, 2019 By Victor Chan

Summary: Wouldn’t it be great to run your favorite Excel functions with macros? Like SUM, COUNTIF, VLOOKUP and SUMIF…

In this tutorial, I’ll walk you through code that will allow you to do just that. After we’re finished, you’ll have flexibility you could never achieve with formulas alone!

Difficulty: Intermediate

Download the Sample Workbook

Download the sample file with VBA code

#1 – The most often used Excel functions

If we’re honest, we use only a handful of Excel functions daily. But these functions form the foundation for an Excel power-user.

SUM, SUMIF, VLOOKUP, and COUNTIF are a few of my go-to functions. Without these functions, my office life would be much more difficult. These functions are fast, reliable, and most of my tasks can be completed using only them.

When we use such functions in worksheets, they all require us to input ranges of cells where they will read or write data. More robust functions require even more complex criteria to work properly.

You may wonder why I even mention the inputs required to use basic Excel functions. Since the functions won’t work without the right inputs, when using functions in macros we’ll need to provide the inputs via VBA code.

Also, in our code we’ll need to declare a range type variable to represent each input range. We’ll also need to declare a variable to represent every other required input value for the function(s) we’re using.

Now that we’ve reviewed the basics, let’s start coding!

Variables needed

Considering all the information the functions need, here’s how we’ll declare the necessary variables:

#2 – SUM

I’ll start with the SUM function, as it’s the simplest of the ones we’re going to discuss.

I copied the payroll calculating macro from the previous tutorial. We can use its table to experiment with these Excel functions. As you can see, MaxSalary is 1200, and StateTax is set to 0.2.

Let’s say we want to SUM the salary in column “B”. We will store the result in the “ResultValue” variable.

This is how the code should look:

The third line displays the result in a Msgbox. We could also write the result in a cell – it’s your responsibility, as the programmer, to display the result in the best location.

If you want to put your knowledge to the test, feel free to modify the code as follows:

Find the last row in column “B” Modify the macro to write the result of the SUM function in the cell below the last row in column “B”

I’m confident you can make these changes with the help of the previous tutorials! Use the power of your knowledge to customize the code the way you want!

#3 – COUNTIF

Using COUNTIF is a bit more complicated, but it’s nothing we can’t solve with VBA!

We’ll use our previously declared variable “rng” for the range. The variable “ResultValue” will again store the result.

This sub will count the occurrences of the number “960” in the dataset. We set “rng” first because the function needs it as input.

We hard-code the searched value (960) in the code. We could’ve used our variable “criteria” instead, but I think it’s more straightforward to show you the code with the hard-coded value.

If you’re performing a COUNTIF on a range of cells formatted as text, you can also add wildcard characters to allow you to count instances of a subset of characters. For example, if you want to count the number of names in column “A” that include the letter “o”, you must put “*” before and after the variable (“search”) that represents the letter “o” in the code.

The code below does just this. As you can see, the code captures the subset of characters for which it’s searching via an InputBox, and it saves that search criteria in the “search” variable.

Источник

Excel VBA Tutorial Part 4 — VBA Function & Sub Procedures

Before you consider creating your own VBA Functions, it is useful to know that there are a large number of built-in VBA functions that you can use in your code.

For a list of the main built-in VBA functions, with examples, see the VBA Functions page.

User-Defined VBA Function & Sub Procedures

In Excel Visual Basic, a set of commands to perform a specific task is placed into a procedure, which can be a Function procedure or a Sub procedure (also known as functions and subroutines).

The main difference between a VBA Function procedure and a Sub procedure is that a Function procedure returns a result, whereas a Sub procedure does not.

Therefore, if you wish to perform a task that returns a result (e.g. summing of a group of numbers), you will generally use a Function procedure, but if you just need a set of actions to be carried out (e.g. formatting a set of cells), you might choose to use a Sub procedure.

Arguments

VBA procedures can be passed data via arguments, which are declared in the procedure definition. For example, you could have a VBA Sub procedure that adds an Integer to every cell in the current selected range on a worksheet. You could supply the value of the integer to the Sub via an argument, as follows:

Sub AddToCells(i As Integer )
.
.
.
End Sub

Note that it is not essential for VBA Functions or Subs to have arguments. Some procedures may not require them.

Optional Arguments

You can also define VBA procedures to have Optional arguments. These are arguments that the user can supply if they want, but if they are omitted, the procedure will assign a default value to them.

To return to the example above, if we wanted to make the supplied integer argument optional, this would be declared as follows:

In this case, the supplied integer, i, has a default value of 0.

You can use multiple Optional arguments in a VBA procedure, as long the Optional arguments are all positioned at the end of the argument list.

Passing Arguments By Value and By Reference

When arguments are passed to VBA procedures, they can be passed in two ways:

• ByVal — The argument is passed by Value. This means that just the value (i.e. a copy of the argument) is passed to the procedure and therefore, any changes that are made to the argument inside the procedure will be lost when the procedure is exited.
• ByRef — The argument is passed by Reference. This means that the address of the argument is passed to the procedure. Any changes that are made to the argument inside the procedure will be remembered when the procedure is exited.

You can specify whether an argument is passed to a VBA procedure by value or by reference by using the ByVal or the ByRef keyword when defining the procedure. This is shown below:

Sub AddToCells( ByVal i As Integer ) . . . End Sub	In this case, the integer i is passed by Value. Any changes that are made to i will be lost when you exit the Sub procedure.
Sub AddToCells( ByRef i As Integer ) . . . End Sub	In this case, the integer i is passed by Reference. When you exit the Sub, any changes that have been made to i will be remembered by the variable that was passed into the Sub procedure.

It should be noted that, by default, VBA arguments are passed by Reference. Therefore, if you do not use the ByVal or the ByRef keyword, the arguments will be passed by Reference.

Before discussing further properties of VBA Function and Sub procedures, it is useful to look at the two types of procedure individually. The following two sections provide a brief discussion of VBA Function and VBA Sub procedures, along with simple examples.

VBA Function Procedures

The VBA editor recognises a Function procedure, because the commands are positioned between the following start and end commands: