User defined functions for excel

Excel allows you to create custom functions using VBA, called «User Defined Functions» (UDFs) that can be used the same way you would use SUM() or other built-in Excel functions. They can be especially useful for advanced mathematics or special text manipulation or date calculations prior to 1900. Many Excel add-ins provide large collections of specialized functions.

This article will help you get started creating user defined functions with a few useful examples.

NOTE: The new LAMBDA Function, available within «Production: Current Channel builds of Excel» is going to revolutionize how custom functions can be used in Excel without VBA.

Watch the Video

How to Create a Custom User Defined Function

1. Open a new Excel workbook.
2. Get into VBA (Press Alt+F11)
3. Insert a new module (Insert > Module)
4. Copy and Paste the Excel user defined function examples
5. Get out of VBA (Press Alt+Q)
6. Use the functions — They will appear in the Paste Function dialog box (Shift+F3) under the «User Defined» category

If you want to use a UDF in more than one workbook, you can save your functions to your personal.xlsb workbook or save them in your own custom add-in. To create an add-in, save your excel file that contains your VBA functions as an add-in file (.xla for Excel 2003 or .xlam for Excel 2007+). Then load the add-in (Tools > Add-Ins… for Excel 2003 or Developer > Excel Add-Ins for Excel 2010+).

Warning! Be careful about using custom functions in spreadsheets that you need to share with others. If they don’t have your add-in, the functions will not work when they use the spreadsheet.

Benefits of User Defined Excel Functions

• Create a complex or custom math function.
• Simplify formulas that would otherwise be extremely long «mega formulas».
• Diagnostics such as checking cell formats.
• Custom text manipulation.
• Advanced array formulas and matrix functions.
• Date calculations prior to 1900 using the built-in VBA date functions.

Limitations of UDF’s

• Cannot «record» an Excel UDF like you can an Excel macro.
• More limited than regular VBA macros. UDF’s cannot alter the structure or format of a worksheet or cell.
• If you call another function or macro from a UDF, the other macro is under the same limitations as the UDF.
• Cannot place a value in a cell other than the cell (or range) containing the formula. In other words, UDF’s are meant to be used as «formulas», not necessarily «macros».
• Excel user defined functions in VBA are usually much slower than functions compiled in C++ or FORTRAN.
• Often difficult to track errors.
• If you create an add-in containing your UDF’s, you may forget that you have used a custom function, making the file less sharable.
• Adding user defined functions to your workbook will trigger the «macro» flag (a security issue: Tools > Macros > Security…).

User Defined Function Examples

To see the following examples in action, download the file below. This file contains the VBA custom functions, so after opening it you will need to enable macros.

Download the Example File (CustomFunctions.xlsm)

Example #1: Get the Address of a Hyperlink

The following example can be useful when extracting hyperlinks from tables of links that have been copied into Excel, when doing post-processing on Excel web queries, or getting the email address from a list of «mailto:» hyperlinks.

This function is also an example of how to use an optional Excel UDF argument. The syntax for this custom Excel function is:

=LinkAddress(cell,[default_value])

To see an example of how to work with optional arguments, look up the IsMissing command in Excel’s VBA help files (F1).

Function LinkAddress(cell As range, _ 
                     Optional default_value As Variant) 
  'Lists the Hyperlink Address for a Given Cell 
  'If cell does not contain a hyperlink, return default_value 
  If (cell.range("A1").Hyperlinks.Count <> 1) Then 
      LinkAddress = default_value 
  Else 
      LinkAddress = cell.range("A1").Hyperlinks(1).Address 
  End If 
End Function

Example #2: Extract the Nth Element From a String

This example shows how to take advantage of some functions available in VBA to do some slick text manipulation. What if you had a bunch of telephone numbers in the following format: 1-800-999-9999 and you wanted to pull out just the 3-digit prefix?

This UDF takes as arguments the text string, the number of the element you want to grab (n), and the delimiter as a string (eg. «-«). The syntax for this example user defined function in Excel is:

=GetElement(text,n,delimiter)

Example: If B3 contains «1-800-333-4444″, and cell C3 contains the formula, =GetElement(B3,3,»-«), C3 will then equal «333». To turn the «333» into a number, you would use =VALUE(GetElement(B3,3,»-«)).

