The VBA Tutorials Blog

How to Autofill Using Excel VBA

Wed, 12 Apr 2023 14:15:00 +0000

In this tutorial, you will learn how to use the Autofill feature in Excel VBA to fill a range of cells with data based on a pattern or a series. Autofill is a useful tool that can save you time and avoid errors when you need to enter repetitive or sequential data in your worksheets.

What is Autofill?

Autofill is a feature in Excel that allows you to automatically fill a range of cells with data based on the first cell or cells in the range. For example, if you enter 1 in cell A1 and 2 in cell A2, select both cells then drag the fill handle (the small square at the bottom right corner of the cell) to cell A10, Excel will autofill the range A1:A10 with the numbers 1 to 10. Similarly, if you enter Jan in cell B1 and drag the fill handle to cell B12, Excel will autofill the range B1:B12 with the months of the year.

You can also use Autofill to fill a range of cells with custom lists that you create or modify in Excel. For example, you can create a list of colors and use Autofill to fill a range of cells with those colors.

How to Use Autofill in Excel VBA

You can use the Range.Autofill method in Excel VBA to perform the same action as dragging the fill handle in Excel. The syntax of the Range.Autofill method is:

Range.AutoFill Destination:=Range, Type:=xlFillDefault

The Range argument specifies the range of cells that contains the data you want to use as the basis for autofilling. The Destination argument specifies the range of cells you want to fill with data. The Type argument specifies the type of autofilling you want to apply. The possible values for this argument are:

xlFillDefault: Fills the destination range with data based on the default behavior of Excel. The default can fill the destination range with formulas, numbers, or text based on the source cell.
xlFillCopy: Copies the data from the source range to the destination range without any changes.
xlFillSeries: Fills the destination range with a series of values based on the source range.
xlFillFormats: Copies only the formats from the source range to the destination range.
xlFillValues: Copies only the values from the source range to the destination range.
xlFillDays: Fills the destination range with a series of dates incremented by one day.
xlFillWeekdays: Fills the destination range with a series of dates incremented by one weekday.
xlFillMonths: Fills the destination range with a series of dates incremented by one month.
xlFillYears: Fills the destination range with a series of dates incremented by one year.
xlGrowthTrend: Fills the destination range with a growth trend or a geometric series of numbers based on the source range.
xlLinearTrend: Fills the destination range with a linear trend based on the source range.
xlFlashFill: Fills the destination range with data based on Flash Fill, which is an intelligent feature that analyzes your data and fills in missing values or extracts values from other columns.

Note that not all types of autofilling are applicable to all types of data. For example, you cannot use xlFillDays to fill a range of cells with text values.

Example 1: How to Autofill Using Excel VBA

Let’s see an example of how to use Autofill in Excel VBA. Suppose you have a worksheet named “Sales” containing the following data:

A	B	C	D
Jan	1000
Feb	1200
Mar	1400

We want to use Autofill to fill column A with names of the months and to fill colum B with a linear trend based on the existing values column B. To do this, we can use the following VBA code:

Sub AutofillExample()

    'Activate worksheet
    Worksheets("Sales").Activate
    
    'Select source range
    Set startingRange = ActiveSheet.Range("A1:A2")
    
    'Autofill destination range with xlFillMonths
    startingRange.AutoFill Destination:=Range("A1:A12"), Type:=xlFillMonths
    
    'Select source range
    Set startingRange = ActiveSheet.Range("B1:B2")
    
    'Autofill destination range with xlLinearTrend
    startingRange.AutoFill Destination:=Range("B1:B12"), Type:=xlLinearTrend

End Sub

When you run this code, columns A and B will be filled, like this:

A	B	C	D
Jan	1000
Feb	1200
Mar	1400
Apr	1600
May	1800
Jun	2000
Jul	2200
Aug	2400
Sep	2600
Oct	2800
Nov	3000
Dec	3200

Example 2: Fill a range with the same value

Suppose you have a worksheet like this:

A	B	C	D
1	Hello
2
3
4

And you want to fill column B with the value “Hello”. You can use VBA Autofill to do this in one line of code:

Sub AutofillExample2()
    Range("B1").AutoFill Destination:=Range("B1:B4"), Type:=xlFillDefault
End Sub

This code will copy the value in B1 and fill the rest of the range B1:B4 with the same value. The result will look like this:

A	B	C	D
1	Hello
2	Hello
3	Hello
4	Hello

Again, the Type argument specifies how to fill the range. In this case, we use xlFillDefault, which means to copy the value or formula in the first cell. You can also use other types, such as xlFillCopy, xlFillSeries, xlFillValues, etc.

Example 3: Fill a range with a series of values

Suppose you have a worksheet like this:

A	B	C	D
10
20
30
40

And you want to fill column B with a series of values that starts from a number that’s 5 greater than the value in Cell A1. You can use VBA Autofill to do this in two lines of code:

Sub AutofillExample3()
    Range("B1").Value = Range("A1") + 5
    Range("B1").AutoFill Destination:=Range("B1:B4"), Type:=xlFillSeries
End Sub

This code will first assign the value in A1 plus 5 to B1, and then fill the rest of the range B1:B4 with a series of values that increases by 1. The result will look like this:

A	B	C	D
10	15
20	16
30	17
40	18

Example 4: Fill a range with formulas

Suppose you have a worksheet like this:

A	B	C	D
x	f(x)
-2
-1
0
1

And you want to fill column B with formulas that calculate f(x) = -0.0625x^2 + x + 0.5. You can use VBA Autofill to do this in two lines of code:

Sub AutofillExample4()
    Range("B2").Formula = "=-0.0625*A2^2+A2+0.5"
    Range("B2").AutoFill Destination:=Range("B2:B5"), Type:=xlFillCopy
End Sub

This code will first assign the formula to B2, and then fill the rest of the range B2:B5 with the same formula. The result will look like this:

A	B	C	D
x	f(x)
-2	-1.75
-1	-0.5625
-0	0.5
-1	1.4375

In this example, you would have gotten the same result if you used the xlFillSeries or the xlFillDefault Type. That just goes to show you that there are often multiple Type parameters that can be used to accomplish the same VBA AutoFill behavior.

I hope this tutorial was helpful and you learned how to use AutoFill in VBA to fill a range with different types of series. Thank you for reading!

How to use the VBA NPV Function

Mon, 03 Apr 2023 18:30:00 +0000

In this tutorial, you will learn how to use the VBA NPV function to calculate the net present value of an investment based on a series of cash flows and a discount rate. The net present value is a measure of how much an investment is worth today, considering the time value of money.

The VBA NPV function has the following syntax:

NPV (Rate, ValueArray)

Where:

Rate is the discount rate per period, expressed as a decimal. For example, if the annual discount rate is 10%, and the cash flows are monthly, then the rate per period is 0.1 / 12 = 0.008333.
ValueArray is an array of cash flow values, where negative values represent payments and positive values represent receipts. The NPV function assumes that the first cash flow occurs at the end of the first period.

Using the NPV Function with an Array

To use the VBA NPV function, you need to declare a variable to store the result, and assign it the value of the function with the appropriate arguments. For example, suppose you have an investment that requires an initial payment of $10,000, and then generates monthly cash flows of $1,000 for 12 months. The annual discount rate is 10%. You can calculate the net present value of this investment as follows:

Sub NPV_Demo1()
Dim NetPV As Double 'Declare a variable to store the result
Dim Values(12) As Double
Values(0) = -10000
Values(1) = 1000
Values(2) = 1000
Values(3) = 1000
Values(4) = 1000
Values(5) = 1000
Values(6) = 1000
Values(7) = 1000
Values(8) = 1000
Values(9) = 1000
Values(10) = 1000
Values(11) = 1000
Values(12) = 1000
NetPV = NPV(0.1 / 12, Values) 'Assign it the value of the NPV function
MsgBox "The net present value of this investment is " & Format(NetPV, "Currency") 'Display the result
End Sub

The result is $1,363.15, which means that this investment is worth more than its cost today.

Note that if your first cash flow occurs at the beginning of the first period, you need to adjust your calculation by adding the first value to the result of the NPV function. For example, suppose you have an investment that requires an initial payment of $10,000 at the beginning of the first month, and then generates monthly cash flows of $1,000 for 12 months. The annual discount rate is 10%. You can calculate the net present value of this investment as follows:

Sub NPV_Demo2()
Dim NetPV As Double 'Declare a variable to store the result
Dim Values(11) As Double
Values(0) = 1000
Values(1) = 1000
Values(2) = 1000
Values(3) = 1000
Values(4) = 1000
Values(5) = 1000
Values(6) = 1000
Values(7) = 1000
Values(8) = 1000
Values(9) = 1000
Values(10) = 1000
Values(11) = 1000
NetPV = -10000 + NPV(0.1 / 12, Values) 'Add the first value to the result of the NPV function
MsgBox "The net present value of this investment is " & Format(NetPV, "Currency") 'Display the result
End Sub

