`LCase` Function

Returns a String that has been converted to lowercase.

Syntax

LCase(string)

Parameters

string (Required): Any valid string expression
If string contains Null, Null is returned

Return Value

Returns a String: - Contains the same string with all uppercase letters converted to lowercase - Lowercase letters and non-alphabetic characters are unchanged - Returns Null if string argument is Null - Empty string returns empty string - Only affects A-Z characters (not accented characters in some locales) - Numbers, punctuation, and symbols are unchanged - Whitespace is preserved

Remarks

The LCase function converts uppercase letters to lowercase:

Only affects uppercase letters A-Z
All other characters remain unchanged
Counterpart to UCase function (converts to uppercase)
Null propagates through the function (Null input returns Null)
Does not modify the original string (strings are immutable in VB6)
Locale-aware in some versions (may affect accented characters)
Common for case-insensitive string comparisons
Useful for normalizing user input
Works with string variables, literals, and expressions
Can be combined with other string functions (Trim, Replace, etc.)
Performance is generally fast for typical strings
For single character, consider using LCase$ for slightly better performance
LCase$ variant returns String type (not Variant)

Typical Uses

Case-Insensitive Comparison: Compare strings ignoring case
User Input Normalization: Convert user input to consistent case
File Path Comparison: Compare file paths case-insensitively (on Windows)
Search Operations: Case-insensitive text searching
Data Validation: Normalize data for validation
Database Queries: Prepare strings for case-insensitive matching
Email Addresses: Normalize email addresses to lowercase
Configuration Keys: Standardize configuration key format

Basic Usage Examples

' Example 1: Basic lowercase conversion
Dim result As String

result = LCase("HELLO")              ' "hello"
result = LCase("Hello World")        ' "hello world"
result = LCase("VB6 Programming")    ' "vb6 programming"

' Example 2: Case-insensitive comparison
Dim input As String
input = "Yes"

If LCase(input) = "yes" Then
MsgBox "User answered yes"
End If

' Example 3: Mixed case preservation
Dim text As String
text = "Hello123WORLD"

Debug.Print LCase(text)              ' "hello123world" - numbers unchanged

' Example 4: Null handling
Dim value As Variant
value = Null

Debug.Print IsNull(LCase(value))     ' True - Null propagates

Common Patterns

' Pattern 1: Case-insensitive string comparison
Function EqualsIgnoreCase(str1 As String, str2 As String) As Boolean
EqualsIgnoreCase = (LCase(str1) = LCase(str2))
End Function

' Pattern 2: Case-insensitive contains check
Function ContainsIgnoreCase(text As String, searchFor As String) As Boolean
ContainsIgnoreCase = (InStr(1, LCase(text), LCase(searchFor)) > 0)
End Function

' Pattern 3: Normalize user input
Function NormalizeInput(userInput As String) As String
NormalizeInput = LCase(Trim(userInput))
End Function

' Pattern 4: Validate yes/no input
Function IsYes(input As String) As Boolean
Select Case LCase(Trim(input))
Case "yes", "y", "true", "1"
IsYes = True
Case Else
IsYes = False
End Select
End Function

' Pattern 5: Case-insensitive array search
Function FindInArray(arr As Variant, searchValue As String) As Long
Dim i As Long
Dim searchLower As String

FindInArray = -1
If Not IsArray(arr) Then Exit Function

searchLower = LCase(searchValue)
For i = LBound(arr) To UBound(arr)
If LCase(arr(i)) = searchLower Then
FindInArray = i
Exit Function
End If
Next i
End Function

' Pattern 6: Extract lowercase letters only
Function GetLowercaseLetters(text As String) As String
Dim i As Long
Dim char As String
Dim result As String

result = ""
For i = 1 To Len(text)
char = Mid(text, i, 1)
If char = LCase(char) And char >= "a" And char <= "z" Then
result = result & char
End If
Next i

GetLowercaseLetters = result
End Function

' Pattern 7: Normalize email address
Function NormalizeEmail(email As String) As String
NormalizeEmail = LCase(Trim(email))
End Function

' Pattern 8: Case-insensitive Replace
Function ReplaceIgnoreCase(text As String, findStr As String, _
replaceStr As String) As String
Dim pos As Long
Dim result As String
Dim textLower As String
Dim findLower As String

result = text
textLower = LCase(text)
findLower = LCase(findStr)

pos = InStr(1, textLower, findLower)
Do While pos > 0
result = Left(result, pos - 1) & replaceStr & _
Mid(result, pos + Len(findStr))
textLower = LCase(result)
pos = InStr(pos + Len(replaceStr), textLower, findLower)
Loop

