为什么ES6类中无法实现本地功能？

Question

What was the idea about leaving out something like this in ES6:

class Foo {
   myMethod(){
      // do something with 'bar'
   }
   constructor(){
       this.myMethod();
   }
   otherMethod(){
       this.myMethod();
   }
}

I know that it's possible to define the function in the constructor or outside the class and then use it with myMethod() . However coming from other languages I was surprised to see classes, but no local (or private) methods. I couldn't find anything on the internet about the reason why this was left out.

Answer 1

EDIT: I just realized your post was about functions, not variables. Since functions are a type of variable, all these solutions work for function even though I didn't explicitly make the examples functions

---

I have found several solutions, each of which have their pros and cons:

Method 0: Factories

 var Foo = (function() { let priv = { "eh": 0 }; return class Foo { constructor(num) { priv.eh = num; } test() { return priv.eh; } }; })(); var a = new Foo(383); console.log(a.test()); 

Taking advantage of JS scoping to hide a variable, priv behind a function

Pros:

• Perfectly secure. It's basically impossible to access priv unless you return a pointer of it
• Takes advantage of a well-used javascript paradigm. Factories have been used by programmers for year
  • Private variables do not clash with parent class(es)

Cons:

• It's not very clear or readable

---

Method 1: Define everything from the constructor

 class Foo2 { constructor(num) { Object.assign(this, { test() { return num; } }); } } var b = new Foo2(262); console.log(b.test()); 

Just what it says on the box.

Pros:

• Perfectly secure again. There's no way to access local variable from outside the scope
• Little more readable than Method 1. It's somewhat obvious what everything does
• Private variables do not clash with parent class(es)

Cons:

• Clogs the constructor function
• Still not very readable

---

Method 2: Naming Convention

 class Foo3 { constructor(num) { this._eh = num; } test() { return this._eh; } } var c = new Foo3(101); console.log(c.test()); 

No need to hide behind strange security procedures. Just specify in the name which properties are "private"

Pros:

• Very easy to read, can take advantage of class structure

Cons:

• Offers absolutely no protection, only a recommendation.
• Private variables clash with the private variables of parent classes

  ---

Method 3: Symbols

 const eh = Symbol("eh"); class Foo4 { constructor(num) { this[eh] = num; } test() { return this[eh]; } } var d = new Foo4(100); console.log(d.test()); 

I just wanted to include this one because I thought it was cool

Pros:

• Readable as naming convention. Private variables don't get strings, they get Symbols. Very easy to read

Cons:

• Pointless. In any situation where the parent scope is protected, you can just store private variables there
  • Not secure. Even if you solve the problem above, people can access all keys (including Symbols) with Reflect.ownKeys()

Hope this was helpful!