Accessing private member variables from prototype-defined functions

Question

Is there any way to make    private    variables  those defined in the constructor   available to prototype-defined methods   TestClass   function        var privateField    hello       this nonProtoHello   function   alert privateField       TestClass prototype prototypeHello   function   alert privateField      This works   t nonProtoHello     But this doesn   t   t prototypeHello     I   m used to defining my methods inside the constructor  but am moving away from that for a couple reasons

User · Answer

see Doug Crockford s page on this  You have to do it indirectly with something that can access the scope of the private variable   another example   Incrementer   function init      var counter   init    0       counter  is a private variable   this  increment   function     return counter        this  set   function x    counter   x      Incrementer prototype increment   function     return this  increment      Incrementer prototype set   function x    return this  set x       use case   js gt i   new Incrementer 100    object Object  js gt i increment   100 js gt i increment   101 js gt i increment   102 js gt i increment   103 js gt i set -44  js gt i increment   -44 js gt i increment   -43 js gt i increment   -42

User · Answer

var getParams   function  func      res    func toString   split  function     1  split      0  split        return res    function TestClass       var private    hidden   secret       clever magic accessor thing goes here   if     this instanceof arguments callee          for  var key in arguments          if  typeof arguments key      function             var keys   getParams arguments key           var params              for  var i   0  i  lt   keys length  i                if  private keys i      undefined                params push private keys i                                  arguments key  apply null params                        TestClass prototype test   function      var  hidden    variable I want to get   TestClass function hidden    hidden   hidden     invoke magic to get     new TestClass   test     How s this  Using an private accessor  Only allows you to get the variables though not to set them  depends on the use case

User · Answer

In current JavaScript  I m fairly certain that there is one and only one way to have private state  accessible from prototype functions  without adding anything public to this   The answer is to use the  weak map  pattern   To sum it up  The Person class has a single weak map  where the keys are the instances of Person  and the values are plain objects that are used for private storage   Here is a fully functional example   play at http   jsfiddle net ScottRippey BLNVr    var Person    function         var     weakMap           Now    this  returns an object  used for private storage      var Person   function first  last               Assign private storage            this  firstName   first            this  lastName   last            Person prototype             fullName  function                    Retrieve private storage              return   this  firstName     this  lastName                     firstName  function                 return   this  firstName                     destroy  function                    Free up the private storage                this  true                        return Person         function weakMap         var instances     values         return function instance  destroy            var index   instances indexOf instance           if  destroy                   Delete the private state              instances splice index  1               return values splice index  1  0             else if  index     -1                   Create the private state              instances push instance               values push                  return values values length - 1             else                  Return the private state              return values index                        Like I said  this is really the only way to achieve all 3 parts     There are two caveats  however   First  this costs performance -- every time you access the private data  it s an O n  operation  where n is the number of instances   So you won t want to do this if you have a large number of instances  Second  when you re done with an instance  you must call destroy  otherwise  the instance and the data will not be garbage collected  and you ll end up with a memory leak     And that s why my original answer   You shouldn t   is something I d like to stick to

User · Answer

No  there s no way to do it   That would essentially be scoping in reverse     Methods defined inside the constructor have access to private variables because all functions have access to the scope in which they were defined     Methods defined on a prototype are not defined within the scope of the constructor  and will not have access to the constructor s local variables   You can still have private variables  but if you want methods defined on the prototype to have access to them  you should define getters and setters on the this object  which the prototype methods  along with everything else  will have access to  For example   function Person name  secret           public     this name   name          private     var secret   secret          public methods have access to private members     this setSecret   function s            secret   s             this getSecret   function             return secret              Must use getters setters  Person prototype spillSecret   function     alert this getSecret

User · Answer

Here s what I came up with    function          var staticVar   0      var yrObj   function              var private     a  1  b  2           var MyObj   function                  private a    staticVar              staticVar                       MyObj prototype                  test    function                      console log private a                                     return new MyObj             window YrObj   yrObj         var obj1   new YrObj  var obj2   new YrObj  obj1 test       1 obj2 test       2   the main problem with this implementation is that it redefines the prototypes on every instanciation

User · Answer

ES6 WeakMaps  By using a simple pattern based in ES6 WeakMaps is possible to obtain private member variables  reachable from the prototype functions      Note   The usage of WeakMaps guarantees safety against memory leaks  by letting the Garbage Collector identify and discard unused instances      x000D   x000D     Create a private scope using an Immediately  x000D     Invoked Function Expression    x000D  let Person    function     x000D   x000D         Create the WeakMap that will hold each   x000D         Instance collection s of private data x000D      let privateData   new WeakMap    x000D       x000D         Declare the Constructor   x000D      function Person name    x000D             Insert the private data in the WeakMap  x000D             using  this  as a unique acces Key x000D          privateData set this    name  name     x000D        x000D       x000D         Declare a prototype method  x000D      Person prototype getName   function     x000D             Because  privateData  is in the same  x000D             scope  it s contents can be retrieved    x000D             by using  again  this    as  the acces key  x000D          return privateData get this  name  x000D         x000D   x000D         return the Constructor x000D      return Person  x000D        x000D   x000D   x000D    A more detailed explanation of this pattern can be found here

User · Answer

Can t you put the variables in a higher scope    function          var privateVariable   true       var MyClass   function              if  privateVariable  console log  readable from private scope                 MyClass prototype publicMethod   function              if  privateVariable  console log  readable from public scope

User · Answer

Try it       function Potatoe size        var  image   new Image         image src    potatoe   size   png       function getImage             if  getImage caller    null    getImage caller owner    Potatoe prototype              throw new Error  This is a private property             return  image            Object defineProperty this  image            configurable  false          enumerable  false          get   getImage                       Object defineProperty this  size            writable  false          configurable  false          enumerable  true          value   size                       Potatoe prototype draw   function ctx x y          ctx drawImage this image x y       console log this image     Potatoe prototype draw owner   Potatoe prototype   var pot   new Potatoe 32   console log  Potatoe size    pot size   try       console log  Potatoe image    pot image     catch e        console log  Oops    e     pot draw

User · Answer

I m late to the party  but I think I can contribute  Here  check this out    x000D   x000D     1  Create closure x000D  var SomeClass   function     x000D       2  Create  key  inside a closure x000D    var key       x000D       Function to create private storage x000D    var private   function     x000D      var obj       x000D         return Function to access private storage using  key  x000D      return function testkey    x000D        if key     testkey  return obj  x000D           If  key  is wrong  then storage cannot be accessed x000D        console error  Cannot access private properties    x000D        return undefined  x000D         x000D       x000D    var SomeClass   function     x000D         3  Create private storage x000D      this     private    x000D         4  Access private storage using the  key  x000D      this   key  priv prop   200  x000D       x000D    SomeClass prototype test   function     x000D      console log this   key  priv prop      Using property from prototype x000D       x000D    return SomeClass  x000D       x000D   x000D     Can access private property from within prototype x000D  var instance   new SomeClass    x000D  instance test        200  logged x000D   x000D     Cannot access private property from outside of the closure x000D  var wrong key       x000D  instance   wrong key      undefined  error logged x000D   x000D   x000D    I call this method accessor pattern  The essential idea is that we have a closure  a key inside the closure  and we create a private object  in the constructor  that can only be accessed if you have the key   If you are interested  you can read more about this in my article  Using this method  you can create per object properties that cannot be accessed outside of the closure  Therefore  you can use them in constructor or prototype  but not anywhere else  I haven t seen this method used anywhere  but I think it s really powerful

User · Answer

