IsEmpty Function

Returns a Boolean value indicating whether a Variant variable has been initialized.

Syntax

IsEmpty(expression)

Parameters

expression (Required): Variant expression to test

Return Value

Returns a Boolean: - True if the variable is Empty (uninitialized) - False if the variable has been initialized - Only Variant variables can be Empty - All other variable types are always initialized with default values - Returns False for Null values (Null is not the same as Empty) - Returns False for zero, empty strings, and False

Remarks

The IsEmpty function is used to determine whether a Variant variable has been initialized: - Only works with Variant data type - Returns True only for uninitialized Variant variables - Empty is different from Null (IsNull) and zero - Empty is different from zero-length string ("") - Empty is different from False - Useful for checking optional Variant parameters - Can detect uninitialized elements in Variant arrays - Once a Variant is assigned any value (including Null), it is no longer Empty - Use VarType(var) = vbEmpty for the same check - Cannot be used to test whether procedure or function exists - Commonly used in procedures with optional Variant parameters

Typical Uses

Optional Parameters: Check if optional Variant parameter was provided
Variable Initialization: Verify Variant has been assigned a value
Array Elements: Check if array elements have been assigned
Data Validation: Distinguish between uninitialized and zero/empty values
Database Fields: Detect uninitialized field values
Configuration Settings: Check if settings have been loaded
Error Handling: Detect uninitialized return values
Default Value Logic: Apply defaults only when variable is uninitialized

Basic Usage Examples

' Example 1: Check uninitialized Variant
Dim myVar As Variant
If IsEmpty(myVar) Then
    Debug.Print "Variable is uninitialized"  ' This prints
End If
myVar = 0
If IsEmpty(myVar) Then
    Debug.Print "Still empty"
Else
    Debug.Print "Now initialized"  ' This prints
End If
' Example 2: Distinguish Empty from other values
Dim testVar As Variant
Debug.Print IsEmpty(testVar)        ' True - uninitialized
testVar = 0
Debug.Print IsEmpty(testVar)        ' False - initialized to zero
testVar = ""
Debug.Print IsEmpty(testVar)        ' False - initialized to empty string
testVar = False
Debug.Print IsEmpty(testVar)        ' False - initialized to False
testVar = Null
Debug.Print IsEmpty(testVar)        ' False - Null is not Empty
' Example 3: Optional parameter handling
Function ProcessData(data As String, Optional threshold As Variant) As Boolean
    Dim thresholdValue As Double
    If IsEmpty(threshold) Then
        ' Use default value when parameter not provided
        thresholdValue = 100
        Debug.Print "Using default threshold: 100"
    Else
        thresholdValue = threshold
        Debug.Print "Using provided threshold: " & threshold
    End If
    ' Process data with threshold
    ProcessData = (Len(data) > thresholdValue)
End Function
' Usage
ProcessData "test"              ' Uses default threshold (100)
ProcessData "test", 10          ' Uses provided threshold (10)
ProcessData "test", 0           ' Uses provided threshold (0) - not Empty!
' Example 4: Check array elements
Dim values(1 To 5) As Variant
Dim i As Integer
values(1) = 10
values(3) = "Hello"
' values(2), values(4), values(5) remain Empty
For i = 1 To 5
    If IsEmpty(values(i)) Then
        Debug.Print "Element " & i & " is uninitialized"
    Else
        Debug.Print "Element " & i & " = " & values(i)
    End If
Next i

Common Patterns

' Pattern 1: Optional parameter with default
Function GetValue(key As String, Optional defaultValue As Variant) As Variant
    Dim result As Variant
    result = LookupValue(key)
    If IsEmpty(result) Then
        If IsEmpty(defaultValue) Then
            GetValue = Null  ' No default provided
        Else
            GetValue = defaultValue
        End If
    Else
        GetValue = result
    End If
End Function
' Pattern 2: Initialize if empty
Sub EnsureInitialized(ByRef value As Variant, defaultValue As Variant)
    If IsEmpty(value) Then
        value = defaultValue
    End If
End Sub
' Pattern 3: Count initialized array elements
Function CountInitializedElements(arr As Variant) As Long
    Dim i As Long
    Dim count As Long
    If Not IsArray(arr) Then
        CountInitializedElements = 0
        Exit Function
    End If
    count = 0
    For i = LBound(arr) To UBound(arr)
        If Not IsEmpty(arr(i)) Then
            count = count + 1
        End If
    Next i
    CountInitializedElements = count
End Function
' Pattern 4: Safe value retrieval
Function SafeGetValue(source As Variant, key As String) As Variant
    On Error Resume Next
    SafeGetValue = source(key)
    If Err.Number <> 0 Or IsEmpty(SafeGetValue) Then
        SafeGetValue = Null
    End If
    On Error GoTo 0
