Skip to main content

How to Slice (Get a Sub-Array) from an Array in Batch Script

Sometimes you don't need an entire dataset, you only need a specific portion. For example, you might have a list of the last 100 log entries but only want to process the "Top 10" for a summary report. Array Slicing is the process of extracting a contiguous segment from an array based on a starting index and a specific length. This allows you to "Zoom in" on relevant data and ignore the rest.

In this guide, we will demonstrate how to slice an array using a targeted FOR /L loop.

The Strategy: The Windowed Loop​

To slice an array:

  1. Define your start index (where to begin the slice).
  2. Define your length (how many items to take).
  3. Loop from start to start + length - 1.
  4. Copy those elements to a new "Sub-Array."
note

This method uses 1-based indexing, matching the convention used throughout this guide series. The first element of the array is at index 1, not 0.

Implementation Script​

@echo off
setlocal enabledelayedexpansion

:: 1. Define the Source Array (Full List)
set "totalSize=8"
set "ARR_1=Alpha"
set "ARR_2=Beta"
set "ARR_3=Gamma"
set "ARR_4=Delta"
set "ARR_5=Epsilon"
set "ARR_6=Zeta"
set "ARR_7=Eta"
set "ARR_8=Theta"

echo Original Array: !ARR_1! !ARR_2! !ARR_3! !ARR_4! !ARR_5! !ARR_6! !ARR_7! !ARR_8!

:: 2. Slice Parameters
:: We want to take 3 items starting from index 4 (Delta, Epsilon, Zeta)
set "startIndex=4"
set "sliceLength=3"
set /a "endIndex=startIndex + sliceLength - 1"

:: 3. Bounds Checking
if !startIndex! LSS 1 (
    echo [ERROR] Start index must be 1 or greater.
    pause
    exit /b 1
)
if !endIndex! GTR !totalSize! (
    echo [WARNING] Slice extends beyond array bounds. Clamping to array size.
    set "endIndex=!totalSize!"
)

echo.
echo Slicing !sliceLength! items starting at index !startIndex!...

:: 4. Slicing Logic
set "subCount=0"

for /L %%i in (!startIndex!,1,!endIndex!) do (
    :: Use call to resolve the dynamic variable name
    call set "val=%%ARR_%%i%%"
    if defined val (
        set /a "subCount+=1"
        set "SUB_!subCount!=!val!"
    )
)

:: 5. Display Results
echo.
echo --- SUB-ARRAY RESULTS (!subCount! items^) ---
for /L %%i in (1,1,!subCount!) do (
    echo [%%i] !SUB_%%i!
)

endlocal
pause

Output:

Original Array: Alpha Beta Gamma Delta Epsilon Zeta Eta Theta

Slicing 3 items starting at index 4...

--- SUB-ARRAY RESULTS (3 items) ---
[1] Delta
[2] Epsilon
[3] Zeta

Why Slice an Array?​

  1. Pagination: If you are displaying a list of 500 files to a user, you can't show them all at once. Slicing allows you to show "Page 1" (items 1-10), "Page 2" (items 11-20), and so on.
  2. Head and Tail Extraction: Getting only the first few entries (the "Head") or the last few entries (the "Tail") of a prioritized task list.
  3. Data Filtering: If you know that the first 5 elements of an export are just "Metadata Headers," you can slice the array starting at index 6 to get only the actionable data rows.

Important Considerations​

warning

Always verify that your endIndex does not exceed the totalSize of the original array. Slicing past the end will reference undefined variables, producing blank entries in your sub-array. The implementation above includes a bounds-clamping guard to handle this automatically.

  1. Bounds Checking: Always verify that your endIndex does not exceed the totalSize of the original array. Trying to slice past the end will result in undefined values.
  2. Indexing Base: Remember whether your array starts at 0 or 1. If you miscalculate the startIndex, your data will be "Off by one."
  3. Memory Scope: Using setlocal is recommended inside slicing functions to ensure your temporary counters don't interfere with the main script logic.

Best Practices​

  1. Dynamic Slicing: Use variables for your start and length so your script can adapt based on user input or file size.
  2. Sub-naming: Use a clear name for your sliced array (like SUB_ or EXTRACTED_) so it is distinct from the source array in your debugging output.
tip

To extract the last N items from an array (a "Tail" slice), calculate the start index dynamically: set /a "startIndex=totalSize - sliceLength + 1". This always gives you the final sliceLength elements regardless of the array's total size.

Conclusion​

Array slicing is a versatile tool for data management that provides surgical precision when handling large datasets. By extracting only the segments you need, you reduce the processing overhead and keep your automation focused on the most relevant information. Whether you are paginating a UI or stripping headers from a system export, the ability to "slice and dice" your data arrays is a hallmark of professional, high-performance scripting.

Table of Contents