Lodash _.pickBy() Method

What You’ll Learn

By the end of this tutorial, you’ll use _.pickBy() to keep object properties that match dynamic rules—not just fixed key names.

What Is _.pickBy()?

_.pickBy() is Lodash’s predicate-driven pick helper. You pass an object and a function; Lodash copies each own enumerable string key whose predicate(value, key) returns a truthy value. Everything else is left out. It is the mirror image of _.omitBy(), which drops properties when the predicate is truthy.

Use _.pickBy() for feature flags, inventory filters, cleaning optional form fields, and any case where what you keep depends on values or key names rather than a static list.

📝 Syntax

The signature pairs an object with an optional predicate function:

_.pickBy(object, [predicate])

Syntax Rules

• object — source object to process (not mutated).
• predicate(value, key) — called for each own enumerable string key.
• Truthy return — property is included in the result.
• Falsy return — property is excluded.
• Default predicate — if omitted, Lodash keeps properties with truthy values.
• Shallow — top-level keys only; nested objects are not traversed.

import pickBy from "lodash/pickBy";

const user = {
  name: "Alice",
  age: 30,
  isAdmin: true,
  isActive: false
};

const adminFlags = pickBy(user, (value) => value === true);
// -> { isAdmin: true }

Examples Gallery

Real-world _.pickBy() patterns with sample output and interactive Try It Yourself labs.

const featureFlags = {
  enableExperimentalFeature: false,
  showBetaBanner: true,
  displayNewUI: false
};

const enabled = _.pickBy(featureFlags, (value) => value === true);

console.log(enabled);
// -> { showBetaBanner: true }

{ showBetaBanner: true }

const sportsEquipment = {
  ball: "football",
  racket: "tennis",
  skates: null,
  helmet: undefined
};

const valid = _.pickBy(sportsEquipment, (value) => value != null);

console.log(valid);
// -> { ball: "football", racket: "tennis" }

{ ball: "football", racket: "tennis" }

const inventory = {
  apple: { quantity: 5, price: 2 },
  banana: { quantity: 10, price: 1 },
  orange: { quantity: 0, price: 3 }
};

const inStock = _.pickBy(inventory, (item) => item.quantity > 0);

console.log(inStock);
// -> {
//      apple: { quantity: 5, price: 2 },
//      banana: { quantity: 10, price: 1 }
//    }

{
  apple: { quantity: 5, price: 2 },
  banana: { quantity: 10, price: 1 }
}

const userPreferences = {
  darkMode: true,
  notifications: false,
  fontSize: "medium",
  compactLayout: true
};

const activePrefs = _.pickBy(userPreferences, (value) => value === true);

console.log(activePrefs);
// -> { darkMode: true, compactLayout: true }

{ darkMode: true, compactLayout: true }

const model = {
  id: 1,
  title: "Hello",
  _internalId: "abc-123",
  _cacheKey: "xyz"
};

const publicFields = _.pickBy(model, (value, key) => !key.startsWith("_"));

console.log(publicFields);
// -> { id: 1, title: "Hello" }

{ id: 1, title: "Hello" }

const stats = { views: 10, likes: 0, shares: 5, drafts: 0 };

const nonZero = _.pickBy(stats, (value) => value > 0);
// -> { views: 10, shares: 5 }

const withoutZeros = _.omitBy(stats, (value) => value === 0);
// -> { views: 10, shares: 5 }

{ views: 10, shares: 5 }

📝 Notes

• Truthy keeps—the predicate returning true means include that key.
• _.pickBy() is non-mutating and works on top-level keys only.
• value === true is not the same as a truthy check—be explicit about boolean flags.
• Calling _.pickBy(obj) without a predicate keeps properties with truthy values.
• Nested objects inside kept keys are shared by reference (shallow copy).
• For a fixed key list, _.pick() is usually clearer.

💡 Best Practices