Apakah mungkin membuat properti pribadi di kelas ES6?

Ini sebuah contoh. Bagaimana saya bisa mencegah akses instance.property?

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

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

Bidang pribadi (dan metode) sedang diterapkan dalam standar ECMA . Anda dapat mulai menggunakannya hari ini dengan babel 7 dan tahap 3 yang telah ditetapkan.

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

Jawaban singkat, tidak, tidak ada dukungan asli untuk properti pribadi dengan kelas ES6.

Tetapi Anda bisa meniru perilaku itu dengan tidak melampirkan properti baru ke objek, tetapi menyimpannya di dalam konstruktor kelas, dan menggunakan getter dan setter untuk mencapai properti tersembunyi. Perhatikan bahwa getter dan setter mendapat definisi ulang pada setiap instance baru kelas.

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

Untuk memperluas jawaban @ loganfsmyth:

Satu-satunya data yang benar-benar pribadi dalam JavaScript masih variabel cakupan. Anda tidak dapat memiliki properti pribadi dalam arti properti yang diakses secara internal dengan cara yang sama seperti properti publik, tetapi Anda dapat menggunakan variabel scoped untuk menyimpan data pribadi.

Variabel cakupan

Pendekatan di sini adalah dengan menggunakan ruang lingkup fungsi konstruktor, yang bersifat pribadi, untuk menyimpan data pribadi. Agar metode memiliki akses ke data pribadi ini, mereka juga harus dibuat di dalam konstruktor, artinya Anda membuat ulang dengan setiap contoh. Ini adalah penalti kinerja dan memori, tetapi beberapa percaya penalti itu dapat diterima. Hukuman dapat dihindari untuk metode yang tidak memerlukan akses ke data pribadi dengan menambahkannya ke prototipe seperti biasa.

Contoh:

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

WeakMap Bercakupan

WeakMap dapat digunakan untuk menghindari kinerja pendekatan dan memori memori sebelumnya. WeakMaps mengaitkan data dengan Objects (di sini, instance) sedemikian rupa sehingga hanya dapat diakses menggunakan WeakMap itu. Jadi, kami menggunakan metode variabel lingkup untuk membuat WeakMap pribadi, lalu gunakan WeakMap itu untuk mengambil data pribadi yang terkait dengannya this. Ini lebih cepat daripada metode variabel cakupan karena semua instance Anda dapat membagikan WeakMap tunggal, jadi Anda tidak perlu membuat ulang metode hanya untuk membuatnya mengakses WeakMaps mereka sendiri.

Contoh:

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

Contoh ini menggunakan Objek untuk menggunakan satu WeakMap untuk beberapa properti pribadi; Anda juga dapat menggunakan beberapa WeakMaps dan menggunakannya age.set(this, 20), atau menulis pembungkus kecil dan menggunakannya dengan cara lain, seperti privateProps.set(this, 'age', 0).

Privasi dari pendekatan ini secara teoritis dapat dilanggar dengan merusak WeakMapobjek global . Karena itu, semua JavaScript dapat dipatahkan oleh global yang hancur. Kode kami sudah dibangun dengan asumsi bahwa ini tidak terjadi.

(Metode ini juga bisa dilakukan Map, tetapi WeakMaplebih baik karena Mapakan membuat kebocoran memori kecuali Anda sangat berhati-hati, dan untuk tujuan ini keduanya tidak berbeda.)

Setengah Jawab: Simbol yang Dicakup

Simbol adalah jenis nilai primitif yang dapat berfungsi sebagai nama properti. Anda dapat menggunakan metode variabel cakupan untuk membuat Simbol pribadi, lalu menyimpan data pribadi di this[mySymbol].

Privasi metode ini dapat dilanggar menggunakan Object.getOwnPropertySymbols, tetapi agak canggung untuk dilakukan.

Contoh:

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

Half-Answer: Menggarisbawahi

