Javascript 解析时如何在对象中生成数组？

我正在解析JSON对象。我想根据id设置存储在会话中的值。我有以下JSON:

[
  {
    "id": "a",
    "text": "a",
    "icon": true,
    "li_attr": {
      "id": "a"
    },
    "a_attr": {
      "href": "#"
    },
    "state": {
      "loaded": true,
      "opened": false,
      "selected": false,
      "disabled": false
    },
    "data": {

    },
    "children": [

    ]
  },
  {
    "id": "b",
    "text": "b\n            ",
    "icon": true,
    "li_attr": {
      "id": "b"
    },
    "a_attr": {
      "href": "#"
    },
    "state": {
      "loaded": true,
      "opened": false,
      "selected": false,
      "disabled": false
    },
    "data": {

    },
    "children": [
      {
        "id": "b-a-1",
        "text": "b-a",
        "icon": true,
        "li_attr": {
          "id": "b-a-1"
        },
        "a_attr": {
          "href": "#"
        },
        "state": {
          "loaded": true,
          "opened": false,
          "selected": false,
          "disabled": false
        },
        "data": {

        },
        "children": [

        ]
      },
      {
        "id": "b-b-2",
        "text": "b-b\n                    ",
        "icon": true,
        "li_attr": {
          "id": "b-b-2"
        },
        "a_attr": {
          "href": "#"
        },
        "state": {
          "loaded": true,
          "opened": false,
          "selected": false,
          "disabled": false
        },
        "data": {

        },
        "children": [
          {
            "id": "b-b-a",
            "text": "b-b-a",
            "icon": true,
            "li_attr": {
              "id": "b-b-a"
            },
            "a_attr": {
              "href": "#"
            },
            "state": {
              "loaded": true,
              "opened": false,
              "selected": false,
              "disabled": false
            },
            "data": {

            },
            "children": [

            ]
          },
          {
            "id": "b-b-b",
            "text": "b-b-b",
            "icon": true,
            "li_attr": {
              "id": "b-b-b"
            },
            "a_attr": {
              "href": "#"
            },
            "state": {
              "loaded": true,
              "opened": false,
              "selected": false,
              "disabled": false
            },
            "data": {

            },
            "children": [

            ]
          }
        ]
      }
    ]
  },
  {
    "id": "c-1",
    "text": "c\n            ",
    "icon": true,
    "li_attr": {
      "id": "c-1"
    },
    "a_attr": {
      "href": "#"
    },
    "state": {
      "loaded": true,
      "opened": false,
      "selected": false,
      "disabled": false
    },
    "data": {

    },
    "children": [
      {
        "id": "not-c-a-1",
        "text": "c-a",
        "icon": true,
        "li_attr": {
          "id": "not-c-a-1"
        },
        "a_attr": {
          "href": "#"
        },
        "state": {
          "loaded": true,
          "opened": false,
          "selected": false,
          "disabled": false
        },
        "data": {

        },
        "children": [

        ]
      },
      {
        "id": "not-c-b-2",
        "text": "b-b",
        "icon": true,
        "li_attr": {
          "id": "not-c-b-2"
        },
        "a_attr": {
          "href": "#"
        },
        "state": {
          "loaded": true,
          "opened": false,
          "selected": false,
          "disabled": false
        },
        "data": {

        },
        "children": [

        ]
      }
    ]
  }
]

我想使相同类型的数组具有对象。对象内部可能存在嵌套对象。我只想根据它的id设置值

我们能得到孩子们的信息吗？如果有子项，我需要设置值。这是我的小提琴：

---

您可以使用传递给

JSON.parse

的恢复器函数

编辑：我试图通过使用不同的方法使代码更加健壮，但它没有像预期的那样工作，因为在我们开始迭代数组之前，

子项

键并不总是出现。看看编辑历史记录，也许我忽略了什么。

假设预期输出中的

“b-b-1”：“value_b-b-2”

是一种类型，实际上应该是

“b-b-2”：“value_b-b-2”

