JavaScript private methods

Question

To make a JavaScript class with a public method I d do something like   function Restaurant       Restaurant prototype buy food   function          something here    Restaurant prototype use restroom   function          something here     That way users of my class can   var restaurant   new Restaurant    restaurant buy food    restaurant use restroom      How do I create a private method that can be called by the buy food and use restroom methods but not externally by users of the class   In other words  I want my method implementation to be able to do   Restaurant prototype use restroom   function        this private stuff        But this shouldn t work   var r   new Restaurant    r private stuff      How do I define private stuff as a private method so both of these hold true   I ve read Doug Crockford s writeup a few times but it doesn t seem like  private  methods can be called by public methods and  privileged  methods can be called externally

User · Answer

I have created a new tool to allow you to have true private methods on the prototype https://github.com/TremayneChrist/ProtectJS

Example:

var MyObject = (function () {

  // Create the object
  function MyObject() {}

  // Add methods to the prototype
  MyObject.prototype = {

    // This is our public method
    public: function () {
      console.log('PUBLIC method has been called');
    },

    // This is our private method, using (_)
    _private: function () {
      console.log('PRIVATE method has been called');
    }
  }

  return protect(MyObject);

})();

// Create an instance of the object
var mo = new MyObject();

// Call its methods
mo.public(); // Pass
mo._private(); // Fail

User · Answer

You can simulate private methods like this   function Restaurant        Restaurant prototype    function         var private stuff   function                Private code here             return            constructor Restaurant           use restroom function                 private stuff                             var r   new Restaurant        This will work  r use restroom        This will cause an error  r private stuff      More information on this technique here  http   webreflection blogspot com 2008 04 natural-javascript-private-methods html

User · Answer

What about this   var Restaurant    function       var  id   0   var privateVars         function Restaurant name         this id      id       this name   name       privateVars this id               cooked                  Restaurant prototype cook   function  food         privateVars this id  cooked push food        return Restaurant           Private variable lookup is impossible outside of the scope of the immediate function  There is no duplication of functions  saving memory   The downside is that the lookup of private variables is clunky privateVars this id  cooked is ridiculous to type  There is also an extra  id  variable

User · Answer

I know it s a bit too late but how about this   var obj   function        var pr    private       var prt   Object getPrototypeOf this       if  prt hasOwnProperty  showPrivate             prt showPrivate   function                console log pr                          var i   new obj    i showPrivate    console log i hasOwnProperty  pr

User · Answer

This is what I worked out   Needs one class of sugar code that you can find here  Also supports protected  inheritance  virtual  static stuff        function class Restaurant  namespace          use strict        if  namespace   Restaurant      return       protect against double inclusions          namespace Restaurant   Restaurant     var Static                 TidBits OoJs setupClass  namespace   Restaurant             constructor            function Restaurant                 this toilets   3          this Private  private stuff            return this Public  buy food  use restroom              function private stuff    console log   There are   this toilets   toilets available          function buy food         return  food               function use restroom     this private stuff          window     var chinese   new Restaurant  console log  chinese buy food               output  food console log  chinese use restroom           output  There are 3 toilets available console log  chinese toilets                output  undefined console log  chinese private stuff          output  undefined     and throws  TypeError  Object   lt Restaurant gt  has no method  private stuff

User · Answer

I conjured up this  EDIT  Actually  someone has linked to a identical solution  Duh   var Car   function        Car prototype    function         var hotWire   function                Private code  with  access to public properties through  this          alert  this drive         Alerts  Vroom              return           steal  function                 hotWire call  this       Call a private method                    drive  function                 return  Vroom                            var getAwayVechile   new Car     hotWire       Not allowed getAwayVechile hotWire       Not allowed getAwayVechile steal       Alerts  Vroom

User · Answer

The module pattern is right in most cases  But if you have thousands of instances  classes save memory  If saving memory is a concern and your objects contain a small amount of private data  but have a lot of public functions  then you ll want all public functions to live in the  prototype to save memory   This is what I came up with   var MyClass    function          var secret          You can only getPriv   if you know this     function MyClass             var that   this  priv                 foo  0        and other private values                    that getPriv   function  proof                return  proof     secret   amp  amp  priv                       MyClass prototype inc   function              var priv   this getPriv secret           priv foo    1          return priv foo             return MyClass        var x   new MyClass    x inc       1 x inc       2   The object priv contains private properties  It is accessible through the public function getPriv    but this function returns false unless you pass it the secret  and this is only known inside the main closure

