Is the range inclusive of both start and end?

Yes, both the start and end index are included in the result, so start=2, end=4 returns items 2, 3, and 4.

What happens with an out-of-range start or end?

Both are clamped into the list's valid range instead of erroring, so an end larger than the list length just returns up to the last item.

What if start is greater than end after clamping?

You get an empty result rather than an error, since that's a well-defined (if unusual) empty range.

How is this different from List Slicer?

List Slicer mirrors JavaScript's Array.prototype.slice exactly: 0-based, negative indices count from the end, and the end index is exclusive. This tool uses simpler 1-based inclusive indices and clamps instead of behaving like slice's negative-index wraparound.

Sublist Extractor Online - Extract a Range of List Items

Overview

Introduction

Pulling out just items 5 through 10 of a long pasted list by hand means carefully counting and copying, easy to get wrong on a big list.

Sublist Extractor does that range selection for you with simple, human-friendly 1-based indices.

What Is Sublist Extractor?

A tool that extracts a contiguous inclusive range of items from a list, from a 1-based start index through a 1-based end index.

It clamps out-of-range bounds into the list's valid range rather than erroring, so you don't need to know the exact item count ahead of time.

How Sublist Extractor Works

The input is split into items on the resolved separator, then both the start and end index are clamped into [1, length].

If the clamped start is still after the clamped end, the result is an empty list; otherwise Array.prototype.slice extracts the inclusive range and it's rejoined with the same separator.

When To Use Sublist Extractor

Use it to pull out a specific page or chunk of items (say, items 21-30) from a longer list.

It's also useful when you only remember roughly where a range starts or ends and want the tool to clamp gracefully rather than error.

Often used alongside List Slicer, List Splitter and List Splicer.

Features

Advantages

1-based inclusive indexing matches how people naturally describe "items 3 through 7".
Clamping means you never have to know the exact list length before choosing an end index.
Works with any separator, not just newline-delimited lists.

Limitations

Only extracts one contiguous range per run; use List Splicer or run twice for non-contiguous selections.
Silently clamps rather than warning when your requested range partially exceeds the list, double-check the output length if that distinction matters.

Examples

Extract items 2 through 4

Input

a
b
c
d
e

Output

b
c
d

Start=2, end=4 returns the 2nd, 3rd, and 4th items inclusive.

End index beyond the list length

Input

x,y,z (start=2, end=99)

Output

y, z

End=99 is clamped down to the list's actual length (3), so the result runs from item 2 to the last item.

Best Practices & Notes

Best Practices

Use a generously large end index (like 9999) if you just want "everything from item N onward" without counting the list first.
Use List Slicer instead if you need exact JavaScript slice semantics, including negative indices counting from the end.

Developer Notes

Both bounds are clamped with Math.min(Math.max(n, 1), items.length) before converting to a 0-based Array.prototype.slice(start - 1, end) call, so out-of-range input degrades gracefully instead of throwing or silently misindexing.

Sublist Extractor Use Cases

Pulling a specific page of results (like items 21-30) out of a longer list
Extracting a known range of rows from a pasted spreadsheet column
Grabbing everything from a rough starting point onward using a deliberately large end index

Common Mistakes

Expecting an error when end exceeds the list length; it's clamped silently instead.
Assuming 0-based indexing, like a JavaScript array, when this tool uses 1-based inclusive indices.
Reaching for this tool when exact negative-index slice semantics are needed; use List Slicer for that instead.

Tips

Pair with List Splitter if you want to see the range you extracted alongside everything else that was left out.
Use List Slicer if you specifically need negative indices to count from the end of the list.

Sublist Extractor