Skip to main content

How to Convert Tabs to Spaces in a Text File in Batch Script

The "Tabs vs. Spaces" debate is more than just a preference in modern computing; it is a matter of file portability. Tabs (represented by the \t character) can vary in width depending on the viewer, often making code or reports look messy and unaligned when moved between different editors. Converting all tabs to a fixed number of spaces (known as "expansion") ensures that your text files look identical on any device.

In this guide, we will demonstrate how to automate the conversion of tabs to spaces using Batch and a PowerShell bridge.

The Strategy: String Replacement​

Batch strings do not natively handle the tab character reliably. To identify and replace tabs throughout an entire file, we use a PowerShell command that can be called directly from your Batch script.

This method is the most robust because it handles the entire replacement inside PowerShell, where the tab character and space padding are both represented precisely.

Implementation Script​

@echo off
setlocal

set "Source=ReportWithTabs.txt"
set "Dest=ReportWithSpaces.txt"
set "SpaceCount=4"

:: Verify source file exists
if not exist "%Source%" (
    echo [ERROR] Source file "%Source%" not found.
    pause
    exit /b 1
)

echo Converting tabs to %SpaceCount% spaces in "%Source%"...

:: Safe environment-variable bridge avoids quoting issues in filenames
:: [int]$env:SpaceCount ensures safe numeric multiplication
powershell -NoProfile -Command ^
    "$spaces = ' ' * [int]$env:SpaceCount; " ^
    "(Get-Content -LiteralPath $env:Source -ErrorAction Stop) -replace \"`t\", $spaces | " ^
    "Set-Content -LiteralPath $env:Dest"

if %errorlevel% equ 0 (
    echo [SUCCESS] Tabs replaced with %SpaceCount% spaces.
    echo           Result saved to "%Dest%".
) else (
    echo [ERROR] PowerShell conversion failed.
    pause
    exit /b 1
)
pause
exit /b 0
tip

The replacement string is built inside PowerShell with ' ' * %SpaceCount% rather than being assembled in Batch with a for /L loop. This avoids the problem of the Batch-assembled padding variable requiring enabledelayedexpansion (which would corrupt any ! characters in file paths) and ensures the exact number of spaces is passed cleanly to the -replace operator.

Method 2: The Inline One-Liner​

If you need a quick conversion from the command line without writing a full script, you can use a single PowerShell command.

powershell -NoProfile -Command "(Get-Content 'input.txt') -replace \"`t\", '    ' | Set-Content 'output.txt' -Encoding UTF8"
warning

The inline method hardcodes 4 spaces as a literal string (' '). If you later need to change the space count, you must manually count and edit the spaces inside the quotes, which is error-prone. For repeatable use, Method 1 with its %SpaceCount% variable is more maintainable.

Method 3: Converting Spaces Back to Tabs​

In some workflows you may need the reverse operation, converting leading spaces back to tabs for a system that requires tab-indented input.

@echo off
setlocal

set "Source=SpacedFile.txt"
set "Dest=TabbedFile.txt"
set "SpaceCount=4"

:: Verify source file exists
if not exist "%Source%" (
    echo [ERROR] Source file "%Source%" not found.
    pause
    exit /b 1
)

echo Converting leading spaces (groups of %SpaceCount%^) to tabs in "%Source%"...

:: Uses environment variables and a robust ForEach pipeline.
:: The regex '^(\t*) {n}' finds leading tabs followed by exactly N spaces,
:: replacing them with the tabs plus one more tab, until all indents are converted.
powershell -NoProfile -Command ^
    "$cnt = [int]$env:SpaceCount; " ^
    "$pat = \"^(\t*) {$cnt}\"; " ^
    "Get-Content -LiteralPath $env:Source -ErrorAction Stop | ForEach-Object { " ^
    "  $l = $_; " ^
    "  while ($l -match $pat) { $l = $l -replace $pat, \"`$1`t\" }; " ^
    "  $l " ^
    "} | Set-Content -LiteralPath $env:Dest"

if %errorlevel% equ 0 (
    echo [SUCCESS] Leading spaces converted to tabs.
    echo           Result saved to "%Dest%".
) else (
    echo [ERROR] PowerShell conversion failed.
    pause
    exit /b 1
)
pause
exit /b 0
info

Method 3 only converts leading spaces (indentation) to tabs. Spaces within the body of a line are left untouched. A naive global replacement of every 4-space sequence would corrupt string literals, aligned comments, and column-formatted data. The regex anchors to ^ and loops through each indentation level to handle nested indentation correctly.

Why Convert Tabs to Spaces?​

  1. Code Consistency: In programming, indentation is critical. Using spaces prevents indentation errors triggered by mixing tabs and spaces in Python or YAML files.
  2. Report Alignment: If you create a table and use tabs for columns, the table will break if a user opens it in a terminal or editor with a different tab-width setting.
  3. Terminal Output: Many standard Windows terminal consoles do not interpret tabs consistently, often causing text to run together or wrap awkwardly.

Handling Tab Stops vs. Simple Replacement​

A true "expansion" tool does not just swap 1 tab for N spaces; it calculates how many spaces are needed to reach the next "tab stop" (every 4th or 8th column). For example, if a tab appears at column 2 with tab stops every 4 columns, it should expand to 2 spaces (to reach column 4), not 4 spaces.

For the vast majority of use cases, configuration files, log cleanup, code indentation, the simple replacement approach in Method 1 produces correct results because tabs appear at consistent indentation positions. True tab-stop-aware expansion is only necessary when tabs are used for mid-line column alignment, which requires tracking the column position of each character on every line.

Best Practices​

  1. Verify Source File: Always check that the input file exists before processing. A missing file will cause PowerShell to throw an exception that may not produce a clear Batch-level error.
  2. Preserve the Original: Always save the result to a new file. If the conversion produces unexpected output, you do not want to have lost your original data.
  3. Standard Width: Use 4 spaces as your default. This is the industry standard for most configuration files and codebases.
  4. Specify Encoding: Always include -Encoding UTF8 in the Set-Content command. Without it, PowerShell 5.1 uses the system's default ANSI code page, which can corrupt non-ASCII characters such as accents, symbols, or international text.
  5. Direction Awareness: Verify whether you need tabs-to-spaces or spaces-to-tabs before running. Converting in the wrong direction and overwriting the original file results in a formatting change that is tedious to reverse manually.
  6. Path Limitations: If your file paths contain single quotes, the PowerShell commands will break because the paths are wrapped in single-quote delimiters. Rename the file or use escaped quoting for such edge cases.

Conclusion​

Converting tabs to spaces is a small but powerful sanitization step for your text data. By automating this process, you eliminate the visual unpredictability of tab characters and ensure that your files remain clean, professional, and readable across all platforms and editors. Whether you are cleaning up a log or preparing code for a cross-platform commit, these scripts provide the consistency your project needs.

Table of Contents