Scott C. said:plexsoup said:
And what's this thing for? (At the end of the primary function.)
}());
(I get why there's a curly brace and a round bracket, but why the extra pair of brackets? )
I'm not a great programmer knowledge wise, but I believe this is so that you can return your functions from the self-invoking function LightCrumb. I fully expect a certain Arcane Scriptomancer to hop in here and give a better explanation.
Sorry for the delay. =D
It looks like you've got this all mostly figured out, but here's a review anyway:
var script = script || (function(){
var func = /* some function */
/* stuff */
return {
thing: func
};
})();There's several things going on here. First is the Singleton aspect of the module pattern:
var script = script || < definition logic > ;
Because of the unique properties of javascript's
|| (or) operator, along with the standard short circuiting logic in most procedural programming languages, the practical upshot of this code is "If there's something named
script already, assign that to my variable
script, otherwise assign the results of executing this
< definition logic > "
Second is that
< definition logic > :
(function() { /* stuff */ }());This is called an IIFE (iffy): Immediately-Invoked Function Expression. Normally, you call a defined function by using it's name followed by the parameter list ():
foo();
You'd normally see a function like that defined as either:
function foo(){ /* stuff */ };
// or
var foo = function(){ /* stuff */ };In this case, we're using an anonymous function by just providing the definition of the function instead of a name for the function (everything in Javascript is an object, functions are not different):
function(){ /* stuff */ };You'd normally see these anonymous functions passed as call backs ( like what is passed to the on() function: on('ready, <anonymous function> ); ), but in this case, we're just taking that function and executing it in place by appending the parameter list ():
(function(){ /* stuff */ }) ();Parenthesis are necessary to properly parse the expression. The () can either be inside them or outside them:
(function(){ /* stuff */ } () );The convention I follow puts them inside as a notation that this is an IIFE.
So, the result of this
< definition logic > is an object that is used as the external interface to the real script. The most important concept here is that the object that is returned can reference everything inside of the function that created it. This is called a
Closure, and is perhaps one of the hardest concepts to understand in Javascript.
The practical upshot of all of this is that your script's code is safely nestled away inside a private space (the closure, the insides of the IIFE) and can't conflict with other code. It can have a variable named bob, instead of script_bob. It can define a function named test(), instead of script_test(), etc. It makes it very clean and easy to deal with. You never end up with having a function in one script that is accidentally being used in another, or a global variable, etc.
Hope that helps!
