Lodash Function methods

Beginner

⏱️ 14 min read

📚 Updated: May 2026

🎯 2 Code examples

Lodash

What you’ll learn

What to know before you start (see Prerequisites).
How the Function group wraps callbacks for arity, timing, and caching.
When debounce, throttle, and memoize solve different problems.
How to import Lodash efficiently for bundle size.
Where each _.methodName is documented and how CodeToFun URLs will map under /lodash/function/....

Prerequisites

Closures, passing functions as values, and optional skim of Lodash Collection methods when wrappers surround iteratees.

Higher-order functions: returning functions from functions and capturing variables in lexical scope.
this semantics: how arrow functions differ from plain functions when combining bind or method extraction.
Timers: familiarity with setTimeout / event loops so debounce, defer, and delay feel predictable.
Modules: ESM import debounce from "lodash/debounce" or CommonJS equivalents.

Key concepts

Lodash Function helpers assume you already think in terms of small composable callbacks. These four ideas recur across signatures and examples.

Arity control

ary, unary, and friends clamp how many parameters reach the inner function—useful before passing callbacks into APIs that over-send arguments.

Partial application

partial, partialRight, and bind fix arguments ahead of time; Lodash placeholders mark slots filled later.

Scheduling

debounce, throttle, defer, and delay shift when work runs relative to input bursts or wall-clock delays.

Caching & guards

memoize remembers outputs; once, before, and after gate how often the underlying function executes.

Overview

Use Lodash Function helpers when UI events, network retries, or middleware need predictable wrapping—without reimplementing timers, argument juggling, or fragile caches by hand.

Event-driven UI

Debounce search inputs, throttle scroll listeners, and cancel pending work on unmount using returned controller methods.

Functional adapters

curry, flip, rearg, and spread reshape functions so they plug into pipelines or older APIs with rigid signatures.

Stable integrations

wrap and bindKey help decorate methods on shared objects while controlling argument flow explicitly.

⚖️ Lodash vs native patterns

Modern JavaScript supplies bind, arrow functions, and optional AbortController—Lodash still buys consistency, cancellable debouncers, and composable wrappers across browsers.

Situation	Prefer native	Consider Lodash
Bind `this` once	`fn.bind(ctx)`	`bind` when using placeholders or Lodash-heavy modules
Simple delayed call	`setTimeout(fn, ms)`	`delay` for identical semantics beside other Lodash timers
Debounce search after typing	DIY timers + edge cases	`debounce` with cancel/flush options tested across releases
Throttle high-frequency events	`requestAnimationFrame` for frames only	`throttle` for generic streams (scroll, pointermove)
Memoize expensive pure work	`Map` + manual keys	`memoize` plus optional resolver

Install and import

Install the core package once per project, then import individual wrappers so bundlers tree-shake unused code paths.

Terminal

npm install lodash

javascript

import debounce from "lodash/debounce";
import memoize from "lodash/memoize";

const saveDraft = debounce((text) => {
  console.log("persist", text);
}, 300);

const expensive = memoize((id) => computeReport(id));

🔄 Scheduling, caches, and guards

Different wrappers change when code runs or how often state updates—mixing them up is the most common source of subtle UI bugs.

Pattern	Typical methods	Rule of thumb
Wait for idle bursts	`debounce`	Invoke after input quiets—remember to `cancel()` on teardown.
Cap invocation rate	`throttle`	Keep firing on an interval while events flood in.
Remember outputs	`memoize`	Ideal for pure functions; watch resolver keys for GC pressure.
Limit call counts	`once`, `before`, `after`	Use when guards replace bespoke boolean flags.

Combine scheduling helpers with framework lifecycle hooks—always flush or cancel pending invocations when components unmount or routes change.

Suggested learning path

Walk these topics in order inside DevTools or Node—the earlier items unblock everyday UI work.

Timers: read official docs for debounce and throttle, then experiment with cancel / flush.
Partial calls: contrast partial with native bind using placeholders.
Currying: step through curry arity progression versus manual closures.
Caching: instrument memoize with a resolver when arguments are objects.
Composition: pair wrap with existing utilities for logging or metrics.