I suggest it would probably be a good idea to describe  having a prototype assignment in a constructor  as a Javascript anti-pattern  Think about it  It is way too risky   What you re actually doing there on creation of the second object  i e  b  is redefining that prototype function for all objects that use that prototype  This will effectively reset the value for object a in your example  It will work if you want a shared variable and if you happen to create all of the object instances up front  but it feels way too risky   I found a bug in some Javascript I was working on recently that was due to this exact anti-pattern  It was trying to set a drag and drop handler on the particular object being created but was instead doing it for all instances  Not good   Doug Crockford s solution is the best

User · Answer

Try it       function Potatoe size        var  image   new Image         image src    potatoe   size   png       function getImage             if  getImage caller    null    getImage caller owner    Potatoe prototype              throw new Error  This is a private property             return  image            Object defineProperty this  image            configurable  false          enumerable  false          get   getImage                       Object defineProperty this  size            writable  false          configurable  false          enumerable  true          value   size                       Potatoe prototype draw   function ctx x y          ctx drawImage this image x y       console log this image     Potatoe prototype draw owner   Potatoe prototype   var pot   new Potatoe 32   console log  Potatoe size    pot size   try       console log  Potatoe image    pot image     catch e        console log  Oops    e     pot draw

User · Answer

When I read this  it sounded like a tough challenge so I decided to figure out a way  What I came up with was CRAAAAZY but it totally works   First  I tried defining the class in an immediate function so you d have access to some of the private properties of that function  This works and allows you to get some private data  however  if you try to set the private data you ll soon find that all the objects will share the same value    x000D   x000D  var SharedPrivateClass    function        use immediate function x000D         our private data x000D      var private    Default   x000D   x000D         create the constructor x000D      function SharedPrivateClass      x000D   x000D         add to the prototype x000D      SharedPrivateClass prototype getPrivate   function     x000D             It has access to private vars from the immediate function  x000D          return private  x000D         x000D   x000D      SharedPrivateClass prototype setPrivate   function value    x000D          private   value  x000D         x000D   x000D      return SharedPrivateClass  x000D        x000D   x000D  var a   new SharedPrivateClass    x000D  console log  a    a getPrivate         a  Default  x000D   x000D  var b   new SharedPrivateClass    x000D  console log  b    b getPrivate         b  Default  x000D   x000D  a setPrivate  foo       a Sets private to  foo  x000D  console log  a    a getPrivate         a  foo  x000D  console log  b    b getPrivate        oh no  b getPrivate   is  foo   x000D   x000D  console log a hasOwnProperty  getPrivate        false  belongs to the prototype x000D  console log a private      undefined x000D   x000D     getPrivate   is only created once and instanceof still works x000D  console log a getPrivate     b getPrivate   x000D  console log a instanceof SharedPrivateClass   x000D  console log b instanceof SharedPrivateClass   x000D   x000D   x000D    There are plenty of cases where this would be adequate like if you wanted to have constant values like event names that get shared between instances  But essentially  they act like private static variables   If you absolutely need access to variables in a private namespace from within your methods defined on the prototype  you can try this pattern    x000D   x000D  var PrivateNamespaceClass    function        immediate function x000D      var instance   0     counts the number of instances x000D          defaultName    Default Name     x000D          p          an array of private objects x000D   x000D         create the constructor x000D      function PrivateNamespaceClass     x000D             Increment the instance count and save it to the instance   x000D             This will become your key to your private space  x000D          this i   instance     x000D           x000D             Create a new object in the private space  x000D          p this i        x000D             Define properties or methods in the private space  x000D          p this i  name   defaultName  x000D           x000D          console log  New instance     this i           x000D        x000D   x000D      PrivateNamespaceClass prototype getPrivateName   function     x000D             It has access to the private space and it s children  x000D          return p this i  name  x000D         x000D      PrivateNamespaceClass prototype setPrivateName   function value    x000D             Because you use the instance number assigned to the object  this i  x000D             as a key  the values set will not change in other instances  x000D          p this i  name   value  x000D          return  Set     p this i  name  x000D         x000D   x000D      return PrivateNamespaceClass  x000D        x000D   x000D  var a   new PrivateNamespaceClass    x000D  console log a getPrivateName        Default Name x000D   x000D  var b   new PrivateNamespaceClass    x000D  console log b getPrivateName        Default Name x000D   x000D  console log a setPrivateName  A     x000D  console log b setPrivateName  B     x000D  console log a getPrivateName        A x000D  console log b getPrivateName        B x000D   x000D     private objects are not accessible outside the PrivateNamespaceClass function x000D  console log a p   x000D   x000D     the prototype functions are not re-created for each instance x000D     and instanceof still works x000D  console log a getPrivateName     b getPrivateName   x000D  console log a instanceof PrivateNamespaceClass   x000D  console log b instanceof PrivateNamespaceClass   x000D   x000D   x000D    I d love some feedback from anyone who sees an error with this way of doing it

User · Answer

Yes  it s possible  PPF design pattern just solves this    PPF stands for Private Prototype Functions  Basic PPF solves these issues    Prototype functions get access to private instance data  Prototype functions can be made private    For the first  just    Put all private instance variables you want to be accessible from prototype functions inside a separate data container  and Pass a reference to the data container to all prototype functions as a parameter    It s that simple  For example      Helper class to store private data  function Data           Object constructor function Point x  y         container for private vars  all private vars go here      we want x  y be changeable via methods only   var data   new Data    data x   x    data y   y               Prototype functions now have access to private instance data Point prototype getX   function data      return data x     Point prototype getY   function data      return data y           Read the full story here   PPF Design Pattern

User · Answer

see Doug Crockford s page on this  You have to do it indirectly with something that can access the scope of the private variable   another example   Incrementer   function init      var counter   init    0       counter  is a private variable   this  increment   function     return counter        this  set   function x    counter   x      Incrementer prototype increment   function     return this  increment      Incrementer prototype set   function x    return this  set x       use case   js gt i   new Incrementer 100    object Object  js gt i increment   100 js gt i increment   101 js gt i increment   102 js gt i increment   103 js gt i set -44  js gt i increment   -44 js gt i increment   -43 js gt i increment   -42

User · Answer

Yes  it s possible  PPF design pattern just solves this    PPF stands for Private Prototype Functions  Basic PPF solves these issues    Prototype functions get access to private instance data  Prototype functions can be made private    For the first  just    Put all private instance variables you want to be accessible from prototype functions inside a separate data container  and Pass a reference to the data container to all prototype functions as a parameter    It s that simple  For example      Helper class to store private data  function Data           Object constructor function Point x  y         container for private vars  all private vars go here      we want x  y be changeable via methods only   var data   new Data    data x   x    data y   y               Prototype functions now have access to private instance data Point prototype getX   function data      return data x     Point prototype getY   function data      return data y           Read the full story here   PPF Design Pattern

User · Answer

I suggest it would probably be a good idea to describe  having a prototype assignment in a constructor  as a Javascript anti-pattern  Think about it  It is way too risky   What you re actually doing there on creation of the second object  i e  b  is redefining that prototype function for all objects that use that prototype  This will effectively reset the value for object a in your example  It will work if you want a shared variable and if you happen to create all of the object instances up front  but it feels way too risky   I found a bug in some Javascript I was working on recently that was due to this exact anti-pattern  It was trying to set a drag and drop handler on the particular object being created but was instead doing it for all instances  Not good   Doug Crockford s solution is the best

User · Answer

