数组对象相同的键组成对象

的方法是什么？

你可以使用 ES6 中的 Map 对象来实现。Map 对象可以存储键值对，并且键可以是任意类型的，包括对象。因此，你可以将数组对象中相同的键作为 Map 对象的键，将对应的值作为 Map 对象的值，最终将 Map 对象转换为普通对象即可。以下是示例代码：

const arr = [{key: 'a', value: 1}, {key: 'b', value: 2}, {key: 'a', value: 3}];

const map = new Map();

arr.forEach(item => {
if (!map.has(item.key)) {
map.set(item.key, []);
}
map.get(item.key).push(item.value);
});

const result = Object.fromEntries(map.entries());

console.log(result); // {a: [1, 3], b: [2]}

相关问题

一个父级数组对象一个子级数组对象 组成父子级结构

如果我们有一个父级数组对象和一个子级数组对象，同样可以使用类似的方法将它们组成父子级结构。我们可以先将父级数组对象和子级数组对象中的每个元素都放入 Map 中，并将它们的 id 作为 Map 的键，然后使用一个循环遍历子级数组对象，每次取出一个子级元素对象，找到它在 Map 中对应的父级元素对象，并将该子级元素对象添加到父级元素对象的子节点列表中。

以下是一个简单的 Java 代码实现：

public static List<TreeNode> buildTree(List<Parent> parents, List<Child> children) {
    Map<Integer, TreeNode> map = new HashMap<>();

    // 将父级数组对象和子级数组对象中的每个元素都放入 Map 中
    for (Parent parent : parents) {
        map.put(parent.getId(), new TreeNode(parent.getId(), parent.getName()));
    }

    for (Child child : children) {
        map.put(child.getId(), new TreeNode(child.getId(), child.getName()));
    }

    // 遍历子级数组对象，将子级元素对象添加到对应的父级元素对象的子节点列表中
    for (Child child : children) {
        int parentId = child.getParentId();
        TreeNode parentNode = map.get(parentId);
        TreeNode childNode = map.get(child.getId());
        parentNode.addChild(childNode);
    }

    // 找到根节点
    List<TreeNode> roots = new ArrayList<>();
    for (TreeNode node : map.values()) {
        if (node.getParent() == null) {
            roots.add(node);
        }
    }

    return roots;
}

其中，Parent 和 Child 是父级数组对象和子级数组对象的类，包含 id 和 name 两个属性。

public class Parent {
    private int id;
    private String name;

    public Parent(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

public class Child {
    private int id;
    private String name;
    private int parentId;

    public Child(int id, String name, int parentId) {
        this.id = id;
        this.name = name;
        this.parentId = parentId;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getParentId() {
        return parentId;
    }

    public void setParentId(int parentId) {
        this.parentId = parentId;
    }
}

这个函数的输入是一个父级数组对象和一个子级数组对象，输出是一个树形结构，每个节点包含一个 id、name 和它的子节点列表。如果一个节点没有父节点，它就是根节点。

对象中相同的键重新组成对象

可以使用 JavaScript 中的 reduce 方法来实现这个功能，具体代码如下：

const obj = { a: 1, b: 2, c: 3, d: 4, e: 5, f: 6, g: 7, h: 8, i: 9, j: 10 };

const result = Object.keys(obj).reduce((acc, key) => {
  const newKey = obj[key];
  if (!acc[newKey]) {
    acc[newKey] = [];
  }
  acc[newKey].push(key);
  return acc;
}, {});

console.log(result);

这段代码会将原始对象中相同的键重新组成一个新的对象，新对象的键是原始对象中相同的值，值是一个数组，包含了原始对象中所有的相同键。