Command$ Function

Returns the argument portion of the command line used to launch Microsoft Visual Basic or an executable program developed with Visual Basic. The dollar sign suffix ($) explicitly indicates that this function returns a String type (not a Variant).

Syntax

Command$()

Parameters

None. The Command$ function takes no arguments.

Return Value

Returns a String containing the command-line arguments passed to the program. If no arguments were passed, returns an empty string (""). The return value is always a String type (never Variant).

Remarks

• The Command$ function always returns a String, while Command (without $) can return a Variant.
• Returns only the arguments, not the executable path or name.
• Arguments are returned as a single string, exactly as passed to the application.
• Multiple arguments are separated by spaces (unless quoted).
• Quoted strings preserve internal spaces but quotes may be included in the result.
• Leading and trailing spaces are typically trimmed by the system.
• Returns empty string ("") if no arguments were provided.
• Case is preserved as entered on the command line.
• For better performance when you know the result is a string, use Command$ instead of Command.

Command Line Processing

When an application is launched with:

MyApp.exe /debug file.txt "long filename.doc"

Command$() returns:

/debug file.txt "long filename.doc"

Typical Uses

1. Processing startup parameters - Read switches and configuration flags
2. File path handling - Accept file paths to open at startup
3. Debug modes - Enable special debugging or logging modes
4. Automation - Support scripted or automated workflows
5. Configuration - Pass runtime configuration without config files
6. Batch processing - Process multiple files or operations
7. Integration - Allow other applications to control behavior

Basic Examples

' Example 1: Get command line arguments
Sub Main()
Dim cmdLine As String
cmdLine = Command$()
MsgBox "Arguments: " & cmdLine
End Sub

' Example 2: Check if arguments provided
Sub Main()
If Command$() <> "" Then
MsgBox "Arguments: " & Command$()
Else
MsgBox "No arguments"
End If
End Sub

' Example 3: Simple file opener
Sub Main()
Dim filename As String
filename = Trim$(Command$())
If filename <> "" Then
OpenFile filename
End If
End Sub

' Example 4: Check for debug mode
Sub Main()
If InStr(Command$(), "/debug") > 0 Then
EnableDebugMode
End If
End Sub

Common Patterns

Processing Multiple Arguments

Function ParseArguments() As Collection
Dim args As String
Dim result As New Collection
Dim parts() As String

args = Command$()
If args = "" Then
Set ParseArguments = result
Exit Function
End If

parts = Split(args, " ")
Dim i As Integer
For i = LBound(parts) To UBound(parts)
If Trim$(parts(i)) <> "" Then
result.Add Trim$(parts(i))
End If
Next i

Set ParseArguments = result
End Function

Processing Switches and Parameters

Sub Main()
Dim args As String
args = Command$()

' Check for various switches
If InStr(args, "/debug") > 0 Then
App.LogMode = 1
End If

If InStr(args, "/silent") > 0 Then
App.SilentMode = True
End If

If InStr(args, "/verbose") > 0 Then
App.VerboseMode = True
End If
End Sub

Opening File from Command Line

Sub Main()
Dim filename As String
filename = Trim$(Command$())

If filename <> "" Then
' Remove surrounding quotes if present
If Left$(filename, 1) = Chr$(34) Then
filename = Mid$(filename, 2)
End If
If Right$(filename, 1) = Chr$(34) Then
filename = Left$(filename, Len(filename) - 1)
End If

' Verify file exists and open it
If Dir$(filename) <> "" Then
LoadDocument filename
Else
MsgBox "File not found: " & filename
End If
End If
End Sub

Named Parameter Extraction

Function GetParameter(paramName As String) As String
Dim args As String
Dim pos As Integer
Dim endPos As Integer
Dim result As String

args = " " & Command$() & " "
pos = InStr(1, args, "/" & paramName & ":", vbTextCompare)

If pos > 0 Then
pos = pos + Len(paramName) + 2
endPos = InStr(pos, args, " ")
If endPos > pos Then
result = Mid$(args, pos, endPos - pos)
End If
End If

GetParameter = result
End Function

Logging Startup Arguments

Sub Main()
Dim args As String
Dim logFile As Integer

