原生微信小程序最实用的工具函数合集

废话不多说，直接上代码。

示例

common.wxs源码：

<wxs src="../../../utils/common.wxs" module="model" />
<view class="br8 bg-cF7F8FA col-s-s ml24 mr24 mb24 pl24 pr24 pt16 pb16">
    <view class="f28 c86909C">结算金额</view>
    <view class="f36 mt16 cF53F3F">{{model.formatAmount(statementData.amount)}}</view>
 </view>

<view class="col-c-c p24 bg-cF7F8FA br8 f24" data-type="2" bind:tap="navSearchWaybill">
          <view class="mb16 ctextColor3">已发运</view>
          <view class="ctextColor1 fw-600">
            <text class="c0077FA mr4 f24">{{ model.formatNum(ogisticsPlan.loadCount) }}</text>
            <text class="f20">车</text>
          </view>
          <view class="ctextColor1 fw-600 mt8">
            <text class="c0077FA mr4 f24">{{ model.formatNum(ogisticsPlan.loadNumber) }}</text>
            <text class="f20">吨</text>
          </view>
        </view>


var formatStringDateToMMDD = function (datetime) {
  // 直接截取日期部分的 MM-DD
  return datetime.substring(5, 10);
}

var formatStringDateToYYYYMMDD = function (datetime) {
  // 直接截取日期部分的YYYY-MM-DD
  return datetime.substring(0, 10);
}




var hasNo = function (arr, no) {
  var flag = false
  if(arr.length) {
    for (var i = 0; i < arr.length; i++) {
      var v = arr[i];
      if(v.no == no) flag = true
    }
  }
  return flag;
};

var toFixed = function (ignoreRule) {
  return ignoreRule.toFixed(2);
};
var getdeductTypeText = function (deductType,percentByType,toleranceValue,unit) {
  // deductType 1固定值 2百分比
  // "percentByType":null,//让损百分比按什么基数类型 1-、3-按发车
  var nuit = deductType== 1? unit :'%'
  var str = percentByType == 1? '按卸货' : percentByType == 3? '按装货':''
  var text = str + '  ' + toleranceValue+nuit;
  return toleranceValue?text:'--';
};
var getAddressTypeText = function (addressType) {
  var text = "";
  if (addressType == 1) {
    text = "煤矿";
  } else if (addressType == 2) {
    text = "洗煤厂";
  } else if (addressType == 3) {
    text = "站台";
  } else if (addressType == 4) {
    text = "港口";
  } else if (addressType == 5) {
    text = "卸车台";
  } else if (addressType == 6) {
    text = "仓库";
  }
  return text;
};
//判断多久前更新 最小是秒 满1分钟显示X分钟前 最多到年
var formatTimeBetween = function (time, nowTime) {
  if (!time) {
    return "1年前";
  }
  var date = getDate(time);
  var diff = nowTime - date.getTime();
  var second = Math.floor(diff / 1000);
  var minute = Math.floor(second / 60);
  var hour = Math.floor(minute / 60);
  var day = Math.floor(hour / 24);
  var month = Math.floor(day / 30);
  var year = Math.floor(month / 12);

  if (year > 0) {
    return year + "年前";
  } else if (month > 0) {
    return month + "个月前";
  } else if (day > 0) {
    return day + "天前";
  } else if (hour > 0) {
    return hour + "小时前";
  } else if (minute > 0) {
    return minute + "分钟前";
  } else {
    if (second < 10) {
      return "刚刚";
    }
    return second + "秒前";
  }
};

//格式化年月日 今年就只显示月日
var formatTimeMonthAndDayAuto = function (time, currentYear) {
  if (!time) {
    return "";
  }
  date = getDate(time);
  var year = date.getFullYear();
  var month = date.getMonth() + 1;
  var day = date.getDate();
  var nowYear = currentYear;
  if (year == nowYear) {
    return [month, day].map(formatNumber).join("-");
  } else {
    return [year, month, day].map(formatNumber).join("-");
  }
};
var getTimeStatus = function (waybill) {
  var bussStatus = waybill.bussStatus;
  var payStatus = waybill.payStatus;
  var checkStatus = waybill.checkStatus;
  var status = "";
  var time = "";
  if (bussStatus == 1) {
    status = "接单";
    time = formatTime(waybill.createTime, true, false);
    return { status, time };
  }
  if (bussStatus == 2) {
    status = "装货";
    time = formatTime(waybill.loadTime, true, false);
    return { status, time };
  }
  if (bussStatus == 3) {
    status = "卸货";
    time = formatTime(waybill.unloadTime, true, false);
    return { status, time };
  }
  if (bussStatus == 4) {
    if (payStatus === 1) {
      status = "支付";
      time = formatTime(waybill.payTime, true, false);
      return { status, time };
    }
    if (checkStatus === 2) {
      status = "驳回";
      time = formatTime(waybill.dismissTime, true, false);
      return { status, time };
    }
    if (payStatus === 0 || payStatus === 2 || checkStatus === 0) {
      status = "签收";
      time = formatTime(waybill.signTime, true, false);
      return { status, time };
    }
    status = "签收";
    time = formatTime(waybill.signTime, true, false);
    return { status, time };
  }
  if (bussStatus == 5) {
    status = "取消";
    time = formatTime(waybill.cancelTime, true, false);
    return { status, time };
  }
};

var getignoreRuvarext = function (ignoreRule) {
  var text = "";
  if (ignoreRule == 1) {
    text = "不抹零";
  } else if (ignoreRule == 2) {
    text = "角分抹零";
  } else if (ignoreRule == 3) {
    text = "5元以下抹零";
  } else if (ignoreRule == 4) {
    text = "10元以下抹零";
  } else {
    text = "--";
  }
  return text;
};

var getsettlementTonsRuleIdText = function (settl) {
  var text = "";
  if (settl == 1) {
    text = "按签收";
  } else if (settl == 2) {
    text = "按最小值";
  } else if (settl == 3) {
    text = "按发车";
  }else {
    text = "--";
  }
  return text;
};

var planTypeText = function (type) {
  var text = "";
  if (type == 1) {
    text = "采购";
  } else if (type == 2) {
    text = "销售";
  }
  return text;
};

var getPurText = function (ignoreRule) {
  var text = "";
  //-2=已驳回 1=待签约 2=已签约 3=已拒绝 4=已关闭
  if (ignoreRule == -2) {
    text = "已驳回";
  } else if (ignoreRule == 1) {
    text = "待签约";
  } else if (ignoreRule == 2) {
    text = "已签约";
  } else if (ignoreRule == 3) {
    text = "已拒绝";
  } else if (ignoreRule == 4) {
    text = "已关闭";
  }
  return text;
};

