meansjs/es/meansjs.min.js

Common methods used in daily development

function ownKeys(object, enumerableOnly) {
  var keys = Object.keys(object);
  if (Object.getOwnPropertySymbols) {
    var symbols = Object.getOwnPropertySymbols(object);
    enumerableOnly && (symbols = symbols.filter(function (sym) {
      return Object.getOwnPropertyDescriptor(object, sym).enumerable;
    })), keys.push.apply(keys, symbols);
  }
  return keys;
}
function _objectSpread2(target) {
  for (var i = 1; i < arguments.length; i++) {
    var source = null != arguments[i] ? arguments[i] : {};
    i % 2 ? ownKeys(Object(source), !0).forEach(function (key) {
      _defineProperty(target, key, source[key]);
    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) {
      Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
    });
  }
  return target;
}
function _typeof(obj) {
  "@babel/helpers - typeof";

  return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) {
    return typeof obj;
  } : function (obj) {
    return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
  }, _typeof(obj);
}
function _classCallCheck(instance, Constructor) {
  if (!(instance instanceof Constructor)) {
    throw new TypeError("Cannot call a class as a function");
  }
}
function _defineProperties(target, props) {
  for (var i = 0; i < props.length; i++) {
    var descriptor = props[i];
    descriptor.enumerable = descriptor.enumerable || false;
    descriptor.configurable = true;
    if ("value" in descriptor) descriptor.writable = true;
    Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor);
  }
}
function _createClass(Constructor, protoProps, staticProps) {
  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
  if (staticProps) _defineProperties(Constructor, staticProps);
  Object.defineProperty(Constructor, "prototype", {
    writable: false
  });
  return Constructor;
}
function _defineProperty(obj, key, value) {
  key = _toPropertyKey(key);
  if (key in obj) {
    Object.defineProperty(obj, key, {
      value: value,
      enumerable: true,
      configurable: true,
      writable: true
    });
  } else {
    obj[key] = value;
  }
  return obj;
}
function _toPrimitive(input, hint) {
  if (typeof input !== "object" || input === null) return input;
  var prim = input[Symbol.toPrimitive];
  if (prim !== undefined) {
    var res = prim.call(input, hint || "default");
    if (typeof res !== "object") return res;
    throw new TypeError("@@toPrimitive must return a primitive value.");
  }
  return (hint === "string" ? String : Number)(input);
}
function _toPropertyKey(arg) {
  var key = _toPrimitive(arg, "string");
  return typeof key === "symbol" ? key : String(key);
}

/**
 * ASCII顺序排序
 * @param {*} obj 对象
 * @returns 
 */
var ascii = function ascii() {
  var obj = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
  if (!Object.keys(obj).length) return console.warn('Object cannot be null'); // 对象不能为空
  var arr = new Array();
  var num = 0;
  for (var i in obj) {
    arr[num] = i;
    num++;
  }
  var sortArr = arr.sort();
  var str = ''; //自定义排序字符串
  for (var _i in sortArr) {
    str += sortArr[_i] + obj[sortArr[_i]];
  }
  return str;
};

/**
 * 字符长度
 * @param size 字符
 * @returns 
 */
var characterSize = function characterSize() {
  var size = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
  return size.toString().replace(/[\u0391-\uFFE5]/g, "aa").length;
};

/**
 * 字符长度排序
 * @param {*} arr 数组
 * @returns 
 */
var sortSize = function sortSize() {
  var arr = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
  if (!arr.length) return console.warn('The array cannot be empty'); // 数组不能为空
  return arr.sort(function (a, b) {
    return characterSize(a) - characterSize(b);
  });
};

/**
 * 排序
 * @param {*} arr 数组
 * @param {*} type asc 升序；desc 降序
 * @param {*} key 排序字段
 * @returns 
 */
var sort = function sort(_ref) {
  var _ref$arr = _ref.arr,
    arr = _ref$arr === void 0 ? [] : _ref$arr,
    _ref$type = _ref.type,
    type = _ref$type === void 0 ? 'asc' : _ref$type,
    _ref$key = _ref.key,
    key = _ref$key === void 0 ? '' : _ref$key;
  if (!arr.length) return console.warn('The array cannot be empty'); // 数组不能为空
  if (key == '') {
    if (type == 'asc') {
      // 升序
      return arr.sort(function (a, b) {
        return a - b;
      });
    } else {
      // 降序
      return arr.sort(function (a, b) {
        return b - a;
      });
    }
  } else {
    return arr.sort(function (a, b) {
      var obj1 = a[key],
        obj2 = b[key];
      var obj = obj1 - obj2;
      if (type == 'asc') {
        obj = obj1 - obj2;
      } else if (type == 'desc') {
        obj = obj2 - obj1;
      }
      return obj;
    });
  }
};

