Cannot iterate children at proper order

[eliseevmikhail]

Nodes order is important sometimes. I think, it is need to add _children array for proper order iterating, something like this:

--- xmlToJSON.js-orig   2016-05-05 13:37:23.096356807 +0700
+++ xmlToJSON.js        2016-05-05 17:39:14.599282243 +0700
@@ -156,7 +156,9 @@
                     }

                     vContent = xmlToJSON.parseXML(oNode);
-
+                    if(!vResult['_children']) vResult._children=[];
+                    vResult._children.push(vContent);
+                    vContent._tagname = sProp;
                     if (vResult.hasOwnProperty(sProp)) {
                         if (vResult[sProp].constructor !== Array) {
                             vResult[sProp] = [vResult[sProp]];

PS Sorry for my english

Have you tries setting childrenAsArray: true in the config options? This should preserve the order. If I have misunderstood your concern, can you post a sample? Thanks.

[eliseevmikhail]

copy((xmlToJSON.parseString("<root><a-two /><z-one /><a-two /></root>", {childrenAsArray: true})));

{
  "_children": [ /* Skip document top-level children tree */  ],
  "root": [
    {
      "_children": [
        {          "_tagname": "a-two"  /* Right order */        },
        {          "_tagname": "z-one"  /* Right order */        },
        {          "_tagname": "a-two"  /* Right order */        }
      ],
      "a-two": [ /* <------- Two elements are putted to list */
        {          "_tagname": "a-two"        },
        {          "_tagname": "a-two"        }
      ],
      "z-one": [  /* And where was one? */
        {          "_tagname": "z-one"        }
      ],
      "_tagname": "root"
    }
  ]
}

Also, JS doesnt guarantee key order in the dict (but all current realization yes). You probably want to add option for this behavior.

This is the intent of setting 'childrenAsArray: true' in the options. Have you tried this approach?

[eliseevmikhail]

As you may see in my last post, "childrenAsArray: true". It causes joining same named tags into array, but tag order was losted. Once more example (original lib, w/o patch):

> copy((xmlToJSON.parseString("<root><a-two /><z-one /><a-two /></root>", {childrenAsArray: true})));
{
  "root": [
    {
      "a-two": [
        {          "_text": [            null          ]        },
        {          "_text": [            null          ]        }
      ],
      "z-one": [
        {          "_text": [            null          ]        }
      ]
    }
  ]
}


```Compare tags order in the source xml and result object

I see. If you don't mind, go ahead and push a patch and I will review and
test it. I am traveling this week, but am planning on publishing a new
release sometime next week.

Thanks.

On Aug 15, 2016 9:46 PM, "eliseevmikhail" notifications@github.com wrote:

As you may see in my last post, "childrenAsArray: true". It causes joining
same named tags into array, but tag order was losted. Once more example
(original lib, w/o patch):

copy((xmlToJSON.parseString("", {childrenAsArray: true})));
{
"root": [
{
"a-two": [
{ "_text": [ null ] },
{ "_text": [ null ] }
],
"z-one": [
{ "_text": [ null ] }
]
}
]
}

Compare tags order in the source xml and result object

—
You are receiving this because you commented.
Reply to this email directly, view it on GitHub
#21 (comment),
or mute the thread
https://github.com/notifications/unsubscribe-auth/AFAjfGC99BjEKr1q_Pz96c6ofLQwqn-fks5qgUCQgaJpZM4IXzU3
.

This will require a significant change to the format of the JSON representation; possibly something like

[
 {nodetype, tag, namespace , attr [], children []},
 {nodetype, tag, namespace , attr [], children [
    {nodetype, tag, namespace , attr [], children []},
    {nodetype, tag, namespace , attr [], children []},
    {nodetype, tag, namespace , attr [], children []},
 ]},
 {nodetype, tag, namespace , attr [], children []},
]

This will require a new way of searching/walking the nodes as well.

I dont like losing the tag names as keys and will have to rethink this approach. The current grouping methodology meets the original intent and I am worried about a find() or match() style api for walking the object array.