IsArray Function

Returns a Boolean value indicating whether a variable is an array.

Syntax

IsArray(varname)

Parameters

varname (Required): Variable name to test

Return Value

Returns a Boolean: - True if the variable is an array - False if the variable is not an array - True for both fixed-size and dynamic arrays - True even for unallocated dynamic arrays (dimensioned but not ReDim-med)

Remarks

The IsArray function is used to determine whether a variable is an array: - Returns True for any array variable, regardless of dimensions - Returns True for dynamic arrays even before they're allocated with ReDim - Returns False for all non-array variables - Useful when working with Variant variables that might contain arrays - Often used with ParamArray parameters to validate input - Can be used with the Array function result - Returns True for arrays passed as Variant parameters - Returns True for arrays stored in Variant variables - Commonly used in procedures that accept flexible data types - Important for validating function arguments

Typical Uses

Parameter Validation: Verify that a Variant parameter contains an array Data Type Detection: Determine if a Variant holds array data ParamArray Handling: Check individual elements of ParamArray Dynamic Programming: Handle different data types in generic routines Array Processing: Validate data before array operations Error Prevention: Avoid runtime errors by checking array status Flexible Functions: Create functions that accept both single values and arrays Type Checking: Part of comprehensive type validation routines

Basic Usage Examples

' Example 1: Simple array check
Dim myArray(1 To 10) As Integer
Dim myValue As Integer
If IsArray(myArray) Then
    Debug.Print "myArray is an array"  ' This prints
End If
If IsArray(myValue) Then
    Debug.Print "myValue is an array"
Else
    Debug.Print "myValue is not an array"  ' This prints
End If

' Example 2: Checking Variant contents
Dim myVariant As Variant
myVariant = Array(1, 2, 3, 4, 5)
If IsArray(myVariant) Then
    Debug.Print "Variant contains an array"  ' This prints
End If
myVariant = 42
If IsArray(myVariant) Then
    Debug.Print "Variant contains an array"
Else
    Debug.Print "Variant does not contain an array"  ' This prints
End If

' Example 3: Dynamic array before ReDim
Dim dynamicArray() As String
If IsArray(dynamicArray) Then
    Debug.Print "Dynamic array variable is an array"  ' This prints even before ReDim
End If

' Example 4: Validating function parameters
Function ProcessData(data As Variant) As Long
    If IsArray(data) Then
        ProcessData = UBound(data) - LBound(data) + 1
        Debug.Print "Processing array with " & ProcessData & " elements"
    Else
        ProcessData = 1
        Debug.Print "Processing single value"
    End If
End Function
' Usage
Dim result As Long
result = ProcessData(Array(1, 2, 3, 4, 5))  ' Prints: Processing array with 5 elements
result = ProcessData(100)                    ' Prints: Processing single value

Common Patterns

' Pattern 1: Validate array parameter
Function SumValues(values As Variant) As Double
    Dim i As Long
    Dim total As Double
    If Not IsArray(values) Then
        Err.Raise 5, , "Parameter must be an array"
    End If
    For i = LBound(values) To UBound(values)
        total = total + values(i)
    Next i
    SumValues = total
End Function

' Pattern 2: Handle single value or array
Sub DisplayData(data As Variant)
    Dim i As Long
    If IsArray(data) Then
        For i = LBound(data) To UBound(data)
            Debug.Print "Item " & i & ": " & data(i)
        Next i
    Else
        Debug.Print "Single value: " & data
    End If
End Sub

' Pattern 3: Convert single value to array if needed
Function EnsureArray(value As Variant) As Variant
    If IsArray(value) Then
        EnsureArray = value
    Else
        EnsureArray = Array(value)
    End If
End Function

vb ' Pattern 4: Count array elements safely Function GetElementCount(data As Variant) As Long If IsArray(data) Then GetElementCount = UBound(data) - LBound(data) + 1 Else GetElementCount = 1 End If End Function