The result is $1,374.51, which is higher than the previous case because you pay less interest on your initial payment.

Using the NPV Function with a Loop

You can also use a loop to populate your ValueArray with dynamic values from a worksheet range or a user input. For example, suppose you have a worksheet with the following data:

A	B
Discount Rate	10%
Initial Payment	-10,000
Cash Flow
Month 1	1,000
Month 2	1,000
Month 3	1,000
Month 4	1,000
Month 5	1,000
Month 6	-2,000
Month 7	-2,000
Month 8	-2,000
Month 9	-2,000
Month 10	-2,000
Month 11	-2,000
Month 12	-2,000

You can calculate the net present value of this investment as follows:

Sub NPV_Demo3()
Dim NetPV As Double 'Declare a variable to store the result
Dim Rate As Double 'Declare a variable to store the discount rate
Dim ValueArray() As Double 'Declare an array to store the cash flow values
Dim i As Long 'Declare a variable to loop through rows
Dim n As Long 'Declare a variable to count rows

Rate = Range("B1").Value / 12 'Get the discount rate per month
n = WorksheetFunction.Count(Range("B4:B15")) 'Count the number of cash flow values
ReDim ValueArray(1 To n) 'Resize the array to match the number of values
For i = 1 To n 'Loop through each row
    ValueArray(i) = Range("B" & i + 3).Value 'Assign the value to the array element
Next i 'Go to the next row
NetPV = WorksheetFunction.NPV(Rate, ValueArray) 'Calculate the net present value using the NPV function
NetPV = NetPV + Range("B2").Value 'Add the initial payment to the result
MsgBox "The net present value of this investment is " & Format(NetPV, "Currency") 'Display the result in a message box
End Sub

In this example, we used a loop to populate the ValueArray with values from a worksheet range. This way, we can easily change the values in the worksheet and recalculate the net present value without modifying the code. We also used the WorksheetFunction object to access the Excel NPV function from VBA instead of the native VBA worksheet function. The WorksheetFunction object allows us to use any of the built-in Excel functions in our code, but we could have easily just used the native VBA NPV function, like we did earlier, and we would have gotten the same result: ($-18,116.84).

Using a loop and an array is a common technique in VBA programming. It can help us simplify our code and make it more dynamic and flexible. There are certainly more efficient ways to extract data from an Excel spreadsheet, but I wanted to demonstrate with loops and arrays since they can be adapted to many use cases.

In this tutorial, we learned how to use the VBA NPV function to calculate the net present value of an investment based on a series of cash flows and a discount rate. We also demonstrated how to use a loop and an array to calculate the net present value of an investment using VBA, both by using the native VBA NPV function and by using the WorksheetFunction object to access Excel functions from VBA. I hope you found this tutorial useful and informative. For more VBA tips and tricks like this, please subscribe using the form below. Thank you for reading!

FormulaR1C1 Makes Relative References in VBA Easy

Fri, 21 Jan 2022 10:00:00 +0000

A1-style notation for spreadsheets is intuitive and easy to work with. Columns are always identified by letters and rows always by numbers, so it’s hard to confuse which is which. The prevalence of using A1-notation is so thorough that sometimes it’s hard to imagine any other way to do it. But another way does exist.

In some circumstances, it makes more sense to use R1C1-style notation, which identifies the entire Excel grid by number. This becomes particularly useful when you need to perform some arithmetic on the column and row placement, such as moving down two rows and left one column.

Connecting R1C1 to Past Experiences
The Power of R1C1
Types of R1C1 Reference
Variable R1C1 References
Modeling Variable Client Closing Times

Connecting R1C1 to Past Experiences

R1C1 is just as intuitive as A1 notation once you’re accustomed to it. Many programmers already have plenty of experience with referencing ranges with R1C1 notation, because this is how the .Cells object works in Excel. It is very common to loop through a set of cells like this:

For i = 2 To 11
    For j = 2 To 6
        Cells(i, j).Value = Cells(i, j).Value * 1000
    Next j
Next i

The code block above moves through a 10-by-5 grid and multiplies each number by 1000. References like this identify the row and the column by number, which is exactly what R1C1 does, albeit in a slightly different manner.

The Power of R1C1

R1C1 notation take the same concept above and applies it to formulas. Instead of entering into cell B4 the formula =B3*1.05 to increase B3 by 5%, we could write into B4 (R2C4) =RC[-1]*1.05, which references

the row offset by 0 (nothing)
the column offset by -1 (one to the left).

A consequence of this is that when dragging or autofilling, in A1 notation we’ll have formulas that look different in each cell but in R1C1 notation the formulas will all be exactly the same:

Simple A1-Style Notation Formulas

Simple R1C1-Style Notation Formulas

This visualization should be intuitive evidence of how powerful R1C1 notation can be: a single formula based on referential logic can generate complex tables. There is also a lot of flexibility in this referential style, which we’ll explore further.

Types of R1C1 Reference

A1-style notation has a single type. You enter the column letter and the row number and that’s it. There are no other ways to make the reference. With R1C1, however, you can make absolute references, relative references, and mixed references.

Absolute References

Absolute references in R1C1-style target a specific cell and they never change. For example, let’s add some absolute references to B2 and C2:

Range("B2").FormulaR1C1 = "=R2C1 * 1.05"      'set by A1 range notation
Cells(3, 2).FormulaR1C1 = "=R3C1 * 1.05"      'set by row/column cell notation

These two formulae reference R2C1 (cell A2) and R3C1 (cell A3) at all times, and they never change, even if you drag them across the sheet. It’s equivalent to typing =$A$2 * 1.05 and =$A$3 * 1.05 directly in the Excel cell.

Relative References

Relative references are a little more interesting, because they let you leverage spatial logic. Simply use square brackets [] to make the R1C1 notation relative rather than absolute, just as we did earlier in the Power of R1C1 section.

Positive numbers reference cells down ↓ or to the right →
Negative numbers reference cells above ↑ or to the left ←
No number (nothing ~=0) maintains the current row or column

The positive/negative difference is intuitive, at least for those of us who read top-to-bottom and left-to-right. A couple examples may help:

Range("B2").FormulaR1C1 = "=R[-1]C[-1]"         'refs A1, one row up (-1) and one column left (-1)
Range("B2").FormulaR1C1 = "=R[2]C[-1]"          'refs A4, two rows down (+2) and one column left (-1)
Range("B2").FormulaR1C1 = "=RC[3]"              'refs E2, zero row changes and three columns right (+3)
Range("B2").FormulaR1C1 = "=R[0]C[3]"           'refs E2, zero row changes and three columns right (+3)

Notice how similar this syntax is to the VBA Offset property. With these relative references, if you drag or autofill the formulas on the worksheet, you’ll get a the same spatial relations. The first formula above in B2 references A1, but if we put it into C3, it would reference B2. This contrasts with the absolute reference, which will always reference the same cell, no matter where it is on the sheet.

Make powerful macros with our free VBA Developer Kit

It’s easy to copy and paste a macro like this, but it’s harder make one on your own. To help you make macros like this, we built a free VBA Developer Kit and wrote the Big Book of Excel VBA Macros full of hundreds of pre-built macros to help you master file I/O, arrays, strings and more - grab your free copy below.

Mixed References

These two styles can be combined, too. Simply add or exclude the square brackets to mix.

Range("B2").FormulaR1C1 = "=R1C[-1]"            'refs A1, but the row will always be 1
Range("B2").FormulaR1C1 = "=R[2]C2"             'refs B4, but the column will never change (always B)

Lock Rows and Lock Columns with R1C1

You may have noticed that for absolute references, the column or row never changes. This seems awfully similar to locking a row or column - and that is exactly what it does.

An absolute reference, such as =R1C2 * 1.05 will always grow cell B1 by 5%, no matter where it is entered in the worksheet. Again, in the more familiar A1 notation, this formula would appear as =$B$2 * 1.05. These two formulas are identical, except one is in R1C1 notation and the other is in A1 notation. Let’s take a look at a couple more examples with locked rows and columns.

Range("B2").FormulaR1C1 = "=R1C[-1]*1.05"            'equivalent to A$1 * 1.05, as the row is locked
Range("B2").FormulaR1C1 = "=R[2]C2*1.05"             'equivalent to $B4 * 1.05, as the column is locked

Note that when making absolute references, it doesn’t matter what your starting cell is. The absolute reference must be specified.

Variable R1C1 References

Variables are a core component of programming. There isn’t much point to programming if some value isn’t varying.

The Range.FormulaR1C1 inputs a formula into a cell, and the formula is written as a string in the VBA code. This means you can concatenate any numerical variable into the R1C1 formula using string concatenation.

