Public Sub arrayMatchv3()
I like that the procedure is explicitly
Public. Unlike a lot of other languages - including VB.NET, in VBA a member is public unless specified otherwise; being explicit is a good thing. I don't see
Option Explicit atop your procedure, but I have it in my IDE and it compiles with it, so kudos for declaring all your variables!
If you're not specifying
Option Explicit, you have to know that the slightest typo in a variable's name will make VBA "declare" an implicit
Variant variable on-the-spot to receive the value you're assigning to what you intended to be that local variable you just declared: VBA happily compiles with undeclared identifiers, which inevitably will cause bugs that will be hard to find. With
Option Explicit specified, the compiler will choke on a typo, finding them for you in a split second.
Member names in VBA should be
PascalCase, so that the API you're writing feels like the API you're using when you write VBA code: the entire Excel object model, the VBA standard library, the scripting runtime library - pretty much every single VBA API out there, they all expose modules, classes, procedures, functions, properties, constants, enums, events, etc. - all in
I like that you're using
camelCase for your locals though; I find it makes the code feel a bit easier to read, and I do it myself.
The name isn't ideal: "array match v3" is a noun - it's an "array match"... nouns make excellent module/class names:
Application. Procedures do something, they're verbs. If the procedure matches arrays then
MatchArray would be a better name.
I see you're having a version number in the name: this supposes there's an
arrayMatchv2 somewhere, and then an
arrayMatch procedure not too far. If not, then just remove the
Otherwise, you're storing versioning metadata in the code base itself - which is clutter: if
arrayMatch usages have been replaced by references to
arrayMatchv2, you now have as many places to revisit in the code to make sure it's now calling
arrayMatchv3. If v3 fixed a bug in v2, your code base still has the bug even though v3 fixed it.
If you need versioning, use source control. You can create a repository on GitHub, and then use a tool such as Rubberduck to commit, revert, push, pull, create branches and merge them, straight from a docked toolwindow in the IDE. And then you can use GitHub to view any version, or git to fetch any specific version.
I guess that covers the method's signature =)
User input and responsibilities
it is working well as far as I have been able to test it
To the outside world, the procedure is a complete black box: it takes no input and returns no value. Beyond the name and without peeking at the source code, we have no idea what's happening in there when we read the calling code.
Application.InputBox is called 4 times: there are 4 user inputs happening. By telling the outside world "I need 4
Range parameters to do my thing", the procedure's signature would already be telling us a lot more.
Collecting user input is a concern in its own right. All kinds of wild things can happen when a user gets involved. They can ESC out, or X-out of your dialogs, make typos, enter illegal values - many things can go wrong when a user needs to get involved.
Set workingCell = Application.InputBox("Select the first cell of your comparison column.", Type:=8)
workingLastRow = workingCell.End(xlDown).Row
workingCell.End here means the program dies with a runtime error if you (/the user) X-out or otherwise cancel the
workingCell.End(xlDown) will stop at the first blank cell it finds: if the row can contain blank cells, your
workingLastRow will not be the actual last row in the selected column. A more reliable way would be to start at the last row in
workingCell's column, and go
xlUp from there instead:
workingLastRow = .Cells(.Rows.Count, workingCell.Column).End(xlUp).Row
Take the collect user input concern out of the procedure: use parameters, and make it the caller's responsibility to figure out how to get that input - with an
InputBox... or perhaps just any arbitrary set of
Range objects. Don't trust the input: either raise a descriptive error, or exit early if the input isn't valid (e.g. if any parameter is
Except... but we aren't actually working with
Range objects - what we really want is a
returnArray... and we return a
Dictionary. 4 parameters and a return value: the
Sub becomes a
Function, and the inputs and outputs become much clearer already. The fact that you felt the need to split it up in the OP speaks a lot about this concern, too.
At this point things are starting to shape up:
- A function to collect user input; validates and returns a
- A function that takes a
Range and returns an array
- A function that takes input arrays and returns a
- A procedure that takes a
Dictionary and writes to a specified
- A procedure that coordinates all those
By simply splitting things up and tightening variable lifetimes and scopes, and passing and returning objects and arrays, we've made it much easier to write code that can test various valid and invalid inputs and document how things behave... and automated tests are much more reliable than ad-hoc F5-debug testing.
Bugs & Assumptions
Your code is making a bad assumption here, can you spot it?
workingArray = Range(.Address, Left(.Address, Len(.Address) - 1) & workingLastRow)
Range is implicitly referring to the active worksheet: the unqualified call will throw an error if the active sheet is a chart! You should be using
.Parent.Range to qualify the
Range method call with a specific worksheet, so that the active sheet isn't an implicit dependency.
But there's another bug: that -1 is assuming
.Row is less than 10, i.e. that the row number in the
.Address string is 1 single digit. If the user selects anything between rows 10 and 19, the
workingArray will be 100 rows too tall; if the user selects anything between rows 20 and 29, it's 200 rows you don't need, that enter the working array, and become useless iterations here:
For i = LBound(workingArray, 1) To UBound(workingArray, 1)
It's not clear from just reading the code, but I also suspect the code assumes
targetCell are on the same row, on the same sheet:
targetArray = Range(.Address, Left(.Address, Len(.Address) - 1) & workingLastRow)
If the two user selections aren't on the same row, then the
targetArray can be missing values: it would probably be a good idea to validate that, or make the procedure fail instead of producing wrong results; that could be caught and handled in the function responsible for collecting user input. If you know that an input value is already validated, you can
Debug.Assert a precondition, and the code will only ever come to a halt if the assertion fails:
Debug.Assert Not workingCell Is Nothing
Debug.Assert Not targetCell Is Nothing
Debug.Assert workingCell.Parent = targetCell.Parent
Debug.Assert workingCell.Row = targetCell.Row
Seeing that at the top of a procedure that takes
workingCell As Range and
targetCell As Range parameters makes it pretty crystal-clear what the assumptions are, and allows the reader/maintainer to say "mismatching working and target rows? impossible!"