Skip to main content

How to Remove a Substring from the Beginning of a String in Batch Script

A common text manipulation task is to remove a specific prefix from a string. For example, you might need to strip a "temp_" prefix from filenames, remove a domain from a username (DOMAIN\user -> user), or clean up a standard header from a line of data. Windows Batch does not have a native TRIMSTART() or REMOVEPREFIX() function, so this requires a manual, scripted approach.

This guide will teach you the standard "pure-batch" method, which involves checking the start of the string and then extracting the rest of it. We will also cover the far simpler and more robust modern approach using a PowerShell one-liner, which is the recommended method for its conciseness and power.

The Challenge: No Native "Trim Start" Function​

The main difficulty is that the standard string substitution in batch (%VAR:find=replace%) is global—it replaces all occurrences of "find," not just the one at the beginning. To remove a prefix, we must first confirm that the string actually starts with it and then perform a precise "slice" to get the remainder of the string.

The Core Method (Pure Batch): Length and Substring Extraction​

This is the most direct and logical "pure-batch" solution. It is self-contained but requires several steps.

The logic:

  1. Get the length of the prefix you want to remove.
  2. Extract a substring from the beginning of the main string that is the same length as the prefix.
  3. Compare this extracted piece with the prefix.
  4. If they match, use another substring operation to extract everything after the prefix.

For any modern Windows system, a PowerShell one-liner is a much cleaner and more powerful solution. It has a built-in .StartsWith() method and can easily perform the substring operation in a single command.

Syntax: powershell -Command "if ('MyString'.StartsWith('Prefix')) { 'MyString'.Substring('Prefix'.Length) } else { 'MyString' }"

This command safely checks if the string starts with the prefix and, if so, returns the part of the string that follows it.

Basic Example: Removing a "temp_" Prefix​

Let's remove the prefix "temp_" from the string "temp_datafile.log".

Method 1: Pure Batch Script​

@ECHO OFF
SETLOCAL ENABLEDELAYEDEXPANSION

SET "MyString=temp_datafile.log"
SET "PrefixToRemove=temp_"
SET "Result="

REM Step 1: Get the length of the prefix
CALL :StrLen PrefixToRemove PrefixLen

REM Step 2 & 3: Extract the start of the string and compare
IF /I "!MyString:~0,%PrefixLen%!"=="%PrefixToRemove%" (
    REM Step 4: If it matches, extract the rest of the string
    SET "Result=!MyString:~%PrefixLen%!"
) ELSE (
    SET "Result=!MyString!"
)

ECHO Batch Method Result: %Result%
GOTO :End

: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 Result: datafile.log

Method 2: PowerShell Script​

@ECHO OFF
SET "MyString=temp_datafile.log"
SET "PrefixToRemove=temp_"
SET "Result="

FOR /F "delims=" %%V IN (
    'powershell -Command "if ('%MyString%'.StartsWith('%PrefixToRemove%')) { '%MyString%'.Substring('%PrefixToRemove%'.Length) } else { '%MyString%' }" '
) DO (
    SET "Result=%%V"
)

ECHO PowerShell Method Result: %Result%

Output:

PowerShell Method Result: datafile.log

How the Pure Batch Script Works​

  • SETLOCAL ENABLEDELAYEDEXPANSION: Essential for this script to handle variables and substring operations correctly.
  • :StrLen: A helper subroutine that manually calculates the length of the prefix because batch has no built-in length function.
  • !MyString:~0,%PrefixLen%!: This is the first substring extraction. It gets the first N characters of MyString, where N is the length of our prefix.
  • IF /I ... == ...: The /I makes the comparison case-insensitive. It checks if the start of our string is indeed the prefix we want to remove.
  • !MyString:~%PrefixLen%!: This is the final step. If the check passes, this extracts the remainder of MyString, starting at the position after the prefix.

Common Pitfalls and How to Solve Them​

Problem: The Match is Case-Sensitive​

By default, string operations are case-sensitive. "Temp_" is different from "temp_".

Solution:

  • Pure Batch: The IF statement's /I switch makes the initial check case-insensitive, which is a great feature.
  • PowerShell: To make the check case-insensitive, you must use a more advanced overload for .StartsWith(): ... ('%MyString%'.StartsWith('%PrefixToRemove%', [System.StringComparison]::OrdinalIgnoreCase)) ...

Problem: The String Does Not Start with the Prefix​

Both scripts shown above handle this correctly. If the prefix is not found at the beginning of the string, they simply return the original, unmodified string. This is usually the desired behavior. The ELSE clause in both methods ensures the Result variable is still set to the original string.

Practical Example: Stripping a Domain from a Username​

A common task is to parse a username in the DOMAIN\username format to get just the username part.

@ECHO OFF
SETLOCAL
SET "FullUser=CORP\jdoe"
SET "DomainPrefix=CORP\"
SET "Username="

ECHO Full username: %FullUser%

REM --- Use the robust PowerShell method ---
FOR /F "delims=" %%V IN (
    'powershell -Command "if ('%FullUser%'.StartsWith('%DomainPrefix%', [System.StringComparison]::OrdinalIgnoreCase)) { ('%FullUser%').Substring('%DomainPrefix%'.Length) } else { '%FullUser%' }" '
) DO (
    SET "Username=%%V"
)

ECHO.
ECHO The username part is: %Username%
ENDLOCAL
note

This script safely and correctly (case-insensitively) extracts "jdoe" from the full string.

Conclusion​

While batch has no direct function for removing a prefix, the logic can be constructed manually, though the process is cumbersome.

  • The pure-batch method using length calculation and substring slicing is a good "native" solution but requires a helper subroutine and careful handling of delayed expansion.
  • The PowerShell method is the overwhelmingly recommended best practice. It is cleaner, more readable, and can easily handle case-insensitivity, making it more robust and powerful for any modern script.

For any task that requires stripping a prefix from a string, the PowerShell one-liner is the most professional and efficient choice.

Table of Contents