var getPurColor = function (ignoreRule) {
  var text = "";
  //-2=已驳回 1=待签约 2=已签约 3=已拒绝 4=已关闭
  if (ignoreRule == -2) {
    text = "cred";
  } else if (ignoreRule == 1) {
    text = "cFA823B"; //待签约
  } else if (ignoreRule == 2) {
    text = "c3BB346";
  } else if (ignoreRule == 3) {
    text = "cC9CDD4";
  } else if (ignoreRule == 4) {
    text = "cC9CDD4";
  }
  return text;
};

var isTimeLong = function (str) {
  return str == "253402185600000";
};

var formatName = function (name) {
  if (!name) return "";
  return name[0] + "**";
};

var getAuditVanIcon = function (status) {
  if (status == 1) {
    icon = "checked";
  } else if (status == 2) {
    icon = "clock";
  } else if (status == 3) {
    icon = "clear";
  }
  return icon;
};

var getAuditVanColor = function (status) {
  if (status == 1) {
    color = "#3BB346";
  } else if (status == 2) {
    color = "#FA823B";
  } else if (status == 3) {
    color = "#ED3B3B";
  }
  return color;
};

var getAuditIcon = function (status) {
  if (status == 1) {
    icon = "driver_ok.png";
  } else if (status == 2) {
    icon = "driver_wait.png";
  } else if (status == 3) {
    icon = "driver_error.png";
  }
  return icon;
};

var getAuditColor = function (status) {
  if (status == 1) {
    color = "c3BB346";
  } else if (status == 2) {
    color = "cFA823B";
  } else if (status == 3) {
    color = "cED3B3B";
  }
  return color;
};

var getAuditBgColor = function (status) {
  if (status == 1) {
    color = "bg-cEBF7EC";
  } else if (status == 2) {
    color = "bg-cFFF3EB";
  } else if (status == 3) {
    color = "bg-cFDEBEB";
  }
  return color;
};

var getAuditText = function (status, isTop = false) {
  if (status == 1) {
    text = isTop ? "认证通过" : "审核通过";
  } else if (status == 2) {
    text = isTop ? "认证中" : "审核中";
  } else if (status == 3) {
    text = isTop ? "认证失败" : "审核失败";
  }
  return text;
};

var formatTimeCommon = function (time, style) {
  if (!time) {
    return "--";
  }

  var date = getDate(time);
  var year = date.getFullYear();
  var month = date.getMonth() + 1;
  var day = date.getDate();
  var hour = date.getHours();
  var minute = date.getMinutes();
  var second = date.getSeconds();

  // 格式化数字为两位数
  var formatNumber = function (n) {
    return n < 10 ? "0" + n : n;
  };

  // 默认格式
  if (!style) {
    style = "YYYY-MM-DD HH:MM:SS";
  }

  // 将 style 转为大写，支持大小写混合
  style = style.toUpperCase();

  // 替换格式中的占位符
  var formattedTime = style
    .replace("YYYY", year)
    .replace("MM", formatNumber(month))
    .replace("DD", formatNumber(day))
    .replace("HH", formatNumber(hour))
    .replace("MM", formatNumber(minute)) // 注意：MM 会被替换两次
    .replace("SS", formatNumber(second));

  return formattedTime;
};

var formatTimeShort = function (time) {
  if (!time) {
    return "--";
  }
  var date = getDate(time);
  var year = date.getFullYear();
  var month = date.getMonth() + 1;
  var day = date.getDate();
  var hour = date.getHours();
  var minute = date.getMinutes();
  var second = date.getSeconds();

  return [hour, minute].map(formatNumber).join(":");
};

var formatTime = function (time, type) {
  if (!time) {
    return "--";
  }
  var date = getDate(time);
  var year = date.getFullYear();
  var month = date.getMonth() + 1;
  var day = date.getDate();
  var hour = date.getHours();
  var minute = date.getMinutes();
  var second = date.getSeconds();
  if (type) {
    return (
      [year, month, day].map(formatNumber).join("-") +
      " " +
      [hour, minute, second].map(formatNumber).join(":")
    );
  }
  return [year, month, day].map(formatNumber).join("-");
};
// 格式年、月、日
var formatTimeYearMonthAndDay = function (time) {
  if (!time) {
    return "";
  }
  date = getDate(time);
  var year = date.getFullYear();
  var month = date.getMonth() + 1;
  var day = date.getDate();
  return [year, month, day].map(formatNumber).join("-");
};
// 格式月和日
var formatTimeMonthAndDay = function (time, isNow) {
  if (!time) {
    return "";
  }
  date = getDate(time);
  var month = date.getMonth() + 1;
  var day = date.getDate();
  return [month, day].map(formatNumber).join("-");
};

var formatNumber = function (n) {
  n = n.toString();
  return n[1] ? n : "0" + n;
};

var formatTimeSec = function (time) {
  if (!time) {
    return "";
  }
  var date = getDate(time);
  var year = date.getFullYear();
  var month = date.getMonth() + 1;
  var day = date.getDate();
  var hour = date.getHours();
  var minute = date.getMinutes();
  var second = date.getSeconds();
  return (
    [year, month, day].map(formatNumber).join("-") +
    " " +
    [hour, minute, second].map(formatNumber).join(":")
  );
};

var formatStatus = function (status) {
  var text = "";
  if (status == 0) {
    text = "未投保";
  } else if (status == 10) {
    text = "核保中";
  } else if (status == 20) {
    text = "待生效";
  } else if (status == 30) {
    text = "保障中";
  } else if (status == 40) {
    text = "已到期";
  } else if (status == 50) {
    text = "已取消";
  } else if (status == 60) {
    text = "已注销";
  } else if (status == 70) {
    text = "投保失败";
  }
  return text;
};
// 认证状态
var formatAuditStatus = function (status) {
  var text = "";
  if (status == -1) {
    text = "需实名";
  } else if (status == 0) {
    text = "未认证";
  } else if (status == 1) {
    text = "已认证";
  } else if (status == 2) {
    text = "认证中";
  } else if (status == 3) {
    text = "认证失败";
  }
  return text;
};

var formatMoneyYuan = function (money) {
  var yuan = Math.floor(money);
  return yuan;
};

var formatMoneyFen = function (money) {
  var fen = (money * 100) % 100;
  if (fen < 10) {
    fen = "0" + fen;
  }
  return fen;
};