There s a simpler way by leveraging the use of bind and call methods   By setting private variables to an object  you can leverage that object s scope   Example  function TestClass  value           The private value s      var  private             value  value                 bind  creates a copy of  getValue  when the object is instantiated     this getValue   TestClass prototype getValue bind  private           Use  call  in another function if the prototype method will possibly change     this getValueDynamic   function             return TestClass prototype getValue call  private              TestClass prototype getValue   function         return this value         This method isn t without drawbacks  Since the scope context is effectively being overridden  you don t have access outside of the  private object  However  it isn t impossible though to still give access to the instance object s scope  You can pass in the object s context  this  as the second argument to bind or call to still have access to it s public values in the prototype function   Accessing public values  function TestClass  value        var  private             value  value             this message    Hello          this getMessage   TestClass prototype getMessage bind  private  this       TestClass prototype getMessage   function  public            Can still access passed in arguments        e g      test getValues  foo     foo  is the 2nd argument to the method     console log    slice call arguments  1        return  public message   this value      var test   new TestClass  World    test getMessage 1  2  3       1  2  3           console log                                 gt   Hello  World   return value   test message    Greetings     test getMessage                              console log                          gt   Greetings  World   return value

User · Answer

ES6 WeakMaps  By using a simple pattern based in ES6 WeakMaps is possible to obtain private member variables  reachable from the prototype functions      Note   The usage of WeakMaps guarantees safety against memory leaks  by letting the Garbage Collector identify and discard unused instances      x000D   x000D     Create a private scope using an Immediately  x000D     Invoked Function Expression    x000D  let Person    function     x000D   x000D         Create the WeakMap that will hold each   x000D         Instance collection s of private data x000D      let privateData   new WeakMap    x000D       x000D         Declare the Constructor   x000D      function Person name    x000D             Insert the private data in the WeakMap  x000D             using  this  as a unique acces Key x000D          privateData set this    name  name     x000D        x000D       x000D         Declare a prototype method  x000D      Person prototype getName   function     x000D             Because  privateData  is in the same  x000D             scope  it s contents can be retrieved    x000D             by using  again  this    as  the acces key  x000D          return privateData get this  name  x000D         x000D   x000D         return the Constructor x000D      return Person  x000D        x000D   x000D   x000D    A more detailed explanation of this pattern can be found here

User · Answer

There is a very simple way to do this  function SharedPrivate      var private    secret     this constructor prototype getP   function   return private    this constructor prototype setP   function v   private   v      var o1   new SharedPrivate    var o2   new SharedPrivate     console log o1 getP        secret console log o2 getP        secret o1 setP  Pentax Full Frame K1 is on sale       console log o1 getP        Pentax Full Frame K1 is on sale    console log o2 getP        Pentax Full Frame K1 is on sale    o2 setP  And it s only for  1 795      console log o1 getP        And it s only for  1 795     JavaScript prototypes are golden

User · Answer

Update  With ES6  there is a better way   Long story short  you can use the new Symbol to create private fields  Here s a great description  https   curiosity-driven org private-properties-in-javascript  Example   var Person    function            Only Person can access nameSymbol     var nameSymbol   Symbol  name         function Person name            this nameSymbol    name             Person prototype getName   function             return this nameSymbol               return Person          For all modern browsers with ES5   You can use just Closures  The simplest way to construct objects is to avoid prototypal inheritance altogether   Just define the private variables and public functions within the closure  and all public methods will have private access to the variables     Or you can use just Prototypes  In JavaScript  prototypal inheritance is primarily an optimization   It allows multiple instances to share prototype methods  rather than each instance having its own methods  The drawback is that this is the only thing that s different each time a prototypal function is called  Therefore  any private fields must be accessible through this  which means they re going to be public   So we just stick to naming conventions for  private fields   Don t bother mixing Closures with Prototypes  I think you shouldn t mix closure variables with prototype methods   You should use one or the other     When you use a closure to access a private variable  prototype methods cannot access the variable  So  you have to expose the closure onto this  which means that you re exposing it publicly one way or another   There s very little to gain with this approach   Which do I choose   For really simple objects  just use a plain object with closures     If you need prototypal inheritance -- for inheritance  performance  etc  -- then stick with the   private  naming convention  and don t bother with closures   I don t understand why JS developers try SO hard to make fields truly private

User · Answer

There is a very simple way to do this  function SharedPrivate      var private    secret     this constructor prototype getP   function   return private    this constructor prototype setP   function v   private   v      var o1   new SharedPrivate    var o2   new SharedPrivate     console log o1 getP        secret console log o2 getP        secret o1 setP  Pentax Full Frame K1 is on sale       console log o1 getP        Pentax Full Frame K1 is on sale    console log o2 getP        Pentax Full Frame K1 is on sale    o2 setP  And it s only for  1 795      console log o1 getP        And it s only for  1 795     JavaScript prototypes are golden

User · Answer

Was playing around with this today and this was the only solution I could find without using Symbols  Best thing about this is it can actually all be completely private   The solution is based around a homegrown module loader which basically becomes the mediator for a private storage cache  using a weak map            const loader    function             function ModuleLoader             Static  accessible only if truly needed through obj constructor modules       Can also be made completely private by removing the ModuleLoader prefix      ModuleLoader modulesLoaded   0      ModuleLoader modules           ModuleLoader prototype define   function moduleName  dModule            if  moduleName in ModuleLoader modules  throw new Error  Error  duplicate module             const module   ModuleLoader modules moduleName                module context                   moduleName  moduleName              exports                          Weak map with instance as the key  when the created instance is garbage collected or goes out of scope this will be cleaned up          module  private                 private sections  new WeakMap                instances                         function private action  instance                switch  action                    case  create                       if  module  private private sections has instance   throw new Error  Cannot create private store twice on the same instance  check calls to create                        module  private instances push instance                       module  private private sections set instance                           break                  case  delete                       const index   module  private instances indexOf instance                       if  index    -1  throw new Error  Invalid state                        module  private instances slice index  1                       return module  private private sections delete instance                       break                  case  get                       return module  private private sections get instance                       break                  default                      throw new Error  Invalid action                        break                                   dModule call module context  private           ModuleLoader modulesLoaded               ModuleLoader prototype remove   function moduleName            if   moduleName in  ModuleLoader modules   return                          Clean up as best we can                     const module   ModuleLoader modules moduleName           module context   moduleName   null          module context exports   null          module cotext   null          module  private instances forEach function instance    module  private private sections delete instance              for  let i   0  i  lt  module  private instances length  i                  module  private instances i    undefined                    module  private instances   undefined          module  private   null          delete ModuleLoader modules moduleName           ModuleLoader modulesLoaded -  1              ModuleLoader prototype require   function moduleName            if    moduleName in ModuleLoader modules   throw new Error  Module does not exist             return ModuleLoader modules moduleName  context exports                return new ModuleLoader                   loader define  MyModule   function private store            function MyClass                   Creates the private storage facility  Called once in constructor              private store  create   this                   Retrieve the private storage object from the storage facility              private store  get   this  no   1                     MyClass prototype incrementPrivateVar   function                 private store  get   this  no    1                     MyClass prototype getPrivateVar   function                 return private store  get   this  no                     this exports   MyClass                Get whatever is exported from MyModule     const MyClass   loader require  MyModule           Create a new instance of  MyClass      const myClass   new MyClass           Create another instance of  MyClass      const myClass2   new MyClass           print out current private vars     console log  pVar       myClass getPrivateVar        console log  pVar2       myClass2 getPrivateVar           Increment it     myClass incrementPrivateVar          Print out to see if one affected the other or shared     console log  pVar after increment       myClass getPrivateVar        console log  pVar after increment on other class       myClass2 getPrivateVar           Clean up      loader remove  MyModule

User · Answer