ReplaceIgnoreCase = result
End Function

' Pattern 9: Check if string is all lowercase
Function IsAllLowercase(text As String) As Boolean
IsAllLowercase = (text = LCase(text))
End Function

' Pattern 10: Toggle case
Function ToggleCase(text As String) As String
Dim i As Long
Dim char As String
Dim result As String

result = ""
For i = 1 To Len(text)
char = Mid(text, i, 1)
If char = UCase(char) Then
result = result & LCase(char)
Else
result = result & UCase(char)
End If
Next i

ToggleCase = result
End Function

Advanced Usage Examples

' Example 1: Case-insensitive dictionary/lookup
Public Class CaseInsensitiveDictionary
Private m_dict As Object  ' Scripting.Dictionary

Private Sub Class_Initialize()
Set m_dict = CreateObject("Scripting.Dictionary")
m_dict.CompareMode = vbTextCompare  ' Alternative to LCase
End Sub

Public Sub Add(key As String, value As Variant)
Dim keyLower As String
keyLower = LCase(key)

If m_dict.Exists(keyLower) Then
Err.Raise 457, "CaseInsensitiveDictionary", "Key already exists"
End If

If IsObject(value) Then
Set m_dict(keyLower) = value
Else
m_dict(keyLower) = value
End If
End Sub

Public Function Get(key As String) As Variant
Dim keyLower As String
keyLower = LCase(key)

If Not m_dict.Exists(keyLower) Then
Err.Raise 5, "CaseInsensitiveDictionary", "Key not found"
End If

If IsObject(m_dict(keyLower)) Then
Set Get = m_dict(keyLower)
Else
Get = m_dict(keyLower)
End If
End Function

Public Function Exists(key As String) As Boolean
Exists = m_dict.Exists(LCase(key))
End Function

Public Sub Remove(key As String)
m_dict.Remove LCase(key)
End Sub
End Class

' Example 2: Text search with case-insensitive highlighting
Public Class TextHighlighter
Public Function Highlight(text As String, searchTerm As String, _
highlightStart As String, _
highlightEnd As String) As String
Dim result As String
Dim pos As Long
Dim lastPos As Long
Dim textLower As String
Dim searchLower As String

If Len(searchTerm) = 0 Then
Highlight = text
Exit Function
End If

result = ""
lastPos = 1
textLower = LCase(text)
searchLower = LCase(searchTerm)

pos = InStr(lastPos, textLower, searchLower)
Do While pos > 0
' Add text before match
result = result & Mid(text, lastPos, pos - lastPos)
' Add highlighted match
result = result & highlightStart & _
Mid(text, pos, Len(searchTerm)) & highlightEnd

lastPos = pos + Len(searchTerm)
pos = InStr(lastPos, textLower, searchLower)
Loop

' Add remaining text
result = result & Mid(text, lastPos)

Highlight = result
End Function
End Class

' Example 3: String matcher with wildcards
Public Class WildcardMatcher
Public Function Matches(text As String, pattern As String, _
Optional caseSensitive As Boolean = False) As Boolean
Dim textToMatch As String
Dim patternToMatch As String

If caseSensitive Then
textToMatch = text
patternToMatch = pattern
Else
textToMatch = LCase(text)
patternToMatch = LCase(pattern)
End If

Matches = MatchesInternal(textToMatch, patternToMatch)
End Function

Private Function MatchesInternal(text As String, pattern As String) As Boolean
' Simple wildcard matching (* = any chars, ? = any single char)
If pattern = "*" Then
MatchesInternal = True
Exit Function
End If

If Len(pattern) = 0 Then
MatchesInternal = (Len(text) = 0)
Exit Function
End If

If Left(pattern, 1) = "*" Then
' Try matching rest of pattern at various positions
Dim i As Long
For i = 0 To Len(text)
If MatchesInternal(Mid(text, i + 1), Mid(pattern, 2)) Then
MatchesInternal = True
Exit Function
End If
Next i
MatchesInternal = False
ElseIf Left(pattern, 1) = "?" Then
If Len(text) > 0 Then
MatchesInternal = MatchesInternal(Mid(text, 2), Mid(pattern, 2))
Else
MatchesInternal = False
End If
Else
If Len(text) > 0 And Left(text, 1) = Left(pattern, 1) Then
MatchesInternal = MatchesInternal(Mid(text, 2), Mid(pattern, 2))
Else
MatchesInternal = False
End If
End If
End Function
End Class

' Example 4: Command parser with case-insensitive commands
Public Class CommandParser
Private m_commands As Collection