This comes in handy when coupled with relative references, allowing you to target different cell distances based on variables.

numMonths = Range("A1")
Range("B2").FormulaR1C1 = "=R[-1]C[" & numMonths & "]*1.05"

Here, we place a formula in cell B2 that increases a value by 5%. The cell we’re referencing is in Row 1 (from R[-1]) and some column determined by the value numMonths in cell A1. If the number of months is 6, then the formula in B2 would be =R[-1]C[6] * 1.05 or, based on its initial cell B2, =H1 * 1.05, which is one row above B2 and 6 columns to the right.

Modeling Variable Client Closing Times

I always like to give examples, and I recently had the opportunity to apply this type of variable R1C1 referencing at my full-time job (which is not actually programming).

I was building a financial model that included multiple client types and each type had a different length of time from lead-in to contract signing. The time to close greatly affects cash flows, because cash only flows in after the client signs. If a client drags out the process - quite common in my experience - cash could dry up, especially in a start-up environment. Averages and smoothing techniques do not apply because closing is a binary decision. Clients rarely pay before the contract is signed, and you can’t extrapolate future earnings to earlier dates.

I came up with three ways to build the model:

use HLOOKUPs and a table
use user-defined functions (UDFs)
use R1C1 references

The first option used a complicated formula which would be difficult for investors and the financial team to parse. The second option required auditors, investors, and the financial team to be able to read VBA, which is, unfortunately, not a very common skill. The third option allowed me to make very clear references but still automate filling out the sheet.

To be transparent, we did end up using HLOOKUP, even though it was messy, because it allowed investors and auditors to easily perform what-if analyses with an .xlsx file instead of an .xlsm file, which are often blocked on internal bank computers. That said, for unsophisticated investors and financial teams, using R1C1 references populated by VBA is still an illustrative approach.

The Setup

Our sheet was set up like in the image below (I’ve changed details for confidentiality). The top section is the number of expected leads, based on marketing, networking, etc. The next section is how many of the leads are expected to close. And the last section provides the expected close time (in months) and the actual number of clients.

Client leads, close rates, and times

The Code

Now for the code. The code essentially enters a formula in each cell in the range C18:Z22 that references the close rate and the client leads from a specific number of months ago.

Sub populateClientLeads()
Dim monthsToClose, currMonth, clientType As Integer

For clientType = 0 To 4  'iterates through all 5 client types
    
    monthsToClose = Cells(18 + clientType, 2)   'grabs number of months to close for current client type
    
    For currMonth = 0 To 23     'starts from 0, January 2022, but note the Cells reference must target the correct cell
    
        If currMonth - monthsToClose < 0 Then       'move current month forward in time until close month makes sense (close must be greater than current month)
            Do Until currMonth - monthsToClose = 0
                currMonth = currMonth + 1
            Loop
        End If
    
        Cells(18 + clientType, 3 + currMonth).FormulaR1C1 = "=R[-8]C2 * R[-15]C[-" & monthsToClose & "]"
            'start in row 18 and move down for each successive client type
            'start in column 3 and add the current month
            'first R1C1 references the close rates, and notice how the column is locked
            'second R1C1 looks 15 rows prior to get client leads for that client type then
                'moves back a number of columns equal to the close time
    Next currMonth
Next clientType

        
End Sub

This is a longer code block than we often post here, so here’s an example to help clarify.

Energy companies take 3 months to close, so to see how many energy companies actually sign contracts in June 2022, we should look at March 2022 leads, 3 months earlier than June.

Of course, we also need to incorporate the close rate (obviously not all leads close), and we must lock the close rate column, since this macro populates the entire range C18:Z22. The reason we reference the close rate with R1C1 style and explicitly add it to the formula is so that investors and auditors can inspect the formula themselves.

The Result

The result is a fully-populated client sales section with a very simple-to-read formula. Investors and auditors can click on any cell in C18:Z22 and see exactly how it’s calculated. It is much more concise than trying to understand HLOOKUPs and VBA code (for the investors and auditors, at least).

Populated sales with proper timing

In this screenshot, the cell S18 contains a formula that looks at the Banking / Finance close rate and checks the Banking / Finance leads 6 months prior to S18 (May 2023), which is November 2022. Manually adjusting each time the average close time changes, especially when doing what-if financial analyses, would be very cumbersome. With the macro, you change the average close time, click a macro button, and the formulas are all rewritten. Unfortunately for my application, that does require an .xlsm file, which couldn’t be run on the investors’ and auditors’ systems. I’m sure many of you can relate to that.

Now you can use R1C1-style notation and even lock columns and rows with it, use variable relative references, and apply cell-distance logic to formulas. R1C1 notation is easy to work with once you’re familiar with it and it makes any distance-based manipulations very easy in your VBA macros.

For more VBA tips and tricks like this, subscribe using the form below.

Use VBA Range.Find to Search and Retrieve Data

Fri, 10 Dec 2021 10:00:00 +0000

We’ve all searched Excel via the GUI for values and strings. Usually we’re just looking for a single cell and then we go on our way, but you can also code the search behavior in VBA to automate the process. This is useful when building customized dashboards, a specific algorithm or a repetitive find and replace process.

The key to using VBA to find matches in cells is Range.Find, a method that searches the range and finds what you’re looking for - with plenty of options, too.

The Method and the Range
- An Essential Test
- Why Use .Find at all?
Range.Find Parameters
Using the Return Value
Finding all matches

The Method and the Range

First, the Range.Find method is a method that acts on a Range object. Therefore, you must know which part of which sheets and workbook you want to target. Set the range with a start and end cell or use an entire column. We’re going to slowly build our Find function, starting with ways to specify the range you want to search.

Range("A2:D500").Find       'starts from Row2/Col1 and goes to Row500/Col4
Range("A:D").Find           'starts in Row1/Col1 and goes to the final row in Col4

Using an entire column means you don’t have to specify the starting or ending rows - they’ll all be included.

An Essential Test

Since the return value is either Nothing or a Range object (it will be a cell), and we usually want to access properties of the object, it makes sense to set the output to an object, like this:

Dim foundCell as Range
Set foundCell = Range().Find

Then we can conveniently access the properties of foundCell, like the .Address, .Row or even its .Value. However, because the output is Nothing when there are no matches, we must check for this condition before attempting to access these properties:

If foundCell Is Nothing Then
    'code to handle not finding a match
Else
    'code to handle the match, such as foundRow = foundCell.Row
End If

Make powerful macros with our free VBA Developer Kit

This is actually pretty neat. If you have trouble understanding or remembering it, our free VBA Developer Kit can help. It’s loaded with VBA shortcuts to help you make your own macros like this one - we’ll send a copy, along with our Big Book of Excel VBA Macros, to your email address below.

Why Use `.Find` at all?

The first reason to use .Find is efficiency. Built-in methods are almost always more efficient than the programmer’s code because Microsoft’s team has specifically optimized their calculations. Could you write a for-loop to look in your range and find the needed values? Sure. You could also read the values into an array. But these are not as efficient as using the built-in VBA method designed specifically to search the range.

Another reason to use .Find is to automate a process. Using the GUI to find cell locations is fine if you only have a few cells to check. But what if you have thousands and need to write all those locations into another file (using OpenTextFile)? .Find will let you automate this process.

Finally, while the Excel GUI is well-designed and powerful, you may be building a custom dashboard. To align the layouts and styles, you may want to build your own search GUI. You can still leverage the efficiency of the .Find method on the backend while your users see your custom frontend UserForm.

Range.Find Parameters

So far we’ve only presented pseudo-code to help paint the big picture of what a Range.Find macro should include (specifying the range, setting the output to a range variable, and checking for nothingness). The Range.Find method itself accepts quite a few inputs but only requires one: What.

What - the thing you’re looking for. This accepts strings but also numbers. Note that operators (<, >, =, etc.) are not accepted unless part of a string
After - starts searching after this cell (and excludes this cell until it loops around)
LookIn - search the values (xlValues) or formulas themselves (xlFormulas). Sometimes used for comments, too (xlComments, xlCommentsThreaded)
LookAt - used to match part of the cell (xlPart) or force a full match (xlWhole)
SearchOrder - search an entire row (xlByRows) or an entire column (xlByColumns) first before moving to the next
SearchDirection - xlPrevious or xlNext, to navigate away from the After cell
MatchCase - whether the case must be a perfect case-sensitive match or not (True or False)
MatchByte - matching by character type (True or False)
SearchFormat - True or False to search in cell formats and requires a separate line of code

Important: VBA saves your settings for LookIn, LookAt, and SearchOrder on every run, including by the GUI. Since users who interact with the GUI may make changes, good coding practice dictates hardcoding these parameters every time you use them in your macro.

What

