Atomy

JavaScript OOP

installaton

npm install atomy

Browser

<script src="/path/to/undercloud.atomy.min.js"></script>

NodeJS

var Atomy = require('atomy');

class creation

var Animal = Atomy.extend({
  weight: 0,
  abilities: ['eat','breath','see'],
  constructor: function(name) {
    this.name = name;
  },
  say: function() {
    console.log("I'am " + this.name);
  }
})
 
var dogg = new Animal('Snoop');
var cat  = new Animal('Tom');
 
dogg.say(); //I'am Snoop
cat.say(); //I'am Tom

inheritance

var Monkey = Animal.extend({
  constructor: function(name) {
    Monkey.superclass.constructor.call(this, name);
  },
  jump: function() {
    console.log('I can jump');
  }
})
 
var monkey = new Monkey('Joe');
 
monkey.say(); //I'am Joe
monkey.jump(); //I can jump

extends an existing class

var ReversedArray = Atomy.extend(Array, {
  constructor: function() {
    for (var i in arguments){
      this.push(arguments[i]);
    }
  },
  reverseSort: function() {
    return this.sort().reverse();
  }
})
 
var ra = new ReversedArray(1,5,3,4,2);
ra.reverseSort(); //[5,4,3,2,1]

instanceof

var Animal = Atomy.extend({/*...*/});
 
var Monkey = Animal.extend({/*...*/});
var Human  = Monkey.extend({/*...*/});
 
var Wolf = Animal.extend({/*...*/});
var Dog  = Wolf.extend({/*...*/});
 
console.log(new Dog() instanceof Wolf); //true
console.log(new Dog() instanceof Animal); //true
console.log(new Dog() instanceof Monkey); //false

constant

var XMath = Atomy.extend({});
 
XMath.constant('PI', 3.14);
 
try {
  XMath.PI = 0;
} catch (e) {
 
}
 
XMath.PI; //3.14

Add constant into existing objects

Atomy.constant(window, 'MYCONST', true);
window.MYCONST = false;
window.MYCONST; //true

private

var Something = Atomy.extend({
  constructor: function() {
    var hiddenProperty = 'Hidden Value';
 
    Something.prototype.getHiddenProperty = function() {
      return hiddenProperty;
    };
  }
});
 
var s = new Something();
s.getHiddenProperty(); //Hidden Value

inject

Extend object prototype

var Something = Atomy.extend({/*...*/});
 
Something.inject({
  foo: 'Bar',
  getFoo: function() {
    return this.foo;
  }
});
 
var some = new Something();
some.getFoo(); //Bar

Inject single property

Something.inject('square', function(x) {
  return x * x;
});
 
some.square(3); //9

Inject into existing objects

Atomy.inject(Array, 'reverseSort', function() {
  return this.sort().reverse()
});
 
var a = [6,7,3,4,2];
a.reverseSort(); //[7, 6, 4, 3, 2]

share

Same as Atomy.inject but extends only static context

var Something = Atomy.extend({/*...*/});
 
Something.share({
  foo: 'Bar',
  getFoo: function() {
    return this.foo;
  }
});
 
Something.getFoo(); //Bar

Share single property

Something.inject('square', function(x) {
  return x * x;
});
 
Something.square(3); //9

Share existing objects

Atomy.share(window.location, 'setHash', function(hash) {
  this.hash = hash;
});
 
window.location.setHash('goto');

singletone

var Animal = Atomy.extend({});
 
Animal.__instance__ = null;
Animal.getInstance = function() {
  if(this.__instance__ === null) {
    this.__instance__ = new Animal();
  }
 
  return this.__instance__;
}
 
var a = Animal.getInstance();
var b = Animal.getInstance();
 
a === b //true

namespace

Atomy.namespace('milkyway.solar.earth');
//window.milkyway.solar.earth
 
var scope = {};
Atomy.namespace('milkyway.solar.earth',scope);
//scope.milkyway.solar.earth
 
Atomy.namespace('milkyway.solar.earth.life').Animal = Atomy.extend({
  /*...*/
});
 
var animal = new milkyway.solar.earth.life.Animal();

isset

Atomy.isset('window.Array.prototype.sort'); //true
Atomy.isset('sort', Array.prototype); //true
 
var Animal = Atomy.extend({
  say: function() {
    /*...*/
  }
});
 
var monkey = new Animal();
monkey.isset('say') //true
 
Animal.abilities = []; 
Animal.isset('abilities'); //true

toString

var Animal = Atomy.extend({
  toString: function() {
    return '[object Atomy]';
  }
});