Cacher is the code snippet organizer for pro developers

Namespace function

var MYAPP = MYAPP || {};

MYAPP.namespace = function (ns_string) {
  var parts = ns_string.split('.'),
      parent = MYAPP,
      i;
      
  // strip redundant leading global
  if (parts[0] === "MYAPP") {
    parts = parts.slice(1);
  }
  
  for (i = 0; i < parts.length; i += 1) {
    // create a property if it doesn't exist
    if (typeof parent[parts[i]] === "undefined") {
      parent[parts[i]] = {};
    }
    parent = parent[parts[i]];
  }
  return parent;
};

// assign returned value to a local var
var module2 = MYAPP.namespace('MYAPP.modules.module2');
module2 === MYAPP.modules.module2; // true

// skip initial `MYAPP`
MYAPP.namespace('modules.module51');

// long namespace
MYAPP.namespace('once.upon.a.time.there.was.this.long.nested.property');

Declaring Dependencies

var myFunction = function () {
  // dependencies
  var event = YAHOO.util.Event,
      dom = YAHOO.util.Dom;
      
  // use event and dom variables
  // for the rest of the function...
};

Private Properties and Methods

function Gadget () {
  // private member
  var name = 'iPod';
  
  var object = {
    color: #f00
  };
  
  // public function
  this.getName = function () {
    return name;
  };
  this.getObject = function () {
    return object; // be carefull
  }
}

var toy = new Gadget();

// `name` is undefined, it's private
console.log(toy.name); // undefined

// public method has access to `name`
console.log(toy.getName()); // "iPod"

var obj = toy.getObject();

obj.color = #fff; // it replaces property of 'private' object

Object Literals and Privacy

var myobj; // this will be the object
(function () {
  // private members
  var name = "my, oh my";
  
  // implement the public part
  // note -- no `var`
  myobj = {
    // privileged method
    getName: function () {
      return name;
    }
  };
}());

myobj.getName(); // "my, oh my"

var myobj = function () {
  // private members
  var name = "my, oh my";
  
  // implement the public part
  return {
    getName: function () {
      return name;
    }
  };
}());

myobj.getName(); // "my, oh my"

Prototypes and Privacy

function Gadget () {
  // private member
  var name = 'iPod';
  // public function
  this.getName = function () {
    return name;
  };
}

Gadget.prototype = (function () {
  // private member
  var browser = "Mobile Webkit";
  // public prototype members
  return {
    getBrowser: function () {
      return browser;
    }
  };
}());

var toy = new Gadget();
console.log(toy.getName()); // priviledged "own" method
conosle.log(toy.getBrowser()); // priviledged prototype method

Revealing Private Functions As Public Methods

var myarray;

(function () {

  var astr = "[object Array]",
      toString = Object.prototype.toString;
      
  function isArray(a) {
    return toString.call(a) === astr;
  }
  
  function indexOf(haystack, needle) {
    var i = 0,
        max = haystack.length;
        
    for (; i < max; i += 1) {
      if (haystack[i] === needle) {
        return i;
      }
    }
    return -1;
  }
  
  myarray = {
    isArray: isArray,
    indexOf: indexOf,
    inArray: indexOf
  };
}());

myarray.isArray([1,2]); // true
myarray.isArray({0: 1}); // false
myarray.indexOf(["a", "b", "z"], "z"); // 2
myarray.inArray(["a", "b", "z"], "z"); // 2

// if something unexpected happens to the public indexOf(), the private indexOf()
// is still safe and therefore inArray() will continue work
myarray.indexOf = null
myarray.inArray(["a", "b", "z"], "z");

Module Pattern

MYAPP.namespace('MYAPP.utilities.array');

MYAPP.utilities.array = (function () {

  // dependencies
  var uobj = MYAPP.utilities.object,
      ulang = MYAPP.utilities.lang,
      
      // private properties
      array_string = "[object Array]",
      ops = Object.prototype.toString;
      
      // private methods
      // ...
      
      // end var
      
  //optionally one-time init procedures
  // ...
  
  // public API
  return {
    inArray: function (needle, haystack) {
      for (var i = 0, max = hastack.length; i < max; i += 1) {
        if (haystack[i] === needle) {
          return true;
        }
      }
    },
    isArray: function (a) {
      return ops.call(a) === array_string;
    }
    // ... more methods and properties
  };
}());

Revealing Module Pattern

MYAPP.utilities.array = (function () {
    // private properties
  var array_string = "[object Array]",
      ops = Objetc.prototype.toString,
      
    // private methods
      inArray = function (haystack, needle) {
        for (var i = 0, max = haystack.length; i < max; i += 1) {
          if (haystack[i] === needle) {
            return i;
          }
        }
        return -1;
      },
      isArray = function (a) {
        return ops.call(a) === array_string;
      };
    // end var
    
  // revealing public API
  return {
    isArray: isArray,
    indexOf: inArray
  };
}());