Nicer way of checking JavaScript namespace

Try this simple helper function:

function exists(namespace) {    
   var tokens = namespace.split('.');
   return tokens.reduce(function(prev, curr) {
      return (typeof prev == "undefined") ? prev : prev[curr];
   }, window);
}

It takes a String as input and will return the object if it exists. You can use it like this:

var module = exists("TOP.middle.realModuleName");

For example:

exists("noexist"); // returns undefined
exists("window"); // returns DOMWindow
exists("window.innerHeight"); // returns Number
exists("window.innerHeight.toString"); // returns Function
exists("window.innerHeight.noexist"); // returns undefined

It also works properly for expressions that evaluate to false:

testNum = 0;
testBool = false;
testNull = null;

exists("testNum"); // returns 0
exists("testBool"); // returns false
exists("testNull"); // returns null

I'd try something like this although it is prone to error if it receives some funky input:

if(check("TOP.middle.realModuleName")) {
  //exists
}

//namespace checking function
function check(ns) {

  var pieces = ns.split('.'),
      current = window;

  for(i in pieces) {    
    if(!(current = current[pieces[i]])) {
      return false;
    }
  }

  return true;
}

You can use a try/catch and look for 'not_defined':

try {
    TOP.middle.realModuleName = function () { /*...*/ };
} catch(e) {
    if ( e.type == 'not_defined' ) {
        // exception
    }
    else {
        // throw other errors
        throw e;
    }
}

I use a function that parses a namespace and creates it if it doesn't exist. Here is the function:

framework.namespace = function(baseName){
  var ns = baseName.split('.');
  var o = window;
  for (var i=0, l=ns.length; i < l; i++){
    o = o[ns[i]] = o[ns[i]] || {};
  }
  return o;
};

Then, before I need to use the namespace, I do this:

framework.namespace("TOP.middle.realModuleName");
TOP.middle.realModuleName = function(){...};

You can do the whole thing in one line this way:

TOP && TOP.middle && TOP.middle.realdModuleName && new TOP.middle.realdModuleName;

Note that your function will be run immediately. If you want to store the function for later reuse, just assign it (var module =). If the module function is not defined, then undefined is set/thrown away.

Short answer

The way that I learnt it was (applies to namespace creation as well):

// Check if the com namespace does not exist:
if (!com) {
    var com = {};
}

// Check if your namespace does not exist:
if (!com.myNamespace) {
    var com.myNamespace = {};
}

Some information that I learnt (so far)

According to a book that I'm reading, the com namespace is a container for commercial products (by that, I mean websites, libraries etc).

The namespace was originally created to hold domains. However, today you'll find com.* in libraries, databases or even frameworks!

It is currently operated by VeriSign, and has been in existence for 33 years now!

Long answer

First, we need to make sure that the main namespace exists. We'll do this checking if com does not exist:

if (!com) {
    var com = {};
}

com is the most common namespace to check. However, we can check any namespace.

We could skip this part, but it would be really irritating to get all of your functions mixed up.

If com does not exist, then create it.

var com = {};

Lastly, we need to check if myNamespace exists. We'll be using the same method for the com, but this time, we'll add com. before myNamespace.

if (!com.myNamespace) {
    var com.myNamespace = {};
}

The reason why we add com. before our namespace declaration, is that the com namespace is made at the second level and myNamespace is made on the third level.

I recommend that you add a Fourth level namespace for your project.
This will ensure that:

• your project has it's own namespace (if myNamespace is taken).

• your project will not be mixed in with other projects (e.g. com.projectA.other and com.projectA.yourProject).

• your functions will not get mixed up (e.g. you have a function called write).

Now, your code

You're nearly there! Here is how I would look at it:

if (!TOP) {
    // Reinitialize your TOP Namespace here:
    var TOP = {};
}

if (!TOP.middle) {
    // Reinitialize your MIDDLE Namespace here:
    var TOP.middle = {};
}

if (typeof TOP.middle.realModuleName == "function") {
    new TOP.middle.realModuleName ();
}
else {
    // Redefine your function here (you never know ;) )
}

there is a way to do that more quickly by:

           ?.

example:

const adventurer = {  name: 'Alice',  cat: {    name: 'Dinah'  }};
const dogName = adventurer.dog?.name;

more detailed answer: https://tc39.es/proposal-optional-chaining/#sec-scope