Lodash _.constant() Method

What You’ll Learn

By the end of this tutorial, you’ll use Lodash’s _.constant() to build functions that always return one fixed value—no matter what arguments callers pass.

What Is _.constant()?

_.constant() is a Lodash util helper that turns any value into a zero-argument function (ignoring extras) returning that value every time. APIs that expect callbacks—_.map, event hooks, or _.cond handlers—often need a function even when the result never changes. _.constant(42) is cleaner than writing () => 42 repeatedly in Lodash-heavy code.

It is a small building block behind Lodash stub utilities and default branches in functional conditionals—not a replacement for real business logic, but a handy adapter when a function signature is required.

📝 Syntax

Pass the value you want every call to return:

_.constant(value)

Syntax Rules

• value — any JavaScript value: number, string, boolean, object, array, or undefined.
• Return value — a new function; each invocation returns the captured value.
• Arguments ignored — fn(), fn(1, 2, 3) all return the same thing.
• Reference types — objects and arrays are returned by reference, not cloned.
• Not lazy — the value is fixed when you call _.constant(), not recomputed per call.

import constant from "lodash/constant";

const always42 = constant(42);

console.log(always42());      // 42
console.log(always42(100));   // 42 — arguments ignored

Examples Gallery

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

const always42 = _.constant(42);

console.log(always42());       // 42
console.log(always42(100));    // 42
console.log(always42(1, 2, 3)); // 42

42
42
42

const alwaysHello = _.constant("Hello");

function registerGreeting(fn) {
  console.log(fn());
}

registerGreeting(alwaysHello);           // "Hello"
registerGreeting(_.constant("Hello"));   // "Hello"

Hello
Hello

const labelSize = _.cond([
  [(n) => n < 10,  _.constant("Small")],
  [(n) => n < 20,  _.constant("Medium")],
  [(n) => n < 30,  _.constant("Large")],
  [_.stubTrue,       _.constant("Huge")]
]);

console.log(labelSize(5));   // "Small"
console.log(labelSize(35));  // "Huge"

Small
Huge

const mockApiResponse = _.constant({
  success: true,
  data: "Mock data"
});

function fetchUser(id, callback) {
  // In production: real HTTP call
  callback(mockApiResponse());
}

fetchUser(1, (result) => {
  console.log(result.success, result.data);
});
// true Mock data

// Test with the constant directly as callback
fetchUser(1, () => mockApiResponse());

true Mock data

const payload = { count: 0 };
const getPayload = _.constant(payload);

const a = getPayload();
a.count = 5;

const b = getPayload();
console.log(b.count); // 5 — same object

// Safer: constant over a primitive
const alwaysZero = _.constant(0);
console.log(alwaysZero()); // 0

5
0

// constant — any fixed return value
console.log(_.constant(42)());        // 42

// stubTrue — sugar for constant(true)
console.log(_.stubTrue());              // true
console.log(_.constant(true)());      // true

// arrow — native equivalent
console.log((() => 42)());            // 42

// defaultTo — NOT a function factory; nullish fallback
console.log(_.defaultTo(null, "guest")); // "guest"
console.log(_.defaultTo("Ada", "guest")); // "Ada"

42
true
true
42
guest
Ada

📝 Notes

• _.constant() creates a function, not the value itself—call it with () when you need the payload.
• Object and array constants return the same reference; clone if callers mutate results.
• Do not use as a default parameter value for strings—use name = "Guest" directly instead.
• _.stubTrue, _.stubFalse, _.stubArray, and _.stubObject are specialized constants.
• For nullable data fallback use _.defaultTo(), not constant.
• Pairs naturally with _.cond() fixed-outcome handlers.

💡 Best Practices