Easy way to make “cheap” Private in JS

In general, a way to create class members that will not be accessible from the outside, exists in JavaScript and is called a closure. But with this approach, there is one serious drawback - many instances of the same function are created, which is not good for resources.

I pondered a little how to make everything simple and efficient at the same time. First, I found a solution that saves resources rather than eliminates “overspending”. Here it is:

var Class_privateMethod = function (_this_privateVar) { alert(_this_privateVar); return null ; } var Class_publicMethod = function (_this_privateVar) { return Class_privateMethod.call( this , _this_privateVar); } var Class = function () { var privateVar = 'Hello, world!' ; this .publicMethod = function () { return Class_publicMethod.call( this , privateVar); } } * This source code was highlighted with Source Code Highlighter .

1. var Class_privateMethod = function (_this_privateVar) { alert(_this_privateVar); return null ; } var Class_publicMethod = function (_this_privateVar) { return Class_privateMethod.call( this , _this_privateVar); } var Class = function () { var privateVar = 'Hello, world!' ; this .publicMethod = function () { return Class_publicMethod.call( this , privateVar); } } * This source code was highlighted with Source Code Highlighter .
2. var Class_privateMethod = function (_this_privateVar) { alert(_this_privateVar); return null ; } var Class_publicMethod = function (_this_privateVar) { return Class_privateMethod.call( this , _this_privateVar); } var Class = function () { var privateVar = 'Hello, world!' ; this .publicMethod = function () { return Class_publicMethod.call( this , privateVar); } } * This source code was highlighted with Source Code Highlighter .
3. var Class_privateMethod = function (_this_privateVar) { alert(_this_privateVar); return null ; } var Class_publicMethod = function (_this_privateVar) { return Class_privateMethod.call( this , _this_privateVar); } var Class = function () { var privateVar = 'Hello, world!' ; this .publicMethod = function () { return Class_publicMethod.call( this , privateVar); } } * This source code was highlighted with Source Code Highlighter .
4. var Class_privateMethod = function (_this_privateVar) { alert(_this_privateVar); return null ; } var Class_publicMethod = function (_this_privateVar) { return Class_privateMethod.call( this , _this_privateVar); } var Class = function () { var privateVar = 'Hello, world!' ; this .publicMethod = function () { return Class_publicMethod.call( this , privateVar); } } * This source code was highlighted with Source Code Highlighter .
5. var Class_privateMethod = function (_this_privateVar) { alert(_this_privateVar); return null ; } var Class_publicMethod = function (_this_privateVar) { return Class_privateMethod.call( this , _this_privateVar); } var Class = function () { var privateVar = 'Hello, world!' ; this .publicMethod = function () { return Class_publicMethod.call( this , privateVar); } } * This source code was highlighted with Source Code Highlighter .
7. var Class_privateMethod = function (_this_privateVar) { alert(_this_privateVar); return null ; } var Class_publicMethod = function (_this_privateVar) { return Class_privateMethod.call( this , _this_privateVar); } var Class = function () { var privateVar = 'Hello, world!' ; this .publicMethod = function () { return Class_publicMethod.call( this , privateVar); } } * This source code was highlighted with Source Code Highlighter .
8. var Class_privateMethod = function (_this_privateVar) { alert(_this_privateVar); return null ; } var Class_publicMethod = function (_this_privateVar) { return Class_privateMethod.call( this , _this_privateVar); } var Class = function () { var privateVar = 'Hello, world!' ; this .publicMethod = function () { return Class_publicMethod.call( this , privateVar); } } * This source code was highlighted with Source Code Highlighter .
9. var Class_privateMethod = function (_this_privateVar) { alert(_this_privateVar); return null ; } var Class_publicMethod = function (_this_privateVar) { return Class_privateMethod.call( this , _this_privateVar); } var Class = function () { var privateVar = 'Hello, world!' ; this .publicMethod = function () { return Class_publicMethod.call( this , privateVar); } } * This source code was highlighted with Source Code Highlighter .
10. var Class_privateMethod = function (_this_privateVar) { alert(_this_privateVar); return null ; } var Class_publicMethod = function (_this_privateVar) { return Class_privateMethod.call( this , _this_privateVar); } var Class = function () { var privateVar = 'Hello, world!' ; this .publicMethod = function () { return Class_publicMethod.call( this , privateVar); } } * This source code was highlighted with Source Code Highlighter .
12. var Class_privateMethod = function (_this_privateVar) { alert(_this_privateVar); return null ; } var Class_publicMethod = function (_this_privateVar) { return Class_privateMethod.call( this , _this_privateVar); } var Class = function () { var privateVar = 'Hello, world!' ; this .publicMethod = function () { return Class_publicMethod.call( this , privateVar); } } * This source code was highlighted with Source Code Highlighter .
13. var Class_privateMethod = function (_this_privateVar) { alert(_this_privateVar); return null ; } var Class_publicMethod = function (_this_privateVar) { return Class_privateMethod.call( this , _this_privateVar); } var Class = function () { var privateVar = 'Hello, world!' ; this .publicMethod = function () { return Class_publicMethod.call( this , privateVar); } } * This source code was highlighted with Source Code Highlighter .
14. var Class_privateMethod = function (_this_privateVar) { alert(_this_privateVar); return null ; } var Class_publicMethod = function (_this_privateVar) { return Class_privateMethod.call( this , _this_privateVar); } var Class = function () { var privateVar = 'Hello, world!' ; this .publicMethod = function () { return Class_publicMethod.call( this , privateVar); } } * This source code was highlighted with Source Code Highlighter .
15. var Class_privateMethod = function (_this_privateVar) { alert(_this_privateVar); return null ; } var Class_publicMethod = function (_this_privateVar) { return Class_privateMethod.call( this , _this_privateVar); } var Class = function () { var privateVar = 'Hello, world!' ; this .publicMethod = function () { return Class_publicMethod.call( this , privateVar); } } * This source code was highlighted with Source Code Highlighter .
16. var Class_privateMethod = function (_this_privateVar) { alert(_this_privateVar); return null ; } var Class_publicMethod = function (_this_privateVar) { return Class_privateMethod.call( this , _this_privateVar); } var Class = function () { var privateVar = 'Hello, world!' ; this .publicMethod = function () { return Class_publicMethod.call( this , privateVar); } } * This source code was highlighted with Source Code Highlighter .

