在Javascript中将xml转换为json

I have the following javascript function (which I got from Stack Overflow) which converts XML to JSON:

我有以下javascript函数（我从Stack Overflow获得）将XML转换为JSON：

function xmlToJson(xml) {
    try {
        var obj = {};
        if (xml.nodeType == 1) {
            if (xml.attributes.length > 0) {
                for (var j = 0; j < xml.attributes.length; j++) {
                    var attribute = xml.attributes.item(j);

                    obj[attribute.nodeName] = attribute.nodeValue;
                }
            }
        } else if (xml.nodeType == 3) {
            obj = xml.nodeValue;
        }

        if (xml.hasChildNodes()) {
            for (var i = 0; i < xml.childNodes.length; i++) {
                var item = xml.childNodes.item(i);
                var nodeName = item.nodeName;

                if (typeof (obj[nodeName]) == "undefined") {
                    obj[nodeName] = xmlToJson(item);
                } else {
                    if (typeof (obj[nodeName].push) == "undefined") {
                        var old = obj[nodeName];

                        obj[nodeName] = [];
                        obj[nodeName].push(old);
                    }

                    obj[nodeName].push(xmlToJson(item));
                }
            }
        }

        console.log(JSON.stringify(obj));
        return obj;
    } catch (e) {
        alert(e.message);
    }
}

What I want is to return it as an array ([]) when a xml node has at-least single child node and it has a parent node also. In this code it returns map ({}) if xml node has single child node but it is fine with multiple child nodes.

我想要的是当xml节点至少具有单个子节点并且它还具有父节点时，将其作为数组（[]）返回。在此代码中，如果xml节点具有单个子节点，则它返回map（{}），但是它具有多个子节点。

For example, I'd like the XML

例如，我喜欢XML

<pnode attr1="abc">
    <cnode attr2="xyz"></cnode>
</pnode>

to be transformed into the JSON

转化为JSON

{
    "pnode": {
        "attr1": "abc"
    },
    "cnode": [
        {"attr2": "xyz"}
    ]
}

2 个解决方案

#1

With the clarification about what you want to achieve, here is an algorithm. I'll leave my other answer up because I still think the wisest choice is not to play with the structure

通过澄清您想要实现的目标，这是一个算法。我会留下我的另一个答案，因为我仍然认为最明智的选择是不要使用结构

function flattenNodes(node, isChild) {
    var obj = {}, obj2, i, key, attributes = {};
    if (node.attributes && node.attributes.length)
        for (i = 0; i < node.attributes.length; ++i)
            attributes[node.attributes[i].nodeName] = node.attributes[i].nodeValue;
    if (!isChild)
        obj[node.nodeName] = attributes;
    else {
        if (!obj.hasOwnProperty(node.nodeName))
            obj[node.nodeName] = [];
        else if (!(obj[node.nodeName] instanceof Array))
            obj[node.nodeName] = [obj[node.nodeName]];
        obj[node.nodeName].push(attributes);
    }
    attributes = null; // free
    if (node.childNodes && node.childNodes.length)
        for (i = 0; i < node.childNodes.length; ++i) {
            if (node.childNodes[i].nodeType === 3) continue; // skip text node
            obj2 = flattenNodes(node.childNodes[i], 1); // recurse
            for (key in obj2) // merge
                if (obj2.hasOwnProperty(key))
                    if (!obj.hasOwnProperty(key)) {
                        obj[key] = obj2[key];
                    } else {
                        if (!(obj[key] instanceof Array))
                            obj[key] = [obj[key]];
                        obj[key] = obj[key].concat(obj2[key]);
                    }
        }
    return obj;
}

Example usage on Node root_node

节点root_node上的示例用法

var root_node;
root_node = new DOMParser().parseFromString(
    '<pnode attr1="abc"><cnode attr2="xyz"></cnode></pnode>',
    'text/xml'
).documentElement;

var o = flattenNodes(root_node); // create
JSON.stringify(o);               // to JSON
// {"pnode":{"attr1":"abc"},"cnode":[{"attr2":"xyz"}]}

If you have XML of the form <foo bar="baz"><foo hello="world"></foo></foo>, the first iteration will cause {foo: {bar: "baz"}}, then the second encounter will modify this to the array form of {foo: [{bar: "baz"}, {hello: "world"}]}

如果您的格式为，则第一次迭代将导致{foo：{bar：“baz”}}，然后第二次遭遇会将其修改为{foo：[{bar：“baz”}，{hello：“world”}]}的数组形式

#2

I would form the object representing the XML differently;

我会以不同的方式形成表示XML的对象;

Integer  nodeType
String   nodeName
String   nodeValue
Array    childNodes
Object   attributes

Now you can have the same form independent of number of child nodes/etc

现在，您可以使用与子节点数等无关的相同形式

function nodeToObject(node) {
    var obj = {}, i;
    obj.nodeType = node.nodeType;
    obj.nodeName = node.nodeName;
    obj.nodeValue = node.nodeValue;
    obj.childNodes = [];
    obj.attributes = {};
    if (node.childNodes && node.childNodes.length)
        for (i = 0; i < node.childNodes.length; ++i)
            obj.childNodes.push(nodeToObject(node.childNodes[i]));
    if (node.attributes && node.attributes.length)
        for (i = 0; i < node.attributes.length; ++i)
            obj.attributes[node.attributes[i].nodeName] = node.attributes[i].nodeValue;
    return obj;
}

And then to transform root_node to JSON,

然后将root_node转换为JSON，

JSON.stringify(nodeToObject(root_node));

Going in the opposite direction is also possible in JavaScript, with some minor logic based upon nodeType to choose the creation method.

在JavaScript中也可以使用相反的方向，使用一些基于nodeType的次要逻辑来选择创建方法。

#1