End Function
' Pattern 5: Validate required parameter
Sub ProcessRecord(recordData As Variant)
    If IsEmpty(recordData) Then
        Err.Raise 5, , "Record data is required"
    End If
    ' Process the record
End Sub
' Pattern 6: Type-aware value handling
Function DescribeValue(value As Variant) As String
    If IsEmpty(value) Then
        DescribeValue = "Uninitialized"
    ElseIf IsNull(value) Then
        DescribeValue = "Null value"
    ElseIf IsNumeric(value) Then
        DescribeValue = "Number: " & value
    ElseIf IsDate(value) Then
        DescribeValue = "Date: " & value
    Else
        DescribeValue = "Other: " & value
    End If
End Function
' Pattern 7: Clear variant (make it empty again)
Sub ClearVariant(ByRef value As Variant)
    ' Set to Empty state
    value = Empty
    Debug.Print "IsEmpty now: " & IsEmpty(value)  ' True
End Sub
' Pattern 8: Coalesce - return first non-empty value
Function Coalesce(ParamArray values() As Variant) As Variant
    Dim i As Long
    For i = LBound(values) To UBound(values)
        If Not IsEmpty(values(i)) And Not IsNull(values(i)) Then
            Coalesce = values(i)
            Exit Function
        End If
    Next i
    Coalesce = Null  ' All values were Empty or Null
End Function
' Pattern 9: Check multiple values
Function AllInitialized(ParamArray values() As Variant) As Boolean
    Dim i As Long
    For i = LBound(values) To UBound(values)
        If IsEmpty(values(i)) Then
            AllInitialized = False
            Exit Function
        End If
    Next i
    AllInitialized = True
End Function
' Pattern 10: Cache with lazy initialization
Private m_cachedValue As Variant
Function GetCachedValue() As Variant
    If IsEmpty(m_cachedValue) Then
        ' Initialize cache on first access
        m_cachedValue = ExpensiveCalculation()
    End If
    GetCachedValue = m_cachedValue
End Function
Sub InvalidateCache()
    m_cachedValue = Empty
End Sub

Advanced Usage Examples

' Example 1: Configuration manager with lazy loading
Public Class ConfigurationManager
    Private m_config As Variant
    Private m_filePath As String
    Public Sub Initialize(filePath As String)
        m_filePath = filePath
        m_config = Empty  ' Mark as uninitialized
    End Sub
    Public Function GetSetting(key As String, Optional defaultValue As Variant) As Variant
        ' Load config on first access
        If IsEmpty(m_config) Then
            LoadConfiguration
        End If
        On Error Resume Next
        GetSetting = m_config(key)
        If Err.Number <> 0 Or IsEmpty(GetSetting) Then
            If IsEmpty(defaultValue) Then
                GetSetting = Null
            Else
                GetSetting = defaultValue
            End If
        End If
        On Error GoTo 0
    End Function
    Private Sub LoadConfiguration()
        ' Load configuration from file
        Set m_config = CreateObject("Scripting.Dictionary")
        ' ... load settings into dictionary ...
    End Sub
    Public Sub Reload()
        m_config = Empty  ' Clear cache to force reload
    End Sub
End Class
' Example 2: Smart default value provider
Public Class DefaultValueProvider
    Private m_defaults As Variant
    Public Sub SetDefault(key As String, value As Variant)
        If IsEmpty(m_defaults) Then
            Set m_defaults = CreateObject("Scripting.Dictionary")
        End If
        m_defaults(key) = value
    End Sub
    Public Function GetWithDefault(value As Variant, key As String) As Variant
        If IsEmpty(value) Then
            If Not IsEmpty(m_defaults) Then
                On Error Resume Next
                GetWithDefault = m_defaults(key)
                If Err.Number <> 0 Then
                    GetWithDefault = Null
                End If
                On Error GoTo 0
            Else
                GetWithDefault = Null
            End If
        Else
            GetWithDefault = value
        End If
    End Function
