Redim Preserve Inside Loop

[IvenBach]

Consider:

Dim foo()
'...
Do
    Redim Preserve foo(UBound(foo) + 1)
    foo(UBound(foo)) = n
    '...
While {condition}

Rubberduck should point out that the redimensioning is inefficient and excessive, and suggest using a Collection instead of an array, if the number of elements isn't known from the start.

[mistresseve666]

Eh, in my experience it depends.

While yes, reallocating by +1 is slower than creating a Collection or System.Collections.ArrayList you can redim smartly (e.g. start with a certain size, double as needed, then shrink to size maximum used index).

The big benefit of using arrays, however, is that it is almost 10x faster to access an index in an array than it is to access an item in a collection. And nearly infinitely larger if you have to iterate over the entire array/collection.

Because of this, if you plan on reading more than writing (e.g. one-time array creation) then arrays are almost always faster.

If any inspection is added, at most, Rubberduck should say unnecessary redimensioning can be expensive. It's ultimately up to the author to ensure their code is optimized and Rubberduck can't possible know what the intentions are by seeing Redim Preserve foo(UBound(foo) + 1).

-robodude666

[retailcoder]

The problem isn't with doubling capacity, or any other "smart" resizing; the problem is with Redim Preserve foo(UBound(foo) + 1), and indeed the goal here is merely to suggest something, to point out the potential performance issue. I don't see an automated quickfix for that one.

[retailcoder]

Also 80% of the inefficient array code is going to be resizing at every iteration while populating values... from a Range - if we can spot that, then we could suggest a 2D variant array and outright eliminating the loop.

[mistresseve666]

So spot

Redim Preserve foo(UBound(foo) + 1)

but not

Redim Preserve foo(UBound(foo) + 2) ' or + 5?

? Where do you draw the line between when a ReDim Preserve should be suggested or not?

[retailcoder]

We're trying to flag the common scenarios. +1 is the most common by far. Code that's doing +2 or +5 is doing that for reasons I cannot fathom, so I wouldn't flag anything. But clearly code that's resizing at +1 at every iteration, is doing it wrong - and if there's a way we can somehow statically detect that the array size should be known from the start, ...we need to pop clippy or something.

[retailcoder]

Adding [discussion] - this inspection is desirable, but its specifications need to be clarified.

[mistresseve666]

👍

@retailcoder fair enough. I can see the case where if the code is redimming +1 that the author may not know better, so offering an inspection to point out the repercussions is good to have.

[IvenBach]

Can there be a separate inspection for +1 and +2(or more) that way you can different messages?

[retailcoder]

Where does it end though? I think we should make inspections as general as possible, e.g. "array resized in loop scope", and then the inspection can eventually be configured with various thresholds - there's already a number of inspections for which I can imagine a number of possible options/configurations.

[IvenBach]

True and well said.