Function GetElement(text As Variant, n As Integer, _ 
                    delimiter As String) As String 
    GetElement = Split(text, delimiter)(n - 1)
End Function

Example #3: Return the name of a month

The following function is based on the built-in visual basic MonthName() function and returns the full name of the month given the month number. If the second argument is TRUE, it will return the abbreviation.

=VBA_MonthName(month,boolean_abbreviate)

Example: =VBA_MonthName(3) will return «March» and =VBA_MonthName(3,TRUE) will return «Mar.»

Function VBA_MonthName(themonth As Long, _
   		Optional abbreviate As Boolean) As Variant 
    VBA_MonthName = MonthName(themonth, abbreviate)
End Function

Example #4: Calculate Age for Years Prior to 1900

The Excel function DATEDIF(start_date,end_date,»y») is a very simple way to calculate the age of a person if the dates are after 1/1/1900. The VBA date functions like Year(), Month(), Day(), DateSerial(), DateValue() are able to handle all the Gregorian dates, so custom functions based on the VBA functions can allow you to work with dates prior to 1900. The function below is designed to work like DATEDIF(start_date,end_date,»y») as long as end_date >= start_date.

=AgeInYears(start_date,end_date)

Example: =AgeInYears(«10-Oct-1850″,»5-Jan-1910») returns the value 59.

Function AgeInYears(start_date As Variant, end_date As Variant) As Variant 
    AgeInYears = Year(end_date) - Year(start_date) - _
    Abs(DateSerial(Year(end_date), Month(start_date), _
    Day(start_date)) > DateValue(end_date))
End Function

More Custom Excel Function Examples

Probably one of the coolest benefits of learning VBA is the ability to create your own functions.

In Excel, there are more than 450 functions, and some of them are highly useful in your daily work. But Excel gives you the ability to create a custom function using VBA. Yes, you get it right. USER‌ DEFINED Function, in short UDF, or you can also call it a Custom VBA function.

And there’s one thing that I can say with confidence every aspiring VBA user wants to learn to create a User Defined Function. Don’t you? Say “Yes” in the comment section, if you are one of those people who want to create a custom function.

I’m excited to tell you that this is a COMPLETE GUIDE to help you to create your first custom function using VBA and apart from this I have shared some examples of USER-DEFINED Functions to help you to get inspired.

1. Here I’ll be using the words User Defined Function, custom function, and UDF interchangeably. So stay with me you are going to be a VBA rock star in the next couple of minutes.
2. To create a code for the VBA custom function you need to write it, you can’t record it using the macro recorder.

Why You Should Create a Custom Excel Function

As I said, there are a lot of in-built functions in Excel which can help you to solve almost all the problems and do all kinds of calculations. But, sometimes, in specific situations, you need to create a UDF.

And, below I have listed some of the reasons or situations in which you need to go with a custom function.

1. When there is no Function for this

This is one of the common reasons for creating a UDF with VBA, because sometimes that you need to calculate something and there is no specific function for this. I can give you an example of counting words from a cell and for this, I found a UDF can be a perfect solution.

2. Replace a Complex Formula

If you work with formulas, I’m sure you know this thing that complex formulas are hard to read and sometimes harder to understand by others. So a custom function can a solution to this problem because once you create a UDF you don’t need to write that complex formula again and again.

3. When you don’t want to use SUB Routine

While you can use a VBA code to perform a calculation but VBA codes are not dynamic*. You need to run that code again if you want to update your calculation. But if you convert that code into a function then you don’t need to run that code again and again as you can simply insert it as a function.

How to Create Your First User Defined Function in Excel

OK so look. I have split the entire process into three steps:

1. Declaring your Procedure as a Function
2. Defining its Arguments and their Data Type
3. Add code to Calculate the Desired Value

But let me give you can:

You need to create a function that can return the name of the day from a date value. Well, we have a function that returns the day number for the week but not the name. You got it what I’m saying? Yes?

So, let’s follow the below steps to create your first user-defined function:

1. First of all, open your visual basic editor by using the shortcut key ALT + F11 or go to Developer Tab and simply click on the “Visual Basic” button.
   
