Is it true that in most Object Oriented Programming Languages, an "i" in an instance method always refers first to local, and then to global, but never to the instance variable or class variable?

Question

In the following code:

    <script type="text/javascript">

        var i = 10;

        function Circle(radius) {
            this.r = radius;
            this.i = radius;
        }

        Circle.i = 123;

        Circle.prototype.area = function() { alert(i); }

        var c = new Circle(1);
        var a = c.area();

    </script>

What is being alerted? The answer is at the end of this question.

I found that the i in the alert call either refers to any local (if any), or the global variable. There is no way that it can be the instance variable or the class variable even when there is no local and no global defined. To refer to the instance variable i, we need this.i, and to the class variable i, we need Circle.i. Is this actually true for almost all Object oriented programming languages? Any exception? Are there cases that when there is no local and no global, it will look up the instance variable and then the class variable scope? (or in this case, are those called scope?)

the answer is: 10 is being alerted.

Answer 1

What you are seeing is a closure.

http://www.jibbering.com/faq/faq_notes/closures.html

If you want this.i or Circle.i, you must explicitly refer to them.

Just like in Python (self.x and cls.x), Javascript has no syntactic sugar for instance or class/prototype attributes.

Answer 2

in general object oriented programming language, instance variable (as the name indicates) can be accessed only through the instance of a class(except static variables which can be accessed by class name). So when ever you want to refer an instance variable you need to have the object(instance) of the class.

Answer 3

To refer to an instance variable you must use this.i. Circle.i refers to a static property on the Circle constructor -- it will have no affect on instances of Circle.

Answer 4

No that is not true.

Most languages will let you access instance variables without using something like this.i to specify that it's an instance variable.

Languages that really are object oriented, like Java, C# and VB (7+), doesn't even have any global variables at all.

Javascript isn't really an object orented language, it's a procedural language with limited support for object orientation. As it doesn't have classes, there isn't any class scope, so you need to use the this keyword to specify the object scope.

Answer 5

Behold:

var i = 10;

function Circle(radius) {
            var i = radius || 0;
            this.r = i;
            this.i = radius;
            this.toString = function(){ return i; };
        }    
var nwCircle = new Circle(45);

alert(nwCircle.r); //=>45;
alert(nwCircle); //=>45 (toString found local i);
alert(i); //=>10

Now, in the Circle constructor you created a closure to the (local, belonging to the object itself) variable i. The globally defined i is unaffected. So, in javascript it depends on where you define your variable. In javascript at least, a bottom up search (from the local scope to the global scope) is done for i and the first one found is used. So if the Circle constructor didn't contain a variable called i, the global i would be used.