tools-for-js/lib/utils/common.js

基于babel构建的JavaScript前端工具库

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.isEqual = exports.isEmpty = exports.deepCopy = exports.IsType = void 0;
function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
/*******
 * @description: 变量类型判断
 * @author: 琴时
 * @param {String} type  [类型] 如：String|Number|Boolean||Object|Array|Date|Null|Undefined|RegExp|Error|Function
 * @param {*} params     [参数]
 * @return {Boolean}
 * @example: IsType('String', '123')
 */
var IsType = exports.IsType = function IsType(type, params) {
  return Object.prototype.toString.call(params) === "[object ".concat(type, "]");
};

/*******
 * @description: 深拷贝变量：
 * 支持->String,Number,Boolean,null,undefined,Object,Array,Date,RegExp,Error,Function 类型-进行深度拷贝
 * @author: 琴时
 * @param {*} params [源变量]
 * @return {*}       [新变量]
 */
var deepCopy = exports.deepCopy = function deepCopy(params) {
  if (_typeof(params) !== 'object' || params === null) {
    // 基础数据类型或空对象
    return params;
  }
  var newValue = IsType('Object', params) // 判断是否是对象
  ? {} //需遍历处理
  : IsType('Array', params) // 判断是否是数组
  ? [] //需遍历处理
  : IsType('Date', params) // 判断是否是日期对象
  ? new params.constructor(+params) : IsType('RegExp', params) || IsType('Error', params) // 判断是否是正则对象或错误对象
  ? new params.constructor(params) : params;
  // 判断是否是数组或对象
  if (IsType('Array', params)) {
    // 循环遍历
    for (var key in params) {
      // 防止原型链的值
      if (Object.prototype.hasOwnProperty.call(params, key)) {
        var element = params[key];
        newValue[key] = deepCopy(element);
      }
    }
  } else if (IsType('Object', params)) {
    var keys = Reflect.ownKeys(params);
    for (var _key in keys) {
      // 防止原型链的值
      if (Object.prototype.hasOwnProperty.call(keys, _key)) {
        var _element = keys[_key];
        newValue[_element] = deepCopy(params[_element]);
      }
    }
  }
  return newValue;
};

/*******
 * @description: 校验空值参数：将 ''|null|undefined|NaN|[]|{} 判断为空
 * @author: 琴时
 * @param {*} params [需要校验的参数]
 * @return {Boolean} [空：true，非空：false]
 */
var isEmpty = exports.isEmpty = function isEmpty(params) {
  if (params === 0 || params === 1) return false; //过滤0/1
  if (!Boolean(params)) return true; //校验''/undefined/null/NaN
  if (IsType('String', params) && params.trim() === '') return true; //校验多空格空字符串
  if (IsType('Array', params) && params.length === 0) return true; //检验空数组[]
  if (IsType('Object', params) && Object.keys(params).length === 0) return true; //检验空对象{}
  return false; //非空
};

/*******
 * @description: 判断两个参数是否相等
 * @author: 琴时
 * @param {*} a
 * @param {*} b
 * @return {Boolean}
 */
var isEqual = exports.isEqual = function isEqual(a, b) {
  // 类型为基本类型时,如果相等,则返回true
  if (a === b) return true;
  if (IsType('Object', a) && IsType('Object', b)) {
    // 若两个参数都为对象，先判断对象长度是否相同，再遍历对象内元素是否相同
    if (Object.keys(a).length !== Object.keys(b).length) return false;
    for (var k in a) {
      if (a.hasOwnProperty(k)) {
        if (!isEqual(a[k], b[k])) {
          // 对象中具有不相同属性 返回false
          return false;
        }
      }
    }
  } else if (IsType('Array', a) && IsType('Array', b)) {
    // 若两个参数都为数组，则先判断数组长度是否相同，遍历数组元素是否相同
    if (a.length !== b.length) return false;
    for (var i = 0, length = a.length; i < length; i++) {
      if (!isEqual(a[i], b[i])) {
        // 如果数组元素中具有不相同元素,返回false
        return false;
      }
    }
  } else {
    return false; // 其它类型,均返回false
  }
  return true;
};