Finding strings is straightforward. Simply enclose the necessary string in quotes. You can even use this to find parts of formula. For example, Column G may contain a user’s total purchases and a formula may exist, like If($G$1>3500,"VIP",""). To raise the VIP status threshold, you need to find the cells with that formula, first. Just pass part of the formula into the What parameter.

What can also be a number. One example is to find order numbers in a list and use that to produce the associated customer name, using something like VBA Offset. This could also be used to find part numbers in a big sheet of part IDs.

After

The search begins AFTER this argument. This argument should also be a cell, such as Cells(2,3) or Range("C2"). This will exclude C2 but include D2 and C4 in the searchable range.

LookIn

This lets you choose whether you want to match the cell value, the cell formula, or the comments associated with the cell.

Most commonly we use xlValues, but we may want to find a formula so that we can change it. This also becomes important to set if we have cells that dictate text via formula, such as =if(G>1500, "VIP","Normal"). If we want to find VIP clients (not the "VIP" in the code) we must pass xlValues to LookIn. If we passed in (or used a saved setting) xlFormulas, we’d get each cell containing this IF-statement.

LookAt

This lets you match part of or the whole cell value (or formula or comment).

For example, you may have multiple words in a cell (or very likely in comments). If your code can only captures a single word (perhaps a user can only remember part of the comment), then you can use xlPart to find any partial match.

If you’d like, you can insert wildcard characters * into the string to effectively induce xlPart behavior with xlWhole.

Set x = Range("A:K").Find(What:="check", LookIn:=xlComments, LookAt:=xlWhole)       'the entire comment must be the single word check
Set x = Range("A:K").Find(What:="check", LookIn:=xlComments, LookAt:=xlPart)            'find all comments with "check" in them
Set x = Range("A:K").Find(What:="*check*", LookIn:=xlComments, LookAt:=xlWhole) 'functionally equivalent to immediately preceding statement

SearchOrder

Use this argument to choose to search by columns or by rows. For some applications this is not very useful, but in others, it may be essential.

When you have multiple cells with similar entries, especially if you are using xlPart, you may have multiple hits. You may also want to exhaust an entire column or row before moving to the next. You could achieve this by using one line of code to target each row or column, but that is unwieldy. Setting SearchOrder is much more efficient.

Search down the rows or across the columns

With the image above in mind, when you set xlByRows, you will check each cell in Column A, and only when the data in Column A is exhausted will Range.Find move to Column B. Conversely, setting xlByColumns will look across the columns, starting in Row 1 and continue until all columns are exhausted before moving to Row 2.

SearchDirection

This parameter sets whether Excel moves down and to the right or up and to the left from your starting cell. If you haven’t set After, then the upper-left corner of the range marks the starting point. Knowing this is useful when you’re running .Find in a loop.

Remember that this parameter’s choice is saved at the application level, so when you run another Range.Find line, whether in another part of the code or as part of a loop, Excel will continue in the same direction.

MatchCase and MatchByte

MatchCase toggles case matching. This might be beneficial if your data formatting standards rely on case, such as all-caps for headers. Using UCase and the header names would help you identify header rows in a large sheet. It could also be used to find “important” comments where the commenter has written everything in capital letters.

MatchByte is used for matching characters, specifically of languages that have too many characters for single-byte data formats. English and other European languages can encode their alphabets using one byte (8 bits) of data. For some languages, like Mandarin, where an alphabet doesn’t directly encode the language’s sounds in an alphabet, more bytes are needed, and hence the use of MatchByte could be beneficial.

Both of these properties are technically of Variant type, but they use True and False, just like a Boolean data type.

SearchFormat

This parameter lets you search formatting, such as bold or large font, for key information. You could even use it for cell fill colors, like if you highlight all Total rows with a yellow background.

Don’t forget to clear the FindFormat format before starting, just in case.

Application.FindFormat.Clear
Application.FindFormat.Interior.Color = vbYellow

Set foundCell = Range("A:K").Find(What:="*", SearchFormat:=True)

If you don’t know the text for a cell (in value, comment, or formula), you can search solely on formatting by using the wildcard, which will match any text (excluding empty cells). Searching an empty string will help you find the blank cells.

Using the Return Value

If a match exists, Excel will return a cell as a Range object. With this, you can access any property that a range would reasonably have.

One example is substituting .Find as a database relation and using the input as a kind of foreign key. Let’s look at an example.

Say you have one sheet with orders, names, and customer IDs, and a second but password-protected sheet that stores customer details. Moreover, you have three access levels for employees: level-1 sees only orders, level-2 sees orders and customer phone numbers, and level-3 sees complete customer and order details.

In this case you may use a VLOOKUP to display names next to orders, linking them by customer ID, but you don’t want to display customer phone numbers to level-1 employees. In this case, you could create a password-enabled dashboard, then use .Find to output the customer’s phone number based on the ID. This would give level-2 employees a way to access phone numbers but protect further details, like customer addresses.

This pseudocode makes orderNum act a bit like a foreign key in a database:

orderNum = functionToGetOrderNumber

Set foundCell = Sheets("Customer Details").Range([customer details range]).Find(orderNum)

customerPhone = Sheets("Customer Details").Cells(foundCell.Row, customerPhoneColumn)

Finding all matches

Range.Find can be as simple as returning the first match of a string, but the optional arguments available make the method very versatile, too. Strings are permissible but so are other data types, and you can search through cell values but also cell formulas and even comments. The option to search for a specific format works, too, and using the wildcard for What here essentially converts Range.Find into a format finder.

You’ll notice that each instance of Range.Find only finds the next item. If you want to find all the cells matching your search criteria, you can combine Range.Find with Range.FindNext inside a loop and you can join all the found cells with the VBA Union method.

To help you build your own application using all of these methods, here’s a working code you can customize for your own needs:

Sub FindAll()
Dim foundCell As Range    'single cell
Dim foundCells As Range   'all found cells
Dim searchCells As Range  'range you want to search
Dim celladdress As String 'just used so you know when you've found everything
Set searchCells = Range("A:E")

Set foundCell = searchCells.Find(What:="check", LookIn:=xlValues, LookAt:=xlPart)


If foundCell Is Nothing Then
    'code to handle not finding a match
    Debug.Print ("no match found")
Else
    'find all other matching cells with FindNext
    celladdress = foundCell.Address
    Set foundCells = foundCell
    Do
        Set foundCell = searchCells.FindNext(foundCell)
        Set foundCells = Union(foundCells, foundCell) 'combine found cells
    Loop While celladdress <> foundCell.Address
    
    Debug.Print (foundCells.Address)
End If

End Sub

At the end of this routine, all cells containing your search parameter will be stored in the Range object foundCells. If you find this helpful and you want more VBA ideas, enter your email address using the form below. We put together some great resources to make sure you’re getting the most out of Excel VBA.

VBA AdvancedFilter with Multiple Criteria

Fri, 05 Nov 2021 09:00:00 +0000

The AdvancedFilter method in VBA is a powerful tool we first introduced to get a list of unique values, which is common in applications that deal with large amounts of data. In this tutorial we’ll explore how to use AdvancedFilter to filter on multiple criteria rather than just a single column of data.

The Target Range
The Criteria Range
The Output Range
- Using XlFilterInPlace
- Using XlFilterCopy
Clear Your CopyToRange
Taking it Further

The Target Range

We’ll use the same dataset we used in our article for finding unique values. Grab the CSV here or follow along with this screenshot:

Here we have a list of orders with headers and the associated names, region, US state, and amount.

Targeting the range is as simple as inputting the columns. VBA will treat everything in that column as part of the table. However, if you’d prefer to only filter part of a table, you can explicitly define an ending row when defining your range.

In our case, rows A through G are the table, so we can target the range to be filtered. Our base range definition will look like this:

Range("A:G").AdvancedFilter

The Criteria Range

Rather than take a single criterion, AdvancedFilter considers an entire set of criteria.

So we don’t have to hardcode our criteria in our VBA macro, let’s build a new table with headers matching those in our target range. Then, we’ll add our filtering requirements to this table. Columns I and J show our new table, below.

Screenshot of data with just two criteria

You don’t need to cover every header and you don’t have to assign a criteria to each header in the table. Our target Range has 7 fields while our Criteria Range table only has City and Amount, and we didn’t even enter a restriction for the latter.

We can then set our CriteriaRange attribute to the range I1:J2, like this:

Range("A:G").AdvancedFilter CriteriaRange:=Range("I1:J2")

We’re still building our AdvancedFilter statement, so the code won’t work just yet. If you try running it now, you’ll get a Run-time error ‘1004’: AdvancedFilter method of Range class failed error because we haven’t defined an Action. This argument tells AdvancedFilter whether to filter in place or copy the filtered results to a new range. We’ll do that later, but I want to step through the code so far.

Make powerful macros with our free VBA Developer Kit

