/**
* @description 判断是否为object对象
* @param data
* @return {boolean}
* @createTime 2021/4/13 17:22
* @author Admin
*/
function isObject(data) {
return data.constructor === Object
}
/**
* @description 判断是否为数字
* @param data
* @author Admin
* @createTime 2021/4/13 17:25
* @version 1.0
* @return {boolean}
*/
function isNumber(data) {
return data.constructor === Number
}
/**
* @description 判断是否为字符串
* @param data
* @author Admin
* @createTime 2021/4/13 17:26
* @version 1.0
* @return {boolean}
*/
function isString(data) {
return data.constructor === String
}
/**
*@description 判断是否为数组
* @param data
* @author Admin
* @createTime 2021/4/13 17:27
* @version 1.0
* @return {boolean}
*/
function isArray(data) {
return data.constructor === Array
}
/**
*@description 判断是否为函数
* @param data
* @author Admin
* @createTime 2021/4/13 17:28
* @version 1.0
* @return {boolean}
*/
function isFunction(data) {
return data.constructor === Function
}
/**
* 判断是否为JSON数据。JSON.parse()能解析成功，那么str是json字符串。
* @param str
* @returns {boolean}
*/
function isJSON(str) {
if (typeof str == "string" && str) {
try {
JSON.parse(str)
return true;
} catch (e) {
return false;
}
}
}
/**
* json字符串转数组
* @param str json字符串
* @returns {*[]} 返回的数组
*/
export function toArray (str) {
if (str === '' || str == null || str === undefined) {
return []
}
if (isArray(str)) {
return str
}
if (isJSON(str)) {
return JSON.parse(str)
}
}
/**
* json字符串转对象
* @param str json字符串
* @returns {{}} 返回的对象
*/
export function toObject (str) {
if (str === '' || str == null || str === undefined) {
return {}
}
if (isObject(str)) {
return str
}
if (isJSON(str)) {
return JSON.parse(str)
}
}
/**
* @description 将数据转为树型结构。
* 将数据分为最外层的父节点和孩子节点。
* 在子节点中找父节点的直接节点，将其从当前子节点中剔除。
* 递归回到1，寻找子节点的子节点。
* 如果当前子节点不是任何节点的父节点，将该子节点放入父节点的children集合中
* @param data 数组数据源
* @param option 配置fid、pid对应关系。默认fid：id，pid：pid
* @return 返回树
* @author Admin
* @createTime 2021/4/13 13:29
* @version 1.0
**/
function getTree(data,option = {fid: 'id', pid: 'pid'}) {
const parents = data.filter((item) => item[option.pid] === 0);
const children = data.filter((item) => item[option.pid] !== 0);
toTree(parents, children);
return parents;
function toTree(parents, children) {
for (let i = 0; i < parents.length; ++i) {
for (let j = 0; j < children.length; ++j) {
if (children[j][option.pid] === parents[i][option.fid]) {
toTree([children[j]], children);
if (parents[i].children) {
parents[i].children.push(children[j]);
} else {
parents[i].children = [children[j]];
}
}
}
}
}
}
/**
* @description 深度克隆。属性值为object时，判断是否时对象数组。再继续递归深度克隆；否则为当前值
* @param source：克隆对象 target：克隆结果对象
* @return 返回克隆结果对象
* @author Admin
* @createTime 2021/4/13 13:21
* @version 1.0
*/
function deepClone(source, target) {
let _tar = target || {};
let keys = Reflect.ownKeys(source);
keys.map((key) => {
if (typeof source[key] === "object") {
_tar[key] =
Object.prototype.toString.call(source[key]) === "[object Array]"
? []
: {};
deepClone(source[key], _tar[key]);
} else {
_tar[key] = source[key];
}
});
return _tar;
}
/**
* @description 对象是无序的，直接返回。数据有内容时，判断对象是否含有排序依据order；若有进行比较，否则直接返回
* @param data 需要排序的对象
* @param order 排序的类型
* @param desc 根据order进行排序。desc： 1为升序， -1为降序
*/
function sortedOrderBy(data, order = '', desc = 1 ) {
let res
if (Array.isArray(data)) {
if (data.length === 0 ){
res = data
return res
} else if (isObject(data[0])) {
if ( order in data[0] ) {
res = data.sort((a, b) => {
if (typeof a[order] === 'string') {
if (order.includes("time")) {
let dateA = new Date(a[order]).getTime()
let dateB = new Date(b[order]).getTime()
return (dateA > dateB ? 1 : -1) * desc
}
return (a[order] >= b[order] ? a[order] === a[order] ? 0 : 1 : -1) * desc
}
if (typeof a[order] === 'number') {
return ( a[order] - b[order] ) * desc
}
});
}else {
res = data
}
}else {
res = data.sort((a, b) => {
return (a >= b ? a === a ? 0 : 1 : -1) * desc
})
}
}else {
res = data
}
return res
}
/**
* @description 得到排序树，
* @param tree 排序的树, orderBy 排序依据, desc：1为升序，-1为降序
* @return []
* @author Admin
* @createTime 2021/4/13 13:26
* @version 1.0
*/
function SortTree(tree, orderBy, desc) {
if (orderBy === '' || orderBy === undefined) {
return tree;
}else {
tree = sortedOrderBy(tree, orderBy, desc)
tree.map((t) => {
if (t.children) {
t.children = SortTree(t.children, orderBy, desc);
}
});
}
return tree;
}
/**
* @description 将data数组转化为排序树
* @param data data数组转为树再配许
* @param orderBy 排序依据。默认为空
* @param desc 升降序。1为升序，-1为降序。默认升序
* @param option 树的层级配置。默认fid为id，pid为pid
* @return [] 返回数组对象
* @author Admin
* @createTime 2021/4/13 15:21
* @version 1.0
*/
function getSortedTree(data, orderBy = '', desc = 1,option = {fid: 'id', pid: 'pid'}) {
let temp = getTree(data,option)
return SortTree(temp, orderBy, desc)
}
function getExportFields(table){
let res = []
this.$refs[table].$children.forEach(obj => {
if(obj.label) {
console.log(obj)
res.push(obj.label)
}
})
return res;
}
export default function (Vue) {
Vue.prototype.$JSONutils = {
toArray,
toObject,
sortedOrderBy,
getTree,
getSortedTree,
getExportFields
}
}
console