var Class_privateMethod = function (_this_privateVar) { alert(_this_privateVar); return null ; } var Class_publicMethod = function (_this_privateVar) { return Class_privateMethod.call( this , _this_privateVar); } var Class = function () { var privateVar = 'Hello, world!' ; this .publicMethod = function () { return Class_publicMethod.call( this , privateVar); } } * This source code was highlighted with Source Code Highlighter .

')
Here we save resources due to the fact that the function created each time in the constructor consists of just one line - calling the real method body. But the functions continue to multiply; they have become smaller.

How else can private members be implemented? You can put them in the element of a global array created for each object. But the object must somehow be identified. But you cannot make such an identifier in the form of an object field — the field can be changed (and we remind you, we are trying to close the methods — otherwise you can simply define for them a prefix like l_privateMethod and calm down). The object does not have any unique characteristics, except for the address in memory and / or numbers in the interpreter list, and we cannot access these characteristics. The object can not be an index in the array ... or stop! Maybe if it's a Number object! Thus, we come to a very simple but effective solution:

1. var ObjectServer = function ()
2. {
3. var objects = new Array (), CURRENT_ID = 1;
5. var result = function (_id)
6. {
7. if (! (_ id instanceof Number))
8. {
9. return ;
10. }
11. if (objects [_id] .external! = _id)
12. {
13. return ;
14. }
15. return objects [_id];
16. }
18. result.create = function (_class)
19. {
20. var object = new _class ();
21. object .external = new Number (CURRENT_ID);
22. for ( var key in _class.external)
23. {
24. object .external [key] = _class.external [key];
25. }
26. objects [CURRENT_ID ++] = object ;
27. return object .external;
28. }
30. result.destroy = function (_id)
31. {
32. if (! (_ id instanceof Number))
33. {
34. return ;
35. }
36. if (objects [_id] .external! = _id)
37. {
38. return ;
39. }
40. delete objects [_id];
41. }
43. return result;
44. }
46. var objs = ObjectServer ();