What we’ve asked AdvancedFilter to do so far is filter all entries in Range("A:G") that contain Pittsburgh. This is a simple single-column filter on City.

The range contains the headers/fields and the criteria themselves. Notice that, unlike the Target Range, we don’t enter the whole column. A blank row in the Criteria Range will match all data records, which is not what we want. Conversely, Excel interprets a blank cell (here J2) to mean any value. Since J2 is empty here, all amounts are valid.

Filtering on Multiple Criteria

This is where the power of AdvancedFilter becomes clear. Let’s say we want to analyze all Center Region orders over $400. We’ll set up our filter table (Criteria Range) to give us the flexibility to drill down by City, too.

We can set up the Criteria Range like so:

To set this as the criteria range, we should expand to Column K, like this:

Range("A:G").AdvancedFilter CriteriaRange:=Range("I1:K2")

With this single table, we can choose to filter on Region, City or both.

We can also have multiple sets of criteria. We can investigate the Center Region with Amounts greater than $400 OR the West Region with Amounts greater than $300.

To add a second set of criteria, we simply add it to a new row and make sure to expand our Criteria Range in our macro:

Range("A:G").AdvancedFilter CriteriaRange:=Range("I1:K3") 'include Row 3

Notice we still don’t have an Action argument defined so this macro still won’t work yet. Don’t worry, we’re getting closer.

AdvancedFilter with AND vs OR

In computing

AND means all conditions must be met
OR means at least one condition must be met

With AdvancedFilter criteria ranges, across rows are treated as ANDs while down rows are treated as ORs.

Thus,the previous example was

Center AND >400

OR

West AND >300

AdvancedFilter with Intervals

With the mathematical operators (<, >, etc.), you can select intervals, too:

Range("A:G").AdvancedFilter CriteriaRange:=Range("I1:L3")

This one will filter for

Center AND >$400 

OR 

West AND >$300 AND <$400

It’s important to remember ANDs go across rows and ORs go down rows when defining your criteria range tables. If you’re not careful, you could end up with statements like West AND Center AND >$100, which wouldn’t return any records since an order can only be assigned to one Region.

The Output Range

The only mandatory parameter, Action, has two possible values: XlFilterInPlace and XlFilterCopy. You must define one of these XlFilterActions or your AdvancedFilter will fail with a run-time 1004 error.

Using `XlFilterInPlace`

The XlFilterInPlace action filters the entire Target Range by hiding rows directly in your table. You’ll get all the fields in the output. Let’s use our criteria above for

Center AND >400

OR

West AND >300

We can filter in place with this code using a macro like this:

Sub AdvancedFilterDemo()
Range("A:G").AdvancedFilter Action:=xlFilterInPlace, CriteriaRange:=Range("I1:K3")
End Sub

Output FilterInPlace

Unqualifying rows are now hidden, though that does include some of the rows in our Criteria Range table itseflf. This is a very quick way to filter, but it does have the drawback of potentially hiding important rows outside your main table.

Note the duplicate Sun Tzu lines in rows 58 through 61, too. You could use AdvancedFilter to display only one of these by leveraging the Unique parameter.

To unhide all the rows, run this code

ActiveSheet.ShowAllData

Once you do that, you’ll be back to your original state.

Using `XlFilterCopy`

In many instances it’s better to copy the output to a new location. This can be another sheet or simply another location on the same sheet.

This method also provides more control over the output, because you can choose which fields to display.

Let’s say you want the criteria

Center AND >400

OR

West AND >300

OR 

Boston

but you only want to output

family name
amount
order number

We’ll start the output at Row 6 (light blue) under the same columns as the Criteria Range (light green). You’ll need to manually type out the header names you want in order for the AdvancedFilter macro to know which headers to paste. That’s precisely what we did in light blue, below. Once you type those out, the VBA AdvancedFilter method will know the columns of data you want and it’ll automatically copy the results matching your filter criteria to that location. If you don’t do this, you’ll get a Run-time error ‘1004’: The extract range has a missing or invalid field name error.

Sub AdvancedFilterCopyDemo()
Range("A:G").AdvancedFilter Action:=xlFilterCopy, _
                            CriteriaRange:=Range("I1:K4"), _
                            CopyToRange:=Range("I6:K6")
End Sub

The last parameter, CopyToRange, contains the Range for the headers/fields you select.

The Criteria Range and Output Range don’t really have to share fields at all. For example, we could filter for amounts greater than $500 in the North region and only output the order number. There’s nothing wrong with that. Of course, both ranges must share fields with the original table, otherwise AdvancedFilter won’t know what to do.

Clear Your `CopyToRange`

If using XlFilterCopy, Excel will guess what to clear in your Output Range. However, you can always be safer by clearing it yourself.

Clear from the first row of data, not from the header row:

Range("I7:K" & Rows.Count).Clear 'headers are in Row 6

This method runs very fast and will clear every row of data all the way to the last row of your worksheet.

Taking It Further

By combining XlFilterCopy with multiple sheets, userforms, or even a UsedRange (to identify the bounds of the Criteria Range and Output Range), you can create a very nice tool for your clients or your own data analysis needs.

These steps give a high-level overview for a sophisticated AdvancedFilter tool:

Place the data table on one sheet
Put the user-adjustable Criteria Range on another sheet, using Data Validation to restrict headers to those in the table
Programmatically determine the last row in the Criteria Range sheet uisng End(xlUp).Row or UsedRange.
Allow users to change output fields under the direction of Data Validation
Add a button to the criteria page that runs your AdvancedFilter macro

Many businesses and organizations leverage Excel for its data manipulation capabilities and AdvancedFilter is one of the quickest ways to get an overview of the data or at least extract the important bits.

You can use the VBA AdvancedFilter method to find matching fields, capture intervals in numerical data and adjust with AND/OR criteria range table structures.

If you found this tutorial useful and you want more tips for writing powerful VBA macros, enter your email address below and I’ll give you my VBA Developer’s Kit for free.

VBA Sgn Function to Check for Positive or Negative Numbers

Sat, 16 Oct 2021 07:00:00 +0000

Every once in a while, I like to post a tutorial about a VBA function that’s rarely used. This is one of those tutorials. The VBA Sgn function is a quick way to check if a number is positive, negative or zero. It’s very simple and returns an integer based on the sign of the number you’re testing.

If the number is greater than zero, Sgn returns 1
If the number equals zero, Sgn returns 0
If the number is less than zero, Sgn returns -1

If you try executing the Sgn function on a value that isn’t a number, like a string, you’ll get a type mismatch so it’s a good idea to pair it with the VBA IsNumeric function, which is what we’re going to do in the following example:

VBA Sgn Function Example Macro

Sub SgnFunctionDemo()
myval = Range("A1")
If IsNumeric(myval) Then
    If Sgn(myval) = 1 Then
        MsgBox ("Cell A1 is positive")
    ElseIf Sgn(myval) = 0 Then
        MsgBox ("Cell A1 is 0 or blank")
    ElseIf Sgn(myval) = -1 Then
        MsgBox ("Cell A1 is negative")
    End If
Else
    MsgBox ("Cell A1 is not numeric")
End If
End Sub

In this macro, we grab the value from cell A1 and first check whether or not it’s numeric. This helps avoid type mismatch errors. After that, we determine the sign of the value using the VBA Sgn function in a series of conditional If statements. You could use this structure to take different actions based on the sign of the cell, or even to force all values to be either negative or positive. Granted, you could just use the VBA Abs function for that, but there’s always more than one way to do something in VBA.

If you’re serious about learning VBA, consider subscribing using the form below. I’ll send a VBA tutorial each week to help you master both simple and challenging VBA concepts.

How to Filter a Column with VBA AutoFilter

Fri, 17 Sep 2021 07:15:00 +0000

Filtering hides rows from a table. Filtering data is a foundational component in understanding large datasets. Some applications only need filtering on one column while others may be more complex. This article will explore filtering on a single column, but we have helpful tutorials on [applying multiple filters with VBA AutoFilter][how to apply multiple filters] and sorting columns using VBA.

The Filter Range
- A Word on Terminology
- The Field Parameter
Defining the Filter Criteria
Clearing Filters

The Filter Range

The first thing to ask yourself when filtering is “what range should I filter?” The .AutoFilter method filters only one column at a time. To filter multiple columns requires an iteration loop or the use of the .AdvancedFilter method, which we touched on in our article about filtering unique values.

The .AutoFilter method operates on Range objects, which both Range and Columns objects satisfy. Since we want to filter an entire column, we can use either of these lines:

Columns(1).AutoFilter       'to filter Column 1 (same as A)
Range("A:A").AutoFilter     'to filter Column A (same as 1)

If you want to filter a defined range rather than an entire column, specify so in your initial Range object: Range("A1:A300").AutoFilter. This allows you to filter up to a certain row, leaving other rows alone.

