带有let的JS / ECMAScript6私有字段的模式？

Question

I'm new to JS, so I'm trying to find a good pattern for having private fields with ECMAScript 6.

I'm using ES6's classes running on Node.js (latest version). I came up with the following snippet but I don't understand why a variable declared with let (which in my probably-incorrect-understanding has only block scope in ES6) will survive after the block has been executed:

 class PrivateTest { constructor(aNumber) { let _aNumber = aNumber; //Privileged setter/getter with access to private _number: this.aNumber = function(value) { if (value !== undefined && (typeof value === typeof _aNumber)) { _aNumber = value; } else { return _aNumber; } } } } const privateTest = new PrivateTest(99); console.log(privateTest.aNumber()); privateTest.aNumber(86); console.log(privateTest.aNumber()); console.log(privateTest._aNumber); //Undefined. // Just to try inheritance: class PrivateTest2 extends PrivateTest { } const privateTest2 = new PrivateTest2(13); console.log(privateTest2.aNumber()); 

The output is this:

99
86
undefined
13

From the code above, it seems that this private field can even be inherited.

So the questions are:

• Am I doing right?
• What's the life cycle of _number supposed to be?

Answer 1

Your _aNumber (declared with let _aNumber = aNumber ) doesn't exist outside of the class scope. You would get undefined if you tried to do console.log(_aNumber) .

But JavaScript has something called closures that "freeze" variables inside of functions. This means that when you call the aNumber method of your class, the let variables still exist within that function.

Also, because JavaScript functions are first-class, assigning this.aNumber to a value is exactly equivalent to assigning this.aNumber to a function that returns a value, and then calling that function.

Eg,

let a = 'foo';
let b = function() {
  return 'foo';
};

b();

console.log(a); // foo
console.log(b); // foo

It's tough to say if you are "doing it right", as I'm not exactly sure what you are going for. But learning more about closures and first-class functions might help you have a better grasp on the lifecycle of variables and the nature of variable assignments.