I want to pass two anonymous functions as arguments for jQuery&#39;s hover, like so:

    $(&#39;element&#39;).hover(
      function() {
        // do stuff on mouseover
      },
      function() {
        // do stuff on mouseout
      }
    );

It&#39;s easy with just one – `hover -&gt;` – but what is the proper syntax in CoffeeScript for two? I tried `...hover -&gt;`, `...hover( -&gt;...`, etc. but nothing gets me the above structure.

How to pass two anonymous functions as arguments in CoffeScript?

This question isn&#39;t terribly specific; **it&#39;s really for my own C enrichment and I hope others can find it useful as well.**

Disclaimer: I know many will have the impulse to respond with &quot;if you&#39;re trying to do FP then just use a functional language&quot;. I work in an embedded environment that needs to link to many other C libraries, and doesn&#39;t have much space for many more large shared libs and does not support many language runtimes. Moreover, dynamic memory allocation is out of the question. I&#39;m also just really curious.

Many of us have seen this nifty C macro for lambda expressions:

    #define lambda(return_type, function_body) \
    ({ \
          return_type __fn__ function_body \
              __fn__; \
    })

And an example usage is:

    int (*max)(int, int) = lambda (int, (int x, int y) { return x &gt; y ? x : y; });
    max(4, 5); // Example

Using `gcc -std=c89 -E test.c`, the lambda expands to:

    int (*max)(int, int) = ({ int __fn__ (int x, int y) { return x &gt; y ? x : y; } __fn__; });

