Lodash _.valuesIn() Method

What You’ll Learn

By the end of this tutorial, you’ll use _.valuesIn() to collect own and inherited enumerable property values into an array for inspection and debugging.

What Is _.valuesIn()?

_.valuesIn() is like _.values(), but it walks the prototype chain and includes inherited enumerable property values too. Think of it as turning a for...in loop into an array of values—keys are omitted.

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

📝 Syntax

The signature takes one argument—the object whose values you want (including inherited):

_.valuesIn(object)

Syntax Rules

• object — any object (instances, plain objects, etc.).
• Return value — array of property values from own and inherited enumerable string keys.
• Included values — own and inherited enumerable string-keyed properties.
• Excluded — non-enumerable props, symbol keys, and nested object internals (not flattened).
• Null-safe — returns [] for null or undefined.

import valuesIn from "lodash/valuesIn";

function Person(name, age) {
  this.name = name;
  this.age = age;
}
Person.prototype.sayHello = function () {
  console.log("Hello, " + this.name);
};

const john = new Person("John", 30);
const allValues = valuesIn(john);

// allValues includes own name/age and inherited sayHello function

Examples Gallery

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

function Person(name, age) {
  this.name = name;
  this.age = age;
}

Person.prototype.sayHello = function () {
  console.log("Hello, my name is " + this.name);
};

const john = new Person("John", 30);
const allValues = _.valuesIn(john);

console.log(allValues.length);
// -> 3  (name, age, sayHello)

console.log(typeof allValues[2]);
// -> "function"

3
function

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

const childValues = _.valuesIn(childObject);

console.log(childValues);
// -> ["childValue", "parentValue"]

["childValue", "parentValue"]

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

const g = new Greeter("Hi");

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

values length: 1
valuesIn length: 2

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

const car = new Vehicle("car");

_.valuesIn(car).forEach(function (value) {
  console.log(typeof value);
});
// string
// function

string
function

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

console.log(
  JSON.stringify(_.values(plain)) === JSON.stringify(_.valuesIn(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(typeof _.valuesIn(hammer)[1]);
// -> "function"

keysIn: ["name", "use"]
valuesIn[1] type: function

📝 Notes

• _.valuesIn() does not mutate the source object—it returns a new array.
• Own and inherited enumerable string-keyed property values are included.
• Nested object values are not flattened—each nested object is one array element.
• ES class methods on the prototype are usually non-enumerable and will not appear; constructor prototype.method = fn assignments are enumerable and will.
• On plain object literals, _.valuesIn() matches _.values().
• For own values only, prefer _.values() or native Object.values().

💡 Best Practices