Question

我使用Tree结构来显示未隐藏的类型。为此，我将删除hidden = true完全正常工作的类型

var filtertypes = function (types) {
    for (var i = 0, l = types.length; i < l; i++) {
      var type = types[i];
      if (type && !type.hidden) {
        if (type.text) {
          type.n = type.text
          type.id = type.id;
        }
        if (type.children) {
          filtertypes(type.children);
        }
      } else {
         types.splice(i, 1);
         filtertypes(types);
      }
    }
    return types;
  };

但由于这对编辑数据（即类型）并不好，所以现在我想创建一个只有非隐藏值的新数组。所以我想要一个函数，我提供types作为数据，它返回所有未隐藏的类型。

注意： - 类型结构如下

1    11    111
     12    121
     13
2    21    211
           212
     22    221 
           222
3    31    311
           312
     32    321 
           322

假设隐藏了13,121,21,31,32，我应该得到如下输出

[1,2,3]

Where 1.children should be should get [11, 12] #as 13 is hidden
        11.children should be [111]
        12.children should be nil #as 121 is hidden
        3.children should be nil #as 31, 32 are hidden

Answer 1

您必须在以前修改过原始文件的每个地方创建新的数组和对象：

var filtertypes = function (types) {
    var newTypes = [];
    for (var i = 0, l = types.length; i < l; i++) {
      var type = types[i];
      if (type && !type.hidden) {
        var newType = extend({}, type); //replace extend with Object.assign, angular.extend or similar
        if (type.children) {
          newType.children = filtertypes(type.children);
        }
        newTypes.push(newType);
      }
    }
    return newTypes;
  };

您还可以查看不可变的数据结构immutable.js，这可能会有所帮助。

Answer 2

function filterInputs(types){
        types = types.filter(function(type){
           if(type.hidden){
              return false;
           }
           if(type.children){
              filterInputs(type.children);
           }
           if(type.text){
              type.n = type.text
              type.id = type.id;
           }
           return true;
       });
    }

就在我脑海里。可能需要进行测试和调整一下。

Answer 3

使用Array.prototype.filter()函数mdn

（如果不应修改原始对象，请不要忘记创建原始对象的副本）

    var types = [
    {nr:1, hidden:false, children:[
        {nr:11, hidden:false, children:[{nr:111, hidden:false}]},
        {nr:12, hidden:false, children:[{nr:121, hidden:true}]},
        {nr:13, hidden:true}
    ]},
    {nr:2, hidden:false, children:[
        {nr:21, hidden:true, children:[{nr:211, hidden:false}, {nr:212, hidden:false}]},
        {nr:22, hidden:false, children:[{nr:221, hidden:false}, {nr:222, hidden:false}]}
    ]},
    {nr:3, hidden:false, children:[
        {nr:31, hidden:true, children:[{nr:311, hidden:false}, {nr:312, hidden:false}]},
        {nr:32, hidden:true, children:[{nr:321, hidden:false}, {nr:322, hidden:false}]}
    ]}
];

// To ensure the original object tree isn't modified, deepclone it first
var copyOfTypes = JSON.parse(JSON.stringify(types))

// Filter the types array
var nonHiddenTypes = copyOfTypes.filter(filterTypes);

function filterTypes(type){
    if(type.hidden) {
        return false; // current item will NOT be in the new array
    }

    if(type.children) {
        type.children = type.children.filter(filterTypes); // recursive filter the children
    }

    return true; // current item will be in the new array
}

请参阅JSFiddle

如何使用递归方法从数组中删除隐藏元素

3 个答案: