Vba excel массивы range

Using the shape of the Range

Another approach in creating a function for ArrayFromRange would be using the shape and size of the Range to determine how we should structure the array. This way we don’t have to load the data into an intermediate array to determine the dimension.

For instance, if the target range is only one cell, then we know we want to return an array with the single value in it Array(target.value).

Below is the complete function that should deal with all cases. Note, this uses the same technique of using the Application.Transpose method to reshape the array.

' Helper function that returns an array from a range with the
' correct dimensions. This fixes the issue of single values
' not returning as an array, and when a 2 dimension array is returned
' when it only has 1 dimension of data.
'
' @author Robert Todar <robert@roberttodar.com>
Public Function ArrayFromRange(ByVal target As Range) As Variant
    Select Case True
        ' Single cell
        Case target.Cells.Count = 1
            ArrayFromRange = Array(target.Value)
            
        ' Single Row
        Case target.Rows.Count = 1
            ArrayFromRange = Application.Transpose( _
                Application.Transpose(target.Value) _
            )
        
        ' Single Column
        Case target.Columns.Count = 1
            ArrayFromRange = Application.Transpose(target.Value)
            
        ' Multi dimension array
        Case Else
            ArrayFromRange = target.Value
    End Select
End Function

Testing the ArrayFromRange function

As a bonus, here are the tests that I ran to check that this function works.

' @requires {function} ArrayDimensionLength
' @requires {function} ArrayCount
Private Sub testArrayFromRange()
    ' Setup a new workbook/worksheet for
    ' adding testing data
    Dim testWorkbook As Workbook
    Set testWorkbook = Workbooks.Add
    Dim ws As Worksheet
    Set ws = testWorkbook.Worksheets(1)
    
    ' Add sample data for testing.
    ws.Range("A1:A2") = Application.Transpose(Array("A1", "A2"))
    ws.Range("B1:B2") = Application.Transpose(Array("B1", "B2"))
    
    ' This section will run all the tests.
    Dim x As Variant
    
    ' Single cell
    x = ArrayFromRange(ws.Range("A1"))
    Debug.Assert ArrayDimensionLength(x) = 1
    Debug.Assert ArrayCount(x) = 1
    
    ' Single Row
    x = ArrayFromRange(ws.Range("A1:B1"))
    Debug.Assert ArrayDimensionLength(x) = 1
    Debug.Assert ArrayCount(x) = 2
    
    ' Single Column
    x = ArrayFromRange(ws.Range("A1:A2"))
    Debug.Assert ArrayDimensionLength(x) = 1
    Debug.Assert ArrayCount(x) = 2
    
    ' Multi Column
    x = ArrayFromRange(ws.Range("A1:B2"))
    Debug.Assert ArrayDimensionLength(x) = 2
    Debug.Assert ArrayCount(x) = 4
    
    ' Cleanup testing environment
    testWorkbook.Close False
    
    ' Print result
    Debug.Print "testArrayFromRange: PASS"
End Sub

Helper functions for the tests

In my tests I used two helper functions: ArrayCount, and ArrayDimensionLength. These are listed below for reference.

' Returns the length of the dimension of an array
'
' @author Robert Todar <robert@roberttodar.com>
Public Function ArrayDimensionLength(sourceArray As Variant) As Integer
On Error GoTo catch
    Do
        Dim currentDimension As Long
        currentDimension = currentDimension + 1
        
        ' `test` is used to see when the
        ' Ubound throws an error. It is unused
        ' on purpose.
        Dim test As Long
        test = UBound(sourceArray, currentDimension)
    Loop
catch:
    ' Need to subtract one because the last
    ' one errored out.
    ArrayDimensionLength = currentDimension - 1
End Function

' Get count of elements in an array regardless of
' the option base. This Looks purely at the size
' of the array, not the contents within them such as
' empty elements.
'
' @author Robert Todar <robert@roberttodar.com>
' @requires {function} ArrayDimensionLength
Public Function ArrayCount(ByVal sourceArray As Variant) As Long
    Dim dimensions As Long
    dimensions = ArrayDimensionLength(sourceArray)
    
    Select Case dimensions
        Case 0
            ArrayCount = 0
        
        Case 1
            ArrayCount = (UBound(sourceArray, 1) - LBound(sourceArray, 1)) + 1
        
        Case Else
            ' Need to set arrayCount to 1 otherwise the
            ' loop will keep multiplying by zero for each
            ' iteration
            ArrayCount = 1
           
            Dim dimension As Long
            For dimension = 1 To dimensions
                ArrayCount = ArrayCount * _
                    ((UBound(sourceArray, dimension) - LBound(sourceArray, dimension)) + 1)
            Next
    End Select
End Function

VBA Arrays And Worksheet Ranges

This page describes how to transfer data between VBA arrays and worksheet ranges.

