CODEWITHSUNDEEP
javascriptfunctionobject
Blnpwr
Blnpwr

Reputation: 1875

Declare a function without a name in JavaScript

I am new to JavaScript (coming from Java) and want to understand this function

(function (global, factory) {
if (typeof define === 'function' && define.amd) {
    define(['../numeral'], factory);
} else if (typeof module === 'object' && module.exports) {
    factory(require('../numeral'));
} else {
    factory(global.numeral);
}

}

It's from this github page https://github.com/adamwdraper/Numeral-js/blob/master/src/formats/currency.js

My question is: Why isn't there a name for the function that takes global and factory as parameter ?

What I would expect is something like this:

function myFunction(p1, p2) {
return p1 * p2;   // The function returns the product of p1 and p2
}

Here, we have the name myFunction but in the above example, we don't have a name for the function. Why? And why is that allowed in JavaScript?

Upvotes: 4

Views: 4211

Answers (3)

tys
tys

Reputation: 699

Yes. They are called anonymous functions in Javascript.

Usually these functions are supplied as callbacks to another function.

Or they could be immediately invoked as Jack said in his answer.

Upvotes: 4

SpeedOfRound
SpeedOfRound

Reputation: 1278

Anonymous functions are just that, functions without names. They cannot be called by name like you would normally use a function. We actually use them a lot in javascript.

A common use for it would be for a function that takes another function as a parameter, like .sort(). Sort allows you to pass a custom function to handle the sorting logic, so with an anonymous function, it would like like this:

var numbers = [4, 2, 5, 1, 3];
numbers.sort(function(a, b) {
  return a - b;
});
//[1, 2, 3, 4, 5]

See how the function is being passed as the only parameter to sort. An equivalent to this could also look like:

var numbers = [4, 2, 5, 1, 3];
var mySortFunction = function(a, b){
   return a - b;
}
numbers.sort(mySortFunction);
//[1, 2, 3, 4, 5]

Anonymous functions are just a clean and quick way to create functions that you would not reuse in your code.

Upvotes: 1

Jack Bashford
Jack Bashford

Reputation: 44107

It's because it's in an IIFE - you don't need to name the function, and the only real use of naming it would be recursion.

It's like this:

var func = function (global, factory) {
    if (typeof define === 'function' && define.amd) {
        define(['../numeral'], factory);
    } else if (typeof module === 'object' && module.exports) {
        factory(require('../numeral'));
    } else {
        factory(global.numeral);
    }
}

You call it like:

(func)();

Or:

func();

It's a function expression - it doesn't have a name, it's assigned to a named variable. Unnamed functions are known as anonymous functions, and you use them as testing/callback functions.

Upvotes: 1

Related Questions