var formatNextLine = function (text) {
  if (!text) {
    return;
  }
  var reg = getRegExp("\\\\n", "g");
  return text.replace(reg, "\n");
};

var formatTimeArea = function (time) {
  if (!time) {
    return "--";
  }
  var date = getDate(time);
  var year = date.getFullYear();
  var month = date.getMonth() + 1;
  var day = date.getDate();
  var hour = date.getHours();
  var minute = date.getMinutes();
  var second = date.getSeconds();
  var timeArea = [year, month, day].map(formatNumber).join("-") + " ";

  switch (parseInt(hour / 6)) {
    case 0:
      timeArea += "00:00-06:00";
      break;
    case 1:
      timeArea += "06:00-12:00";
      break;
    case 2:
      timeArea += "12:00-18:00";
      break;
    case 3:
      timeArea += "18:00-24:00";
      break;
  }
  return timeArea;
};

var formatSplit = function (text, flitter) {
  if (!text) {
    return;
  }

  return text.split(flitter);
};
//米转千米 保留2位小数 也要返回单位 如果不足1000m则返回m
var formatDistance = function (distance) {
  if (!distance) {
    return "--";
  }
  var distanceStr = "";
  if (distance > 1000) {
    distanceStr = (distance / 1000).toFixed(2) + "km";
  } else {
    distanceStr = distance + "m";
  }
  return distanceStr;
};

var formatAmount = function (amount) {
  if (!amount || isNaN(amount)) {
    return "0.00";
  }

  // 保留两位小数
  var str = parseFloat(amount).toFixed(2);

  // 手动实现千分位分隔
  var parts = str.split(".");
  var integerPart = parts[0];
  var decimalPart = parts[1];
  var result = "";
  var count = 0;

  for (var i = integerPart.length - 1; i >= 0; i--) {
    result = integerPart[i] + result;
    count++;
    if (count % 3 === 0 && i !== 0) {
      result = "," + result;
    }
  }

  return result + "." + decimalPart;
};

/**
 * 千分位
 * @param {*} value
 * @param {*} precision 保留几位小数
 * @param {*} separator 分隔符
 */
function formatNum(value, precision) {
  if (value == undefined || value == null) {
    var num = precision ? "0." : "0";
    for (var i = 0; i < Number(precision); i++) num += "0";
    return num;
  } else {
    var num = value;
    var parts = [];
    // 判断是否为数字
    if (!isNaN(parseFloat(num)) && isFinite(num)) {
      num = Number(num);
      // 修复四舍五入逻辑
      num = (
        typeof precision !== "undefined"
          ? (
              Math.round(num * Math.pow(10, precision)) /
              Math.pow(10, precision)
            ).toFixed(precision)
          : num
      ).toString();

      var count = 0;
      parts = num.split(".");
      var integerPart = parts[0];
      var result = "";
      for (var i = integerPart.length - 1; i >= 0; i--) {
        result = integerPart[i] + result;
        count++;
        if (count % 3 === 0 && i !== 0) {
          result = "," + result;
        }
      }

      parts[0] = result;
      return parts.join(".");
    }
    return value;
  }
}

module.exports = {
  formatSplit: formatSplit,
  formatTime: formatTime,
  formatTimeSec: formatTimeSec,
  formatStatus: formatStatus,
  formatMoneyYuan: formatMoneyYuan,
  formatMoneyFen: formatMoneyFen,
  formatNextLine: formatNextLine,
  formatTimeMonthAndDay: formatTimeMonthAndDay,
  formatAuditStatus: formatAuditStatus,
  formatTimeArea: formatTimeArea,
  formatTimeYearMonthAndDay: formatTimeYearMonthAndDay,
  formatTimeShort: formatTimeShort,
  getAuditColor: getAuditColor,
  getAuditBgColor: getAuditBgColor,
  getAuditText: getAuditText,
  getAuditIcon: getAuditIcon,
  getAuditVanIcon: getAuditVanIcon,
  getAuditVanColor: getAuditVanColor,
  formatName: formatName,
  formatDistance: formatDistance,
  isTimeLong: isTimeLong,
  getignoreRuvarext: getignoreRuvarext,
  formatTimeCommon: formatTimeCommon,
  planTypeText: planTypeText,
  getPurText: getPurText,
  getPurColor: getPurColor,
  getTimeStatus: getTimeStatus,
  formatTimeBetween: formatTimeBetween,
  formatTimeMonthAndDayAuto: formatTimeMonthAndDayAuto,
  formatAmount: formatAmount,
  getAddressTypeText: getAddressTypeText,
  formatNum: formatNum,
  getsettlementTonsRuleIdText: getsettlementTonsRuleIdText,
  toFixed: toFixed,
  getdeductTypeText: getdeductTypeText,
  hasNo: hasNo,
  formatStringDateToMMDD: formatStringDateToMMDD,
  formatStringDateToYYYYMMDD:formatStringDateToYYYYMMDD,
  
};

util.js源码：

import { navigateTo, throttle, validateDecimalPlaces } from "@utils/util";

handleInput(e) {
    waybillList[index].unloadWeight = validateDecimalPlaces(value, 2)
}



// 查看单个图或 PDF 文件
export const previewSingleFile = (url) => {
    const fileExtension = url.split(".").pop().toLowerCase(); // 获取文件扩展名

    if (fileExtension === "pdf") {
        // 如果是 PDF 文件
        wx.downloadFile({
            url: url, // 下载 PDF 文件
            success: function (res) {
                const filePath = res.tempFilePath; // 临时文件路径
                wx.openDocument({
                    filePath: filePath, // 打开 PDF 文件
                    fileType: "pdf",
                    success: function () {
                        console.log("预览 PDF 成功");
                    },
                    fail: function () {
                        console.log("预览 PDF 失败");
                    },
                });
            },
            fail: function () {
                console.log("下载 PDF 失败");
            },
        });
    } else {
        // 如果是图片
        wx.previewImage({
            urls: [url],
            success: function () {
                console.log("预览图片成功");
            },
            fail: function () {
                console.log("预览图片失败");
            },
        });
    }
};

// 获取嵌套属性值的工具函数
const getNestedValue2 = (obj, path) => {
    return path.split(".").reduce((acc, key) => acc && acc[key], obj);
};

// 设置嵌套属性值的工具函数
const setNestedValue2 = (obj, path, value) => {
    const keys = path.split(".");
    const lastKey = keys.pop();
    const target = keys.reduce((acc, key) => (acc[key] = acc[key] || {}), obj);
    target[lastKey] = value;
};

