工具包 -- 开发中一些常用的公共方法

lodash 是一个一致性、模块化、高性能的 JavaScript 实用工具库。(强烈推荐)

import isEmpty from "lodash/isEmpty";
import router from "../router";
/**
 * @description: 路由跳转
 */
export const jump = (name, query = {}, params = {}) => {
  router.push({
    name: name,
    query: query,
    params: params
  });
};
/**
 * @description: tree转数组
 * @param {type}
 * @return:
 * @use:
 */
export const treeToArray = (tree, key) => {
  return [].concat(
    ...tree.map(item => {
      if (item[key] && item[key].length) {
        return [].concat(item, ...treeToArray(item[key]));
      } else {
        return item;
      }
    })
  );
};
/**
 * @description: 数组转tree
 * @param {type}
 * @return:
 * @use:
 */
export const listToTree = (list = [], pidField = "parentId") => {
  const data = JSON.parse(JSON.stringify(list)); // 浅拷贝不改变源数据
  const result = [];
  if (!Array.isArray(data)) {
    return result;
  }
  data.forEach(item => {
    delete item.children;
  });
  const map = {};
  data.forEach(item => {
    map[item.id] = item;
  });
  data.forEach(item => {
    const parent = map[item[pidField]];
    if (parent) {
      (parent.children || (parent.children = [])).push(item);
    } else {
      result.push(item);
    }
  });
  return result;
};

/**
 * @description: 获取头像
 * @param {type}
 * @return:
 * @use:
 */
export const getAvatarUrl = url => {
  if (url) {
    return url;
  } else {
    return "/images/avatar.png";
  }
};

//根据key获取对象值
export const getObj = (key, obj) => {
  let value = obj;
  if (key.indexOf(".") > -1) {
    const keysArr = key.split(".");
    for (let i = 0; i < keysArr.length; i++) {
      const k = keysArr[i];
      value = value[k];
    }
  } else {
    value = value[key];
  }
  return value;
};

//数组去重
export const arrayUnique = arr => {
  var hash = [];
  for (var i = 0; i < arr.length; i++) {
    if (arr.indexOf(arr[i]) == arr.lastIndexOf(arr[i])) {
      hash.push(arr[i]);
    }
  }
  return hash;
};
export const arrayUnique2 = arr => {
  var arr1 = [];
  for (var i = 0, len = arr.length; i < len; i++) {
    if (!arr1.includes(arr[i])) {
      // 检索arr1中是否含有arr中的值
      arr1.push(arr[i]);
    }
  }
  return arr1;
};

export const hasClass = (elements, cName) => {
  return !!elements.className.match(new RegExp("(\\s|^)" + cName + "(\\s|$)"));
};
export const addClass = (elements, cName) => {
  if (!hasClass(elements, cName)) {
    elements.className += " " + cName;
  }
};
export const removeClass = (elements, cName) => {
  if (hasClass(elements, cName)) {
    elements.className = elements.className.replace(
      new RegExp("(\\s|^)" + cName + "(\\s|$)"),
      " "
    );
  }
};
// 拖拽改变数组排序
export const applyDrag = (arr, dragResult) => {
  const { removedIndex, addedIndex, payload } = dragResult;
  if (removedIndex === null && addedIndex === null) return arr;
  const result = [...arr];
  let itemToAdd = payload;
  if (removedIndex !== null) {
    itemToAdd = result.splice(removedIndex, 1)[0];
  }
  if (addedIndex !== null) {
    result.splice(addedIndex, 0, itemToAdd);
  }
  return result;
};

export const accMul = (arg1, arg2) => {
  var m = 0,
    s1 = arg1.toString(),
    s2 = arg2.toString();
  try {
    m += s1.split(".")[1].length;
  } catch (e) {}
  try {
    m += s2.split(".")[1].length;
  } catch (e) {}
  return (
    (Number(s1.replace(".", "")) * Number(s2.replace(".", ""))) /
    Math.pow(10, m)
  );
};
export const accAdd = (arg1, arg2) => {
  var r1, r2, m, c;
  try {
    r1 = arg1.toString().split(".")[1].length;
  } catch (e) {
    r1 = 0;
  }
  try {
    r2 = arg2.toString().split(".")[1].length;
  } catch (e) {
    r2 = 0;
  }
  c = Math.abs(r1 - r2);
  m = Math.pow(10, Math.max(r1, r2));
  if (c > 0) {
    var cm = Math.pow(10, c);
    if (r1 > r2) {
      arg1 = Number(arg1.toString().replace(".", ""));
      arg2 = Number(arg2.toString().replace(".", "")) * cm;
    } else {
      arg1 = Number(arg1.toString().replace(".", "")) * cm;
      arg2 = Number(arg2.toString().replace(".", ""));
    }
  } else {
    arg1 = Number(arg1.toString().replace(".", ""));
    arg2 = Number(arg2.toString().replace(".", ""));
  }
  return (arg1 + arg2) / m;
};