There s a simpler way by leveraging the use of bind and call methods   By setting private variables to an object  you can leverage that object s scope   Example  function TestClass  value           The private value s      var  private             value  value                 bind  creates a copy of  getValue  when the object is instantiated     this getValue   TestClass prototype getValue bind  private           Use  call  in another function if the prototype method will possibly change     this getValueDynamic   function             return TestClass prototype getValue call  private              TestClass prototype getValue   function         return this value         This method isn t without drawbacks  Since the scope context is effectively being overridden  you don t have access outside of the  private object  However  it isn t impossible though to still give access to the instance object s scope  You can pass in the object s context  this  as the second argument to bind or call to still have access to it s public values in the prototype function   Accessing public values  function TestClass  value        var  private             value  value             this message    Hello          this getMessage   TestClass prototype getMessage bind  private  this       TestClass prototype getMessage   function  public            Can still access passed in arguments        e g      test getValues  foo     foo  is the 2nd argument to the method     console log    slice call arguments  1        return  public message   this value      var test   new TestClass  World    test getMessage 1  2  3       1  2  3           console log                                 gt   Hello  World   return value   test message    Greetings     test getMessage                              console log                          gt   Greetings  World   return value

User · Answer

Here s what I came up with    function          var staticVar   0      var yrObj   function              var private     a  1  b  2           var MyObj   function                  private a    staticVar              staticVar                       MyObj prototype                  test    function                      console log private a                                     return new MyObj             window YrObj   yrObj         var obj1   new YrObj  var obj2   new YrObj  obj1 test       1 obj2 test       2   the main problem with this implementation is that it redefines the prototypes on every instanciation

User · Answer

I faced the exact same question today and after elaborating on Scott Rippey first-class response  I came up with a very simple solution  IMHO  that is both compatible with ES5 and efficient  it also is name clash safe  using  private seems unsafe      jslint white  true  plusplus  true        global console     var a  TestClass    function         use strict       function PrefixedCounter  prefix            var counter   0          this count   function                  return prefix      counter                        var TestClass    function            var cls  pc   new PrefixedCounter   TestClass priv              privateField   pc count                     cls   function                this privateField     hello               this nonProtoHello   function                    console log this privateField                                      cls prototype prototypeHello   function                console log this privateField                       return cls                return TestClass         a   new TestClass    a nonProtoHello    a prototypeHello      Tested with ringojs and nodejs  I m eager to read your opinion

User · Answer

You can use a prototype assignment within the constructor definition    The variable will be visible to the prototype added method but all the instances of the functions will access the same SHARED variable   function A       var sharedVar   0    this local          A prototype increment   function lval              if  lval  this local   lval          alert    sharedVar      while this p is still     this local          var a   new A    var b   new A        a increment  I belong to a    b increment  I belong to b    a increment    b increment      I hope this can be usefull

User · Answer

You need to change 3 things in your code    Replace var privateField    hello  with this privateField    hello   In the prototype replace privateField with this privateField  In the non-prototype also replace privateField with this privateField    The final code would be the following   TestClass   function        this privateField    hello       this nonProtoHello   function   alert this privateField       TestClass prototype prototypeHello   function   alert this privateField     var t   new TestClass     t prototypeHello

User · Answer

Kai  That won t work  If you do  var t2   new TestClass      then t2 prototypeHello will be accessing t s private section    AnglesCrimes  The sample code works fine  but it actually creates a  static  private member shared by all instances  It may not be the solution morgancodes looked for   So far I haven t found an easy and clean way to do this without introducing a private hash and extra cleanup functions  A private member function can be simulated to certain extent    function         function Foo               Foo prototype bar   function            privateFoo call this  blah              function privateFoo blah                scoped to the instance by passing this to call             window Foo   Foo

User · Answer

No  there s no way to do it   That would essentially be scoping in reverse     Methods defined inside the constructor have access to private variables because all functions have access to the scope in which they were defined     Methods defined on a prototype are not defined within the scope of the constructor  and will not have access to the constructor s local variables   You can still have private variables  but if you want methods defined on the prototype to have access to them  you should define getters and setters on the this object  which the prototype methods  along with everything else  will have access to  For example   function Person name  secret           public     this name   name          private     var secret   secret          public methods have access to private members     this setSecret   function s            secret   s             this getSecret   function             return secret              Must use getters setters  Person prototype spillSecret   function     alert this getSecret

User · Answer

When I read this  it sounded like a tough challenge so I decided to figure out a way  What I came up with was CRAAAAZY but it totally works   First  I tried defining the class in an immediate function so you d have access to some of the private properties of that function  This works and allows you to get some private data  however  if you try to set the private data you ll soon find that all the objects will share the same value    x000D   x000D  var SharedPrivateClass    function        use immediate function x000D         our private data x000D      var private    Default   x000D   x000D         create the constructor x000D      function SharedPrivateClass      x000D   x000D         add to the prototype x000D      SharedPrivateClass prototype getPrivate   function     x000D             It has access to private vars from the immediate function  x000D          return private  x000D         x000D   x000D      SharedPrivateClass prototype setPrivate   function value    x000D          private   value  x000D         x000D   x000D      return SharedPrivateClass  x000D        x000D   x000D  var a   new SharedPrivateClass    x000D  console log  a    a getPrivate         a  Default  x000D   x000D  var b   new SharedPrivateClass    x000D  console log  b    b getPrivate         b  Default  x000D   x000D  a setPrivate  foo       a Sets private to  foo  x000D  console log  a    a getPrivate         a  foo  x000D  console log  b    b getPrivate        oh no  b getPrivate   is  foo   x000D   x000D  console log a hasOwnProperty  getPrivate        false  belongs to the prototype x000D  console log a private      undefined x000D   x000D     getPrivate   is only created once and instanceof still works x000D  console log a getPrivate     b getPrivate   x000D  console log a instanceof SharedPrivateClass   x000D  console log b instanceof SharedPrivateClass   x000D   x000D   x000D    There are plenty of cases where this would be adequate like if you wanted to have constant values like event names that get shared between instances  But essentially  they act like private static variables   If you absolutely need access to variables in a private namespace from within your methods defined on the prototype  you can try this pattern    x000D   x000D  var PrivateNamespaceClass    function        immediate function x000D      var instance   0     counts the number of instances x000D          defaultName    Default Name     x000D          p          an array of private objects x000D   x000D         create the constructor x000D      function PrivateNamespaceClass     x000D             Increment the instance count and save it to the instance   x000D             This will become your key to your private space  x000D          this i   instance     x000D           x000D             Create a new object in the private space  x000D          p this i        x000D             Define properties or methods in the private space  x000D          p this i  name   defaultName  x000D           x000D          console log  New instance     this i           x000D        x000D   x000D      PrivateNamespaceClass prototype getPrivateName   function     x000D             It has access to the private space and it s children  x000D          return p this i  name  x000D         x000D      PrivateNamespaceClass prototype setPrivateName   function value    x000D             Because you use the instance number assigned to the object  this i  x000D             as a key  the values set will not change in other instances  x000D          p this i  name   value  x000D          return  Set     p this i  name  x000D         x000D   x000D      return PrivateNamespaceClass  x000D        x000D   x000D  var a   new PrivateNamespaceClass    x000D  console log a getPrivateName        Default Name x000D   x000D  var b   new PrivateNamespaceClass    x000D  console log b getPrivateName        Default Name x000D   x000D  console log a setPrivateName  A     x000D  console log b setPrivateName  B     x000D  console log a getPrivateName        A x000D  console log b getPrivateName        B x000D   x000D     private objects are not accessible outside the PrivateNamespaceClass function x000D  console log a p   x000D   x000D     the prototype functions are not re-created for each instance x000D     and instanceof still works x000D  console log a getPrivateName     b getPrivateName   x000D  console log a instanceof PrivateNamespaceClass   x000D  console log b instanceof PrivateNamespaceClass   x000D   x000D   x000D    I d love some feedback from anyone who sees an error with this way of doing it

User · Answer

