Ist es möglich, private Eigenschaften in ES6-Klassen zu erstellen?

Hier ist ein Beispiel. Wie kann ich den Zugriff auf verhindern instance.property?

class Something {
  constructor(){
    this.property = "test";
  }
}

var instance = new Something();
console.log(instance.property); //=> "test"

Private Felder (und Methoden) werden im ECMA-Standard implementiert . Sie können sie heute mit den Voreinstellungen für Babel 7 und Stufe 3 verwenden.

class Something {
  #property;

  constructor(){
    this.#property = "test";
  }

  #privateMethod() {
    return 'hello world';
  }

  getPrivateMessage() {
      return this.#privateMethod();
  }
}

const instance = new Something();
console.log(instance.property); //=> undefined
console.log(instance.privateMethod); //=> undefined
console.log(instance.getPrivateMessage()); //=> hello world

Kurze Antwort, nein, es gibt keine native Unterstützung für private Eigenschaften mit ES6-Klassen.

Sie können dieses Verhalten jedoch nachahmen, indem Sie die neuen Eigenschaften nicht an das Objekt anhängen, sondern in einem Klassenkonstruktor belassen und Getter und Setter verwenden, um die verborgenen Eigenschaften zu erreichen. Beachten Sie, dass die Getter und Setter für jede neue Instanz der Klasse neu definiert werden.

ES6

class Person {
    constructor(name) {
        var _name = name
        this.setName = function(name) { _name = name; }
        this.getName = function() { return _name; }
    }
}

ES5

function Person(name) {
    var _name = name
    this.setName = function(name) { _name = name; }
    this.getName = function() { return _name; }
}

So erweitern Sie die Antwort von @ loganfsmyth:

Die einzigen wirklich privaten Daten in JavaScript sind Variablen mit Gültigkeitsbereich. Sie können nicht über private Eigenschaften im Sinne von Eigenschaften verfügen, auf die intern wie auf öffentliche Eigenschaften zugegriffen wird. Sie können jedoch Gültigkeitsbereichsvariablen zum Speichern privater Daten verwenden.

Gültigkeitsbereichsvariablen

Der Ansatz hier besteht darin, den Umfang der Konstruktorfunktion, die privat ist, zum Speichern privater Daten zu verwenden. Damit Methoden auf diese privaten Daten zugreifen können, müssen sie auch im Konstruktor erstellt werden. Dies bedeutet, dass Sie sie mit jeder Instanz neu erstellen. Dies ist eine Leistungs- und Gedächtnisstrafe, aber einige glauben, dass die Strafe akzeptabel ist. Die Strafe kann für Methoden vermieden werden, die keinen Zugriff auf private Daten benötigen, indem diese wie gewohnt zum Prototyp hinzugefügt werden.

Beispiel:

function Person(name) {
  let age = 20; // this is private
  this.name = name; // this is public

  this.greet = function () {
    // here we can access both name and age
    console.log(`name: ${this.name}, age: ${age}`);
  };
}

let joe = new Person('Joe');
joe.greet();

// here we can access name but not age

Scoped WeakMap

Eine WeakMap kann verwendet werden, um die Leistung und den Speicherverlust des vorherigen Ansatzes zu vermeiden. WeakMaps ordnen Daten Objekten (hier Instanzen) so zu, dass nur mit dieser WeakMap auf sie zugegriffen werden kann. Daher verwenden wir die Methode mit Gültigkeitsbereichsvariablen, um eine private WeakMap zu erstellen, und verwenden diese WeakMap dann, um private Daten abzurufen, die mit verknüpft sindthis . Dies ist schneller als die Methode mit Gültigkeitsbereichsvariablen, da alle Ihre Instanzen eine einzige WeakMap gemeinsam nutzen können. Sie müssen also keine Methoden neu erstellen, um sie auf ihre eigenen WeakMaps zugreifen zu lassen.

Beispiel:

let Person = (function () {
  let privateProps = new WeakMap();

  class Person {
    constructor(name) {
      this.name = name; // this is public
      privateProps.set(this, {age: 20}); // this is private
    }

    greet() {
      // Here we can access both name and age
      console.log(`name: ${this.name}, age: ${privateProps.get(this).age}`);
    }
  }

  return Person;
})();

let joe = new Person('Joe');
joe.greet();

// here we can access joe's name but not age

In diesem Beispiel wird ein Objekt verwendet, um eine WeakMap für mehrere private Eigenschaften zu verwenden. Sie können auch mehrere WeakMaps verwenden und sie wie verwenden age.set(this, 20)oder einen kleinen Wrapper schreiben und ihn auf andere Weise verwendenprivateProps.set(this, 'age', 0) .

Die Privatsphäre dieses Ansatzes könnte theoretisch durch Manipulationen an der Welt verletzt werden WeakMap Objekt . Das heißt, alle JavaScript kann durch verstümmelte Globals gebrochen werden. Unser Code basiert bereits auf der Annahme, dass dies nicht geschieht.