User · Answer

Here s what i enjoyed the most so far regarding private public methods members and instantiation in javascript   here is the article  http   www sefol com  p 1090  and here is the example   var Person    function             Immediately returns an anonymous function which builds our modules      return function  name  location             alert  createPerson called with     name            var localPrivateVar   name           var localPublicVar    A public variable            var localPublicFunction   function                  alert  PUBLIC Func called  private var is      localPrivateVar                      var localPrivateFunction   function                  alert  PRIVATE Func called                        var setName   function  name                 localPrivateVar   name                      return                publicVar  localPublicVar               location  location               publicFunction  localPublicFunction               setName  setName                             Request a Person instance - should print  createPerson called with ben  var x   Person  ben    germany       Request a Person instance - should print  createPerson called with candide  var y   Person  candide    belgium       Prints  ben  x publicFunction       Prints  candide  y publicFunction       Now call a public function which sets the value of a private variable in the x instance x setName  Ben 2       Shouldn t have changed this   prints  candide  y publicFunction       Should have changed this   prints  Ben 2  x publicFunction      JSFiddle  http   jsfiddle net northkildonan kopj3dt3 1

User · Answer

In these situations when you have a public API  and you would like private and public methods properties  I always use the Module Pattern  This pattern was made popular within the YUI library  and the details can be found here   http   yuiblog com blog 2007 06 12 module-pattern   It is really straightforward  and easy for other developers to comprehend  For a simple example   var MYLIB   function           var aPrivateProperty   true      var aPrivateMethod   function                some code here               return           aPublicMethod   function                 aPrivateMethod       okay                some code here                       aPublicProperty   true                MYLIB aPrivateMethod      not okay MYLIB aPublicMethod      okay

User · Answer

All of this closure will cost you   Make sure you test the speed implications especially in IE  You will find you are better off with a naming convention  There are still a lot of corporate web users out there that are forced to use IE6

User · Answer

Old question but this is a rather simple task that can be solved properly with core JS    without the Class abstraction of ES6  In fact as far as i can tell  the Class abstraction do not even solve this problem  We can do this job both with the good old constructor function or even better with Object create    Lets go with the constructor first  This will essentially be a similar solution to georgebrock s answer which is criticised because all restaurants created by the Restaurant constructor will have the same private methods  I will try to overcome that limitation   x000D   x000D  function restaurantFactory name menu      function Restaurant name       this name   name         function prototypeFactory menu          This is a private function     function calculateBill item         return menu item     0               This is the prototype to be     return   constructor  Restaurant              askBill      function    items                               var cost   items reduce  total item    gt  total   calculateBill item   0                              return  Thank you for dining at     this name      Total is      cost     n                                           callWaiter   function                                return  I have just called the waiter at     this name     n                                                   Restaurant prototype   prototypeFactory menu      return new Restaurant name menu      var menu     water  1              coke   2              beer   3              beef   15              rice   2                   name    Silver Scooop       rest   restaurantFactory name menu    console log rest callWaiter     console log rest askBill  beer    beef     x000D   x000D   x000D   Now obviously we can not access menu from outside but we may easily rename the name property of a restaurant  This can also be done with Object create   in which case we skip the constructor function and simply do like  var rest   Object create prototypeFactory menu   and add the name property to the rest object afterwards like rest name   name

User · Answer

You can do this now with es10 private methods  You just need to add a   before the method name   class ClassWithPrivateMethod      privateMethod         return  hello world          getPrivateMessage         return  privateMethod

User · Answer