Was playing around with this today and this was the only solution I could find without using Symbols  Best thing about this is it can actually all be completely private   The solution is based around a homegrown module loader which basically becomes the mediator for a private storage cache  using a weak map            const loader    function             function ModuleLoader             Static  accessible only if truly needed through obj constructor modules       Can also be made completely private by removing the ModuleLoader prefix      ModuleLoader modulesLoaded   0      ModuleLoader modules           ModuleLoader prototype define   function moduleName  dModule            if  moduleName in ModuleLoader modules  throw new Error  Error  duplicate module             const module   ModuleLoader modules moduleName                module context                   moduleName  moduleName              exports                          Weak map with instance as the key  when the created instance is garbage collected or goes out of scope this will be cleaned up          module  private                 private sections  new WeakMap                instances                         function private action  instance                switch  action                    case  create                       if  module  private private sections has instance   throw new Error  Cannot create private store twice on the same instance  check calls to create                        module  private instances push instance                       module  private private sections set instance                           break                  case  delete                       const index   module  private instances indexOf instance                       if  index    -1  throw new Error  Invalid state                        module  private instances slice index  1                       return module  private private sections delete instance                       break                  case  get                       return module  private private sections get instance                       break                  default                      throw new Error  Invalid action                        break                                   dModule call module context  private           ModuleLoader modulesLoaded               ModuleLoader prototype remove   function moduleName            if   moduleName in  ModuleLoader modules   return                          Clean up as best we can                     const module   ModuleLoader modules moduleName           module context   moduleName   null          module context exports   null          module cotext   null          module  private instances forEach function instance    module  private private sections delete instance              for  let i   0  i  lt  module  private instances length  i                  module  private instances i    undefined                    module  private instances   undefined          module  private   null          delete ModuleLoader modules moduleName           ModuleLoader modulesLoaded -  1              ModuleLoader prototype require   function moduleName            if    moduleName in ModuleLoader modules   throw new Error  Module does not exist             return ModuleLoader modules moduleName  context exports                return new ModuleLoader                   loader define  MyModule   function private store            function MyClass                   Creates the private storage facility  Called once in constructor              private store  create   this                   Retrieve the private storage object from the storage facility              private store  get   this  no   1                     MyClass prototype incrementPrivateVar   function                 private store  get   this  no    1                     MyClass prototype getPrivateVar   function                 return private store  get   this  no                     this exports   MyClass                Get whatever is exported from MyModule     const MyClass   loader require  MyModule           Create a new instance of  MyClass      const myClass   new MyClass           Create another instance of  MyClass      const myClass2   new MyClass           print out current private vars     console log  pVar       myClass getPrivateVar        console log  pVar2       myClass2 getPrivateVar           Increment it     myClass incrementPrivateVar          Print out to see if one affected the other or shared     console log  pVar after increment       myClass getPrivateVar        console log  pVar after increment on other class       myClass2 getPrivateVar           Clean up      loader remove  MyModule

User · Answer

I have one solution  but I am not sure it is without flaws   For it to work  you have to use the following structure    Use 1 private object that contains all private variables  Use 1 instance function  Apply a closure to the constructor and all prototype functions  Any instance created is done outside the closure defined    Here is the code   var TestClass     function             difficult to be guessed      var hash   Math round Math random     Math pow 10  13      new Date         var TestClass   function              var privateFields                 field1  1              field2  2                    this getPrivateFields   function  hashed                if hashed     hash                    throw  Cannot access private fields outside of object                       or return null                            return privateFields                         TestClass prototype prototypeHello   function              var privateFields   this getPrivateFields hash           privateFields field1   Math round Math random     100           privateFields field2   Math round Math random     100               TestClass prototype logField1   function              var privateFields   this getPrivateFields hash           console log privateFields field1               TestClass prototype logField2   function              var privateFields   this getPrivateFields hash           console log privateFields field2               return TestClass          How this works is that it provides an instance function  this getPrivateFields  to access the  privateFields  private variables object  but this function will only return the  privateFields  object inside the main closure defined  also prototype functions using  this getPrivateFields  need to be defined inside this closure    A hash produced during runtime and difficult to be guessed is used as parameters to make sure that even if  getPrivateFields  is called outside the scope of closure will not return the  privateFields  object   The drawback is that we can not extend TestClass with more prototype functions outside the closure   Here is some test code    var t1   new TestClass    console log  Initial t1 field1 is      t1 logField1    console log  Initial t1 field2 is      t1 logField2    t1 prototypeHello    console log  t1 field1 is now      t1 logField1    console log  t1 field2 is now      t1 logField2    var t2   new TestClass    console log  Initial t2 field1 is      t2 logField1    console log  Initial t2 field2 is      t2 logField2    t2 prototypeHello    console log  t2 field1 is now      t2 logField1    console log  t2 field2 is now      t2 logField2     console log  t1 field1 stays      t1 logField1    console log  t1 field2 stays      t1 logField2     t1 getPrivateFields 11233     EDIT  Using this method  it is also possible to  define  private functions   TestClass prototype privateFunction   function  hashed        if hashed     hash            throw  Cannot access private function              TestClass prototype prototypeHello   function          this privateFunction hash

User · Answer

No  there s no way to do it   That would essentially be scoping in reverse     Methods defined inside the constructor have access to private variables because all functions have access to the scope in which they were defined     Methods defined on a prototype are not defined within the scope of the constructor  and will not have access to the constructor s local variables   You can still have private variables  but if you want methods defined on the prototype to have access to them  you should define getters and setters on the this object  which the prototype methods  along with everything else  will have access to  For example   function Person name  secret           public     this name   name          private     var secret   secret          public methods have access to private members     this setSecret   function s            secret   s             this getSecret   function             return secret              Must use getters setters  Person prototype spillSecret   function     alert this getSecret

User · Answer

I have one solution  but I am not sure it is without flaws   For it to work  you have to use the following structure    Use 1 private object that contains all private variables  Use 1 instance function  Apply a closure to the constructor and all prototype functions  Any instance created is done outside the closure defined    Here is the code   var TestClass     function             difficult to be guessed      var hash   Math round Math random     Math pow 10  13      new Date         var TestClass   function              var privateFields                 field1  1              field2  2                    this getPrivateFields   function  hashed                if hashed     hash                    throw  Cannot access private fields outside of object                       or return null                            return privateFields                         TestClass prototype prototypeHello   function              var privateFields   this getPrivateFields hash           privateFields field1   Math round Math random     100           privateFields field2   Math round Math random     100               TestClass prototype logField1   function              var privateFields   this getPrivateFields hash           console log privateFields field1               TestClass prototype logField2   function              var privateFields   this getPrivateFields hash           console log privateFields field2               return TestClass          How this works is that it provides an instance function  this getPrivateFields  to access the  privateFields  private variables object  but this function will only return the  privateFields  object inside the main closure defined  also prototype functions using  this getPrivateFields  need to be defined inside this closure    A hash produced during runtime and difficult to be guessed is used as parameters to make sure that even if  getPrivateFields  is called outside the scope of closure will not return the  privateFields  object   The drawback is that we can not extend TestClass with more prototype functions outside the closure   Here is some test code    var t1   new TestClass    console log  Initial t1 field1 is      t1 logField1    console log  Initial t1 field2 is      t1 logField2    t1 prototypeHello    console log  t1 field1 is now      t1 logField1    console log  t1 field2 is now      t1 logField2    var t2   new TestClass    console log  Initial t2 field1 is      t2 logField1    console log  Initial t2 field2 is      t2 logField2    t2 prototypeHello    console log  t2 field1 is now      t2 logField1    console log  t2 field2 is now      t2 logField2     console log  t1 field1 stays      t1 logField1    console log  t1 field2 stays      t1 logField2     t1 getPrivateFields 11233     EDIT  Using this method  it is also possible to  define  private functions   TestClass prototype privateFunction   function  hashed        if hashed     hash            throw  Cannot access private function              TestClass prototype prototypeHello   function          this privateFunction hash