/**
 * 深拷贝
 * @param {*} deep 
 * @returns 
 */
var deepClone = function deepClone(deep) {
  // 1.判断 返回的变量为 数组还是对象
  var clone = Array.isArray(deep) ? [] : {};
  // 2.判定传进来的数组是否有值和 是否为对象
  if (deep && _typeof(deep) === "object") {
    // 3.迭代数组中的每一个数值
    for (var key in deep) {
      // 4. hasOwnProperty 查找属性是都在自身身上;如果在就返回为true 否则就false  原型链不算
      if (deep.hasOwnProperty(key)) {
        // console.log(deep[key]);
        // 5.判断数据是否是对象;如果是就在调用递归函数继续执行
        if (deep[key] && _typeof(deep[key]) === 'object') {
          clone[key] = deepClone(deep[key]);
        } else {
          // 6.如果不等于对象就直接赋值返回                        
          clone[key] = deep[key];
        }
      }
    }
  }
  // 7.返回
  return clone;
};

var timer$1 = null;

/**
 * 防抖
 * @param {*} fn 函数 
 * @param {*} time 时间 
 * @returns 
 */
var antiShake = function antiShake(foo) {
  // 如果有时间就清除
  if (timer$1) clearTimeout(timer$1);
  shake(foo);
};
var shake = function shake(_ref) {
  var fn = _ref.fn,
    _ref$time = _ref.time,
    time = _ref$time === void 0 ? 500 : _ref$time;
  if (typeof fn !== 'function') throw new Error('fn must be function');
  var context = this;
  var ages = arguments;
  timer$1 = setTimeout(function () {
    // 在定时器里面调用需要 防抖的函数
    fn.call(context, ages);
  }, time);
};

/**
 * 节流
 * @param {*} foo 
 * @returns 
 */
var timer = null;

/**
 * 节流
 * @param {*} fn 函数
 * @param {*} time 时间
 */
var throttle = function throttle(foo) {
  // timer = null;
  // 返回一个函数值
  utils(foo);
};
var utils = function utils(_ref) {
  var fn = _ref.fn,
    _ref$time = _ref.time,
    time = _ref$time === void 0 ? 500 : _ref$time;
  if (typeof fn !== 'function') throw new Error('fn must be function');
  // 将this指向赋值   此时的 this 指向的是 实例 button
  var context = this;
  // 获取传过来的值
  var ages = arguments;
  // 清除定时器
  if (!timer) {
    // 判定timer没有数值
    // 声明一个定时器
    timer = setTimeout(function () {
      // 在定时器里面调用需要 节流的函数
      fn.call(context, ages);
      // 如果执行到这儿的是否需要把 timer 初始化 为null  ;便于下次判断
      clearTimeout(timer);
      timer = null;
    }, time);
  }
};

/**
 * 数组去重
 * @param {*} arr 数组
 * @param {*} key 默认为空,一维数组
 * @returns 
 */
var deWeight = function deWeight() {
  var arr = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
  var key = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
  if (!arr.length) return console.warn('The array cannot be empty'); // 数组不能为空
  var isKeyObj = arr.some(function (item) {
    return Object.keys(item).length;
  });
  if (isKeyObj && !key) return console.warn('key Cannot be empty'); // 二维数组并且key值空时

  var map = new Map();
  var arrs = [];
  if (!isKeyObj) {
    // 一维数组
    arrs = arr.filter(function (item) {
      return !map.has(item) && map.set(item);
    });
  } else if (key) {
    var isKey = arr.some(function (item) {
      return item[key];
    });
    if (!isKey) return console.warn("Not found ".concat(key, " fields"));
    arrs = arr.filter(function (item) {
      return !map.has(item[key]) && map.set(item[key]);
    });
  }
  return arrs;
};

/**
 * 获取url的值
 * @param {*} url 默认值为空
 * @returns 
 */
