By the end of this tutorial, you’ll use wrapper .at() inside Lodash chains to pluck nested values by path and unwrap with .value().
_(obj).at(paths)
Dotted & bracket paths.
Always returns value[].
Same logic, chain style.
Many paths at once.
Finish with .value().
.at()?Wrapper .at() is the chainable version of _.at(). Call it on a Lodash sequence wrapper to extract values at one or more property paths from the wrapped object or array, then continue chaining or unwrap with .value().
_.prototype.at()There is no _.prototype.at() function. The correct call is _(object).at('a.b.c').value() or _.chain(object).at(['name', 'email']).value().
Use wrapper .at() when you already have a chain and want to pluck several nested fields in one step—API responses, form prefill data, or config snapshots.
Call .at() on a wrapper; pass one path or many:
_(object).at(paths)
// or
_.chain(object).at(path1, path2, ...)paths — string path(s), array of paths, or rest arguments ('a', 'b.c')..value()) — always an array of values in path order.undefined at that index; no exception is thrown.'address.city') or bracket segments ('a[0].b').[['weird.key']] (see _.at()).import _ from "lodash";
const object = { a: [{ b: { c: 3 } }, 4] };
const extracted = _(object)
.at(["a[0].b.c", "a[1]"])
.value();
// extracted -> [3, 4]| Task | Code pattern | Result |
|---|---|---|
| Single nested path | _(obj).at('a.b.c') | [value] array |
| Multiple paths | .at('name', 'email') | [name, email] |
| Path array | .at(['a[0].b', 'a[1]']) | Values in order |
| Direct equivalent | _.at(obj, paths) | See _.at() |
| One path, one value | _.get(obj, path) | See _.get() |
| Finish chain | ... .value() | Plain array |
.at(paths)Many paths → array
.get(path)One value
.value()Plain array
Arguments to wrapper .at() and what you get after .value():
paths RequiredOne or more path strings (or an array of paths) to read from the wrapped value.
.at('name', 'address.city')return (wrapper) WrapperAnother Lodash wrapper with the pluck step queued until unwrap.
_(obj).at('a.b').value() result ArrayAlways an array of extracted values, aligned with path order.
.value() // -> [3, 4]missing path undefinedAbsent paths produce undefined at that index—no throw.
.at('missing') // -> [undefined]Same path rules as _.at(); wrapper .at() is for fluent chains only.
Practical wrapper .at() patterns with sample output and interactive Try It Yourself labs.
Wrap an object, call .at() with paths, unwrap with .value().
Pull values from deeply nested objects using dot and bracket path notation.
const object = { a: [{ b: { c: 3 } }, 4] };
const extracted = _(object)
.at(["a[0].b.c", "a[1]"])
.value();
console.log(extracted);
// -> [3, 4]Each path string is resolved against the wrapped object. Results are collected into an array in the same order as the paths you passed.
Pass several paths as separate arguments instead of wrapping them in an array.
const user = {
name: "Alice",
email: "alice@example.com",
address: { city: "Portland", zip: "97201" }
};
const fields = _(user)
.at("name", "email", "address.city")
.value();
console.log(fields);
// -> ["Alice", "alice@example.com", "Portland"]Real-world plucking from API payloads, handling missing data, and comparing approaches.
Extract only the fields you need from a nested API payload inside a chain.
const apiResponse = {
data: {
name: "John Doe",
email: "john@example.com",
address: { city: "New York", zip: "10001" }
},
meta: { requestId: "abc-123" }
};
const requiredFields = ["data.name", "data.email", "data.address.city"];
const extracted = _(apiResponse).at(requiredFields).value();
console.log(extracted);
// -> ["John Doe", "john@example.com", "New York"]Lodash does not throw when a path is absent—the slot is undefined.
const config = { server: { host: "localhost" } };
const values = _(config)
.at("server.host", "server.port", "database.name")
.value();
console.log(values);
// -> ["localhost", undefined, undefined]When to use wrapper .at() versus direct _.at() or _.get().
Both produce the same array—wrapper form fits inside longer chains.
const object = { a: [{ b: { c: 3 } }, 4] };
const paths = ["a[0].b.c", "a[1]"];
const chained = _(object).at(paths).value();
const direct = _.at(object, paths);
console.log(JSON.stringify(chained) === JSON.stringify(direct));
// -> trueUse .get() for one value; use .at() when you need several paths at once.
const user = {
name: "Bob",
profile: { age: 28, city: "Austin" }
};
const single = _(user).get("profile.city").value();
// -> "Austin" (one value)
const many = _(user).at("name", "profile.age", "profile.city").value();
// -> ["Bob", 28, "Austin"] (array)
console.log(single);
console.log(many);.at() WorksStart with _(object) or _.chain(object) so Lodash knows the source for path resolution.
.at(paths)Lodash resolves each path against the wrapped value—dot notation, brackets, and array indices all work.
.value()The pipeline runs and you receive a plain array of extracted values, ordered to match your paths.
_.at()Wrapper .at() delegates to _.at()—use it when path plucking belongs in the middle of a longer chain.
_.prototype.at() function—the correct name is wrapper .at() on a sequence object..value(), the result is always an array, even for a single path ([value]).undefined at that index; Lodash does not throw..get(path, default) or _.get().Wrapper .at() lets you pluck one or many nested values inside a Lodash chain. Pass path strings, unwrap with .value(), and get an ordered array of results. It is the fluent companion to _.at()—ideal for API responses, form prefill, and config parsing when you are already chaining.
Next in the wrapper prototype series: .chain(), which re-wraps a value mid-pipeline for nested sequences.
.at() when plucking several nested paths inside an existing chainconst FIELDS = [...]) for reuse and clarityundefined slots when paths may be missing on partial data.get() when you only need one value with an optional default_.prototype.at()—that name does not exist in Lodash.at() for top-level key picking when .pick() returns a cleaner object.value() and treat the wrapper as the final array.at() when a direct _.at(obj, paths) call is simpler.at()Use these when plucking nested paths inside Lodash chains.
_(obj).at(...)
CoreAlways [values].
ReturnDirect equivalent.
EquivalentMany paths vs one.
Compareundefined slots.
SafetyWrapper .at() always returns an array—even when you pass a single path like 'a.b.c', you get [value] after .value(). That is why _.get() is better when you need one scalar with a default, while .at() shines when plucking several fields in order.
Pluck nested paths, compare with direct _.at(), and unwrap results instantly.
6 people found this page helpful