Thanks, I’ve rewritten a bit this sentence; hope now it sounds easier.

I have another question:do the prototype property store in vo??
I mean the implicit __proto__ property you mentioned in the article javascript: the core

It’s better to put questions related to other articles in their comments. But, on the question — no, implicit [[Prototype]] property (which is __proto__ on figures) is the property of objects.

However, in some implementations, e.g. SpiderMonkey (Firefox), the global object (which is VO of the global context) inherits from Object.prototype. And in this case your sentence makes sense, since the global object is the VO there and has __proto__.

P.S.: I also fixed typos in lexical environment article, thanks.

Dmitry.

maybe your mean is “traversing the scope chain …”

Yep, it makes sense; I changed.

Dmitry.

other:

bypassing the scope chain in identifier resolution

maybe your mean is “traversing the scope chain …”

may be you means is “exists until the function exits“

Yep, it was a typo. Now it is: “exists until the function object is destroyed”. Which means, that a function’s [[Scope]] (list of parent VOs) will be removed when the function itself will be removed.

[[Scope]] contains as one of its objects that lexical environment (parent variable object) in which function is created.

It was too bad to understand, could you explain to me?

I removed the part with “as one of its objects”. Now it should be clearer. If you carefully read about [[Scope]], you should know that this internal function’s property stores a VO of the context in which a function is created.

Having this code:

var foo;
function bar() {}

the [[Scope]] of the “bar” function is:

bar.[[Scope]] = { // [[Scope]] is a global object
  foo: undefined,
  bar: <reference to function>,
  __parent__: null
};

E.g. for inner function “baz” the [[Scope]] is the following:

var x = 10;
function foo() {
  var bar;
  function baz() {}
}

And we have:

baz.[[Scope]] = {
  bar: undefined
  __parent__: foo.[[Scope]] // global
};

Alternative and more convenient representation of the [[Scope]] isn’t as separate objects with __parent__, but as an array. And we use this approach during this chapter. So the [[Scope]] — is a list which contains all parent variable objects (see 10.1.4).

For our “baz” function its internal [[Scope]] array is:

baz.[[Scope]] = [

  // foo's VO i.e. AO of foo's context
  {
    bar: undefined,
    baz: <reference to function>
  },

  // global VO
  {
    x: 10
  }

];

So you see that “baz.[[Scope]]” “contains that (parent) variable object in which function “baz” is created, i.e. the AO of foo’s context.

And then, when the “baz” will be activated, the scope chain of the baz’s context (a real scope chain which is used for identifier resolution lookup) is:

Scope(baz) = AO(baz) + baz.[[Scope]];

I.e. Scope(baz) is being created every time at baz’s activation and is related with the execution context. And the baz.[[Scope]] is created only once — at baz’s creation and related with the baz function.

Dmitry.

exists until the function exists

may be you means is “exists until the function exits”

[[Scope]] contains as one of its objects that lexical environment (parent variable object) in which function is created.

It was too bad to understand, could you explain to me?

I don’t know how to understand the “bypassing the scope chain.”.

Yes, a confusing word; I simply removed it.

Dmitry.

another question:

starting from the deepest context and up to the top bypassing the scope chain.

I don’t know how to understand the “bypassing the scope chain.”.

I think you means is :”starting from the deepest context and up to the top the scope chain.“,no “bypass”.

right?