User · Answer

I know it has been more than 1 decade since this was was asked  but I just put my thinking on this for the n-th time in my programmer life  and found a possible solution that I don t know if I entirely like yet  I have not seen this methodology documented before  so I will name it the  private public dollar pattern  or        pattern   var ownFunctionResult   this    functionName    arg1   arg2         var ownFieldValue   this     fieldName    newValue     var objectFunctionResult   objectX    functionName    arg1   arg2            Throws an exception  objectX    is not defined var objectFieldValue   objectX     fieldName    newValue      The concept uses a ClassDefinition function that returns a Constructor function that returns an Interface object  The interface s only method is   which receives a name argument to invoke the corresponding function in the constructor object  any additional arguments passed after name are passed in the invocation   The globally-defined helper function ClassValues stores all fields in an object as needed  It defines the    function to access them by name  This follows a short get set pattern so if value is passed  it will be used as the new variable value   var ClassValues   function  values      return           function    name  value          if  arguments length  gt  1            values name    value                 return values name                   The globally defined function Interface takes an object and a Values object to return an  interface with one single function   that examines obj to find a function named after the parameter name and invokes it with values as the scoped object  The additional arguments passed to   will be passed on the function invocation   var Interface   function  obj  values  className      var  interface            function   name          if  typeof obj name        function             return obj name  apply values  Array prototype splice call arguments  1                   throw className         name     is not a function                    Give values access to the interface    values      interface       return  interface       In the sample below  ClassX is assigned to the result of ClassDefinition  which is the Constructor function  Constructor may receive any number of arguments  Interface is what external code gets after calling the constructor   var ClassX    function ClassDefinition        var Constructor   function Constructor  valA        return Interface this  ClassValues   valA  valA      ClassX            Constructor prototype getValA   function getValA           private value access pattern to get current value      return this     valA            Constructor prototype setValA   function setValA valA          private value access pattern to set new value      this     valA   valA           Constructor prototype isValAValid   function isValAValid validMessage  invalidMessage          interface access pattern to call object function      var valA   this    getValA           timesAccessed was not defined in constructor but can be added later        var timesAccessed   this     timesAccessed         if  timesAccessed          timesAccessed   timesAccessed   1        else         timesAccessed   1             this     timesAccessed   timesAccessed        if  valA          return  valA is     validMessage                   return  valA is     invalidMessage                return Constructor          There is no point in having non-prototyped functions in Constructor  although you could define them in the constructor function body  All functions are called with the public dollar pattern this    functionName    param1   param2         The private values are accessed with the private dollar pattern this     valueName    replacingValue     As Interface does not have a definition for     the values cannot be accessed by external objects  Since each prototyped function body s this is set to the values object in function    you will get exceptions if you call Constructor sibling functions directly  the        pattern needs to be followed in prototyped function bodies too  Below sample usage   var classX1   new ClassX    console log  classX1     classX1    isValAValid    valid    invalid     console log  classX1 valA      classX1    getValA     classX1    setValA    v1    console log  classX1     classX1    isValAValid    valid    invalid     var classX2   new ClassX  v2    console log  classX1 valA      classX1    getValA     console log  classX2 valA      classX2    getValA       This will throw an exception   classX1     valA      And the console output   classX1 valA is invalid  classX1 valA  undefined classX1 valA is valid  classX1 valA  v1 classX2 valA  v2   The        pattern allows full privacy of values in fully-prototyped classes  I don t know if I will ever use this  nor if it has flaws  but hey  it was a good puzzle

User · Answer

You need to change 3 things in your code    Replace var privateField    hello  with this privateField    hello   In the prototype replace privateField with this privateField  In the non-prototype also replace privateField with this privateField    The final code would be the following   TestClass   function        this privateField    hello       this nonProtoHello   function   alert this privateField       TestClass prototype prototypeHello   function   alert this privateField     var t   new TestClass     t prototypeHello

User · Answer

I know it has been more than 1 decade since this was was asked  but I just put my thinking on this for the n-th time in my programmer life  and found a possible solution that I don t know if I entirely like yet  I have not seen this methodology documented before  so I will name it the  private public dollar pattern  or        pattern   var ownFunctionResult   this    functionName    arg1   arg2         var ownFieldValue   this     fieldName    newValue     var objectFunctionResult   objectX    functionName    arg1   arg2            Throws an exception  objectX    is not defined var objectFieldValue   objectX     fieldName    newValue      The concept uses a ClassDefinition function that returns a Constructor function that returns an Interface object  The interface s only method is   which receives a name argument to invoke the corresponding function in the constructor object  any additional arguments passed after name are passed in the invocation   The globally-defined helper function ClassValues stores all fields in an object as needed  It defines the    function to access them by name  This follows a short get set pattern so if value is passed  it will be used as the new variable value   var ClassValues   function  values      return           function    name  value          if  arguments length  gt  1            values name    value                 return values name                   The globally defined function Interface takes an object and a Values object to return an  interface with one single function   that examines obj to find a function named after the parameter name and invokes it with values as the scoped object  The additional arguments passed to   will be passed on the function invocation   var Interface   function  obj  values  className      var  interface            function   name          if  typeof obj name        function             return obj name  apply values  Array prototype splice call arguments  1                   throw className         name     is not a function                    Give values access to the interface    values      interface       return  interface       In the sample below  ClassX is assigned to the result of ClassDefinition  which is the Constructor function  Constructor may receive any number of arguments  Interface is what external code gets after calling the constructor   var ClassX    function ClassDefinition        var Constructor   function Constructor  valA        return Interface this  ClassValues   valA  valA      ClassX            Constructor prototype getValA   function getValA           private value access pattern to get current value      return this     valA            Constructor prototype setValA   function setValA valA          private value access pattern to set new value      this     valA   valA           Constructor prototype isValAValid   function isValAValid validMessage  invalidMessage          interface access pattern to call object function      var valA   this    getValA           timesAccessed was not defined in constructor but can be added later        var timesAccessed   this     timesAccessed         if  timesAccessed          timesAccessed   timesAccessed   1        else         timesAccessed   1             this     timesAccessed   timesAccessed        if  valA          return  valA is     validMessage                   return  valA is     invalidMessage                return Constructor          There is no point in having non-prototyped functions in Constructor  although you could define them in the constructor function body  All functions are called with the public dollar pattern this    functionName    param1   param2         The private values are accessed with the private dollar pattern this     valueName    replacingValue     As Interface does not have a definition for     the values cannot be accessed by external objects  Since each prototyped function body s this is set to the values object in function    you will get exceptions if you call Constructor sibling functions directly  the        pattern needs to be followed in prototyped function bodies too  Below sample usage   var classX1   new ClassX    console log  classX1     classX1    isValAValid    valid    invalid     console log  classX1 valA      classX1    getValA     classX1    setValA    v1    console log  classX1     classX1    isValAValid    valid    invalid     var classX2   new ClassX  v2    console log  classX1 valA      classX1    getValA     console log  classX2 valA      classX2    getValA       This will throw an exception   classX1     valA      And the console output   classX1 valA is invalid  classX1 valA  undefined classX1 valA is valid  classX1 valA  v1 classX2 valA  v2   The        pattern allows full privacy of values in fully-prototyped classes  I don t know if I will ever use this  nor if it has flaws  but hey  it was a good puzzle

User · Answer

