UCase$ Function

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

Syntax

UCase$(string)

Parameters

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

Returns

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

Remarks

• UCase$ converts all lowercase letters in a string to uppercase.
• The "$" suffix explicitly indicates the function returns a String type rather than a Variant.
• Only lowercase letters (a-z) are affected; uppercase letters and non-alphabetic characters remain unchanged.
• UCase$ is functionally equivalent to UCase, but UCase$ returns a String while UCase can return a Variant.
• For better performance when you know the result is a string, use UCase$.
• 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 LCase$, which converts strings to lowercase.
• Common use cases include display formatting, SQL keywords, and creating constants.

Typical Uses

1. Display formatting - Format text for display in uppercase
2. SQL keyword generation - Create SQL queries with uppercase keywords
3. Constant generation - Generate uppercase constant names
4. File path normalization - Normalize file paths for case-insensitive systems
5. Acronym formatting - Format acronyms and abbreviations
6. Header text - Create uppercase headers for reports
7. Code generation - Generate uppercase identifiers in code

Basic Examples

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

' Example 2: Mixed case
Dim text As String
text = UCase$("Hello World")  ' Returns "HELLO WORLD"

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

' Example 4: Already uppercase
Dim upper As String
upper = UCase$("ALREADY UPPERCASE")  ' Returns "ALREADY UPPERCASE"

Common Patterns

SQL Keyword Formatting

Function BuildSQLQuery(table As String, field As String) As String
    BuildSQLQuery = UCase$("SELECT") & " * " & UCase$("FROM") & " " & table
End Function

Constant Name Generator

Function GenerateConstantName(baseName As String) As String
    GenerateConstantName = UCase$(Replace(baseName, " ", "_"))
End Function

Acronym Formatter

Function FormatAcronym(text As String) As String
    FormatAcronym = UCase$(text)
End Function

Header Text Generator

Function CreateHeader(title As String) As String
    CreateHeader = String$(Len(title), "=") & vbCrLf & _
                   UCase$(title) & vbCrLf & _
                   String$(Len(title), "=")
End Function

Case-Insensitive Command Comparison

Function ProcessCommand(cmd As String) As Boolean
    Select Case UCase$(Trim$(cmd))
        Case "START"
            ProcessCommand = StartService()
        Case "STOP"
            ProcessCommand = StopService()
        Case "RESTART"
            ProcessCommand = RestartService()
        Case Else
            ProcessCommand = False
    End Select
End Function

File Extension Normalization

Function NormalizeExtension(filename As String) As String
    Dim ext As String
    ext = Right$(filename, 4)
    If UCase$(ext) = ".TXT" Then
        NormalizeExtension = "Text File"
    End If
End Function

Environment Variable Names

Function GetEnvironmentVar(varName As String) As String
    GetEnvironmentVar = Environ$(UCase$(varName))
End Function

Registry Key Normalization

Function NormalizeRegistryKey(keyName As String) As String
    NormalizeRegistryKey = UCase$(Trim$(keyName))
End Function

Display Name Formatting

Function FormatDisplayName(firstName As String, lastName As String) As String
    FormatDisplayName = UCase$(lastName) & ", " & firstName
End Function

Code Template Generator

Function GenerateEnumMember(memberName As String) As String
    GenerateEnumMember = "    " & UCase$(memberName) & " = " & counter
End Function

Advanced Examples

SQL Query Builder with Uppercase Keywords

Function BuildComplexQuery(table As String, fields As String, whereClause As String) As String
    Dim sql As String
    sql = UCase$("SELECT") & " " & fields & " "
    sql = sql & UCase$("FROM") & " " & table
    If Len(whereClause) > 0 Then
        sql = sql & " " & UCase$("WHERE") & " " & whereClause
    End If
    BuildComplexQuery = sql
End Function

Configuration File Writer

Sub WriteConfigSection(fileNum As Integer, sectionName As String, settings As Collection)
    Dim key As Variant
    Print #fileNum, "[" & UCase$(sectionName) & "]"
    For Each key In settings
        Print #fileNum, UCase$(key) & "=" & settings(key)
    Next key
    Print #fileNum, ""
End Sub

Report Header Generator

Function GenerateReportHeader(reportTitle As String, reportDate As String) As String
    Dim header As String
    Dim separator As String
    separator = String$(60, "=")
    header = separator & vbCrLf
    header = header & Space$((60 - Len(reportTitle)) \ 2) & UCase$(reportTitle) & vbCrLf
    header = header & Space$((60 - Len(reportDate)) \ 2) & reportDate & vbCrLf
    header = header & separator & vbCrLf
    GenerateReportHeader = header
End Function

Macro Name Validator

Function ValidateMacroName(macroName As String) As String
    Dim validName As String
    Dim i As Long
    Dim char As String
    ' Convert to uppercase and remove invalid characters
    validName = UCase$(macroName)
    For i = 1 To Len(validName)
        char = Mid$(validName, i, 1)
        If (char >= "A" And char <= "Z") Or _
           (char >= "0" And char <= "9") Or _
           char = "_" Then
            ValidateMacroName = ValidateMacroName & char
        End If
    Next i
End Function

Error Handling

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

Performance Notes

• UCase$ is a fast operation with minimal overhead
• For large strings, the performance is linear with string length
• UCase$ (returns String) is slightly faster than UCase (returns Variant)
• When formatting multiple strings, consider caching uppercase versions if reused
• For very large datasets, consider using database-level text functions

Best Practices

1. Use for display - Convert to uppercase when formatting for display
2. Prefer UCase$ over UCase - Use UCase$ when you know the result is a string
3. SQL keywords - Use uppercase for SQL keywords to improve readability
4. Handle Null - Check for Null values before calling UCase$
5. Combine with Trim - Often useful to combine UCase$ with Trim$ for cleaner output
6. Document intent - Make it clear when uppercase conversion is for display vs. comparison
7. Consider locale - Be aware that conversion may vary by system locale

Comparison with Related Functions

Common Use Cases

HTTP Header Names

Function FormatHTTPHeader(headerName As String, headerValue As String) As String
    FormatHTTPHeader = UCase$(headerName) & ": " & headerValue
End Function

Database Column Names

Function GetColumnName(fieldName As String) As String
    GetColumnName = UCase$(Replace(fieldName, " ", "_"))
End Function

License Key Formatting

Function FormatLicenseKey(key As String) As String
    ' Format as XXXX-XXXX-XXXX-XXXX
    Dim upperKey As String
    upperKey = UCase$(Replace(key, "-", ""))
    FormatLicenseKey = Mid$(upperKey, 1, 4) & "-" & _
                       Mid$(upperKey, 5, 4) & "-" & _
                       Mid$(upperKey, 9, 4) & "-" & _
                       Mid$(upperKey, 13, 4)
End Function

Command Line Argument Parsing

Function ParseArgument(arg As String) As String
    If Left$(arg, 1) = "/" Or Left$(arg, 1) = "-" Then
        ParseArgument = UCase$(Mid$(arg, 2))
    Else
        ParseArgument = UCase$(arg)
    End If
End Function

Platform Notes

• On Windows, UCase$ 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 UCase$ 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 may not convert in all locales