Default yang lama, cukup gunakan properti publik dengan awalan garis bawah. Meskipun bukan merupakan properti pribadi dengan cara apa pun, konvensi ini cukup lazim sehingga ia melakukan pekerjaan yang baik dengan mengomunikasikan bahwa pembaca harus memperlakukan properti itu sebagai milik pribadi, yang sering kali menyelesaikan pekerjaannya. Sebagai gantinya selang ini, kami mendapatkan pendekatan yang lebih mudah dibaca, lebih mudah untuk mengetik, dan lebih cepat.

Contoh:

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.

Kesimpulan

Pada ES2017, masih belum ada cara sempurna untuk melakukan properti pribadi. Berbagai pendekatan memiliki pro dan kontra. Variabel yang dicakup benar-benar pribadi; WeakMaps scoped sangat pribadi dan lebih praktis daripada variabel scoped; Simbol yang dicakup cukup pribadi dan praktis; garis bawah sering kali cukup pribadi dan sangat praktis.

Pembaruan: Sebuah proposal dengan sintaksis yang lebih baik sedang dalam perjalanan. Kontribusi dipersilahkan.

Ya, ada - untuk akses cakupanSymbol dalam objek - ES6 memperkenalkan s .

Simbol itu unik, Anda tidak bisa mendapatkan akses dari luar kecuali dengan refleksi (seperti privat di Java / C #) tetapi siapa pun yang memiliki akses ke simbol di dalam dapat menggunakannya untuk akses utama:

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

Jawabannya adalah tidak". Tetapi Anda dapat membuat akses pribadi ke properti seperti ini:

• Gunakan modul. Segala sesuatu dalam modul bersifat pribadi kecuali dibuat publik dengan menggunakan exportkata kunci.
• Di dalam modul, gunakan penutupan fungsi: http://www.kirupa.com/html5/closures_in_javascript.htm

(Saran bahwa Symbols dapat digunakan untuk memastikan privasi benar dalam versi sebelumnya dari spesifikasi ES6 tetapi tidak lagi terjadi: https://mail.mozilla.org/pipermail/es-discuss/2014-January/035604. html dan https://stackoverflow.com/a/22280202/1282216 . Untuk diskusi lebih lama tentang Simbol dan privasi, lihat: https://curiosity-driven.org/private-properties-in-javascript )

Satu-satunya cara untuk mendapatkan privasi sejati di JS adalah melalui pelingkupan, jadi tidak ada cara untuk memiliki properti yang merupakan anggota thisyang hanya dapat diakses di dalam komponen. Cara terbaik untuk menyimpan data yang benar-benar pribadi di ES6 adalah dengan 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));
  }
}

Jelas ini mungkin lambat, dan tentu saja jelek, tetapi memang memberikan privasi.

Perlu diingat bahwa BAHKAN INI tidak sempurna, karena Javascript sangat dinamis. Seseorang masih bisa melakukannya

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

untuk menangkap nilai saat disimpan, jadi jika Anda ingin ekstra hati-hati, Anda harus menangkap referensi lokal .setdan .getmenggunakan secara eksplisit alih-alih mengandalkan prototipe yang dapat ditimpa.

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

Untuk referensi lain di masa depan pada pemirsa, saya mendengar sekarang bahwa rekomendasi adalah menggunakan WeakMaps untuk menyimpan data pribadi.

Berikut ini contoh yang lebih jelas dan berfungsi:

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

Tergantung pada siapa Anda bertanya :-)

Tidak ada privatepengubah properti yang termasuk dalam proposal kelas minimal Maksimal yang tampaknya telah masuk ke draft saat ini .

Namun, mungkin ada dukungan untuk nama pribadi , yang memungkinkan properti pribadi - dan mereka mungkin dapat digunakan dalam definisi kelas juga.

Menggunakan modul ES6 (awalnya diusulkan oleh @ d13) bekerja dengan baik untuk saya. Itu tidak meniru properti pribadi dengan sempurna, tetapi setidaknya Anda bisa yakin bahwa properti yang seharusnya pribadi tidak akan bocor di luar kelas Anda. Ini sebuah contoh:

sesuatu

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

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

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

Maka kode konsumsi dapat terlihat seperti ini:

import Something from './something.js';

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

Pembaruan (Penting):

