LCase$ Function

Returns a String that has been converted to lowercase. The "$" suffix indicates this function returns a String type.

Syntax

LCase$(string)

Parameters

• string: Required. Any valid string expression. If string contains Null, Null is returned.

Returns

Returns a String with all uppercase letters converted to lowercase. Numbers and punctuation are unchanged.

Remarks

• LCase$ converts all uppercase letters in a string to lowercase.
• The "$" suffix explicitly indicates the function returns a String type rather than a Variant.
• Only uppercase letters (A-Z) are affected; lowercase letters and non-alphabetic characters remain unchanged.
• LCase$ is functionally equivalent to LCase, but LCase$ returns a String while LCase can return a Variant.
• For better performance when you know the result is a string, use LCase$.
• If the argument is Null, the function returns Null.
• The conversion is based on the system locale settings.
• For international characters, the behavior depends on the current code page.
• The inverse function is UCase$, which converts strings to uppercase.
• Common use cases include case-insensitive comparisons and normalizing user input.

Typical Uses

1. Case-insensitive comparisons - Compare strings without regard to case
2. User input normalization - Convert user input to a consistent case
3. Email address handling - Normalize email addresses to lowercase
4. File path comparisons - Compare file paths on case-insensitive file systems
5. Username validation - Normalize usernames to lowercase
6. Search operations - Perform case-insensitive searches
7. Data standardization - Ensure consistent casing in databases

Basic Examples

' Example 1: Simple conversion
Dim result As String
result = LCase$("HELLO")  ' Returns "hello"

' Example 2: Mixed case
Dim text As String
text = LCase$("Hello World")  ' Returns "hello world"

' Example 3: With numbers and punctuation
Dim mixed As String
mixed = LCase$("ABC123!@#")  ' Returns "abc123!@#"

' Example 4: Already lowercase
Dim lower As String
lower = LCase$("already lowercase")  ' Returns "already lowercase"

Common Patterns

Case-Insensitive Comparison

Function CompareIgnoreCase(str1 As String, str2 As String) As Boolean
    CompareIgnoreCase = (LCase$(str1) = LCase$(str2))
End Function

Normalize User Input

Function NormalizeInput(userInput As String) As String
    NormalizeInput = Trim$(LCase$(userInput))
End Function

Email Address Normalization

Function NormalizeEmail(email As String) As String
    NormalizeEmail = LCase$(Trim$(email))
End Function

Case-Insensitive Search

Function ContainsIgnoreCase(text As String, searchFor As String) As Boolean
    ContainsIgnoreCase = (InStr(LCase$(text), LCase$(searchFor)) > 0)
End Function

Username Validation

Function ValidateUsername(username As String) As String
    ' Normalize to lowercase
    ValidateUsername = LCase$(Trim$(username))
End Function

File Extension Check

Function HasExtension(filename As String, ext As String) As Boolean
    Dim fileExt As String
    fileExt = LCase$(Right$(filename, Len(ext)))
    HasExtension = (fileExt = LCase$(ext))
End Function

Dictionary Key Normalization

Sub AddToDictionary(dict As Object, key As String, value As Variant)
    dict.Add LCase$(key), value
End Sub

Case-Insensitive Replace

Function ReplaceIgnoreCase(text As String, findText As String, replaceWith As String) As String
    Dim lowerText As String
    Dim lowerFind As String
    Dim pos As Long
    lowerText = LCase$(text)
    lowerFind = LCase$(findText)
    pos = InStr(lowerText, lowerFind)
    If pos > 0 Then
        ReplaceIgnoreCase = Left$(text, pos - 1) & replaceWith & Mid$(text, pos + Len(findText))
    Else
        ReplaceIgnoreCase = text
    End If
End Function

Sort Key Generation

Function GenerateSortKey(text As String) As String
    GenerateSortKey = LCase$(Trim$(text))
End Function

Command Parser

Function ParseCommand(input As String) As String
    Dim cmd As String
    cmd = LCase$(Trim$(input))
    Select Case cmd
        Case "help"
            ParseCommand = "ShowHelp"
        Case "exit", "quit"
            ParseCommand = "Exit"
        Case Else
            ParseCommand = "Unknown"
    End Select
End Function

Advanced Examples

Case-Insensitive Collection Lookup

Function FindInCollection(col As Collection, key As String) As Variant
    On Error Resume Next
    Dim lowerKey As String
    Dim item As Variant
    Dim i As Long
    lowerKey = LCase$(key)
    ' Try direct lookup first
    FindInCollection = col(lowerKey)
    If Err.Number <> 0 Then
        ' Not found, search manually
        Err.Clear
        For i = 1 To col.Count
            If LCase$(col(i)) = lowerKey Then
                FindInCollection = col(i)
                Exit Function
            End If
        Next i
    End If