A Word on Terminology

Excel filters apply across entire rows! You cannot filter only some columns, because filtering hides the entire row. Filtering some columns but not others would break the integrity of the data, erasing the relational connections between columns.

To explain what we mean, try visualizing this scenario. Let’s say we have First Names in column A and Last Names in column B. It wouldn’t make sense to filter only rows in A because then first and last names would no longer be matched appropriately.

Therefore, we usually speak of filtering ON a column, meaning we can look for all first names that start with J, but we cannot filter only Column A without hiding values in B. The phrase filter on [target] implies we use the target as the criteria, but we still hide rows across the entire sheet.

The `Field` Parameter

The .AutoFilter method has a parameter Field. This comes in handy when your Range spans multiple columns. For example,

Range("B:E").AutoFilter Field:=3    'filters the third column, Column D
Range("B:E").AutoFilter Field:=1    'filters the first column, Column B

When the Range object consists of only one column, such as Columns(3).AutoFilter, the Field parameter is still required - you’d just set it to 1.

Defining the Filter Criteria

Filters are based on two Criteria parameters and a set of special Excel operators, for a total of 3 parameters. Only a single criteria is required to filter, but all three can be used to filter a single column.

You can practice using this CSV, which contains this dataset:

Filter For a String

Let’s say you want to find all orders from the North region. We can filter the Region column like this:

Range("E:E").AutoFilter Field:=1, Criteria1:="North"

which yields

Note the filter is applied only to Column E, as indicated by the filter icon at the top of column E.

Filter For Multiple Strings

What if we wanted all data from the North and the West regions? This is where Criteria2 and Operator comes in. The Operator parameter accepts, among others, xlAnd and xlOr. In mathematics terms, AND intersects and OR unions. In non-technical terms, AND requires both criteria to be true, while OR requires only one (but at least one).

So, to filter for all North and all West records, we could use this code:

Range("E:E").AutoFilter Field:=1, Criteria1:="North", Criteria2:="West", Operator:=xlOr

Filtered for North or West

You can even use wildcards (the * symbol) in strings. For example, if you wanted to find all first names that started with F or G, you could use

Range("B:B").AutoFilter Field:=1, Criteria1:="F*", Criteria2:="G*", Operator:=xlOr

If you wanted cities that started with a C and end with an S, you could use xlAnd to force both conditions to be true, like we do in this example:

Range("C:C").AutoFilter Field:=1, Criteria1:="C*", Criteria2:="*S", Operator:=xlAnd

This would yield cities like Columbus and Colorado Springs. Except not in this dataset, because Colorado was not yet in existence when the Declaration of Independence was signed, and this list is mostly signatories of that document.

You may have noticed Sun Tzu (who didn’t live in Ohio or sign the Declaration of Independence) appearing 4 times with exactly the same data. Duplicates like this are common issues in data science, so we made a guide showing you how to filter duplicates (using unique records), too.

Make powerful macros with our free VBA Developer Kit

Filter For Values

Business revolves around numbers, so surely we can filter on more than just strings? That’s right, we can also filter on values, like the Amount values in Column G.

To find all orders over 500 - perhaps for expedited shipping - use the Criteria1 parameter and set it equal to ">500":

Range("G:G").AutoFilter Field:=1, Criteria1:=">500"

The Criteria2 and Operator pramaters are not necessary since we are filtering the Amount column on only one criterion.

Special Filters

We’ve talked about xlAnd and xlOr but the Operator parameter also enables some special filters, like xlTop10Percent. This will display the top 10% of the values in a field, so in a dataset of 50, you’ll get 5 and in a dataset of 1500, you’ll get 150.

Although the name of the operator is xlTop10Percent, you can adjust the actual percentage using Criteria1:

'filter on Amount column (G)
Range("G:G").AutoFilter Field:=1, Criteria1:=5, Operator:=xlTop10Percent        'top 5 percent
Range("G:G").AutoFilter Field:=1, Criteria1:=25, Operator:=xlTop10Percent       'top 25 percent

The Operator parameter also has an xlTop10Items option that restricts the response to X number of items, where X is defined using the Criteria1 parameter.

'filter on Amount column (G)
Range("G:G").AutoFilter Field:=1, Criteria1:=5, Operator:=xlTop10Items          'top 5 items
Range("G:G").AutoFilter Field:=1, Criteria1:=10, Operator:=xlTop10Items         'top 10 items

Leverage User Input

One neat thing about filtering is your filters don’t need to be hardwired. You can ask the user for input since the Criteria parameters accept variables. This example simply asks for a region name in a message box, but with a bit of work on userforms you could design a nice dashboard with many business-specific options and constraints.

Sub filterOnRegion()

Dim regionName As String
regionName = InputBox("Enter the Region name")
Range("E:E").AutoFilter Field:=1, Criteria1:=regionName

End Sub

Clearing Filters

Filters cannot be applied independently using .AutoFilter. Multiple criteria can be applied and on different columns, but each new line of AutoFilter intersects the results - that is, each new line will only “see” the results of the previous filter. When you’re testing, this may cause runtime errors and plenty of frustration. Keep this in your Immediate Window (shortcut Ctrl+G) to quickly reset the filters while testing your code:

ActiveSheet.AutoFilterMode = False

If you need multiple filters, check out our guide on how to properly apply multiple filters.

As you can see, filtering a column in VBA is pretty easy, and you can even add some additional criteria without issue. You can filter on both numeric amounts and strings, and you can apply mathematical relations (like greater than). Excel also provides some built-in dynamic filtering, like xlTop10Percent, depending on your dataset

Just keep in mind that AutoFilter only applies to one column at a time. You can filter multiple columns using it, but it requires multiple lines of code. For more VBA tutorials like this, subscribe using the form below.

VBA Filter Unique Values with AdvancedFilter

Fri, 06 Aug 2021 10:00:00 +0000

When working with large datasets, there’s a good chance that one day you’ll need to find unique values, especially unique strings. It might not matter how many times a value or string repeats, only that it exists in the dataset. When you have 50,000 records with potentially hundreds of unique strings, data cleansing becomes easier when these unique records are collected in one place.

The VBA .AdvancedFilter method is a very powerful tool for this. The method can retain old data, take worksheet-based criteria, and, most importantly for this tutorial, find unique values. The criteria portion itself is a powerful feature, but we’ll dive into that in another tutorial. Today, we’re going to show you how to collect unique values in one place.

Setting the Range
- Unique Values Across Multiple Columns
Output in the Same Place or a New One?
- The Action Parameter
- CopyToRange Parameter
Finding Unique Values
Is the Original Unique? Full Code

Before we show you fully functional code, we’re going to step through the parameters of AdvancedFilter so you can make sure you’re using it correctly.

Setting the Range

The AdvancedFilter method operates on a Range object, just as any filter would. Set the range normally, but note that VBA always treats the first row as a row containing headers. If your data has no headers - that is, your first cell is a regular value - the first value may appear twice in the uniques list. This is easy to recognize and adjust, but it is a bit inconvenient if you’re not expecting it. Unfortunately, Microsoft does not give us a [SourceHasHeaders] type optional parameter here.

Often we want to find uniques in just one column. If the values we want to filter are in Column C, then we’d operate on C like so

Range("C:C").AdvancedFilter     'Option 1 - using a general Range object

Columns(3).AdvancedFilter       'Option 2 - using a column Range object

This is just the non-functional base code - we’ll show you how to get it working properly soon. Also, notice the range can be a single Column from the Columns collection, or it can be a range object. .AdvancedFilter can operate on more than one column and its row range can be limited, as well, if you only want to filter a subset of the data.

Unique Values Across Multiple Columns

Filtering for unique values behaves properly across columns, too. For example, if Column A contains first names and Column B contains last names, we could use .AdvancedFilter to find unique First Name + Last Name combinations. This can be extended to any number of columns. Just use Range("A:B").AdvancedFilter to expand the filter target to both columns.

Output in the Same Place or a New One?

VBA AdvancedFilter can either filter in place, which hides any records that do not match the criteria, or it can output the results to a new location. While filtering in place has its uses, I recommend copying to a new location whenever you have columns on which you do not filter. This is good way to preserve your original data integrity.

The `Action` Parameter

The Action parameter tells .AdvancedFilter to

output results in the same place as the original (xlFilterInPlace) or
copy results to a new location (xlFilterCopy)

Beware of xlFilterInPlace! This will filter the entire sheet and hide rows that do not match your filtering condition on your specified column. This can cause users to panic because they don’t realize the data still exists. All you need to do to unhide the filtered rows is select the “Clear” button on the Excel Data tab to reshow the hidden rows. Alternatively, you can run this code to do it programmatically:

ActiveSheet.ShowAllData

