Lodash _.toPairsIn() Method

What You’ll Learn

By the end of this tutorial, you’ll use _.toPairsIn() to list own and inherited enumerable keys as [key, value] pairs.

What Is _.toPairsIn()?

_.toPairsIn() is like _.toPairs(), but it walks the prototype chain and includes inherited enumerable string-keyed properties too. Think of it as turning a for...in loop into an array of [key, value] tuples.

Use it for object inspection, debugging prototype-augmented instances, and understanding what enumerable keys exist beyond own properties. For API payloads and plain config objects, _.toPairs() is usually the safer default.

📝 Syntax

The signature takes one argument—the object to convert:

_.toPairsIn(object)

Syntax Rules

• object — the object to convert (instances, plain objects, etc.).
• Return value — array of [key, value] tuples.
• Included keys — own and inherited enumerable string-keyed properties.
• Excluded — non-enumerable keys and symbol keys (same rules as for...in).
• Nested values — not flattened; nested objects stay in the value slot.

import toPairsIn from "lodash/toPairsIn";

function Animal(name) {
  this.name = name;
}
Animal.prototype.speak = function () {
  console.log(this.name + " makes a sound.");
};

const dog = new Animal("Dog");
const pairs = toPairsIn(dog);

// pairs includes own "name" and inherited "speak"

Examples Gallery

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

function Animal(name) {
  this.name = name;
}
Animal.prototype.speak = function () {
  console.log(this.name + " makes a sound.");
};

const dog = new Animal("Dog");
const animalPairs = _.toPairsIn(dog);

console.log(animalPairs.map(function (p) { return p[0]; }));
// -> ["name", "speak"]

Keys: ["name", "speak"]

const parentObject = { parentProp: "parentValue" };
const childObject = Object.create(parentObject, {
  childProp: { value: "childValue", enumerable: true }
});

const childPairs = _.toPairsIn(childObject);

console.log(childPairs);
// -> [["childProp", "childValue"], ["parentProp", "parentValue"]]

[["childProp", "childValue"], ["parentProp", "parentValue"]]

function Greeter(msg) { this.msg = msg; }
Greeter.prototype.greet = function () { return this.msg; };

const g = new Greeter("Hi");

console.log(_.toPairs(g).length);    // -> 1 (own only)
console.log(_.toPairsIn(g).length);  // -> 2 (own + greet)

toPairs length: 1
toPairsIn length: 2

function Vehicle(type) { this.type = type; }
Vehicle.prototype.honk = function () { return "beep"; };

const car = new Vehicle("car");

_.toPairsIn(car).forEach(function (pair) {
  console.log(pair[0] + ": " + typeof pair[1]);
});
// type: string
// honk: function

type: string
honk: function

const plain = { a: 1, b: 2, c: 3 };

console.log(
  JSON.stringify(_.toPairs(plain)) === JSON.stringify(_.toPairsIn(plain))
);
// -> true

true

function Tool(name) { this.name = name; }
Tool.prototype.use = function () { return "used"; };

const hammer = new Tool("hammer");

console.log(_.keysIn(hammer));
// -> ["name", "use"]

console.log(_.toPairsIn(hammer)[1]);
// -> ["use", function use() { ... }]

keysIn: ["name", "use"]
pair[1][0]: "use"

📝 Notes

• _.toPairsIn() includes inherited enumerable properties—not just own keys.
• On plain object literals, results usually match _.toPairs().
• Non-enumerable prototype methods (common in ES6 classes) are excluded.
• Nested object values are not flattened into additional pairs.
• There is no built-in Object.entriesIn—that is why _.toPairsIn exists.
• For API payloads and config objects, prefer _.toPairs() to avoid prototype noise.

💡 Best Practices