常用数据获取存储 随机数 正反向遍历 一位数据 树结构

import { isString, isArray, has, compact, cloneDeep } from "lodash";

// 遍历子元素，并添加给定权限
export function traverseChild(currentNode:any, permissionType:any) {
  if (currentNode.children && currentNode.children.length) {
    currentNode.children.forEach(o => {
      if (!o.dataPermissionArr.includes(permissionType)) {
        o.dataPermissionArr.push(permissionType);
        // 1为查看，其它权限需以查看为前提，若无，则添加查看
        if (permissionType !== 1 && !o.dataPermissionArr.includes(1)) {
          o.dataPermissionArr.push(1);
        }
      }
      traverseChild(o, permissionType)
    })
  }
}
// 判断是否为开发环境
export const isDev = () => {
  return process.env.NODE_ENV === "development";
};
// 判断是否是json串
export const isJson = (str: string) => {
  if (isString(str)) {
    try {
      JSON.parse(str);
      return true;
    } catch (e) {
      return false;
    }
  } else {
    return false;
  }
};
function getsec(str = ""): number {
  let str1 = Number(str.substring(1, str.length));
  let str2 = str.substring(0, 1);
  let time = 0;
  switch (str2) {
    case "s":
      time = str1 * 1000;
      break;
    case "h":
      time = str1 * 60 * 60 * 1000;
      break;
    case "d":
      time = str1 * 24 * 60 * 60 * 1000;
      break;
    default:
      time = str1 * 1000;
      break;
  }
  return time;
}
// 设置cookie
export function setCookie(c_name: string, value: any, time = "h1") {
  let strsec: number = getsec(time);
  let exp = new Date();
  exp.setTime(exp.getTime() + strsec * 1);
  document.cookie =
    c_name +
    "=" +
    encodeURI(value) +
    ";expires=" +
    exp.toUTCString() +
    ";path=/";
}
// 获取cookie
export function getCookie(c_name: string): string {
  let cookie = "";
  if (document.cookie.length > 0) {
    let c_start = document.cookie.indexOf(c_name + "=");
    if (c_start != -1) {
      c_start = c_start + c_name.length + 1;
      let c_end = document.cookie.indexOf(";", c_start);
      if (c_end == -1) c_end = document.cookie.length;
      cookie = decodeURI(document.cookie.substring(c_start, c_end));
    }
  }
  return cookie;
}
// 删除cookie
export function delCookie(c_name: string) {
  let exp = new Date();
  exp.setTime(exp.getTime() + 1);
  document.cookie = c_name + "=null;expires=" + exp.toUTCString();
}
// 删除全部cookie
export function clearAllCookie() {
  let keys = document.cookie.match(/[^ =;]+(?=\=)/g);
  if (keys) {
    for (let i = keys.length; i--;) {
      document.cookie = keys[i] + "=null;expires=" + new Date(0).toUTCString();
    }
  }
}
// 设置SessionStorage
export function setSessionStorage(name: string, content: any) {
  if (!name) {
    return;
  }
  let contentTemp = content;
  if (!isString(content)) {
    contentTemp = JSON.stringify(content);
  }
  window.sessionStorage.setItem(name, contentTemp);
}
// 获取SessionStorage
export function getSessionStorage(name: string) {
  if (!name) {
    return;
  }
  let str: any = window.sessionStorage.getItem(name);
  return isJson(str) ? JSON.parse(str) : str;
}
// 删除SessionStorage
export function removeSessionStorage(name: string) {
  if (!name) {
    return;
  }
  window.sessionStorage.removeItem(name);
}
// 递归遍历正向
export function treeEach(treeArray: any[], fn: any, prop = "children") {
  if (!treeArray || !Array.isArray(treeArray) || treeArray.length <= 0) {
    return null;
  }
  treeArray.map((item) => {
    fn(item);
    treeEach((item && item[prop]) || [], fn, prop);
  });
}
// 递归遍历反向
export function treeEachDFS(treeArray: any, fn: any, prop = "children") {
  if (!treeArray || !Array.isArray(treeArray) || treeArray.length <= 0) {
    return null;
  }
  let nodes = treeArray.slice();
  for (let i = 0; i < nodes.length; i++) {
    let node = nodes[i];
    if (node[prop] && node[prop].length) {
      treeEachDFS(node[prop], fn);
    }
    fn(node);
  }
}

