JavaScript's public, private and privileged modes_javascript tips

Summary
Private variables are declared inside the object using the 'var' keyword, and it can only be accessed by private functions and privileged methods.
Private functions are declared in the object's constructor (or defined through var functionName=function(){...}). They can be called by privileged functions (including the object's constructor) and private functions.
Privileged methods are declared via this.methodName=function(){...} and may be called by code outside the object. It can use: this.privileged function() method to call privileged functions, and use: private function() method to call private functions.
Public properties are defined through this.variableName and are readable and writable outside the object. Cannot be called by private functions.
Public methods are defined by ClassName.prototype.methodName=function(){...} and can be called from outside the object.
Prototype properties are defined by ClassName.prototype.propertyName=someValue.
Static properties are defined by ClassName.propertyName=someValue.
Also pay attention to this writing method: var function name = function function name () {...} This function has the characteristics of a privileged function and a private function when it is called.
Example:

Copy code The code is as follows:

< ;div onclick="start()" style="color:blue">click me

JavaScript It is the most misunderstood programming language in the world. Some argue that it lacks information hiding features because JavaScript objects cannot have methods on private variables.
But this is a misunderstanding. JavaScript objects can have private members.
Objects
JavaScript is fundamentally about objects. Arrays are objects, methods are objects, and Objects are also objects. What is an object? An object is a collection of key-value pairs. Keys are strings and
values ​​can be strings, numbers, booleans and objects (including arrays and methods). Objects are usually implemented as Hashtables so that values ​​can be retrieved quickly.
If the value is a function, I can call it a method. When an object's method is called, the "this" variable is assigned to the object. Methods can access instance
variables through the "this" variable.
Objects can be generated by the method of initializing objects - the constructor. Constructors provide features that classes provide in other programming languages, including static variables and methods.
Public
The members of the object are all public members. Any object can access, modify, delete these members or add new members. There are two main ways to place members in a new object:
In the constructor
This technique is usually used to initialize public instance variables. The "this" variable of the constructor is used to add members to the object.
Java code

Copy code The code is as follows:

functin Container(param) {
this.member = param;
}
functin Container(param) {
this.member = param;
}

In this way, if we construct a new Object var myContainer = new Container('abc'), then myContainer.member is 'abc'.
In prototype
This technique is usually used to add public methods. When looking for a member and it is not in the object itself, it is found in the prototype member of the object's constructor.
The prototype mechanism is used for inheritance. To add a method to all objects created by the constructor, just add to the constructor's prototype:
Java code

Copy code The code is as follows:

Container.prototype.stamp = function (string) {
return this.member string;
}
Container.prototype.stamp = function (string) {
return this. member string;
}

In this way, we can call the method myContainer.stamp('def'), and the result is 'abcdef'.
Private
Private members are generated by the constructor. Ordinary var variables and constructor parameters are called private members.
Java code

Copy code The code is as follows:

function Container(param) {
this.member = param;
var secret = 3;
var that = this;
}
function Container(param) {
this.member = param;
var secret = 3;
var that = this;
}

The constructor creates 3 private instance variables: param, secret and that. They are added to the object, but cannot be accessed externally, nor by the object's own
public methods. They can only be accessed by private methods. Private methods are internal methods of the constructor.
Java code

Copy code The code is as follows:

function Container(param) {
function dec() {
if (secret > 0) {
secret -= 1;
return true;
} else {
return false;
}
}
this.member = param;
var secret = 3;
var that = this;
}
function Container(param) {
function dec() {
if (secret > 0) {
secret -= 1;
return true;
} else {
return false;
}
}
this.member = param;
var secret = 3;
var that = this;
}

Private method dec checks the secret instance variable. If it is greater than 0, decrement the secret and return true, otherwise return false. It can be used to limit the use of this object to 3 times.
As usual, we define a private that variable. This is used to make this object available to private methods. This is done because there is a bug in the ECMAScript language specification.
This bug prevents the correct setting of this to internal methods.
Private methods cannot be called by public methods. In order to make private methods useful, we need to introduce privileged methods.
Privileged
The privileged method can access private variables and methods, and it can itself be accessed by public methods and the outside world. A privileged method can be removed or replaced, but it cannot
be changed or forced to reveal its secrets.
Privileged methods are allocated using this in the constructor.
Java code

Copy code The code is as follows:

function Container(param) {
function dec() {
if (secret > 0) {
secret -= 1;
return true;
} else {
return false;
}
}
this.member = param;
var secret = 3;
var that = this;
this.service = function() {
if (dec()) {
return that.member;
} else {
return null;
}
};
}
function Container(param) {
function dec() {
if (secret > 0) {
secret -= 1;
return true;
} else {
return false;
}
}
this.member = param;
var secret = 3;
var that = this;
this.service = function() {
if (dec()) {
return that.member;
} else {
return null;
}
};
}

service is a privileged method. The first three calls to myContainer.service() will return 'abc'. After that it will return null. The service calls the private dec method, and the
dec method accesses the private secret variable. Service is visible to other objects and methods, but it does not allow direct access to private variables.
Closures
Since JavaScript has closures, the pattern of public, private and privileged members is possible. This means that an inner method can always access its outer method's
var variables and parameters, even after the outer method returns. This is a very powerful feature of the JavaScript language. There are currently no JavaScript
programming books that show how to exploit this feature, and most don't even mention it.
Private and privileged members can only be generated when the object is constructed. Public members can be added at any time.
Mode
public
Java code

Copy code The code is as follows:

function Constructor(...) {
this.membername = value;
}
Constructor.prototype.membername = value;
function Constructor(...) {
this.membername = value;
}
Constructor.prototype.membername = value;

Private
Java code

Copy code The code is as follows:

function Constructor( ...) {
var that = this;
var membername = value;
function membername(...) {...}
}
// Note: function statement
// function membername(...) {...}
// is the abbreviation of the following code
// var membername = function membername(...) {...};
function Constructor(...) {
var that = this;
var membername = value;
function membername(...) {...}
}
// Note: function statement
// function membername(...) {...}
// is the abbreviation of the following code
// var membername = function membername(...) {...};

Privileged
Java code

Copy code The code is as follows:

function Constructor(...) {
this.membername = function (...) {...};
}
function Constructor(...) {
this. membername = function (...) {...};
}

Translator’s Note: I think the privileged method can simply be regarded as a public method in the constructor , because the privileged method can be accessed by the outside world and public methods,
and it itself can access private variables.