tian-yan-yan/src/utils/DateTime.js

一套不算好用的组件

/*
* 时间处理
* @author 张文
* @date  2022-01-26
* */

import {Language} from "./Language";
import {Timezone} from "./Timezone";

// 内部使用函数，截取指定时间的值
function timeTextSplit(str, type){
  // 如果没有传入类型或者当前值不包含传入类型则返回传入值
  if (!type || !str.includes(type)) return str

  return str.split(type)[0] + type
}

export const DateTime = {

  /**
   * 时间格式化
   * @author 张文
   * @param date 需要格式化的时间（字符串、时间戳或时间对象）
   * @param format 格式化表达式
   */
  format(date, format = 'yyyy-MM-dd') {
    if (!date) return '-'

    // 如果是标准时就调用标准时转换
    if (/(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(.\d+)?Z)/gm.test(date)){
      return Timezone.UTCToTimezone({
        date,
        format
      })
    }

    const value = date instanceof Date ? date : /^\d+$/.test(date) ? new Date(Number(date)) : new Date(date)
    let o = {
      'M+': value.getMonth() + 1,
      'd+': value.getDate(),
      'h+': value.getHours(),
      'm+': value.getMinutes(),
      's+': value.getSeconds(),
      'q+': Math.floor((value.getMonth() + 3) / 3),
      'S': value.getMilliseconds()
    }
    if (/(y+)/.test(format)) {
      format = format.replace(RegExp.$1, (value.getFullYear() + '').substr(4 - RegExp.$1.length))
    }
    for (let k in o) {
      if (Object.prototype.hasOwnProperty.call(o, k) && new RegExp('(' + k + ')').test(format)) {
        format = format.replace(RegExp.$1, RegExp.$1.length === 1 ? o[k].toString() : (('00' + o[k]).substr((o[k].toString()).length)))
      }
    }
    return format
  },


  /**
   * 计算两个时间的差值
   * @author 张文
   * @param  l 起始时间（字符串、时间戳或时间对象）
   * @param  n 结束时间（字符串、时间戳或时间对象）
   * @param {String} type 返回的时间类型默认秒钟，可选值：s-秒，m-分钟，h-小时, d-天
   * @return {Object} { time:返回相减后的值，不足1的忽略不计，ago: l < n 起始时间是否大于结束时间 }
   * */
  judgeDate(l, n = new Date().toUTCString(), type = 's') {
    const a = new Date(this.format(l, 'yyyy-MM-dd hh:mm:ss')).getTime()
    const b = new Date(this.format(n, 'yyyy-MM-dd hh:mm:ss')).getTime()
    let time
    switch (type) {
      case 's':
        time = 1000
        break;
      case 'm':
        time = 1000 * 60
        break;
      case 'h':
        time = 1000 * 60 * 60
        break;
      case 'd':
        time = 1000 * 60 * 60 * 24
        break;
      default:
        time = 1000
        break;
    }

    const abs = a - b

    return {
      time: Math.floor(Math.abs(abs) / time),
      ago: abs < 0
    }
  },


  /**
   * 两个时间差转换为中文，可自定义显示到最大时间单位
   * @author 张文
   * @param {Object} obj {
   * l-起始时间,
   * n-结束时间,默认当前时间,
   * s-当前秒数(存在值时忽略 l，n),
   * type-最大显示单位（可选）。y-年（默认）；m-月，d-日，h-小时，min-分钟，s-秒,
   * agoText-需要在文本后显示的文字（可选）。为空时值为 s > 0 || l-n > 0 ? '后' : '前'，若无需显示任何描述文字传入：false(默认),
   * minType-文本翻译的最小单位（可选）。 y-年；m-月，d-日，h-小时，min-分钟，s-秒（默认）
   * }
   * @return {Object} {y-年, m-月, d-日, h-时, min-分, s-秒, text:当前时间的中文翻译，xx小时xx分xx秒, success-是否处理成功}
   * */
  timeToStr({l, n = new Date().toUTCString(), s = 0, type='y', agoText=false, minType='s'}) {
    const obj = {
      y: 0,
      m: 0,
      d: 0,
      h: 0,
      min: 0,
      s: 0,
      success:true
    }

    let time, ago


    try {

      // 判断是否传入了需要计算的秒数
      if (!s) throw Error

      let nTime = Number(s)
      if (isNaN(nTime) || nTime === 0) {
        throw Error
      }

      ago = nTime > 0
      time = Math.abs(nTime)
    }catch {

      if (!l || !n){
        obj.success = false
        return {
          ...obj,
          text:''
        }
      }

      let oTime = this.judgeDate(l, n)
      time = oTime.time
      ago = oTime.ago
    }

    const language = {
      s : Language.get('wms_project.pda.common.sec','秒'),
      min : Language.get('wms_project.pda.common.min','分钟'),
      h : Language.get('wms_project.pda.common.hour','小时'),
      d : Language.get('wms_project.pda.common.day','天'),
      m : Language.get('wms_project.pda.common.month','月'),
      y : Language.get('wms_project.pda.common.year','年'),
    }

    let text
    if (agoText === false) {
      text = ''
    } else if (agoText) {
      text = agoText
    } else {
      text = ago ? Language.get('wms_project.pda.common.ago','前') : Language.get('wms_project.pda.common.old','后')
    }


    const maxMin = Math.floor(time / 60)
    if (type === 's' || !maxMin) {
      obj.s = time
      return {
        ...obj,
        text: timeTextSplit(`${obj.s}${language.s}${text}`, language[minType])
      }
    }


    obj.s = time % 60
    text = `${obj.s}${language.s}${text}`
    const maxH = Math.floor(maxMin / 60)
    if (type === 'min' || !maxH) {
      obj.min = maxMin
      return {
        ...obj,
        text: timeTextSplit(`${obj.min}${language.min}${text}`, language[minType])
      }
    }

    obj.min = maxMin % 60
    text = `${obj.min}${language.min}${text}`
    const maxD = Math.floor(maxH / 24)
    if (type === 'h' || !maxD) {
      obj.h = maxH
      return {
        ...obj,
        text: timeTextSplit(`${obj.h}${language.h}${text}`, language[minType])
      }
    }

    obj.h = maxH % 24
    text = `${obj.h}${language.h}${text}`
    const maxM = Math.floor(maxD / 30)
    if (type === 'd' || !maxM) {
      obj.d = maxD
      return {
        ...obj,
        text: timeTextSplit(`${obj.d}${language.d}${text}`, language[minType])
      }
    }

    obj.d = maxD % 30
    text = `${obj.d}${language.d}${text}`
    if (type === 'm' || !obj.y) {
      obj.m = maxM
      return {
        ...obj,
        text: timeTextSplit(`${obj.m}${language.m}${text}`, language[minType])
      }
    }

    obj.m = maxM % 12
    text = `${obj.m}${language.m}${text}`
    obj.y = Math.floor(maxM / 12)
    return {
      ...obj,
      text: timeTextSplit(`${obj.y}${language.y}${text}`, language[minType])
    }

  },
}