What is a private member in Javascript

Private members must be generated by the constructor. This constructor has three private instance variables: param, secret, and self. They are attached to the object, but they are not accessible from the outside, nor can they be accessed by the object's public methods. They are only visible to private members.

The operating environment of this tutorial: windows7 system, javascript version 1.8.5, Dell G3 computer.

JavaScript is the most misunderstood language in the world. Many people believe that it lacks information hiding features so objects cannot have private instance variables and methods. But this is a misunderstanding. JavaScript objects can also have private variables. Let’s explain it below:

Object

JavaScript is fundamentally about objects (Object). Array is an object, function is an object, and Object will not be mentioned. So what is an object? An object is a collection of name-value pairs. Names are strings and values ​​can be strings, numbers, booleans, and objects (including arrays and functions). Objects are often implemented as hash tables to quickly access values.

If a value is a function, we can treat it as a method. When a method on an object is called, the this variable is set to that object. This method allows you to access instance variables through this variable.

The object is generated by the constructor, which is the function that initializes the object. Constructors provide features that classes in other languages ​​provide, including static methods and variables.

Public members

The members of the object are all public public members. Any function can access, modify, or delete these members. There are two main ways to add members to a new object:

In the constructor

This technique is generally used to initialize public instance variables. The this variable of the constructor is used to add members to the object.

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

In this way, if we construct a new object

var myContainer = new Container('abc');

then myContainer.member will contain 'abc'.

In prototype

This technique is generally used to add public methods. When a member is retrieved and is not found in the object, it is obtained from the prototype member of the object's constructor. This prototype mechanism can be used to implement inheritance. It also saves memory. To add a method to all objects generated by a constructor, add the function to the prototype of the constructor:

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

In this way, we can call this method

myContainer.stamp('def')

It will return 'abcdef'.

Private members

Private members must be generated by the constructor. Ordinary var variables and parameters in the constructor become private members.

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

This constructor has three private instance variables: param, secret, and self. They are attached to the object, but they are not accessible from the outside, nor can they be accessed by the object's public methods. They are only visible to private members. Private methods are functions inside the constructor.

function Container(param) {

	function dec() {
		if (secret > 0) {
			secret -= 1;
			return true;
		} else {
			return false;
		}
	}

	this.member = param;
	var secret = 3;
	var self = this;
}

Private method dec checks the secret instance variable. If it is greater than 0, reduce the secret size and return true. Otherwise it returns false . This limits the object to three uses.

By convention, we give a private self parameter. This makes the object visible to private methods. This practice is due to a bug in the ECMAScript Language Specification that prevents this from being set correctly for internal functions.

Private methods cannot be called by public methods. To make private methods useful, we need to introduce a privileged method.

Privileged members

A privileged A privileged method can access private variables and methods, while it is visible to the public domain. You can also delete or replace a privileged method, but you cannot change it.

Privileged methods are assigned in the constructor using this.

function Container(param) {

	function dec() {
		if (secret > 0) {
			secret -= 1;
			return true;
		} else {
			return false;
		}
	}

	this.member = param;
	var secret = 3;
	var self = this;

	this.service = function () {
		if (dec()) {
			return self.member;
		} else {
			return null;
		}
	};
}

service is a privileged method. The first three calls will return 'abc'. After that, it returns null. The private dec method called by the service, and dec accesses the private secret variable. The service is visible to other objects and methods, but cannot directly access private members.

Closure

The reason this pattern of public, private, and privileged members is possible is because JavaScript has closures. This means that an inner function can always access the variables and parameters outside the function, even after the outer function returns. This is an extremely powerful feature of the language. No current book on JavaScript programming shows how to exploit this feature. Most are not mentioned.

Private and privileged members can only be generated during object construction. Public members can be added at any time.

Mode

Public(Public)

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

Private(Private)

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

Note that the actual function statement

function  membername(...)  {...}

is as follows The abbreviation of the statement, both are the same:

var  membername = function  membername(...)  {...};

Privileged

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

[Recommended learning: javascript advanced tutorial]

The above is the detailed content of What is a private member in Javascript. For more information, please follow other related articles on the PHP Chinese website!