JS 中数组、树常用方法总结

数组

数组转树

/**
 * 数组转树-递归版本
 * @param list
 * @param pid
 * @returns {*[]}
 */
export function listToTree (list, pid = -1) {
  const tree = []
  for (let i = 0, total = list.length; i < total; i++) {
    const item = list[i]
    if (item.pid === pid) {
      item.children = listToTree(list, item.id)
      tree.push(item)
    }
  }
  return tree
}

/**
 * 数组转树-非递归版本
 * @param list
 * @param pid
 * @returns {*[]}
 */
export function listToTree2 (list, pid = -1) {
  const map = {}
  const tree = []
  for (let i = 0, total = list.length; i < total; i++) {
    map[list[i].id] = list[i]
    list[i].children = []
  }
  for (let i = 0, total = list.length; i < total; i++) {
    const item = list[i]
    if (item.pid === pid) {
      tree.push(item)
      continue
    }
    if (map[item.pid].children) {
      map[item.pid].children.push(item)
    } else {
      map[item.pid].children = [item]
    }
  }
  return tree
}

/**
 * 数组转树带层级
 * @param list
 * @param pid
 * @param level
 * @returns {*[]}
 */
export function listToTreeAddLevel (list, pid = -1, level = 0) {
  const tree = []
  for (let i = 0, total = list.length; i < total; i++) {
    const item = list[i]
    if (item.pid === pid) {
      item.level = level
      item.children = listToTreeAddLevel(list, item.id, level + 1)
      tree.push(item)
    }
  }
  return tree
}

树

树转数组

/**
 * 树转数组-递归法
 * @param tree
 * @param key
 * @returns {*[]}
 */
export function treeToList (tree = {}, key = 'children') {
  let list = []
  if (tree) {
    list.push(tree)
    const children = tree[key]
    for (let i = 0; i < children.length; i++) {
      const child = treeToList(children[i])
      list = [...list, ...child]
    }
  }
  return list
}

/**
 * 树转数组-非递归
 * @param tree
 * @param key
 * @returns {*[]}
 */
export function treeToList2 (tree = [], key = 'children') {
  const list = []
  let queue = []
  queue = queue.concat(tree)
  while (queue.length) {
    const item = queue.shift()
    if (item[key]) {
      queue = queue.concat(item[key])
    }
    list.push(item)
  }
  return list
}

其他方法

/**
 * 树给父级元素添加禁用
 * @param tree
 * @returns {*[]}
 */
export function treeAddDisabled (tree = []) {
  for (let i = 0, length = tree.length; i < length; i++) {
    if (tree[i].children?.length) {
      tree[i].disabled = true
      treeAddDisabled(tree[i].children)
    }
  }
  return tree
}

/**
 * 树节点添加标识
 * @param tree
 * @param init
 * @returns {*[]}
 */
export function treeAddLevel (tree = [], init = -1) {
  for (let i = 0; i < tree.length; i++) {
    tree[i].level = init + 1
    if (tree[i].children?.length) {
      treeAddLevel(tree[i].children, tree[i].level)
    }
  }
  return tree
}

/**
 * 获取树节点 key
 * @param tree
 * @param key
 * @returns {*[]}
 */
export function getTreeKeys (tree = [], key = 'key') {
  const list = treeToList2(tree)
  return list.map(item => item[key])
}

/**
 * 获取树某一节点数据
 * @param tree
 * @param id
 * @param key
 * @returns {*[]}
 */
export function getTreeItem (tree = [], id, key = 'id') {
  const list = treeToList2(tree)
  return list.filter(item => item[key] === id)
}

/**
 * 获取树中第一个子节点
 * @param tree
 * @param firstItem
 * @returns {*[]}
 */
export function getTreeFirstItem (tree = [], firstItem = []) {
  tree.map((item, index) => {
    if (index === 0) {
      if (!item?.children?.length) {
        firstItem.push(item)
      } else {
        getTreeFirstItem(item.children, firstItem)
      }
    }
  })
  return firstItem
}

/**
 * 获取最深层节点 key
 * @param tree
 * @param list
 * @param key
 * @returns {*[]}
 */
export function getDeepList (tree = [], list = [], key = 'key') {
  tree.map(item => {
    if (item?.children?.length) {
      getDeepList(item.children, list, key)
    } else {
      list.push(item[key])
    }
  })
  return list
}

/**
 * 已知子节点id, 从下往上组装树节点路径
 * @param tree
 * @param target
 * @param key
 * @returns {*[]}
 */
export function findLeafPathInTree (tree = [], target = 0, key = 'id') {
  let path = null
  for (let i = 0, length = tree.length; i < length; i++) {
    const item = tree[i]
    if (item.children?.length > 0) {
      path = findLeafPathInTree(item.children, target, key)
      if (path) {
        path.unshift(item[key])
        return path
      }
    } else {
      if (item[key] === target) {
        return [item[key]]
      }
    }
  }
  return path
}