private-js

Clean 'private' support for JavaScript. This library contains classes and utilities that will allow you to add 'privates' to your JavaScript classes in a clean, spec-compliant way. This library will work both within a browser environment and node.js. It was created in order to make it easier for a distributed team of developers to handle privates in a consistent way. The library is based on JavaScript prototypes in order to avoid repetitive creation of functions.

Private.JS

What is private.js?

Private.js is a JavaScript library that allows you to work with 'private' variables and methods withing JavaScript classes. The library is compatible with browsers and server-side javascript (for example node.js).

The library respects the following best-practices/conventions:

  • Adheres to 'use strict'.
  • Uses prototypes - does NOT re-create methods per instance.
  • Is fully documented with JSDoc and a MarkDown reference.
  • Follows the _underscore notation convention for private variables in JavaScript
  • Exposes a DSL for convenience.
  • Respects 'this' contract even within private scope.
  • Fully unit-tested (using nodeunit).

You can find the documentation here.

As nothing can tell you more than an example, here is one:

var Private = require('private').Private;

// If using Node.JS only:
// var util = require('util'); // Node.JS only

var MyClass = function(){

    Private.call(this); // Extend the Private class (and call the super constructor).

    // Initialize a private variable. This corresponds to this._privates
    Private(this).setValue('Some private value');

};
MyClass.prototype = Object.create(Private.prototype); // Extend the prototype

// Or using Node.JS style:
// util.inherits(MyClass, Private);

// Public getValue method with access to private variables (style 1):

MyClass.prototype.getValue = Private.hasAccess(function(privates){
    return privates.myValue;
});

// Invocation of the getValue method is transparent (as the privates are injected):
MyClass.prototype.toString = function(){

    // Invoke the getValue method - without parameters!
    return this.getValue();
};

// Or, the alternative - without parameter injection (style 2):
MyClass.prototype.getValue2 = function(){

    // Or access the private value directly, through Private(...).
    return Private(this).myValue;
};

// Declare the Private method setValue:
MyClass.prototype.privateMethod('setValue',function(privates, value){
    privates.myValue = value;
});

// Private method toJSON:
MyClass.prototype.privateMethod('toJSON', function(privates){

    // Note that 'this' within this context is the instance of MyClass, NOT the privates.
    return JSON.stringify(this); // JSON stringification will NOT include the privates.
});

Copyright (C) 2012 by Daan Kets, Blackbit Consulting

This library by Daan Kets - Blackbit Consulting is licensed under a Creative Commons Attribution-ShareAlike 3.0 Unported License. You may use this library even within a commercial product as long as you attribute to the original source. You may created derived work as long as you give back your modifications to the orignal source.