var global = 0;
function outerFunction() {
    var outerLocal = 1;
    function innerFunction() {
        var innerLocal = 2;
        // Can access outerLocal here
        // Can access global here
    }
    return innerFunction;
}
 
 
 

outerFunction.staticVar = 10; 
// elsewhere
function callingFunction() {
    // Get a reference to innerFunction()
    var refToOuterDotInner = outerFunction();
    refToOuterDotInner();
} 
 

public class Outer() {
    public static int staticField = 10;
    private int outerLocal = 1;
    public class Inner() {
        private int innerLocal = 2;

        private void innerMethod() {
            int methodLocal = 4;
            // Can access innerLocal here
            // Can access outerLocal here
        }
    }

    public Inner getInner() {
        return new Inner();
    }
}

    // elsewhere
    public void callingMethod() {
        Outer outer = new Outer();
        Inner innerInstance = outer.getInner();
        // Invoke method of inner class
        inner.innerMethod();
    }

innerFunction() is analogous to --------->

The scope of innerFunction() maps to two concepts in Java world - the scopes of innerMethod() and the instance of Inner class.

The execution call stack of innerFunction() maps to the innerMethod() though.

 innerMethod() and instance of Inner class

I think this is the source of confusion for Java programmer. At least it was to me.

Three scopes when the innerFunction is executing:

• Global
• scope of outerFunction
• scope of innerFunction - maps to last two scopes on Java side
  

Three scopes when innerMethod() is executing.

• No equivalent in Java
  
• Outer instance scope
• Inner instance scope
• innerMethod() local scope
  

outerLocal in outerFunction is analogous to --------->

outerLocal is private to outerLocal but can be accessed from innerFunction() .

outerLocal field of an instance of Outer class.

outerLocal is private to the instance of Outer class but can be accessed from innertMethod() .

call stack involves:

innerFunction()
callingFunction()

call stack:

innerMethod()
callingMethod()

outerFunciton.staticVar is analogous to --------->

Note the absence of  () after outerFunction.