ang-tool/src/index.js

JavaScript常用方法的封装|Encapsulation of common JavaScript methods

console.log('ang-tool 1.0 Ready')

const ang = {

  /**
   * 数组去重
   * @param {array} e 需要去重的数组
   * @param {number} [t] 我还没想好有什么用
   * @returns {array} 返回内容唯一的数组
   * @author huziya
   */
  arrayOnly (arr, t) {
    // typeof e !== Array
    if (!arr || typeof arr !== Array) {
      console.error('arrayOnly(arr)??')
      return [];
    }
    return [...new Set(arr)]
  },

  /**
   * 累加
   * @param {Array<number|string>} arr 要累加的数组
   * @param {number} tail 要保留小数点后的位数
   * @returns {string} 精确的累加结果
   * @author huziya
   */
  add (arr, tail = null) {
    const total = arr.reduce((acc, cur) => acc + Number(cur) * 100, 0);
    const result = total / 100;
    if (tail) {
      return result.toFixed(tail);
    } else {
      return result;
    }
  },

  /**
   * 金钱格式矫正 k:[0: ..., 1: ...]
   * @param {*} v  需要矫正为金钱格式的数值
   * @param {number} [k] 需要做哪些特殊处理 默认0
   * @returns {string} 返回矫正后的结果 例如0.00
   * @author huziya
   */
  moneyInit (v, k = 0) {
    // if (!v) return v = v ?? '0.00'
    if (!v) {
      return '0.00';
    }
    v = v.replace(/[^\d.]/g, "").replace(/^\./g, "").replace(/\.{2,}/g, ".").replace(".", "$#$").replace(/\./g, "").replace("$#$", ".")
    v = Number(v)
    return (v === 0 ? '0.00' : v.toString())
  },

  /**
   * 将数字转换为格式化的货币字符串
   * @param {number} num 要格式化的数字
   * @param {number} [tail=2] 要保留的小数位数 默认为2
   * @param {string} [type='CNY'] 货币类型 默认为'CNY'
   * @returns {string} 格式化后的货币字符串 [￥9,999.99]
   * @author huziya
   */
  rmb (num = 0, tail = 2, type = 'CNY') {
    if (num != 0 && !num) return '-'
    let a = new Intl.NumberFormat('zh-CN', {
      style: 'currency',
      currency: type,
      minimumFractionDigits: tail
    });
    return a.format(num);
  },

  /**
   * 金额[￥9,999.99] 转换为数字类型[9999.99]
   * @param {string} rmb 待转换的金额字符串
   * @returns {number|null} 转换后的数字类型的金额 如果转换失败则返回null
   * @author huziya
   */
  bmr (rmb) {
    let match = rmb.match(/\d+(\.\d+)?/);
    if (!match) {
      return null;
    }
    let number = parseFloat(match[0]);
    return number;
  },

  /**
   * 时间字符yyyy-MM-dd HH:mm:ss串转时间戳 考虑兼容模式
   * @param {string} dateString 待转换的日期字符串，格式为 yyyy-MM-dd HH:mm:ss
   * @returns {number|null} 转换后的时间戳，单位为毫秒；如果转换失败，返回null
   * @author huziya
   */
  getTimeStamp (dateString) {
    let reg = /^(\d{4})-(\d{2})-(\d{2})\s+(\d{2}):(\d{2}):(\d{2})$/;
    let match = dateString.match(reg);
    if (!match) {
      return null;
    }
    let yyyy = parseInt(match[1], 10);
    let MM = parseInt(match[2], 10) - 1;
    let dd = parseInt(match[3], 10);
    let HH = parseInt(match[4], 10);
    let mm = parseInt(match[5], 10);
    let ss = parseInt(match[6], 10);
    let timeStamp = new Date(yyyy, MM, dd, HH, mm, ss).getTime();
    return timeStamp;
  },

  /**
   * 获取日期 今日/前推近几日
   * @param {number} n 推算日期数 [0/false: 今日, 0++: yyyy-mm-dd HH:mm:ss]
   * @param {string} k [q:前推, h:后推]
   * @returns {string} 日期
   * @author huziya
   */
  getTime (n, k = null) {
    const _start = ' 00:00:00';
    const _end = ' 23:59:59';
    let d = new Date();
    let _year = d.getFullYear();
    let _month = (d.getMonth() + 1).toString().padStart(2, '0');
    let _date = d.getDate().toString().padStart(2, '0')
    let _today = _year + '-' + _month + '-' + _date;	// yyyy-mm-dd HH:mm:ss
    if (!n) return [_today + _start, _today + _end];
    let t = new Date(_today.replace(/-/g, "/"));
    let ti = new Date(t.setDate(t.getDate() - (n - 1))).toLocaleDateString();
    let tim = ti.split("/");
    let time = tim[0] + '-' + tim[1].padStart(2, '0') + '-' + tim[2].padStart(2, '0')
    return [time + _start, _today + _end]
  },

  /**
   * 万物皆可判断
   * @param {*} value - 要判断的值
   * @param {boolean} [isStrict=true] - 是否使用强制模式进行判断，默认为 true
   * @returns {boolean} 若值为真，则返回 true；否则，返回 false
   * @description 如果关闭了严格模式，会追加对字符串 "false"、"null"、"undefined"、"0"、"NaN" 和 "" 进行特殊判断；
   * @example
   * isTruthy(true);              // true
   * isTruthy(1);                 // true
   * isTruthy('hello');           // true
   * isTruthy(null);              // false
   * isTruthy(undefined, false);  // true 
   * @author huziya
   */
  isTruthy (value, isStrict = true) {
    //数组
    if (Array.isArray(value)) {
      return value.length !== 0;
    }
    // 对象
    if (typeof value === 'object' && value !== null) {
      return Object.keys(value).length !== 0;
    }
    if (!isStrict) {
      // 这个判断并不好笑,神奇的服务端接口才好笑
      const falsyValues = ['false', 'null', 'undefined', '0', 'NaN', ''];
      if (falsyValues.includes(value)) {
        return false;
      }
    }
    // 剩余6个真值以及所有除外的字符串
    return Boolean(value);
  },

  /**
   * 指定时间传入毫秒加减推算
   * 
   * @param {string} initTime - 初始时间（格式为字符串）
   * @param {string} type - 操作类型（可选值为 "add" 或 "subtract"）
   * @param {number} ms - 要添加或减去的毫秒数
   * @returns {string} - 格式化后的日期字符串（yyyy-mm-dd hh:mm:ss）
   * @throws {string} - 如果初始时间无效，则抛出异常 "无效的初始时间"
   * @throws {string} - 如果操作类型无效，则抛出异常 "无效的操作类型"
   */
  calculateTime (initTime, type, ms) {
    var date = new Date(initTime);
    if (isNaN(date)) {
      return '无效的初始时间';
    }
    if (type === 'add') {
      date.setTime(date.getTime() + ms);
    } else if (type === 'subtract') {
      date.setTime(date.getTime() - ms);
    } else {
      return '无效的操作类型';
    }
    var formattedDate = date.getFullYear() + '-' +
      ('0' + (date.getMonth() + 1)).slice(-2) + '-' +
      ('0' + date.getDate()).slice(-2) + ' ' +
      ('0' + date.getHours()).slice(-2) + ':' +
      ('0' + date.getMinutes()).slice(-2) + ':' +
      ('0' + date.getSeconds()).slice(-2);
    return formattedDate;
  },



  // /**
  //  * '1=成功 2=失败 3=未知' => [{ value: 1, label: 成功 }, ...)] (临时用下，等服务端的字典)
  //  * @param {string} str 待转字符串 注意格式必须为'1=成功 2=失败 3=未知' 用空格隔开
  //  * @returns {Array<Object>} 转换后的选项数组[{ value: 1, label: 成功 }, ...)] 失败则为[]
  //  */
  // const getOptionList = (str) => {
  //   let pairs = str.split(' ');
  //   let options = [];
  //   pairs.forEach(function (pair) {
  //     let match = pair.match(/^(\d+)=(.+)$/);
  //     if (match) {
  //       let value = parseInt(match[1], 10);
  //       let label = match[2];
  //       options.push({ value: value, label: label });
  //     }
  //   });
  //   return options;
  // }

}

export default ang;