如何使用 Traceur 在 ES6 类中实现私有方法

在当前的 ECMAScript 6 规范中没有private、public或protected关键字。

所以 Traceur 不支持 private 和 public 6to5（目前称为"Babel"）出于实验目的实现了这个提议（另请参阅此讨论）。但这毕竟只是提议。

因此，现在您可以通过WeakMap模拟私有属性（请参阅此处）。另一种选择是Symbol - 但它不提供实际的隐私，因为可以通过Object.getOwnPropertySymbols轻松访问该物业。

恕我直言，目前最好的解决方案 - 只需使用伪隐私。如果您经常将apply或call与方法一起使用，则此方法非常特定于对象。因此，值得仅在类中仅使用下划线前缀声明它：

class Animal {
    _sayHi() {
        // do stuff
    }
}

您始终可以使用普通函数：

function myPrivateFunction() {
  console.log("My property: " + this.prop);
}
class MyClass() {
  constructor() {
    this.prop = "myProp";
    myPrivateFunction.bind(this)();
  }
}
new MyClass(); // 'My property: myProp'

尽管目前无法将方法或属性声明为私有，但 ES6 模块不在全局命名空间中。因此，您在模块中声明但未导出的任何内容都不适用于程序的任何其他部分，但在运行时仍可用于模块。因此，您有私有属性和方法:)

这是一个例子（在test.js文件中）

function tryMe1(a) {
  console.log(a + 2);
}
var tryMe2 = 1234;
class myModule {
  tryMe3(a) {
    console.log(a + 100);
  }
  getTryMe1(a) {
    tryMe1(a);
  }
  getTryMe2() {
    return tryMe2;
  }
}
// Exports just myModule class. Not anything outside of it.
export default myModule; 

在另一个文件中

import MyModule from './test';
let bar = new MyModule();
tryMe1(1); // ReferenceError: tryMe1 is not defined
tryMe2; // ReferenceError: tryMe2 is not defined
bar.tryMe1(1); // TypeError: bar.tryMe1 is not a function
bar.tryMe2; // undefined
bar.tryMe3(1); // 101
bar.getTryMe1(1); // 3
bar.getTryMe2(); // 1234

您可以使用符号

var say = Symbol()
function Cat(){
  this[say]() // call private methos
}
Cat.prototype[say] = function(){ alert('im a private') }

附言亚历克斯是不正确的。 他得到保护而不是私人，因为继承是名称冲突

实际上您可以使用var say = String(Math.random())代替符号

在 ES6 中：

var say = Symbol()
class Cat {
  constructor(){
    this[say]() // call private
  }
  [say](){
    alert('im private')
  }
}

我希望这会有所帮助。 :)

I. 声明 vars，IIFE（立即调用的函数表达式）中的函数，这些只能在匿名函数中使用。（当您需要更改 ES6 的代码时，最好使用"let， const"关键字而不使用"var"。

let Name = (function() {
  const _privateHello = function() {
  }
  class Name {
    constructor() {
    }
    publicMethod() {
      _privateHello()
    }
  }
  return Name;
})();

二、弱图对象可以解决内存泄漏问题。

弱图中存储的变量将在实例移除时被移除。查看这篇文章。（管理 ES6 类的私有数据）

let Name = (function() {
  const _privateName = new WeakMap();
})();

三、让我们把所有的东西放在一起。

let Name = (function() {
  const _privateName = new WeakMap();
  const _privateHello = function(fullName) {
    console.log("Hello, " + fullName);
  }
  class Name {
    constructor(firstName, lastName) {
      _privateName.set(this, {firstName: firstName, lastName: lastName});
    }
    static printName(name) {
      let privateName = _privateName.get(name);
      let _fullname = privateName.firstName + " " + privateName.lastName;
      _privateHello(_fullname);
    }
    printName() {
      let privateName = _privateName.get(this);
      let _fullname = privateName.firstName + " " + privateName.lastName;
      _privateHello(_fullname);
    }
  }
  return Name;
})();
var aMan = new Name("JH", "Son");
aMan.printName(); // "Hello, JH Son"
Name.printName(aMan); // "Hello, JH Son"

您是否考虑过使用工厂函数？它们通常是Javascript中类或构造函数的更好替代品。以下是其工作原理的示例：

function car () {
    var privateVariable = 4
    function privateFunction () {}
    return {
        color: 'red',
        drive: function (miles) {},
        stop: function() {}
        ....
    }
}

由于闭包，您可以访问返回对象中的所有私有函数和变量，但您无法从外部访问它们。

正如alexpods所说，在ES6中没有专门的方法来做到这一点。但是，对于那些感兴趣的人，还有一个关于绑定运算符的建议，它可以启用这种语法：

function privateMethod() {
  return `Hello ${this.name}`;
}
export class Animal {
  constructor(name) {
    this.name = name;
  }
  publicMethod() {
    this::privateMethod();
  }
}

再一次，这只是一个建议。您的里程可能会有所不同。

出了一个我认为更好的解决方案，允许：

• 不需要"this._"，那个/自我，弱图，符号等。 清晰明了的"类"代码

私有

• 变量和方法实际上是私有的，并且具有正确的"this"绑定

• 完全不使用"this"，这意味着清晰的代码更不容易出错

• 公共接口是明确的，并且作为私有方法的代理与实现分开

• 易于合成

有了这个，您可以做到：

function Counter() {
  // public interface
  const proxy = {
    advance,  // advance counter and get new value
    reset,    // reset value
    value     // get value
  }
	
  // private variables and methods
  let count=0;
    
  function advance() {
    return ++count;
  }
    	
  function reset(newCount) {
    count=(newCount || 0);
  }
    	
  function value() {
    return count;
  }
    
  return proxy;
}
    	
let counter=Counter.New();
console.log(counter instanceof Counter); // true
counter.reset(100);
console.log('Counter next = '+counter.advance()); // 101
console.log(Object.getOwnPropertyNames(counter)); // ["advance", "reset", "value"]

<script src="https://cdn.rawgit.com/kofifus/New/7987670c/new.js"></script>

有关代码和更详细的示例（包括构造函数和组合），请参阅新建

正如马塞洛·拉扎罗尼（Marcelo Lazaroni）已经说过的那样，

尽管目前无法将方法或属性声明为私有，但 ES6 模块不在全局命名空间中。因此，您在模块中声明但未导出的任何内容都不适用于程序的任何其他部分，但在运行时仍可用于模块。

但是他的例子没有说明私有方法如何访问类实例的成员。 Max 向我们展示了一些很好的例子，说明如何通过绑定或在构造函数中使用 lambda 方法的替代方法访问实例成员，但我想添加一种更简单的方法：将实例作为参数传递给私有方法。这样做会导致Max的MyClass看起来像这样：

function myPrivateFunction(myClass) {
  console.log("My property: " + myClass.prop);
}
class MyClass() {
  constructor() {
    this.prop = "myProp";
  }
  testMethod() {
    myPrivateFunction(this);
  }
}
module.exports = MyClass;

你以哪种方式做它实际上归结为个人喜好。