var getUrl = function getUrl() {
  var url = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
  // 获取url 传递传递过来的值
  var styleList = url ? url : window.location.href;
  // 判断是否有问号
  if (styleList.toString().indexOf('?') === -1) return console.error('No value found');
  // 查询/截取url中？开始 & 结束以内的值
  var styleOut = styleList.substring(styleList.indexOf('?') + 1).split('&');
  // 声明一个变量 用来接收
  var result = {};
  for (var i in styleOut) {
    var key = styleOut[i].split('=');
    result[key[0]] = key[1];
  }
  return result;
};

/**
 * 判断终端
 * @returns 
 */
var judgeUa = function judgeUa() {
  var u = navigator.userAgent;
  var u2 = navigator.userAgent.toLowerCase();
  return {
    //移动终端浏览器版本信息
    trident: u.indexOf('Trident') > -1,
    //IE内核
    presto: u.indexOf('Presto') > -1,
    //opera内核
    webKit: u.indexOf('AppleWebKit') > -1,
    //苹果、谷歌内核
    gecko: u.indexOf('Gecko') > -1 && u.indexOf('KHTML') == -1,
    //火狐内核
    mobile: !!u.match(/AppleWebKit.*Mobile.*/),
    //是否为移动终端
    ios: !!u.match(/\(i[^;]+;( U;)? CPU.+Mac OS X/),
    //ios终端
    android: u.indexOf('Android') > -1 || u.indexOf('Linux') > -1,
    //android终端或uc浏览器
    iPhone: u.indexOf('iPhone') > -1,
    //是否为iPhone或者QQHD浏览器
    iPad: u.indexOf('iPad') > -1,
    //是否iPad
    webApp: u.indexOf('Safari') == -1,
    //是否web应该程序，没有头部与底部
    // iosv: u.substr(u.indexOf('iPhone OS') + 9, 3),
    weixin: u2.match(/MicroMessenger/i) == "micromessenger",
    // 判断是否为微信
    ali: u.indexOf('AliApp') > -1
  };
};

/**
 * 图片链接转base64
 * @param {*} url 链接地址 -- 必填
 * @param {*} cb 回调函数
 * @param {*} quality 图片质量
 * @param {*} format 图片格式
 */
var toBase64 = function toBase64(url, cb) {
  var quality = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0.92;
  var format = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 'webp';
  if (!url) return console.warn('url cannot be empty');
  var canvas = document.createElement('canvas'),
    ctx = canvas.getContext('2d'),
    img = new Image();
  img.crossOrigin = 'Anonymous';
  img.onload = function () {
    var imgWidth = img.width;
    var imgHeight = img.height;
    // canvas 宽高
    canvas.width = imgWidth;
    canvas.height = imgHeight;
    ctx.drawImage(img, 0, 0, imgWidth, imgHeight);
    var dataURL = canvas.toDataURL("image/".concat(format), quality);
    cb && cb(dataURL);
    canvas = null;
  };
  img.onerror = function (e) {
    throw new Error("base64 ".concat(e));
  };
  img.src = url;
};

/**
 * base64转file文件
 * @param {*} base base64
 * @param {*} filename 名称
 * @returns 
 */
var base64File = function base64File(base) {
  var filename = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new Date().getTime();
  var arr = base.split(',');
  var mime = arr[0].match(/:(.*?);/)[1];
  var suffix = mime.split("/")[1];
  var bstr = atob(arr[1]);
  var n = bstr.length;
  var u8arr = new Uint8Array(n);
  while (n--) {
    u8arr[n] = bstr.charCodeAt(n);
  }
  //转换成file对象
  return new File([u8arr], "".concat(filename, ".").concat(suffix), {
    type: mime
  });
};

/**
 * 获取最小值
 * @param {*} arr 
 * @param {*} key 
 */
var min = function min() {
  var arr = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
  var key = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
  if (!arr.length) return console.warn('The array cannot be empty'); // 数组不能为空
  var isKeyObj = arr.some(function (item) {
    return Object.keys(item).length;
  });
  if (isKeyObj && !key) return console.warn('key Cannot be empty'); // 二维数组并且key值空时

  var mins;
  if (!isKeyObj) {
    // 一维数组
    mins = arr.reduce(function (one, pro) {
      return one > pro ? pro : one;
    });
  } else if (key) {
    if (!arr.some(function (item) {
      return item[key];
    })) return console.warn("Not found ".concat(key, " fields"));
    mins = arr.reduce(function (one, pro) {
      return one[key] > pro[key] ? pro : one;
    })[key];
  }
  return mins;
};

/**
 * 获取最大值
 * @param {*} arr 
 * @param {*} key 
 */
var max = function max() {
  var arr = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
  var key = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
  if (!arr.length) return console.warn('The array cannot be empty'); // 数组不能为空
  var isKeyObj = arr.some(function (item) {
    return Object.keys(item).length;
  });
  if (isKeyObj && !key) return console.warn('key Cannot be empty'); // 二维数组并且key值空时

  var maxs;
  if (!isKeyObj) {
    // 一维数组
    maxs = arr.reduce(function (one, pro) {
      return one < pro ? pro : one;
    });
  } else if (key) {
    if (!arr.some(function (item) {
      return item[key];
    })) return console.warn("Not found ".concat(key, " fields"));
    maxs = arr.reduce(function (one, pro) {
      return one[key] < pro[key] ? pro : one;
    })[key];
  }
  return maxs;
};

var myDate = new Date(); //实例一个时间对象；
var year = myDate.getFullYear(); //获取系统的年；
var month = myDate.getMonth() + 1; //获取系统的年；
var d = myDate.getDate(); // 获取系统日，
month = month < 10 ? "0" + month : month;
d = d < 10 ? "0" + d : d;

// 年月日
var date = function date() {
  myDate = new Date();
  return year + "-" + month + "-" + d;
};

// 年月日时分秒
var dateTime = function dateTime() {
  myDate = new Date();
  var h = myDate.getHours(); //获取系统时，
  var m = myDate.getMinutes(); //分
  var s = myDate.getSeconds(); // 秒
  h = h < 10 ? "0" + h : h;
  m = m < 10 ? "0" + m : m;
  s = s < 10 ? "0" + s : s;
  return year + "-" + month + "-" + d + " " + h + ":" + m + ":" + s;
};

// 时间戳
var unix = function unix() {
  myDate = new Date();
  return myDate.getTime();
};
var toDate = /*#__PURE__*/_createClass(function toDate() {
  _classCallCheck(this, toDate);
  this.meTime = dateTime;
  this.meDate = date;
  this.meUnix = unix;
});
var toDate$1 = new toDate();

// function toDate () {};

// toDate.prototype = {
//     time:dateTime,
//     date
// };

// export default {
//     time:dateTime,
//     date:date
// };

/**
 * 判断数据类型
 * @param {*} type 需要判断的字段
 * @param {*} boo 是否首字母大写
 * @returns 
 */
var typeJudge = function typeJudge(type) {
  var boo = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
  var typeSize = Object.prototype.toString.call(type);
  var kind;
  switch (typeSize) {
    case '[object String]':
      kind = 'String';
      break;
    case '[object Number]':
      kind = 'Number';
      break;
    case '[object Boolean]':
      kind = 'Boolean';
      break;
    case '[object Object]':
      kind = 'Object';
      break;
    case '[object Array]':
      kind = 'Array';
      break;
    case '[object Null]':
      kind = 'Null';
      break;
    case '[object Undefined]':
      kind = 'Undefined';
      break;
    case '[object Function]':
      kind = 'Function';
      break;
    case '[object Date]':
      kind = 'Date';
      break;
    case '[object Symbol]':
      kind = 'Symbol';
      break;
  }
  if (boo) {
    // 首字母大写
    kind = kind.substring(0, 1).toUpperCase() + kind.substring(1);
  } else {
    // 小写
    kind = kind.toLowerCase();
  }
  return kind;
};
var jsType = /*#__PURE__*/_createClass(function jsType() {
  _classCallCheck(this, jsType);
  this.meJstype = typeJudge;
});
var jsType$1 = new jsType();

var index$1 = _objectSpread2(_objectSpread2({
  meAscii: ascii,
  meCharacterSize: characterSize,
  meSortSize: sortSize,
  meSort: sort,
  meDeepClone: deepClone,
  meAntiShake: antiShake,
  meThrottle: throttle,
  meDeWeight: deWeight,
  meGetUrl: getUrl,
  meTerminal: judgeUa,
  meToBase64: toBase64,
  meBase64File: base64File,
  meMin: min,
  meMax: max
}, toDate$1), jsType$1);

function meansjs() {}
meansjs.prototype = index$1;
var index = new meansjs();

export { index as default };