Question

我试图打印所有已创建的群组并且他们是小孩，所以它看起来像这样：

[ [ 'Father1', 'Child1', 'Child2', 'Child3' ],
  [ 'Father1', 'Child1', 'Child4' ],
  [ 'Father1', 'Child1', 'Child5' ] ]

我遇到的问题各不相同。从： var keys = name.keys（o）; ^ TypeError：name.keys不是总堆栈溢出的函数，iv调试了printPath函数，它是单独完成它的工作，而不是我的最终树结构。

我的树和打印功能如下：

groups.js：

class groups {
    constructor() {
        this.root = new Group('root');
    }



    printPath(name){
        this.root.getPath(name)
    }

group.js：

class Group {
    constructor(name, parent) {
        this.name = name;
        this.parent = parent || null;
        this.children = [];
        this.users = new users || null;
    }



     getPath(name) {
        function iter(o, p)  {
            var keys = name.keys(o);
            if (keys.length) {
                return keys.forEach(function (k) {
                    iter(o[k], p.concat(k));
                });
            }
            result.push(p);
        }

        var result = [];
        iter(name, []);
        return result;
    }

修改 使用菜单处理函数创建群组

function createGroup(callback) {
    rl.question('Add name for father group: \n', (parent) => {
        let parentGroup = programdata.groups.findGroupByName(parent);

        if (!parentGroup) {
            parentGroup = programdata.groups.root;
        }

        rl.question('name of new group\n', (groupName) => {
            parentGroup.setChildren(new Group(groupName, parentGroup));

            console.log(parentGroup);
            callback();
          });
        })
    }

findGroupByName是一个很好的递归，我发现它位于类组中的嵌套组（随意使用！）。

 findGroupByName(name) {
   if (!name) return null;

   return this._findGroupByNameInternal(this.root, name);
   }


    _findGroupByNameInternal(group, name) {
   if (!group) return null;

   if (group.name === name) return group;

  for (const g of group.children) {
    const result = this._findGroupByNameInternal(g, name);

    if (!result) continue;

    return result;
    }
   }

并将setChildren函数放在类Group：

中

setChildren(child) {
    this.children.push(child);
}

修改谢谢你的答案，请你帮我在菜单处理程序中实现你的方法？我试过这个：它什么都没给我。

 function createGroup(callback) {
 rl.question('Add name for father group: \n', (parent) => {
let parentGroup = programdata.groups.findGroupByName(parent);
let treePath = Group.root.printPath();
if (!parentGroup) {
    parentGroup = programdata.groups.root;
}

rl.question('name of new group\n', (groupName) => {
    parentGroup.addChild(new Group(groupName, parentGroup));

    console.log(treePath);
    callback();
   });
 })
}

Answer 1

您收到错误TypeError: name.keys is not a function的根本原因是字符串作为参数getPath(name)传递给name，您知道JS字符串对象没有函数属性键

我重构你的代码并修复了一些错误，这是可测试的版本。请将它们放在同一文件夹中并运行test.js。

group.js

class Group {


constructor(name, parent) {
    this.name = name;
    this.parent = parent || null; // Point to this group's father
    this.children = []; // Children of this group, can be sub-group or string
    if (!!parent) { // Link to the father
      parent.addChild(this);
    }
    // this.users = new users || null; // Useless, remove it.
  }

  addChild(...args) {
    for(let o in args) {
      this.children.push(args[o]);
    }
  }

  /**
   * Recursion to build the tree
   * @param group
   * @returns {*}
   */
  iter(group) {
    let children = group.children;
    if (Array.isArray(children)) { // If the child is a group
      if (children.length > 0) {
        let result = [];
        result.push(group.name);
        for (let child of children) {
          result.push(group.iter(child));
        }
        return result;
      }
      else {
        return [];
      }
    }
    else { // If the group is a string
      return group;
    }
  }

  getPath() {
    return this.iter(this);
  }
}

module.exports = Group;

groups.js

let Group = require('./group');

class Groups {
  constructor() {
    this.root = new Group('root');
  }

  printPath() {
    return this.root.getPath();
  }
}

module.exports = Groups;

test.js

let Group = require('./group');
let Groups = require('./groups');

// Root
let rootGroups = new Groups();

// Group 1
let group1 = new Group('Father1', rootGroups.root);
group1.addChild('Child1', 'Child2', 'Child3');

// Group 2
let group2 = new Group('Father1', rootGroups.root);
group2.addChild('Child1', 'Child4');

// Group 3
let group3 = new Group('Father1', rootGroups.root);
group3.addChild('Child1', 'Child5');

let treePath = rootGroups.printPath();
console.log(treePath);

输出为：

[ 'root',
  [ 'Father1', 'Child1', 'Child2', 'Child3' ],
  [ 'Father1', 'Child1', 'Child4' ],
  [ 'Father1', 'Child1', 'Child5' ] ]

Process finished with exit code 0

享受它：）

Answer 2

好的，找到了解决方案。

  Treeshow(){
    var node = this.root;
    var depth = '-'
    recurse( node );
    function recurse( node) {
        depth +='-'
        console.log(depth+node.name);

        for (var child in node.children ) {
            recurse(node.children[child]);
        }
        depth  = depth.slice(0, -1);
    }
}

将显示我的树：

--root
---FooFather
----BarSemiFather
-----FooChild
------BarBaby

在nodeJS app中打印我的组树时出现问题

2 个答案:

group.js

groups.js

test.js

输出为：