Est-il possible de créer des propriétés privées dans les classes ES6?

Voici un exemple. Comment puis-je empêcher l'accès à instance.property?

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

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

Les champs (et méthodes) privés sont en cours de mise en œuvre dans la norme ECMA . Vous pouvez commencer à les utiliser dès aujourd'hui avec les préréglages babel 7 et stage 3.

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

Réponse courte, non, il n'y a pas de support natif pour les propriétés privées avec les classes ES6.

Mais vous pouvez imiter ce comportement en n'attachant pas les nouvelles propriétés à l'objet, mais en les conservant dans un constructeur de classe, et en utilisant des getters et des setters pour atteindre les propriétés cachées. Notez que les getters et setters sont redéfinis sur chaque nouvelle instance de la classe.

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; }
}

Pour développer la réponse de @ loganfsmyth:

Les seules données vraiment privées en JavaScript sont toujours des variables de portée. Vous ne pouvez pas avoir de propriétés privées au sens de propriétés accessibles en interne de la même manière que les propriétés publiques, mais vous pouvez utiliser des variables de portée pour stocker des données privées.

Variables de portée

L'approche ici consiste à utiliser la portée de la fonction constructeur, qui est privée, pour stocker des données privées. Pour que les méthodes aient accès à ces données privées, elles doivent également être créées dans le constructeur, ce qui signifie que vous les recréez avec chaque instance. Il s'agit d'une pénalité liée aux performances et à la mémoire, mais certains pensent que la pénalité est acceptable. La pénalité peut être évitée pour les méthodes qui n'ont pas besoin d'accéder aux données privées en les ajoutant au prototype comme d'habitude.

Exemple:

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

Scope WeakMap

Un WeakMap peut être utilisé pour éviter les performances et la pénalité de mémoire de l'approche précédente. Les WeakMaps associent les données aux objets (ici, les instances) de manière à ce qu'elles ne soient accessibles qu'en utilisant ce WeakMap. Ainsi, nous utilisons la méthode des variables de portée pour créer un WeakMap privé, puis utilisons ce WeakMap pour récupérer les données privées associées à this. C'est plus rapide que la méthode des variables de portée car toutes vos instances peuvent partager une seule WeakMap, vous n'avez donc pas besoin de recréer des méthodes juste pour leur faire accéder à leurs propres WeakMaps.

Exemple:

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

Cet exemple utilise un objet pour utiliser un WeakMap pour plusieurs propriétés privées; vous pouvez également utiliser plusieurs WeakMaps et les utiliser comme age.set(this, 20), ou écrire un petit wrapper et l'utiliser d'une autre manière, comme privateProps.set(this, 'age', 0).

La confidentialité de cette approche pourrait théoriquement être violée en altérant l' WeakMapobjet global . Cela dit, tout JavaScript peut être brisé par des globaux mutilés. Notre code est déjà construit sur l'hypothèse que cela ne se produit pas.

(Cette méthode pourrait également être utilisée avec Map, mais elle WeakMapest meilleure car Mapelle créera des fuites de mémoire à moins que vous ne soyez très prudent, et à cette fin, les deux ne sont pas autrement différents.)

Demi-réponse: symboles de portée

Un symbole est un type de valeur primitive qui peut servir de nom de propriété. Vous pouvez utiliser la méthode des variables de portée pour créer un symbole privé, puis stocker des données privées sur this[mySymbol].

La confidentialité de cette méthode peut être violée à l'aide Object.getOwnPropertySymbols, mais est quelque peu difficile à faire.

