Skip to content

A
attendance-performance-platform
Commit 312d6fe2 authored by 姬鋆屾's avatar 姬鋆屾
Browse files
Options

推

parent dc407829
Hide whitespace changes
Inline Side-by-side
Showing with 165 additions and 175 deletions
attendance-performance-manager-ui/admin/src/assets/utils/common.js
View file @ 312d6fe2
/** /**
* @desc 克隆 * @desc 克隆
* @param obj 克隆源 * @param obj 克隆源
*/ */
export const deepClone = (obj) => { export const deepClone = (obj) => {
let newObj = Array.isArray(obj) ? [] : {}; let newObj = Array.isArray(obj) ? [] : {};
if (obj && typeof obj === "object") { if (obj && typeof obj === "object") {
for (let key in obj) { for (let key in obj) {
if (obj.hasOwnProperty(key)) { if (obj.hasOwnProperty(key)) {
newObj[key] = newObj[key] =
obj && typeof obj[key] === "object" obj && typeof obj[key] === "object" ? deepClone(obj[key]) : obj[key];
? deepClone(obj[key]) }
: obj[key];
}
}
} }
return newObj; }
} return newObj;
};
/** /**
* @desc 建立树型 * @desc 建立树型
* @param data 数据源 * @param data 数据源
* @param parentId 根节点 * @param parentId 根节点
* @param id id 匹配项 * @param id id 匹配项
* @param pid parentId匹配项 * @param pid parentId匹配项
*/ */
export const toTreeData = (data, parentId, id, pid) => { export const toTreeData = (data, parentId, id, pid) => {
// 建立个树形结构,需要定义个最顶层的父节点，pId是-1 // 建立个树形结构,需要定义个最顶层的父节点，pId是-1
let parent = []; let parent = [];
for (let i = 0; i < data.length; i++) { for (let i = 0; i < data.length; i++) {
if (data[i][pid] != parentId) { if (data[i][pid] != parentId) {
} else { } else {
let obj = {}; let obj = {};
for (let key in data[i]) { for (let key in data[i]) {
obj[key] = data[i][key] obj[key] = data[i][key];
} }
obj['children'] = []; obj["children"] = [];
parent.push(obj); parent.push(obj);
}
} }
fnChildren(parent); }
function fnChildren(parent) { fnChildren(parent);
if (data.length !== 0) { function fnChildren(parent) {
for (let i = 0; i < parent.length; i++) { if (data.length !== 0) {
for (let j = 0; j < data.length; j++) { for (let i = 0; i < parent.length; i++) {
if (parent[i].id == data[j][pid]) { for (let j = 0; j < data.length; j++) {
let obj = {}; if (parent[i].id == data[j][pid]) {
for (let k in data[j]) { let obj = {};
obj[k] = data[j][k] for (let k in data[j]) {
} obj[k] = data[j][k];
obj["children"] = [];
parent[i].children.push(obj);
}
}
fnChildren(parent[i].children);
} }
obj["children"] = [];
parent[i].children.push(obj);
}
} }
fnChildren(parent[i].children);
}
} }
return deleteEmptyChildren(parent); }
return deleteEmptyChildren(parent);
} };
export const deleteEmptyChildren = (arr) => { export const deleteEmptyChildren = (arr) => {
if (arr.length) { if (arr.length) {
for (let i in arr) { for (let i in arr) {
if (arr[i].children.length) { if (arr[i].children.length) {
deleteEmptyChildren(arr[i].children) deleteEmptyChildren(arr[i].children);
} else { } else {
delete arr[i].children; delete arr[i].children;
} }
}
} }
return arr }
} return arr;
};
export const parentTreeNode = (treeList, parentKEY, id) => { export const parentTreeNode = (treeList, parentKEY, id) => {
let temp = [] let temp = [];
let searchFn = function (treeList, id) { let searchFn = function(treeList, id) {
for (let i = 0; i < treeList.length; i++) { for (let i = 0; i < treeList.length; i++) {
let item = treeList[i] let item = treeList[i];
if (item.id === id) { if (item.id === id) {
temp.push(item) temp.push(item);
searchFn(treeList, item[parentKEY]) searchFn(treeList, item[parentKEY]);
break break;
} else { } else {
if (item.children) { if (item.children) {
searchFn(item.children, id) searchFn(item.children, id);
}
}
} }
}
} }
searchFn(treeList, id) };
return temp searchFn(treeList, id);
} return temp;
};
export const childrenTreeNode = (treeList, parentKEY, id) => { export const childrenTreeNode = (treeList, parentKEY, id) => {
let temp = [{ id: id }]; let temp = [{ id: id }];
let searchFn = function (treeList, id) { let searchFn = function(treeList, id) {
for (let i = 0; i < treeList.length; i++) { for (let i = 0; i < treeList.length; i++) {
let item = treeList[i]; let item = treeList[i];
if (item[parentKEY] === id) { if (item[parentKEY] === id) {
temp.push(item); temp.push(item);
searchFn(treeList, item.id); searchFn(treeList, item.id);
// break; // break;
} else { } else {
if (item.children) { if (item.children) {
searchFn(item.children, id); searchFn(item.children, id);
}
}
// console.log("run");
} }
}; }
searchFn(treeList, id); // console.log("run");
return temp; }
} };
searchFn(treeList, id);
return temp;
};
export const getItemData = (list, key, value) => { export const getItemData = (list, key, value) => {
for (let i = 0; i < list.length; i++) { for (let i = 0; i < list.length; i++) {
let item = list[i]; let item = list[i];
if (item[key] === value) { if (item[key] === value) {
return item; return item;
} else { } else {
if (item.children && item.children.length > 0) { if (item.children && item.children.length > 0) {
let res = getItemData(item.children, key, value); let res = getItemData(item.children, key, value);
if (res) { if (res) {
return res; return res;
}
}
} }
}
} }
} }
};
/** /**
* @desc 叶子节点查询根节点 * @desc 叶子节点查询根节点
* @param tree 数据源 * @param tree 数据源
* @param parentId 根节点 * @param parentId 根节点
* @param config id children 匹配项 * @param config id children 匹配项
*/ */
export const getTreeIds = (tree, nodeId, config) => { export const getTreeIds = (tree, nodeId, config) => {
const { children = 'children', id = 'id' } = config || {} const { children = "children", id = "id" } = config || {};
const toFlatArray = (tree, parentId) => { const toFlatArray = (tree, parentId) => {
return tree.reduce((t, _) => { return tree.reduce((t, _) => {
const child = _[children] const child = _[children];
return [ return [
...t, ...t,
parentId ? { ..._, parentId } : _, parentId ? { ..._, parentId } : _,
...(child && child.length ? toFlatArray(child, _[id]) : [])] ...(child && child.length ? toFlatArray(child, _[id]) : []),
}, []) ];
} }, []);
};
const getIds = flatArray => {
let ids = [nodeId] const getIds = (flatArray) => {
let child = flatArray.find(_ => _[id] === nodeId) let ids = [nodeId];
while (child && child.parentId) { let child = flatArray.find((_) => _[id] === nodeId);
ids = [child.parentId, ...ids] while (child && child.parentId) {
child = flatArray.find(_ => _[id] === child.parentId) ids = [child.parentId, ...ids];
} child = flatArray.find((_) => _[id] === child.parentId);
return ids
} }
return ids;
};
return getIds(toFlatArray(tree));
return getIds(toFlatArray(tree)) };
}
/** /**
* 根据树子节点ID查找所有父节点ID * 根据树子节点ID查找所有父节点ID
...@@ -181,40 +167,44 @@ export const getTreeIds = (tree, nodeId, config) => { ...@@ -181,40 +167,44 @@ export const getTreeIds = (tree, nodeId, config) => {
* @returns {array} 包含所有父节点ID的数组，按照从根节点到直接父节点的顺序排序 * @returns {array} 包含所有父节点ID的数组，按照从根节点到直接父节点的顺序排序
*/ */
export const findParentIds = (dataSource, nodeId) => { export const findParentIds = (dataSource, nodeId) => {
const parentIds = []; // 用于存储所有父节点ID的数组 const parentIds = []; // 用于存储所有父节点ID的数组
// 定义一个递归函数，用于遍历整棵树并查找子节点的所有父节点 // 定义一个递归函数，用于遍历整棵树并查找子节点的所有父节点
function traverse(node, nodeId) { function traverse(node, nodeId) {
if (node.id === nodeId) { // 如果当前节点的ID等于子节点的ID，则表示已经找到了子节点，可以开始向上查找父节点 if (node.id === nodeId) {
return true; // 返回true表示已经找到了子节点 // 如果当前节点的ID等于子节点的ID，则表示已经找到了子节点，可以开始向上查找父节点
} return true; // 返回true表示已经找到了子节点
if (node.children) { // 如果当前节点有子节点，则继续遍历子节点 }
for (const childNode of node.children) { if (node.children) {
if (traverse(childNode, nodeId)) { // 如果在子节点中找到了子节点的父节点，则将当前节点的ID添加到父节点ID数组中，并返回true表示已经找到了子节点 // 如果当前节点有子节点，则继续遍历子节点
parentIds.push(node.id); for (const childNode of node.children) {
return true; if (traverse(childNode, nodeId)) {
} // 如果在子节点中找到了子节点的父节点，则将当前节点的ID添加到父节点ID数组中，并返回true表示已经找到了子节点
parentIds.push(node.id);
return true;
} }
} }
return false; // 如果当前节点不是子节点的父节点，则返回false
} }
// 从根节点开始遍历整棵树，并调用递归函数查找子节点的所有父节点 return false; // 如果当前节点不是子节点的父节点，则返回false
for (const node of dataSource) { }
if (traverse(node, nodeId)) { // 如果在当前节点的子树中找到了子节点的父节点，则直接退出循环 // 从根节点开始遍历整棵树，并调用递归函数查找子节点的所有父节点
break; for (const node of dataSource) {
}else{ if (traverse(node, nodeId)) {
if(node.children && node.children.length>0){ // 如果在当前节点的子树中找到了子节点的父节点，则直接退出循环
traverse(node.children, nodeId) break;
} } else {
if (node.children && node.children.length > 0) {
traverse(node.children, nodeId);
} }
} }
return parentIds; // 返回所有父节点ID的数组 }
} return parentIds; // 返回所有父节点ID的数组
};
// 格式化 // 格式化
export const booleanToNum = (val) => { export const booleanToNum = (val) => {
if(val){ if (val) {
return 1 return 1;
}else{ } else {
return 0 return 0;
} }
} };
\ No newline at end of file
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment