Lodash _.toPath() Method

What You’ll Learn

By the end of this tutorial, you’ll know how Lodash _.toPath() turns path strings into key arrays for safe nested object work.

What Is _.toPath()?

_.toPath() is a Lodash utility that converts a property path into an array of keys. Developers often write paths as strings ("user.address.city"), but many algorithms work more cleanly with arrays (["user", "address", "city"]).

Lodash uses this internally when you pass string paths to _.get(), _.set(), and related methods. Calling _.toPath() yourself is useful when you need the array for custom utilities, validation, or logging.

📝 Syntax

Pass a string path or an existing key array:

_.toPath(value)

Syntax Rules

• value — a path string, or an array of keys (strings/numbers).
• String input — dots split segments; brackets extract indices or quoted keys.
• Array input — returns a new shallow copy of the array.
• Return value — always an array of path segments (strings).
• No object access — parsing only; use _.get / _.set to read or write values.

import toPath from "lodash/toPath";

toPath("a.b[0].c");
// -> ["a", "b", "0", "c"]

Examples Gallery

Practical _.toPath() patterns with copy-ready code, sample output, and interactive Try It Yourself labs.

const pathString = "user.address.city";
const pathArray = _.toPath(pathString);

console.log(pathArray);
// -> ["user", "address", "city"]

["user", "address", "city"]

const pathString = "a.b[0].c.d";
const pathArray = _.toPath(pathString);

console.log(pathArray);
// -> ["a", "b", "0", "c", "d"]

// Naive split would fail:
console.log("a.b[0].c.d".split("."));
// -> ["a", "b[0]", "c", "d"]  — wrong

toPath:   ["a", "b", "0", "c", "d"]
split:    ["a", "b[0]", "c", "d"]

function normalizePath(input) {
  return _.toPath(input);
}

console.log(normalizePath("items[1].name"));
// -> ["items", "1", "name"]

console.log(normalizePath(["items", "1", "name"]));
// -> ["items", "1", "name"] (shallow copy)

["items", "1", "name"]
["items", "1", "name"]

const userConfig = {
  user: {
    name: "John",
    address: { city: "Anytown", zip: "12345" }
  }
};

const pathString = "user.address.city";
const city = _.get(userConfig, _.toPath(pathString));

console.log(city);
// -> "Anytown"

Anytown

const target = {};
const segments = ["user", "address", "city"];
const pathString = segments.join(".");
const pathArray = _.toPath(pathString);

_.set(target, pathArray, "Anytown");

console.log(target);
// -> { user: { address: { city: "Anytown" } } }

{ user: { address: { city: "Anytown" } } }

const fieldPaths = [
  "user.name",
  "user.address.city",
  "orders[0].total"
];

const parsed = fieldPaths.map(_.toPath);

console.log(parsed);
// -> [
//   ["user", "name"],
//   ["user", "address", "city"],
//   ["orders", "0", "total"]
// ]

[
  ["user", "name"],
  ["user", "address", "city"],
  ["orders", "0", "total"]
]

📝 Notes

• _.toPath() does not access objects—it only converts path notation.
• Bracket indices become strings ("0", "1"), which is what _.get expects for arrays.
• split(".") is not a substitute when paths contain [index] segments.
• _.get(obj, "a.b") already parses strings internally—explicit _.toPath() is for when you need the array itself.
• Validate user-supplied paths with an allow-list; parsing is not the same as sanitizing.
• Next in the series: _.uniqueId() for incrementing string labels.

💡 Best Practices