Data transfer between worksheet cells and VBA variables is an expensive operation
that should be kept to a minimum. You can considerably increase the performance of your Excel application
by passing arrays of data to the worksheet, and vice versa, in a single operation rather
than one cell at a time. If you need to do extensive calculations on data in VBA,
you should transfer all the values from the worksheet to an array, do the calculations
on the array, and then, possibly, write the array back to the worksheet. This keeps the number
of times data is transferred between the worksheet and VBA to a minimum. It is far more
efficient to transfer one array of 100 values to the worksheet than to transfer 100 items at a time.

This page shows you how to transfer data between worksheet cells and VBA ararys.
You will find that with large amounts of data being transferred between the
worksheet and the array, working with the array is much faster than working
directly with worksheet cells.

It is very simple to read a range on a worksheet and put it into an array
in VBA. For example,

Dim Arr() As Variant 
Arr = Range("A1:C5")

When you bring in data from a worksheet to a VBA array, the array is always
2 dimensional. The first dimension is the rows and the second dimension is
the columns. So, in the example above, Arr is implicitly sized as
Arr(1 To 5, 1 To 3) where 5 is the number of rows and
3 is the number of columns. A 2 dimensional array is created even if the worksheet data
is in a single row or a single column (e.g, Arr(1 To 10, 1 To 1)).
The array into which the worksheet data is loaded always has an lower bound
(LBound) equal to 1, regardless of what Option Base
directive you may have in your module. You cannot change this behavior. For example,

Dim Arr() As Variant
Arr = Range("A1:A10")

Here, Arr is dimensioned automatically by VBA as Arr(1 to 10,
1 To 1).

You can use code like the following to loop through the array of the worksheet values:

Dim Arr() As Variant
Arr = Range("A1:B10")
Dim R As Long
Dim C As Long
For R = 1 To UBound(Arr, 1) 
    For C = 1 To UBound(Arr, 2) 
        Debug.Print Arr(R, C)
    Next C
Next R

There is a special case when the range on the worksheet is a single cell. Expanding on the code above,
you should use the code below if it is possible that the range is a single cell:

Dim Arr() As Variant
Dim RangeName As String
Dim R As Long
Dim C As Long
Dim RR As Range

RangeName = "TheRange"
Set RR = Range(RangeName)
If RR.Cells.Count = 1 Then
    ReDim Arr(1 To 1, 1 To 1)
    Arr(1, 1) = RR.Value
Else
    Arr = Range(RangeName)
End If

Once you have calculated an array with the appropriate values, you
can write it back to the worksheet. The array may be 1 or 2 dimensional.

To write a one dimensional array back to the worksheet, you must create a
Range object, resize that range to the size of your
array, and then write to the range.

Suppose we have a one dimensional array and want to write that out to the worksheet starting
at cell K1. The code must first resize the destination range. For
example,

Dim Destination As Range
Set Destination = Range("K1")
Set Destination = Destination.Resize(1, UBound(Arr))
Destination.Value = Arr

This code will write the values of Arr to range that is
one row tall by UBound(Arr) columns wide, starting at
range K1. If you want the results passed to a range that is
one column wide spanning several rows, use code like the following to resize the range
and set the values.

Dim Destination As Range
Set Destination = Range("K1")
Set Destination = Destination.Resize(UBound(Arr), 1)
Destination.Value = Application.Transpose(Arr)

NOTE that the parameters to Resize are reversed and that
the array Arr is transposed before being written to the worksheet.

If you have a 2 dimensional array, you need to use Resize to
resize the destination range to the proper size. The first dimension is the number of rows
and the second dimension is the number of columns. The code below illustrates writing an array
Arr out to the worksheet starting at cell K1.

Dim Destination As Range
Set Destination = Range("K1")
Destination.Resize(UBound(Arr, 1), UBound(Arr, 2)).Value = Arr

You can transpose the array when writing to the worksheet:

Set Destination = Range("K1")
Destination.Resize(UBound(Arr, 2), UBound(Arr, 1)).Value = Application.Transpose(Arr)

Here, the parameters to Resize are reversed and the array
Arr is transposed.

When you read from a worksheet to an array variable, VBA will automatically size
the array to hold the range on the worksheet. You don’t have to concern yourself
with sizing the array. However, when writing an array from VBA to the worksheet,
you must resize the destination range to hold the array. We saw this earlier in
the examples. Basically, you use code like the following.

Dim NumRows As Long
Dim NumCols As Long
NumRows = UBound(Arr,1) - LBound(Arr,1) + 1
NumCols = UBound(Arr,2) - LBound(Arr,2) + 1
Set Destination = Range("K1").Resize(NumRows, NumCols).Value = Arr

If the array being passed to the worksheet is smaller than the Range to which it is written, the
unused cells get a #N/A error. If the array being passed is larger than
the range to which it is written, the array is truncated on the right or bottom to fit the range.

As you’ve seen in the examples, passing array between the worksheet and VBA is really quite simple. Used correctly,
the code snippets above can have a strong effect on increasing the performance of your VBA application.

This page last updated: 13-September-2012.