I see correct output in your example. I guess output format of the consoles may confuse, but:

foo.bar(); correctly matches to Object { bar=function()} — this is the foo object.

test() maps to the Window which is the global object in the browser environment.

fooTwo===fooTwo.prototype.constructor: true is really true.

fooTwo() also correctly shows Window (global).

fooTwo {} maps to fooTwo.prototype.

 var foo={
            bar:function(){
                return this;
            }
        };
        console.log(foo.bar());//foo
        //Again we have the value of type Reference which base is foo object and which
        //is foo object and which is used as this value at bar function activation
            //var fooBarReference={
            //base:foo,
            //propertyName:'bar'
            //};

        //However,activating the same function with another form of a call expression,
        //we have already other this value
        var test=foo.bar;
        console.log(test());//global
        //Because test,being the identifier,produces other value of Reference type,which
        //base(the global object) is used as this value;
            //var testReference={
            //  base:global,
            //  propertyName:'test'
            //}

        function fooTwo(){
            return this;
        }
        console.log("fooTwo===fooTwo.prototype.constructor:",fooTwo===fooTwo.prototype.constructor);
console.log(fooTwo());
console.log(fooTwo.prototype.constructor()); 

the resluts is :

Object { bar=function()}
Window
fooTwo===fooTwo.prototype.constructor: true
Window
fooTwo {}

could you give me some suggests about this question.thank u

1) In function getValue() I had to use return v.base instead of v.base[v.propertyName];

No, it’s not correct, should be nevertheless v.base[v.propertyName].

The mistake you made is that you used not correct base component for e.g. x reference. You used x as the base, but it should be the global object. Once again, the base component of the reference is an object to which the property belongs. Global variable x belongs to global object, therefore global object is its base.

You have (wrong):

var x = 10;

// wrong
var xReference = new Reference(x,"x");

and it should be:

// global object -- we need it to
// use as a base of global variables!

var global = this;

var x = 10;

// base is "global" (not "x" as in your example),
// since variable "x" is a global variable

var xReference = new Reference(global, "x");

Also if you defined your own ReferenceError constructor (though, it’s a native built-in function), then for tests you may not throw it in getValue, but just return. So the complete code to test may look like this:

// global object
var global = this;

// global variable "x"
var x = 10;

// reference for global variable "x":
// base: global, propertyName: "x"
var xReference = new Reference(global, "x");

console.log("Type of 'x': ", typeof x); // "number"
console.log("Value of 'x': ", getValue(xReference)); // 10

// unresolved reference for non-existing
// variable "y" (i.e. base is null)

var yReference = new Reference(null, "y");

console.log("Type of 'y': ", typeof y ); // "undefined"
console.log("Value of 'y': ", getValue(yReference)); // ReferenceError

function Reference(base, propertyName) {
  this.base = base;
  this.propertyName = propertyName;
}

function ReferenceError(error) {
    return "Reference Error: " + error;
}

function getValue(v) {
  if (v instanceof Reference) {
    if (!v.base) {
      return ReferenceError(v.propertyName + " is not defined");
    }
    return v.base[v.propertyName];
  }
  return v;
}

Dmitry.

1) In function getValue() I had to use return v.base instead of v.base[v.propertyName];
2) for undefined var y ReferenceError is not called in the statements like:

alert(y);

or

document.write("Value of 'y': ", getValue(yReference));

//========================================================//

var x = 10;

var xReference = new Reference(x,"x");
document.write("Type of 'x': ", typeof x );
document.write("Value of 'x': ", getValue(xReference));

var yReference = new Reference(null,"y");
document.write(getValue(yReference));  // works, "Reference Error"
document.write("Type of 'y': ", typeof y );    			//does not work
document.write("Value of 'y': ", getValue(yReference)); //does not work

function Reference(base, propertyName) {
  this.base = base;
  this.propertyName = propertyName;
}

function ReferenceError(error) {
 document.write("Reference Error: ", error);
} 

function getValue(v) {
  if (v instanceof Reference) {
    if (!v.base) {
      throw new ReferenceError(v.propertyName + " is not defined");
    }
    return v.base;  //instead of v.base[v.propertyName];
  }
  return v;
}

//==================================================//

Thank you.
Luiz.

Yes, as you correctly noted, it’s a pseudo-code and just corresponds to the technical algorithm of the specification.

I am not sure how to interpret the “base:global” expression

Well, for the global we may use direct this value in the global context as is mentioned in the appropriate section above. I.e.:

var global = this;

Alternatively, in the browser environment, we can use window binding to refer the global object (though, this is more correct).

var global = window;

GetValue() function is also kind of vaguely defined.

Can you please provide the same (or similar) code fragment in the form that can be actually executed (let’s say in Firebug debugger) and would be useful in exploring this internal machinery?

Yeah, first, GetValue described here is a pseudo-code reflection of the corresponding algorithm of the ES5/ES5 spec. Take a look on it — here (I used ES3 version when was writing this chapter, ES5 version is slightly modified, but the main part is the same).