// 递归过滤正向
export function treeFilter(
  treeArray: any[],
  fn: any,
  prop = "children"
): any[] {
  if (!treeArray || !Array.isArray(treeArray) || treeArray.length <= 0) {
    return [];
  }
  let narr = treeArray.filter((item) => {
    return fn(item);
  });
  return narr.map((item) => {
    if (item[prop] && item[prop].length > 0) {
      item[prop] = treeFilter(item[prop], fn, prop);
    }
    if (item[prop] && item[prop].length === 0) {
      delete item[prop];
    }
    return item;
  });
}

// 递归过滤反向
export function treeFilterDFS(
  treeArray: any[],
  fn: any,
  prop = "children"
): any[] {
  if (!treeArray || !Array.isArray(treeArray) || treeArray.length <= 0) {
    return [];
  }
  return treeArray.map((item) => {
    if (item[prop] && item[prop].length > 0) {
      item[prop] = treeFilterDFS(item[prop], fn, prop);
    }
    if (item[prop]) {
      let narr = compact(item[prop]);
      narr.length === 0 && delete item[prop];
    }
    if (fn(item)) {
      return item;
    }
  });
}

//随机返回num位字符
export function getRandomNumber(num: number) {
  let randomStr = "";
  let arr = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
  for (let i = 0; i < num; i++) {
    let index = Math.floor(Math.random() * 10);
    randomStr += arr[index];
  }
  return randomStr;
}

// 获取一维数组选中的选项的全部内容
export function getSelectedItems(value, options) {
  let valueArr: any[] = [];
  if (isArray(value)) {
    valueArr = value;
  } else {
    valueArr = [value];
  }
  const selected = options.filter((item) => {
    return valueArr.includes(item.id);
  });
  let selecteds = null;
  selected.length > 1 ? selected : selected[0];
  if (selected.length > 0) {
    selecteds = selected.length > 1 ? selected : selected[0];
  }
  return selecteds;
}
// 获取树选中的选项的全部内容
export function getTreeSelectedItems(value, options, keyprop) {
  let valueArr: any[] = [];
  if (isArray(value)) {
    valueArr = value;
  } else {
    valueArr = [value];
  }
  let selecteds: any = null;
  treeEach(options.value, (item) => {
    if (valueArr.includes(item[keyprop])) selecteds = item;
  });
  return selecteds;
}
// 过滤一维数组选项
export const formatOptions = (
  options,
  data,
  key = "id",
  prop = "displayStatus",
  eq = ["1"]
) => {
  let selected: any[] = [];
  if (isArray(data[key])) {
    selected = data[key];
  } else {
    selected = [data[key]];
  }
  let activeArr = [];
  activeArr = options.filter((item) => {
    if (has(item, prop)) {
      return eq.includes(String(item[prop])) || selected.includes(item[key]);
    } else {
      return true;
    }
  });
  return activeArr;
};

// 过滤树形数组选项
export const formatTreeOptions = (
  options,
  data,
  key = "id",
  prop = "displayStatus",
  eq = ["1"]
) => {
  let selected: any[] = [];
  if (isArray(data[key])) {
    selected = data[key];
  } else {
    selected = [data[key]];
  }
  let activeArr: any[] = [];
  activeArr = treeFilter(cloneDeep(options), (item) => {
    if (has(item, prop)) {
      return eq.includes(String(item[prop])) || selected.includes(item[key]);
    } else {
      return true;
    }
  });
  return activeArr;
};