Skip to main content

How to Pad a String with Leading Zeros in Batch Script

A common formatting requirement in scripting is to pad numbers with leading zeros to create fixed-width strings. This is especially important for filenames, as it ensures they sort correctly in alphanumeric order (e.g., img_001.jpg, img_002.jpg, ..., img_010.jpg instead of the incorrect img_1.jpg, img_10.jpg, img_2.jpg). Windows Batch does not have a native LPAD() or FORMAT() function, so this task requires a simple but clever workaround.

This guide will teach you the standard "pure-batch" method, which involves adding a prefix of zeros and then "slicing" the string to the correct length. We will also cover the simpler and more powerful modern approach using a PowerShell one-liner, which is the recommended method for its readability and flexibility.

The Challenge: No Native LPAD() Function​

The cmd.exe interpreter has no built-in command to format a string to a fixed width with a padding character. We cannot simply do SET "Padded=LPAD(%MyNumber%, 5, '0')". This means we have to construct the logic manually. The most efficient way to do this is not to count and loop, but to manipulate the string as a whole.

The Core Method (Pure Batch): The "Add and Slice" Trick​

This is the fastest and most common "pure-batch" solution. It's a two-step process:

  1. Add: Prepend a long string of zeros to the front of your number or string.
  2. Slice: Use substring extraction to take only the last N characters from the resulting string.

For example:

SET "MyNumber=42"
SET "PaddedZeros=00000"
SET "TempString=%PaddedZeros%%MyNumber%"
SET "Result=!TempString:~-5!"

The result will be 00042. This requires Delayed Expansion.

For any modern Windows system, a PowerShell one-liner is a much cleaner and more readable solution. It has a built-in string method, .PadLeft(), designed for this exact purpose.

Syntax: powershell -Command "'YourString'.PadLeft(TotalWidth, 'PaddingCharacter')"

This command is more flexible, as you can easily change the total width and the character used for padding.

Basic Example: Padding a Number​

Let's pad the number 42 to a total width of 5 characters, resulting in 00042.

Method 1: Pure Batch Script​

@ECHO OFF
SETLOCAL ENABLEDELAYEDEXPANSION

SET "MyNumber=42"
SET "TotalWidth=5"

REM 1. Add a prefix of zeros
SET "PaddedZeros=00000"
SET "TempString=%PaddedZeros%%MyNumber%"

REM 2. Slice the last N characters
SET "Result=!TempString:~-%TotalWidth%!"

ECHO Batch Method Result: %Result%
ENDLOCAL

Output:

Batch Method Result: 00042

Method 2: PowerShell Script​

@ECHO OFF
SET "MyNumber=42"
SET "TotalWidth=5"
SET "Result="

FOR /F %%P IN (
    'powershell -Command "'%MyNumber%'.PadLeft(%TotalWidth%, '0')" '
) DO (
    SET "Result=%%P"
)

ECHO PowerShell Method Result: %Result%

Output:

PowerShell Method Result: 00042

How the Pure Batch Trick Works​

The key to the batch method is the substring extraction syntax: !TempString:~-5!.

  • SETLOCAL ENABLEDELAYEDEXPANSION: This is required to use the ! syntax, which gets the current value of a variable inside a loop or after it has been modified.
  • SET "TempString=%PaddedZeros%%MyNumber%": This creates a temporary string. If MyNumber is 42, TempString becomes 0000042.
  • !TempString:~-5!: This is the "slice."
    • : starts the substring operation.
    • ~-5 is a special syntax meaning "start 5 characters from the end of the string."
    • The command extracts from that starting point to the end of the string. The result is 00042.

Common Pitfalls and How to Solve Them​

Problem: The Input String is Longer Than the Target Width​

The "Add and Slice" trick will truncate a string that is already longer than the desired width.

For example, if you try to pad 123456 to a width of 5:

  • TempString becomes 00000123456.
  • !TempString:~-5! takes the last 5 characters, resulting in 23456.

Solution: The PowerShell method does not truncate by default. '123456'.PadLeft(5, '0') will correctly return the full 123456. This makes the PowerShell method safer for situations where truncation is not desired.

Problem: Forgetting Delayed Expansion​

The pure-batch method will fail silently or behave incorrectly if you forget to enable delayed expansion and use the ! syntax for the final slice.

Solution: Always include SETLOCAL ENABLEDELAYEDEXPANSION at the start of any script that uses this technique.

Practical Example: A File Renaming Loop​

This is the most common use case for zero-padding. This script finds all files named image(N).jpg and renames them to a padded, 3-digit format image_00N.jpg for correct sorting.

@ECHO OFF
SETLOCAL ENABLEDELAYEDEXPANSION

ECHO --- Renaming and Padding Files ---
ECHO.

REM This loop finds files like image(1).jpg, image(2).jpg, etc.
FOR /F "tokens=1,2 delims=()" %%A IN ('DIR /B "image(*).jpg"') DO (
    
    SET "prefix=%%A"
    SET "number=%%B"
    
    ECHO Found file with number: !number!
    
    REM --- Pad the number to 3 digits using PowerShell ---
    SET "padded_number="
    FOR /F %%P IN ('powershell -Command "!number!.ToString().PadLeft(3, '0')"') DO (
        SET "padded_number=%%P"
    )
    
    SET "OriginalName=image(!number!).jpg"
    SET "NewName=image_!padded_number!.jpg"
    
    ECHO Renaming "!OriginalName!" to "!NewName!"
    REN "!OriginalName!" "!NewName!"
    ECHO.
)

ECHO --- Done ---
ENDLOCAL

Conclusion​

While batch scripting has no native function for padding strings, it provides a clever workaround that is sufficient for simple cases.

  • The "Add and Slice" trick is the traditional pure-batch method. It's fast and self-contained but requires careful handling of delayed expansion and can truncate long strings.
  • The PowerShell .PadLeft() method is the overwhelmingly recommended best practice. It is more readable, more flexible, safer (as it doesn't truncate), and just as easy to call from a batch script.

For any modern script, the PowerShell one-liner is the most professional and reliable choice for formatting strings with leading zeros.

Table of Contents