用js写一个数组转树结构的代码

很高兴为您服务！根据您的要求，可以使用以下代码实现将数组转换为树结构：

function arrayToTree(data, id = null, link = 'parent_id') {
let tree = [];
let temp;
for (let i = 0; i < data.length; i++) {
if (data[i][link] === id) {
let obj = data[i];
temp = arrayToTree(data, data[i].id);
if (temp.length > 0) {
obj.children = temp;
}
tree.push(obj);
}
}
return tree;
}

相关问题

用javascript帮我写一个数组转树的函数

以下是使用递归的示例代码：

function arrayToTree(arr, parentId = null) {
  let result = []
  for (let i = 0; i < arr.length; i++) {
    if (arr[i].parentId === parentId) {
      let obj = {
        id: arr[i].id,
        name: arr[i].name,
        children: arrayToTree(arr, arr[i].id)
      }
      result.push(obj)
    }
  }
  return result
}

其中，`arr` 是输入的数组，每个元素包含 `id`、`name` 和 `parentId`。`parentId` 为 `null` 表示该元素为根节点。函数返回一个树型结构的数组，每个节点包含 `id`、`name` 和 `children`（子节点数组）。

示例输入：

let arr = [
  { id: 1, name: 'A', parentId: null },
  { id: 2, name: 'B', parentId: 1 },
  { id: 3, name: 'C', parentId: 1 },
  { id: 4, name: 'D', parentId: 2 },
  { id: 5, name: 'E', parentId: 2 },
  { id: 6, name: 'F', parentId: 3 },
  { id: 7, name: 'G', parentId: null },
  { id: 8, name: 'H', parentId: 7 },
]

示例输出：

[
  {
    "id": 1,
    "name": "A",
    "children": [
      {
        "id": 2,
        "name": "B",
        "children": [
          { "id": 4, "name": "D", "children": [] },
          { "id": 5, "name": "E", "children": [] }
        ]
      },
      {
        "id": 3,
        "name": "C",
        "children": [
          { "id": 6, "name": "F", "children": [] }
        ]
      }
    ]
  },
  {
    "id": 7,
    "name": "G",
    "children": [
      { "id": 8, "name": "H", "children": [] }
    ]
  }
]

用 js 写数组转树方法

### 回答1：
可以使用以下代码实现数组转树的方法：

function arrayToTree(arr) {
const map = {};
const roots = [];
let node;

for (let i = ; i < arr.length; i += 1) {
map[arr[i].id] = i;
arr[i].children = [];
}

for (let i = ; i < arr.length; i += 1) {
node = arr[i];
if (node.parentId !== '') {
arr[map[node.parentId]].children.push(node);
} else {
roots.push(node);
}
}

return roots;
}

这个方法可以将一个数组转换为树形结构，其中每个节点都包含一个 id 和 parentId 属性，表示节点的唯一标识和父节点的标识。

### 回答2：
要用 JavaScript 写一个数组转树的方法，可以按照以下步骤进行：

1. 创建一个函数 `arrayToTree`，接受一个参数 `arr`，即要转换的数组。

2. 在函数中创建一个空对象 `tree`，用于最终存储转换后的树形对象。

3. 遍历数组 `arr`，对于每一个元素，执行以下操作：

1. 获取元素的 `parentId`，通常是数组元素中的某个属性，表示该元素的父节点的 `id`。

2. 如果 `parentId` 不存在或为空，则将当前元素作为根节点添加到 `tree` 对象中。否则，将当前元素添加到相应父节点的 `children` 属性中，如果 `children` 属性不存在，则创建一个新数组并将元素添加进去。

4. 循环结束后，返回 `tree` 对象即可。

以下是一段示例代码：

function arrayToTree(arr) {
  let tree = {};
  
  for (let i = 0; i < arr.length; i++) {
    let current = arr[i];
    let parentId = current.parentId;
    
    if (!parentId || parentId === '') {
      tree[current.id] = current;
    } else {
      let parent = tree[parentId];
      if (!parent.children) {
        parent.children = [current];
      } else {
        parent.children.push(current);
      }
    }
  }
  
  return tree;
}

这个方法会将传入的数组转换成一个以 `id` 为键的树形对象，其中每个节点都包含了其对应的子节点。你可以根据实际情况对其进行调整和扩展，例如添加深度遍历的功能等。

### 回答3：
在 JavaScript 中，可以使用以下的方法将一个数组转换成树结构：

1. 首先，创建一个空的对象作为树的根节点；
2. 遍历数组中的每个元素，并将元素的父子关系构建到树中；
3. 遍历数组中的每个元素，将其作为树节点的子节点添加到相应的位置。

下面是一个示例代码：

// 定义一个数组
const arr = [
  { id: 1, name: '节点1', parentId: null },
  { id: 2, name: '节点2', parentId: 1 },
  { id: 3, name: '节点3', parentId: 1 },
  { id: 4, name: '节点4', parentId: 2 },
  { id: 5, name: '节点5', parentId: 4 },
];

// 创建一个空对象作为根节点
const tree = {};

// 遍历数组，建立父子关系
arr.forEach(item => {
  // 取出当前节点的 id 和 parentId
  const { id, parentId } = item;

  // 如果当前节点没有父节点，即是根节点
  if (parentId === null) {
    tree[id] = item; // 将当前节点添加到树
  } else {
    const parent = tree[parentId]; // 找到当前节点的父节点
    if (!parent.children) {
      parent.children = []; // 如果父节点没有子节点数组，就创建一个
    }
    parent.children.push(item); // 将当前节点添加到父节点的子节点数组
  }
});

console.log(tree); // 输出树结构

上述代码中，我们使用了一个对象 `tree` 来保存树结构。根据每个节点的 `id` 和 `parentId` 属性来建立父子关系，并将每个节点添加到对应的父节点的 `children` 属性中。

该方法适用于任意大小的数组，可以根据具体的需求进行调整和扩展。