Using self invoking function and call JavaScript uses prototypes and does t have classes  or methods for that matter  like Object Oriented languages  A JavaScript developer need to think in JavaScript  Wikipedia quote   Unlike many object-oriented languages  there is no distinction between a function definition and a method definition  Rather  the distinction occurs during function calling  when a function is called as a method of an object  the function s local this keyword is bound to that object for that invocation   Solution using a self invoking function and the call function to call the private  quot method quot    var MyObject    function                Constructor   function MyObject foo        this  foo   foo         function privateFun prefix        return prefix   this  foo             MyObject prototype publicFun   function          return privateFun call this   quot  gt  gt  quot               return MyObject          var myObject   new MyObject  quot bar quot    myObject publicFun            Returns  quot  gt  gt bar quot  myObject privateFun  quot  gt  gt  quot       ReferenceError  private is not defined  The call function allows us to call the private function with the appropriate context  this   Simpler with Node js If you are using Node js  you don t need the IIFE because you can take advantage of the module loading system  function MyObject foo      this  foo   foo         function privateFun prefix      return prefix   this  foo     MyObject prototype publicFun   function        return privateFun call this   quot  gt  gt  quot           module exports  MyObject   Load the file  var MyObject   require  quot   MyObject quot         var myObject   new MyObject  quot bar quot    myObject publicFun            Returns  quot  gt  gt bar quot  myObject privateFun  quot  gt  gt  quot       ReferenceError  private is not defined   new   Native private methods in future JavaScript versions TC39 private methods and getter setters for JavaScript classes proposal is stage 3  That means any time soon  JavaScript will implement private methods natively  Note that JavaScript private class fields already exists in modern JavaScript versions  Here is an example of how it is used  class MyObject         Private field    foo         constructor foo        this  foo   foo          privateFun prefix       return prefix   this  foo             publicFun         return this  privateFun  quot  gt  gt  quot            You may need a JavaScript transpiler compiler to run this code on old JavaScript engines  PS  If you wonder why the   prefix  read this   deprecated  ES7 with the Bind Operator Warning  The bind operator TC39 proposition is near dead https   github com tc39 proposal-bind-operator issues 53 issuecomment-374271822 The bind operator    is an ECMAScript proposal and is implemented in Babel  stage 0   export default class MyObject     constructor  foo        this  foo   foo         publicFun          return this  privateFun  quot  gt  gt  quot           function privateFun  prefix      return prefix   this  foo

User · Answer

Class         Namespace ABC        Name  ClassL2         Bases  ABC ClassTop         Private             m var 2                Protected             proval 2            fight Property function                  this m var--                console log  ClassL2  fight  m var    this m var                Property Type Virtual                  Public             Fight function                  console log  ClassL2  Fight  m var   this m var                 this fight                                  https   github com nooning JSClass

User · Answer

In general I added the private Object   temporarily to the object  You have to open the privacy exlipcitly in the  Power-constructor  for the method  If you call the method from the prototype  you will be able to overwrite the prototype-method   Make a public method accessible in the  Power-constructor    ctx is the object context   ctx test   GD Fabric open  test   GD Test prototype  ctx         is a private object  Now I have this openPrivacy   GD Fabric openPrivacy   function func  clss  ctx           return function             ctx                var res   clss func  apply ctx  arguments           ctx     null          return res

User · Answer

Wrap all code in Anonymous Function  Then   all functions will be private  ONLY  functions attached  to window object      function w nameSpacePrivate        w Person function name            this name name              return this                w Person prototype profilePublic function              return nameSpacePrivate profile call this                   nameSpacePrivate profile function           return  My name is   this name              window        Use this       var abdennour new Person  Abdennour      abdennour profilePublic      FIDDLE

User · Answer