So, these are my questions:

 1. What precisely does the line *int (\*X);* declare? Of course, *int \* X;* is a pointer to an integer, but how do these two differ?

 2. Taking a look at the exapnded macro, what on earth does the final `__fn__` do? If I write a test function `void test() { printf(&quot;hello&quot;); } test;` - that immediately throws an error. I do not understand that syntax.

 3. What does this mean for debugging? (I&#39;m planning to experiment myself with this and gdb, but others&#39; experiences or opinions would be great). Would this screw up static analyzers?

Anonymous functions using GCC statement expressions

Is it possible to put a function in a data structure, without first giving it a name with `def`?

    # This is the behaviour I want. Prints &quot;hi&quot;.
    def myprint(msg):
        print msg
    f_list = [ myprint ]
    f_list[0](&#39;hi&#39;)
    # The word &quot;myprint&quot; is never used again. Why litter the namespace with it?

The body of a lambda function is severely limited, so I can&#39;t use them. 

Edit: For reference, this is more like the real-life code where I encountered the problem.

    def handle_message( msg ):
        print msg
    def handle_warning( msg ):
        global num_warnings, num_fatals
        num_warnings += 1
        if ( is_fatal( msg ) ):
            num_fatals += 1
    handlers = (
        ( re.compile( &#39;^&lt;\w+&gt; (.*)&#39; ), handle_message ),
        ( re.compile( &#39;^\*{3} (.*)&#39; ), handle_warning ),
    )
    # There are really 10 or so handlers, of similar length.
    # The regexps are uncomfortably separated from the handler bodies,
    # and the code is unnecessarily long.
    
    for line in open( &quot;log&quot; ):
        for ( regex, handler ) in handlers:
            m = regex.search( line )
            if ( m ): handler( m.group(1) )

Choose Python function to call based on a regex

In Python, I am trying to sort by date with lambda.  I can&#39;t understand my error message. The message is:

    &lt;lambda&gt;() takes exactly 1 argument (2 given)

The line I have is

    a = sorted(a, lambda x: x.modified, reverse=True)

How to sort with lambda in Python

Is it possible to have a PHP function that is both recursive and anonymous? This is my attempt to get it to work, but it doesn&#39;t pass in the function name.

    $factorial = function( $n ) use ( $factorial ) {
        if( $n &lt;= 1 ) return 1;
        return $factorial( $n - 1 ) * $n;
    };
    print $factorial( 5 );

I&#39;m also aware that this is a bad way to implement factorial, it&#39;s just an example.

Anonymous recursive PHP functions

Let&#39;s say I have a basic recursive function:

    function recur(data) {
        data = data+1;
        var nothing = function() {
            recur(data);
        }
        nothing();
    }

How could I do this if I have an anonymous function such as...

    (function(data){
        data = data+1;
        var nothing = function() {
            //Something here that calls the function?
        }
        nothing();
    })();

I&#39;d like a way to call the function that called this function... I&#39;ve seen scripts somewhere (I can&#39;t remember where) that can tell you the name of a function called, but I can&#39;t recall any of that information right now.

javascript: recursive anonymous function?

I have an object that has methods in it. These methods are put into the object inside an anonymous function. It looks like this:

    var t = {};
    window.document.addEventListener(&quot;keydown&quot;, function(e) {
        t.scroll = function(x, y) {
            window.scrollBy(x, y);
        };
        t.scrollTo = function(x, y) {
            window.scrollTo(x, y);
        };
    });  
(there is a lot more code, but this is enough to show the problem)

Now I want to stop the event listener in some cases. Therefore I am trying to do a removeEventListener but I can&#39;t figure out how to do this. I have read in other questions that it is not possible to call removeEventListener on anonymous functions, but is this also the case in this situation?

I have a method in t created inside the anonymous function and therefore I thought it was possible. Looks like this:

    t.disable = function() {
        window.document.removeEventListener(&quot;keydown&quot;, this, false);
    }

Why can&#39;t I do this?

Is there any other (good) way to do this?

Bonus info; this only has to work in Safari, hence the missing IE support.

removeEventListener on anonymous functions in JavaScript

I was recently comparing the current version of [json2.js][1] with the version I had in my project and noticed a difference in how the function expression was created and self executed.

The code used to wrap an anonymous function in parenthesis and then execute it,

    (function () {
      // code here
    })();

but now it wraps the auto-executed function in parenthesis.

    (function () {
      // code here
    }());

There is a comment by CMS in the accepted answer of [Explain JavaScript’s encapsulated anonymous function syntax][2] that “both: `(function(){})();` and `(function(){}());` are valid.”

I was wondering what the difference is?  Does the former take up memory by leaving around a global, anonymous function?  Where should the parenthesis be located?


  [1]: https://github.com/douglascrockford/JSON-js/blob/master/json2.js
  [2]: https://stackoverflow.com/questions/1634268/explain-javascripts-encapsulated-anonymous-function-syntax

Location of parenthesis for auto-executing anonymous JavaScript functions?

    function foo(x) {
       console.log(arguments)
    } //foo(1) prints [1]

but 

    var bar = x =&gt; console.log(arguments) 

gives the following error when invoked in the same way:

    Uncaught ReferenceError: arguments is not defined

Why do arrow functions not have the arguments array?

Part of a website&#39;s JSON response had this (... added for context):

    {..., now:function(){return(new Date).getTime()}, ...}

Is adding anonymous functions to JSON valid?  I would expect each time you access &#39;time&#39; to return a different value.

Is it valid to define functions in JSON results?

We have two different way for doing function expression in JavaScript:

**Named function expression (NFE)**: 

    var boo = function boo () {
      alert(1);
    };

**Anonymous function expression**:

    var boo = function () {
      alert(1);
    };

And both of them can be called with `boo();`. I really can&#39;t see why/when I should use anonymous functions and when I should use Named Function Expressions. What difference is there between them?

Why use named function expressions?

&gt; **Possible Duplicate:**  
&gt; [How can I pre-set arguments in JavaScript function call? (Partial Function Application)](https://stackoverflow.com/questions/321113/how-can-i-pre-set-arguments-in-javascript-function-call-partial-function-appli)  

&lt;!-- End of automatically inserted text --&gt;

I need to able to **pass a reference to a function with a given set of parameters**.

Here is an example of passing a reference ***without** parameters*:

    var f = function () {
        //Some logic here...
    };
    
    var fr = f; //Here I am passing a reference to function &#39;f&#39;, without parameters
    fr(); //the &#39;f&#39; function is invoked, without parameters

Now what I need to do is pass the same `f` function, but this time I would need to pass parameters to the reference.  Now, I can do it with an anonymous function and invoke the `f` function with parameters inside the newly created function, like such:

    var f = function () {
            //Some logic here...
        };
    
    var fr = function (pars) {
        f(pars);
    }; //Here I am creating an anonymous function, and invoking f inside it
    
    fr({p : &#39;a parameter&#39;}); //Invoking the fr function, that will later invoke the f function with parameters

But my question is, **Is there a way to pass a direct reference to the `f` function With parameters to `fr`, but without enclosing it in an anonymous function?**

*What do I need to assign to `fr` to make it invokable without parameters (`fr()`), so that f(1,2,3) is executed when `fr` is invoked?*   

**[UPDATE]** 
I followed [Jason Bunting][1]&#39;s answer to [here][2] about the *Partial Function* and the JavaScript function he posts there is exactly what I was looking for.  Here is the solution:

    function partial(func /*, 0..n args */) {
      var args = Array.prototype.slice.call(arguments).splice(1);
      return function() {
        var allArguments = args.concat(Array.prototype.slice.call(arguments));
        return func.apply(this, allArguments);
      };
    }

   


  [1]: https://stackoverflow.com/questions/373157/javascript-passing-a-reference-to-a-function-with-parameters#373216
  [2]: https://stackoverflow.com/questions/321113

How can I pass a reference to a function, with parameters?

How can I write an anonymous function in Java?

I was pretty excited to read about [anonymous functions][1] in php, which let you declare a variable that is function easier than you could do with [create_function][2]. Now I am wondering if I have a function that is passed a variable, how can I check it to determine if it is a function? There is no is_function() function yet, and when I do a var_dump of a variable that is a function::

    $func = function(){
        echo &#39;asdf&#39;;
    };
    var_dump($func);

I get this:

    object(Closure)#8 (0) { } 

Any thoughts on how to check if this is a function? 

  [1]: http://php.net/manual/en/functions.anonymous.php
  [2]: http://us2.php.net/manual/en/function.create-function.php

php is_function() to determine if a variable is a function

How to removeEventListener that is addEventListener with anonymous function?

Why is **this** in an anonymous function undefined when using javascript in strict mode? I understand why this could make sense, but I couldn&#39;t find any concrete answer.

Example:

    (function () {
        &quot;use strict&quot;;
        
        this.foo = &quot;bar&quot;; // *this* is undefined, why?
    }());

Test in a fiddle: http://jsfiddle.net/Pyr5g/1/
Check out the logger (firebug).

Why is &quot;this&quot; in an anonymous function undefined when using strict?

The PHP manual states 

&gt; It is not possible to use `$this` from anonymous function before PHP
&gt; 5.4.0

on the [anonymous functions page][1].  But I have found I can make it work by assigning `$this` to a variable and passing the variable to a `use` statement at the function definition.

	$CI = $this;
	$callback = function () use ($CI) {
		$CI-&gt;public_method();
	};

Is this a good practice?  
Is there a better way to access `$this` inside an anonymous function using PHP 5.3?


  [1]: http://php.net/manual/en/functions.anonymous.php

Using `$this` in an anonymous function in PHP pre 5.4.0

Considering the following code snippet:

    # directorys == {&#39;login&#39;: &lt;object at ...&gt;, &#39;home&#39;: &lt;object at ...&gt;}
    for d in directorys:
        self.command[&quot;cd &quot; + d] = (lambda : self.root.change_directory(d))

I expect to create a dictionary of two function as following :

    # Expected :
    self.command == {
        &quot;cd login&quot;: lambda: self.root.change_directory(&quot;login&quot;),
        &quot;cd home&quot;: lambda: self.root.change_directory(&quot;home&quot;)
    }

but it looks like the two lambda function generated are exactly the same :

    # Result :
    self.command == {
        &quot;cd login&quot;: lambda: self.root.change_directory(&quot;login&quot;),
        &quot;cd home&quot;: lambda: self.root.change_directory(&quot;login&quot;)   # &lt;- Why login ?
    }

I really don&#39;t understand why. Do you have any suggestions ?

Lambda in a loop

There&#39;s something I don&#39;t understand about anonymous functions using the short notation #(..)

The following works:

    REPL&gt;  ((fn [s] s) &quot;Eh&quot;)
    &quot;Eh&quot;

But this doesn&#39;t:

    REPL&gt;  (#(%) &quot;Eh&quot;)

This works:

    REPL&gt; (#(str %) &quot;Eh&quot;)
    &quot;Eh&quot;

What I don&#39;t understand is why *(#(%) &quot;Eh&quot;)* doesn&#39;t work and at the same time I don&#39;t need to use *str* in *((fn [s] s) &quot;Eh&quot;)*

They&#39;re both anonymous functions and they both take, here, one parameter.  Why does the shorthand notation need a function while the other notation doesn&#39;t?



Anonymous function shorthand

    class MyClass {
      var $lambda;
      function __construct() {
        $this-&gt;lambda = function() {echo &#39;hello world&#39;;};
        // no errors here, so I assume that this is legal
      }
    }

    $myInstance = new MyClass();
    $myInstance-&gt;lambda();
    //Fatal error: Call to undefined method MyClass::lambda()

So what is the correct syntax for reaching class variables ?

How to call a closure that is a class variable?

&gt; **Possible Duplicate:**  
&gt; [In Php 5.3.0 what is the Function &amp;ldquo;Use&amp;rdquo; Identifier ? Should a sane programmer use it?](https://stackoverflow.com/questions/1065188/in-php-5-3-0-what-is-the-function-use-identifier-should-a-sane-programmer-use)  

&lt;!-- End of automatically inserted text --&gt;

I&#39;ve been examining the Closures in PHP and this is what took my attention:

    public function getTotal($tax)
        {
            $total = 0.00;
            
            $callback =
                function ($quantity, $product) use ($tax, &amp;$total)
                {
                    $pricePerItem = constant(__CLASS__ . &quot;::PRICE_&quot; .
                        strtoupper($product));
                    $total += ($pricePerItem * $quantity) * ($tax + 1.0);
                };
            
            array_walk($this-&gt;products, $callback);
            return round($total, 2);
        }
And somebody please give me an explanation about the usage of `use` in this code.

    function ($quantity, $product) use ($tax, &amp;$total)

When I search `use` in PHP, it finds `use` keyword where it is used in namespaces but here it looks different.

Thanks.

Use keyword in functions - PHP

Summary
-------
Can you explain the reasoning behind the syntax for encapsulated anonymous functions in JavaScript? Why does this work: `(function(){})();` but this doesn&#39;t: `function(){}();`?


----------


What I know
------------

In JavaScript, one creates a named function like this:

    function twoPlusTwo(){
        alert(2 + 2);
    }
    twoPlusTwo();

You can also create an anonymous function and assign it to a variable:

    var twoPlusTwo = function(){
        alert(2 + 2);
    };
    twoPlusTwo();

You can encapsulate a block of code by creating an anonymous function, then wrapping it in brackets and executing it immediately:

    (function(){
        alert(2 + 2);
    })();

This is useful when creating modularised scripts, to avoid cluttering up the current scope, or global scope, with potentially conflicting variables - as in the case of Greasemonkey scripts, jQuery plugins, etc.

Now, I understand why this works. The brackets enclose the contents and expose only the outcome (I&#39;m sure there&#39;s a better way to describe that), such as with `(2 + 2) === 4`.

---

What I don&#39;t understand
-----------------------

But I don&#39;t understand why this does not work equally as well:

    function(){
        alert(2 + 2);
    }();

Can you explain that to me?

Explain the encapsulated anonymous function syntax

I was reading some posts about closures and saw this everywhere, but there is no clear explanation how it works - everytime I was just told to use it...:

    // Create a new anonymous function, to use as a wrapper
    (function(){
        // The variable that would, normally, be global
        var msg = &quot;Thanks for visiting!&quot;;
    
        // Binding a new function to a global object
        window.onunload = function(){
            // Which uses the &#39;hidden&#39; variable
            alert( msg );
        };
    // Close off the anonymous function and execute it
    })();

Ok I see that we will create new anonymous function and then execute it. So after that this simple code should work (and it does):

    (function (msg){alert(msg)})(&#39;SO&#39;);

My question is what kind of magic happens here? I thought that when I wrote:

    (function (msg){alert(msg)})

then a new unnamed function would be created like function &quot;&quot;(msg) ...

but then why doesn&#39;t this work?

    (function (msg){alert(msg)});
    (&#39;SO&#39;);

Why does it need to be in the same line?

Could you please point me some posts or give me an explanation?


Why do you need to invoke an anonymous function on the same line?

&gt; **Possible Duplicates:**  
&gt; [What is Closures/Lambda in PHP or Javascript in layman terms?](https://stackoverflow.com/questions/4501411/what-is-closures-lambda-in-php-or-javascript-in-layman-terms)  
&gt; [What is the difference between a &amp;#39;closure&amp;#39; and a &amp;#39;lambda&amp;#39;?](https://stackoverflow.com/questions/220658/what-is-the-difference-between-a-closure-and-a-lambda)  

&lt;!-- End of automatically inserted text --&gt;

Hi,

I have been unable to find a definition that clearly explains the differences between a closure and an anonymous function.

Most references I have seen clearly specify that they are distinct &quot;things&quot; yet I can&#39;t seem to get my head around why.

Could someone please simplify it for me? What are the specific differences between these two language features? Which one is more appropriate in what scenarios?

Closure vs Anonymous function (difference?)

I was reading JS sources from Twitter &amp;mdash; on my way to improve my JS knowledge base, when I came across the strange way of calling anonymous function:

    !function( $ ) {
        ...
    }( window.jQuery );

... and this works! :)

It&#39;s obvious to everyone, that this:

    function ( $ ) { ... } ( window.jQuery )

does not work (Syntax error), while this one is correct:

    (function ( $ ) { .... })( window.jQuery )

Can anyone please explain this magic (why case with `!function` works)?

Javascript anonymous function call

I&#39;m new-ish to JavaScript.  I understand many of the concepts of the language, I&#39;ve been reading up on the prototype inheritance model, and I&#39;m whetting my whistle with more and more interactive front-end stuff.  It&#39;s an interesting language, but I&#39;m always a bit turned off by the callback spaghetti that is typical of many non-trivial interaction models.

Something that has always seemed strange to me is that in spite of the readability nightmare that is a nest of JavaScript nested callbacks, the one thing that I very rarely see in many examples and tutorials is the use of predefined named functions as callback arguments.  I&#39;m a Java programmer by day, and [discarding the stereotypical jabs about Enterprise-y names for units of code](http://projects.haykranen.nl/java/) one of the things I&#39;ve come to enjoy about working in a language with a strong selection of featureful IDE&#39;s is that using meaningful, if long, names can make the intent and meaning of code much clearer without making it more difficult to actually be productive.  So why not use the same approach when writing JavaScript code?

Giving it thought, I can come up with arguments that are both for and against this idea, but my naivety and newness to the language impairs me from reaching any conclusions as to why this would be good at a technical level.

## Pros:

- Flexibility.  An asynchronous function with a callback parameter could be reached by one of many different code paths and it could be harried to have to write a named function to account for every single possible edge case.
- Speed.  It plays heavily in to the hacker mentality.  Bolt things on to it until it works.
- Everyone else is doing it
- Smaller file sizes, even if trivially so, but every bit counts on the web.
- Simpler AST? I would assume that anonymous functions are generated at runtime and so the JIT won&#39;t muck about with mapping the name to instructions, but I&#39;m just guessing at this point.
- Quicker dispatching?  Not sure about this one either.  Guessing again.

## Cons:

- It&#39;s hideous and unreadable
- It adds to the confusion when you&#39;re nested nuts deep in a swamp of callbacks (which, to be fair, probably means you&#39;re writing poorly constructed code to begin with, but it&#39;s quite common).
- For someone without a functional background it can be a bizarre concept to grok

With so many modern browsers showing the ability to execute JavaScript code much faster than before, I&#39;m failing to see how any trivial sort of performance gain one might get out using anonymous callbacks would be a necessity.  It seems that, if you are in a situation where using a named function is feasible (predictable behavior and path of execution) then there would be no reason not to.

So are there any technical reasons or gotchas that I&#39;m not aware of that makes this practice so commonplace for a reason?

What are the benefits to using anonymous functions instead of named functions for callbacks and parameters in JavaScript event code?

Basically I&#39;d like to do something like this:

    $arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
    $avg = array_sum($arr) / count($arr);
    $callback = function($val){ return $val &lt; $avg };

    return array_filter($arr, $callback);

Is this actually possible? Calculating a variable outside of the anonymous function and using it inside?


Callback function using variables calculated outside of it

I know this is silly, but there&#39;s any difference between this:

    (function() {  
        var foo = &#39;bar&#39;;  
    })();

and this?

    (function() {  
        var foo = &#39;bar&#39;;  
    }());

[JSLint][1] tells us to `Move the invocation into the parens that contain the function`, but I see no need to.

**Edit:** The answers are too cool. `~function`, the [JSHint][2] alternative along with jQuery&#39;s preference for `(/***/)();` and Crockford&#39;s explanation! I thought I was going to just get a &quot;they&#39;re the same thing&quot; kind of answer.  
You guys decide the best one through upvotes and I tick it.


  [1]: http://www.jslint.com/
  [2]: http://www.jshint.com/

(...()) vs. (...)() in javascript closures

What does this code refer too?
&lt;!-- language-all: lang-js --&gt;
    
    queryString: function() {

    //some code

    }

I tested it in the WebConsole (Firefox) but it wouldn&#39;t execute, so I&#39;m thinking that it isn&#39;t equivalent to `function queryString() {}`.

So what is it exactly?

Javascript &#39;colon&#39; for labeling anonymous functions?

&gt; **Possible Duplicates:**  
&gt; [What is the difference between a function expression vs declaration in JavaScript?](https://stackoverflow.com/questions/1013385)  
&gt; [Explain JavaScript&amp;#39;s encapsulated anonymous function syntax](https://stackoverflow.com/questions/1634268/explain-javascripts-encapsulated-anonymous-function-syntax)  

&lt;!-- End of automatically inserted text --&gt;

Why this:
    
    (function () {
        //code
    }());

and this:

    var f = function () {
        //code
    }();

works, while this:
        
    function () {
        //code
    }();

does not? It looks exactly the same - anonymous function defined, and immediately called. Can someone make a quotation from the JavaScript/ECMAScript standard which explains that?

**UPDATE**: Thanks for the answers everyone! 
So it&#39;s about **function expression vs. function declaration**. See [this Stack&amp;nbsp;Overflow answer][1], [ECMAScript standard][2] section 13, and this great article: *[Named function expressions demystified][3]*.

To recap answers:

1. The first snippet is interpreted as an expression because the grouping operator, `()`, is applied - see [ECMAScript standard][4] section 11.1.6.

2. In the second snippet, the function is interpreted as an expression because it&#39;s on the right-hand part of assignment operator, `=`.

3. The third snippet doesn&#39;t have anything which allows the interpreter to read the function as an expression, so it&#39;s considered a declaration, which is invalid without an identifier (Gecko lets it pass however, but it chokes on following `()` grouping operator (as it thinks) applied to nothing).

  [1]: https://stackoverflow.com/questions/1634268/explain-javascripts-encapsulated-anonymous-function-syntax/1634321#1634321
  [2]: http://www.ecma-international.org/publications/files/ECMA-ST/Ecma-262.pdf
  [3]: http://kangax.github.com/nfe/
  [4]: http://www.ecma-international.org/publications/files/ECMA-ST/Ecma-262.pdf




JavaScript anonymous function immediate invocation/execution (expression vs. declaration)

I quickly want to determine whether/when a set of events are triggered. Therefore I quickly assigned empty lambda&#39;s to them.

    _session.TopologyStarted += () =&gt; { };

When tracing through the code when the event is triggered, the debugger goes into the anonymous function, allowing to debug it&#39;s execution. However, when setting a breakpoint on this line of code, a breakpoint is set on the assignment of the anonymous function to the event.

Is there a way to set a breakpoint within the anonymous function?

All Anonymous Function Solutions on Gang of Coders

Total of 31 Anonymous Function Solutions