Here s something I ve come up with while trying to find most simple solution for this problem  perhaps it could be useful to someone  I m new to javascript  so there might well be some issues with the code      pseudo-class definition scope  function              this is used to identify  friend  functions defined within this scope         while not being able to forge valid parameter for GetContext           to gain  private  access from outside     var  scope   new  function                   -----------------------------------------------------------------         pseudo-class definition     this Something   function  x                 private  members are wrapped into context object             it can be also created with a function         var  ctx   Object seal                   actual private members             Name  null              Number  null               Somefunc  function                      console log  Something     this Name      Somefunc    number       this Number                                        -----------------------------------------------------------------             function below needs to be defined in every class            to allow limited access from prototype         this GetContext   function  scope                 if  scope      scope  throw  access               return  ctx                       -----------------------------------------------------------------                           initialization code  if any              ctx Name    x      undefined     x    default                ctx Number   0               Object freeze this                          -----------------------------------------------------------------         prototype is defined only once     this Something prototype   Object freeze               public accessors for  private  field         get Number     return this GetContext  scope  Number             set Number v    this GetContext  scope  Number   v                 public function making use of some private fields         Test  function                   var  ctx   this GetContext  scope                  access  private  field             console log  Something      ctx Name      Test         ctx Number                  call  private  func              ctx Somefunc                             -----------------------------------------------------------------         wrap is used to hide  scope value and group definitions    call this    function  A cond    if  cond     true  throw new Error  assert failed         -----------------------------------------------------------------  function test smth          console clear         var smth1   new Something  first          smth2   new Something  second            A false        A smth1 Test     smth2 Test        smth1 Number   3      smth2 Number   5      console log  smth1 Number      smth1 Number      smth2 Number      smth2 Number        smth1 Number   2      smth2 Number   6       smth1 Test        smth2 Test         try           var ctx   smth1 GetContext          catch  err            console log  error      err            test smth

User · Answer

You can also try to add method not directly on prototype  but on constructor function like this   var MyArray   function         var array            this add   MyArray add bind null  array       this getAll   MyArray getAll bind null  array      MyArray add   function array  item        array push item     MyArray getAll   function array        return array     var myArray1   new MyArray    myArray1 add  some item 1    console log myArray1 getAll          some item 1   var myArray2   new MyArray    myArray2 add  some item 2    console log myArray2 getAll          some item 2   console log myArray1 getAll          some item 2   - FINE

User · Answer

I faced the exact same question today and after elaborating on Scott Rippey first-class response  I came up with a very simple solution  IMHO  that is both compatible with ES5 and efficient  it also is name clash safe  using  private seems unsafe      jslint white  true  plusplus  true        global console     var a  TestClass    function         use strict       function PrefixedCounter  prefix            var counter   0          this count   function                  return prefix      counter                        var TestClass    function            var cls  pc   new PrefixedCounter   TestClass priv              privateField   pc count                     cls   function                this privateField     hello               this nonProtoHello   function                    console log this privateField                                      cls prototype prototypeHello   function                console log this privateField                       return cls                return TestClass         a   new TestClass    a nonProtoHello    a prototypeHello      Tested with ringojs and nodejs  I m eager to read your opinion

User · Answer

No  there s no way to do it   That would essentially be scoping in reverse     Methods defined inside the constructor have access to private variables because all functions have access to the scope in which they were defined     Methods defined on a prototype are not defined within the scope of the constructor  and will not have access to the constructor s local variables   You can still have private variables  but if you want methods defined on the prototype to have access to them  you should define getters and setters on the this object  which the prototype methods  along with everything else  will have access to  For example   function Person name  secret           public     this name   name          private     var secret   secret          public methods have access to private members     this setSecret   function s            secret   s             this getSecret   function             return secret              Must use getters setters  Person prototype spillSecret   function     alert this getSecret

User · Answer

Can t you put the variables in a higher scope    function          var privateVariable   true       var MyClass   function              if  privateVariable  console log  readable from private scope                 MyClass prototype publicMethod   function              if  privateVariable  console log  readable from public scope

User · Answer

Kai  That won t work  If you do  var t2   new TestClass      then t2 prototypeHello will be accessing t s private section    AnglesCrimes  The sample code works fine  but it actually creates a  static  private member shared by all instances  It may not be the solution morgancodes looked for   So far I haven t found an easy and clean way to do this without introducing a private hash and extra cleanup functions  A private member function can be simulated to certain extent    function         function Foo               Foo prototype bar   function            privateFoo call this  blah              function privateFoo blah                scoped to the instance by passing this to call             window Foo   Foo

User · Answer

You can actually achieve this by using Accessor Verification    function key  global         Creates a private data accessor function    function   pData        return function aKey          return aKey     key  amp  amp  pData                   Private data accessor verifier   Verifies by making sure that the string      version of the function looks normal and that the toString function hasn t      been modified   NOTE   Verification can be duped if the rogue code replaces      Function prototype toString before this closure executes    function   me        if me            asString  amp  amp  me   toString      toString          return me   key               var  asString                toString     toString        Creates a Person class    var PersonPrototype    global Person   function firstName  lastName        this               firstName   firstName        lastName   lastName              prototype    PersonPrototype getName   function         var pData     this       return pData firstName         pData lastName         PersonPrototype setFirstName   function firstName        var pData     this       pData firstName   firstName      return this         PersonPrototype setLastName   function lastName        var pData     this       pData lastName   lastName      return this              this    var chris   new Person  Chris    West    alert chris setFirstName  Christopher   setLastName  Webber   getName       This example comes from my post about Prototypal Functions  amp  Private Data and is explained in more detail there

User · Answer

see Doug Crockford s page on this  You have to do it indirectly with something that can access the scope of the private variable   another example   Incrementer   function init      var counter   init    0       counter  is a private variable   this  increment   function     return counter        this  set   function x    counter   x      Incrementer prototype increment   function     return this  increment      Incrementer prototype set   function x    return this  set x       use case   js gt i   new Incrementer 100    object Object  js gt i increment   100 js gt i increment   101 js gt i increment   102 js gt i increment   103 js gt i set -44  js gt i increment   -44 js gt i increment   -43 js gt i increment   -42

User · Answer

Update  With ES6  there is a better way   Long story short  you can use the new Symbol to create private fields  Here s a great description  https   curiosity-driven org private-properties-in-javascript  Example   var Person    function            Only Person can access nameSymbol     var nameSymbol   Symbol  name         function Person name            this nameSymbol    name             Person prototype getName   function             return this nameSymbol               return Person          For all modern browsers with ES5   You can use just Closures  The simplest way to construct objects is to avoid prototypal inheritance altogether   Just define the private variables and public functions within the closure  and all public methods will have private access to the variables     Or you can use just Prototypes  In JavaScript  prototypal inheritance is primarily an optimization   It allows multiple instances to share prototype methods  rather than each instance having its own methods  The drawback is that this is the only thing that s different each time a prototypal function is called  Therefore  any private fields must be accessible through this  which means they re going to be public   So we just stick to naming conventions for  private fields   Don t bother mixing Closures with Prototypes  I think you shouldn t mix closure variables with prototype methods   You should use one or the other     When you use a closure to access a private variable  prototype methods cannot access the variable  So  you have to expose the closure onto this  which means that you re exposing it publicly one way or another   There s very little to gain with this approach   Which do I choose   For really simple objects  just use a plain object with closures     If you need prototypal inheritance -- for inheritance  performance  etc  -- then stick with the   private  naming convention  and don t bother with closures   I don t understand why JS developers try SO hard to make fields truly private

User · Answer

see Doug Crockford s page on this  You have to do it indirectly with something that can access the scope of the private variable   another example   Incrementer   function init      var counter   init    0       counter  is a private variable   this  increment   function     return counter        this  set   function x    counter   x      Incrementer prototype increment   function     return this  increment      Incrementer prototype set   function x    return this  set x       use case   js gt i   new Incrementer 100    object Object  js gt i increment   100 js gt i increment   101 js gt i increment   102 js gt i increment   103 js gt i set -44  js gt i increment   -44 js gt i increment   -43 js gt i increment   -42