`CopyToRange` Parameter

If you choose xlFilterCopy as your Action parameter, you need to specify where you want to place the copy. The CopyToRange parameter lets you do this. All you need to do is specify a single cell or you can specify an entire column. If the output range is too small to contain all the results, VBA just overflows the area. This means you can’t limit the output, so choose a column without values or with values you don’t mind overwriting.

There’s another quirk of xlFilterCopy to be aware of, too. If two columns in the data you’re trying to filter have the same header title, the xlFilterCopy feature may copy the first column with that name twice to your destination column (CopyToRange).

Finding Unique Values

The last piece of the puzzle is the Boolean parameter Unique, which takes only TRUE or FALSE. To find unique values, set this to TRUE.

To find each unique City in the dataset shown below and place the list of unique cities in Column H, we can use this code

Range("C:C").AdvancedFilter xlFilterCopy, , Range("H1:H1"), True

Don’t miss the blank CriteriaRange parameter. This is our output:

Original Data in Column A and the Filtered Data in Column H

Once you have the list of unique cities, you can further process your data if you’d like using VBA AutoFilter to alphabetize or filter further.

Make powerful macros with our free VBA Developer Kit

To find unique given-family name combinations, you could use

Range("A:B").AdvancedFilter xlFilterCopy, , Range("H1:H1"), True

Since our list is very short, there are no first-last name combination duplicates and the output matches the input. On the other hand, if we had 3 Samuel Adams, one each in Annapolis, New York, and Erie, we would only see a single instance in the output. Of course, we could also filter on Family Name + Given Name + City, which would preserve all three in that example.

Is the Original Unique? Full Code

You can check if your original data has any duplicates by counting the input and output from the AdvancedFilter method. If the number of values match, then your original data didn’t have any duplicates to begin with. One way to do this is to use the WorksheetFunction.Count method. The xlFilterInPlace approach can also apply here, but keep in mind the warning we talked about earlier.

This fully functional code block tells you whether the data in Column A is unique already or not:

Sub wasOriginalUnique()

Dim beforeCount, afterCount As Integer

Range("A:A").AdvancedFilter xlFilterCopy, , Range("B:B"), True
beforeCount = WorksheetFunction.CountA(Range("A:A"))
afterCount = WorksheetFunction.CountA(Range("B:B"))

If beforeCount = afterCount Then MsgBox ("The original was unique")
If beforeCount <> afterCount Then MsgBox ("The original had repeated records")

End Sub

To reinforce the value of the VBA AdvancedFilter method, let’s so you have values in Column A and you want to copy only unique values to a new column, column H. It only takes one line of code to do this:

Sub uniquesToColumnH()

Range("A:A").AdvancedFilter xlFilterCopy, , Range("H:H"), True

End Sub

All your unique values from column A now appear in column H. It’s as simple as that. Advanced filtering unique values provides a valuable alternative to the VBA RemoveDuplicates method we wrote about not too long ago.

We’ve now shown you how to filter out unique records, both in single columns or for consecutive columns. You also know how to put the results in a separate space for later comparison and to keep all the data on one page (without hiding large portions of your original dataset).

Once you have the unique records, you can alphabetize and filter further using AutoFilter, both as an entire table or as a single column.

If you found this helpful, please subscribe using the form below and we’ll send you a couple more tips to make sure you’re getting the most out of VBA.

VBA Insert Rows on Worksheets and Tables

Wed, 07 Jul 2021 10:00:00 +0000

Inserting a row in a spreadsheet seems like a straightforward task. If you don’t overthink it, you could probably guess right now how to .Insert a Row into the Rows collection without looking up anything else. However, one of my favorite Bertrand Russell quotes applies here: everything is vague to a degree you do not realize until you have tried to make it precise.

In that spirit, what exactly is meant by row? Is it the row of a table? The row of the entire sheet? Can a single cell be a row if we constrain ourselves to a single column? Let’s take a look at the different ways to insert rows.

The Guessable Method
The Table Row
The Shift
The Entire Row Property
Conclusion

The Guessable Method

I’m going to call this method the guessable method, because, well, even non-programmers could probably guess how it do it. Let’s say you want a new Row 2. Perhaps you need to load some data into it because you’re using a worksheet as a reverse chronological database for sales - against all advice, might I add. Tip: don’t use Excel as a database. VBA works in Access, too.

To add a new Row 2, it really is as simple as

Rows(2).Insert

To be more precise, this accesses the Rows collection and uses the .Insert method for the second entry. .Insert pertains to many objects, but VBA interpolates you would like to insert a row when accessing the Rows collection.

If you’d like to inject several rows, you need to put the range into quotes:

Rows("2:4").Insert  'this inserts THREE rows (2, 3, and 4)

This method inserts entire rows, from Column A all the way to Column XFD or whatever your rightmost column is. While this is the guessable method because it’s simple, simplicity is not the only method or even the preferred method for all use cases.

The Table Row

In spreadsheet terminology, “row” can be, believe it or not, a somewhat nebulous term. While Rows(1).Insert does indeed insert a row, this type of row spans the entire worksheet. This method isn’t all that useful if you only want to change part of a table or if you have two tables side-by-side and you only want to target one of them.

Let’s say you use a UserForm to gather data about orders, then have two subroutines that run: one injects new orders into the left table, while the other changes the inventory table on the right. Rows.Insert will not produce the desired result here because you don’t want to shift rows in the inventory table on the right while updating the order table on the left.

To target a row within a table, you can target the top row of the table using the range in two ways. One way is specify the columns and rows in your statement:

Sub InsertRow()
Range("A2:E2").Rows.Insert      'target the row directly
End Sub

In fact, you could even drop the .Rows part from this and get the same result, because Excel understands this range is indeed a single row.

Alternatively, if you prefer to use relative locations:

Sub InsertRow2()
Range("A1:E2").Rows(2).Insert   'target the second row in the range A1:E2
End Sub

The second method is useful if you already have a named range for the table or have a looping process. This version does indeed require the .Rows part to specify which part of the range to change. Otherwise, Excel wouldn’t know whether you wanted to insert rows or columns.

With all the macro examples in this section, we’re not inserting an entire row across your whole spreadsheet, like we did in our first example. We’re simply inserting cells in a row within a defined range.

Make powerful macros with our free VBA Developer Kit

The Shift

The .Insert method takes two optional inputs: Shift and CopyOrigin. Since they’re optional you don’t need to use them, but they can be useful in some instances.

If you’re targeting a range, such as the first row of the Inventory table, normally you would shift the cells down. However, you can also shift the targeted cells to the right. This is precisely why Excel asks this question:

Excel GUI Prompt for How to Shift after Insert Cells

In most cases, you’ll probably be using xlShiftDown, which is the default for .Insert when referring to rows. However, sometimes you might want to copy to the right, say for a visual check after the subroutine runs:

Range("H2:J2").Insert xlShiftToRight

This will produce the following result, where the range H2:J2 was inserted and the original values were moved to the right:

Cells Shifted to Right

The other optional parameter chooses where to copy the format of the inserted cells from. The default is xlFormatFromLeftOrAbove. In our table example, if we insert at "A2:E2", we copy the cell formatting from "A1:E1". Since this is our header, the inserted cells are initially set as bolded font. In order to ensure we have non-bold font, you should explicitly specify the CopyOrigin parameter:

Range("A2:E2").Insert CopyOrigin:=xlFormatFromRightOrBelow

This ensures that the inserted cells use the format of the cells below the range before the insertion instead of what’s above (the header format).

The Entire Row Property

The Excel GUI prompt above also allows you to insert an Entire Row. From our example earlier, this would affect the order table on the left and all other cells on the sheet, including the inventory table on the right. It’s equivalent to the Guessable Method, except the initial reference is a range of cells rather than the Rows collection directly.

To replicate the GUI’s Insert Entire Row from this example, you’ll add the the EntireRow property of the Range object:

Range("H2:J2").EntireRow.Insert

This is most useful if you only have a cell location (especially a relative location, so you don’t know the true location) and you want to insert a full row.

Conclusion

Now you can insert rows across the entire sheet or only for specific ranges using VBA. In the latter case, you can now also choose whether to shift the cells down or to the right of the newly-inserted cells. And finally, you can choose the format of the new cells from the surrounding, existing cells.

You also learned a little about the EntireRow property, which can be useful in same instances, especially when programming complex macros where you don’t know the exact cell reference.

How To Use VBA GetAttr To Gather File Information

Sat, 12 Jun 2021 07:00:00 +0000

Sometimes you may find it useful to know basic file attributes of the files or filepaths with which you’re interacting. If you read and then write back to a file, it’s important to know if the original is read-only, in which case your write will fail, or if it’s a system file, in which case the write will probably also fail but if it succeeds, you could damage the system. Other times, you may just want to check that a string indeed points to a valid file or a directory.

