11

Normally, in Javascript, when I want to pass an anonymous/inline function as an argument to another function, I do one of the following.

someFunctionCall(function() {
    //...
});

someFunctionCall( () => {
    //...
});

However, I've recently inherited a codebase that uses named function as inline arguments, like this

someFunctionCall(function foo() {
    //...
});

I've never seen this syntax before. The function still seems to be anonymous -- there's no foo function defined in either the calling or called scope. Is this just a matter of style, or can using a named function (foo above) as an anonymous function change the behavior or state of that program?

This is specifically for a NodeJS (not a browser based program) program, and I'm specifically interested in behavior specific to using functions as parameters. That said information from behavior across platforms and runtimes is welcome.

Alana Storm
  • 164,128
  • 91
  • 395
  • 599
  • 3
    Stack traces. The name will show up in the trace if the callback throws. At least in the browser, haven't tested in node. – Jared Smith Apr 12 '19 at 18:26
  • 2
    tfw you suddenly realize the avoidable-hell you've been causing other developers by not doing this. Thank you! – Alana Storm Apr 12 '19 at 18:31
  • 1
    Also the function name would act like a self documention – Sushanth -- Apr 12 '19 at 18:33
  • 1
    you can also use them as a persistent yet not global object store for state. `(function me(x){ me.lastX=x; })` – dandavis Apr 12 '19 at 18:41
  • 1
    Also, I would suggest you understand the difference between a function and a function expression - which kind of look the same but are not entirely. – Mark Schultheiss Apr 12 '19 at 18:47
  • 1
    If you promise to give me good stack traces from now on, we'll call it even ;) – Jared Smith Apr 12 '19 at 20:20
  • Possible duplicate of [Why use named function expressions?](https://stackoverflow.com/questions/15336347/why-use-named-function-expressions) – JJJ Apr 13 '19 at 07:00

3 Answers3

8

There are at least three advantages of using named function expressions instead of anonymous function expressions.

  • Makes debugging easier as the function name shows up in call hierarchy.
  • The function name is accessible in the inner scope of the function, so it can be used for recursion
  • The function name itself acts like a self documentation of what the function is doing instead of reading the code.
JJJ
  • 32,902
  • 20
  • 89
  • 102
Sushanth --
  • 55,259
  • 9
  • 66
  • 105
2

Using those "named anonymous functions" won't change the behavior but will show the function name in stack traces which is very useful. Also the function gets callable within itself that way.

Anatol - user3173842
  • 1,385
  • 1
  • 12
  • 16
-1

I'll give an example

Case 1:

var obj =  {count: 0, counter: ()=> {this.count+=1;}}

If you do console.log(obj.count) you'll get 0

Case 2:

var obj  = {count: 0, counter (){this.count+=1;}}

In 2nd case if you do console.log(obj.count) value will be one.

Hope you understood by now. Lamda expressions cannot access values with reference of this object. It can only access variables with global reference.

In case 1 if you want to make it work with lamba you have to use obj.count+=1 with name has reference.

And rest of the JavaScript function implementation remains same there is not much difference.

Nandan
  • 172
  • 8