How JavaScript closures work under the hood

http://dmitryfrank.com/articles/js_closures

by dimonomid • 11 years ago

83 16 11 years ago

inglor2• 11 years ago

Can't talk about closures without mentioning this excellent piece http://mrale.ph/blog/2012/09/23/grokking-v8-closures-for-fun...

agumonkey• 11 years ago

Funny how all these articles make me think that lambda/closures are a very very nice syntax to create linguistic friendly structure. Automatically embedding of lexical scope avoid unnecessary names, assignments and side effects. Similarly to this talk https://news.ycombinator.com/item?id=3717715 where the author demonstrates how often we write classes with a bit of state, a constructor, and a single method [1].. which is a what a function does for us.

Some programming classes takes some time to describe this habit of unnecessary wrapping[2]. From

    ```
    if bool_var then true else false
    ```

, to theses functions-written-as-classes, or even, depending on the language you use, function that wraps other functions disguised as operators

    ```
    map(function add(x, y) { return x + y }, list)
    // aka `map + list` in deeply functional languages
    ```

[1] Java had many single method interfaces that can now be replaced by lambdas

[2] see Dan Grossman proglang on Coursera (taken from his original classes at UoWashington)

tel• 11 years ago

There is technically a pretty significant difference between

    +
    function add(x, y) { return x + y; }

in general in strict, effectful languages. The transformation is called "eta expansion" (technically, I performed two eta expansions and an un-currying) and we really would like it to be valid—it implies conceptual freedom to introduce and eliminate abstractions, but it rarely is. The issue being that it introduces thunks where computation or effects can hide.

Lio3• 11 years ago

AFAICT Closures are still much faster than Function.prototype.bind.

(http://jsperf.com/bind-vs-closure-setup/44)

Could anyone who knows more about the implementation details point to an explanation of what's going on under the surface?

draw_down• 11 years ago

How could test1 here ever be faster than test2? The functions are identical but calling test1 will always incur twice the actual function invocations, first to the bound function and then to _test1.

inglor2• 11 years ago

Here is an answer I wrote about it a while back http://stackoverflow.com/questions/17638305/why-is-bind-slow...

Let me know if you have any questions about it

Lio3• 11 years ago

That's a great answer, thank you.

songgao• 11 years ago

In case you are interested, `Function.prototype.bind` in V8 is implemented here:

https://github.com/nodejs/node/blob/9fddd83cf9adf505bce2e237...

Lio3• 11 years ago

That's vert interesting. Thank you.

haberman2• 11 years ago

Lua uses a concept called "upvalues" to refer to variables from enclosing scopes. The main observation here seems to be that you can statically determine a unique index for all local variables in any enclosing scope. I'm not sure exactly how the details work in cases where there are sibling scopes, but anyway it seems like a useful concept and i am surprised the concept/terminology is not more common.

ScottBurson2• 11 years ago

This technique is very old -- it goes back at least to Pascal, IIRC, and probably to Algol 60. It certainly was used in Scheme implementations in the late 1970s. I haven't heard the term "upvalue" before, though.

haberman2• 11 years ago

That's sort of my point. There seems to be some established knowledge about how you can address "upvalues" within closures but very little shared terminology or literature about it.

rjeli• 11 years ago

Tcl uses uplevel to evaluate a block of code in the current context.

ScottBurson2• 11 years ago

I've noticed that a lot of people (though not the author of this article) confuse the terms "lambda expression" and "closure". Perhaps this confusion is worth taking a moment to address here.

A closure, as explained in the article, is a pair of a code pointer and an environment. It is an object "inside the machine" that exists at runtime.

A lambda expression is a syntactic entity, a piece of source code: something you can see on the screen.

A lambda expression evaluates to a closure, just as an integer literal (a string of digits) evaluates to an integer, or a 'new' expression evaluates to an instance (object).

PyComfy• 11 years ago

A closure is a procedure that captures its free variables where those free variables are resolved in the lexical context.

A lambda procedure is just an anonymous procedure.

A lambda is not necessary a closure and a closure is not necessary a lambda.

Lx1oG-AWb6h_ZG0• 11 years ago

Every implementation of a closure I've encountered creates a new Capture class which stores references/copies of all variables the closure uses. I think they do this even if the closure doesn't reference any local variables - only class-level ones. In this case, wouldn't it be better to just implement it as a local function of the parent class instead of creating a new class? Or does it not matter because the cost of calling this.foo is negligibly similar to this.parent.foo?

How JavaScript closures work under the hood

Related Stories