Skip to main content

How to Get the Length of a String in Batch Script

Calculating the length of a string is a fundamental operation in programming, essential for validating user input, padding text to a certain width, or truncating long filenames. However, the Windows Batch interpreter (cmd.exe) is a simple shell and famously lacks a built-in LEN() or LENGTH() function. This means we must create the functionality ourselves.

This guide will teach you the traditional "pure-batch" method, which uses a looping subroutine to count the characters one by one. More importantly, it will introduce the vastly simpler and faster modern method using a PowerShell one-liner, which is the recommended approach for any script running on a modern Windows system.

The Challenge: No Native LEN() Function​

The primary difficulty is that you cannot simply ask cmd.exe for a string's length. There is no command like SET len = LEN(%MyString%). To solve this natively, we have to create a helper function (a subroutine) that manually counts the characters in a string. This is a classic batch scripting problem that demonstrates both the limitations and the surprising flexibility of the language.

The Core Method (Pure Batch): The Character-by-Character Count​

This method uses a subroutine that repeatedly removes the first character of a string and increments a counter until the string is empty. It is entirely self-contained but is also very slow.

The logic:

  1. Pass the name of the variable containing the string to a subroutine.
  2. Inside the subroutine, enter a loop that continues as long as the string has content.
  3. In each iteration, remove the first character of the string.
  4. Increment a counter.
  5. When the string is empty, the loop ends, and the counter holds the original length.

For any modern Windows system, the best solution is to use PowerShell. It has a built-in .Length property for all strings, which returns the character count instantly.

This command can be called directly from a batch script to get the length: powershell -Command "'Your String Here'.Length"

This method is orders of magnitude faster, simpler to write, and more robust.

Basic Example: Measuring a String​

Let's find the length of the string "Hello, World!" using both methods.

Method 1: Pure Batch Script​

@ECHO OFF
SETLOCAL ENABLEDELAYEDEXPANSION

SET "MyString=Hello, World!"
SET "StringLength=0"

CALL :StrLen MyString StringLength

ECHO Batch Method: The length is %StringLength%.
GOTO :End

REM --- Subroutine to calculate string length ---
:StrLen
SET "string=!%1!"
SET "len=0"
:StrLenLoop
IF DEFINED string (
    SET "string=!string:~1!"
    SET /A "len+=1"
    GOTO :StrLenLoop
)
SET "%2=%len%"
GOTO :EOF

:End
ENDLOCAL

Output:

Batch Method: The length is 13.

Method 2: PowerShell Script​

@ECHO OFF
SET "MyString=Hello, World!"
SET "StringLength=0"

FOR /F %%L IN (
    'powershell -Command "'%MyString%'.Length"'
) DO (
    SET "StringLength=%%L"
)

ECHO PowerShell Method: The length is %StringLength%.

Output:

PowerShell Method: The length is 13.

How the Pure Batch Subroutine Works​

The :StrLen subroutine is the core of the native method:

  • SETLOCAL ENABLEDELAYEDEXPANSION: Required for the !string! variables to work correctly.
  • :StrLen: Defines the start of the subroutine.
  • SET "string=!%1!": This is a bit tricky. %1 is the name of the variable passed in (e.g., MyString). !%1! retrieves the value of that variable.
  • :StrLenLoop: The start of the counting loop.
  • IF DEFINED string: The loop continues as long as the string variable contains something.
  • SET "string=!string:~1!": This is the crucial step. It replaces the string with a substring of itself, starting from the second character, effectively removing the first character.
  • SET "%2=%len%": This sets the output variable. %2 is the name of the second argument passed to the subroutine (e.g., StringLength). This line effectively says SET StringLength=13.

Common Pitfalls and How to Solve Them​

Problem: Performance on Long Strings​

The pure-batch subroutine is extremely slow. Because it has to loop once for every single character, its execution time increases linearly with the length of the string. For a string with several thousand characters, it can take multiple seconds to return a result.

Solution: Use the PowerShell method. The .Length property is an intrinsic feature of the string object and returns its value almost instantly, regardless of the string's length.

Problem: Handling Special Characters​

The pure-batch method can fail if the string contains certain characters that are special to the batch interpreter, especially if they are not handled carefully with quoting and delayed expansion.

Solution: The PowerShell method is far more robust. It handles almost any character correctly without any extra work, making it safer for processing unknown or user-provided input.

Practical Example: Validating a User Password Length​

This is a perfect use case for a length check. The script will prompt a user to create a password and will not accept it until it meets a minimum length requirement. This example uses the fast and reliable PowerShell method.

@ECHO OFF
SETLOCAL

:Prompt
SET "UserPassword="
SET /P "UserPassword=Create a new password (min 8 characters): "

SET "PasswordLength=0"
FOR /F %%L IN ('powershell -Command "'%UserPassword%'.Length"') DO (
    SET "PasswordLength=%%L"
)

IF %PasswordLength% LSS 8 (
    ECHO.
    ECHO [ERROR] Password is too short. Please try again.
    ECHO.
    GOTO :Prompt
)

ECHO.
ECHO [SUCCESS] Password accepted.
ENDLOCAL

Conclusion​

While it is possible to calculate a string's length in a pure batch script, the method is a complex workaround with significant performance drawbacks.

  • The pure-batch subroutine method is a good "academic" example of what can be achieved with native commands, but it is not suitable for performance-critical or robust applications.
  • The PowerShell .Length property is the overwhelmingly recommended best practice. It is faster, simpler, safer, and more reliable.

For any modern script that needs to determine the length of a string, the PowerShell one-liner is the professional and efficient choice.

Table of Contents