Exemple:

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)`.

Demi-réponse: Souligne

L'ancien défaut, utilisez simplement une propriété publique avec un préfixe de soulignement. Bien qu'elle ne soit en aucun cas une propriété privée, cette convention est suffisamment répandue pour faire un bon travail en communiquant que les lecteurs doivent traiter la propriété comme privée, ce qui fait souvent le travail. En échange de ce laps de temps, nous obtenons une approche plus facile à lire, plus facile à taper et plus rapide.

Exemple:

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.

Conclusion

Depuis ES2017, il n'y a toujours pas de moyen idéal pour faire des propriétés privées. Diverses approches ont des avantages et des inconvénients. Les variables de portée sont vraiment privées; les WeakMaps de portée sont très privés et plus pratiques que les variables de portée; les symboles de portée sont raisonnablement privés et raisonnablement pratiques; les soulignés sont souvent assez privés et très pratiques.

Mise à jour: une proposition avec une syntaxe plus agréable est en cours. Les contributions sont les bienvenues.

Oui, il existe - pour un accès limitéSymbol aux objets - ES6 introduit l' art .

Les symboles sont uniques, vous ne pouvez pas y accéder de l'extérieur sauf avec la réflexion (comme les privés en Java / C #) mais toute personne ayant accès à un symbole à l'intérieur peut l'utiliser pour accéder aux clés:

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

La réponse est non". Mais vous pouvez créer un accès privé à des propriétés comme celle-ci:

• Utilisez des modules. Tout dans un module est privé, sauf s'il est rendu public à l'aide du exportmot clé.
• À l'intérieur des modules, utilisez la fermeture de fonction: http://www.kirupa.com/html5/closures_in_javascript.htm

(La suggestion que les symboles pourraient être utilisés pour garantir la confidentialité était vraie dans une version antérieure de la spécification ES6 mais n'est plus le cas: https://mail.mozilla.org/pipermail/es-discuss/2014-January/035604. html et https://stackoverflow.com/a/22280202/1282216 . Pour une discussion plus longue sur les symboles et la confidentialité, voir: https://curiosity-driven.org/private-properties-in-javascript )

La seule façon d'obtenir une véritable confidentialité dans JS est par l'étendue, il n'y a donc aucun moyen d'avoir une propriété qui en est membre thisqui ne sera accessible qu'à l'intérieur du composant. La meilleure façon de stocker des données véritablement privées dans ES6 est avec un 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));
  }
}

Évidemment, c'est probablement un processus lent et certainement moche, mais cela offre de l'intimité.

Gardez à l'esprit que CECI N'EST PAS parfait, car Javascript est tellement dynamique. Quelqu'un pourrait encore faire

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

pour capturer les valeurs au fur et à mesure qu'elles sont stockées, donc si vous voulez être très prudent, vous devez capturer une référence locale .setet l' .getutiliser explicitement au lieu de vous fier au prototype remplaçable.

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));
  }
}

Pour référence future d'autres sur les spectateurs, j'entends maintenant que la recommandation est d'utiliser WeakMaps pour conserver des données privées.

Voici un exemple de travail plus clair:

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}`)
      }
    }
  }
}

Dépend de qui vous demandez :-)

Aucun privatemodificateur de propriété n'est inclus dans la proposition de classes minimalement maximales qui semble avoir fait partie du brouillon actuel .

Cependant, les noms privés peuvent être pris en charge , ce qui autorise les propriétés privées - et ils pourraient probablement être également utilisés dans les définitions de classe.

L'utilisation de modules ES6 (initialement proposée par @ d13) fonctionne bien pour moi. Il n'imite pas parfaitement les propriétés privées, mais au moins vous pouvez être sûr que les propriétés qui devraient être privées ne fuiront pas en dehors de votre classe. Voici un exemple:

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

Le code consommateur peut alors ressembler à ceci:

import Something from './something.js';

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

Mise à jour (importante):

Comme @DanyalAytekin l'a souligné dans les commentaires, ces propriétés privées sont statiques, donc de portée globale. Ils fonctionneront bien lorsque vous travaillez avec des singletons, mais il faut faire attention aux objets transitoires. Extension de l'exemple ci-dessus:

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

Compléter @ d13 et les commentaires de @ johnny-oshika et @DanyalAytekin:

Je suppose que dans l'exemple fourni par @ johnny-oshika, nous pourrions utiliser des fonctions normales au lieu de fonctions fléchées, puis .bindles utiliser avec l'objet actuel plus un _privatesobjet comme paramètre curry:

quelque chose.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

Avantages auxquels je peux penser:

• nous pouvons avoir des méthodes privées ( _greetet _updateMessageagir comme des méthodes privées tant que nous n'avons pas exportles références)
• bien qu'elles ne soient pas sur le prototype, les méthodes mentionnées ci-dessus économiseront de la mémoire car les instances sont créées une fois, en dehors de la classe (au lieu de les définir dans le constructeur)
• nous ne fuyons pas de globaux puisque nous sommes à l'intérieur d'un module
• nous pouvons également avoir des propriétés privées en utilisant l' _privatesobjet lié

Quelques inconvénients auxquels je peux penser:

• moins intuitif
• utilisation mixte de la syntaxe des classes et des modèles old school (liaisons d'objets, variables de portée module / fonction)
• liaisons dures - nous ne pouvons pas relier les méthodes publiques (bien que nous puissions améliorer cela en utilisant des liaisons souples ( https://github.com/getify/You-Dont-Know-JS/blob/master/this%20%26% 20object% 20prototypes / ch2.md # adoucissement-liaison ))

Un extrait en cours d'exécution peut être trouvé ici: http://www.webpackbin.com/NJgI5J8lZ

Oui - vous pouvez créer une propriété encapsulée , mais cela n'a pas été fait avec des modificateurs d'accès (public | privé), du moins pas avec ES6.

Voici un exemple simple de la façon dont cela peut être fait avec ES6:

1 Créer une classe en utilisant un mot de classe

2 À l'intérieur, le constructeur déclare la variable de portée de bloc en utilisant les mots réservés let OR const -> car ils sont de portée de bloc, ils ne sont pas accessibles de l'extérieur (encapsulés)

3 Pour autoriser un certain contrôle d'accès (setters | getters) à ces variables, vous pouvez déclarer la méthode d'instance à l'intérieur de son constructeur en utilisant: this.methodName=function(){}syntax

"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;
            }
        }
    }

Vérifions maintenant:

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

Une approche différente du «privé»

Au lieu de lutter contre le fait que la visibilité privée n'est actuellement pas disponible dans ES6, j'ai décidé d'adopter une approche plus pratique qui fonctionne très bien si votre IDE prend en charge JSDoc (par exemple, Webstorm). L'idée est d'utiliser la @privatebalise . En ce qui concerne le développement, l'IDE vous empêchera d'accéder à tout membre privé en dehors de sa classe. Fonctionne assez bien pour moi et cela a été vraiment utile pour masquer les méthodes internes, donc la fonction de saisie semi-automatique me montre exactement ce que la classe voulait vraiment exposer. Voici un exemple:

WeakMap

• pris en charge dans IE11 (les symboles ne le sont pas)
• hard-private (les accessoires utilisant des symboles sont soft-private en raison de Object.getOwnPropertySymbols)
• peut sembler très propre (contrairement aux fermetures qui nécessitent tous les accessoires et méthodes du constructeur)

Tout d'abord, définissez une fonction pour envelopper WeakMap:

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

Ensuite, construisez une référence en dehors de votre classe:

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

Remarque: la classe n'est pas prise en charge par IE11, mais elle semble plus propre dans l'exemple.

Oh, tant de solutions exotiques! Je ne me soucie généralement pas de la confidentialité, j'utilise donc la "pseudo confidentialité" comme il est dit ici . Mais si vous vous en souciez (s'il y a des exigences particulières pour cela), j'utilise quelque chose comme dans cet exemple:

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

Une autre implémentation possible de la fonction (constructeur) Job:

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

Personnellement, j'aime la proposition de l' opérateur de liaison :: et je la combinerais alors avec la solution @ d13 mentionnée, mais pour l'instant je m'en tiens à la réponse de @ d13 où vous utilisez le exportmot - clé pour votre classe et placez les fonctions privées dans le module.

il y a une autre solution difficile qui n'a pas été mentionnée ici qui suit est une approche plus fonctionnelle et lui permettrait d'avoir tous les accessoires / méthodes privés au sein de la classe.

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

des commentaires à ce sujet seraient appréciés.

Je suis tombé sur ce post en cherchant la meilleure pratique pour les "données privées pour les classes". Il a été mentionné que certains des modèles auraient des problèmes de performances.

J'ai rassemblé quelques tests jsperf basés sur les 4 modèles principaux du livre en ligne "Exploring ES6":

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

Les tests peuvent être trouvés ici:

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

Dans Chrome 63.0.3239 / Mac OS X 10.11.6, les modèles les plus performants étaient "Données privées via des environnements constructeurs" et "Données privées via une convention de dénomination". Pour moi, Safari a bien fonctionné pour WeakMap mais Chrome pas si bien.

Je ne connais pas l'impact de la mémoire, mais le modèle des "environnements constructeurs" dont certains avaient averti qu'il s'agissait d'un problème de performances était très performant.

Les 4 modèles de base sont:

Données privées via des environnements constructeurs

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();

Données privées via des environnements constructeurs 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();

Données privées via une convention de nommage

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();

Données privées via 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();

Données privées via des symboles

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();

Je crois qu'il est possible d'obtenir le «meilleur des deux mondes» en utilisant des fermetures à l'intérieur des constructeurs. Il existe deux variantes:

Tous les membres des données sont privés

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);
   }
};

Certains membres sont privés

REMARQUE: c'est certes moche. Si vous connaissez une meilleure solution, veuillez modifier cette réponse.

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);
   }
};

En fait, il est possible d'utiliser des symboles et des proxys. Vous utilisez les symboles dans la portée de la classe et définissez deux interruptions dans un proxy: un pour le prototype de classe afin que Reflect.ownKeys (instance) ou Object.getOwnPropertySymbols ne donne pas vos symboles, l'autre pour le constructeur lui-même donc quand new ClassName(attrs)est appelé, l'instance retournée sera interceptée et verra ses propres symboles de propriétés bloqués. Voici le 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()fonctionne comme ça: Object.getOwnPropertyNames(myObj).concat(Object.getOwnPropertySymbols(myObj))c'est pourquoi nous avons besoin d'un piège pour ces objets.