Private Sub Class_Initialize()
Set m_commands = New Collection
End Sub

Public Sub RegisterCommand(commandName As String, handler As Object)
m_commands.Add handler, LCase(commandName)
End Sub

Public Function Parse(input As String) As Boolean
Dim parts() As String
Dim command As String
Dim handler As Object

Parse = False
input = Trim(input)
If Len(input) = 0 Then Exit Function

parts = Split(input, " ")
If UBound(parts) < 0 Then Exit Function

command = LCase(parts(0))

On Error Resume Next
Set handler = m_commands(command)
On Error GoTo 0

If Not handler Is Nothing Then
' Execute command handler
' handler.Execute(parts)
Parse = True
End If
End Function

Public Function GetCommandList() As String
Dim i As Long
Dim result As String

result = ""
For i = 1 To m_commands.Count
If i > 1 Then result = result & ", "
' Note: Can't easily get key from Collection
' This is simplified example
Next i

GetCommandList = result
End Function
End Class

Error Handling

LCase handles special cases gracefully:

' Empty string returns empty string
Debug.Print LCase("")                ' ""

' Null propagates
Dim value As Variant
value = Null
Debug.Print IsNull(LCase(value))     ' True

' Non-alphabetic characters unchanged
Debug.Print LCase("123!@#")          ' "123!@#"

' Mixed content
Debug.Print LCase("ABC123xyz")       ' "abc123xyz"

' Safe pattern with Null check
Function SafeLCase(value As Variant) As String
If IsNull(value) Then
SafeLCase = ""
Else
SafeLCase = LCase(value)
End If
End Function

Performance Considerations

Fast Operation: LCase is generally very fast
String Creation: Creates new string (strings are immutable)
Repeated Calls: Cache result if using same lowercase value multiple times
LCase$ Variant: Use LCase$ for String return type (slightly faster)

Performance tips:

' Less efficient - multiple conversions
If LCase(str1) = LCase(str2) And LCase(str1) = LCase(str3) Then

' More efficient - cache conversion
Dim str1Lower As String
str1Lower = LCase(str1)
If str1Lower = LCase(str2) And str1Lower = LCase(str3) Then

Best Practices

Case-Insensitive Comparisons: Always use LCase for both operands
Null Handling: Check for Null before calling LCase if needed
Cache Results: Store converted strings when used multiple times
Database Comparisons: Use LCase to normalize before database queries
User Input: Always normalize user input with LCase + Trim
Email Addresses: Convert email addresses to lowercase for storage/comparison
File Extensions: Use LCase when comparing file extensions
Configuration: Use consistent casing for configuration keys

Function	Purpose	Returns	Use Case
`LCase`	Convert to lowercase	`String`	Lowercase conversion
`UCase`	Convert to uppercase	`String`	Uppercase conversion
`StrComp`	Compare strings	`Integer`	Case-sensitive or insensitive comparison
`Trim`	Remove whitespace	`String`	Cleanup whitespace
`Left`/`Right`/`Mid`	Extract substring	`String`	Substring extraction

`LCase` vs `StrComp`

Dim str1 As String, str2 As String
str1 = "Hello"
str2 = "HELLO"

' Using LCase for comparison
If LCase(str1) = LCase(str2) Then
MsgBox "Equal (case-insensitive)"
End If

' Using StrComp for comparison
If StrComp(str1, str2, vbTextCompare) = 0 Then
MsgBox "Equal (case-insensitive)"
End If

' LCase is more explicit and readable for simple comparisons
' StrComp is better when you need the comparison result (-1, 0, 1)

`LCase$` Variant

' LCase returns Variant
Dim result As Variant
result = LCase("HELLO")

' LCase$ returns String (slightly faster, cannot handle Null)
Dim resultStr As String
resultStr = LCase$("HELLO")

' LCase$ will error on Null
' resultStr = LCase$(Null)  ' Error 94: Invalid use of Null

Platform and Version Notes

Available in all VB6 versions
Part of VBA core functions
Returns Variant containing String (LCase$ returns String type)
Locale-aware in some implementations
Only converts A-Z in most locales
Accented characters may or may not be converted depending on locale

Limitations

Only converts standard ASCII uppercase letters (A-Z)
Accented characters may not be converted consistently
Does not handle Unicode case mapping comprehensively
Cannot convert specific ranges of characters
No option to preserve certain characters
Creates new string (cannot modify in place)

UCase: Convert string to uppercase
StrComp: Compare strings with case options
Trim/LTrim/RTrim: Remove whitespace
Replace: Replace substrings (with case-sensitive option)
InStr: Find substring (can be case-insensitive)

LCase Function