Excel VBA performance of worksheetfunction vs code, for arrays - excel

Question

In a quest to speed up my VBA code I searched for methods online. A lot of methods pass by, and one of them that keeps returning seems to be to use worksheetfunctions in stead of code, where possible.
My experience however is contrary to that tip. I find that worksheetfunctions tend to be slower than my code. My simple test below shows that the code is about twice faster than the worksheetfunction. I found the same results with other functions, like MATCH.
My question is then, do you VBA'ers tend to use code or worksheetfunctions? Are there reasons to use the functions over code (besides the couple of lines of extra code)?
Sub testSum()
Dim testarray(0 To 10000) As Variant
Dim val As Variant
Dim valSum As Variant
Dim i As Long, j As Long
Dim t As Single
' create testarray
For i = 0 To 10000
testarray(i) = Rnd
Next
For i = 0 To 10000 Step 100
testarray(i) = "text"
Next
' measure code
t = Timer
For j = 1 To 10000
valSum = 0
For Each val In testarray
If IsNumeric(val) Then valSum = valSum + val
Next
Next
Debug.Print "Array: ", Int(valSum), Timer - t
' measure function
t = Timer
For j = 1 To 10000
valSum = 0
valSum = Application.WorksheetFunction.Sum(testarray)
Next
Debug.Print "Sum: ", Int(valSum), Timer - t
End Sub

Answer 1

I prefer to use the worksheet function in the worksheet. Measuring the function in the macro is an unfair test as the VBA environment must switch to the Excel environment to get the results and this adds an overhead that does not exist otherwise.
As a general coding rule, my priorities are:
use Native Excel formulas, including setting up helper cells or
columns.
use VBA with arrays
use VBA with ranges
As a test:
set up 10,000 rows with random numbers
set up your formula in one cell (B1) =Sum(A1:A10000)
select B1 and calculate the cell
Set up a macro - the below is a quick and dirty based on your code above - it could be neater by using properly qualified ranges and Option Explicit.
Sub TestNativeSpeed()
Dim j As Long
Dim t As Single
t = Timer
For j = 1 To 10000
Range("B1").Dirty
Next
Debug.Print "Native Sum: ", Int(Range("B1").Value), Timer - t
End Sub
I set up my cells with the formula =Rand() and I got the results (single run only):
Native Sum: 4990 16.53125
I reset them to values only (consistent with your code) and I got the results (single run only):
Native Sum: 4990 1.765625
I ran your code and got (single run only):
Array: 4917 4.386719
Sum: 4917 27.73438
What the above shows is that Native Excel is usually the fastest and most efficient approach. But arrays (where it doesn't have to keep switching between the VBA and Excel models) are the next in line in terms of efficiency.

Answer 2

I almost exclusively use code.
It's probably an issue, but I hate using functions because I find that I always have to go back and edit bits and it just gets confusing, where I can just mess around with one Sub if I'm using code.
To answer your code, I would likely say just use arrays to sum - that'll shed a few picoSeconds
Try and use Code Review to get those brainiacs to improve on your speeds