export function setPrePageData(dataObject, addType = "update", refresh = false) {
    const pages = getCurrentPages(); // 获取页面栈
    if (pages.length < 2) {
        console.error("没有上一个页面，无法设置数据");
        return;
    }
    const prevPage = pages[pages.length - 2]; // 获取上一个页面
    console.log("addType", addType);
    if (addType == "update") {
        prevPage.setData(dataObject); // 动态设置多个键值对
        if (prevPage && typeof prevPage.refresh === 'function' && refresh == true) {
            prevPage.refresh();
        }
    } else if (addType == "add") {
        // 拼接数据到上一个页面的数据数组第一个
        const keyName = Object.keys(dataObject)[0];
        const currentData = getNestedValue2(prevPage.data, keyName) || [];
        const newData = [dataObject[keyName]];

        // 使用工具函数设置嵌套数据
        const updatedData = [...newData, ...currentData];
        setNestedValue2(prevPage.data, keyName, updatedData);
        if (prevPage && typeof prevPage.refresh === 'function' && refresh == true) {
            prevPage.refresh();
        }
        // 更新页面数据
        prevPage.setData({
            [keyName]: updatedData,
        });
    }
    wx.navigateBack(); // 返回上一个页面
}

//查看大图
export const previewImage = (url) => {
    wx.previewImage({
        urls: [url],
        success: function () {
            console.log("预览图片成功");
        },
        fail: function () {
            console.log("预览图片失败");
        },
    });
};

//弹出底部弹窗 复制号码 拨打电话
export const showPhonePopup = (phoneNumber) => {
    wx.showActionSheet({
        itemList: ["复制号码", "拨打电话"],
        success: function (res) {
            if (res.tapIndex === 0) {
                // 复制号码
                wx.setClipboardData({
                    data: phoneNumber,
                    success: function () {
                        wx.showToast({
                            title: "号码已复制",
                            icon: "success",
                        });
                    },
                    fail: function () {
                        wx.showToast({
                            title: "复制失败",
                            icon: "none",
                        });
                    },
                });
            } else if (res.tapIndex === 1) {
                // 拨打电话
                wx.makePhoneCall({
                    phoneNumber: phoneNumber,
                    success: function () {
                        console.log("拨打电话成功");
                    },
                    fail: function () {
                        console.log("拨打电话失败");
                    },
                });
            }
        },
        fail: function (err) {
            console.error("显示操作菜单失败", err);
        },
    });
};

//联系客服
export const callHelpPhone = () => {
    wx.makePhoneCall({
        phoneNumber: "4001168856 ", // 这里替换为你的客服电话
        success: function () {
            console.log("拨打电话成功");
        },
        fail: function () {
            console.log("拨打电话失败");
        },
    });
};

/**
 * 千分位
 * @param {*} value
 * @param {*} precision 保留几位小数
 * @param {*} separator 分隔符
 */
export const thousands = (value, precision, separator = ",") => {
    if (value == undefined || value == null) {
        let num = precision ? "0." : "0";
        for (let i = 0; i < Number(precision); i++) num += "0";
        return num;
    } else {
        let [num, parts] = [value, []];
        // 判断是否为数字
        if (!isNaN(parseFloat(num)) && isFinite(num)) {
            num = Number(num);
            // 修复四舍五入逻辑
            num = (
                typeof precision !== "undefined"
                    ? (
                        Math.round(num * Math.pow(10, precision)) /
                        Math.pow(10, precision)
                    ).toFixed(precision)
                    : num
            ).toString();
            parts = num.split(".");
            parts[0] = parts[0]
                .toString()
                .replace(/(\d)(?=(\d{3})+(?!\d))/g, "$1" + separator);
            return parts.join(".");
        }
        return value;
    }
};

// 定义一个模块作用域的变量
let isNavigating = false; // 在模块加载时初始化为 false

/**
 * 公共跳转方法，带节流功能
 * @param {string} url - 跳转的目标页面路径
 * @param {object} options - 跳转参数（可选）
 */
export const navigateTo = (url, options = {}) => {
    if (isNavigating) {
        console.log("跳转过于频繁，请稍后再试");
        return;
    }

    isNavigating = true; // 设置跳转标记
    setTimeout(() => {
        isNavigating = false; // 一段时间后解除跳转限制
    }, 1000); // 节流时间，单位为毫秒

    // 执行跳转
    wx.navigateTo({
        url,
        ...options,
        success: () => {
            console.log("跳转成功");
        },
        fail: (err) => {
            console.error("跳转失败", err);
        },
    });
};

/**
 * 公共跳转方法，带节流功能
 * @param {string} url - 跳转的目标页面路径
 * @param {object} options - 跳转参数（可选）
 */
export const redirectTo = (url, options = {}) => {
    if (isNavigating) {
        console.log("跳转过于频繁，请稍后再试");
        return;
    }

    isNavigating = true; // 设置跳转标记
    setTimeout(() => {
        isNavigating = false; // 一段时间后解除跳转限制
    }, 1000); // 节流时间，单位为毫秒

    // 执行跳转
    wx.redirectTo({
        url,
        ...options,
        success: () => {
            console.log("跳转成功");
        },
        fail: (err) => {
            console.error("跳转失败", err);
        },
    });
};

export const logout = () => {
    wx.removeStorageSync("token");
    const app = getApp();
    app.globalData.token = null;
    wx.reLaunch({
        url: "/pages/splash/index",
    });
};

export const isLogin = (jump = false) => {
    const token = wx.getStorageSync("token");
    if (!token) {
        if (jump) {
            wx.navigateTo({
                url: "/pages/login/login",
            });
        }
        return false;
    }
    return true;
};

export const formatTime = (date, type, nosecond) => {
    if (!date) {
        return "";
    }
    date = new Date(date);
    const year = date.getFullYear();
    const month = date.getMonth() + 1;
    const day = date.getDate();
    const hour = date.getHours();
    const minute = date.getMinutes();
    const second = date.getSeconds();
    if (type) {
        if (nosecond) {
            return `${[year, month, day].map(formatNumber).join("-")} ${[hour, minute]
                .map(formatNumber)
                .join(":")}`;
        } else {
            return `${[year, month, day].map(formatNumber).join("-")} ${[
                hour,
                minute,
                second,
            ]
                .map(formatNumber)
                .join(":")}`;
        }
    }
    return [year, month, day].map(formatNumber).join("-");
};

export const formatNumber = (n) => {
    n = n.toString();
    return n[1] ? n : `0${n}`;
};

