By the end of this tutorial, you’ll use Lodash’s _.times() to run a function a fixed number of times and collect results—without manual index increment logic.
_.times(n, fn)
Iteratee arg.
Of results.
Objects, IDs.
_.stubArray
Fn vs numbers.
_.times()?_.times(n, iteratee) calls iteratee exactly n times, passing the zero-based index 0 through n - 1 each time. It returns an array of whatever the iteratee returns on each call—unlike _.range(), which builds a numeric sequence without running your function.
_.times(3, i => i * 2) yields [0, 2, 4]. If the iteratee only logs and returns nothing, you get [undefined, undefined, undefined].
Use times to build placeholder arrays, generate sequential IDs, batch-index work, or pass stub helpers like _.stubArray when each iteration should produce a fresh value.
Invoke with a count and optional iteratee (defaults to _.identity):
_.times(n, [iteratee = _.identity])n — how many times to invoke the iteratee (converted to integer).0, 1, …, n - 1 only—no collection item.n < 1 — returns []; iteratee is never called.[0, 1, …, n - 1] via identity.import times from "lodash/times";
times(3, (i) => i * 2);
// [0, 2, 4]| Task | Code pattern | Result |
|---|---|---|
| Index array via identity | _.times(5) | [0, 1, 2, 3, 4] |
| Map index to value | _.times(3, i => i * 2) | [0, 2, 4] |
| Build objects | _.times(n, i => ({ id: i })) | Array of objs |
| Stub callback | _.times(2, _.stubString) | ['', ''] |
| Zero iterations | _.times(0, fn) | [] |
| Numeric sequence only | _.range(n) | Use range |
ArrayResults
0..n-1Iteratee arg
[]No calls
UtilIterate
Arguments to _.times() and how they shape the output:
n CountHow many times to invoke the iteratee. Coerced with toInteger. Values less than 1 yield [].
_.times(3, fn)iteratee OptionalFunction called per iteration with index 0..n-1. Defaults to _.identity.
(index) => valueindex ArgOnly argument passed to iteratee—zero-based, increasing by 1 each call.
0, 1, 2, ...return ArrayArray of each iteratee return value, in iteration order.
[r0, r1, r2]Need only a number sequence without a custom function? See _.range()—often clearer for start/end/step math.
Practical _.times() patterns with copy-ready code, sample output, and interactive Try It Yourself labs.
Run an iteratee n times and collect return values.
Each iteration receives the index; return whatever you want in the result array.
console.log(_.times(3, i => i * 2));
// [0, 2, 4]Indexes are 0, 1, 2. The iteratee runs three times; Lodash pushes each return value into the final array.
Omit the callback and Lodash uses _.identity—handy when you just need indexes.
console.log(_.times(3));
console.log(_.times(5));
// [0, 1, 2]
// [0, 1, 2, 3, 4]_.times(n) is similar to _.range(n) when you only need 0-based indexes—times runs a function; range builds numbers directly.
Generate sequential IDs or placeholder rows in one expression.
const items = _.times(4, i => ({
id: i + 1,
name: `Item ${i + 1}`
}));
console.log(items);
// [{ id: 1, name: "Item 1" }, …]Each object is created fresh on every call—unlike reusing one shared object in a manual loop.
Stub helpers, edge cases, and side effects.
Pass a stub function reference (no parentheses) so each iteration returns a new empty array.
const rows = _.times(3, _.stubArray);
console.log(rows);
console.log(rows[0] === rows[1]);
// [[], [], []]
// false_.stubArray is invoked per iteration—each slot gets its own []. See also _.stubArray().
Lodash returns [] without calling the iteratee—no manual guard needed.
console.log(_.times(0, () => "never"));
console.log(_.times(-2, () => "never"));
// []
// []When n < 1, the loop body never runs. This differs from a raw for loop where you must check bounds yourself.
times vs range, for loops, and Array.from.
Same length, different APIs—pick the one that reads best.
// Lodash times — callback per index
console.log(_.times(3, i => i * 10));
// [0, 10, 20]
// Lodash range — numbers only
console.log(_.range(3));
// [0, 1, 2]
// Native Array.from — flexible mapper
console.log(Array.from({ length: 3 }, (_, i) => i * 10));
// [0, 10, 20]Need only integers? _.range(). Need computed values per step? _.times. Need break or async? Use a for loop.
_.times() WorksIf n < 1, return an empty array immediately—no iteratee calls.
For each index, invoke the iteratee (default _.identity) with that index.
Push each return value onto a result array in iteration order.
A dense list of whatever your iteratee returned—ready for map, render, or further Lodash chaining.
_.identity, so _.times(n) yields [0, 1, …, n − 1].n < 1, you get [] and the iteratee is never called.undefined values)._.times() is Lodash’s counted loop helper: run a function n times, pass the index each time, and get back an array of results. It shines when each iteration produces data—objects, strings, or computed numbers.
Pair it with stub helpers for placeholder structures, or reach for _.range() when you only need a numeric sequence without invoking a callback.
_.times when you want an array of computed values in one expression_.stubArray) when each slot needs a fresh defaultn < 1 guard instead of redundant if-checks_.times when you only need integers—_.range is simpler() when you mean to pass the function reference_.times for async/await per iteration—use for…of or Promise.all_.times(1_000_000, …) unless you truly need every slot in memory_.times()Use these points whenever you need a counted loop that returns data.
Index 0 .. n−1.
CoreCollect results.
OutputIndexes only.
ShorthandNo calls.
EdgeCallback vs numbers.
CompareOmitting the iteratee makes _.times(n) behave like _.range(n)—both produce [0, 1, …, n − 1] because the default callback is _.identity.
Map indexes to values, build object lists, and try stub iteratees.
6 people found this page helpful