// +-*/计算
function NumberCalculation(num, fixed) {
  this.fixed = fixed;
  this.num = num;
}

NumberCalculation.prototype = {
  number: function(fixed) {
    fixed = fixed ? fixed : this.fixed;
    if (fixed) {
      return Number(this.num.toFixed(fixed));
    } else {
      return this.num;
    }
  },
  conversionType: function(item) {
    var type = typeof item;
    if (item instanceof NumberCalculation) {
      item = item.num;
    }
    return item;
  },
  //加法
  add: function(...arg) {
    var that = this;
    arg.forEach(function(item) {
      that.addFuc(item);
    });
    return this;
  },
  //减法
  minus: function(...arg) {
    var that = this;
    arg.forEach(function(item) {
      that.minusFuc(item);
    });
    return this;
  },
  //乘法
  multiply: function(...arg) {
    var that = this;
    arg.forEach(function(item) {
      that.multiplyFuc(item);
    });
    return this;
  },
  //除法
  divide: function(...arg) {
    var that = this;
    arg.forEach(function(item) {
      that.divideFuc(item);
    });
    return this;
  },
  //加法
  addFuc: function(y) {
    if (!y) {
      y = 0;
    }
    var x = this.num.toString(),
      rX,
      rY,
      m;
    y = this.conversionType(y).toString();
    try {
      rX = x.split(".")[1].length;
    } catch (e) {
      rX = 0;
    }
    try {
      rY = y.split(".")[1].length;
    } catch (e) {
      rY = 0;
    }
    m = Math.pow(10, Math.max(rX, rY));
    this.num = (x * m + y * m) / m;
    return this;
  },
  //减法
  minusFuc: function(y) {
    if (!y) {
      y = 0;
    }
    var x = this.num.toString(),
      rX,
      rY,
      m,
      n;
    y = this.conversionType(y).toString();
    try {
      rX = x.split(".")[1].length;
    } catch (e) {
      rX = 0;
    }
    try {
      rY = y.split(".")[1].length;
    } catch (e) {
      rY = 0;
    }
    m = Math.pow(10, Math.max(rX, rY));
    n = rX >= rY ? rX : rY;
    this.num = Number(((x * m - y * m) / m).toFixed(n));
    return this;
  },
  //乘法
  multiplyFuc: function(y) {
    if (!y) {
      y = 0;
    }
    var x = this.num,
      m = 0;
    x = Number(x).toString();
    y = this.conversionType(y).toString();
    try {
      m += x.split(".")[1].length;
    } catch (e) {}
    try {
      m += y.split(".")[1].length;
    } catch (e) {}
    this.num =
      (Number(x.replace(".", "")) * Number(y.replace(".", ""))) /
      Math.pow(10, m);
    return this;
  },
  //除法
  divideFuc: function(y) {
    if (!y) {
      y = 0;
    }
    var x = this.num.toString(),
      m = 0,
      n = 0,
      rX,
      rY;
    y = this.conversionType(y).toString();
    try {
      m = x.split(".")[1].length;
    } catch (e) {}
    try {
      n = y.split(".")[1].length;
    } catch (e) {}
    rX = Number(x.replace(".", ""));
    rY = Number(y.replace(".", ""));
    this.num = rX / rY;
    this.num = this.multiply(Math.pow(10, n - m)).number();
    return this;
  }
};
// +-*/计算
export function calc(num, fixed) {
  return new NumberCalculation(num, fixed);
}

// 设置当前url
export const setCurrentUrl = url => {
  window.history.replaceState(
    {
      path: url
    },
    "",
    url
  );
};

// 获取树形数据子节点的父级节点
export function treeFindPath(tree, func, path = [], field = "name") {
  if (!tree) return [];
  for (const data of tree) {
    // 这里按照你的需求来存放最后返回的内容吧
    path.push(data[field]);
    if (func(data)) return path;
    if (data.children) {
      const findChildren = treeFindPath(data.children, func, path);
      if (findChildren.length) return findChildren;
    }
    path.pop();
  }
  return [];
}
/**
 * /导出数据下载
 * @param {*} content 流文件
 * @param {*} fileName 文件名
 */
export const DownLoad = (content, fileName) => {
  const blob = new Blob([content]);
  var a = document.createElement("a");
  var url = window.URL.createObjectURL(blob);
  a.href = url;
  a.download = fileName;
  // a.style.display = "none";
  // document.body.appendChild(a);
  //a.remove();
  a.click();
  window.URL.revokeObjectURL(url);
};

export const createEnum = object => {
  let arr = {};
  for (const key in object) {
    const value = object[key];
    arr[(arr[value] = key)] = value;
  }
  return key => {
    return arr[key];
  };
};
//是否有数字
export const hasInt = num => {
  if (/(^[1-9]\d*$)/.test(Number(num))) {
    return true;
  }
  return false;
};
//是否为正整数
export const validatorInt = (rule, value, callback) => {
  if (!hasInt(value)) {
    callback("请输入正整数");
  }
  callback();
};