This question already has answers here:
Explain the encapsulated anonymous function syntax
(10 answers)
Closed 6 years ago.
Lets assume we have
function () {}.bind(null);
and
(function () {}).bind(null);
Why the first one doesn't work in developer console (it throws syntax error) but both of them work in code (".js" file in website).
I think its because you are trying to define an anonymous function. Console has no future way of referencing it so its a pointless endeavour, youre defining a function you have no way of calling. If you define it as a variable it works:
var a = function () {}.bind(null);
Also I dont think its binding related. Defining an anonymous function without binding and you have the same error
Edits
A statement that begins with the keyword "function" must be a valid
function declaration statement. That requires a name for the function.
In an expression (or expression statement), that rule is different; no
name is necessary because the function acts as a value in that
context. No name is required then.
via #Pointy from this answer
A function declaration cannot be anonymous, but a function expression
can. A stand alone anonymous function looks like a function
declaration that is missing an identifier to JavaScript. But, combined
with an operator, JavaScript treats an anonymous function as the
operator's operand expression.
via #gilly3 from this answer
Related
This question already has answers here:
JavaScript plus sign in front of function expression
(4 answers)
Closed 5 years ago.
I had look at this question to know about what this means.
(function($) {
})(jQuery);
I am looking at different bootstrap plugins, which have +function ($), while defining the function.
What does + does here, does it appends this function to other functions ?
To guide the javascript parser, that the thing written near the unary operator + is an expression.
EDIT: You can create javascript functions anonymously. This is one of the syntaxes to create the same. By doing so, when they are called (i.e evaluated), they act like a returning a function value. You can read more from the second link which provides a good description of it.
This link explains it well
Once declared, if not named, these can be executed inline like IIFE (Immediately invoked function expressions) as well. And in this form, they can then be used to create plugins or used as namespaces and attached to window object or jquery object for use later.
Good sample file to see anonymous function code in action
http://www.programering.com/a/MTMwITMwATk.html
It's a bang function
the + operator is faster than usual !
see more at
javascript function leading bang ! syntax
This question already has answers here:
Explain the encapsulated anonymous function syntax
(10 answers)
Closed 5 years ago.
Sorry about this being so vague, but I'm sure how else to ask this, simply because I don't know what it is. I've seen this once before, but I can't remember what it's doing or where to look for it.
What is this code doing with the outer parentheses and "window" thing?
(function(angular){
//some code
})(window.angular);
I really am sorry. After I get reference to some official documentation or something, I'll delete the post.
This is an example of IIFE (Immediately Invoked Function Expressions). Take a look at here for more explanation.
The first part
(function(angular){
//some code
})
is an anonymous function (it does not have a name). Since you want to execute it immediately (when the page/DOM is loaded), you just call it like any other function
(window.angular);
..with a parenthesis, arguments and a semicolon.
Your argument (window.angular) is just a global object (which is why it is defined on window scope).
In short, you are executing that body of function with an argument, which is defined globally.
This question already has answers here:
Reason behind this self invoking anonymous function variant
(5 answers)
Closed 8 years ago.
I just took a look at the underscore.js source code and when i strip the source code down to its bare containing IIFE it looks like this:
(function() {
}.call(this));
I always used the syntax with outer parantheses (function() {}).call(this); and wondered if this syntax is also valid and common?
If you're asking about the location of the outer ) specifically, then whether it's located immediately after the closing brace or after the entire expression doesn't matter for the most part. Either way doesn't make a difference to how the IIFE is executed.
The only difference here is the .call(this), which is invoked as a member of the function expression — a typical IIFE has just the inner parentheses immediately following the closing brace. The reason .call(this) is used is detailed in a number of other answers including this one.
This question already has answers here:
How does JavaScript determine when to give a function call a "this" context? [duplicate]
(2 answers)
Closed 8 years ago.
What exactly is the parsing rule in JS that results in the following:
Let's say we have this function
getThis = function(){
return this;
}
These all work as expected using the "previous dot" rule:
getThis(); //=> Window
obj = {getThis: getThis};
obj.getThis(); //=> obj
getThisTwo = obj.getThis;
getThisTwo(); //=> Window
However, this surprises me:
(obj.getThis)() //=> obj ...WAT
My intuition would be that it would behave exactly like the 3rd example (getThisTwo). Ie, the part in parentheses is evaluated, which returns an anonymous function, which is then invoked. My expectation then is that this would be Window, not obj.
Is this a special case, or is my understanding of how this is resolved faulty?
(Edited to make the reason for my confusion clearer)
Yes. The value of the this context of a call depends on the type of the function invocation.
In your case, it's a method invocation - a function that is called by a property reference. And yes, parentheses do not evaluate a property reference.
See also Nature of JS bound functions and function invocation operator and this very good answer for details.
This question already has answers here:
Immediate function invocation syntax
(3 answers)
Closed 9 years ago.
In order to use the $ symbol in jquery and not have to use jQuery.functionname, we use this
(function($) {
})(jQuery);
(In drupal, you actually have to specify this implicitly).
I don't understand this javascript syntax, why is there an initial parentheses? How is the (jQuery) at the end used?
It's just an anonymous function with an argument that's automatically invoked.
For example, if we were to expand it out a bit you'd end up with something like this:
var anon = function($) {
...
};
anon(jQuery);
The $ is a valid identifer in JavaScript and we pass in the existing jQuery object into the function for use through $, as it could be replaced later.
All that's doing is declaring an anonymous function and executing it immediately, passing in one argument (jQuery) into the function. That argument is given the name $ which can be used throughout the scope of the function.
The brackets around the function aren't strictly necessary in all contexts; see the comment under this answer for details. The gist is that they're needed here to make the function behave like an expression instead of a statement (function declaration).