(Diese Methode könnte auch angewendet werden Map, WeakMapist jedoch besser, da dadurch MapSpeicherlecks entstehen, wenn Sie nicht sehr vorsichtig sind. Zu diesem Zweck unterscheiden sich die beiden nicht voneinander.)

Halbe Antwort: Symbole mit Gültigkeitsbereich

Ein Symbol ist eine Art primitiver Wert, der als Eigenschaftsname dienen kann. Mit der Methode der Gültigkeitsbereichsvariablen können Sie ein privates Symbol erstellen und dann private Daten unter speichernthis[mySymbol] .

Die Privatsphäre dieser Methode kann mit verletzt werden Object.getOwnPropertySymbols , ist aber etwas umständlich zu tun.

Beispiel:

let Person = (function () {
  let ageKey = Symbol();

  class Person {
    constructor(name) {
      this.name = name; // this is public
      this[ageKey] = 20; // this is intended to be private
    }

    greet() {
      // Here we can access both name and age
      console.log(`name: ${this.name}, age: ${this[ageKey]}`);
    }
  }

  return Person;
})();

let joe = new Person('Joe');
joe.greet();

// Here we can access joe's name and, with a little effort, age. ageKey is
// not in scope, but we can obtain it by listing all Symbol properties on
// joe with `Object.getOwnPropertySymbols(joe)`.

Halbe Antwort: Unterstriche

Verwenden Sie bei der alten Standardeinstellung einfach eine öffentliche Eigenschaft mit einem Unterstrichpräfix. Obwohl diese Konvention in keiner Weise ein Privateigentum ist, ist sie weit genug verbreitet, um zu kommunizieren, dass die Leser das Eigentum als privat behandeln sollten, was häufig die Arbeit erledigt. Als Gegenleistung für diesen Fehler erhalten wir einen Ansatz, der einfacher zu lesen, einfacher zu tippen und schneller ist.

Beispiel:

class Person {
  constructor(name) {
    this.name = name; // this is public
    this._age = 20; // this is intended to be private
  }

  greet() {
    // Here we can access both name and age
    console.log(`name: ${this.name}, age: ${this._age}`);
  }
}

let joe = new Person('Joe');
joe.greet();

// Here we can access both joe's name and age. But we know we aren't
// supposed to access his age, which just might stop us.

Fazit

Ab ES2017 gibt es noch keine perfekte Möglichkeit, private Immobilien zu erwerben. Verschiedene Ansätze haben Vor- und Nachteile. Gültigkeitsbereichsvariablen sind wirklich privat. WeakMaps mit Gültigkeitsbereich sind sehr privat und praktischer als Variablen mit Gültigkeitsbereich. Symbole mit Gültigkeitsbereich sind einigermaßen privat und recht praktisch. Unterstriche sind oft privat genug und sehr praktisch.

Update: Ein Vorschlag mit einer schöneren Syntax ist auf dem Weg. Beiträge sind willkommen.

Ja, es gibt - für den Zugriff auf Objekte mit Gültigkeitsbereich - ES6 führt Symbols ein .

