Wanted to get opinions from the experts, I am declaring a variable that will act as the namespace for my application javascript code, but i want to check it is not already defined.
this code is terse and 'seems' to work - any reason I should avoid this and use typeof 'undef' checking instead?
var MY_NAMESPACE = MY_NAMESPACE || {};
Thanks
This is the standard way of doing it. See Matt Snider's analysis of the YUI YAHOO.namespace function which uses this same check (Also for a look at how to make it easy to create namespaces).
Matt's code, which he adapted from YUI to namespace off the window object instead of the YAHOO object:
window.object_mes_namespace = function() {
var a = arguments,
o = window,
i = 0,
j = 0,
tok = null,
name = null;
// iterate on the arguments
for (i = 0; i < a.length; i = i + 1) {
tok = a[i].split(".");
// iterate on the object tokens
for (j = 0; j < tok.length; j = j + 1) {
name = tok[j];
o[name] = o[name] || {};
o = o[name];
}
}
return o;
}
Note the o[name] = o[name] || {}; line, which parallels your example.
Although what you posted is seen commonly, I personally don't think it's the best way to do it.
MY_NAMESPACE could evaluate to false for several reasons other than undefined -- the variable could really be defined but be 0 or false or an empty string, and you might end up replacing this value.
MY_NAMESPACE could evaluate to true for several reasons other than already being an object -- it could be a non-zero number or true or a string, and this will cause your script to silently fail, because adding properties to a primitive will fail without an error.
Really, the best way depends on what your goal is. If you don't want to pollute an existing variable/namespace, you should do a typeof check and stop if the variable is already defined but not an object:
if (typeof MY_NAMESPACE == 'undefined') {
// create a new namespace
MY_NAMESPACE = {};
}
if (typeof MY_NAMESPACE == 'object') {
// go ahead
} else {
// MY_NAMESPACE was already defined, but it is not an object
// your script will fail if you continue, so do what you must and stop
}
If your script must work, just blindly create the namespace without any checks (of course, I'm not recommending that you do this).
Edit: (in response to @jball's comment, thought I'd just add it here)
If this namespace is part of a library that you're developing, then it is imperative that you name your namespace carefully to avoid collision. If you do encounter a collision, it's better to just stop loading your library than mix your library with another and get unexpected results.
If this namespace is just for your own application, it should be fairly simple to pick a name that isn't used by any libraries that you're using.
namespace || {}.foo needs to respect the fact that I may very well write other modules in that same namespace and use them before or after I use foo. Namespacing needs to be a "check if exists or create" operation in order to have modularity.This is already the preferred way.
But your statement does nothing, unless you leak MY_NAMESPACE into another scope, because MY_NAMESPACE is MY_NAMESPACE.
window.MY_NAMESPACE = window.MY_NAMESPACE || {};I like the YUI example and use it for all my Apps. In yours, you're re-assigning MY_NAMESPACE no matter what, which isn't a huge deal, but I prefer to avoid that assignment if it's not necessary.
if (typeof myNamespace == "undefined" || !myNamespace) {
var myNamespace = {};
}
YAHOO variable, but not for how it creates namespaces below it. Code dump: YAHOO.namespace = function() { var a=arguments, o=null, i, j, d; for (i=0; i<a.length; i=i+1) { d=(""+a[i]).split("."); o=YAHOO; /* YAHOO is implied, so it is ignored if it is included */ for (j=(d[0] == "YAHOO") ? 1 : 0; j<d.length; j=j+1) { o[d[j]]=o[d[j]] || {}; o=o[d[j]]; } } return o; }; - Note in particular the o[d[j]]=o[d[j]] || {}; statement.