End Function

SQL Query Builder

Function BuildWhereClause(fieldName As String, operator As String, value As String) As String
    Dim op As String
    op = LCase$(Trim$(operator))
    Select Case op
        Case "equals", "="
            BuildWhereClause = fieldName & " = '" & value & "'"
        Case "contains", "like"
            BuildWhereClause = fieldName & " LIKE '%" & value & "%'"
        Case "startswith"
            BuildWhereClause = fieldName & " LIKE '" & value & "%'"
        Case Else
            BuildWhereClause = ""
    End Select
End Function

Configuration File Parser

Function ParseConfigLine(line As String, ByRef key As String, ByRef value As String) As Boolean
    Dim pos As Long
    Dim trimmedLine As String
    trimmedLine = Trim$(line)
    ' Skip comments and empty lines
    If Len(trimmedLine) = 0 Or Left$(trimmedLine, 1) = "#" Then
        ParseConfigLine = False
        Exit Function
    End If
    pos = InStr(trimmedLine, "=")
    If pos > 0 Then
        key = LCase$(Trim$(Left$(trimmedLine, pos - 1)))
        value = Trim$(Mid$(trimmedLine, pos + 1))
        ParseConfigLine = True
    Else
        ParseConfigLine = False
    End If
End Function

Smart String Comparison

Function SmartCompare(str1 As String, str2 As String, caseSensitive As Boolean) As Boolean
    If caseSensitive Then
        SmartCompare = (str1 = str2)
    Else
        SmartCompare = (LCase$(str1) = LCase$(str2))
    End If
End Function

Error Handling

Function SafeLCase(text As String) As String
    On Error GoTo ErrorHandler
    If IsNull(text) Then
        SafeLCase = ""
        Exit Function
    End If
    SafeLCase = LCase$(text)
    Exit Function
ErrorHandler:
    SafeLCase = ""
End Function

Performance Notes

• LCase$ is a fast operation with minimal overhead
• For large strings, the performance is linear with string length
• LCase$ (returns String) is slightly faster than LCase (returns Variant)
• When comparing strings, convert both once rather than repeatedly
• Consider caching lowercase versions of frequently compared strings
• For very large datasets, consider using database-level case-insensitive comparisons

Best Practices

1. Use for comparisons - Always normalize case when doing case-insensitive comparisons
2. Prefer LCase$ over LCase - Use LCase$ when you know the result is a string
3. Cache results - Store lowercase versions rather than converting repeatedly
4. Handle Null - Check for Null values before calling LCase$
5. Combine with Trim - Often useful to combine LCase$ with Trim$ for user input
6. Document intent - Make it clear when lowercase conversion is for comparison vs. display
7. Consider locale - Be aware that conversion may vary by system locale

Comparison with Related Functions

Common Use Cases

Case-Insensitive String Arrays

Function ArrayContains(arr() As String, value As String) As Boolean
    Dim i As Long
    Dim lowerValue As String
    lowerValue = LCase$(value)
    For i = LBound(arr) To UBound(arr)
        If LCase$(arr(i)) = lowerValue Then
            ArrayContains = True
            Exit Function
        End If
    Next i
    ArrayContains = False
End Function

URL Parameter Parsing

Function GetURLParameter(url As String, paramName As String) As String
    Dim lowerURL As String
    Dim lowerParam As String
    Dim startPos As Long
    Dim endPos As Long
    lowerURL = LCase$(url)
    lowerParam = LCase$(paramName) & "="
    startPos = InStr(lowerURL, lowerParam)
    If startPos > 0 Then
        startPos = startPos + Len(lowerParam)
        endPos = InStr(startPos, url, "&")
        If endPos = 0 Then endPos = Len(url) + 1
        GetURLParameter = Mid$(url, startPos, endPos - startPos)
    End If
End Function

Platform Notes

• On Windows, LCase$ respects the system locale for character conversion
• Behavior may vary for extended ASCII and international characters
• For ASCII characters (A-Z), behavior is consistent across all platforms
• Some characters may convert differently depending on the active code page
• Modern Windows systems handle Unicode characters in LCase$ operations

Limitations

• Conversion is based on system locale; may not work as expected for all Unicode characters
• Returns Null if the input is Null (unlike some other string functions that error)
• Does not handle advanced Unicode normalization or case folding
• For true Unicode case folding, more sophisticated methods may be needed
• Some special characters (like German ß) may not convert in all locales