将原始数组映射到预期输出应该非常容易

在数组上使用

map

方法（或者，如果您需要支持较旧的浏览器，请使用您正在使用的某些库的

map

实现（例如jQuery或下划线）

对于数组中的每个项，您需要创建一个具有两个属性的项。第一个属性应根据输入对象的

id

属性的值命名，该属性的值似乎应该是文本

value\uu

，然后是来自t的

id

属性的值他输入对象

此外，每个项还应具有

arr

属性，这是将项映射函数应用于

子项

数组中的项的结果

所以代码可能看起来像

function mapItem(inputItem){
    var item = {};
    item[inputItem.id] = "value_" + inputItem.id;
    item.arr = inputItem.children.map(mapItem);
    return item;
};
var results = originalArray.map(mapItem);

---

我在

处对您的样本数据运行了上述映射函数，您的预期输出对我来说没有任何意义。有时您有

arr

和

子对象

。有时

arr

是一个数组，有时是一个字符串。您需要更好地解释您试图实现的转换类型e、 您只需给出一个简单的示例，说明1个具有子节点的初始节点以及该节点应如何转换。还应包括相关属性。@plalx抱歉，请检查我的更新。抱歉..这是一个“arr”不是孩子我将更新我的问题arr始终是数组而不是字符串..我只是制作自己的..它与原始相同只是将名称从孩子更改为arrI只是从会话中获取值，但在数组上，请给出fiddle@user944513我编辑了答案并提供了一个提琴。虽然代码肯定更复杂，但这将转换解析时使用structure，而不是解析后转换它的其他解决方案。@plax你能看看这个问题吗@user944513我试图避免这些wierd条件，以使函数更健壮（例如，如果有多个数组，则无法正常工作），但不知何故，

JSON.parse在它的迭代中似乎并不一致。请看一下历史上这个answser的编辑版本。也许我忽略了什么。我认为在解析时需要OP。那是在解析之后。@robert你能看看这个问题吗@plalx你完全正确，问题的标题是这样说的然而，我认为， map > /Cuff>方法更容易阅读，而且在尝试解析代码时，数组必须非常大，这比我们在如何解决OP问题时提供两个不同的建议，这样OP可以选择。请承认，我在写自己的答案时遗漏了关于“解析时”的部分，这就是为什么我对你的答案投了更高的票。但是，我仍然认为，在我将映射作为解析的一部分而不是将它们分开之前，数组必须非常大。
[
  {
    "a": "value_a",

    "arr": [

    ]
  },
  {
    "b": "value_b",

    "arr": [
      {
        "b-a-1": "value_b-a-1",

        "arr": [

        ]
      },
      {
        "b-b-1": "value_b-b-2",

        "arr": [
          {
            "b-b-a": "value_b-b-a",

            "arr": [

            ]
          },
          {
            "b-b-b": "value_b-b-b",

            "arr": [

            ]
          }
        ]
      }
    ]
  },
  {
    "c-1": "value_c-1",

    "arr": [
      {
        "not-c-a-1": "value_not-c-a-1",

        "arr": [

        ]
      },
      {
        "not-c-b-2": "value_not-c-b-2",

        "arr": [

        ]
      }
    ]
  }
]

var json = JSON.stringify([{ id: 'root', children: [ { id: 'nested' } ]}]);

var p = JSON.parse(json, function (k, v) {
    if (!k) return v;
    if (k === 'id' || k === 'children') return v;
    if (+k == k && typeof v === 'object' && v != null && 'id' in v) {
        v[v.id] = 'value_' + v.id;
        delete v.id;
        if (v.children) v.arr = v.children;
        delete v.children;
        return v;
    }
});

JSON.stringify(p); //[{"root":"value_root","arr":[{"nested":"value_nested"}]}]

function mapItem(inputItem){
    var item = {};
    item[inputItem.id] = "value_" + inputItem.id;
    item.arr = inputItem.children.map(mapItem);
    return item;
};
var results = originalArray.map(mapItem);