Skip to main content

How to Check if a Command-Line Argument was Provided in Batch Script

Command-line arguments are what make batch scripts truly powerful and reusable. They allow you to pass information into your script, such as a filename to process or an option to change its behavior. However, if your script requires an argument to function, it's critical to check that the user actually provided one. Running the script without a required argument can lead to errors or unexpected behavior.

This guide will teach you the simple, standard, and robust method for checking if a command-line argument exists using a simple IF statement. You will learn how to handle both quoted and unquoted arguments and how to display a user-friendly "usage" message if an argument is missing.

What are Command-Line Arguments?​

Command-line arguments are the pieces of text that you type after the script's name when you run it. They are accessed inside the script using a percent sign (%) followed by their numeric position.

Command Line: C:\> MyScript.bat "C:\My File.txt" /silent

Inside MyScript.bat:

  • %0: The name of the script itself (MyScript.bat).
  • %1: The first argument ("C:\My File.txt").
  • %2: The second argument (/silent).
  • %*: A special variable that contains all arguments ("C:\My File.txt" /silent).

The Core Method: The IF "%~1"=="" Check​

The most reliable and standard way to check if the first argument was provided is with a simple IF statement that checks if %1 is an empty string.

The best-practice syntax is: IF "%~1"=="" (command)

  • %1: Refers to the first argument.
  • ~: This is the crucial "tilde modifier." It removes any surrounding double quotes from the argument. This is what makes the check robust.
  • "%~1"=="": This safely compares the (now unquoted) argument to an empty string. If the user provided no argument, %~1 will be empty, and the condition will be true.

Basic Example: A Simple Argument Check​

This script requires one argument and will display an error message if it's missing.

CheckArg.bat
@ECHO OFF
ECHO --- Argument Checker ---

REM Check if the first argument is empty.
IF "%~1"=="" (
    ECHO [ERROR] You did not provide a required argument.
    ECHO Usage: %~n0 <filename>
    GOTO :EOF
)

ECHO [SUCCESS] You provided the following argument:
ECHO %~1
note

%~n0 is a handy trick to get the script's name without its extension.

In Action​

Scenario 1: Argument is Provided

C:\> CheckArg.bat "Hello World"
--- Argument Checker ---
[SUCCESS] You provided the following argument:
Hello World

Scenario 2: Argument is Missing

C:\> CheckArg.bat
--- Argument Checker ---
[ERROR] You did not provide a required argument.
Usage: CheckArg <filename>

How the Check Works​

The IF "%~1"=="" pattern is robust for two key reasons:

  1. It Handles No Argument: If the user runs CheckArg.bat with no parameters, %1 is completely empty. The command processor sees IF ""=="", which is true, and the error logic is correctly triggered.
  2. It Handles Empty Quoted Arguments: If the user runs CheckArg.bat "", %1 is "". The ~ modifier removes the quotes, leaving an empty string. The check again becomes IF ""=="", which is correctly evaluated as true. This prevents users from tricking the script with an "empty" but technically present argument.

Common Pitfalls and How to Solve Them​

Problem: Checking for Multiple Arguments​

If your script requires more than one argument (e.g., a source and a destination), you simply add more checks.

@ECHO OFF
IF "%~1"=="" GOTO :Usage
IF "%~2"=="" GOTO :Usage

ECHO Source:      %~1
ECHO Destination: %~2
GOTO :EOF

:Usage
ECHO [ERROR] Missing arguments.
ECHO Usage: %~n0 <source_file> <destination_file>

Problem: Checking for an Optional Argument with a Default Value​

Sometimes an argument is optional, and you want to assign a default value if it's not provided. The IF "%~1"=="" pattern is perfect for this.

@ECHO OFF
SET "Mode=%~1"
SET "DefaultMode=Production"

ECHO Checking for optional mode argument...

IF "%Mode%"=="" (
    ECHO Mode not specified. Using default.
    SET "Mode=%DefaultMode%"
)

ECHO The script will run in %Mode% mode.

Practical Example: A "File Processor" Script​

This script requires a single argument: the path to a file that it will process. The check at the beginning is essential to its function.

@ECHO OFF
SETLOCAL

REM --- Step 1: Validate the Input ---
IF "%~1"=="" (
    ECHO [ERROR] No input file specified.
    ECHO Please drag and drop a file onto this script,
    ECHO or run it from the command line with a filename.
    ECHO.
    ECHO Usage: %~n0 <file_to_process>
    PAUSE
    GOTO :EOF
)

SET "InputFile=%~1"

IF NOT EXIST "%InputFile%" (
    ECHO [ERROR] The specified file does not exist:
    ECHO "%InputFile%"
    PAUSE
    GOTO :EOF
)

REM --- Step 2: Main Script Logic ---
ECHO [SUCCESS] Processing file: "%InputFile%"
ECHO.
REM (Your file processing commands would go here)
ECHO ...done.

ENDLOCAL

Conclusion​

Checking for required command-line arguments is the first step in writing robust, user-friendly, and error-proof batch scripts.

The core technique is simple and powerful:

  • Use IF "%~1"=="" to check if the first argument is missing.
  • The tilde modifier (~) is essential for correctly handling quoted arguments and empty strings.
  • If an argument is missing, provide a helpful "Usage" message to the user explaining how to run the script correctly.

By incorporating this simple check into your scripts, you can prevent a huge category of common runtime errors.

Table of Contents