I am just wondering why self execution code should be needed when implement module pattern in javascript.
Following code is typical module pattern sample :
var app = app || {};
app.model = app.model || {};
app.model.person = (function () {
var say = function () {
alert('say');
};
return {
saySomething: say
}
})();
But, I cannot find out the reason why this function should be self executed with closing curly brace.
The function/module isn't self-executed with the closing curly brace, it's self-executed (or self-invoked) with the () at the end.
The reason for doing this is to emulate privacy in JavaScript. The function is executed immediately and the saySomething function is returned, which remains available after the return because of a closure, and is therefore public. The say function is not returned and is not accessible outside of the function so is therefore private
Who says it needs to be implemented this way? I see no reason why much more readable:
var app = app || {};
app.model = app.model || {};
app.model.person = {
saySomething: function () {
alert('say');
}
}
can't be used...
In your example there is really no point, because the say function is later exposed in the returned object. But consider this:
app.model.person = (function () {
var privateVar = 'I am private';
var say = function () {
alert(privateVar);
};
var doSomething = function() {
// operates on privateVar
};
return {
saySomething: say
}
})();
Here it makes sense, because privateVar is never accessible from outside of the object.