A value of Reference type as mentioned is a pair: base and propertyName. It can be presented as a constructor in plain JS:

function Reference(base, propertyName) {
  this.base = base;
  this.propertyName = propertyName;
}

When interpreter meets a variable/function name (or in other words — an identifier), it resolves it — i.e. it searches it in the scope chain. This is a process of the identifier resolution which is described in the Chapter 4 Scope chain.

The thing interesting to us, is that the result of the identifier resolution mechanism is always the value of type reference.

If the identifier is found in the scope chain — return the value of Reference type with base containing that variable object in which the identifier is found (scope chain as you probably know or will learn in the next chapter 4 is a chain of variable objects from different nested contexts).

If the identifier is not found — also the value of Reference type is returned, but with base component equals to null.

And then, if to transform our pseudo-code of GetValue more closely to JS, we’ll get:

function getValue(v) {
  if (v instanceof Reference) {
    if (!v.base) {
      throw new ReferenceError(v.propertyName +
         " is not defined");
    }
    return v.base[v.propertyName];
  }
  return v;
}

And if we have, e.g. global variable x:

var x = 10;

then after the identifier resolution mechanism, we get the following value of the Reference type:

var xReference = new Reference(global, "x");

Notice, it’s an intermediate result of some calculation, it’s not the real value of x yet, i.e. 10. To get exactly the value of x, already getValue is applied:

getValue(xReference); // 10

If in contrast we refer a non-existing variable from the code, e.g. y, then as we said, we also get the value of Reference type, but with base set to null:

var yReference = new Reference(null, "y");

Such intermediate results (of the Reference type) are very important to JS. E.g. exactly via it the work of typeof operator is explained. We won’t get an error in the following code:

alert(typeof y); // "undefined"

because typeof doesn’t call getValue, it just works with the reference itself. However, we do get the ReferenceError if try to just alert the y:

alert(y); // "ReferenceError": y is not defined

and now we know why -- because we provided such a behavior in the getValue. Function alert to display the value of the variable, should call getValue:

getValue(yReference); // y is not defined

And in the similar respect determination of this value for function calls works. If on the left-hand side (LHS) is the value of Reference type, then this is set to the base of reference

var foo = {
  bar: function () {
    alert(this);
  }
};

foo.bar(); // Reference, OK => foo

Grouping operator, the same as typeof also doesn't call our getValue, which means either with, or without grouping operator -- we still have the reference value:

(foo.bar)(); // Reference, OK => foo

However, assignment (the same as alert above with y) does call getValue and after its work we already have not the value of Reference type, but the function value, and as a result -- this value is set to null and then converted (in ES3) to global object:

(foo.bar = foo.bar)(); // global

That is -- a shorter, but detailed description of these algorithms. Feel free to ask questions if is needed to clarify something.

Dmitry.

I am reading this chapter and specifically work on this pieces of code:

var foo = 10;
function bar() {}

var fooReference = {
  base: global,
  propertyName: 'foo'
};

var barReference = {
  base: global,
  propertyName: 'bar'
};

function GetValue(value) {

  if (Type(value) != Reference) {
    return value;
  }

  var base = GetBase(value);

  if (base === null) {
    throw new ReferenceError;
  }

  return base.[[Get]](GetPropertyName(value));

}

GetValue(fooReference); // 10
GetValue(barReference); // function object "bar"

I realize that the code above is partially a pseudo-code, but I am still trying to
to modify it and run to see in action what is actually going on here.

I am not sure how to interpret the “base:global” expression in both fooReference and barReference variables. GetValue() function is also kind of vaguely defined.

Can you please provide the same (or similar) code fragment in the form that can be actually executed (let’s say in Firebug debugger) and would be useful in exploring this internal machinery? This is a key point to understanding “this” so more details about the Reference type would be extremely useful.
Thanks in advance!

It’s not completely wrong of course; it’s correct for exactly Firefox (in which console seems I was testing the code).

As you probably know Firefox defines a special type of functions which are called Function Statements. This extension allows to define functions conditionally in e.g. if-blocks. In all other current implementations a function declaration is independent from the conditional if-block.

if (true) {
  function foo() {
    alert(1);
  }
} else {
  function foo() {
    alert(2);
  }
}

foo(); // 1 in FF, 2 - in other

So in case of that example f4 as shown in the reply to leoner is hoisted to the top and saves the parent scope chain at the moment of its definition. At this moment of course there is no that {x: 5} added by the with.

And in Chrome (and other) the behavior is correct. It should be 20 in the last call. But, in Firefox the behavior is also correct — depending on its Function Statement extension (which behaves similarly in this respect to Function Expressions as shown in that reply). And in FF it should be 50 in the last call.

The future version of ECMAScript should standardize function statements, and then the correct result should be as in FF, i.e. 50. But now, both are correct. Since function declarations in blocks (which are function statements) are not defined by the current spec and are extensions with their own behavior. Though, the behavior of FF seems more logical to me.

Dmitry.