JavaScript namespace + using proposal

I've just uploaded inside devpro my last JavaScript proposal: a little, simple and fast namespace function, with a single static public method called using.

What's a namespace ?

A namespace is "a place where everything is unobtrusive", where in this case unobtrusive means that You can't (shouldn't) modify other libraries.

Who use a namespace ?

Many program languages (C# / Python / Java / maybe one day PHP and others) use namespace since their first implementation (packages, from - import, using).
In JavaScript world, big (but not too) libraries use namespace too (Dojo, YUI!) while many other libraries use a sort of internal namespace (jQuery, MooTools, Prototype) to separe FX, utils and other piece of code.

What about my proposal ?

It's really tiny as simple to use and You can find them in this page.


Here there's a first, basic, simple example:

// create / modify or overwrite a namespace called webreflection
// setting an object with a type key and its value
namespace("webreflection", {type:"blog"});

// create / modify or overwrite another namespace
// adding a string as value
namespace("webreflection.author", "Andrea Giammarchi");


// get created namespace
var MyBlog = namespace("webreflection");

// show saved variables
alert([MyBlog.author, MyBlog.type].join("'s "));
// Andrea Giammarchi's blog


// show just author value
alert(namespace("webreflection.author"));
// in this case Andrea Giammarchi string

Simple? You can save every kind of variable inside your namespace and You can create any kind of name, splitting them with a "." char:

var FX = namespace("this.is.my.Library.FX", function(){
 // do stuff
});

var myFX = new FX;
// the same of
var myFX = new namespace("this.is.my.Library.FX");

There's something else interesting, a static global using function!

What about using ?

Function namespace.using inject your namespace scope inside a callback, sending them one or more variables:

var tellMeSomething = namespace.using("webreflection", function(){
 return [
  "This kind of site is a",
  this.type,
  "and its publisher is",
  this.author
 ].join(" ")
});

alert(tellMeSomething);
// This kind of site is a blog and its publisher is Andrea Giammarchi

Seems interesting ? This is last example:

namespace("webreflection.utils.String", {
 trim:function(str){
  return str.replace(/^\s+|\s+$/g, "")
 },
 camel:function(str){
  return str.toLowerCase().replace(/\-([a-z])/g, function(m,c){return "-"+c.toUpperCase()})
 },
 repeat:function(str, times){
  for(var i = 0, a = new Array(times); i < times; i++)
   a[i] = str;
  return a.join();
 }
});

alert([
 namespace("webreflection.utils.String").camel("tEsT-mE"),
 namespace.using("webreflection.utils.String", function(){
  return this.repeat("test", 3);
 }),
 namespace.using("webreflection", function(){
  return "[" + this.utils.String.trim(" hello ") + "]"
 }),
 namespace("webreflection.utils").String.repeat
].join("\n"));

So, what's new ?
Well, this way to create a dedicated namespace is the same of my old JSTONE constructor: a tested way to manage namespaces and, imho, extremely useful for every JS developer and / or library.