Ma************@gmail.com wrote:
I've written a short article explaining closures in JavaScript. It's
at:
http://www.martinrinehart.com/articl...-closures.html
I think I've understood. I look forward to your constructive critique.
- A closure is _not_ "a bundle of data and code that manipulates that data";
that is how you could describe an *object* (and often it is done so),
which has properties and methods (which are merely callable properties in
ECMAScript implementations) to operate on these properties.
A closure is instead a subroutine (function) that reproduces its
definition context when executed. This definition context would
contain what is called "bound variables" that can then be accessed
from within the subroutine when executed (cf. Wikipedia etc.)
- Inner functions, by which you mean function declarations within function
declarations, must be distinguished from function expressions that you
are using later in your article to create closures.
While both constructs can create a closure, the former cannot create
closures with bound "variables" that are created after variable
instantiation. In contrast to function expressions, function declarations
cannot be within a block statement, so they cannot be conditional (except
with evil[tm] eval()).
I find calling a function expression an "inner function" to be confusing
at best. That is a term that I would use only for nested function
declarations.
And while the Specification makes no statement regarding the nesting depth
of functions (be they declared or created through an expression), there is
most certainly a practical limit, stack size included. IIRC we have
discussed this here before.
- I disagree with your sentiment that JS/ES was more pythonic than Python;
knowing both languages quite well, when it comes to power of expression
ECMAScript implementations still have a lot to learn from Python.
Incidentally, they are beginning to: read Brendan Eich's blog regarding
this; then consider Array comprehensions being supported since JavaScript
1.7 (Gecko 1.8.1/Firefox 2.0.x), which is but a Python copycat.
- The statement "In addition to explicitly declared parameters and vars,
there are other things. You can access some of them directly, such as
this and arguments." is wrong, because neither of the mentioned features
are either parameters or variables.
`this' is a keyword and a (Reference) value that refers to the calling or
constructed object. `arguments' is a property (of the Activation/Variable
object).
- The statement "Other parts, such as the activation object and the
execution context are also present, but you cannot access them from
JavaScript." is wrong in its absoluteness, because you can access the
Activation Object of the global execution context with `this' because
the Global object is also the Variable Object of this context.
The execution context as such is not anything that is supposed to be
accessible in code because it is merely a theoretical construct.
- "When outer() returns a function it also returns a copy of its execution
context." No, it does not, that's nonsense; because again, the execution
context is only a theoretical construct.
Instead, when the Function object is created in outer() it would need to
retain some information about which of the "variables" (properties) in it
are bound to the execution context of outer() and which are not; probably
a copy of or a reference to the Variable Object of the execution context
created with the previous outer() call.
What is returned is a reference to the Function object. Whether or not
that Function object retains a copy of or a reference to the Variable
Object of the execution context created with the previous outer() call
instead, remains to be seen; I would presume this to be
implementation-dependent, although it would be more efficient to use
a reference.
- As for your example, where is `init()'?
- As for your summary, where is `grow'?
HTH
PointedEars
--
Anyone who slaps a 'this page is best viewed with Browser X' label on
a Web page appears to be yearning for the bad old days, before the Web,
when you had very little chance of reading a document written on another
computer, another word processor, or another network. -- Tim Berners-Lee