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)
         }
     }
 }