JavaScript private member analysis_javascript skills

Object
JavaScript operations are all about objects. Array is an object and function is an object. Object (type) is an object. So what is an object? Objects are name-value pairs. The name is a string and the value can be a string, numeric value, boolean, or object (including arrays and functions). Objects are often implemented using hash tables, so values ​​can be retrieved very quickly.
If a value of the object is a function, we can think of it as a member function. When the member function is called, the this variable will point to the object. Member functions can access the members of the object through the this variable.
Objects can be generated through a constructor, which is a function that initializes an object. The constructor here plays the role of "class" in other languages, and also provides a means to define static variables and methods.
Public members
All members of the object are public members, and anyone can read, write, and even delete these members or add new members. There are two ways to add new members:
Add
in the constructor. This is usually used to initialize public member variables. Use the this variable of the constructor to add members to the object.
function Container(param)
{ this.member = param;}
Use the following line of code to generate an object instance
var myContainer = new Container('abc');
myContainer The member member value is 'abc'.
Add
to the prototype This method is often used to add public member functions. When the Javascript interpreter encounters a member of an object and finds that the member does not exist in the object itself, it will look for it in the prototype of the object's constructor. The prototype mechanism can be used to implement inheritance. It also takes up memory. If you want to add a method to all objects generated by a certain constructor, just add this method to the prototype of the object.
Container.prototype.stamp = function (string) { return this.member string;}
This way you can call this member function
myContainer.stamp('def')
Return value 'abcdef' .
Private members
Private members are generated in the constructor. Variables defined by var and constructor parameters will become private members.
function Container(param){
this.member = param;
var secret = 3;
var that = this;
}
This constructor defines three private variables : param, secret and self. They are properties of the object Container, and they cannot be accessed by code outside the object or by the object's public methods.
Only private methods can be accessed. Private methods are functions defined within the constructor.
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 value of the instance variable secret, if it is greater than 0 Decrements its value and returns true; otherwise it returns false.
It can be used to limit this object to only being used 3 times.
According to the protocol, we define a private variable that to allow private methods to access the object itself.
This is a workaround solution. The fundamental reason for needing it is an error in the ECMAscrīpt language specification, and this error causes the this variable of the internal function to have
errors. (Honker: It seems that it doesn’t matter if you don’t use that. Maybe the original article was written too early. Has any expert encountered this problem?)
Private methods cannot be called by public methods. To make private functions useful, we need to introduce the concept of privileged methods.
Privileges
A privileged method can access private variables and methods, and it can itself be accessed by public methods and externally. You can remove or replace a privileged method but you cannot change it or force it to give up its secrets.
Privileged methods are defined in the constructor through 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;
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 which 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 functions, but we cannot directly access private members.
Closure
Because of me with closure, the writing of these public, private and privileged methods is possible. It means that an inner function can always access the variables and parameters defined by its outer function. Even if the outer function has returned. This is an extremely powerful feature of Javascript. There is currently no Javascript programming book that talks about how to use it, and most of them don't mention it.
Private and privileged members can only be generated when the object is constructed. Public members can be added at any time.
写法
Public
function Constructor(...) {
this.membername = value;
}
Constructor.prototype.membername = value;
Private
function Constructor(...) {
var that = this;
var membername = value;
function membername(...) {...}
}
Note: The function statement
function membername(...) {...}
is shorthand for
var membername = function membername(...) {...};
Privileged
function Constructor(...) {
this.membername = function (...) {...};
}