2. The next thing is to insert a module, so right-click on the VBA project window and then go to insert, and after that click “Module”. (ALERT: You need to enter a USER‌ DEFINED FUNCTION only into standard modules. Sheet and ThisWorkbook modules both are a special type of module and if you enter a UDF in these two modules, Excel does not recognize that you are creating a UDF).
   
3. The third thing is to define a name for the function and here I’m using “myDayName”. So you must write “Function mydayName”. Why Function before the Name? As you are creating a VBA function so the using the word “Function” tells Excel to treat this code as a function (make sure to read the scope of a UDF ahead in the post).
4. After that, you need to define arguments for your function. So insert starting parentheses and write “InputDate As Date”. Here InputDate is the Argument’s name and date is its data type. It’s always better to define a data type for the argument.
   
5. Now, close the parentheses and write “As String”. Here you are defining the data type of the result returns by the function and as you want day name which is a text so its data type should be as “String”. If you want to have the result which is other than a string make sure to define its data type according to that. (Function myDayName(InputDate As Date) As String).
   
6. In the end, hit ENTER. At this point, your function’s name, its argument, argument’s data type, and function’s data type is defined and you have something like below in your module:
   
7. Now within the “Function” and “End Function”, you need to define the calculation or you can say working of this UDF. In Excel, there is a worksheet function called “Text” and we are using the same here. And for this, you need to write the below code and with this code, you are defining the value which should be returned by the function. myDayName = WorksheetFunction.Text(InputDate, “dddddd”)
   
8. Now, close your VB editor and go back to the worksheet and in the cell B2, enter “=myDayName(A2)” hit enter and you’ll have the day name.
   

Congratulations! You have just created your first User Defined Function. This is the moment of real Joy. Isn’t it? Type “Joy” in the comment section.

How this Function Works and Return Value in a Cell

Your first custom function is here, but the thing is, you need to understand how it works. If I say in simple words, it’s a VBA code but you have used it as a function procedure. Let’s divide it into three parts:

• You enter it in a Cell as Function and Specify the Input Value.
• Excel runs the code behind the function and uses the value which you have referred to.
• You got the result in the cell.

But you need to understand how this function works from inside. So I have split the entire process into three different parts where you can see how the code which you have written for the function actually works.

As you have specified “InputDate” as the argument for the function and when you enter the function in the cell and specify a date, VBA takes that date value and supply it to the text function which you have used in the code.

And in the example which I have mentioned above, the date you have in the cell A1 is 01-Jan-2019.

After that, the TEXT function converts that date into a day using the format code “dddddd” which you have already mentioned in the function code. And that day which is returns by the TEXT function is assigned to the “myDayName”.

So if the result of the TEXT function is Tuesday that value will be assigned to the “myDayName”.

And here the working of the function comes to an end. “myDayName” is the name of the function so any value is which is assigned to “myDayName” will be the result value and the function which you have inserted in the worksheet will return it in the cell.

​When you write a code for a custom function there one thing you need to take care that the value which that code return must be assigned to the function’s name.

How to Improve a UDF for Good

Well, you know how to create a custom VBA function.

Now…

There’s one thing you need to take care that the code you have used to function should be good enough to handle all the possibilities. If you talk about the function which you just wrote above can return the day name from a date.

But…

What if the value you have specified will not a date? And if the cell you have referred is blank? There can be other possibilities but I’m sure you got my point.

Right? So, let’s try to improve this custom function which could be able to deal with the above problems. Alright. First of all, you need to change the data type of the argument and use:

InputDate As Variant

With this, your custom function can take any kind of data type as input. Next, we need to use VBA IF statement to check InputDate for some conditions. The first condition is if the cell is blank or not. And for this, you need to use below code:

If InputDate = "" Then
myDayName = ""

This will make the function return blank if the cell you have referred is blank.

One problem is solved, let’s get into the next one. Other than a date there are possibilities that you can have a number or a text. So, for this, you also need to create a condition which should check whether the value referred is an actual date or not.

The code would be:

If IsDate(InputDate) = False Then
myDateName = ""

Here I’m using a blank for both of the conditions, so that if you have large data, you could easily filter values where the input value is not valid. So, after adding the above conditions, the code would look like:

