Question

We have some js code splitted in many files. We have a core file that defines code used by many other js files.

Currently we have something like this:

core.js:

window.mycore = function() {

    var myfunction1 = function() {
    };
    var myfunction2 = function() {
    };
    var myfunction3 = function() {
        //..
        var a =  myfunction1(b);
        //..        
    };
    //...
    // many "myfunction"
    //...
    var myfunctionN = function() {
    };
    var publish = function() {
        for(var i = 0; i < arguments.length; i++) {
            try {
                window.mycore[arguments[i]] = eval('(' + arguments[i] + ')');
            }
            catch(e) {
                Log.err(600, arguments[i], e);
            }
        }
    };
    publish("myfunction1", "myfunction7", "myfunction8",/*...*/"myfunctionM")
}

app.js:

// ...
// ...
var result = window.core.myfunction1("myparam");
// ...
// ...

Note that none core methods are declared as members of the window.core object. Instead they are attached to the core object with the publish function.

This has some pros:

• The core code can reference any core function without the need of writing “window.core.”
• We avoid writing “var myfunction = window.mycore.myfunction = function() …” in every public function declaration
• The exposed methods can be seen centraliced.

But, the use of eval in the publish function is bringing us problems when using code analysis tools since they don’t tend to understand eval declarations.

So, here is my question.
Which is the better way to improve this code, so we can keep the advantages mentioned but eradicating the eval declaration.
I am aware of the solution of sending to the publish function some name/value pairs like publish({‘myfunction1’: myfunction1}, … ), but I also want to avoid function name repetitions.
Consider that I am not looking for radical changes since there is a lot of code written already.

Thanks!

Answer 1

I’m not sure I understand completely your reasons for using the “publish” method, but is there any reason your not just returning an object with the correct functions from your constructor?

ie:

window.mycore = (function() {
   var myFunc1 = function(a) {
      alert(a);
   };

   var myFunc2 = function(b) {
      // call to other function in the same scope
      myFunc1(b);
   }

   ...

   // at the end just expose the public members you want
   return {
      myFunc1: myFunc1,
      myFunc2: myFunc2
   };
})();

or

window.mycore = (function() {
   return {
      myFunc1: function(a) {
         alert(a);
      },
      myFunc2: function(b) {
         this.myFunc1(b);
      }
   };
})();

or, yet another way to end up with the same object 🙂 … as always there are different ways to get there

(function(){

    var o = {};

    o.func1 = function(a) {
        alert(a);
    }

    o.func2 = function(b) {
        this.func1(b);
    }

    window.mycore = o;

})();