This question already has an answer here:
-
Location of parenthesis for auto-executing anonymous JavaScript functions?
4 answers
Both of these code blocks below alert foo
then bar
. The only difference is })()
and }())
.
Code 1:
(function()
{
bar = \'bar\';
alert(\'foo\');
})();
alert(bar);
Code 2:
(function()
{
bar = \'bar\';
alert(\'foo\');
}());
alert(bar);
So is there any difference, apart from the syntax?
No; they are identical
However, if you add new
beforehand and .something
afterwards, they will be different.
Code 1
new (function() {
this.prop = 4;
}) ().prop;
This code creates a new instance of this function\'s class, then gets the prop
property of the new instance.
It returns 4
.
It\'s equivalent to
function MyClass() {
this.prop = 4;
}
new MyClass().prop;
Code 2
new ( function() {
return { Class: function() { } };
}() ).Class;
This code calls new
on the Class
property.
Since the parentheses for the function call are inside the outer set of parentheses, they aren\'t picked up by the new
expression, and instead call the function normally, returning its return value.
The new
expression parses up to the .Class
and instantiates that. (the parentheses after new
are optional)
It\'s equivalent to
var namespace = { Class: function() { } };
function getNamespace() { return namespace; }
new ( getNamespace() ).Class;
//Or,
new namespace.Class;
Without the parentheses around the call to getNamespace()
, this would be parsed as (new getNamespace()).Class
— it would call instantiate the getNamespace
class and return the Class
property of the new instance.
There\'s no difference - the opening brace only serves as a syntactic hint to tell the parser that what follows is a function expression instead of a function declaration.
There\'s no difference. Both are function expressions.
There is be a third way, too:
+function() {
bar = \'bar\';
alert(\'foo\');
}();
(instead of the +
another operator would work, too)
The most common way is
(function() {
// ...
})();
though.