negating self invoking function? !function ($) { ... }(window.jQuery);

javascript, jquery, negate, self-invoking-function, twitter-bootstrap

Solution

1) if you just do:

function () { /* ... */ }();

You will get an error. JS will not allow you to fire off a function declaration (because of a concept of "variable hoisting", which isn't technically correct, but is much easier for a lot of people to think about). If you use declarative functions:

function myFunc () { /* ... */ }

The JS engine will create them in the scope you're in, before creating the variables of the scope -- even if the vars are all on the top and the functions are all on the bottom.

So when you write:

function myFunc () { /* ... */ }();

There's an error there, because the vars which don't even exist yet, in the current scope might be called inside, which is a guaranteed crash.

To further that, if you don't give your function-declaration a name:

function () { /* ... */ }

...then there's an error there, regardless, because you can't call the function yet, but you have no way of getting at it, because it doesn't have a name, and you didn't assign it to a variable.

Operators like `()` or `+` or `!` -- anything which will force the engine to evaluate whatever comes next, will allow you to fire the function like:

+function () { /* ... */ }();

As long as there is no variable listening for a return statement, you're fine.

2) Additionally, in the case of `!function () { /*...*/ }();`, if that function doesn't have a return statement naturally, then it will return `undefined`. The opposite of `undefined` is `true` when coerced in that way...

...so if you really, REALLY wanted, you could do something like:

var success = !function () { /* ... */ }();
if (success) { doStuff(); }

Problem

Original source

Related problems

• What does the exclamation mark do before the function?
• javascript function leading bang ! syntax
• What does the exclamation mark do before the function?