args = Command$()

logFile = FreeFile
Open App.Path & "\startup.log" For Append As #logFile
Print #logFile, Now & " - Started with args: " & args
Close #logFile
End Sub

Configuration from Command Line

Sub Main()
Dim args As String
args = UCase$(Command$())

' Set configuration based on arguments
If InStr(args, "/SERVER:") > 0 Then
App.ServerName = GetParameter("server")
End If

If InStr(args, "/PORT:") > 0 Then
App.Port = Val(GetParameter("port"))
End If

If InStr(args, "/USER:") > 0 Then
App.UserName = GetParameter("user")
End If
End Sub

Help Display

Sub Main()
Dim args As String
args = LCase$(Trim$(Command$()))

If args = "/?" Or args = "-?" Or args = "/help" Or args = "-help" Then
DisplayHelp
End
End If
End Sub

Sub DisplayHelp()
Dim helpText As String
helpText = "Usage: MyApp [options]" & vbCrLf
helpText = helpText & "/debug    - Enable debug mode" & vbCrLf
helpText = helpText & "/silent   - Run in silent mode" & vbCrLf
helpText = helpText & "/file:xxx - Open specified file" & vbCrLf
MsgBox helpText
End Sub

Batch Mode Processing

Sub Main()
Dim args As String
Dim files() As String
Dim i As Integer

args = Command$()

If InStr(args, "/batch") > 0 Then
' Parse file list
files = Split(Replace$(args, "/batch", ""), " ")

For i = LBound(files) To UBound(files)
If Trim$(files(i)) <> "" Then
ProcessFile Trim$(files(i))
End If
Next i

End  ' Exit after batch processing
End If
End Sub

Error Recovery

Sub Main()
On Error GoTo ErrorHandler

Dim args As String
args = Command$()

' Process arguments
If args <> "" Then
ProcessCommandLine args
End If

Exit Sub

ErrorHandler:
MsgBox "Error processing command line: " & args & vbCrLf & _
"Error: " & Err.Description
End
End Sub

Case-Insensitive Switch Detection

Function HasSwitch(switchName As String) As Boolean
Dim args As String
args = " " & UCase$(Command$()) & " "
switchName = " /" & UCase$(switchName) & " "
HasSwitch = (InStr(args, switchName) > 0)
End Function

Related Functions

• Command: Returns command-line arguments as Variant instead of String
• App.Path: Returns the path where the application executable is located
• App.EXEName: Returns the name of the executable file
• Environ$: Returns environment variable values

Best Practices

1. Always trim the result to remove leading/trailing spaces
2. Handle the case where no arguments are provided (empty string)
3. Use case-insensitive comparison for switches and parameters
4. Document expected command-line format in your application
5. Validate arguments before using them
6. Provide meaningful error messages for invalid arguments
7. Consider implementing a /help or /? switch
8. Use Command$ instead of Command for better performance
9. Be careful with quoted strings - they may include the quotes
10. Log startup arguments for debugging and support purposes

Performance Considerations

• Command$ is slightly more efficient than Command because it avoids Variant overhead
• The function is typically called once at startup, so performance is rarely a concern
• Parsing complex command lines can be slow; cache the result if needed multiple times
• Consider using a dedicated command-line parser for complex argument processing

Platform Notes

• Command-line argument handling is consistent across Windows platforms
• Maximum command-line length varies by Windows version (typically 8191 characters)
• Arguments are passed by the operating system when the executable is launched
• VB6 IDE does not allow setting command-line arguments for debugging
• Use a shortcut or command prompt to test command-line arguments

Security Considerations

1. Never execute command-line arguments directly as code
2. Validate all file paths before accessing files
3. Sanitize arguments before using in SQL queries or shell commands
4. Limit accepted argument values to known good values when possible
5. Log suspicious or malformed command-line arguments

Limitations

• Returns arguments as a single string (manual parsing required for multiple arguments)
• Does not provide the executable path or name (use App.Path and App.EXEName)
• No built-in support for named parameters (must implement custom parsing)
• Quote handling is system-dependent and may vary
• Cannot distinguish between missing arguments and empty string argument