Function myDayName(InputDate As Variant) As String
If InputDate = "" Then
myDayName = ""
Else
If IsDate(InputDate) = False Then
myDateName = ""
Else
myDayName = WorksheetFunction.Text(InputDate, "dddddd")
End If
End If
End Function

And here’s how it works now: I’m sure you can still make some changes in this function but I’m sure you got my point clearly.

How to use a Custom VBA Function

At this point, you’re pretty much clear about how you can create a VBA function in Excel. But once you have it, you need to know how you can use it. And in this part of the post, I’m going to share with you how and where you can use it. So, let’s jump into it.

1. Simply within a Worksheet

Why we create a custom function? Simple. To use it in the worksheet. You can simply enter a UDF in a worksheet by using equal sign and type name of the function and then specify it’s arguments.

You can also enter a user defined function from the function library. Go to Formula Tab ➜ Insert Function ➜ User Defined.

From this list, you can choose the UDF you want to insert.

2. Using in other Sub Procedures and Functions

You can also use a function within other functions or in a “Sub” procedure. Below is a VBA code where you have used the function to get day name for the current date.

Sub todayDay()
MsgBox "Today is " & myDayName(Date)
End Sub

Make sure to read “Scope of a UDF” ahead in this post to learn more on using a function in other procedures.

3. Accessing Functions from Other Workbook

If you have a UDF in one workbook and you want to use it in another workbook or in all the workbooks, you do it by making an add-in for it. Follow these simple steps:

• First of all, to you need to save the file (in which you have the custom function code) as an add-in.
• For this, go to the File Tab ➜ Save As ➜ “Excel Add-Ins (.xalm).

• After that, double-click on the add-in you and install it.

That’s it. Now you can use all of your VBA functions in any of the workbook.

Different Ways to Create a Custom VBA Function [Advanced Level]

At this point, you know about to create a custom function in VBA. But the thing is when we use In-Built functions, they come with different type of arguments.

So in this section of this guide, you gonna learn how to create a UDF with the different type of arguments.

• Without Any Arguments
• With Just One Argument
• With Multiple Arguments
• Using Array as the Argument

…let’s move ahead.

1. Without Any Arguments

Do you remember about functions like NOW and TODAY where you don’t need to enter any argument?

Yes. You can create a User Defined Function where you don’t need to enter an argument. Let’s do it with an example:

Let’s create a custom function which can return the location of the current file. And here’s the code:

Function myPath() As String
Dim myLocation As String
Dim myName As String
myLocation = ActiveWorkbook.FullName
myName = ActiveWorkbook.Name
If myLocation = myName Then
myPath = "File is not saved yet."
Else
myPath = myLocation
End If
End Function

This function returns the path of the location where the current file is stored and if the workbook is not stored anywhere, it will show a message says “File is not saved yet”.

Now, if you pay close attention to the code of this function, you don’t have defined any argument (within the bracket). You have just defined the data type for the function’s result.

The basic rule of creating a function without argument is a code where you don’t need to input anything.

In simple words, the value you want to have in return from the function should be calculated automatically.

And in this function, you have the same thing.

This code ActiveWorkbook.FullName returns the location of the file and this one ActiveWorkbook.Name returns the name. You don’t need to input anything.

2. With Just One Argument

We have already covered this thing while learning how to create a user-defined function. But let’s dig a bit deeper and create a different function. This is the function which I had created a few months back to extract URL from a hyperlink.

Function giveMeURL(rng As Range) As String
On Error Resume Next
giveMeURL = rng.Hyperlinks(1).Address
End Function

Now in this function, you have just one argument.

When you enter this in a cell and then specify the cell where you have a hyperlink, and it will return the URL from the hyperlink. Now in this function, the main work is done by:

rng.Hyperlinks(1).Address

But the rng is what you need to specify. Say “Easy” in the comment section if you find creating a UDF easy.

3. With Multiple Arguments

Normally, most of the Excel’s In-Built Functions have multiple arguments. So it’s a must for you to learn how you create a custom function with multiple arguments.

Let’s take an example: You want to remove particular letters from a text string and want to have the rest of the part.

Well, you have functions like RIGHT and LEN which you are going to use in this custom function. But here we don’t need this. All we need is a custom function using VBA.

So, here’s the function:

