Overview
Introduction
Sometimes a single pasted list actually represents two logical groups, a header section and a body, or a "before" batch and an "after" batch, that need to be worked on separately.
List Splitter cuts a list into exactly two pieces at whatever position you choose, without dropping or reordering a single item.
What Is List Splitter?
A tool that divides one list into two lists at a 1-based cut index: items from the start up to that index form list A, everything remaining forms list B.
It shares the same configurable separator (newline, comma, or custom delimiter) as the rest of the List category.
How List Splitter Works
The input is split into items on the resolved separator, the cut index is clamped into the valid [0, length] range, and Array.prototype.slice divides the items at that point.
Both resulting lists are rejoined using the same separator and delimiter settings as the input, so the output format matches what you started with.
When To Use List Splitter
Use it to peel off a fixed-size batch of items (say, the first 10) from the rest of a longer list for separate processing.
It's also useful for A/B-style workflows where you need to route the front and back portions of a list to two different destinations.
Often used alongside List Merger, Sublist Extractor and List Slicer.
Features
Advantages
- Guarantees no items are lost, added, or reordered, the two outputs always recombine to the original list.
- Clamped indexing means you never get an error for an index that's too large or negative, just a sensible empty side.
- Works with any separator, so it isn't limited to newline-delimited lists.
Limitations
- Only produces a single cut point; run it twice (or use Sublist Extractor) if you need to pull out a middle range instead.
- Doesn't validate that both halves are non-empty, an index at either extreme will happily produce one empty output.
Examples
Best Practices & Notes
Best Practices
- Count items carefully with a custom separator, since visually similar delimiters (like a period vs. a comma) change where items are split.
- Use Sublist Extractor instead if you only care about the itemsin one range and want to discard the rest.
Developer Notes
The cut index is clamped with Math.min(Math.max(index, 0), items.length) before calling Array.prototype.slice twice, once for each half, so out-of-range input degrades gracefully instead of throwing.
List Splitter Use Cases
- Separating a header batch of items from the remainder of a longer list
- Dividing a list roughly in half for two-person or two-step review
- Peeling off a known-size prefix (like the first N results) for separate handling
Common Mistakes
- Expecting the index to be 0-based like an array index; it counts items starting from 1, so index 2 means "after the second item."
- Assuming an out-of-range index produces an error; it's silently clamped instead.
- Forgetting that both outputs use the same separator as the input, not necessarily the one you'd choose for display.
Tips
- Try index 0 or a very large index to quickly sanity-check which output holds "everything."
- Pair with List Merger to verify the two halves recombine exactly to your original list.