-1

在父子关系中绑定 Html Grid 中的数组并按排序列排序

Unformatted array:   var data = [
{ index : 1,  parent : null,sort:0 },
{ index : 2,  parent : null ,sort:1},
{ index : 3,  parent : 2 , sort:0},
{ index : 4,  parent : null,sort:2},
{ index : 5,  parent : 4,sort:0 },
{ index : 6,  parent : 5 ,sort:0},
{ index : 7,  parent : 5 ,sort:1},
{ index : 8,  parent : 6 ,sort:0},
{ index : 9,  parent : 2 ,sort:2},
{ index : 10, parent : 2 ,sort:1},
];

if data binds looks like this ,Example
 Parent 1
 Child 12
 Child 1.1
 Subchild 1.1.2
 Subchild 1.1.1
 Subchild 1.2.2
 Subchild 1.2.1

结果应该如下

formatted array: var data = [
{ index : 1,  parent : null,sort:0 },
{ index : 2,  parent : null ,sort:1},
{ index : 3,  parent : 2 , sort:0},
{ index : 10, parent : 2 ,sort:1},
{ index : 9,  parent : 2 ,sort:2},
{ index : 4,  parent : null,sort:2},
{ index : 5,  parent : 4,sort:0 },
{ index : 6,  parent : 5 ,sort:0},
{ index : 8,  parent : 6 ,sort:0},
{ index : 7,  parent : 5 ,sort:1},
];

我想像这样绑定 -->

 Parent 1
    --> Child 1.1
       --> Subchild 1.1.1
          --> Subchild 1.1.2
    --> Child 12
         --> Subchild 1.2.1
           --> Subchild 1.2.2

以下是我现在使用的解决方案，如果数组有大数据，则需要更多时间来绑定网格

 function Ordering(Data,successCallBack) {
    var Grid= [];
    var parentdata=[];
    $.each(Data, function (key, value) {
         if (value.parent== null) {
            parentdata.push(value);
          }
    });

    $.each(parentdata, function (key, value) {
        child(Requirements, value, Grid, function    (Order) {
              successCallBack(Order);
        });
    });

}
function child(data, parentdata, Grid, successCallBack) {
    Grid.push(parentdata);
    $.each(data, function (key, value) {
        if (parentdata== value.parent) {
            child(data, value, Grid, function () { });
        }
    });
    if (Grid.length == Grid.length) {
        successCallBack(Grid);
    }
}
4

1 回答 1

2

目前尚不清楚您的订购要求到底是什么。但是您需要创建自己的比较函数，类似于：

var newOrder = [];
function myCompare(a, b){
    if (a.sort != b.sort){
        return (a.sort < b.sort ? -1 : 1)
    }
    if (data[a.parent].sort != data[b.parent].sort){
        return (data[a.parent].sort < data[b.parent].sort ? -1 : 1)
    }
    return 0;
}
for (var i in data){
    newOrder[i] = data[i];
}
newOrder.sort(myCompare);

顺便说一句，您有一个错误：sort每个对象中有两个属性。

编辑：好的，我想我现在明白你想要什么了。这是我的解决方案的 JSFiddle。

var newData = [];

var top = {};

function doSort() {
    for (var i in data) {
        var child = data[i];
        if (child.parent) {
            var parent = data[child.parent-1];
        } else {
            var parent = top;
        }
        if (parent.children === undefined){
            parent.children = [];
        }
        parent.children[parent.children.length] = child;
    }
    recurse(top);
}

function recurse(parentObject) {
    var position = newData.length;
    if (parentObject !== top) {
        newData[position] = parentObject;
    }
    if (parentObject.children !== undefined) {
        parentObject.children.sort(myCompare);
        for (var i in parentObject.children) {
            var child = parentObject.children[i];
            recurse(child);
            if (parentObject === top) {
                // do nothing, it's the top container
            } else if (child.parent) {
                child.parent = position + 1;
            } else {
                // leave as null
            }
        }
    }
}

function myCompare(a, b) {
    if (a.sort != b.sort) {
        return (a.sort < b.sort ? -1 : 1);
    }
    return 0;
}

doSort();
于 2013-03-19T07:33:03.880 回答