A lightweight class system. It's just prototypes!


P.js is a lightweight layer over javascript's built-in inheritance system that keeps all the good stuff and hides all the crap.


// adapted from coffeescript.org 
// P.js exposes the `P` variable 
var Animal = P(function(animal) {
  animal.init = function(name) { this.name = name; };
  animal.move = function(meters) {
    console.log(this.name+" moved "+meters+"m.");
var Snake = P(Animal, function(snakeanimal) {
  snake.move = function() {
    animal.move.call(this, 5);
var Horse = P(Animal, function(horseanimal) {
  horse.move = function() {
    animal.move.call(this, 45);
var sam = Snake("Sammy the Python")
  , tom = Horse("Tommy the Palomino")

Most class systems for JS let you define classes by passing an object. P.js lets you pass a function instead, which allows you to closure private methods and macros. It's also <0.4kb minified (make report: 478).

Unlike some other frameworks out there, Pjs doesn't do any of this:

  • interfaces, abstract static factory factories, and other bloat
  • use Object.create (it even works in IE < 8!)
  • break instanceof
  • hack functions onto this at runtime
  • rely on magical object keys which don't minify (the only special name is init)
  • inheritable constructors (via the optional init method)
  • closure-based "private" methods (see below)
  • easily call super on public methods without any dirty hacks
  • instantiate your objects without calling the constructor (absolutely necessary for inheritance)
  • construct objects with variable arguments

You can call P in a few different ways:

// this defines a class that inherits directly from Object. 
P(function(protosuperclasssuperclass) {
  // define private methods as regular functions that take 
  // `self` (or `me`, or `it`, or anything you really want) 
  function myPrivateMethod(selfarg1arg2) {
    // ... 
  proto.init = function() {
    myPrivateMethod(this, 1, 2)
  // you can also return an object from this function, which will 
  // be merged into the prototype. 
  return { thing: 3 };
// this defines a class that inherits from MySuperclass 
P(MySuperclass, function(protosuperclasssuperclass) {
  proto.init = function() {
    // call superclass methods with super.method.call(this, ...) 
    //                           or super.method.apply(this, arguments) 
// for shorthand, you can pass an object in lieu of the function argument, 
// but you lose the niceness of super and private methods. 
P({ initfunction(a) { this.thing = a } });
MyClass = P(function(p) { p.init = function(ab) { console.log("init!", a, b) }; });
// instantiate objects by calling the class as a function 
MyClass(1, 2) // => init!, 1, 2 
// to initialize with varargs, use `apply` like any other function. 
var argsList = [1, 2];
MyClass.apply(null, argsList) // init!, 1, 2 
// you can use it like an idiomatic class: 
// `new` is optional, not really recommended. 
new MyClass(1, 2) // => init!, 1, 2 
// non-pjs idiomatic subclass 
function Subclass(a) { MyClass.call(this, a, a); }
new Subclass(3) // => init!, 3, 3 
new Subclass(3) instanceof MyClass // => true 
// `new` may be used to "force" instantiation when ambiguous, 
// for example in a factory method that creates new instances 
MyClass.prototype.clone = function(ab) {
  return new this.constructor(a, b);
// because without `new`, `this.constructor(a, b)` is equivalent to 
// `MyClass.call(this, a, b)` which as we saw in the previous example 
// mutates `this` rather than creating new instances 
// allocate uninitialized objects with .Bare 
// (much like Ruby's Class#allocate) 
new MyClass.Bare // nothing logged 
new MyClass.Bare instanceof MyClass // => true 
// you can use `.open` to reopen a class.  This has the same behavior 
// as the regular definitions. 
// note that _super will still be set to the class's prototype 
MyClass = P({ a: 1 });
var myInst = MyClass();
MyClass.open(function(proto) { proto.= 2 });
myInst.// => 2 
MyClass.open(function(proto_super) { /* _super is Object.prototype here */ });
// you can also use `.extend(definition)` to create new subclasses.  This is equivalent 
// to calling P with two arguments. 
var Subclass = MyClass.extend({ a: 3 });

Assuming you have it installed (via npm install pjs), you can import it with

var P = require('pjs').P;

and go about your business.

It's super useful! In addition to make, Pjs uses some build tools written on Node. With the Node Package Manager that comes with recent versions of it, just run

npm install

from the root directory of the repo and make will start working.

Here are the things you can build:

  • make minify generates build/p.min.js

  • make commonjs generates build/p.commonjs.js, which is the same but has exports.P = P at the end

  • make amd generates build/p.amd.js, which is the same but has define(P) at the end

  • make test runs the test suite using the commonjs version. Requires mocha.