export function debounce(func, delay = 300) {
    let timer = null;
    return function (...args) {
        if (timer) clearTimeout(timer);
        timer = setTimeout(() => {
            func.apply(this, args);
        }, delay);
    };
}

export function throttle(fn, interval) {
    var enterTime = 0;
    var gapTime = interval || 1500;
    return function () {
        var context = this;
        var args = arguments;
        var backTime = new Date();
        if (backTime - enterTime > gapTime) {
            fn.apply(context, args);
            enterTime = backTime;
        }
    };
}

export function secKillClock(that, param, list) {
    return setInterval(function () {
        let allChange = false;
        for (let idx = 0; idx < list.length; idx++) {
            if (list[idx].seckillType == "2") {
                allChange = true;
                list[idx].timeLeft -= 1;
                list[idx].timeLeftShow = secToClock(list[idx].timeLeft);
                if (list[idx].timeLeft == 0) {
                    list[idx].seckillType = "1";
                }
            }
        }
        if (allChange) {
            that.setData({
                [param]: list,
            });
        }
    }, 1000);
}
export const formatTimeArea = (dateStart, dateEnd, type = false) => {
    dateStart = new Date(dateStart);
    const year = dateStart.getFullYear();
    const month = dateStart.getMonth() + 1;
    const day = dateStart.getDate();
    const hour = dateStart.getHours();
    const minute = dateStart.getMinutes();
    const second = dateStart.getSeconds();
    let timeArea = [year, month, day].map(formatNumber).join("-") + " ";

    switch (parseInt(hour / 6)) {
        case 0:
            timeArea += "00:00-06:00";
            break;
        case 1:
            timeArea += "06:00-12:00";
            break;
        case 2:
            timeArea += "12:00-18:00";
            break;
        case 3:
            timeArea += "18:00-24:00";
            break;
    }
    return timeArea;
};

export function throttleShort(fn, interval) {
    var enterTime = 0;
    var gapTime = interval || 200;
    return function () {
        var context = this;
        var backTime = new Date();
        if (backTime - enterTime > gapTime) {
            fn.call(context, arguments);
            enterTime = backTime;
        }
    };
}

export var accMul = function (arg1, arg2) {
    if (!arg1 || !arg2) {
        return 0;
    }
    var m = 0,
        s1 = arg1.toString(),
        s2 = arg2.toString();
    try {
        m += s1.split(".")[1].length;
    } catch (e) { }
    try {
        m += s2.split(".")[1].length;
    } catch (e) { }
    let data =
        (Number(s1.replace(".", "")) * Number(s2.replace(".", ""))) /
        Math.pow(10, m);
    let string = data.toString();
    if (string.indexOf(".") > -1) {
        data = data.toFixed(2);
    }
    return data;
};
/**
 * 身份证隐藏
 * @param {*} value
 * @param {*} frontLen 前面保留位数
 * @param {*} endLen 后面保留位数
 */
export var hideIDCard = (value, frontLen, endLen) => {
    frontLen = frontLen || 4;
    endLen = endLen || 4;
    if (value) {
        let len = value.length - frontLen - endLen;
        let xing = "";
        for (let i = 0; i < len; i++) {
            xing += "*";
        }
        return (
            value.substring(0, frontLen) +
            xing +
            value.substring(value.length - endLen)
        );
    } else {
        return "";
    }
};

export var calculateDistance = (lat1, lon1, lat2, lon2) => {
    const R = 6371; // 地球半径，单位为公里
    const dLat = ((lat2 - lat1) * Math.PI) / 180;
    const dLon = ((lon2 - lon1) * Math.PI) / 180;
    const a =
        0.5 -
        Math.cos(dLat) / 2 +
        (Math.cos((lat1 * Math.PI) / 180) *
            Math.cos((lat2 * Math.PI) / 180) *
            (1 - Math.cos(dLon))) /
        2;
    return R * 2 * Math.asin(Math.sqrt(a)); // 返回距离，单位为公里
};

// 格式化身份证号
export const formatCardNumber = (cardNumber) => {
    if (cardNumber) {
        return cardNumber.replace(/(\d{3})(\d{4})(\d{7})(\d{2})/, "$1 **** $4");
    }
    return "";
};

export const formatter = (type, val) => {
    if (type === "year") return `${val}年`;
    if (type === "month") return `${val}月`;
    if (type === "day") return `${val}日`;
    if (type === "hour") return `${val}时`;
    if (type === "minute") return `${val}分`;
    return val;
};

export const formatTimestamp = (timestamp) => {
    var date = new Date(timestamp * 1000);
    var year = date.getFullYear();
    var month = ("0" + (date.getMonth() + 1)).slice(-2);
    var day = ("0" + date.getDate()).slice(-2);
    var hour = ("0" + date.getHours()).slice(-2);
    var minute = ("0" + date.getMinutes()).slice(-2);
    var second = ("0" + date.getSeconds()).slice(-2);

    return (
        year + "-" + month + "-" + day + " " + hour + ":" + minute + ":" + second
    );
};

/**
 * 时间戳转年月日格式
 * @param {number} timestamp 时间戳
 * @returns {string} 格式化后的日期字符串 (YYYY-MM-DD)
 */
export const formatTimestampToDate = (timestamp, type) => {
    if (!timestamp) return '';
    const date = new Date(timestamp);
    const year = date.getFullYear();
    const month = String(date.getMonth() + 1).padStart(2, '0');
    const day = String(date.getDate()).padStart(2, '0');
    const hour = String(date.getHours()).padStart(2, "0");
    const minute = String(date.getMinutes()).padStart(2, "0");
    const second = String(date.getSeconds()).padStart(2, "0");
    if (type === 'ymdHsm') {
        return `${year}-${month}-${day} ${hour}:${minute}:${second}`;
    } else {
        return `${year}-${month}-${day}`
    }
};

// 将字符串转换为 Base64
export const stringToBase64 = (str) => {
    // 把字符串编码成 Uint8Array
    const encoder = new TextEncoder();
    const uint8Array = encoder.encode(str);

    // 把 Uint8Array 转换为 ArrayBuffer
    const arrayBuffer = uint8Array.buffer;

    // 利用小程序 API 把 ArrayBuffer 转换为 Base64 字符串
    return wx.arrayBufferToBase64(arrayBuffer);
};

