Question

Where is the data supplied by the argument being stored? Is a var first being created implicitly?

function Student(first){
   this.getFirst = function(){
     return first;
   }
}

Tested with:

var myStudent = new Student("ross");

console.log(myStudent); // Student { getFirst=function() }

console.log(myStudent.getFirst()); // ross

console.log(first); // reference error, first not defined

console.log(myStudent.first); // undefined

for(var x in myStudent){
console.log(x);
} // getFirst

My second question is if I understand these correctly:

What happens with "var" variables inside a JavaScript Constructor?

“var” variables, "this" variables and "global" variables – inside a JavaScript Constructor

…is the getFirst function creates a closure and saves the state of the constructor’s parameter value, if I use a var first in the constructor body is it okay to think of that as ‘encapsulation’? Additionally, any inner function saves all the parameter values in a “closure state” or just the one’s referenced by the inner function?

Thank you very much for your thoughts. This is my first question on S.O. but use the site almost daily as a reference, so thank you for that. My programming knowledge is limited so pardon if I’ve used crappy terms, happy to clarify where needed.

Answer 1

The first parameter is stored locally to the function that is your constructor, so anywhere inside Student() it will be in scope.

More interestingly, the the anonymous inner function that you’re assigning to this.getFirst is closing over that value. Because of that, the inner function maintains a reference to the first variable even after the constructor is finished executing.

This works for regular functions too, not just constructors:

function makeCounter() {
   var count = 1;
   return function() { return count++; };
}

var counter = makeCounter();
console.log(counter());  // 1
console.log(counter());  // 2
console.log(counter());  // 3

When used the right way, this approach can be used to achieve “private” variables in JavaScript, in the sense that the values captured in the closure are inaccessible from the outside.

Because of that, it turns out not to matter whether a closure captures all the variables in its scope or just the ones it uses, since you can’t “reach inside” to those closed-over variables anyway. (Though in practice generally only the used values are captured, so that the runtime can garbage collect the rest, as they’re unneeded.)