Lodash _.identity() Method

What You’ll Learn

By the end of this tutorial, you’ll know when and why Lodash’s _.identity() returns values unchanged—and how it fits into maps, filters, and composition pipelines.

What Is _.identity()?

_.identity() is the simplest Lodash util: it takes a value and returns it unchanged. Think of it as a named version of (x) => x—a pass-through or “no-op” transform.

It looks trivial, but many Lodash methods accept iteratee callbacks. When you need “don’t transform this” without writing an inline arrow, _.identity documents that intent clearly.

📝 Syntax

Call it directly or pass the function reference as a callback:

_.identity(value)

Syntax Rules

• value — any value; returned as-is.
• Extra arguments — ignored; only the first argument is returned.
• As callback — pass _.identity without parentheses to methods like _.map.
• Reference equality — objects and arrays are returned by reference, not cloned.

import identity from "lodash/identity";



identity(42);           // 42

identity("hello");      // "hello"

identity(null);         // null



const nums = [1, 2, 3];

_.map(nums, identity);  // [1, 2, 3] — same values

Examples Gallery

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

console.log(_.identity(42));        // 42

console.log(_.identity("hello"));   // "hello"

console.log(_.identity(false));     // false

console.log(_.identity(null));      // null



const obj = { a: 1 };

console.log(_.identity(obj) === obj); // true — same reference

42

hello

false

null

true

const nums = [1, 2, 3, 4];



const mapped = _.map(nums, _.identity);



console.log(mapped);

// [1, 2, 3, 4]



console.log(mapped === nums); // false — new array, same values

[ 1, 2, 3, 4 ]

false

const mixed = [0, 1, "", "hi", false, null, 42];



console.log(_.filter(mixed, _.identity));

// [1, "hi", 42]



console.log(_.compact(mixed));

// [1, "hi", 42] — similar for arrays

[ 1, 'hi', 42 ]

[ 1, 'hi', 42 ]

const double = (x) => x * 2;

const addTen = (x) => x + 10;



const pipeline = _.flow(_.identity, double, addTen);



console.log(pipeline(5));

// identity(5)=5, double(5)=10, addTen(10)=20

20

function transformItems(items, mapper = _.identity) {

  return items.map(mapper);

}



console.log(transformItems([1, 2, 3]));

// [1, 2, 3] — default pass-through



console.log(transformItems([1, 2, 3], (n) => n * 10));

// [10, 20, 30]

[ 1, 2, 3 ]

[ 10, 20, 30 ]

console.log(_.identity(99));       // 99

console.log(_.identity(1));        // 1



const always99 = _.constant(99);

console.log(always99());           // 99

console.log(always99(1, 2, 3));    // 99 — args ignored

99

1

99

99

📝 Notes

• _.identity does not clone objects—it returns the same reference.
• Only the first argument is returned; extra iteratee args (index, collection) are ignored.
• As a filter predicate, identity keeps truthy values—not the same as keeping all items.
• Do not confuse with _.constant(), which ignores input and returns a fixed value.
• Wrong pattern from older tutorials: _.filter(_.identity) is invalid—always pass a collection first.
• Next in the series: _.iteratee() builds callbacks from shorthands.

💡 Best Practices