// utils/dateRange.js
export const DateRangeUtil = {
    // 格式化日期时间（精确到分钟）
    formatDateTime(date) {
        const year = date.getFullYear();
        const month = String(date.getMonth() + 1).padStart(2, "0");
        const day = String(date.getDate()).padStart(2, "0");
        const hour = String(date.getHours()).padStart(2, "0");
        const minute = String(date.getMinutes()).padStart(2, "0");
        return `${year}-${month}-${day} ${hour}:${minute}`;
    },

    // 获取相对时间范围
    getRelativeRange(days) {
        const end = new Date();
        end.setHours(23, 59, 0, 0); // 结束时间设为23:59

        const start = new Date();
        start.setDate(end.getDate() - days + 1);
        start.setHours(0, 0, 0, 0); // 开始时间设为00:00

        return {
            start: this.formatDateTime(start),
            end: this.formatDateTime(end),
        };
    },
    // 昨天
    yesterday() {
        const end = new Date();
        end.setDate(end.getDate() - 1);
        end.setHours(23, 59, 0, 0); // 结束时间设为23:59

        const start = new Date();
        start.setDate(end.getDate());
        start.setHours(0, 0, 0, 0); // 开始时间设为00:00

        return {
            start: this.formatDateTime(start),
            end: this.formatDateTime(end),
        };
    },

    // 近3天
    last3Days() {
        return this.getRelativeRange(3);
    },

    // 近7天
    last7Days() {
        return this.getRelativeRange(7);
    },

    // 近30天
    last30Days() {
        return this.getRelativeRange(30);
    },

    // 本周（从周一开始到周日结束）
    thisWeek() {
        const end = new Date();
        end.setHours(23, 59, 0, 0);

        const start = new Date();
        start.setDate(end.getDate() - (end.getDay() || 7) + 1); // 周一是第1天
        start.setHours(0, 0, 0, 0);

        return {
            start: this.formatDateTime(start),
            end: this.formatDateTime(end),
        };
    },

    // 本月
    thisMonth() {
        const end = new Date();
        end.setHours(23, 59, 0, 0);
        end.setMonth(end.getMonth() + 1, 0); // 本月最后一天

        const start = new Date();
        start.setDate(1);
        start.setHours(0, 0, 0, 0);

        return {
            start: this.formatDateTime(start),
            end: this.formatDateTime(end),
        };
    },

    // 本季度
    thisQuarter() {
        const now = new Date();
        const quarter = Math.floor(now.getMonth() / 3);

        const start = new Date(now.getFullYear(), quarter * 3, 1, 0, 0, 0);

        const end = new Date(now.getFullYear(), (quarter + 1) * 3, 0, 23, 59, 0);

        return {
            start: this.formatDateTime(start),
            end: this.formatDateTime(end),
        };
    },

    // 本年
    thisYear() {
        const year = new Date().getFullYear();
        return {
            start: `${year}-01-01 00:00`,
            end: `${year}-12-31 23:59`,
        };
    },
};
/**
 * 获取嵌套对象的值（支持 'address.detail' 格式路径）
 * @param {Object} obj 目标对象
 * @param {string} path 字段路径（如 'address.detail'）
 * @returns {any} 字段值
 */
function getNestedValue(obj, path) {
    return path.split(".").reduce((acc, part) => {
        return acc && acc.hasOwnProperty(part) ? acc[part] : null;
    }, obj);
}
/**
 * 通用表单校验方法
 * @param {Object} formData 表单数据对象
 * @param {Object} rules 校验规则配置（结构示例见下方说明）
 * @returns {Object} 错误信息对象（键为字段名，值为错误提示）
 */
export function validateForm(formData, rules) {
    const errors = {};

    // 遍历所有校验规则
    Object.keys(rules).forEach((field) => {
        const fieldRules = rules[field];
        let errorMsg = "";

        // 支持嵌套字段（如 address.detail）
        const fieldValue = getNestedValue(formData, field);

        // 执行所有校验规则（遇到第一个错误即停止）
        for (const rule of fieldRules) {
            if (errorMsg) break; // 已有错误则跳过后续校验

            // 处理必填校验
            if (rule.required) {
                const msg = validators.required(fieldValue, rule.message);
                if (msg) {
                    errorMsg = msg;
                    continue;
                }
            }

            if (rule.pattern) {
                if (fieldValue != null && fieldValue != "") {
                    const isValid = new RegExp(rule.pattern.replace(/\\\\/g, "\\")).test(
                        fieldValue
                    );
                    if (!isValid) {
                        errorMsg = rule.message || "输入内容不符合要求";
                    }
                }
            }
        }

        errors[field] = errorMsg;
    });

    //遍历errors 每一项里的值为空 则去掉这个值
    Object.keys(errors).forEach((key) => {
        if (errors[key] === "") {
            delete errors[key];
        }
    });
    // 获取第一个错误 用于toast
    const firstKey = Object.keys(errors)[0]; // 获取第一个键
    const firstValue = errors[firstKey];

    return {
        isValid: errors && Object.keys(errors).length === 0,
        errors: errors,
        firstError: firstValue || "",
    };
}

const validators = {
    // 通用必填校验（可复用）
    required: (value, message = "该字段为必填项") => {
        return value ? "" : message;
    },
};
/**
 * 计算当前日期到指定日期的天数差
 * @param {string|number|Date} targetDate - 指定日期（支持字符串、时间戳或Date对象）
 * @param {Object} options - 配置项
 * @param {boolean} [options.includeToday=true] - 是否包含今天（默认true）
 * @param {boolean} [options.ignoreTime=true] - 是否忽略时分秒（默认true）
 * @returns {number} 天数差（正值表示未来，负值表示过去）
 */
export function daysFromToday(targetDate, options = {}) {
    const { includeToday = true, ignoreTime = true } = options;

    // 获取当前日期
    const today = new Date();

    // 处理目标日期
    const target =
        typeof targetDate === "number"
            ? new Date(targetDate)
            : new Date(targetDate);

    // 忽略时分秒（可选）
    if (ignoreTime) {
        today.setHours(0, 0, 0, 0);
        target.setHours(0, 0, 0, 0);
    }

    // 计算时间差（毫秒）
    const timeDiff = target.getTime() - today.getTime();

    // 转换为天数
    const daysDiff = Math.floor(timeDiff / (1000 * 3600 * 24));

    // 如果包含今天，需要加1天
    return includeToday ? daysDiff + 1 : daysDiff;
}

