By the end of this tutorial, you’ll use Lodash’s _.methodOf() to fix an object and invoke different method paths on it at runtime.
_.methodOf(object, ...args)
Returned fn takes the method path.
Bind method args at creation.
Pick operation name at runtime.
Object first vs path first.
Context stays on the object.
_.methodOf()?_.methodOf() is the mirror of _.method(). You fix the object upfront; the returned function accepts a method path and calls that method on the object—with correct this binding.
_.methodOf(user)('greet') calls user.greet(). Do not write _.methodOf(user, 'greet')—the second argument to methodOf is a method argument, not the path name.
Use this when one instance exposes many operations and you choose the method name dynamically—calculator ops, plugin APIs, or command routers.
Fix the object (and optional method args); pass the path when you call the invoker:
_.methodOf(object, [args])object — the target whose methods will be invoked.args — optional arguments forwarded to the method (bound at creation).(path) => result.path — method name or dot-path passed to the returned function._.method(path, ...args)(object) ↔ _.methodOf(object, ...args)(path).import methodOf from "lodash/methodOf";
const user = {
name: "John",
greet() {
return "Hello, " + this.name + "!";
},
};
const invokeOnUser = methodOf(user);
invokeOnUser("greet");
// "Hello, John!"| Task | Code pattern | Notes |
|---|---|---|
| Build invoker | _.methodOf(obj) | Object fixed |
| Call method | invoker('methodName') | Path argument |
| With method args | _.methodOf(calc, 10, 5)('add') | Args bound early |
| Nested path | _.methodOf(root)('api.fetch') | Dot path |
| Path-first twin | _.method('add', 10, 5)(calc) | Same invoke |
| One-off | _.invoke(obj, 'greet') | No factory |
FunctionPath invoker
ObjectTarget instance
methodPath first
UtilInvocation
Arguments to _.methodOf() and the invoker it returns:
object RequiredThe instance whose methods will be called. Closed over by the returned invoker.
_.methodOf(calculator)args OptionalValues passed to the method when the invoker runs. Set on _.methodOf, not on invoker(path).
_.methodOf(calc, 10, 5)path Invoker argMethod path supplied when you call the returned function—e.g. 'greet' or 'api.fetch'.
invokeOnUser("greet")missing path undefinedIf the path is missing or not callable, invoke returns undefined. Guard with _.has or a typeof check.
invokeOnUser("missing")When the path is fixed and objects vary, use _.method() instead.
Practical _.methodOf() patterns with copy-ready code, sample output, and interactive Try It Yourself labs.
Basic greet and dynamic operation dispatch.
Fix the object, pass the method path to the invoker.
const user = {
name: "John",
greet() {
return "Hello, " + this.name + "!";
},
};
const invokeOnUser = _.methodOf(user);
console.log(invokeOnUser("greet"));
// "Hello, John!"The old tutorial used _.methodOf(user, 'greet') then greetingFunction()—that misplaces the path. The path belongs on the invoker call: invokeOnUser('greet').
One math utils object; pick square or cube at runtime.
const mathUtils = {
square(n) { return n * n; },
cube(n) { return n * n * n; },
};
const calculate = (operation, num) =>
_.methodOf(mathUtils, num)(operation);
console.log(calculate("square", 3)); // 9
console.log(calculate("cube", 3)); // 27Bind the numeric operand with _.methodOf(mathUtils, num), then pass the operation name as the path—clean dispatch without a large switch statement.
Partial args, nested paths, and comparison with method.
Bind method arguments when creating the invoker; path selects add vs subtract.
const calculator = {
value: 0,
add(n) {
this.value += n;
return this.value;
},
};
const addFive = _.methodOf(calculator, 5);
console.log(addFive("add"));
// 5 — this.value updated on calculatorthis stays on calculator automatically—no manual .call(calculator, …) needed. The old reference’s addFive.call(calculator, 5) pattern was redundant and misused the API.
Invoke a method on a nested object via dot path.
const service = {
api: {
ping() { return "pong"; },
},
};
const invokeOnService = _.methodOf(service);
console.log(invokeOnService("api.ping"));
// "pong"Path resolution matches _.invoke—traverse nested properties before calling the method.
Mirror of method and safe invocation.
Two ways to invoke the same method with the same partial args.
const calc = {
add(a, b) { return a + b; },
};
console.log(_.methodOf(calc, 10, 5)("add"));
console.log(_.method("add", 10, 5)(calc));
// both: 15Use methodOf when the object is stable and paths vary. Use method when the path is stable and you map over many objects.
Validate that the path exists on the object.
const car = {
brand: "Toyota",
startEngine() {
return "Engine started.";
},
};
const invokeOnCar = _.methodOf(car);
const path = "startEngine";
if (typeof _.get(car, path) === "function") {
console.log(invokeOnCar(path));
} else {
console.log("Method not found.");
}Using _.has(car, 'startEngine') before building the invoker is fine too. Avoid the old anti-pattern of composing with window.alert via methodOf—it couples code to globals unnecessarily.
_.methodOf() WorksLodash closes over the target object and any method arguments.
The new function waits for a method path string or key array.
Find the method at path on the fixed object, call with bound args and correct this.
Whatever the invoked method returns—or undefined if the path is missing.
_.methodOf—it is the argument to the returned function.object in _.methodOf are forwarded to the method, like _.method.this is set to the fixed object automatically—no extra .call needed._.map(collections, _.method('fn')) patterns.undefined from invoke—validate dynamic path strings in user-facing dispatchers._.methodOf() fixes an object and lets you invoke different method paths on it— the object-first mirror of _.method().
Use it for dispatch tables and plugin APIs; bind operands with partial args and pass the operation name when you call the invoker.
invokeOn(obj)('methodName')_.methodOf(object, ...args)_.invoke for one-off calls_.methodOf.call the object unless you know whywindow methods in tutorials or app codeundefined_.methodOf()Use these points when building object-first invokers.
Fix instance.
BasicsOn invoker call.
MechanicsAt creation.
PartialRuntime paths.
PracticalMirror helper.
Compare_.methodOf(object, ...args)(path) and _.method(path, ...args)(object) are two views of the same invoke operation—pick whichever side of the call varies in your code.
Open the Try It editor, run the examples, and build object-first dispatch helpers.
6 people found this page helpful