Function removeFirstC(rng As String, cnt As Long) As String
removeFirstC = Right(rng, Len(rng) - cnt)
End Functio

OK so look:

In this function, you two arguments:

• rng: In this argument, you need to specify the cell from where you want to remove the first character of a text.
• cnt: And in the argument, you need to specify the count of the characters to remove (If you want to remove more than one character from the text).

When you enter it in a cell it works something like below:

3.1 Creating a User Defined Function with Optional as well as Required Argument

If you think about the function we have just created in the above example where you have two different arguments, well, both of them are required. And, if you miss any of these you’ll get an error like this.

Now if you think logically, the function we have created is to remove the first character. But here you need to specify the count of the characters to remove. So my point is this argument should be optional and must take one as a default value.

What do you think?

Say “Yes” in the comment section if you agree with me on this.

OK so look. To make an argument optional you just need to add “Optional” before it. Just like this:

But the important thing is to make your code to work with or without the value for that argument. So, our new code for the same function would be like this: Now in the code, if you skip specifying the second argument.

4. Using Array as the Argument

There are few In-built functions which can take arguments as an array and you can also make your custom VBA function to do this.

Let’s do with a simple example where you need to create a function where you sum values from a range where you have numbers and text. Here we go.

Function addNumbers(CellRef As Range)
Dim Cell As Range
For Each Cell In CellRef
If IsNumeric(Cell.Value) = True Then
Result = Result + Cell.Value
End If
Next Cell
addNumbers = Result
End Function

In the above code of the function, we have used an entire range A1:A10 instead of a single value or a cell reference.

By using FOR EACH loop, it will check every cell of the range and sum the value if the cell has a number in it.

The scope of a User Defined Function

In simple words, the scope of a function means if it can be called from other procedures or not. A UDF can have two different types of scopes.

1. Public

You can make your custom function public so that you can call it in all the worksheets of the workbook. To make a Function public you just need to use the word “Public”, just like below.

But a function is a public function by default if you don’t make it private. In all examples we have covered, all are public.

2. Private

When you make a function private you can use it in the procedures of the same module.

Let’s say if you have your UDF in “Module1” you can only use it in procedures you have in “Module1”. And it won’t appear in the function list of the worksheet (when you use = sign and try to type the name) but you can still use it by typing its name and specifying arguments.

Limitations of User Defined Function [UDF]

UDFs are super useful. But they are limited in some of the situations. Here are the few things which I want you to note down and remember while creating a custom function in VBA.

• You can’t change, delete, or format cells and a range by using a custom function.
• Also, can’t move, rename, delete, or add worksheets to a workbook.
• Make a change to another cell’s value.
• It also can’t make changes to any of the environment options,

…click here read more details from Microsoft’s website.

Is there any difference between an In-Built Function and a User Defined Function?

I’m glad you asked. Well, to answer this question I want to share some of the points which I believe are important for you to know.

1. Slower Than In-Built: If you compare the speed of inbuilt functions and VBA function, you’ll find earlier is fast. The reason behind this is that the in-built functions are written using C++ or FORTRAN.
2. Hard to Share Files: We often share files over email and cloud so if you are using any of the custom function you require to share that file in “xlam” format so that other person can also use your custom function.

But as I said above in “Why You Should Create a Custom Excel Function” there are some specific situations when you can go for a VBAcustom function.

Conclusion

Creating a User Defined Function is simple. All you need to do it use “Function” before the name to define it as a function, add arguments, define arguments data type and then define the data type for the return value.

In the end, add code to calculate the value which you want to get in return from the function. This guide which I have shared with your today is the simplest one to learn how to create a custom function in VBA and I’m sure you have found it useful.

But now, tell me one thing.

UDFs are useful, what do you think?

Please share your views with me in the comment section. I’d love to hear from you, and please, don’t forget to share this post with your friends, I am sure they will appreciate it.

• VBA Functions List – Explained with Examples
• How to Run a Macro in Excel
• How to use IF Statement in VBA
• How to Work with Ranges and Cells in VBA
• VBA Comment
• Add New Sheet using a VBA Code

VBA is one of the Advanced Excel Skills, and if you are getting started with VBA, make sure to check out there (What is VBA and Useful Macro Examples and VBA Codes).

Is this article up to date?