Personally  I prefer the following pattern for creating classes in JavaScript   var myClass    function            Private class properties go here      var blueprint   function                Private instance properties go here                         blueprint prototype                 Public class properties go here                         return                Public class properties go here         create   function     return new blueprint                                As you can see  it allows you to define both class properties and instance properties  each of which can be public and private   Demo  x000D   x000D  var Restaurant   function         var totalfoodcount   0            Private class property     var totalrestroomcount    0       Private class property          var Restaurant   function name           var foodcount   0             Private instance property         var restroomcount    0        Private instance property                  this name   name                  this incrementFoodCount   function                 foodcount                totalfoodcount                this printStatus                       this incrementRestroomCount   function                 restroomcount                totalrestroomcount                this printStatus                       this getRestroomCount   function                 return restroomcount                     this getFoodCount   function                 return foodcount                           Restaurant prototype             name               buy food   function               this incrementFoodCount                       use restroom   function               this incrementRestroomCount                       getTotalRestroomCount   function                 return totalrestroomcount                     getTotalFoodCount   function                 return totalfoodcount                     printStatus   function                document body innerHTML                     lt h3 gt Buying food at   this name   lt  h3 gt                      lt ul gt                       lt li gt Restroom count at     this name          this getRestroomCount       lt  li gt                      lt li gt Food count at     this name           this getFoodCount       lt  li gt                      lt li gt Total restroom count      this getTotalRestroomCount       lt  li gt                      lt li gt Total food count      this getTotalFoodCount       lt  li gt                      lt  ul gt                          return       Singleton public properties         create   function name                return new Restaurant name                      printStatus   function               document body innerHTML                    lt hr   gt                     lt h3 gt Overview lt  h3 gt                     lt ul gt                      lt li gt Total restroom count      Restaurant prototype getTotalRestroomCount       lt  li gt                     lt li gt Total food count      Restaurant prototype getTotalFoodCount       lt  li gt                     lt  ul gt                     lt hr   gt                           var Wendys   Restaurant create  Wendy s    var McDonalds   Restaurant create  McDonald s    var KFC   Restaurant create  KFC    var BurgerKing   Restaurant create  Burger King     Restaurant printStatus     Wendys buy food    Wendys use restroom    KFC use restroom    KFC use restroom    Wendys use restroom    McDonalds buy food    BurgerKing buy food     Restaurant printStatus     BurgerKing buy food    Wendys use restroom    McDonalds buy food    KFC buy food    Wendys buy food    BurgerKing buy food    McDonalds buy food     Restaurant printStatus    x000D   x000D   x000D   See also this Fiddle

User · Answer

ES2021   ES12 - Private Methods Private method names start with a hash   prefix and can be accessed only inside the class where it is defined  class Restaurant         private method    private stuff         console log  quot private stuff quot              public method   buy food         this  private stuff             const restaurant   new Restaurant    restaurant buy food        quot private stuff quot   restaurant private stuff       Uncaught TypeError  restaurant private stuff is not a function  This is an experimental proposal  ECMAScript 2021 version is expected to be released in June 2021

User · Answer

You have to put a closure around your actual constructor-function  where you can define your private methods  To change data of the instances through these private methods  you have to give them  this  with them  either as an function argument or by calling this function with  apply this     var Restaurant    function        var private buy food   function that           that data soldFood   true            var private take a shit   function            this data isdirty   true                  New Closure     function restaurant                 this data                 isdirty   false              soldFood  false                        restaurant prototype buy food   function                private buy food this             restaurant prototype use restroom   function                private take a shit call this             return restaurant           TEST   var McDonalds   new Restaurant    McDonalds buy food    McDonalds use restroom    console log McDonalds   console log McDonalds   proto

User · Answer

I think such questions come up again and again because of the lack of understanding of the  closures   losures is most important thing in JS  Every JS programmer have to feel the essence of it   1  First of all we need to make separate scope  closure    function           2  In this area  we can do whatever we want  And no one will know about it   function          var name          secretSkills                 pizza  function      return new Pizza                  sushi  function      return new Sushi                    function Restaurant  name            name    name           Restaurant prototype getFood   function  name            return name in secretSkills   secretSkills name      null           3  For the world to know about our restaurant class   we have to return it from the closure   var Restaurant    function             Restaurant definition     return Restaurant        4  At the end  we have   var Restaurant    function          var name          secretSkills                 pizza  function      return new Pizza                  sushi  function      return new Sushi                    function Restaurant  name            name    name           Restaurant prototype getFood   function  name            return name in secretSkills   secretSkills name      null           return Restaurant        5  Also  this approach has potential for inheritance and templating     Abstract class function AbstractRestaurant skills        var name     function Restaurant  name            name    name           Restaurant prototype getFood   function  name            return skills  amp  amp  name in skills   skills name      null           return Restaurant       Concrete classes SushiRestaurant   AbstractRestaurant        sushi  function     return new Sushi          PizzaRestaurant   AbstractRestaurant        pizza  function     return new Pizza          var r1   new SushiRestaurant  Yo  Sushi        r2   new PizzaRestaurant  Dominos Pizza    r1 getFood  sushi   r2 getFood  pizza     I hope this helps someone better understand this subject

