index.js

export function isEmpty (obj, allowBlank = false) {
    if (isNull(obj)) return true
    if (isArray(obj)) return obj.length === 0
    if (isString(obj)) return !(allowBlank || obj.length > 0)
    if (isObject(obj)) return isEmptyObject(obj)
    for (var key in obj) { if (obj.hasOwnProperty(key)) return false }
    return obj === undefined || (!allowBlank ? obj === '' : false)
}
/**
  * 判断是否不为空
  * @param {*} obj
  */
export function isNotEmpty (obj, allowBlank = false) {
    return !isEmpty(obj, allowBlank)
}
export function isEmptyObject (obj) {
    if (!obj) return true
    for (const name in obj) {
        return false
    }
    return true
}
export function isNotEmptyObject (obj) {
    return isNotEmptyObject(obj)
}
/**
  * 是否是对象
  * @param {*} input
  */
export function isObject (input) {
    return Object.prototype.toString.call(input) === '[object Object]'
}
/**
  * 是否是数组
  * @param {*} input
  */
export function isArray (input) {
    return (
        input instanceof Array ||
         Object.prototype.toString.call(input) === '[object Array]'
    )
}
export function isDate (input) {
    return (
        input instanceof Date ||
         Object.prototype.toString.call(input) === '[object Date]'
    )
}
export function isNumber (input) {
    return (
        input instanceof Number ||
         Object.prototype.toString.call(input) === '[object Number]'
    )
}
export function isString (input) {
    return (
        input instanceof String ||
         Object.prototype.toString.call(input) === '[object String]'
    )
}
export function isBoolean (input) {
    return typeof input === 'boolean'
}
export function isFunction (input) {
    return typeof input === 'function'
}
export function isNull (input) {
    return input === undefined || input === null
}
export function isPlainObject (obj) {
    if (
        obj &&
         Object.prototype.toString.call(obj) === '[object Object]' &&
         obj.constructor === Object &&
         !hasOwnProperty.call(obj, 'constructor')
    ) {
        var key
        for (var k in obj) {
            key = k
        }
        return key === undefined || hasOwnProperty.call(obj, key)
    }
    return false
}
/**
  * 转树形
  */
export function toTree (data) {
    // 删除 所有 children,以防止多次调用
    data.forEach(function (item) {
        delete item.children
    })
    // 将数据存储为 以 id 为 KEY 的 map 索引数据列
    var map = {}
    data.forEach(function (item) {
        map[item.id] = item
    })
    var val = []
    data.forEach(function (item) {
        // 以当前遍历项，的pid,去map对象中找到索引的id
        var parent = map[item.parentId]

        // 好绕啊，如果找到索引，那么说明此项不在顶级当中,那么需要把此项添加到，他对应的父级中
        if (parent) {
            ;
            (parent.children || (parent.children = [])).push(item)
        } else {
            // 如果没有在map中找到对应的索引ID,那么直接把 当前的item添加到 val结果集中，作为顶级
            val.push(item)
        }
    })
    return val
}
/**
  * 通用排序
  */
export function sortExp (key, isAsc) {
    return function (x, y) {
        if (isNaN(key)) {
            if (x[key] > y[key]) {
                return 1 * (isAsc ? 1 : -1)
            } else if (x[key] < y[key]) {
                return -1 * (isAsc ? 1 : -1)
            } else {
                return 0
            }
        } else {
            return (x[key] - y[key]) * (isAsc ? 1 : -1)
        }
    }
}