(This answer servers as a TL;DR for the existing answers. As such, it may overlap in main theses.)

The key difference between the two can be summarized as the "this" being injected versus captured.

Typically, there are two points to be considered:

The first point is the benefit of allowing the same instance of anonymous function to be reused for different instances of Foo. It seems that you won't benefit from this; as a result, the two approaches (inject vs capture) doesn't seem to matter to you.

anonymous_callback = (foo, n) => { // <-- 1 this.something(n); // this "this" refers to "Bar" foo.someFunc(); // this "foo" is passed in, i.e. injected } this.foo_one = new Foo(); // imagine Foo is a button this.foo_two = new Foo(); // another button this.foo_one.addCallback(anonymous_callback); this.foo_two.addCallback(anonymous_callback); 

The second point is the risk of object lifetime issue, i.e. whether the lambda might be invoked beyond the lifetime of its captures (the captured "this"). C++ is the only language that I know of that can potentially suffer from this type of risk. Thus, it doesn't seem to affect your chosen language.

Conclusion: I think the approaches are roughly equivalent in your use case.

The key difference between the two can be summarized as the "this" being injected versus captured.

Typically, there are two points to be considered:

The first point is the benefit of allowing the same instance of anonymous function to be reused for different instances of Foo. It seems that you won't benefit from this; as a result, the two approaches (inject vs capture) doesn't seem to matter to you.

anonymous_callback = (foo, n) => { // <-- 1 this.something(n); // this "this" refers to "Bar" foo.someFunc(); // this "foo" is passed in, i.e. injected } this.foo_one = new Foo(); // imagine Foo is a button this.foo_two = new Foo(); // another button this.foo_one.addCallback(anonymous_callback); this.foo_two.addCallback(anonymous_callback); 

The second point is the risk of object lifetime issue, i.e. whether the lambda might be invoked beyond the lifetime of its captures (the captured "this"). C++ is the only language that I know of that can potentially suffer from this type of risk. Thus, it doesn't seem to affect your chosen language.

Conclusion: I think the approaches are roughly equivalent in your use case.