Skip to main content

How to Insert a Character at a Specific Position in Batch Script

Inserting a character or a string into the middle of another string is a common need for formatting data, such as adding hyphens to a date stamp or inserting a separator into a long ID. Unlike extracting a substring, which has a direct syntax, batch scripting offers no single, built-in command to insert text.

The solution is a straightforward but manual workaround: you split the original string into two pieces at the desired insertion point and then join them back together with the new character in the middle. This guide will teach you this fundamental technique using substring expansion.

The Challenge: No Native INSERT() Function​

The cmd.exe command processor is simple by design. It provides syntax for extracting substrings (%VAR:~start,len%) but lacks a corresponding function for insertion. Therefore, we must manually deconstruct and reconstruct the string ourselves.

The Core Method: Splitting and Concatenating​

The logic is simple and can be broken down into three steps:

  1. Get the First Part: Use substring syntax to get everything before the insertion point.
  2. Get the Second Part: Use substring syntax to get everything from the insertion point to the end.
  3. Concatenate: Join the three pieces together in the correct order: (First Part) + (New Character) + (Second Part).

The Script: A Basic Insertion Example​

Let's insert a hyphen (-) into the middle of the string "HelloWorld" at position 5.

@ECHO OFF
SET "OriginalString=HelloWorld"
SET "CharToInsert=-"
SET "Position=5"

ECHO Original String: %OriginalString%

REM Step 1: Get the first part (from index 0, for a length of 5)
SET "Part1=%OriginalString:~0,5%"

REM Step 2: Get the second part (from index 5 to the end)
SET "Part2=%OriginalString:~5%"

REM Step 3: Concatenate the pieces
SET "NewString=%Part1%%CharToInsert%%Part2%"

ECHO.
ECHO New String: %NewString%

Output:

Original String: HelloWorld

New String: Hello-World

How the Script Works​

The entire process relies on the substring extraction syntax.

  • %OriginalString:~0,5%: This gets the first part.
    • ~0: Starts at the beginning (index 0).
    • ,5: Takes 5 characters.
    • Result: Hello
  • %OriginalString:~5%: This gets the second part.
    • ~5: Starts at the 6th character (index 5).
    • The length is omitted, so it takes everything to the end of the string.
    • Result: World
  • SET "NewString=%Part1%%CharToInsert%%Part2%": This is a standard string concatenation that joins the three pieces into the final result.

Making it Reusable: An "Insert" Subroutine​

This multi-step process is perfect for a reusable subroutine. This allows you to call the logic easily without rewriting it every time.

@ECHO OFF
SETLOCAL

SET "MyData=ImportantInfo"
ECHO Before: %MyData%

REM Call the subroutine to modify the MyData variable
CALL :InsertString MyData "_file_" 9

ECHO After: %MyData%
GOTO :EOF


:InsertString
    REM Subroutine to insert a string into another.
    REM Usage: CALL :InsertString VarName StringToInsert Position
    SETLOCAL ENABLEDELAYEDEXPANSION
    SET "Original=!%1!"
    SET "ToInsert=%~2"
    SET "Pos=%3"

    SET "Part1=!Original:~0,%Pos%!"
    SET "Part2=!Original:~%Pos%!"
    SET "Result=!Part1!!ToInsert!!Part2!"

    ENDLOCAL & SET "%1=%Result%"
    GOTO :EOF

This powerful pattern uses SETLOCAL and ENDLOCAL to safely modify the variable passed by name (%1).

Common Pitfalls and How to Solve Them​

The Zero-Based Indexing System​

This is the most frequent source of errors. String positions in batch are zero-based. The first character is at index 0, the second at 1, and so on.

For the string HelloWorld:

  • H is at index 0.
  • W is at index 5.

Solution: Always remember this rule. To insert a character before the 6th character, you use position 5.

Using Insertion Inside a Loop (Delayed Expansion)​

If you are performing this operation inside a FOR loop on a variable that is changing, you must use delayed expansion with exclamation marks. Standard %VAR% expansion will not work correctly as it's evaluated only once before the loop starts.

@ECHO OFF
SETLOCAL ENABLEDELAYEDEXPANSION
SET "MyVar=ABC"

FOR %%i IN (1 2 3) DO (
    SET "Part1=!MyVar:~0,1!"
    SET "Part2=!MyVar:~1!"
    SET "MyVar=!Part1!_!Part2!"
    ECHO Result: !MyVar!
)

Output:

Result: A_BC
Result: A__BC
Result: A___BC

Practical Example: Formatting a Date String​

This is a classic use case. The script takes a raw date string like 20231027 and inserts hyphens to format it as 2023-10-27.

@ECHO OFF
SET "RawDate=20231027"
ECHO Original date: %RawDate%

REM --- Insert the first hyphen at position 4 ---
SET "Part1=%RawDate:~0,4%"
SET "Part2=%RawDate:~4%"
SET "FormattedDate=%Part1%-%Part2%"

REM --- Insert the second hyphen at position 7 of the *new* string ---
SET "Part1=%FormattedDate:~0,7%"
SET "Part2=%FormattedDate:~7%"
SET "FormattedDate=%Part1%-%Part2%"

ECHO.
ECHO Formatted date: %FormattedDate%

Output:

Original date: 20231027

Formatted date: 2023-10-27

Conclusion​

While batch scripting lacks a direct command for inserting characters, the "split and concatenate" method is a fully effective and reliable workaround.

The core of this technique is the powerful substring syntax:

  • %VAR:~0,index% gets the part before the insertion point.
  • %VAR:~index% gets the part from the insertion point to the end.

By combining these two extractions with your new character, you can perform any insertion operation needed. For cleaner and reusable code, encapsulating this logic in a subroutine is a highly recommended best practice.

Table of Contents