Skip to main content

How to Get the Number of Command-Line Arguments Passed to a Script in Batch Script

When writing flexible Batch scripts, you often need to handle inputs from the command line. Whether your script accepts a list of file paths, names, or configuration flags, knowing exactly how many arguments the user provided is the first step in input validation. Unlike languages like Bash (which uses $#) or Python (which uses len(sys.argv)), Windows Batch does not have a built-in variable to tell you the argument count.

This guide will explain how to use a simple loop and the SHIFT command to accurately count command-line arguments.

The Challenge: No Native Counter​

In Batch, you can access arguments using %1, %2, up to %9. However, if the user passes 15 arguments, there is no single variable that says "15". To find this number, we must iterate through the arguments until we hit an empty one.

This method is the standardized way to count parameters without affecting the rest of your script.

@echo off
setlocal

set "argCount=0"

:: Loop through every argument provided
for %%x in (%*) do (
    set /a "argCount+=1"
)

echo You passed %argCount% argument(s) to this script.

:: Practical Usage: Check for minimum required arguments
if %argCount% lss 2 (
    echo.
    echo [ERROR] This script requires at least 2 arguments.
    echo Usage:  %~nx0 [InputFile] [OutputFile]
    exit /b 1
)

echo Argument 1: %1
echo Argument 2: %2

pause
endlocal

Why this works:​

  • %*: This is a special variable that represents "all arguments" passed to the script.
  • for %%x in (%*): This tells Batch to treat the arguments as a list and run the code inside the parentheses for each item found.
info

Limitation with quoted arguments containing spaces. The for %%x in (%*) loop splits on spaces and treats quoted strings as single tokens in most cases. However, arguments containing wildcards (*, ?) may be expanded by the for command. If your arguments could contain wildcard characters, use Method 2 instead.

Method 2: The "Shift" Method​

If you need precise handling of every argument (including those with special characters), the SHIFT approach processes them one at a time through %1.

@echo off
setlocal

set "count=0"

:: Save original arguments before shifting
set "allArgs=%*"

:countLoop
if "%~1"=="" goto :doneCount
set /a "count+=1"
shift
goto :countLoop

:doneCount
echo Total arguments: %count%

:: Practical Usage: Validate and display usage
if %count% lss 1 (
    echo.
    echo [ERROR] No arguments provided.
    echo Usage:  %~nx0 [filename] [options...]
    exit /b 1
)

echo All arguments were: %allArgs%

pause
endlocal
warning

The SHIFT Side-Effect. Using shift physically removes %1 and moves %2 into its place. Once the counting loop finishes, your original %1, %2, etc., are gone. The script above saves %* into a variable before the loop so the original values remain accessible.

How to Avoid Common Errors​

Wrong Way: Hardcoding checks for %1, %2...​

Some beginners try to check if "%2"=="" ....

Why it fails: This doesn't tell you how many there are; it only tells you if at least two exist. If the user passes 20 arguments, this logic becomes incredibly messy and hard to maintain.

Correct Way: Use the FOR loop (Method 1) or SHIFT loop (Method 2) to let Batch do the counting for you, regardless of how many items are passed.

Problem: Special Characters in Arguments​

If a user passes an argument containing & or |, it might break your FOR loop if not handled correctly.

Best Practice: Use the "%~1" syntax (the tilde removes existing quotes, and the outer quotes ensure the string remains a single token) for comparisons in the SHIFT method.

Wrong Way: Using LTR for comparison​

The correct comparison operator for "less than" is lss, not ltr. Using ltr will cause a syntax error.

Best Practices and Rules​

1. Script Documentation​

If your script requires a specific number of arguments, start your script by showing a "Usage" message if the count is wrong.

if "%~1"=="" (
    echo Usage: %~nx0 [InputFile] [OutputFile]
    exit /b 1
)

2. The %0 Variable​

Remember that %0 is always the name of the script itself. It is not included in the %* list. If you want to include the script name in your count, start your counter at 1.

3. Argument Limits​

While Batch can theoretically handle many arguments, the total command-line length is limited to 8191 characters. If you need to pass hundreds of arguments, consider passing a single path to a .txt file containing the data.

Conclusions​

Counting command-line arguments is a fundamental part of writing professional, error-resistant Batch scripts. By shifting the burden of counting to a simple FOR loop or iteration block, you can validate user input and ensure your automation logic has exactly the data it needs to succeed. These techniques transform simple scripts into robust tools that behave predictably in complex environments.

Table of Contents