User · Answer

var getParams   function  func      res    func toString   split  function     1  split      0  split        return res    function TestClass       var private    hidden   secret       clever magic accessor thing goes here   if     this instanceof arguments callee          for  var key in arguments          if  typeof arguments key      function             var keys   getParams arguments key           var params              for  var i   0  i  lt   keys length  i                if  private keys i      undefined                params push private keys i                                  arguments key  apply null params                        TestClass prototype test   function      var  hidden    variable I want to get   TestClass function hidden    hidden   hidden     invoke magic to get     new TestClass   test     How s this  Using an private accessor  Only allows you to get the variables though not to set them  depends on the use case

User · Answer

You can actually achieve this by using Accessor Verification    function key  global         Creates a private data accessor function    function   pData        return function aKey          return aKey     key  amp  amp  pData                   Private data accessor verifier   Verifies by making sure that the string      version of the function looks normal and that the toString function hasn t      been modified   NOTE   Verification can be duped if the rogue code replaces      Function prototype toString before this closure executes    function   me        if me            asString  amp  amp  me   toString      toString          return me   key               var  asString                toString     toString        Creates a Person class    var PersonPrototype    global Person   function firstName  lastName        this               firstName   firstName        lastName   lastName              prototype    PersonPrototype getName   function         var pData     this       return pData firstName         pData lastName         PersonPrototype setFirstName   function firstName        var pData     this       pData firstName   firstName      return this         PersonPrototype setLastName   function lastName        var pData     this       pData lastName   lastName      return this              this    var chris   new Person  Chris    West    alert chris setFirstName  Christopher   setLastName  Webber   getName       This example comes from my post about Prototypal Functions  amp  Private Data and is explained in more detail there

User · Answer

You can also try to add method not directly on prototype  but on constructor function like this   var MyArray   function         var array            this add   MyArray add bind null  array       this getAll   MyArray getAll bind null  array      MyArray add   function array  item        array push item     MyArray getAll   function array        return array     var myArray1   new MyArray    myArray1 add  some item 1    console log myArray1 getAll          some item 1   var myArray2   new MyArray    myArray2 add  some item 2    console log myArray2 getAll          some item 2   console log myArray1 getAll          some item 2   - FINE

User · Answer

Here s something I ve come up with while trying to find most simple solution for this problem  perhaps it could be useful to someone  I m new to javascript  so there might well be some issues with the code      pseudo-class definition scope  function              this is used to identify  friend  functions defined within this scope         while not being able to forge valid parameter for GetContext           to gain  private  access from outside     var  scope   new  function                   -----------------------------------------------------------------         pseudo-class definition     this Something   function  x                 private  members are wrapped into context object             it can be also created with a function         var  ctx   Object seal                   actual private members             Name  null              Number  null               Somefunc  function                      console log  Something     this Name      Somefunc    number       this Number                                        -----------------------------------------------------------------             function below needs to be defined in every class            to allow limited access from prototype         this GetContext   function  scope                 if  scope      scope  throw  access               return  ctx                       -----------------------------------------------------------------                           initialization code  if any              ctx Name    x      undefined     x    default                ctx Number   0               Object freeze this                          -----------------------------------------------------------------         prototype is defined only once     this Something prototype   Object freeze               public accessors for  private  field         get Number     return this GetContext  scope  Number             set Number v    this GetContext  scope  Number   v                 public function making use of some private fields         Test  function                   var  ctx   this GetContext  scope                  access  private  field             console log  Something      ctx Name      Test         ctx Number                  call  private  func              ctx Somefunc                             -----------------------------------------------------------------         wrap is used to hide  scope value and group definitions    call this    function  A cond    if  cond     true  throw new Error  assert failed         -----------------------------------------------------------------  function test smth          console clear         var smth1   new Something  first          smth2   new Something  second            A false        A smth1 Test     smth2 Test        smth1 Number   3      smth2 Number   5      console log  smth1 Number      smth1 Number      smth2 Number      smth2 Number        smth1 Number   2      smth2 Number   6       smth1 Test        smth2 Test         try           var ctx   smth1 GetContext          catch  err            console log  error      err            test smth

User · Answer

I m late to the party  but I think I can contribute  Here  check this out    x000D   x000D     1  Create closure x000D  var SomeClass   function     x000D       2  Create  key  inside a closure x000D    var key       x000D       Function to create private storage x000D    var private   function     x000D      var obj       x000D         return Function to access private storage using  key  x000D      return function testkey    x000D        if key     testkey  return obj  x000D           If  key  is wrong  then storage cannot be accessed x000D        console error  Cannot access private properties    x000D        return undefined  x000D         x000D       x000D    var SomeClass   function     x000D         3  Create private storage x000D      this     private    x000D         4  Access private storage using the  key  x000D      this   key  priv prop   200  x000D       x000D    SomeClass prototype test   function     x000D      console log this   key  priv prop      Using property from prototype x000D       x000D    return SomeClass  x000D       x000D   x000D     Can access private property from within prototype x000D  var instance   new SomeClass    x000D  instance test        200  logged x000D   x000D     Cannot access private property from outside of the closure x000D  var wrong key       x000D  instance   wrong key      undefined  error logged x000D   x000D   x000D    I call this method accessor pattern  The essential idea is that we have a closure  a key inside the closure  and we create a private object  in the constructor  that can only be accessed if you have the key   If you are interested  you can read more about this in my article  Using this method  you can create per object properties that cannot be accessed outside of the closure  Therefore  you can use them in constructor or prototype  but not anywhere else  I haven t seen this method used anywhere  but I think it s really powerful

User · Answer

In current JavaScript  I m fairly certain that there is one and only one way to have private state  accessible from prototype functions  without adding anything public to this   The answer is to use the  weak map  pattern   To sum it up  The Person class has a single weak map  where the keys are the instances of Person  and the values are plain objects that are used for private storage   Here is a fully functional example   play at http   jsfiddle net ScottRippey BLNVr    var Person    function         var     weakMap           Now    this  returns an object  used for private storage      var Person   function first  last               Assign private storage            this  firstName   first            this  lastName   last            Person prototype             fullName  function                    Retrieve private storage              return   this  firstName     this  lastName                     firstName  function                 return   this  firstName                     destroy  function                    Free up the private storage                this  true                        return Person         function weakMap         var instances     values         return function instance  destroy            var index   instances indexOf instance           if  destroy                   Delete the private state              instances splice index  1               return values splice index  1  0             else if  index     -1                   Create the private state              instances push instance               values push                  return values values length - 1             else                  Return the private state              return values index                        Like I said  this is really the only way to achieve all 3 parts     There are two caveats  however   First  this costs performance -- every time you access the private data  it s an O n  operation  where n is the number of instances   So you won t want to do this if you have a large number of instances  Second  when you re done with an instance  you must call destroy  otherwise  the instance and the data will not be garbage collected  and you ll end up with a memory leak     And that s why my original answer   You shouldn t   is something I d like to stick to

User · Answer

You can use a prototype assignment within the constructor definition    The variable will be visible to the prototype added method but all the instances of the functions will access the same SHARED variable   function A       var sharedVar   0    this local          A prototype increment   function lval              if  lval  this local   lval          alert    sharedVar      while this p is still     this local          var a   new A    var b   new A        a increment  I belong to a    b increment  I belong to b    a increment    b increment      I hope this can be usefull

[javascript] Accessing private member variables from prototype-defined functions

Examples related to javascript

Examples related to private-members