树结构数据各种递归

/**
* 树组件节点添加属性
* @param {Object}    data 树的源数据
* @returns {Object}  data 添加自定义属性后的树的数据
*/
setTreeRecursion(data) {
    data.map((item,index) => {
    item.scopedSlots = { title: 'customNode'};
    if(item.children.length != 0){
      this.setTreeRecursion(item.children);
    }
  });
  return data;
}
setTreeRecursion('树结构数据')

/**
 * 查询 树组件 共有多少节点
 * @param {Object}    data 树的源数据
 * @returns {Number}  num 总节点数
 */
queryNodesTotal(data, num = 0){
  let forFn = (nodes) => {
    for(let i = 0; i < nodes.length; i++){
      num++;
      if(nodes[i].children){
        forFn(nodes[i].children);
      }
    }
  }
  forFn(data);
  return num;
}
queryNodesTotal('树结构数据')

/**
 * 取出树组件最后子节点---一维数组
 * @param {Object}     node 树的源数据
 * @returns {Object}   temp 取出树组件最后子节点的集合
 */
getLastChildNode(node, temp = []) {
  let forFn = (arr) => {
    for (let i = 0; i < arr.length; i++) {
      if (arr[i].children.length === 0) {
        temp.push(arr[i]);
      } else {
        forFn(arr[i].children)
        // if(arr[i].children.length != 0){
        // forFn(arr[i].children)
        // }
      }
    }
  }
  forFn(node)
  return temp;
}
getLastChildNode('树结构数据')

/**
 * 取出树组件最后子节点---二维数组
 * @param {Object}      node 树的源数据
 * @returns {Object}    temp 取出树组件最后子节点的集合
 */
getLastChildNode(node, temp = []) {
  let forFn = (arr) => {
    for (let i = 0; i < arr.length; i++) {
      if (arr[i].children.length === 0) {
        temp.push(arr);
        arr = [];
      } else {
        forFn(arr[i].children)
      }
    }
  }
  forFn(node)
  return temp;
}
getLastChildNode('树结构数据')

/**
 * 删除树组件源数据的最后子节点
 * @param {Object}     node 树的源数据
 * @returns {Object}   node 删除最后子节点之后的树的数据
 */
deleteSourceNode(node) {
  for (let i = node.length - 1; i >= 0; i--) {
    if (!node[i].hasOwnProperty('children')) {
      continue;
    }
    if (node[i].children.length === 0) {
      node.splice(i, 1);
      continue;
    }
    this.deleteSourceNode(node[i].children);
  }
  return node;
}
deleteSourceNode('树组件数据')

/**
 * 查询 树组件 父节点
 * @param {Object}     node 树的源数据
 * @param {Object}     pid  节点的pid
 * @returns {Object}   temp 返回的父节点数据
 */
queryParentNode(node, pid, temp = undefined){
  let forFn = (arr, id) => {
    for (let i = 0; i < arr.length; i++) {
      if (arr[i].id === id) {
        temp = arr[i]; // 查询父级节点
        break;
        // 如需查询所有父节点: 参数 temp 的默认值设置为空数组('[]')
        // temp.push(arr[i]); // arr[i]应 push 到 temp 中
        // forFn(node, arr[i].pId); // 继续递归查询
        // break;
      } else {
        if (arr[i].children) {
          forFn(arr[i].children, id)
        }
      }
    }
  }
  forFn(node, pid);
  return temp;
}
queryParentNode('树组件数据', '节点的pId')

/**
 * 树形数据（数组）获取最深层级数
 * @param {Object}     treeData 树的源数据
 * @returns {Number}   max 最深层级数的值
 */
getMaxFloor(treeData) {
  let floor = 0;
  let max = 0;
  let deepEach = (data, floor) => {
    data.map((item,index) => {
      item.floor = floor;
      if (floor > max) {
        max = floor;
      };
      if (item.children.length > 0) {
        deepEach(item.children, floor + 1);
      };
    });
  };
  deepEach(treeData, 1);
  return max;
}
getMaxFloor('树组件数据')

/**
 * 将树结构数据格式，转化为，二维数组 表格形式
 * @param {Object}     node 树的源数据
 * @returns {Object}   data 树转化为二维数组的数据
 */
parseTreeToRow(node, data = [], row = []) {
  if (node.children.length === 0) {
    data.push(row);
  } else {
    node.children.map((item,index) => {
      const obj = {
        label:item.label,
        id: item.id,
        isfile: item.isfile,
        pId: item.pId
      };
      this.parseTreeToRow(item, data, [...row, obj]);
    });
  }
  return data;
}
// 需要一个  只有一个根节点 的数据
let obj = {
  id: '',
  isfile: false,
  label: '',
  pId: '',
  children: '树组件数据'
}
parseTreeToRow(obj)

/**
 * 查询树组件的所有父节点
 * @param {Object}     treeData 树的源数据
 * @returns {Object}   id 节点的id
 */
findParents(treeData,id) {
  let allparents = []
  if(treeData.length === 0){
    return 
  }
  let findele = (data,id) => {
    if (!id) return
    data.forEach((item,index) => {
      if (item.id === id) {
        allparents.unshift(item.id)
        findele(treeData,item.parentId)
      } else {
        if (item.children) {
            findele(item.children,id)
        }
      }
    })
  }
  findele(treeData,id)
  return allparents
}

/**
 * 递归组装树数据
 * @param {*} arr 
 * @param {*} pid 
 * @returns 组装好的树结构
 */
function createTree(arr, pid = 0) {
  return arr
    .filter((v) => v.parent_id === pid)
    .map((v) => {
      v = JSON.parse(JSON.stringify(v))
      const children = createTree(arr, v.id)
      if (children.length) {
        v.children = createTree(arr, v.id)
      }
      return v
    })
}