Symbole sind einzigartig. Sie können nur von außen auf eines zugreifen (außer bei Privaten in Java / C #). Jeder, der Zugriff auf ein Symbol im Inneren hat, kann es jedoch für den Schlüsselzugriff verwenden:

var property = Symbol();
class Something {
    constructor(){
        this[property] = "test";
    }
}

var instance = new Something();

console.log(instance.property); //=> undefined, can only access with access to the Symbol

Die Antwort ist nein". Sie können jedoch einen privaten Zugriff auf Eigenschaften wie diese erstellen:

• Verwenden Sie Module. Alles in einem Modul ist privat, es sei denn, es wird mithilfe von veröffentlichtexport Schlüsselwort veröffentlicht.
• Verwenden Sie in Modulen den Funktionsabschluss: http://www.kirupa.com/html5/closures_in_javascript.htm

(Der Vorschlag, dass Symbole verwendet werden könnten, um den Datenschutz zu gewährleisten, war in einer früheren Version der ES6-Spezifikation wahr, ist jedoch nicht mehr der Fall: https://mail.mozilla.org/pipermail/es-discuss/2014-January/035604. HTML und https://stackoverflow.com/a/22280202/1282216 . Eine längere Diskussion über Symbole und Datenschutz finden Sie unter: https://curiosity-driven.org/private-properties-in-javascript )

Der einzige Weg, um echte Privatsphäre in JS zu erhalten, ist das Scoping. Es gibt also keine Möglichkeit, eine Eigenschaft, zu der ein Mitglied gehört this, nur innerhalb der Komponente zugänglich zu machen. Der beste Weg, um wirklich private Daten in ES6 zu speichern, ist eine WeakMap.

const privateProp1 = new WeakMap();
const privateProp2 = new WeakMap();

class SomeClass {
  constructor() {
    privateProp1.set(this, "I am Private1");
    privateProp2.set(this, "I am Private2");

    this.publicVar = "I am public";
    this.publicMethod = () => {
      console.log(privateProp1.get(this), privateProp2.get(this))
    };        
  }

  printPrivate() {
    console.log(privateProp1.get(this));
  }
}

Offensichtlich ist dies wahrscheinlich langsam und definitiv hässlich, aber es bietet Privatsphäre.

Denken Sie daran, dass auch dies nicht perfekt ist, weil Javascript so dynamisch ist. Jemand könnte es noch tun

var oldSet = WeakMap.prototype.set;
WeakMap.prototype.set = function(key, value){
    // Store 'this', 'key', and 'value'
    return oldSet.call(this, key, value);
};

Um Werte zu erfassen, während sie gespeichert werden, müssen Sie, wenn Sie besonders vorsichtig sein möchten , einen lokalen Verweis auf diesen erfassen .setund .getexplizit verwenden, anstatt sich auf den überschreibbaren Prototyp zu verlassen.

const {set: WMSet, get: WMGet} = WeakMap.prototype;

const privateProp1 = new WeakMap();
const privateProp2 = new WeakMap();

class SomeClass {
  constructor() {
    WMSet.call(privateProp1, this, "I am Private1");
    WMSet.call(privateProp2, this, "I am Private2");

    this.publicVar = "I am public";
    this.publicMethod = () => {
      console.log(WMGet.call(privateProp1, this), WMGet.call(privateProp2, this))
    };        
  }

  printPrivate() {
    console.log(WMGet.call(privateProp1, this));
  }
}

Als zukünftige Referenz für andere Betrachter höre ich jetzt, dass die Empfehlung lautet, WeakMaps zum Speichern privater Daten zu verwenden.

Hier ist ein klareres, funktionierendes Beispiel:

function storePrivateProperties(a, b, c, d) {
  let privateData = new WeakMap;
  // unique object as key, weak map can only accept object as key, when key is no longer referened, garbage collector claims the key-value 
  let keyA = {}, keyB = {}, keyC = {}, keyD = {};

  privateData.set(keyA, a);
  privateData.set(keyB, b);
  privateData.set(keyC, c);
  privateData.set(keyD, d);

  return {
    logPrivateKey(key) {
      switch(key) {
      case "a":
        console.log(privateData.get(keyA));
        break;
      case "b":
        console.log(privateData.get(keyB));
        break;
      case "c":
        console.log(privateData.get(keyC));
        break;
      case "d":
        console.log(privateData.set(keyD));
        break;
      default:
        console.log(`There is no value for ${key}`)
      }
    }
  }
}

Kommt drauf an wen du fragst :-)

Der Vorschlag für maximal minimale Klassen enthält keinen privateEigenschaftsmodifikator, der anscheinend in den aktuellen Entwurf aufgenommen wurde .

Es könnte jedoch sein Unterstützung für private Namen , die private Eigenschaften zulassen - und sie könnten wahrscheinlich auch in Klassendefinitionen verwendet werden.

Die Verwendung von ES6-Modulen (ursprünglich von @ d13 vorgeschlagen) funktioniert für mich gut. Es ahmt private Eigenschaften nicht perfekt nach, aber zumindest können Sie sicher sein, dass Eigenschaften, die privat sein sollten, nicht außerhalb Ihrer Klasse auslaufen. Hier ist ein Beispiel:

etwas.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');
  }
};

Dann kann der konsumierende Code folgendermaßen aussehen:

import Something from './something.js';

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

Update (wichtig):

Wie @DanyalAytekin in den Kommentaren dargelegt hat, sind diese privaten Eigenschaften statisch und daher global. Sie funktionieren gut, wenn Sie mit Singletons arbeiten, aber Sie müssen auf vorübergehende Objekte achten. Das obige Beispiel erweitern:

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

Vervollständigung von @ d13 und den Kommentaren von @ johnny-oshika und @DanyalAytekin:

Ich denke, in dem Beispiel von @ johnny-oshika könnten wir normale Funktionen anstelle von Pfeilfunktionen verwenden und diese dann .bindmit dem aktuellen Objekt plus einem _privatesObjekt als Curry-Parameter:

etwas.js

function _greet(_privates) {
  return 'Hello ' + _privates.message;
}

function _updateMessage(_privates, newMessage) {
  _privates.message = newMessage;
}

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

    this.say = _greet.bind(this, _privates);
    this.updateMessage = _updateMessage.bind(this, _privates);
  }
}

main.js

import Something from './something.js';

const something = new Something('Sunny day!');

const message1 = something.say();
something.updateMessage('Cloudy day!');
const message2 = something.say();

console.log(message1 === 'Hello Sunny day!');  // true
console.log(message2 === 'Hello Cloudy day!');  // true

// the followings are not public
console.log(something._greet === undefined);  // true
console.log(something._privates === undefined);  // true
console.log(something._updateMessage === undefined);  // true

// another instance which doesn't share the _privates
const something2 = new Something('another Sunny day!');

