JavaScript creates examples of private functions and variables

They firmly believe that if you create a Property object, or create a three-dimensional global variable, this is a fair game for anyone. However, with some very simple patterns, you can use JavaScript to protect the privacy of accessing a given object or variable!

Classes

You may know that there is no real class in JavaScript, but using features and prototypes, we can simulate very well. Using this pattern, you can also simulate private variables:

Function myclass (parameter)  {    // create the private var     var privatevar = 8,         self

 = this;     self.parameter = parameter     // function that  handles the private     function handleprivate ()  {  

      return privateVar ? privateVar-- :  false;     }     // public method that calls the  handler     // returns parameter until it ' s been  Accessed 8 times     this.getprivate ()  {      

  return handleprivate ()  ? self.parameter : null;  &nbsP; &NBSP}} 

Private creation is accessed by building functions, and only by building functions, by adding special access methods to access private properties, in which the value is accessed only through a specific method.

Closures

The pattern closes around a variable range, returning an object or function to access the variable. This is a simple example:

var accessor =  (function ()  {    //  create the private var     var privateVar =  "you 
Can ' t see me,  ';          // some other functionality here that
 periodically changes privatevar, because it has access to it     // [ MORE CODE HERE&NBSP]        
  // return the accessor     return function (name)  {
        return privateVar + name;
    };
})();
 use!  currentvalue = accessor ("David");   "You can ' T see me, david" 

Privatevar variables cannot be closed externally, so there is no way to access them directly. We do this, however, to be able to change back from the closure there is a definition function. Therefore, the variable remains private and you can access its value, but not direct access. You can also return a method to modify a protected object variable:

var accessor = (function () {

//The "private"

var val = 9;

//An object for getting and setting return

{

get:function () {return

val *        3;

},

set:function (s) {

val = s;

}

};

}) ();

Of course, the above pattern allows users to regain a similar approach:

accessor = function (n) {return "My custom string," + N;}

Usually all the features that handle private information are closed, preventing users from rewriting the method's problem. Something like this:

var accessor =  (function ()  {         var 

permissions = {};          function handleresult (Perm)  {         // do something with the result     

}          return function (permissiontocheck, callback)  {         if (Permissions[permissiontocheck])  != undefined)  {            callback (permissions[

Permissiontocheck]);

        }         else {             $.post ({                 url:  " /permissions "                 data: {                     perm: permissiontocheck                  }             &NBSP}). Success (function (res)  {            

    callback (Handleresult (res));

            });

        }     };     }) ();

In JavaScript simplicity must be beautiful, do not write it down because it does not provide the same explicit structure for other languages