managing object construction parameters in javascript

Question

I am posting this in hopes that someone might have dealt with a similar problem.

I am using a javascript object that encapsulates paramaters to intialize greater objects in my code, like so :

function MyObject(setup)
{
   this.mysetup = setup;
   if(typeof this.mysetup == "undefined") { this.mysetup = {} }

   if(typeof this.mysetup.stringParameter == "undefined")
   { 
       this.mysetup.stringParameter="string default value"
   }

   if(typeof this.mysetup.objParameter == "undefined")
   {
       this.mysetup.objParameter == {}
   }
   else
   { 
       if(typeof this.mysetup.objParameter.member1 == "undefined")
       {
           this.mysetup.objParameter.member1 = "member1 default value"
       }
    }


   // ...and so on

}

This way I can make sure not every parameter needs to be in setup, and still MyObject can resort to default values for what is missing.

However, this is a tedious thing to write and quite error prone. So I thought I'd try for a solution that checks the setup against a setupPrototype:

function MyObject(setup)
{

    this.setupPrototype = {
                             stringParameter : "string default value",
                             objectParameter : { member1 : "member default value"}
                           }
 }

and try to compare the setup against this.setupPrototype. The function I'm putting together for this purpose looks like

parseSetup = function (obj, objPrototype)
{
    var returnedObj = {};
    var hasMembers = false;

    if(typeof obj=="undefined")
    {
        returnedObj = objPrototype;
        return returnedObj;
    }

    for(member in objPrototype)
    {
        hasMembers = true;
        //if prototype member is not part of initialization object
        if (typeof obj[member]=="undefined")
        {
            returnedObj[member] = objPrototype[member];
        }
        else
        {
             if(objPrototype[member] instanceof Object)
             {
                 if(objPrototype[member] instanceof Array)
         {
                     returnedObj[member]=[];
                     for(var i=0; i<objPrototype[member].length; i++)
         {
                         returnedObj[member].push(parseSetup(obj[member][i], objPrototype[member][i]))
                      }
                  }
                  else{
                      returnedObj[member] = parseSetup(obj[member], objPrototype[member])
                  }
              }
        else
            returnedObj[member] = obj[member];
          }

    }


    if(!hasMembers)
    {
         if (typeof obj == "undefined")
     {  
              returnedObj = objPrototype;
         }  
     else
              returnedObj = obj;
     }

     return returnedObj;
 }

This however is still not up to par. An additional issue, which I'm debating is whether the original 'setup' should retain any of its own initial properties, or just have whatever is in the prototype. Also, it would be pointless to require that the prototype itself be aware of every possible value the setup might contain, especially for deep nested objects.

So my question is, are you aware of any proper way to solve this problem and end up with a setup object that, where its parameters are missing, can get default values from the prototype, but also not lose its own where they somehow need to be kept?

Many thanks

Answer 1

I would recommend using jQuery and then taking advantage of the $.extend() function, as described on the jQuery plugins page. Basically, you define your default parameters as an object within the constructor method, and then use $.extend() to overwrite only the properties that are supplied in the parameter to your function.

So you might end up with something like:

var MyObject = function (options) {
    this.defaultOptions = {
        stringParameter: "string default value",
        objParameter: {}
    };

    this.options = $.extend(true, this.defaultOptions, options);
};

To instantiate with the default parameters:

var obj1 = new MyObject({});

To instantiate with an overridden stringParameter:

var obj2 = new MyObject({stringParameter: 'overridden value'});

You can see a demo of this in action here.