User · Answer

The apotheosis of the Module Pattern  The Revealing Module Pattern  A neat little extension to a very robust pattern

User · Answer

I prefer to store private data in an associated WeakMap   This allows you to keep your public methods on the prototype where they belong   This seems to be the most efficient way to handle this problem for large numbers of objects   const data   new WeakMap     function Foo value        data set this   value          public method accessing private value Foo prototype accessValue   function         return data get this  value        private  method  accessing private value function accessValue foo        return data get foo  value     export  Foo

User · Answer

If you want the full range of public and private functions with the ability for public functions to access private functions  layout code for an object like this   function MyObject arg1  arg2             constructor code using constructor arguments        create access public variables as       this var1   foo       private variables    var v1    var v2       private functions   function privateOne            function privateTwon              public functions    MyObject prototype publicOne   function              MyObject prototype publicTwo   function

User · Answer

Take any of the solutions that follow Crockford s private or priviledged pattern  For example   function Foo x        var y   5      var bar   function             return y   x              this public   function z            return bar     x   z             In any case where the attacker has no  execute  right on the JS context he has no way of accessing any  public  or  private  fields or methods  In case the attacker does have that access he can execute this one-liner   eval  Foo       Foo toString   replace              this eval   function code    return eval code              Note that the above code is generic to all constructor-type-privacy  It will fail with some of the solutions here but it should be clear that pretty much all of the closure based solutions can be broken like this with different replace   parameters    After this is executed any object created with new Foo   is going to have an eval method which can be called to return or change values or methods defined in the constructor s closure  e g    f   new Foo 99   f eval  x    f eval  y    f eval  x   8      The only problem I can see with this that it won t work for cases where there is only one instance and it s created on load  But then there is no reason to actually define a prototype and in that case the attacker can simply recreate the object instead of the constructor as long as he has a way of passing the same parameters  e g  they are constant or calculated from available values    In my opinion  this pretty much makes Crockford s solution useless  Since the  privacy  is easily broken the downsides of his solution  reduced readability  amp  maintainability  decreased performance  increased memory  makes the  no privacy  prototype based method the better choice    I do usually use leading underscores to mark   private and  protected methods and fields  Perl style   but the idea of having privacy in JavaScript just shows how it s a misunderstood language    Therefore I disagree with Crockford except for his first sentence   So how do you get real privacy in JS  Put everything that is required to be private on the server side and use JS to do AJAX calls

User · Answer

You can do it  but the downside is that it can t be part of the prototype   function Restaurant         var myPrivateVar       var private stuff   function         Only visible inside Restaurant           myPrivateVar    I can set this here               this use restroom   function         use restroom is visible to all         private stuff               this buy food   function          buy food is visible to all         private stuff

User · Answer

Don t be so verbose  It s Javascript  Use a Naming Convention   After years of working in es6 classes  I recently started work on an es5 project  using requireJS which is already very verbose-looking   I ve been over and over all the strategies mentioned here and it all basically boils down to use a naming convention    Javascript doesn t have scope keywords like private  Other developers entering Javascript will know this upfront  Therefore  a simple naming convention is more than sufficient  A simple naming convention of prefixing with an underscore solves the problem of both private properties and private methods   Let s take advantage of the Prototype for speed reasons  but lets not get anymore verbose than that  Let s try to keep the es5  class  looking as closely to what we might expect in other backend  languages  and treat every file as a class  even if we don t need to return an instance   Let s demonstrate with a more realistic module situation  we ll use old es5 and old requireJs     my-tooltip js        define            tooltip             function          tooltip                 function MyTooltip                    Later  if needed  we can remove the underscore on some                of these  make public  and allow clients of our class                to set them              this  selector     my-tooltip              this  template    Hello from inside my tooltip                this  initTooltip                       MyTooltip prototype                 constructor  MyTooltip                initTooltip  function                      new tooltip tooltip this  selector                        content  this  template                      closeOnClick  true                      closeButton  true                                                      return               init  function init                    new MyTooltip         lt -- Our constructor adds our tooltip to the DOM so not much we need to do after instantiation                                You could instead return a new instantiation                  if later you do more with this class                              create  function create                    return new MyTooltip

User · Answer