```vb
' Pattern 5: Validate before array operation
Function GetFirstElement(arr As Variant) As Variant
    If Not IsArray(arr) Then
        GetFirstElement = arr
        Exit Function
    End If
    If UBound(arr) >= LBound(arr) Then
        GetFirstElement = arr(LBound(arr))
    Else
        GetFirstElement = Null
    End If
End Function

' Pattern 6: Type checking with IsArray
Function DescribeVariable(v As Variant) As String
    If IsArray(v) Then
        DescribeVariable = "Array with " & (UBound(v) - LBound(v) + 1) & " elements"
    ElseIf IsNumeric(v) Then
        DescribeVariable = "Numeric value: " & v
    ElseIf IsDate(v) Then
        DescribeVariable = "Date value: " & v
    ElseIf IsNull(v) Then
        DescribeVariable = "Null value"
    ElseIf IsEmpty(v) Then
        DescribeVariable = "Empty variant"
    Else
        DescribeVariable = "String or object: " & v
    End If
End Function

' Pattern 7: ParamArray validation
Sub ProcessItems(ParamArray items() As Variant)
    Dim i As Long
    For i = LBound(items) To UBound(items)
        If IsArray(items(i)) Then
            Debug.Print "Item " & i & " is an array"
        Else
            Debug.Print "Item " & i & ": " & items(i)
        End If
    Next i
End Sub

' Pattern 8: Safely iterate over data
Sub SafeIterate(data As Variant)
    Dim i As Long
    If IsArray(data) Then
        For i = LBound(data) To UBound(data)
            ProcessValue data(i)
        Next i
    Else
        ProcessValue data
    End If
End Sub

' Pattern 9: Flatten nested arrays
Function FlattenArray(arr As Variant) As Variant
    Dim result() As Variant
    Dim i As Long
    Dim count As Long
    If Not IsArray(arr) Then
        ReDim result(0 To 0)
        result(0) = arr
        FlattenArray = result
        Exit Function
    End If
    count = 0
    ReDim result(0 To 100)  ' Initial size
    For i = LBound(arr) To UBound(arr)
        If IsArray(arr(i)) Then
            ' Handle nested array (recursive)
            Dim flattened As Variant
            flattened = FlattenArray(arr(i))
            ' Add flattened elements to result...
        Else
            result(count) = arr(i)
            count = count + 1
        End If
    Next i
    ReDim Preserve result(0 To count - 1)
    FlattenArray = result
End Function

' Pattern 10: Conditional array processing
Function ApplyOperation(data As Variant, operation As String) As Variant
    Dim i As Long
    Dim result As Variant
    If IsArray(data) Then
        ReDim result(LBound(data) To UBound(data))
        For i = LBound(data) To UBound(data)
            result(i) = PerformOperation(data(i), operation)
        Next i
        ApplyOperation = result
    Else
        ApplyOperation = PerformOperation(data, operation)
    End If
End Function

Advanced Usage Examples

' Example 1: Flexible data processor class
Public Class DataProcessor
    Private m_data As Variant
    Public Sub SetData(data As Variant)
        m_data = data
    End Sub
    Public Function GetCount() As Long
        If IsArray(m_data) Then
            GetCount = UBound(m_data) - LBound(m_data) + 1
        ElseIf IsEmpty(m_data) Then
            GetCount = 0
        Else
            GetCount = 1
        End If
    End Function
    Public Function GetSum() As Double
        Dim i As Long
        Dim total As Double
        If IsArray(m_data) Then
            For i = LBound(m_data) To UBound(m_data)
                If IsNumeric(m_data(i)) Then
                    total = total + m_data(i)
                End If
            Next i
        ElseIf IsNumeric(m_data) Then
            total = m_data
        End If
        GetSum = total
    End Function
    Public Function GetAverage() As Double
        Dim count As Long
        count = GetCount()
        If count > 0 Then
            GetAverage = GetSum() / count
        End If
    End Function
    Public Sub DisplayData()
        Dim i As Long
        If IsArray(m_data) Then
            Debug.Print "Array with " & GetCount() & " elements:"
            For i = LBound(m_data) To UBound(m_data)
                Debug.Print "  [" & i & "] = " & m_data(i)
            Next i
        ElseIf IsEmpty(m_data) Then
            Debug.Print "No data"
        Else
            Debug.Print "Single value: " & m_data
        End If
    End Sub
End Class

' Example 2: Generic collection converter
Public Class CollectionConverter
    Public Function ToArray(source As Variant) As Variant
        Dim result() As Variant
        Dim i As Long
        If IsArray(source) Then
            ' Already an array, just return it
            ToArray = source
        ElseIf TypeName(source) = "Collection" Then
            ' Convert collection to array
            ReDim result(1 To source.Count)
            For i = 1 To source.Count
                result(i) = source(i)
            Next i
            ToArray = result
        Else
            ' Single value, wrap in array
            ReDim result(0 To 0)
            result(0) = source
            ToArray = result
        End If
    End Function
    Public Function ToCollection(source As Variant) As Collection
        Dim result As Collection
        Dim i As Long
        Set result = New Collection
        If IsArray(source) Then
            For i = LBound(source) To UBound(source)
                result.Add source(i)
            Next i
        Else
            result.Add source
        End If
        Set ToCollection = result
    End Function
End Class

' Example 3: Safe array utilities module
Public Module ArrayUtils
    Public Function SafeUBound(arr As Variant, Optional dimension As Integer = 1) As Long
        On Error Resume Next
        If IsArray(arr) Then
            SafeUBound = UBound(arr, dimension)
            If Err.Number <> 0 Then SafeUBound = -1
        Else
            SafeUBound = -1
        End If
        On Error GoTo 0
    End Function
    Public Function SafeLBound(arr As Variant, Optional dimension As Integer = 1) As Long
        On Error Resume Next
        If IsArray(arr) Then
            SafeLBound = LBound(arr, dimension)
            If Err.Number <> 0 Then SafeLBound = 0
        Else
            SafeLBound = 0
        End If
        On Error GoTo 0
    End Function
    Public Function IsAllocatedArray(arr As Variant) As Boolean
        On Error Resume Next
        If IsArray(arr) Then
            Dim ub As Long
            ub = UBound(arr)
            IsAllocatedArray = (Err.Number = 0)
        Else
            IsAllocatedArray = False
        End If
        On Error GoTo 0
    End Function
    Public Function CombineArrays(arr1 As Variant, arr2 As Variant) As Variant
        Dim result() As Variant
        Dim i As Long, count As Long
        count = 0
        ' Count total elements
        If IsArray(arr1) Then
            count = count + (UBound(arr1) - LBound(arr1) + 1)
        Else
            count = count + 1
        End If
        If IsArray(arr2) Then
            count = count + (UBound(arr2) - LBound(arr2) + 1)
        Else
            count = count + 1
        End If
        ReDim result(0 To count - 1)
        ' Copy elements
        count = 0
        If IsArray(arr1) Then
            For i = LBound(arr1) To UBound(arr1)
                result(count) = arr1(i)
                count = count + 1
            Next i
        Else
            result(count) = arr1
            count = count + 1
        End If
        If IsArray(arr2) Then
            For i = LBound(arr2) To UBound(arr2)
                result(count) = arr2(i)
                count = count + 1
            Next i
        Else
            result(count) = arr2
            count = count + 1
        End If
        CombineArrays = result
    End Function
End Module

' Example 4: Flexible function that handles multiple input types
Function CalculateTotal(values As Variant, Optional taxRate As Double = 0) As Double
    Dim i As Long
    Dim subtotal As Double
    Dim tax As Double
    subtotal = 0
    If IsArray(values) Then
        ' Process array of values
        For i = LBound(values) To UBound(values)
            If IsNumeric(values(i)) Then
                subtotal = subtotal + values(i)
            ElseIf IsArray(values(i)) Then
                ' Handle nested array (recursive call)
                subtotal = subtotal + CalculateTotal(values(i), 0)
            End If
        Next i
    ElseIf IsNumeric(values) Then
        ' Process single value
        subtotal = values
    Else
        Err.Raise 13, , "Type mismatch: values must be numeric or array"
    End If
    ' Apply tax
    If taxRate > 0 Then
        tax = subtotal * taxRate
        CalculateTotal = subtotal + tax
    Else
        CalculateTotal = subtotal
    End If
End Function

Error Handling

The IsArray function itself does not raise errors, but it's often used in error prevention:

Function SafeArrayOperation(arr As Variant) As Variant
    On Error GoTo ErrorHandler
    If Not IsArray(arr) Then
        Err.Raise 5, , "Invalid procedure call: array expected"
    End If
    ' Proceed with array operations
    Dim i As Long
    For i = LBound(arr) To UBound(arr)
        ' Process array elements
    Next i
    Exit Function
ErrorHandler:
    MsgBox "Error: " & Err.Description, vbCritical
    SafeArrayOperation = Null
End Function

Performance Considerations

Fast Operation: IsArray is a very fast check with minimal overhead
Type Checking: More efficient than attempting array operations and handling errors
Avoid Redundant Checks: Cache IsArray result if checking multiple times
Early Validation: Check IsArray early to avoid unnecessary processing

Best Practices

Validate Parameters: Use IsArray to validate Variant parameters before array operations
Flexible Functions: Create functions that gracefully handle both arrays and single values
Clear Error Messages: Provide informative errors when array is expected but not received
Combine Checks: Use with other Is functions (IsNumeric, IsNull, etc.) for complete validation
Document Expectations: Clearly document whether functions expect arrays or single values
Handle Edge Cases: Consider unallocated dynamic arrays (IsArray returns True but UBound fails)
Use Early Returns: Check IsArray early and return/exit if validation fails
ParamArray Elements: Remember each ParamArray element might be an array

Function	Purpose	Returns	Use Case
`IsArray`	Check if array	`Boolean`	Validate array variables
`IsEmpty`	Check if uninitialized	`Boolean`	Check Variant initialization
`IsNull`	Check if Null	`Boolean`	Check for Null values
`IsNumeric`	Check if numeric	`Boolean`	Validate numeric data
`IsObject`	Check if object	`Boolean`	Validate object references
`VarType`	Get variant type	`Integer`	Detailed type information
`TypeName`	Get type name	`String`	Type name as string

Platform and Version Notes

Available in all VB6 versions
Part of VBA core functions
Returns Boolean type
Works with all array types (fixed, dynamic, single or multi-dimensional)
Returns True for unallocated dynamic arrays

Limitations

Does not indicate whether dynamic array is allocated (dimensioned vs ReDim-med)
Cannot determine number of dimensions
Cannot determine array bounds
Does not validate array contents
Does not distinguish between different array types

UBound: Upper bound of array dimension
LBound: Lower bound of array dimension
Array: Create Variant array
VarType: Get detailed type information
TypeName: Get type name as string
IsEmpty: Check if Variant is uninitialized
IsNull: Check if Variant is Null