By the end of this tutorial, you’ll use Lodash’s _.range() to build number arrays for loops, indexes, and pagination—without writing manual increment logic.
_.range(start, end, step)
_.range(5) → 0..4
End not included.
Skip by 2, 5, etc.
Negative step.
Reverse order.
_.range()?_.range() creates an array of numbers in order—like Python’s range. You control where the sequence starts, where it stops (exclusive), and how much it steps each time. It is one of the most practical Lodash helpers for replacing for (let i = 0; i < n; i++) when you need the index array itself.
_.range(5) is [0, 1, 2, 3, 4]. The lone number is the end, not the start. Start defaults to 0.
Use range for iteration helpers, zero-based indexes, page-number lists, chart tick marks, and any time you need a predictable numeric sequence in one expression.
All arguments are optional except that you need at least one value for a non-empty result:
_.range([start = 0], end, [step = 1 or -1])end; start is 0. _.range(4) → [0, 1, 2, 3].start and end (exclusive). Step defaults to 1 if start < end, else -1.step (can be negative for countdowns)._.range(0) returns []; invalid step/end combos may also yield [].import range from "lodash/range";
range(1, 6, 2);
// [1, 3, 5]| Task | Code pattern | Result |
|---|---|---|
| Zero to n − 1 | _.range(n) | [0..n−1] |
| Start to end | _.range(1, 5) | [1, 2, 3, 4] |
| Step by 2 | _.range(0, 10, 2) | [0, 2, 4, 6, 8] |
| Countdown | _.range(5, 0, -1) | [5, 4, 3, 2, 1] |
| Loop indexes | _.range(items.length) | 0..len−1 |
| Descending order | _.rangeRight(...) | Reversed |
ArrayNumbers
ExclusiveNot included
±1By direction
UtilSequence
Arguments to _.range() and how they shape the output:
start OptionalFirst value in the sequence. Defaults to 0 when only one argument is passed (that arg becomes end).
_.range(2, 5) // start 2end Required*Stop boundary—exclusive. With one arg, it is the only number you pass: _.range(end).
_.range(1, 5) // stops before 5step OptionalIncrement (or decrement when negative). Defaults to 1 or -1 based on start vs end.
_.range(0, 20, 5)return ArrayDense array of numbers following the progression until the next step would reach or pass end.
[0, 1, 2, 3, 4]Official edge case: _.range(1, 4, 0) repeats 1 (step zero)—rare in practice; prefer positive or negative steps.
Practical _.range() patterns with copy-ready code, sample output, and interactive Try It Yourself labs.
Start, end, and step—the core progression pattern.
From 1 up to (but not including) 6, stepping by 2.
console.log(_.range(1, 6, 2));
// [1, 3, 5]Values are 1, then +2 → 3, then +2 → 5. Next would be 7, which reaches past end 6, so the array stops.
Common shorthands from the Lodash docs.
console.log(_.range(5));
console.log(_.range(1, 10, 2));
console.log(_.range(0));
// [0, 1, 2, 3, 4]
// [1, 3, 5, 7, 9]
// []_.range(5) means “zero up to five (exclusive).” _.range(0) has nowhere to go, so you get an empty array.
Includes negative direction when start and end flip.
console.log(_.range(4));
console.log(_.range(-4));
console.log(_.range(1, 5));
console.log(_.range(0, 20, 5));
console.log(_.range(0, -4, -1));
// [0, 1, 2, 3]
// [0, -1, -2, -3]
// [1, 2, 3, 4]
// [0, 5, 10, 15]
// [0, -1, -2, -3]_.range(-4) is shorthand for start 0, end -4, default step -1—handy to remember when the lone argument is negative.
Loops, pagination, and countdown sequences.
When start is greater than end, pass a negative step (or rely on the default -1 with two args).
console.log(_.range(5, 1, -1));
console.log(_.range(5, 0, -1));
// [5, 4, 3, 2]
// [5, 4, 3, 2, 1]End is still exclusive: _.range(5, 1, -1) stops before 1, so 1 is omitted. Include zero by using end 0 with step -1 carefully, or use _.range(5, 0, -1).
Build [1, 2, …, totalPages] for a pager UI.
const itemsPerPage = 10;
const totalItems = 87;
const totalPages = Math.ceil(totalItems / itemsPerPage);
const pageNumbers = _.range(1, totalPages + 1);
console.log(pageNumbers);
// [1, 2, 3, 4, 5, 6, 7, 8, 9]Pages are 1-based, so start at 1 and use end totalPages + 1 because end is exclusive.
range vs native alternatives and rangeRight.
Same length indexes—different APIs. Descending values vs descending array order.
// Lodash range — explicit start/end/step
console.log(_.range(2, 5));
// [2, 3, 4]
// Native — length-based indexes
console.log(Array.from({ length: 3 }, (_, i) => i + 2));
// [2, 3, 4]
// Same numbers, reversed array order (see rangeRight tutorial)
console.log(_.rangeRight(2, 5));
// [4, 3, 2]Need countdown values? Use negative step with range. Need the array stored high-to-low? Use rangeRight.
_.range() WorksOne arg → start 0, that arg is end. Infer step sign from start vs end if omitted.
Push current value, add step, repeat until the next value would cross end.
The end boundary itself is never pushed—same rule as Python range.
A dense list ready for map, for…of, pagination UI, or index lookups.
_.range(n) is 0 through n - 1, not 1 through n._.range(1_000_000) unless you truly need every index in memory._.range() is the quick way to materialize numeric sequences in JavaScript. Once you internalize “one arg = end, exclusive stop,” it becomes a go-to for indexes, pagers, and loop helpers.
Pair it with collection methods (_.map(_.range(n), …)) or use native for…of—choose the style that reads best in your project.
_.range(n) for 0-based indexes of length n_.map to build derived arrays from indexes_.range(5) includes 5—it stops at 40 unless you intentionally want repeated values_.range()Use these points whenever you need a numeric sequence array.
Stop before end.
Rule0 .. n−1.
ShorthandCustom stride.
ControlCount down.
PatternReverse order.
CompareLodash’s _.range(-4) yields [0, -1, -2, -3] because the single argument becomes an exclusive end below zero with default step -1—not a length of four positive numbers.
Try step-by-two sequences, countdown ranges, and pagination page numbers.
6 people found this page helpful