export function timeDiff(date1, date2, hasNewDay=true) {
    
    // hasNewDay是否计算今天，默认算今天
    // 处理输入参数：转换为Date对象
    var d1 = typeof date1 === "number" ? new Date(date1) : new Date(date1);
    var d2 = typeof date2 === "number" ? new Date(date2) : new Date(date2);

    // 重置时分秒为0（只比较日期部分）
    d1.setHours(0, 0, 0, 0);
    d2.setHours(0, 0, 0, 0);

    // 如果日期部分相同，返回1天
    if (d1.getTime() === d2.getTime() && hasNewDay) {
        return 1;
    }

    // 计算时间差（毫秒）
    var timeDiff = d2.getTime() - d1.getTime();
    
    // 将时间差转换为天数（向下取整并加1）
    return Math.floor(timeDiff / (1000 * 3600 * 24)) + (hasNewDay ? 1 : 0);
}

//数字范围校验 允许小数 不符合条件的不允许输入不要清空
export const validateNumberRange = (inputValue, min, max) => {
    // 正则表达式：允许输入数字和小数点
    const reg = /^\d*\.?\d*$/;

    // 如果输入的不是数字或小数点，移除非法字符
    inputValue = inputValue.replace(/[^0-9.]/g, "");

    // 转换为数字进行范围校验
    const numValue = parseFloat(inputValue);

    // 如果转换后的值不在范围内，调整为范围内的合法值
    if (!isNaN(numValue)) {
        if (numValue < min) {
            inputValue = min.toString();
        } else if (numValue > max) {
            inputValue = max.toString();
        }
    } else {
        inputValue = ""; // 如果输入无法转换为数字，清空输入框
    }

    return inputValue;
};
//数字范围校验 允许输入小数点后几位 几位可配置 不符合条件不允许输入 不要清空
export const validateDecimalPlaces = (inputValue, decimalPlaces) => {
    // 正则表达式：允许输入数字和小数点，限制小数点后位数
    const reg = new RegExp(`^\\d*(\\.\\d{0,${decimalPlaces}})?$`);

    // 如果输入的不是符合条件的格式，移除非法字符
    if (!reg.test(inputValue)) {
        inputValue = inputValue.replace(/[^0-9.]/g, "");
        const parts = inputValue.split(".");
        if (parts.length > 1) {
            // 保留小数点后指定的位数
            inputValue = parts[0] + "." + parts[1].slice(0, decimalPlaces);
        }
    }

    return inputValue;
};

export const getignoreRuleTextAndRole = function (ignoreRule) {
    let obj = { text: "", role: "" }
    var text = "";
    if (ignoreRule == 1) {
        obj.dialogTitle = "不抹零";
    } else if (ignoreRule == 2) {
        obj.dialogTitle = "角分抹零";
        obj.role = "运费:108.80元 抹零后:108元";
    } else if (ignoreRule == 3) {
        obj.dialogTitle = "5元以下抹零";
        obj.role = "运费:108.80元 抹零后:105元,\n 运费:104.80元 抹零后:100元";
    } else if (ignoreRule == 4) {
        obj.dialogTitle = "10元以下抹零";
        obj.role = "运费:108.80元 抹零后:100元";
    }
    return obj;
};

export const getSettlementTonsRuleName = (id) => {
    let name = "";
    if (id == 1) {
        name = "按签收";
    }
    if (id == 2) {
        name = "按最小值";
    }
    if (id == 3) {
        name = "按发车";
    }
    return name
};
export const getErasureRuleName = (id) => {
    let name = "";
    if (id == 1) {
        name = "不抹零";
    }
    if (id == 2) {
        name = "角分抹零";
    }
    if (id == 3) {
        name = "5元以下抹零";
    }
    if (id == 4) {
        name = "10元以下抹零";
    }
    return name;
}

// 对象格式序列化
export function toFormUrlEncoded(obj) {
    return Object.keys(obj)
        .map((key) => encodeURIComponent(key) + "=" + encodeURIComponent(obj[key] || ''))
        .join("&");
}

// 将对象中，vlaue为空值，转换为--
export const handleNullValue = (obj) => {
    for (let key in obj) {
        if (obj[key] === null || obj[key] === undefined || obj[key] === '') {
            obj[key] = '--';
        } else if (typeof obj[key] === 'object') {
            handleNullValue(obj[key]);
        }
    }
    return obj;
}

// 获取performanceId对应的文字描述
export const getPerformanceDesc = (id, channelType, channelTypeCn, isList) => {
    let channelTypeStr;
    if (channelType === null || channelType === undefined) {
        channelTypeStr = '--';
    } else if (channelType === -1) {
        channelTypeStr = "不使用";
    } else {
        channelTypeStr = channelTypeCn ?? '-';
    }
    const performanceMap = {
        1: isList ? '汽运入库（' + channelTypeStr + '）' : '汽运入库',
        4: '直接入库',
        6: '火运入库',
        7: '货权转入',
        8: '货权转出',
        11: '火运出库',
        9: '直接出库',
        10: isList ? '汽运出库（' + channelTypeStr + '）' : '汽运出库'
    };
    return performanceMap[id] || '--';
};

export const formatTimeCommon = function (time, style) {
    if (!time) {
        return "--";
    }
    const date = new Date(time);
    var year = date.getFullYear();
    var month = date.getMonth() + 1;
    var day = date.getDate();
    var hour = date.getHours();
    var minute = date.getMinutes();
    var second = date.getSeconds();

    // 格式化数字为两位数
    var formatNumber = function (n) {
        return n < 10 ? "0" + n : n;
    };

    // 默认格式
    if (!style) {
        style = "YYYY-MM-DD HH:MM:SS";
    }

    // 将 style 转为大写，支持大小写混合
    style = style.toUpperCase();

    // 替换格式中的占位符
    var formattedTime = style
        .replace("YYYY", year)
        .replace("MM", formatNumber(month))
        .replace("DD", formatNumber(day))
        .replace("HH", formatNumber(hour))
        .replace("MM", formatNumber(minute)) // 注意：MM 会被替换两次
        .replace("SS", formatNumber(second));

    return formattedTime;
};

export const round = (number, precision = 0) => {
  // 处理精度范围（防止过大或过小）
  precision = Math.min(Math.max(precision, -292), 292);

  // 转换为科学计数法进行舍入
  const shift = 10 ** precision;
  return Math.round(number * shift) / shift;
}

/**
 * 千分位
 * @param {*} value
 * @param {*} precision 保留几位小数
 * @param {*} separator 分隔符
 */
