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.

npm install private-js
8 downloads in the last week
16 downloads in the last month

Private.JS

Introduction

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).

Documentation

You can find the documentation here.

Example

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

License

Creative Commons Attribution-ShareAlike 3.0 Unported License

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.

npm loves you