Même Typescript ne peut pas le faire. De leur documentation :

Lorsqu'un membre est marqué comme privé, il n'est pas accessible depuis l'extérieur de sa classe conteneur. Par exemple:

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

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

Mais transposé sur leur terrain de jeu, cela donne:

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

Leur mot-clé "privé" est donc inefficace.

Venant très tard à cette fête mais j'ai frappé la question OP dans une recherche donc ... Oui, vous pouvez avoir des propriétés privées en enveloppant la déclaration de classe dans une fermeture

Il y a un exemple de la façon dont j'ai des méthodes privées dans ce codepen . Dans l'extrait ci-dessous, la classe Subscribeable a deux fonctions «privées» processet processCallbacks. Toutes les propriétés peuvent être ajoutées de cette manière et elles sont gardées privées grâce à l'utilisation de la fermeture. La confidentialité de l'OMI est un besoin rare si les préoccupations sont bien séparées et que Javascript n'a pas besoin d'être gonflé en ajoutant plus de syntaxe lorsqu'une fermeture fait le travail proprement.

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)}}}})();

J'aime cette approche car elle sépare bien les préoccupations et garde les choses vraiment privées. Le seul inconvénient est la nécessité d'utiliser «soi» (ou quelque chose de similaire) pour faire référence à «ceci» dans le contenu privé.

Je pense que la réponse de Benjamin est probablement la meilleure pour la plupart des cas jusqu'à ce que le langage supporte nativement les variables explicitement privées.

Cependant, si pour une raison quelconque vous devez empêcher l'accès avec Object.getOwnPropertySymbols(), une méthode que j'ai envisagée d'utiliser consiste à attacher une propriété unique, non configurable, non énumérable et non inscriptible qui peut être utilisée comme identificateur de propriété pour chaque objet en construction (comme un unique Symbol, si vous n'avez pas déjà une autre propriété unique comme un id). Ensuite, gardez simplement une carte des variables «privées» de chaque objet en utilisant cet identifiant.

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"

L'avantage potentiel de cette approche par rapport à l'utilisation d'un WeakMapest un temps d'accès plus rapide si les performances deviennent un problème.

Oui, tout à fait, et assez facilement aussi. Cela se fait en exposant vos variables et fonctions privées en renvoyant le graphique d'objet prototype dans le constructeur. Ce n'est pas nouveau, mais prenez un peu de js foo pour en comprendre l'élégance. De cette façon, vous n'utilisez pas de cartes globales ou faibles. C'est une forme de réflexion intégrée à la langue. Selon la façon dont vous tirez parti de cela; on peut soit forcer une exception qui interrompt la pile des appels, soit enterrer l'exception en tant que undefined. Ceci est démontré ci-dessous, et vous pouvez en savoir plus sur ces fonctionnalités ici

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"

Une autre façon similaire aux deux derniers publiés

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

La plupart des réponses disent que c'est impossible, ou vous obligent à utiliser un WeakMap ou un symbole, qui sont des fonctionnalités ES6 qui nécessiteraient probablement des polyfills. Il y a cependant une autre façon! Découvrez ceci:

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

J'appelle ce modèle d'accesseur de méthode . L'idée essentielle est que nous avons une fermeture , une clé à l'intérieur de la fermeture, et nous créons un objet privé (dans le constructeur) qui n'est accessible que si vous avez la clé .

Si vous êtes intéressé, vous pouvez en savoir plus à ce sujet dans mon article . En utilisant cette méthode, vous pouvez créer des propriétés par objet qui ne sont pas accessibles en dehors de la fermeture. Par conséquent, vous pouvez les utiliser dans un constructeur ou un prototype, mais pas ailleurs. Je n'ai vu cette méthode utilisée nulle part, mais je pense qu'elle est vraiment puissante.

Voir cette réponse pour une solution de classe propre et simple avec une interface privée et publique et un support pour la composition

J'ai trouvé une solution très simple, il suffit de l'utiliser Object.freeze(). Bien sûr, le problème est que vous ne pouvez rien ajouter à l'objet plus tard.

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

J'utilise ce modèle et cela a toujours fonctionné pour moi

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

En fait , il est possible.
1. D'abord, créez la classe et dans le constructeur retournez la _publicfonction appelée .
2. Dans la _publicfonction appelée , passez la thisréférence (pour obtenir l'accès à toutes les méthodes et accessoires privés) , et tous les arguments de constructor (qui seront passés new Names()).
3. Dans l' _publicétendue de la fonction, il y a aussi la Namesclasse avec l'accès à this(_this ) référence de la Namesclasse privée

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);
}

Vous pouvez essayer ceci https://www.npmjs.com/package/private-members

Ce package enregistrera les membres par instance.

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;