Question

What is the best way to test the integrity of a complex object in JavaScript?

My object has a bunch of different variables, some optional, some required. The correct structure is vital to the code’s functionality, but if I make a mistake during the definition, finding the exact value that caused the problem could get very tedious. Especially with error messages that tell me no more than “Somwehere in the code you’re using the wrong variable type!”.

My object could look something like this, for example:

{
  name:"Test",
  categories:{
    A:{
      depth:1,
      groups:{
        main:[
          {myFunction:funcA, arg:[1,2]},
          {myFunction:funcB}
        ]
      }
    },
    B:{
      groups{
        main:[
          {myFunction:funcC}
        ],
        secondary:[
          {myFunction:funcD}           
        ]
      }
    }
  }
}

Thanks!

Answer 1

Okay, this is how I’ve solved it: I create an object that defines what my complex objects should look like. A blueprint, in a way.

var structure = {
  property1: {id:"name", type:"string", required:false},
  property2: {
    id:"categories", type:"object", required:true,
    content:{
      property1:{
        type:"object", min:1,
        content:{
          property1:{id:"depth", type:"positiveinteger", required:false},
          property2:{
            id:"groups", type:"object", required:true,
            content:{
              property1:{
                type:"array", min:1,
                content:{
                  type:"object", min:1,
                  content:{
                    property1:{id:"myFunction", type:"function", required:true},
                    property2:{id:"args", type:"array", required:false},
                  }
                }
              }
            }
          }
        }
      }
    }
  }
}

Then I run a function that compares the blueprint (“struct”) with the object to be tested (“def”):

function compareStructure(struct, def){
  if(isArray(def)){
    if(isDefined(struct.min) && def.length < struct.min){ alert("Error in structur check: " + " min is " + struct.min + "."); return false}
    if(isDefined(struct.max) && def.length > struct.max){ alert("Error in structur check: " + " max is " + struct.max + "."); return false}
    for(var i = 0; i < def.length; i++){
      compareStructure(struct.content, def[i]);
    }
  } else {
    for(var k in struct){
      if(struct[k].id){
        propFound = false;
        for(var m in def) if(m == struct[k].id) propFound = m;
        if(!propFound && struct[k].required){ alert("Error in structure check:  " + struct[k].id + " not defined."); return false}
        if(propFound && !verifyThis(struct[k], def[propFound], propFound)) return false;
        if(propFound && struct[k].content) compareStructure(struct[k].content, def[propFound]);
      } else {
        for(var m in def){
          if(!verifyThis(struct[k], def[m], m)) return false;
          if(struct[k].content) compareStructure(struct[k].content, def[m]);
        }
      }
    }
  }
}

function verifyThis(struct, def, prop){
  // This is where the checks for types and values are made.
}

The comparison function is still work in progress, but that’s the concept I’m going with for now.