const message3 = something2.say();

console.log(message3 === 'Hello another Sunny day!'); // true

Vorteile, die mir einfallen:

• Wir können private Methoden haben ( _greetund uns _updateMessagewie private Methoden verhalten, solange wir nicht exportdie Referenzen haben)
• Obwohl sie nicht im Prototyp enthalten sind, sparen die oben genannten Methoden Speicher, da die Instanzen außerhalb der Klasse einmal erstellt werden (anstatt sie im Konstruktor zu definieren).
• Wir lecken keine Globals, da wir uns in einem Modul befinden
• Mit dem gebundenen _privatesObjekt können wir auch private Eigenschaften haben

Einige Nachteile, die mir einfallen:

• weniger intuitiv
• gemischte Verwendung von Klassensyntax und Mustern der alten Schule (Objektbindungen, Variablen mit Modul- / Funktionsbereich)
• harte Bindungen - Wir können die öffentlichen Methoden nicht neu binden (obwohl wir dies durch die Verwendung weicher Bindungen verbessern können ( https://github.com/getify/You-Dont-Know-JS/blob/master/this%20%26%) 20Objekt% 20prototypen / ch2.md # Erweichungsbindung ))

Ein laufendes Snippet finden Sie hier: http://www.webpackbin.com/NJgI5J8lZ

Ja - Sie können gekapselte Eigenschaften erstellen , dies wurde jedoch nicht mit Zugriffsmodifikatoren (öffentlich | privat) durchgeführt, zumindest nicht mit ES6.

Hier ist ein einfaches Beispiel, wie es mit ES6 gemacht werden kann:

1 Erstellen Sie eine Klasse mit class Wort

2 In seinem Konstruktor deklarieren Sie die Variable mit Blockbereich mit let OR const reservierten Wörtern -> da sie Blockbereich sind, kann von außen nicht auf sie zugegriffen werden (gekapselt)

3 Um eine gewisse Zugriffssteuerung (Setter | Getter) auf diese Variablen zu ermöglichen, können Sie die Instanzmethode in ihrem Konstruktor mithilfe der folgenden this.methodName=function(){}Syntax deklarieren

"use strict";
    class Something{
        constructor(){
            //private property
            let property="test";
            //private final (immutable) property
            const property2="test2";
            //public getter
            this.getProperty2=function(){
                return property2;
            }
            //public getter
            this.getProperty=function(){
                return property;
            }
            //public setter
            this.setProperty=function(prop){
                property=prop;
            }
        }
    }

Lassen Sie es uns jetzt überprüfen:

var s=new Something();
    console.log(typeof s.property);//undefined 
    s.setProperty("another");//set to encapsulated `property`
    console.log(s.getProperty());//get encapsulated `property` value
    console.log(s.getProperty2());//get encapsulated immutable `property2` value

Ein anderer Ansatz für "privat"

Anstatt gegen die Tatsache anzukämpfen, dass private Sichtbarkeit in ES6 derzeit nicht verfügbar ist, habe ich mich für einen praktischeren Ansatz entschieden, der gut funktioniert, wenn Ihre IDE JSDoc unterstützt (z. B. Webstorm). Die Idee ist, das @privateTag zu verwenden . In Bezug auf die Entwicklung verhindert die IDE, dass Sie von außerhalb ihrer Klasse auf private Mitglieder zugreifen können. Funktioniert ziemlich gut für mich und war sehr nützlich, um interne Methoden auszublenden. Die Funktion zur automatischen Vervollständigung zeigt mir, was die Klasse wirklich aussetzen wollte. Hier ist ein Beispiel:

Schwache Karte

• wird in IE11 unterstützt (Symbole nicht)
• hart-privat (Requisiten mit Symbolen sind aufgrund von weich-privat Object.getOwnPropertySymbols)
• kann sehr sauber aussehen (im Gegensatz zu Verschlüssen, die alle Requisiten und Methoden im Konstruktor erfordern)

Definieren Sie zunächst eine Funktion zum Umschließen von WeakMap:

function Private() {
  const map = new WeakMap();
  return obj => {
    let props = map.get(obj);
    if (!props) {
      props = {};
      map.set(obj, props);
    }
    return props;
  };
}

Erstellen Sie dann eine Referenz außerhalb Ihrer Klasse:

const p = new Private();

class Person {
  constructor(name, age) {
    this.name = name;
    p(this).age = age; // it's easy to set a private variable
  }

  getAge() {
    return p(this).age; // and get a private variable
  }
}

Hinweis: Die Klasse wird von IE11 nicht unterstützt, sieht im Beispiel jedoch sauberer aus.

Oh, so viele exotische Lösungen! Ich kümmere mich normalerweise nicht um die Privatsphäre, deshalb verwende ich "Pseudo-Privatsphäre", wie es hier gesagt wird . Aber wenn es mich interessiert (wenn es einige spezielle Anforderungen dafür gibt), verwende ich so etwas wie in diesem Beispiel:

class jobImpl{
  // public
  constructor(name){
    this.name = name;
  }
  // public
  do(time){
    console.log(`${this.name} started at ${time}`);
    this.prepare();
    this.execute();
  }
  //public
  stop(time){
    this.finish();
    console.log(`${this.name} finished at ${time}`);
  }
  // private
  prepare(){ console.log('prepare..'); }
  // private
  execute(){ console.log('execute..'); }
  // private
  finish(){ console.log('finish..'); }
}

function Job(name){
  var impl = new jobImpl(name);
  return {
    do: time => impl.do(time),
    stop: time => impl.stop(time)
  };
}

// Test:
// create class "Job"
var j = new Job("Digging a ditch");
// call public members..
j.do("08:00am");
j.stop("06:00pm");

// try to call private members or fields..
console.log(j.name); // undefined
j.execute(); // error

Eine weitere mögliche Implementierung der Funktion (Konstruktor) Job:

function Job(name){
  var impl = new jobImpl(name);
  this.do = time => impl.do(time),
  this.stop = time => impl.stop(time)
}

Persönlich gefällt mir der Vorschlag des Bindungsoperators :: und ich würde ihn dann mit der erwähnten Lösung @ d13 kombinieren, aber vorerst bei der Antwort von @ d13 bleiben, bei der Sie das exportSchlüsselwort für Ihre Klasse verwenden und die privaten Funktionen in das Modul einfügen .

Es gibt eine weitere schwierige Lösung, die hier nicht erwähnt wurde. Die folgenden sind funktionaler und ermöglichen es ihr, alle privaten Requisiten / Methoden innerhalb der Klasse zu haben.

Private.js

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

Test.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

Kommentare dazu wären willkommen.

Ich bin auf diesen Beitrag gestoßen, als ich nach der besten Vorgehensweise für "private Daten für Klassen" gesucht habe. Es wurde erwähnt, dass einige der Muster Leistungsprobleme aufweisen würden.

Ich habe einige jsperf-Tests zusammengestellt, die auf den 4 Hauptmustern aus dem Online-Buch "Exploring ES6" basieren:

http://exploringjs.com/es6/ch_classes.html#sec_private-data-for-classes

Die Tests finden Sie hier:

https://jsperf.com/private-data-for-classes

In Chrome 63.0.3239 / Mac OS X 10.11.6 waren die Muster mit der besten Leistung "Private Daten über Konstruktorumgebungen" und "Private Daten über eine Namenskonvention". Für mich hat Safari eine gute Leistung für WeakMap erbracht, Chrome jedoch nicht so gut.

Ich kenne die Auswirkungen auf den Speicher nicht, aber das Muster für "Konstruktorumgebungen", von dem einige gewarnt hatten, dass es sich um ein Leistungsproblem handelt, war sehr leistungsfähig.

Die 4 Grundmuster sind:

Private Daten über Konstruktorumgebungen

class Countdown {
    constructor(counter, action) {
        Object.assign(this, {
            dec() {
                if (counter < 1) return;
                counter--;
                if (counter === 0) {
                    action();
                }
            }
        });
    }
}
const c = new Countdown(2, () => {});
c.dec();
c.dec();

Private Daten über Konstruktorumgebungen 2

class Countdown {
    constructor(counter, action) {
        this.dec = function dec() {
            if (counter < 1) return;
            counter--;
            if (counter === 0) {
                action();
            }
        }
    }
}
const c = new Countdown(2, () => {});
c.dec();
c.dec();

Private Daten über eine Namenskonvention

class Countdown {
    constructor(counter, action) {
        this._counter = counter;
        this._action = action;
    }
    dec() {
        if (this._counter < 1) return;
        this._counter--;
        if (this._counter === 0) {
            this._action();
        }
    }
}
const c = new Countdown(2, () => {});
c.dec();
c.dec();

Private Daten über WeakMaps

const _counter = new WeakMap();
const _action = new WeakMap();
class Countdown {
    constructor(counter, action) {
        _counter.set(this, counter);
        _action.set(this, action);
    }
    dec() {
        let counter = _counter.get(this);
        if (counter < 1) return;
        counter--;
        _counter.set(this, counter);
        if (counter === 0) {
            _action.get(this)();
        }
    }
}
const c = new Countdown(2, () => {});
c.dec();
c.dec();

Private Daten über Symbole

const _counter = Symbol('counter');
const _action = Symbol('action');

class Countdown {
    constructor(counter, action) {
        this[_counter] = counter;
        this[_action] = action;
    }
    dec() {
        if (this[_counter] < 1) return;
        this[_counter]--;
        if (this[_counter] === 0) {
            this[_action]();
        }
    }
}
const c = new Countdown(2, () => {});
c.dec();
c.dec();

Ich glaube, es ist möglich, mit Verschlüssen in Konstruktoren das Beste aus beiden Welten herauszuholen. Es gibt zwei Variationen:

Alle Datenmitglieder sind privat

function myFunc() {
   console.log('Value of x: ' + this.x);
   this.myPrivateFunc();
}

function myPrivateFunc() {
   console.log('Enhanced value of x: ' + (this.x + 1));
}

class Test {
   constructor() {

      let internal = {
         x : 2,
      };
      
      internal.myPrivateFunc = myPrivateFunc.bind(internal);
      
      this.myFunc = myFunc.bind(internal);
   }
};

Einige Mitglieder sind privat

HINWEIS: Dies ist zugegebenermaßen hässlich. Wenn Sie eine bessere Lösung kennen, bearbeiten Sie diese Antwort.

function myFunc(priv, pub) {
   pub.y = 3; // The Test object now gets a member 'y' with value 3.
   console.log('Value of x: ' + priv.x);
   this.myPrivateFunc();
}

function myPrivateFunc() {
   pub.z = 5; // The Test object now gets a member 'z' with value 3.
   console.log('Enhanced value of x: ' + (priv.x + 1));
}

class Test {
   constructor() {
      
      let self = this;

      let internal = {
         x : 2,
      };
      
      internal.myPrivateFunc = myPrivateFunc.bind(null, internal, self);
      
      this.myFunc = myFunc.bind(null, internal, self);
   }
};

Tatsächlich ist es möglich, Symbole und Proxies zu verwenden. Sie verwenden die Symbole im Klassenbereich und legen zwei Traps in einem Proxy fest: einen für den Klassenprototyp, damit die Symbole Reflect.ownKeys (Instanz) oder Object.getOwnPropertySymbols Ihre Symbole nicht verraten, der andere für den Konstruktor selbst Wenn new ClassName(attrs)also aufgerufen wird, wird die zurückgegebene Instanz abgefangen und die eigenen Eigenschaftssymbole blockiert. Hier ist der Code:

const Human = (function() {
  const pet = Symbol();
  const greet = Symbol();

  const Human = privatizeSymbolsInFn(function(name) {
    this.name = name; // public
    this[pet] = 'dog'; // private 
  });

  Human.prototype = privatizeSymbolsInObj({
    [greet]() { // private
      return 'Hi there!';
    },
    revealSecrets() {
      console.log(this[greet]() + ` The pet is a ${this[pet]}`);
    }
  });

  return Human;
})();

const bob = new Human('Bob');

console.assert(bob instanceof Human);
console.assert(Reflect.ownKeys(bob).length === 1) // only ['name']
console.assert(Reflect.ownKeys(Human.prototype).length === 1 ) // only ['revealSecrets']


// Setting up the traps inside proxies:
function privatizeSymbolsInObj(target) { 
  return new Proxy(target, { ownKeys: Object.getOwnPropertyNames });
}

function privatizeSymbolsInFn(Class) {
  function construct(TargetClass, argsList) {
    const instance = new TargetClass(...argsList);
    return privatizeSymbolsInObj(instance);
  }
  return new Proxy(Class, { construct });
}

Reflect.ownKeys()funktioniert so: Object.getOwnPropertyNames(myObj).concat(Object.getOwnPropertySymbols(myObj))Deshalb brauchen wir eine Falle für diese Objekte.

Selbst Typescript kann das nicht. Aus ihrer Dokumentation :

Wenn ein Mitglied als privat markiert ist, kann von außerhalb seiner enthaltenden Klasse nicht auf es zugegriffen werden. Zum Beispiel:

class Animal {
    private name: string;
    constructor(theName: string) { this.name = theName; }
}

new Animal("Cat").name; // Error: 'name' is private;

Aber auf ihrem Spielplatz transpiliert gibt dies:

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

Ihr "privates" Schlüsselwort ist also unwirksam.

Ich komme sehr spät zu dieser Party, aber ich habe die OP-Frage bei einer Suche getroffen, also ... Ja, Sie können private Eigenschaften haben, indem Sie die Klassendeklaration in einen Abschluss einschließen

Es gibt ein Beispiel dafür, wie ich private Methoden in diesem Codepen habe . Im folgenden Snippet verfügt die Subscribeable-Klasse über zwei 'private' Funktionen processund processCallbacks. Alle Eigenschaften können auf diese Weise hinzugefügt werden und werden durch die Verwendung des Verschlusses privat gehalten. IMO-Datenschutz ist eine seltene Notwendigkeit, wenn Bedenken gut getrennt sind und Javascript nicht durch Hinzufügen weiterer Syntax aufgebläht werden muss, wenn ein Abschluss die Aufgabe ordnungsgemäß erledigt.

const Subscribable = (function(){

  const process = (self, eventName, args) => {
    self.processing.set(eventName, setTimeout(() => processCallbacks(self, eventName, args)))};

  const processCallbacks = (self, eventName, args) => {
    if (self.callingBack.get(eventName).length > 0){
      const [nextCallback, ...callingBack] = self.callingBack.get(eventName);
      self.callingBack.set(eventName, callingBack);
      process(self, eventName, args);
      nextCallback(...args)}
    else {
      delete self.processing.delete(eventName)}};

  return class {
    constructor(){
      this.callingBack = new Map();
      this.processing = new Map();
      this.toCallbacks = new Map()}

    subscribe(eventName, callback){
      const callbacks = this.unsubscribe(eventName, callback);
      this.toCallbacks.set(eventName,  [...callbacks, callback]);
      return () => this.unsubscribe(eventName, callback)}  // callable to unsubscribe for convenience

    unsubscribe(eventName, callback){
      let callbacks = this.toCallbacks.get(eventName) || [];
      callbacks = callbacks.filter(subscribedCallback => subscribedCallback !== callback);
      if (callbacks.length > 0) {
        this.toCallbacks.set(eventName, callbacks)}
      else {
        this.toCallbacks.delete(eventName)}
      return callbacks}

    emit(eventName, ...args){
      this.callingBack.set(eventName, this.toCallbacks.get(eventName) || []);
      if (!this.processing.has(eventName)){
        process(this, eventName, args)}}}})();

Ich mag diesen Ansatz, weil er Bedenken gut voneinander trennt und die Dinge wirklich privat hält. Der einzige Nachteil ist die Notwendigkeit, "Selbst" (oder etwas Ähnliches) zu verwenden, um im privaten Inhalt auf "Dies" zu verweisen.

Ich denke, Benjamins Antwort ist wahrscheinlich die beste für die meisten Fälle, bis die Sprache nativ explizit private Variablen unterstützt.

Wenn Sie jedoch aus irgendeinem Grund den Zugriff mit verhindern müssen Object.getOwnPropertySymbols(), ist eine Methode, die ich in Betracht gezogen habe, das Anhängen einer eindeutigen, nicht konfigurierbaren, nicht aufzählbaren, nicht beschreibbaren Eigenschaft, die als Eigenschaftskennung für jedes Objekt bei der Erstellung verwendet werden kann (z. B. eine Symboleindeutige Eigenschaft, wenn Sie noch keine andere eindeutige Eigenschaft wie eine haben id). Behalten Sie dann einfach eine Karte der "privaten" Variablen jedes Objekts unter Verwendung dieser Kennung.

const privateVars = {};

class Something {
    constructor(){
        Object.defineProperty(this, '_sym', {
            configurable: false,
            enumerable: false,
            writable: false,
            value: Symbol()
        });

        var myPrivateVars = {
            privateProperty: "I'm hidden"
        };

        privateVars[this._sym] = myPrivateVars;

        this.property = "I'm public";
    }

    getPrivateProperty() {
        return privateVars[this._sym].privateProperty;
    }

    // A clean up method of some kind is necessary since the
    // variables won't be cleaned up from memory automatically
    // when the object is garbage collected
    destroy() {
        delete privateVars[this._sym];
    }
}

var instance = new Something();
console.log(instance.property); //=> "I'm public"
console.log(instance.privateProperty); //=> undefined
console.log(instance.getPrivateProperty()); //=> "I'm hidden"

Der potenzielle Vorteil dieses Ansatzes gegenüber der Verwendung von a WeakMapist eine schnellere Zugriffszeit, wenn die Leistung zu einem Problem wird.

Ja, das kann man und das auch ganz einfach. Dazu werden Ihre privaten Variablen und Funktionen verfügbar gemacht, indem das Prototyp-Objektdiagramm im Konstruktor zurückgegeben wird. Das ist nichts Neues, aber nehmen Sie sich ein bisschen Zeit, um die Eleganz zu verstehen. Auf diese Weise werden keine globalen Gültigkeitsbereiche oder Schwachkarten verwendet. Es ist eine in die Sprache eingebaute Form der Reflexion. Abhängig davon, wie Sie dies nutzen. Man kann entweder eine Ausnahme erzwingen, die den Aufrufstapel unterbricht, oder die Ausnahme als begraben undefined. Dies wird unten demonstriert und kann hier mehr über diese Funktionen gelesen werden

class Clazz {
  constructor() {
    var _level = 1

    function _private(x) {
      return _level * x;
    }
    return {
      level: _level,
      public: this.private,
      public2: function(x) {
        return _private(x);
      },
      public3: function(x) {
        return _private(x) * this.public(x);
      },
    };
  }

  private(x) {
    return x * x;
  }
}

var clazz = new Clazz();

console.log(clazz._level); //undefined
console.log(clazz._private); // undefined
console.log(clazz.level); // 1
console.log(clazz.public(1)); //1
console.log(clazz.public2(2)); //2
console.log(clazz.public3(3)); //27
console.log(clazz.private(0)); //error

class Something {
  constructor(){
    var _property = "test";
    Object.defineProperty(this, "property", {
        get: function(){ return _property}
    });
  }
}

var instance = new Something();
console.log(instance.property); //=> "test"
instance.property = "can read from outside, but can't write";
console.log(instance.property); //=> "test"

Ein anderer Weg ähnlich den letzten beiden geposteten

class Example {
  constructor(foo) {

    // privates
    const self = this;
    this.foo = foo;

    // public interface
    return self.public;
  }

  public = {
    // empty data
    nodata: { data: [] },
    // noop
    noop: () => {},
  }

  // everything else private
  bar = 10
}

const test = new Example('FOO');
console.log(test.foo); // undefined
console.log(test.noop); // { data: [] }
console.log(test.bar); // undefined

Die meisten Antworten sagen entweder, dass dies unmöglich ist, oder Sie müssen eine WeakMap oder ein Symbol verwenden. Hierbei handelt es sich um ES6-Funktionen, für die wahrscheinlich Polyfüllungen erforderlich wären. Es gibt jedoch einen anderen Weg! Schauen Sie sich das an:

// 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

Ich nenne diese Methode Accessor-Muster . Die wesentliche Idee ist, dass wir einen Abschluss haben , einen Schlüssel innerhalb des Abschlusses, und wir erstellen ein privates Objekt (im Konstruktor), auf das nur zugegriffen werden kann, wenn Sie den Schlüssel haben .

Wenn Sie interessiert sind, können Sie mehr darüber in meinem Artikel lesen . Mit dieser Methode können Sie Objekteigenschaften erstellen, auf die außerhalb des Abschlusses nicht zugegriffen werden kann. Daher können Sie sie im Konstruktor oder Prototyp verwenden, aber nirgendwo anders. Ich habe diese Methode nirgendwo gesehen, aber ich denke, sie ist wirklich mächtig.

In dieser Antwort finden Sie eine saubere und einfache "Klassen" -Lösung mit einer privaten und öffentlichen Schnittstelle und Unterstützung für die Komposition

Ich habe eine sehr einfache Lösung gefunden, benutze sie einfach Object.freeze(). Das Problem ist natürlich, dass Sie dem Objekt später nichts mehr hinzufügen können.

class Cat {
    constructor(name ,age) {
        this.name = name
        this.age = age
        Object.freeze(this)
    }
}

let cat = new Cat('Garfield', 5)
cat.age = 6 // doesn't work, even throws an error in strict mode

Ich benutze dieses Muster und es hat immer für mich funktioniert

class Test {
    constructor(data) {
        class Public {
            constructor(prv) {

                // public function (must be in constructor on order to access "prv" variable)
                connectToDb(ip) {
                    prv._db(ip, prv._err);
                } 
            }

            // public function w/o access to "prv" variable
            log() {
                console.log("I'm logging");
            }
        }

        // private variables
        this._data = data;
        this._err = function(ip) {
            console.log("could not connect to "+ip);
        }
    }

    // private function
    _db(ip, err) {
        if(!!ip) {
		    console.log("connected to "+ip+", sending data '"+this.data+"'");
			return true;
		}
        else err(ip);
    }
}



var test = new Test(10),
		ip = "185.167.210.49";
test.connectToDb(ip); // true
test.log(); // I'm logging
test._err(ip); // undefined
test._db(ip, function() { console.log("You have got hacked!"); }); // undefined

Eigentlich ist es ist möglich.
1. Erstellen Sie zunächst die Klasse und geben Sie im Konstruktor die aufgerufene _publicFunktion zurück.
2. Übergeben Sie in der aufgerufenen _publicFunktion die thisReferenz (um den Zugriff auf alle privaten Methoden und Requisiten zu erhalten) und alle Argumente von constructor (die übergeben werden new Names()).
3. Im _publicFunktionsumfang befindet sich auch die NamesKlasse mit dem Zugriff auf this(_this ) Bezug der privaten NamesKlasse

class Names {
  constructor() {
    this.privateProperty = 'John';
    return _public(this, arguments);
  }
  privateMethod() { }
}

const names = new Names(1,2,3);
console.log(names.somePublicMethod); //[Function]
console.log(names.publicProperty); //'Jasmine'
console.log(names.privateMethod); //undefined
console.log(names.privateProperty); //undefind

function _public(_this, _arguments) {
  class Names {
    constructor() {
      this.publicProperty = 'Jasmine';
      _this.privateProperty; //"John";
      _this.privateMethod; //[Function]
    }

    somePublicMethod() {
      _this.privateProperty; //"John";
      _this.privateMethod; //[Function]
    }

  }
  return new Names(..._arguments);
}

Sie können dies unter https://www.npmjs.com/package/private-members versuchen

Dieses Paket speichert die Mitglieder nach Instanz.

const pvt = require('private-members');
const _ = pvt();

let Exemplo = (function () {    
    function Exemplo() {
        _(this).msg = "Minha Mensagem";
    }

    _().mensagem = function() {
        return _(this).msg;
    }

    Exemplo.prototype.showMsg = function () {
        let msg = _(this).mensagem();
        console.log(msg);
    };

    return Exemplo;
})();

module.exports = Exemplo;