💻 Environment and versions

Lodash 4.x: the index below lists the stable Function surface shipped with lodash@^4.
Node.js and browsers: identical imports; prefer ESM paths in Vite/Webpack and require("lodash/debounce") in legacy CommonJS.
TypeScript: add @types/lodash for richer typings on composed wrappers.

Method index

Focused tutorials on CodeToFun use /lodash/function/{method-kebab} (for example /lodash/function/debounce). Until each page ships, each name links to the matching Lodash 4.x documentation entry.

Method	What it does
`_.after()`	Create a function that invokes func after being called n times.
`_.ary()`	Wrap func to accept only n arguments; extras are dropped.
`_.before()`	Create a function that invokes func until it has been called n times.
`_.bind()`	Partially apply arguments with optional placeholder support for _.bind.
`_.bindKey()`	Bind a method on object[key]; supports placeholders like bind.
`_.curry()`	Curry func so arguments can be supplied across multiple calls.
`_.curryRight()`	Curry func with arguments provided from right to left.
`_.debounce()`	Delay invoking func until wait ms after the last call; supports cancel and flush.
`_.defer()`	Defer invoking func until the current stack clears (similar to setTimeout 0).
`_.delay()`	Invoke func after wait milliseconds.
`_.flip()`	Create a function that invokes func with arguments reversed.
`_.memoize()`	Memoize func results; optional resolver customizes cache keys.
`_.negate()`	Return a predicate that negates the result of the given predicate.
`_.once()`	Create a function restricted to invoking func at most once.
`_.overArgs()`	Transform arguments before they reach func.
`_.partial()`	Partial application from the left (shortcut for bind-style curry).
`_.partialRight()`	Partial application from the right.
`_.rearg()`	Create a function that invokes func with arguments rearranged.
`_.rest()`	Transform func so leading arguments are fixed and the rest are grouped.
`_.spread()`	Spread array arguments across func parameters.
`_.throttle()`	Ensure func is invoked at most once per wait window.
`_.unary()`	Wrap func so it only accepts one argument.
`_.wrap()`	Wrap func so value becomes self as first argument to wrapper.

Pitfalls to avoid

Teardown

Leaked timers

Debounced handlers scheduled before navigation may still fire unless you cancel them explicitly.

Memo keys

Unbounded caches

Memoizing on raw objects without a resolver can retain references longer than you expect.

Binding

Lost context

Arrow functions ignore bind-style this injection—reach for plain functions when this binding matters.

❓ FAQ

What is the Lodash Function category?

It bundles higher-order helpers that wrap plain functions: fixing arity, reordering arguments, delaying invocation, caching results, and composing UI-friendly callbacks.

How is debounce different from throttle?

Debounce waits until calls pause for the full wait window before firing—ideal after typing stops. Throttle enforces a maximum rate while events stream—common for resize or scroll.

When should I still use Function.prototype.bind?

Native bind is enough for stable this-binding without placeholders. Reach for _.bind or _.partial when you rely on Lodash placeholder semantics or stack helpers consistently.

Does memoize leak memory?

Yes if keys grow without bound; pair memoize with an LRU or clear caches on navigation unless inputs are a small closed set.

Should I import the entire lodash package?

Prefer lodash/debounce-style imports or tree-shakeable paths so only wrappers you use ship to clients.

Summary

Scope: Lodash Function helpers wrap callbacks for timing, arity, argument order, and memoization.
Bundles: import per method for minimal client weight.
Next step: open Lodash _.after(), revisit Lodash Date Methods, or jump into the official docs from the index above.

Did you know?

Lodash debounce and throttle both rate-limit callbacks, but debounce waits for a quiet window while throttle guarantees periodic execution—pick debounce for search boxes and throttle for scroll handlers.

About the author

Mari Selvan M P 🔗

Developer, cloud engineer, and technical writer

Experience 12 years building web and cloud systems
Focus Full Stack Development, AWS, and Developer Education

I write practical tutorials so students and working developers can learn by doing—from databases and APIs to deployment on AWS.

AWS Certified Developer – Associate (Credly)

9 people found this page helpful

Lodash Date Methods Lodash _.after()