What is the point in setting something equal to itself?

Question

I just saw this question into which someone passed window.Module = window.Module || {} into a function.

For example:

(function(module){
    // do something with module
})(window.Module = window.Module || {});

I understand that if window.Module is undefined (or false for that matter) then {} would be passed in, but what is the point in setting window.Module equal to itself?

For people posting answers:

I read the code as:

if(!(window.Module = window.Module)) {
     // pass {} into function
}
else {
     // pass window.Module = window.Module into function 
     // (which makes NO sense to me)
}

Maybe it's being used like that just because of the conditionality? If false, give empty object. Shorter than an if statement? — Sterling Archer, Jan 02 '14 at 17:48
yes, by setting it to itself, you are basically doing "nothing" if it exists, if not, set to empty object. just shorthand if — A.O., Jan 02 '14 at 17:49
You may find this question helpful - http://stackoverflow.com/questions/2802055/what-does-this-construct-x-x-y-mean — kmoe, Jan 02 '14 at 17:56
`if( !( 'Module' in window ) ) window.Module = {};` is how I would do it, then there is no self assignment. However in the long run of things, this isn't going to matter really. — rlemon, Jan 02 '14 at 18:22

T.J. Crowder · Accepted Answer · 2014-01-02T17:56:15.877

That bit does two things:

The window.Module || {} bit uses JavaScript's curiously-powerful || operator to evaluate to either window.Module (if it's truthy) or {} (if window.Module is falsey). || evalutes to its first non-falsey operand. Then the result of that is assigned to window.Module. The result is that if window.Module was falsey (probably undefined), it gets {} assigned to it; if it wasn't falsey (it probably already refers to an object), in theory it gets reassigned to itself although in practice engines are probably smart enough not to bother with the dead store.
Then it passes the result of the assignment (the value [now] in window.Module) into the function.

So the end result is that window.Module is set to a new blank object if it wasn't set before, and regardless of whether it was set before, whatever object is (now) in window.Module is passed into the function.

score 1 · Answer 2 · answered Jan 02 '14 at 17:50

This confusion is why I'm not a fan of the short-circuit expression over a simple if.

Expressed using a conventional structure:

if (!window.Module)
{
    window.Module = {};
}
else
{
    // this is a no-op, and the whole else clause could be removed.
    window.Module = window.Module;
}

You can't use this structure in an expression, but it is more readable.

The main reason it's assigning window.Module is to be sure it's assigned. You could simply pass window.Module || {}, but that would leave it uninitialized.

Šime Vidas · Answer 3 · 2014-01-02T18:06:15.277

0

(function(module){
    // do something with module
})(window.Module = window.Module || {});

This code first makes sure that a global Module object is set, and then passes it into the function. If you left out the assignment:

(function(module){
    // do something with module
})(window.Module || {});

then Module would not be set (if it didn't exist at that point). Of course, module can be used to access the object, but some code inside the function may require Module.

A better pattern could be:

// global code
if (!iwindow.Module) window.Module = {};

(function () {
  // use Module
}());

edited Jan 02 '14 at 18:06

answered Jan 02 '14 at 17:53

Šime Vidas

182,163
62
281
385

Well in your last part, I would still pass `Module` into the function anyway, no? Isn't that always a good pattern? – qwertynl Jan 02 '14 at 17:58
@qwertynl I don't think so. For the sake of code clarity, `Module` should just be accessed as a global variable. – Šime Vidas Jan 02 '14 at 18:04

What is the point in setting something equal to itself?

3 Answers3