An ugly solution but it works   x000D   x000D  function Class cb        const self            const constructor    fn    gt            func   fn                  const addPrivate    fnName  obj    gt            self fnName    obj             const addPublic    fnName  obj    gt            this fnName    obj          self fnName    obj          func prototype fnName    obj                 cb constructor  addPrivate  addPublic  self       return func     const test   new Class  constructor  private  public  self    gt        constructor function  test            console log test              public  test    yay        private  qwe    nay        private  no        gt            return  hello             public  asd        gt            return  this is public             public  hello        gt            return self qwe   self no     self asd             const asd   new test  qweqwe    console log asd hello     x000D   x000D   x000D

User · Answer

Private functions cannot access the public variables using module pattern

User · Answer

There are many answers on this question already  but nothing fitted my needs  So i came up with my own solution  I hope it is usefull for someone   function calledPrivate        var stack   new Error   stack toString   split   n        function getClass line           var i   line indexOf               var i2   line indexOf               return line substring i i2             return getClass stack 2    getClass stack 3       class Obj      privateMethode            if calledPrivate                 console log  your code goes here                        publicMethode            this privateMethode             var obj   new Obj    obj publicMethode      logs  your code goes here  obj privateMethode      does nothing   As you can see this system works when using this type of classes in javascript  As far as I figured out none of the methods commented above did

User · Answer

var TestClass   function           var privateProperty   42       function privateMethod              alert   privateMethod      privateProperty               this public             constructor  TestClass           publicProperty  88          publicMethod  function                  alert   publicMethod                 privateMethod                         TestClass prototype   new TestClass    public    var myTestClass   new TestClass      alert  myTestClass publicProperty    myTestClass publicMethod      alert  myTestClass privateMethod     no privateMethod       Similar to georgebrock but a little less verbose  IMHO  Any problems with doing it this way   I haven t seen it anywhere   edit  I realised this is kinda useless since every independent instantiation has its own copy of the public methods  thus undermining the use of the prototype

User · Answer

Since everybody was posting here his own code  I m gonna do that too     I like Crockford because he introduced real object oriented patterns in Javascript  But he also came up with a new misunderstanding  the  that  one   So why is he using  that   this   It has nothing to do with private functions at all  It has to do with inner functions    Because according to Crockford this is buggy code    Function Foo          this bar   0       var foobar function              alert this bar              So he suggested doing this   Function Foo          this bar   0      that   this       var foobar function              alert that bar             So as I said  I m quite sure that Crockford was wrong his explanation about that and this  but his code is certainly correct   Or was he just fooling the Javascript world  to know who is copying his code  I dunno   I m no browser geek  D  EDIT  Ah  that s what is all about  What does   39 var that   this   39  mean in JavaScript   So Crockie was really wrong with his explanation    but right with his code  so he s still a great guy

User · Answer

Here is the class which I created to understand what Douglas Crockford s has suggested in his site Private Members in JavaScript  function Employee id  name      Constructor       Public member variables     this id   id      this name   name        Private member variables     var fName      var lName      var that   this        By convention  we create a private variable  that   This is used to            make the object available to the private methods          Private function     function setFName pfname            fName   pfname          alert  setFName called                Privileged function     this setLName   function  plName  pfname            lName   plName     Has access to private variables         setFName pfname     Has access to private function         alert  setLName called     this id     Has access to member variables             Another privileged member has access to both member variables and private variables       Note access of this dataOfBirth created by public member setDateOfBirth     this toString   function              return  toString called     this id         this name         fName         lName         this dataOfBirth             Public function has access to member variable and can create on too but does not have access to private variable Employee prototype setDateOfBirth   function  dob        alert  setDateOfBirth called     this id       this dataOfBirth   dob      Creates new public member note this is accessed by toString       alert fName     Does not have access to private member     document  ready         var employee   new Employee 5   Shyam      Create a new object and initialize it with constructor     employee setLName  Bhaskar    Ram       Call privileged function     employee setDateOfBirth  1 1 2000       Call public function     employee id   9                        Set up member value       employee setFName  Ram       can not call Private Privileged method     alert employee toString        See the changed object

[javascript] JavaScript private methods

Examples related to javascript

Examples related to oop

Examples related to private-methods