Seperti @DanyalAytekin diuraikan dalam komentar, properti pribadi ini bersifat statis, sehingga cakupannya global. Mereka akan bekerja dengan baik ketika bekerja dengan Lajang, tetapi harus diperhatikan untuk objek Transient. Memperluas contoh di atas:

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

Melengkapi @ d13 dan komentar oleh @ johnny-oshika dan @DanyalAytekin:

Saya kira dalam contoh yang disediakan oleh @ johnny-oshika kita bisa menggunakan fungsi normal alih-alih fungsi panah dan kemudian .bindmereka dengan objek saat ini ditambah _privatesobjek sebagai parameter kari:

sesuatu

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

Manfaat yang dapat saya pikirkan:

• kita dapat memiliki metode pribadi ( _greetdan _updateMessagebertindak seperti metode pribadi selama kita tidak exportreferensi)
• walaupun mereka tidak ada pada prototipe, metode yang disebutkan di atas akan menghemat memori karena instans dibuat sekali, di luar kelas (sebagai lawan mendefinisikannya dalam konstruktor)
• kita tidak membocorkan global karena kita berada di dalam sebuah modul
• kita juga dapat memiliki properti pribadi menggunakan _privatesobjek yang diikat

Beberapa kekurangan yang dapat saya pikirkan:

• kurang intuitif
• penggunaan campuran sintaksis kelas dan pola sekolah lama (binding objek, variabel / cakupan fungsi variabel)
• hard binding - kami tidak dapat mengubah metode publik (meskipun kami dapat memperbaikinya dengan menggunakan soft binding ( https://github.com/getify/You-Dont-Know-JS/blob/master/this%20%26%%) 20 objek% 20protipe / ch2.md # pelunakan-mengikat ))

Cuplikan berjalan dapat ditemukan di sini: http://www.webpackbin.com/NJgI5J8lZ

Ya - Anda dapat membuat properti enkapsulasi , tetapi belum dilakukan dengan pengubah akses (publik | pribadi) setidaknya tidak dengan ES6.

Berikut adalah contoh sederhana bagaimana hal itu dapat dilakukan dengan ES6:

1 Buat kelas menggunakan kata kelas

2 Di dalamnya konstruktor menyatakan variabel blok-dicakup menggunakan membiarkan ATAU kata-kata dicadangkan const -> karena mereka blok-lingkup mereka tidak dapat diakses dari luar (dienkapsulasi)

3 Untuk mengizinkan beberapa kontrol akses (setter | getter) ke variabel-variabel tersebut, Anda dapat mendeklarasikan metode instan di dalam konstruktornya menggunakan: this.methodName=function(){}sintaksis

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

Sekarang mari kita periksa:

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

Pendekatan berbeda untuk "pribadi"

Alih-alih melawan fakta bahwa visibilitas pribadi saat ini tidak tersedia di ES6, saya memutuskan untuk mengambil pendekatan yang lebih praktis yang tidak masalah jika IDE Anda mendukung JSDoc (misalnya, Webstorm). Idenya adalah menggunakan @privatetag . Sejauh pengembangan berjalan, IDE akan mencegah Anda mengakses anggota pribadi dari luar kelasnya. Berfungsi cukup baik untuk saya dan sudah sangat berguna untuk menyembunyikan metode internal sehingga fitur lengkapi-otomatis menunjukkan kepada saya apa yang sebenarnya ingin diungkapkan oleh kelas. Ini sebuah contoh:

WeakMap

• didukung di IE11 (Simbol tidak)
• hard-private (alat peraga yang menggunakan Simbol bersifat soft-private karena Object.getOwnPropertySymbols)
• dapat terlihat sangat bersih (tidak seperti penutupan yang membutuhkan semua alat peraga dan metode dalam konstruktor)

Pertama, tentukan fungsi untuk membungkus WeakMap:

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

Kemudian, buat referensi di luar kelas Anda:

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

Catatan: kelas tidak didukung oleh IE11, tetapi terlihat lebih bersih dalam contoh.

Oh, banyak sekali solusi eksotis! Saya biasanya tidak peduli dengan privasi jadi saya menggunakan "privasi semu" seperti yang dikatakan di sini . Tetapi jika peduli (jika ada beberapa persyaratan khusus untuk itu) saya menggunakan sesuatu seperti dalam contoh ini:

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

Kemungkinan implementasi fungsi lainnya (konstruktor) Job:

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

Secara pribadi saya suka proposal dari operator mengikat :: dan kemudian akan menggabungkannya dengan solusi @ d13 yang disebutkan tetapi untuk sekarang tetap dengan jawaban @ d13 di mana Anda menggunakan exportkata kunci untuk kelas Anda dan meletakkan fungsi pribadi dalam modul.

ada satu lagi solusi sulit yang belum disebutkan di sini yang berikut adalah pendekatan yang lebih fungsional dan akan memungkinkannya untuk memiliki semua alat peraga / metode pribadi di dalam kelas.

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

komentar tentang itu akan sangat dihargai.

Saya menemukan posting ini ketika mencari praktik terbaik untuk "data pribadi untuk kelas". Disebutkan bahwa beberapa pola akan memiliki masalah kinerja.

Saya mengumpulkan beberapa tes jsperf berdasarkan 4 pola utama dari buku online "Exploring ES6":

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

Tes dapat ditemukan di sini:

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

Di Chrome 63.0.3239 / Mac OS X 10.11.6, pola berkinerja terbaik adalah "Data pribadi melalui lingkungan konstruktor" dan "Data pribadi melalui konvensi penamaan". Bagi saya Safari berkinerja baik untuk WeakMap tetapi Chrome tidak begitu baik.

Saya tidak tahu dampak memori, tetapi pola "lingkungan konstruktor" yang beberapa orang peringatkan akan menjadi masalah kinerja sangat bagus.

4 pola dasar adalah:

Data pribadi melalui lingkungan konstruktor

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

Data pribadi melalui lingkungan konstruktor 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();

Data pribadi melalui konvensi penamaan

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

Data pribadi melalui 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();

Data pribadi melalui simbol

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

Saya percaya adalah mungkin untuk mendapatkan 'terbaik dari kedua dunia' menggunakan penutupan di dalam konstruktor. Ada dua variasi:

Semua anggota data bersifat pribadi

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

Beberapa anggota bersifat pribadi

CATATAN: Ini diakui jelek. Jika Anda tahu solusi yang lebih baik, harap edit jawaban ini.

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

Bahkan dimungkinkan menggunakan Simbol dan Proxy. Anda menggunakan simbol dalam ruang lingkup kelas dan menetapkan dua jebakan dalam proxy: satu untuk prototipe kelas sehingga Reflect.ownKeys (instance) atau Object.getOwnPropertySymbols tidak memberikan simbol Anda, yang lain adalah untuk konstruktor itu sendiri jadi ketika new ClassName(attrs)dipanggil, instance dikembalikan akan dicegat dan memiliki simbol properti sendiri diblokir. Berikut kodenya:

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()berfungsi seperti itu: Object.getOwnPropertyNames(myObj).concat(Object.getOwnPropertySymbols(myObj))itu sebabnya kita perlu jebakan untuk objek-objek ini.

Bahkan naskah tidak dapat melakukannya. Dari dokumentasi mereka :

Ketika seorang anggota ditandai pribadi, itu tidak dapat diakses dari luar kelasnya yang mengandung. Sebagai contoh:

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

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

Tapi ditransfasikan di taman bermain mereka ini memberi:

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

Jadi kata kunci "pribadi" mereka tidak efektif.

Datang sangat terlambat ke pesta ini tapi saya menekan pertanyaan OP dalam pencarian jadi ... Ya, Anda dapat memiliki properti pribadi dengan membungkus deklarasi kelas dalam penutupan

Ada contoh bagaimana saya memiliki metode pribadi dalam codepen ini . Dalam cuplikan di bawah ini, kelas Berlangganan memiliki dua fungsi 'pribadi' processdan processCallbacks. Properti apa pun dapat ditambahkan dengan cara ini dan sifatnya dirahasiakan melalui penggunaan penutupan. Privasi IMO adalah kebutuhan yang langka jika kekhawatiran dipisahkan dengan baik dan Javascript tidak perlu membengkak dengan menambahkan lebih banyak sintaks ketika sebuah penutupan dengan rapi melakukan pekerjaan.

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

Saya suka pendekatan ini karena ini memisahkan masalah dengan baik dan menjaga hal-hal yang benar-benar pribadi. Satu-satunya downside adalah kebutuhan untuk menggunakan 'diri' (atau sesuatu yang serupa) untuk merujuk 'ini' dalam konten pribadi.

Saya pikir jawaban Benjamin mungkin yang terbaik untuk sebagian besar kasus sampai bahasa itu secara native mendukung variabel pribadi secara eksplisit.

Namun, jika karena alasan tertentu Anda perlu mencegah akses Object.getOwnPropertySymbols(), metode yang saya pertimbangkan untuk digunakan adalah melampirkan properti unik, tidak dapat dikonfigurasi, tidak dapat dihitung, tidak dapat ditulis yang dapat digunakan sebagai pengidentifikasi properti untuk setiap objek pada konstruksi (seperti unik Symbol, jika Anda belum memiliki beberapa properti unik lainnya seperti a id). Kemudian simpan saja peta variabel 'pribadi' setiap objek menggunakan pengenal itu.

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"

Keuntungan potensial dari pendekatan ini daripada menggunakan WeakMapadalah waktu akses yang lebih cepat jika kinerja menjadi perhatian.

Ya benar-benar bisa, dan sangat mudah juga. Ini dilakukan dengan mengekspos variabel dan fungsi pribadi Anda dengan mengembalikan grafik objek prototipe dalam konstruktor. Ini bukan hal yang baru, tetapi ambillah sedikit untuk memahami keanggunannya. Cara ini tidak menggunakan cakupan global, atau kelemahan. Ini adalah bentuk refleksi yang dibangun ke dalam bahasa. Tergantung pada bagaimana Anda memanfaatkan ini; seseorang dapat memaksa pengecualian yang menginterupsi tumpukan panggilan, atau mengubur pengecualian sebagai undefined. Ini ditunjukkan di bawah ini, dan dapat membaca lebih lanjut tentang fitur ini di sini

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"

Cara lain mirip dengan dua yang terakhir diposting

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

Sebagian besar jawaban mengatakan itu tidak mungkin, atau mengharuskan Anda untuk menggunakan WeakMap atau Symbol, yang merupakan fitur ES6 yang mungkin membutuhkan polyfill. Namun ada cara lain! Lihat ini:

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

Saya menyebutnya pola pengakses metode ini . Ide dasarnya adalah bahwa kami memiliki penutup , kunci di dalam penutupan, dan kami membuat objek pribadi (dalam konstruktor) yang hanya dapat diakses jika Anda memiliki kunci .

Jika Anda tertarik, Anda dapat membaca lebih lanjut tentang ini di artikel saya . Menggunakan metode ini, Anda bisa membuat per objek properti yang tidak dapat diakses di luar penutupan. Oleh karena itu, Anda dapat menggunakannya dalam konstruktor atau prototipe, tetapi tidak di tempat lain. Saya belum pernah melihat metode ini digunakan di mana pun, tapi saya pikir ini sangat kuat.

Lihat jawaban ini untuk solusi 'kelas' yang bersih & sederhana dengan antarmuka pribadi dan publik serta dukungan untuk komposisi

Saya menemukan solusi yang sangat sederhana, cukup gunakan Object.freeze(). Tentu saja masalahnya adalah Anda tidak dapat menambahkan apa pun ke objek nanti.

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

Saya menggunakan pola ini dan selalu berhasil untuk saya

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

Sebenarnya adalah mungkin.
1. Pertama, buat kelas dan di konstruktor mengembalikan _publicfungsi yang dipanggil .
2. Dalam _publicfungsi yang dipanggil lulus thisreferensi (untuk mendapatkan akses ke semua metode pribadi dan alat peraga) , dan semua argumen dari constructor (yang akan diteruskan new Names()).
3. Dalam _publiclingkup fungsi ada juga Nameskelas dengan akses ke this(_ini ) referensi Nameskelas privat

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

Anda dapat mencoba ini https://www.npmjs.com/package/private-members

Paket ini akan menyelamatkan anggota secara instan.

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;