Question

I have always used to write function prototype declaration in this way:

var O = function () {};
O.prototype.fn = function () {}

But Some developer write in this way:

var O = function () {};
O.prototype.fn = function fn () {}

Are these way equivalent? If not, what is the advantage for using the second way?

var O = function () {};
O.prototype.fn = function fn () {}

Answer 1

var a = function _a() { }

vs

var a = function () { }

The former is called a named function expression,

The latter is just a function assignment.

A NFE has two advantages

• It has a name which is shown in a stack trace. This improves debugging significantly
• It has a name you can use within the function for recursion

A NFE has disadvantages. Kangax talks about them in depth.

Personally I use NFE everywhere and ignore the memory leaks IE makes. However since IE leaks these function names into global scope, an effort should be made to make them unique.

Because IE has a habit of leaking these names into global scope, I try to make them unique.

This is why I prepend function declaration names with _

var doSomeLogic = function _doSomeLogic() {

};

As a side-note there’s an alternative pattern to

var O = function () {};
O.prototype.fn = function fn () {}

var obj = new O();

Which is

// prototype object
var O = {
    fn: function _fn() { }
};
// factory
var o = function _o() { return Object.create(O); }

var obj = o();