By the end of this tutorial, you’ll build reusable method invokers with Lodash’s _.method()—fix the method path, pass the object later.
_.method(path, ...args)
Bind method args at creation time.
Call the same method on each item.
Dot paths like 'a.b'.
Reusable vs one-off call.
Path first vs object first.
_.method()?_.method() is an invoker factory. You give it a method path (and optional arguments for that method); Lodash returns a function that accepts an object and calls the method on it—with this bound correctly.
_.method('greet', 'John')(obj) calls obj.greet('John'). Extra arguments belong in the _.method(...) call, not after the object when you invoke the returned function.
This pattern shines with _.map when every element exposes the same method name—pass _.method('getLabel') as the iteratee instead of writing (item) => item.getLabel() repeatedly.
Specify the method path and any arguments to pass through:
_.method(path, [args])path — method path on the target object (string dot-path or key array).args — optional arguments forwarded to the method when the invoker runs.(object) => result.this — the method runs with the target object as its context._.invoke(object, path, ...args) when you do not need a reusable invoker.import method from "lodash/method";
const obj = {
greet(name) {
return "Hello, " + name + "!";
},
};
const greetJohn = method("greet", "John");
greetJohn(obj);
// "Hello, John!"| Task | Code pattern | Notes |
|---|---|---|
| Build invoker | _.method('getName') | No method args |
| With method args | _.method('add', 10, 5) | Bound at creation |
| Run on object | invoker(obj) | Single object arg |
| Map iteratee | _.map(items, _.method('label')) | Per-element call |
| Nested path | _.method('a.b') | Deep method |
| One-off call | _.invoke(obj, 'greet', 'A') | No factory |
FunctionInvoker
PathMethod name
methodOfObject first
UtilInvocation
Arguments to _.method() and the invoker it returns:
path RequiredMethod path on each target object—e.g. 'greet', 'calc.add', or ['calc', 'add'].
_.method("getTotal")args OptionalValues passed to the method when the invoker runs. Set them here—not as extra parameters on invoker(obj).
_.method("add", 10, 5)returned fn InvokerAccepts the target object, resolves path, invokes the method with bound args, returns the method’s result.
const run = _.method("fn", 1)missing method undefinedIf the path is missing or not callable, invoke returns undefined—not a function. Validate before critical calls.
_.method("missing")(obj)When the object is fixed and the path varies, use _.methodOf() instead.
Practical _.method() patterns with copy-ready code, sample output, and interactive Try It Yourself labs.
Basic invokers and runtime method names.
Pass the greeting name when building the invoker.
const obj = {
greet(name) {
return "Hello, " + name + "!";
},
};
const greetJohn = _.method("greet", "John");
console.log(greetJohn(obj));
// "Hello, John!"The old tutorial used greetMethod(obj, 'John'), but Lodash binds 'John' in _.method('greet', 'John'). The invoker receives only the object.
Pick add or subtract at runtime, with operands bound upfront.
const calc = {
add(a, b) { return a + b; },
subtract(a, b) { return a - b; },
};
const operation = "+";
const methodName = operation === "+" ? "add" : "subtract";
const mathFunc = _.method(methodName, 10, 5);
console.log(mathFunc(calc));
// add(10, 5) = 15Both the method name and its arguments can be chosen before you create the invoker—ideal for strategy-style dispatch tables.
Map iteratees, nested paths, and safe invocation.
Call the same method on every item in a collection.
const widgets = [
{ label() { return "A"; } },
{ label() { return "B"; } },
{ label() { return "C"; } },
];
console.log(_.map(widgets, _.method("label")));
// ["A", "B", "C"]Each array element becomes the object passed to the invoker—Lodash’s canonical _.method use case.
Invoke a method on a nested object via dot path.
const items = [
{ api: { fetch: () => "data-A" } },
{ api: { fetch: () => "data-B" } },
];
console.log(_.map(items, _.method("api.fetch")));
// ["data-A", "data-B"]Path resolution matches _.get / _.invoke—traverse nested objects before calling the method.
Compare with invoke and guard missing methods.
Reuse a factory vs call once inline.
const obj = {
greet(name) { return "Hi, " + name; },
};
const greetAnn = _.method("greet", "Ann");
console.log(greetAnn(obj)); // reusable invoker
console.log(_.invoke(obj, "greet", "Ann")); // one-off equivalentPrefer _.method when passing an invoker to _.map or storing it. Use _.invoke for a single immediate call.
Check before invoking—the result is not a function when the path is missing.
const obj = {
greet(name) { return "Hello, " + name + "!"; },
};
const unknown = _.method("unknownMethod");
const result = unknown(obj);
console.log(result);
// undefined — not a function
if (typeof _.get(obj, "unknownMethod") === "function") {
console.log("safe to call");
} else {
console.log("method missing — skip or fallback");
}The reference incorrectly checked typeof result === 'function'. Missing methods yield undefined from invoke—not another function.
_.method() WorksLodash stores the method path and any arguments to forward.
The new function waits for a target object.
On call, find the method at path and run it with object as this and stored args.
Whatever the invoked method returns—or undefined if the path is missing.
_.method(path, ...args), not on invoker(object, ...).this—important for methods that read this internally.undefined; they do not throw by default in Lodash invoke._.map when each element shares the same method name._.invoke(object, path, ...args)._.method() builds reusable invokers that call a method path on whatever object you pass in— with optional arguments bound upfront.
Reach for it in _.map pipelines and dynamic dispatch tables; pair with _.methodOf() when the object is fixed instead of the path.
_.method(path, ...args)_.map iteratee when method names align_.invoke for one-off callsundefinedtypeof result === 'function' after invoke for existencethis without an invoker or bind_.method()Use these points when building method invokers.
Path fixed.
BasicsAt creation.
MechanicsShared method.
PracticalOne-off call.
CompareObject first.
Next stepLodash’s classic map example _.map(objects, _.method('a.b')) works because each array element becomes the object argument to the invoker—calling a nested method without writing a lambda per item.
Open the Try It editor, run the examples, and build reusable method invokers.
6 people found this page helpful