The VBA GetAttr function will, unsurprisingly, return basic attributes of a file. Keep in mind, this is a function so it outputs a value; it is not a property of a file object! You cannot write to GetAttr to change the attributes of a file. Likewise, you can’t use this function to make files read-only or hide files.

GetAttr works in a rather clever way, so we’ll outline bitwise operations to help our understanding. Don’t worry, though, you can skip that section if you prefer.

The Possible Attributes
The Output
Unmixing Attributes
Decomposing Bitwise AND

The Possible Attributes

There are 7 possible attributes and more than one may be true for a given filepath, though there are some mutually exclusive ones.

Here are the attributes, straight from the Microsoft documentation (literally - this is their table):

Constant	Value	Description
vbNormal	0	Normal.
vbReadOnly	1	Read-only.
vbHidden	2	Hidden.
vbSystem	4	System file. Not available on the Macintosh.
vbDirectory	16	Directory or folder.
vbArchive	32	File has changed since last backup. Not available on the Macintosh.
vbAlias	64	Specified file name is an alias. Available only on the Macintosh.

The first column is the VBA name, which is a human-understandable name for each of the constants in the second column. In your macros, you can use the vbXX name interchangeably with the number itself.

The Output

So what exactly does the GetAttr function output? The only output is a single integer value equal to the sum of all the true attributes. Whichever attribute is true for your particular input will appear in the function output.

The simplest case is one where the file satisfies only one attribute. Let’s say myFile is hidden and this is the only attribute from the above list. Then the statement GetAttr(myFile) will evaluate to 2.

Slightly more complicated is a hidden system file. Here we have to include 4 and 2 in the sum, so the output is 6: GetAttr(myFile) = vbHidden + vbSystem = 6.

What’s the value for a hidden directory? vbHidden + vbDirectory = 2 + 16 = 18. A hidden read-only system file? vbReadOnly + vbHidden + vbSystem = 7.

The reason the numbers are successive powers of 2 is twofold: every combination of attributes will always give a unique number and the mechanics of binary addition make bitwise operation easier.

This clever technique means multiple attributes can be represented by a single number without losing any information, like multiple dimensions collapsing into one.

Make powerful macros with our free VBA Developer Kit

Unmixing Attributes

You could look at a table of all of the possible outputs and know which attributes are present. However, most of the time we are only interested in one attribute. Possible values for read-only inputs are 1, 3, 5, 35, and others. But it would be cumbersome to test each of these. To make it easier, we can rely on the cleverness of binary bitwise operations.

To see whether a particular attribute is present, you’ll need to use the AND operator and set the resulting value to an integer:

iReadOnly = GetAttr(myFile) And vbReadOnly

If the output is zero, vbReadOnly is not an attribute of this file. If the output is anything other than zero, vbReadOnly is present. Here’s a full macro example to test the read-only attribute using a VBA If-Then statement:

Sub VBA_GetAttr_Demo()
Dim myFile As String
Dim iReadOnly As Integer
myFile = "C:\Users\Public\MySpreadsheet.xlsm"
iReadOnly = GetAttr(myFile) And vbReadOnly
If iReadOnly <> 0 Then
    'File is read-only
Else
    'File is not read-only
End If
End Sub

To drive the message home, let’s run through a second example to test whether a a path is a directory or a file:

Sub VBA_GetAttr_Demo_Dir()
Dim myPath As String
Dim iDir As Integer
myPath = "C:\Users\Public"
iDir = GetAttr(myPath) And vbDirectory
If iDir <> 0 Then
    'A directory was selected
Else
    'Not a directory
End If
End Sub

This will work whether or not you have trailing slash at the end of your file path.

Testing is as easy as that. To use GetAttr you don’t need any more information, but if you’re curious how we can break down the sum, read the next section.

Decomposing Bitwise AND

So how can we test whether a number is really part of the sum? By using bitwise AND.

Every number in computing is represented by a string of bits, which can be on/true or off/false, usually represented as 1 and 0, respectively. There are two operations we can do with these bits, AND and OR, which come from mathematical logic. For this article, the important point is that both sides of an AND operation must be true/on/1 for the output to be 1. If one or both sides is false/off/0, then the output is 0.

When we look at the bitstring representation of 2, we get 10. Leading zeros can be added indefinitely, so 10 = 00000010 = 0010. The important part is the trailing zeros (and 1s).

The bitstring representation of 4 is 100 and 8 is 1000. It is best to read these as “one zero zero” and “one zero zero zero” rather than “one hundred”, “one thousand”, etc. 6 is 2 + 4, or 110 = 010 + 100. Here are the bitstrings of the attribute values above:

00 = 0000000
     6543210 <-- raise 2 to this power if 1 appears in the column
01 = 0000001
02 = 0000010
04 = 0000100
08 = 0001000
16 = 0010000
32 = 0100000
64 = 1000000

Because each value in the table above is a power of 2, all bits in the bitstring representation will be zero except one of them. For this reason, adding any of these numbers together will never “flip a bit” and carry over to the next column, as each number is fully represented in its own column.

To see whether 4 is “part of” 6, we can check whether each 1-bit in 4 has a corresponding 1-bit in 6. Remember this is bitwise operation, so we need to go column-by-column:

06 = 0000110
  AND
04 = 0000100
xx = 0000100 <-- bitwise output where bits in top and bottom row are BOTH 1

In the 3rd column from the right, which is four’s designated column, we have a 1-bit in 6. The bitwise AND operator output produces a non-zero number, and hence 4, vbSystem, is part of 6. If we have 14 (2 + 4 + 8), can you work out how the calculations look to determine whether vbArchive is present?

This trick does not work if the possible inputs for the sum are not powers of 2.

The VBA GetAttr function provides information about the attributes of a file using a summation technique that provides a unique number for each combination of attributes. Again, the VBA GetAttr function is a function, not a file property, so you can’t use it to change file attributes. You can only use it to determine which file attributes are present.

Whether a particular attribute is present can be determined using the bitwise AND operator. Bitwise operations go bit-by-bit rather than taking the bitstring as a whole, and the gaps in the decimal representation of the attributes make bitwise AND able to detect whether an attribute is true or not.

Bitwise operations can be complicated, but the GetAttr function, and VBA in general, don’t have to be. If you want to learn VBA without all the unnecessary coding complications, subscribe using the form below. We’ll walk you through a free step-by-step training program to making mastering VBA a breeze.

The VBA Tutorials Blog

How to Autofill Using Excel VBA

What is Autofill?

How to Use Autofill in Excel VBA

Example 1: How to Autofill Using Excel VBA

Example 2: Fill a range with the same value

Example 3: Fill a range with a series of values

Example 4: Fill a range with formulas

How to use the VBA NPV Function

Using the NPV Function with an Array

Using the NPV Function with a Loop

FormulaR1C1 Makes Relative References in VBA Easy

Connecting R1C1 to Past Experiences

The Power of R1C1

Types of R1C1 Reference

Absolute References

Relative References

Mixed References

Lock Rows and Lock Columns with R1C1

Variable R1C1 References

Modeling Variable Client Closing Times

The Setup

The Code

The Result

Use VBA Range.Find to Search and Retrieve Data

The Method and the Range

An Essential Test

Why Use .Find at all?

Range.Find Parameters

What

After

LookIn

LookAt

SearchOrder

SearchDirection

MatchCase and MatchByte

SearchFormat

Using the Return Value

Finding all matches

VBA AdvancedFilter with Multiple Criteria

The Target Range

The Criteria Range

Filtering on Multiple Criteria

AdvancedFilter with AND vs OR

AdvancedFilter with Intervals

The Output Range

Using XlFilterInPlace

Using XlFilterCopy

Clear Your CopyToRange

Taking It Further

VBA Sgn Function to Check for Positive or Negative Numbers

VBA Sgn Function Example Macro

How to Filter a Column with VBA AutoFilter

The Filter Range

A Word on Terminology

The Field Parameter

Defining the Filter Criteria

Filter For a String

Filter For Multiple Strings

Filter For Values

Special Filters

Leverage User Input

Clearing Filters

VBA Filter Unique Values with AdvancedFilter

Setting the Range

Unique Values Across Multiple Columns

Output in the Same Place or a New One?

The Action Parameter

CopyToRange Parameter

Finding Unique Values

Is the Original Unique? Full Code

VBA Insert Rows on Worksheets and Tables

The Guessable Method

The Table Row

The Shift

The Entire Row Property

Conclusion

How To Use VBA GetAttr To Gather File Information

The Possible Attributes

The Output

Why Use `.Find` at all?

Using `XlFilterInPlace`

Using `XlFilterCopy`

Clear Your `CopyToRange`

The `Field` Parameter

The `Action` Parameter

`CopyToRange` Parameter