遍历JSON以获取孩子的名字

Question

I want to get the name of child under Version1 and Version 2. Examples below for name of child are "Customer" and "Invoice".

How would I get it using javascript?

I tried Errors.Version1.[0] to get name but that does not seem to work. I dont want to use Errors.Version1.Customer because it can change. It can be "Customer" or "Invoice". I just want to get whatever name it is.

Thanks!

JSON example

{
  "Errors": [
    {
      "Version1": {
        "Customer": {
          "BillAddr": {
            "Id": "Id1",
            "Line1": "Line11",
            "Line2": "Line21",
            "Line3": "Line31",
            "Line4": "Line41",
            "Line5": "Line51",
            "City": "City1",

          }
        }
      },
      "Version2": {
        "Invoice": {
          "BillAddr": {
            "Id": "Id1",
            "Line1": "Line11",
            "Line2": "Line21",
            "Line3": "Line31",
            "Line4": "Line41",
            "Line5": "Line51",
            "City": "City1",

          }
        }
      }
    }
  ]
}

Answer 1

The correct notation would be

Errors[0].Version1[0] // however still won't work

Because you have an extra array wrapper in your json and you mixed notations.
However, object properties can't be accessed by their index, because their order is not guaranteed. So you either need to convert Version1 and Version2 to an array, or have to access the properties by name.

Errors[0].Version1["Customer"] //works for your current markup

Also, use either dot-Notation object.property or Bracket-Notation object["property"] - you can't mix it.

The following would work for your Notation Errors.Version1[0] :

{
  "Errors":
    {
      "Version1": [
        {
          "BillAddr": {
            "Id": "Id1",
            "Line1": "Line11",
            "Line2": "Line21",
            "Line3": "Line31",
            "Line4": "Line41",
            "Line5": "Line51",
            "City": "City1",

          }
        }
      ]
    }
}

As an array the order is guaranteed to be fixed, but you lose the information customer because arrays have no keys but only indices.

Answer 2

You can't reference object properties as indexes; in other words you can't do:

var foo = {a:1};
foo[0]; // Doesn't work

What you can do though is reference the property using a similar syntax as an index:

var foo = {a:1};
foo[someBoolean ? 'Customer' : 'Invoice']; // Does work

But, if you just want to get ANY properties of an object, regardless of what they're named? Well, then you need to iterate through them:

var foo = {randomName:1};
for (var key in foo) {
    // key=="randomName"
    // foo[key]==foo["randomName"]==foo.randomName==1
    // do whatever you want with foo[key];
}

However, I'd recommend using a library (both Underscore or jQuery have their own "each" functions) rather than the native JS, because if you use any libraries that add custom properties they could mess things up.

Answer 3

If it can only ever be one or the other, then just do a simple test:

var type = ("Customer" in Errors[0].Version1) ? "Customer" : "Invoice",
    obj  = Errors[0].Version1[type];

If it's more dynamic than just those two possible results, then you need to do a for ... in iteration through the keys of the object.

That said, if you have 100% ownership of this data format, and the ability to change it, might I suggest removing one level, and instead giving the error an error_type property, rather than trying to guess it?

{
    Errors : [{
        Version1 : {
            ErrorType : "Customer",
            BillAddr : {
                Id    : "Id1",
                Line1 : "Line11",
                Line2 : "Line21",
                Line3 : "Line31",
                Line4 : "Line41",
                Line5 : "Line51",
                City  : "City1"
            }
        },

        Version2 : { /* ... */ }
    }]
}

Alternatively, you could make VersionX an array, rather than an object, and to that end, you could have multiple errors, held as objects (with their own error-type properties), at which point, figuring out what you're dealing with, through:

Errors[0].Version1[0].ErrorType;

becomes dead-simple.