export const thousands = (value, precision = 2, separator = ",") => {
  if (value == undefined || value == null) {
    let num = precision ? "0." : "0";
    for (let i = 0; i < Number(precision); i++) num += "0";
    return num;
  } else {
    let [num, parts] = [value, []];
    // 判断是否为数字
    if (!isNaN(parseFloat(num)) && isFinite(num)) {
      num = Number(num);
      num = (
        typeof precision !== "undefined"
          ? round(num, precision).toFixed(precision)
          : num
      ).toString();
      parts = num.split(".");
      parts[0] = parts[0]
        .toString()
        .replace(/(\d)(?=(\d{3})+(?!\d))/g, "$1" + separator);
      return parts.join(".");
    }
    return value;
  }
};

// 金额千分位
export const amountThousands = (val) => thousands(val, 2);

// 吨位千分位，小数点后面有0，则不展示
export const tonThousands = (val) => {
  const valStr = thousands(val, 4);

  if (valStr.indexOf(".") > 0) {
    // 匹配小数点后面的0，并且匹配至少一个数字后面跟着小数点
    const regex = /(\.0*|0|00|000|0000)$/;
    // 使用replace方法去除尾部的0
    const result = valStr.replace(regex, "");
    // 如果结果是空字符串，返回0，否则返回处理后的字符串
    return result ? result : "0";
  }

  return val ? thousands(val, 4) : "0";
};

/**
 * 金额大写
 * @param {*} value
 */
export const chineseNumeral = (value) => {
  // 汉字的数字
  const cnNums = ["零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖"];
  // 基本单位
  const cnIntRadice = ["", "拾", "佰", "仟"];
  // 对应整数部分扩展单位
  const cnIntUnits = ["", "万", "亿", "兆"];
  // 对应小数部分单位
  const cnDecUnits = ["角", "分", "毫", "厘"];
  // 整数金额时后面跟的字符
  const cnInteger = "整";
  // 整型完以后的单位
  const cnIntLast = "元";
  // 最大处理的数字
  const maxNum = 999999999999999.9999;
  // 金额整数部分
  let integerNum;
  // 金额小数部分
  let decimalNum;
  // 输出的中文金额字符串
  let chineseStr = "";
  // 分离金额后用的数组，预定义
  let parts;

  if (value == "" || value == 0) {
    return "零元整";
  }
  value = parseFloat(value);
  if (value >= maxNum) {
    // 超出最大处理数字
    return "";
  }
  if (value == 0) {
    chineseStr = cnNums[0] + cnIntLast + cnInteger;
    return chineseStr;
  }
  // 转换为字符串
  value = value.toString();
  if (value.indexOf(".") == -1) {
    integerNum = value;
    decimalNum = "";
  } else {
    parts = value.split(".");
    integerNum = parts[0];
    decimalNum = parts[1].substr(0, 4);
  }
  // 获取整型部分转换
  if (parseInt(integerNum, 10) > 0) {
    let zeroCount = 0;
    const IntLen = integerNum.length;
    for (let i = 0; i < IntLen; i++) {
      const n = integerNum.substr(i, 1);
      const p = IntLen - i - 1;
      const q = p / 4;
      const m = p % 4;
      if (n == "0") {
        zeroCount++;
      } else {
        if (zeroCount > 0) {
          chineseStr += cnNums[0];
        }
        // 归零
        zeroCount = 0;
        chineseStr += cnNums[parseInt(n)] + cnIntRadice[m];
      }
      if (m == 0 && zeroCount < 4) {
        chineseStr += cnIntUnits[q];
      }
    }
    chineseStr += cnIntLast;
  }
  // 小数部分
  if (decimalNum != "") {
    const decLen = decimalNum.length;
    for (let i = 0; i < decLen; i++) {
      const n = decimalNum.substr(i, 1);
      if (n != "0") {
        chineseStr += cnNums[Number(n)] + cnDecUnits[i];
      }
    }
  }
  if (chineseStr == "") {
    chineseStr += cnNums[0] + cnIntLast + cnInteger;
  } else if (decimalNum == "") {
    chineseStr += cnInteger;
  }
  return chineseStr;
};

export const digitsNumberal = (value) => {
  const base = ["", "十", "百", "千"];
  const unit = ["", "万", "亿", "兆"]; //, '京', '垓', '杼', '穰', '沟', '涧', '正', '载', '极'];

  const digit = Math.floor(Math.log10(value));
  return digit >= base.length * unit.length
    ? "远超上限"
    : base[digit % 4] + unit[Math.floor(digit / 4)];
};

/**
 * 身份证隐藏
 * @param {*} value
 * @param {*} frontLen 前面保留位数
 * @param {*} endLen 后面保留位数
 */
export const hideIDCard = (value, frontLen = "", endLen = "") => {
  frontLen = frontLen || 4;
  endLen = endLen || 4;
  if (value) {
    let len = value.length - frontLen - endLen;
    if (len <= 0) {
      return value;
    }
    let xing = "****";
    return (
      value.substring(0, frontLen) +
      xing +
      value.substring(value.length - endLen)
    );
  } else {
    return "";
  }
};

/**
 * 银行卡号4位分割
 * @param {*} value
 */
export const bankNumber = (value) => {
  if (!value) return "";
  if (/\S{5}/.test(value)) {
    return value.replace(/\s/g, "").replace(/(.{4})/g, "$1 ");
  } else {
    return value;
  }
};

/**
 * 格式化数字为万或亿的显示形式，并支持选择保留小数位数
 * @param {number} value - 需要格式化的数字
 * @param {number} [decimalPlaces=0] - 保留的小数位数，默认为 0
 * @returns {string} - 格式化后的字符串，单位为万或亿
 */
export const formatNumberWithUnits = (value, decimalPlaces = 0) => {
  if (value >= 100000000) {
    // 大于等于 1 亿
    const result = value / 100000000;
    return (
      (result < 10 ? result.toFixed(1) : result.toFixed(decimalPlaces)) + "亿"
    );
  } else if (value >= 10000) {
    // 大于等于 1 万
    const result = value / 10000;
    return (
      (result < 10 ? result.toFixed(1) : result.toFixed(decimalPlaces)) + "万"
    );
  } else {
    // 其他情况，直接返回原值
    return value.toFixed(decimalPlaces);
  }
};

//格式化年月日 今年就只显示月日
var formatTimeMonthAndDayAuto = function (time, currentYear) {
  if (!time) {
    return "";
  }
  date = getDate(time);
  var year = date.getFullYear();
  var month = date.getMonth() + 1;
  var day = date.getDate();
  var nowYear = currentYear;
  if (year == nowYear) {
    return [month, day].map(formatNumber).join("-");
  } else {
    return [year, month, day].map(formatNumber).join("-");
  }
};

    

END...