检查复杂JavaScript对象的完整性

在JavaScript中测试复杂对象完整性的最佳方法是什么

我的对象有一堆不同的变量，有些是可选的，有些是必需的。正确的结构对代码的功能至关重要，但是如果我在定义过程中出错，找到导致问题的确切值可能会变得非常乏味。尤其是错误消息告诉我“代码中的Somwehere您使用了错误的变量类型！”

我的对象可能看起来像这样，例如：

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

---

谢谢

您可以尝试根据

---

但是这可能是一种过分的做法。

除了编写一个函数来接收一个对象作为输入，并验证它是否具有“正确”的结构之外，没有其他好方法可以做到这一点

function isValid(obj)
{
    if (!o) return false;
    if (typeof o.name !== 'string') return false;
    if (typeof o.categories !== 'object') return false;
    if (typeof o.categories.a !== 'object') return false;
    if (typeof o.categories.b !== 'object') return false;
    // etc...

    return true;
}

另一方面，您可以定义一个构造函数，它接受正确构造对象所需的任何参数

function MyObj(name, categoryNames /* other args */)
{
    this.name = name;
    this.categories = {};

    for (var i=0; i<categoryNames.length; i++)
    {
        this.categories[categoryNames[i]] =
        {
            groups: {main: []}
        };
    }

    // etc
}

// use it like this:
var foo = new MyObj('Test', ['A', 'B'] /* other args */);

函数MyObj（名称、类别名称/*其他参数*/）
{
this.name=名称；
this.categories={}；
对于（var i=0；i您可以尝试一下。您可能需要进行一些修改，以说明您也可以使用JSON中无效的函数。
好的，我就是这样解决的：我创建了一个对象，它定义了我的复杂对象应该是什么样子。从某种意义上说，是一个蓝图

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},
                  }
                }
              }
            }
          }
        }
      }
    }
  }
}

然后我运行一个函数，将blueprint（“struct”）与要测试的对象（“def”）进行比较：

函数比较结构（struct，def）{
if（isArray（def））{
if（isDefined（struct.min）和&def.lengthstruct.max）{alert（“结构检查中的错误：“+”max为“+struct.max+”）；返回false}
对于（变量i=0；i

比较函数仍在进行中，但这是我现在要使用的概念。
如果是“最佳”，可能会更好真的是一个可以回答的问题吗？在你看来，什么能让一种技术比另一种技术更好？@Neal:codereview.se在什么方面是合适的位置？OP目前没有任何他们试图改进的代码。JSON不能包含函数，这不足以满足OP的对象。@Matt当你需要解析它时，例如se安全原因。但由于对象已经被解析，所以它是一种JSONA，但绝对不是！JSON是JavaScript中对象文字符号的严格子集。@马特，好吧，但我不确定模式验证是否关心它。你是如何做到这一点的？最重要的是：如何防止任何人通过
java重写你的函数脚本：
url注入或控制台，所以它总是返回true？
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.
}