Lodash _.toPairs() Method

What You’ll Learn

By the end of this tutorial, you’ll use _.toPairs() to turn objects into arrays of [key, value] tuples for iteration and transformation.

What Is _.toPairs()?

_.toPairs() converts a plain object into an array of two-element arrays— each inner array is a [key, value] tuple. It is Lodash’s version of Object.entries() and is the object-side counterpart to _.fromPairs(), which does the reverse.

Use it when building forms from object data, transforming keys, serializing for APIs, or piping object data through Lodash chains before converting back with _.fromPairs().

📝 Syntax

The signature takes one argument—the object to convert:

_.toPairs(object)

Syntax Rules

• object — any object (or object-like value Lodash accepts).
• Return value — array of [key, value] tuples.
• Included keys — own enumerable string-keyed properties only.
• Excluded — symbol keys and non-enumerable properties are skipped.
• Nested values — stay as-is inside the value slot (not flattened).

import toPairs from "lodash/toPairs";

const myObject = { a: 1, b: 2, c: 3 };
const pairs = toPairs(myObject);

// pairs -> [["a", 1], ["b", 2], ["c", 3]]

Examples Gallery

Practical _.toPairs() patterns with sample output and interactive Try It Yourself labs.

const myObject = { a: 1, b: 2, c: 3 };
const pairsArray = _.toPairs(myObject);

console.log(pairsArray);
// -> [["a", 1], ["b", 2], ["c", 3]]

[["a", 1], ["b", 2], ["c", 3]]

const user = { name: "John", age: 30, city: "New York" };

_.toPairs(user).forEach(([key, value]) => {
  console.log(key + ": " + value);
});
// name: John
// age: 30
// city: New York

name: John
age: 30
city: New York

const nestedObject = { a: { nestedProp: 1 }, b: 2 };
const nestedPairs = _.toPairs(nestedObject);

console.log(nestedPairs);
// -> [["a", { nestedProp: 1 }], ["b", 2]]

[["a", { nestedProp: 1 }], ["b", 2]]

const config = { theme: "dark", lang: "en" };

const uppercased = _.fromPairs(
  _.map(_.toPairs(config), ([key, value]) => [key.toUpperCase(), value])
);

console.log(uppercased);
// -> { THEME: "dark", LANG: "en" }

{ THEME: "dark", LANG: "en" }

const original = { x: 10, y: 20 };
const pairs = _.toPairs(original);
const restored = _.fromPairs(pairs);

console.log(restored);
// -> { x: 10, y: 20 }

{ x: 10, y: 20 }

const obj = { a: 1, b: 2 };

const lodashPairs = _.toPairs(obj);
const nativePairs = Object.entries(obj);

console.log(JSON.stringify(lodashPairs) === JSON.stringify(nativePairs));
// -> true

true

📝 Notes

• _.toPairs() does not mutate the source object—it returns a new array.
• Only own enumerable string-keyed properties are included.
• Nested object values are not flattened into more pairs.
• Property order follows modern JavaScript enumeration rules (integer-like keys first, then strings in insertion order).
• For inherited enumerable keys, use _.toPairsIn().
• Rebuild objects with _.fromPairs() or native Object.fromEntries().

💡 Best Practices