vue常用方法

封装 @/utils下的index.js中

import moment from "moment";

/**
 * UTC时间转本地时间
 * @param utc  utc时间
 * @param format  要转换的格式
 * @returns {string}
 */
const utc2localDate = (utc, format = "YYYY-MM-DD HH:mm:ss") => {
  if (utc == null) {
    return "";
  } else {
    return moment(utc).format(format);
  }
};

/**
 * 本地时间转UTC时间
 * @param local
 * @returns {string}
 */
const localDate2utc = local => {
  return moment(local)
    .utc()
    .format();
};

// 时间比较大小
function bjDate(date) {
  var date = new Date(date);
  var date1 = new Date();
  if (date.getTime() - date1.getTime() < 0) {
    return false
  } else {
    return true
  }
}

/**
 * 计算时间差
 * @param startDate 开始时间
 * @param endDate 结束时间
 * @returns {object}
 */
function dateDifference(startDate, endDate) {
  let stime = Date.parse(new Date(startDate));
  let etime = Date.parse(new Date(endDate));
  // 两个时间戳相差的毫秒数
  let usedTime = etime - stime;
  // 计算相差的天数
  let days = Math.floor(usedTime / (24 * 3600 * 1000));
  // 计算天数后剩余的毫秒数
  let leave1 = usedTime % (24 * 3600 * 1000);
  // 计算出小时数
  let hours = Math.floor(leave1 / (3600 * 1000));
  // 计算小时数后剩余的毫秒数
  let leave2 = leave1 % (3600 * 1000);
  // 计算相差分钟数
  let minutes = Math.floor(leave2 / (60 * 1000));
  // 计算分钟数后剩余的毫秒数
  let leave3 = leave2 % (60 * 1000);
  // 计算相差分钟数
  let second = Math.floor(leave3 / (1000));
  let time = {
    days,
    hours,
    minutes,
    second
  }
  return time;
}

// 获取文件名后缀
function getSuffix(fileName) {
  let pos = fileName.lastIndexOf('.');
  let suffix = '';
  if (pos !== -1) {
    suffix = fileName.substring(pos + 1);
  }
  return suffix.toLowerCase();
}

// 判断数组内属性值相等时，只保留一个
function unique(arr, key) {
  const result = [arr[0]]
  for (let i = 1; i < arr.length; i++) {
    let item = arr[i]
    let repeat = false
    for (let j = 0; j < result.length; j++) {
      if (item[key] === result[j][key]) {
        repeat = true
        break
      }
    }
    if (!repeat) {
      result.push(item)
    }
  }
  return result
}

// 时间格式校验 2023-04-03T01:57:00Z
function isDateTimeString(str) {
  const regex = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}\+\d{2}:\d{2}$/;
  return regex.test(str);
}

// 去除空格返回数据
const formatTrimValue = data => {
  let trimData = data;
  formatArrOrObjTrimValue(trimData);
  return trimData;
}

// 去空格
const formatArrOrObjTrimValue = val => {
  for (let i in val) {
    if (typeof val[i] === 'string' && val[i].length > 0) {
      val[i.trim()] = val[i].trim();
      // 如果key两端有空格
      if (i.trim().length < i.length) {
        delete val[i];
      }
    }
    else if (
      isAnyObject(val[i]) ||
      (Array.isArray(val[i]) && val[i].length > 0)
    ) {
      val[i.trim()] = val[i];
      // 如果key两端有空格
      if (i.trim().length < i.length) {
        delete val[i];
      }
      formatArrOrObjTrimValue(val[i.trim()])
    }
  }
}

// 判断是否为json字符串
const jsonType = (str) => {
  if (typeof str == 'string') {
    try {
      var obj = JSON.parse(str);
      // 等于这个条件说明就是JSON字符串 会返回true
      if (typeof obj == 'object' && obj) {
        return true;
      } else {
        //不是就返回false
        return false;
      }
    } catch (e) {
      return false;
    }
  }
  return false;
}

// 异步加载js文件
const loadScripts = (urls, callback) => {
  return new Promise(function (resolve, reject) {
    let count = urls.length; // 记录需要加载的 JS 插件数量
    const loadScript = (url) => {
      const scripts = document.getElementsByTagName('script');
      for (let i = 0; i < scripts.length; i++) {
        if (scripts[i].src == url) {
          count--; // 每完成加载一个 JS 插件，数量减 1
          if (count == 0) {
            resolve(); // 所有 JS 插件加载完成后执行回调函数
          }
          return;
        }
      }
      const script = document.createElement('script');
      script.type = 'text/javascript';
      if (script.readyState) {
        script.onreadystatechange = function () {
          if (script.readyState == "loaded" || script.readyState == "complete") {
            script.onreadystatechange = null;
            count--; // 每完成加载一个 JS 插件，数量减 1
            if (count == 0) {
              resolve(); // 所有 JS 插件加载完成后执行回调函数
            }
          }
        }
      } else {
        script.onload = function () {
          count--; // 每完成加载一个 JS 插件，数量减 1
          if (count == 0) {
            resolve(); // 所有 JS 插件加载完成后执行回调函数
          }
        }
      }
      script.onerror = function () {
        reject();
      };
      script.async = true;
      script.src = url;
      document.head.appendChild(script);
    }
    for (let i = 0; i < urls.length; i++) {
      loadScript(urls[i]);
    }
  })
}

// 判断是否为对象
const isAnyObject = val => Object.prototype.toString.call(val) === '[object Object]'

/**
 * 数组去重
 * @param arr
 * @param key
 * @returns {arr}
 */
const duplication = function (arr, key) {
  var result = [];
  var obj = {};
  for (var i = 0; i < arr.length; i++) {
    if (!obj[arr[i][key]]) {
      result.push(arr[i]);
      obj[arr[i][key]] = true;
    }
  }
  return result;
};

/**
 * 判断str是否存在汉字
 * @param str
 * @returns {boolean}
 */
const hasHanZi = function (str) {
  if (/.*[\u4e00-\u9fa5]+.*$/.test(str)) return false;
  return true;
};

/**
 * 根据数组中对象的某个字段排序
 * @param props 进行排序的字段
 * @param type 排序规则 ascend 升序 descend降序
 * @returns {*}
 */
function sortBy(props, type) {
  return function (a, b) {
    if (type == 'ascend') {
      return b[props] - a[props];
    } else if (type == 'descend') {
      return a[props] - b[props];
    }
  }
}

/**
 * 深拷贝对象
 * @param ori
 * @returns {Array|any}
 */
function deepClone(ori) {
  const type = getType(ori);
  let copy;
  switch (type) {
    case "array":
      return copyArray(ori, type, copy);
    case "object":
      return copyObject(ori, type, copy);
    default:
      return ori;
  }
}

/**
 * 拷贝数组
 * @param ori
 * @param type
 * @param copy
 * @returns {Array}
 */
function copyArray(ori, type, copy = []) {
  for (const [index, value] of Object.entries(ori)) {
    copy[index] = deepClone(value);
  }
  return copy;
}

/**
 * 拷贝对象
 * @param ori
 * @param type
 * @param copy
 */
function copyObject(ori, type, copy = {}) {
  for (const [key, value] of Object.entries(ori)) {
    if (getType(value) === "function") {
      copy[key] = ori[key];
    } else {
      copy[key] = deepClone(value);
    }
  }
  return copy;
}