大多数答案要么说不可能，要么要求你使用WeakMap或Symbol，这是ES6的特性，可能需要腻子。然而，还有另一种方法!看看这个:

// 1. Create closure var SomeClass = function() { // 2. Create `key` inside a closure var key = {}; // Function to create private storage var private = function() { var obj = {}; // return Function to access private storage using `key` return function(testkey) { if(key === testkey) return obj; // If `key` is wrong, then storage cannot be accessed console.error('Cannot access private properties'); return undefined; }; }; var SomeClass = function() { // 3. Create private storage this._ = private(); // 4. Access private storage using the `key` this._(key).priv_prop = 200; }; SomeClass.prototype.test = function() { console.log(this._(key).priv_prop); // Using property from prototype }; return SomeClass; }(); // Can access private property from within prototype var instance = new SomeClass(); instance.test(); // `200` logged // Cannot access private property from outside of the closure var wrong_key = {}; instance._(wrong_key); // undefined; error logged

我称这个方法为accessor pattern。基本思想是我们有一个闭包，闭包中有一个键，我们创建一个私有对象(在构造函数中)，只有当你拥有键时才能访问它。

如果你感兴趣，你可以在我的文章中阅读更多有关这方面的内容。使用此方法，可以为每个对象创建不能在闭包外部访问的属性。因此，你可以在构造函数或原型中使用它们，但不能在其他任何地方使用。我还没有在任何地方见过这种方法，但我认为它真的很强大。

就我个人而言，我喜欢绑定操作符::的建议，然后将其与@d13提到的解决方案结合起来，但现在坚持使用@d13的答案，在这里您为类使用export关键字，并将私有函数放在模块中。

还有一个棘手的解决方案，这里没有提到，下面是更实用的方法，将允许它在类中拥有所有的私有道具/方法。

Private.js

export const get = state => key => state[key];
export const set = state => (key,value) => { state[key] = value; }

. js

import { get, set } from './utils/Private'
export default class Test {
  constructor(initialState = {}) {
    const _set = this.set = set(initialState);
    const _get = this.get = get(initialState);

    this.set('privateMethod', () => _get('propValue'));
  }

  showProp() {
    return this.get('privateMethod')();
  }
}

let one = new Test({ propValue: 5});
let two = new Test({ propValue: 8});
two.showProp(); // 8
one.showProp(); // 5

请对此提出意见。

使用ES6模块(最初由@d13提出)对我来说效果很好。它不能完美地模拟私有属性，但至少您可以确信，应该是私有的属性不会泄漏到类之外。这里有一个例子:

something.js

let _message = null;
const _greet = name => {
  console.log('Hello ' + name);
};

export default class Something {
  constructor(message) {
    _message = message;
  }

  say() {
    console.log(_message);
    _greet('Bob');
  }
};

然后消费代码可以是这样的:

import Something from './something.js';

const something = new Something('Sunny day!');
something.say();
something._message; // undefined
something._greet(); // exception

更新(重要):

正如@DanyalAytekin在评论中概述的那样，这些私有属性是静态的，因此在全球范围内。它们在处理单例对象时工作得很好，但在处理瞬态对象时必须小心。扩展上面的例子:

import Something from './something.js';
import Something2 from './something.js';

const a = new Something('a');
a.say(); // a

const b = new Something('b');
b.say(); // b

const c = new Something2('c');
c.say(); // c

a.say(); // c
b.say(); // c
c.say(); // c

不同的“私人”方式

Instead of fighting against the fact that private visibility is currently unavailable in ES6, I decided to take a more practical approach that does just fine if your IDE supports JSDoc (e.g., Webstorm). The idea is to use the @private tag. As far as development goes, the IDE will prevent you from accessing any private member from outside its class. Works pretty well for me and it's been really useful for hiding internal methods so the auto-complete feature shows me just what the class really meant to expose. Here's an example:

甚至Typescript也做不到。从他们的文档来看:

当成员被标记为private时，就不能从其包含类的外部访问它。例如: 动物类{ 私有名称:字符串; 构造函数(名称:字符串){this.name =名称;｝ ｝ 新的动物(猫). name;//错误:'name'是private;

但在他们的操场上，这说明:

var Animal = (function () {
    function Animal(theName) {
        this.name = theName;
    }
    return Animal;
}());
console.log(new Animal("Cat").name);

所以他们的“私人”关键字是无效的。

正如我们所知，ES6类不支持私有属性。

下面是我使用的方法(可能会有帮助)。基本上，我是在工厂内部包装一个类。

function Animal(name) {
    const privateData = 'NO experiments on animals have been done!';

    class Animal {
        constructor(_name) {
            this.name = _name;
        }
        getName() {
            return this.name
        }
        getDisclamer() {
            return `${privateData} Including ${this.name}`
        }
    }
    return new Animal(name)
}

我是一个初学者，所以很高兴听到这是一个坏的方法。