* This source code was highlighted with Source Code Highlighter .

Now real objects are stored in the objects array of the object server, and only the public (external) part is given to the outside. To create an object based on the class constructor function, you need to write objs.create, to delete - objs.destroy (by the way, there is a great opportunity to include destructors here, if you modify the solution a bit - the link to the object will be stored in the array until we obviously not delete). To access the closed part of the object, you need to use the objs function itself:

objs(myObject).privateMember;

External methods are declared as members of the external subobject as well as closed ones as members of the prototype subobject. The only restriction is that the constructor should not have parameters; you cannot write new constructor.call (...).

Here is how you can use this mechanism to implement a module:

1. var global = this ;
3. ( function () {
5. var objs = ObjectServer (); // The ObjectServer function is defined somewhere outside.
7. var Class = function ()
8. {
9. this .privateVar = 'I \' ma private variable. ' ;
10. }
12. Class.prototype.privateMethod = function ()
13. {
14. alert ( this .privateVar);
15. alert ( this .external.publicPrimitiveVar);
16. this .external.publicCompoundVar.push ( this .privateVarDefinedInConstructor);
17. alert ( this .external.publicCompoundVar);
18. }
20. Class.external = new Object ();
22. Class.external.publicPrimitiveVar = 10;
24. Class.external.publicMethod = function ()
25. {
26. objs ( this ). privateMethod ();
27. objs ( this ). privateVar = 'Changed!' ;
28. objs ( this ). privateMethod ();
29. }
31. global.Class = function (_arg)
32. {
33. var result = objs.create (Class);
34. result.publicCompoundVar = new Array ( 'a' , 'b' , 'c' );
35. objs (result). privateVarDefinedInConstructor = _arg;
36. return result;
37. }
39. }) ();
41. var object1 = Class ( 'd' );
42. var object2 = Class ( 'e' );
43. object2.publicPrimitiveVar = 50;
44. object1.publicMethod ();
45. object2.publicMethod ();
46. alert (object1.privateMethod);
47. object2 = new Number (object2 * 1);
48. object2.publicMethod ();

* This source code was highlighted with Source Code Highlighter .

Calling from the outside global.Class (or simply Class is the name of the global space) we get the public interface of the class, while the closed interface will remain only in the annals of the object server - see for yourself alert (object1.privateMethod); will display undefined. The main thing to remember is to define the server of objects inside the module so that it is not accessible from the outside. The server creation function can be defined once somewhere outside the set of utilitarian functions. And you can not be afraid that someone will override the object number - the server will refuse such a request (see the last two drains).

I hope that the method will be useful to you, since it is as simple as a penny and allows you not to waste memory and time in vain (well, except for function pointers). If someone modifies it, so that you can do more and protected members for the roll between different modules, then it will be generally wonderful. Well, I bow to this! Thank you for your attention!

UPD 02.12.09

With the help of such a modification, you can make constructor functions with parameters (ie, objs.create (Class, 10, 20)):

1. ObjectServer.create = function (_class)
2. {
3. var constructor = new Function ();
4. constructor.prototype = _class.prototype;
5. var object = new constructor ();
6. object .constructor = _class;
7. object .external = new Number ( this .CURRENT_ID);
8. for ( var key in _class.external)
9. {
10. object .external [key] = _class.external [key];
11. }
12. this .objects [ this .CURRENT_ID ++] = object ;
13. _class.apply ( object , Array.prototype.slice.call (arguments, 1));
14. return object .external;
15. }

* This source code was highlighted with Source Code Highlighter .

UPD 02.12.09

Thanks dsCode for the advice, I corrected the lack of a library in terms of copying external methods. Now the gain in comparison with the standard time solution is about 6000% on the same test (see comments): ^) (0.864 versus 0.013, i.e. ~ 60 times). The library can be found here:
JOS library
example
PS Now you need to remember two more keywords: external and id. They should not be used as object field identifiers.