Implement lodash.get(obj, path, defaultValue)

Q: Implement lodash.get(obj, path, defaultValue)

**Target Audience:** Engineers preparing for practical JavaScript coding interviews. **Difficulty:** Medium > **How to read this doc:** the real, easy-to-get-wrong detail this question tests — correctly distinguishing "the value IS a real falsy value" from "the value is genuinely MISSING" — was verified directly: `get({a: 0}, "a", "fallback")` correctly returned the real `0`, not `"fallback"`, confirming the missing-vs-falsy distinction is handled correctly via an explicit `=== undefined` check, not a naive truthiness check. ## 1. The problem, restated Safely walk a dot-notation (or array-bracket) path string through a nested object, returning the value found at the end of that path — or `defaultValue` if the path genuinely does not fully resolve (some segment along the way is `null`/`undefined`, or the final value itself is genuinely `undefined`) — critically, WITHOUT confusing a real, present FALSY value (like `0`) with a genuinely missing one. ## 2. Clarifying questions a strong

The problem

Problem, as an interviewer would state it: "Implement get(obj, path, defaultValue) — safely reading a deeply nested value from an object via a dot-notation (or array-bracket) path string, returning defaultValue if any part of the path is genuinely missing, matching lodash's own well-known _.get behavior."

Examples:

Code

get({a: {b: {c: 42}}}, "a.b.c"); // 42
get({a: 1}, "x.y.z", "fallback"); // "fallback"

Clarifying questions expected:

Does the path need to support BOTH dot notation ("a.b.c") AND array-bracket notation ("a[0].b"), or just one format?
If the actual value at the path is a genuine FALSY value (like 0, false, or an empty string), should the default still correctly NOT be used?
Should the path also be acceptable as a pre-split array of keys, not just a string?

Code / implementation expected: Yes — real, direct proof of correct dot/bracket path access, correct fallback on a genuinely missing path, and — critically — confirmation a genuine falsy value at the path is correctly returned, not confused with "missing."

array
get
lodash-get
path

Try it yourself

Sketch your approach before you read the solution. That is what the interview tests.

Stuck? Get a hint.

A short nudge toward the approach. It will not give the answer away.

Solution

Target Audience: Engineers preparing for practical JavaScript coding interviews. Difficulty: Medium

How to read this doc: the real, easy-to-get-wrong detail this question tests — correctly distinguishing "the value IS a real falsy value" from "the value is genuinely MISSING" — was verified directly: get({a: 0}, "a", "fallback") correctly returned the real 0, not "fallback", confirming the missing-vs-falsy distinction is handled correctly via an explicit === undefined check, not a naive truthiness check.

1. The problem, restated

Safely walk a dot-notation (or array-bracket) path string through a nested object, returning the value found at the end of that path — or defaultValue if the path genuinely does not fully resolve (some segment along the way is null/undefined, or the final value itself is genuinely undefined) — critically, WITHOUT confusing a rea

The solution is hidden so you can try first

7 min read · 9 sections

Run the code

Edit the code and run it here. Each console line with an expected value becomes a test.

JavaScriptReal, direct proof: get() correctly walks dot and bracket-notation paths, falls back to a default on a genuinely missing path, and correctly preserves a real falsy value like 0