End Class
' Example 3: Variant array processor
Public Class VariantArrayProcessor
    Public Function Compact(arr As Variant) As Variant
        ' Remove Empty elements from array
        Dim result() As Variant
        Dim i As Long, count As Long
        If Not IsArray(arr) Then
            Compact = arr
            Exit Function
        End If
        ReDim result(LBound(arr) To UBound(arr))
        count = LBound(arr) - 1
        For i = LBound(arr) To UBound(arr)
            If Not IsEmpty(arr(i)) Then
                count = count + 1
                result(count) = arr(i)
            End If
        Next i
        If count >= LBound(result) Then
            ReDim Preserve result(LBound(result) To count)
            Compact = result
        Else
            Compact = Array()  ' Empty array
        End If
    End Function
    Public Function FillEmpty(arr As Variant, fillValue As Variant) As Variant
        ' Replace Empty elements with fill value
        Dim result() As Variant
        Dim i As Long
        If Not IsArray(arr) Then
            FillEmpty = arr
            Exit Function
        End If
        ReDim result(LBound(arr) To UBound(arr))
        For i = LBound(arr) To UBound(arr)
            If IsEmpty(arr(i)) Then
                result(i) = fillValue
            Else
                result(i) = arr(i)
            End If
        Next i
        FillEmpty = result
    End Function
End Class
' Example 4: Flexible function with multiple optional parameters
Function CreateReport(title As String, Optional author As Variant, _
                      Optional date As Variant, Optional includeIndex As Variant) As String
    Dim report As String
    report = "REPORT: " & title & vbCrLf
    If Not IsEmpty(author) Then
        report = report & "Author: " & author & vbCrLf
    Else
        report = report & "Author: Unknown" & vbCrLf
    End If
    If Not IsEmpty(date) Then
        If IsDate(date) Then
            report = report & "Date: " & Format$(date, "Long Date") & vbCrLf
        Else
            report = report & "Date: " & date & vbCrLf
        End If
    Else
        report = report & "Date: " & Format$(Now, "Long Date") & vbCrLf
    End If
    report = report & String(40, "-") & vbCrLf
    ' Add content...
    ' Add index if requested
    If Not IsEmpty(includeIndex) Then
        If includeIndex = True Then
            report = report & vbCrLf & "INDEX" & vbCrLf
            ' ... add index content ...
        End If
    End If
    CreateReport = report
End Function

Error Handling

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

Function SafeOperation(value As Variant) As Boolean
    If IsEmpty(value) Then
        MsgBox "Value must be initialized", vbExclamation
        SafeOperation = False
        Exit Function
    End If
    ' Safe to use value
    SafeOperation = True
End Function

Performance Considerations

Fast Operation: IsEmpty is a very fast check with minimal overhead
Variant Only: Only applicable to Variant variables
Early Validation: Check IsEmpty early to avoid unnecessary processing
VarType Alternative: VarType(var) = vbEmpty provides same check

Best Practices

Optional Parameters: Always check IsEmpty for optional Variant parameters
Explicit Defaults: Provide clear default values when parameters are Empty
Document Behavior: Document whether Empty is valid for function parameters
Distinguish States: Understand difference between Empty, Null, zero, and empty string
Initialization: Consider explicitly initializing Variants when Empty is not desired
Combine Checks: Use with IsNull for comprehensive validation
Clear Code: Use IsEmpty rather than VarType for better readability
Reset to Empty: Use var = Empty to reset Variant to uninitialized state

Function	Purpose	Returns	Use Case
`IsEmpty`	Check if uninitialized	`Boolean`	Detect Empty Variants
`IsNull`	Check if Null	`Boolean`	Detect Null values
`IsNumeric`	Check if numeric	`Boolean`	Validate numeric data
`IsDate`	Check if date	`Boolean`	Validate date data
`IsArray`	Check if array	`Boolean`	Validate array variables
`VarType`	Get variant type	`Integer`	Detailed type information
`TypeName`	Get type name	`String`	Type name as string

`Empty` vs `Null` vs `Zero` vs Empty `String`

Dim v As Variant
' Empty (uninitialized)
Debug.Print IsEmpty(v)         ' True
Debug.Print IsNull(v)          ' False
Debug.Print v = 0              ' True (Empty coerces to 0 in numeric context)
Debug.Print v = ""             ' True (Empty coerces to "" in string context)
' Null
v = Null
Debug.Print IsEmpty(v)         ' False
Debug.Print IsNull(v)          ' True
' Zero
v = 0
Debug.Print IsEmpty(v)         ' False
Debug.Print v = 0              ' True
' Empty String
v = ""
Debug.Print IsEmpty(v)         ' False
Debug.Print v = ""             ' True

Platform and Version Notes

Available in all VB6 versions
Part of VBA core functions
Returns Boolean type
Only works with Variant data type
Empty is VB-specific concept (not in all languages)

Limitations

Only works with Variant variables
Cannot test non-Variant types (they're always initialized)
Does not indicate what type of value is expected
Cannot distinguish between intentionally Empty and accidentally uninitialized
Empty has different coercion behavior in different contexts

IsNull: Check if Variant is Null
VarType: Get detailed Variant type information
TypeName: Get type name as String
IsNumeric: Check if numeric
IsDate: Check if Date
IsArray: Check if Array