jinbi-utils 1.0.19 → 1.0.21

package/src/number/index.ts

@@ -0,0 +1,362 @@
+/**
+ * number处理相关
+ * @packageDocumentation
+ * @module Number
+ * @preferred
+ */
+
+/**
+ * 格式化字节大小为可读字符串
+ * @param bytes - 字节数
+ * @param decimals - 小数位数，默认为 2
+ * @returns 格式化后的字符串（如 "1.5 MB"）
+ */
+export function formatBytes(bytes: number, decimals: number = 2): string {
+  if (bytes === 0) return '0 Bytes';
+
+  const k = 1024;
+  const dm = decimals < 0 ? 0 : decimals;
+  const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'];
+
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+
+  return parseFloat((bytes / Math.pow(k, i)).toFixed(dm)) + ' ' + sizes[i];
+}
+
+import { isEmpty } from '../common';
+
+/**
+ * 货币计算选项接口
+ */
+interface MoneyComputeOptions {
+  // 操作类型: multiply(乘法) 或 divide(除法)
+  operation: 'multiply' | 'divide';
+  // 系数，默认为100（分转元）
+  factor: number;
+  // 小数位数
+  precision?: number;
+  // 是否格式化为货币格式
+  formatAsCurrency?: boolean;
+  // 货币符号，默认为¥
+  currencySymbol?: string;
+  // 自定义格式化函数
+  formatter?: (value: number) => string;
+}
+
+// 默认货币计算选项
+const DEFAULT_MONEY_OPTIONS: MoneyComputeOptions = {
+  operation: 'divide', // 默认为除法，将分转换为元
+  factor: 100,        // 默认除法因子为100，分转元
+  precision: 2,       // 默认保留两位小数
+  formatAsCurrency: false,
+  currencySymbol: '¥' // 人民币符号
+};
+/**
+ * 千分位格式化
+  #### 使用说明
+  ```
+  toThousands(1) => 1
+  toThousands(12345) => 12,345
+  toThousands('12323.12') 返回 '12,323.12'
+  ```
+ */
+export function toThousands(num: number | string, defaultValue = '-'): string {
+  if (isEmpty(num)) {
+    return defaultValue;
+  }
+  let val = num.toString();
+
+  if (!val.includes('.')) {
+    val += '.';
+  }
+  return val.replace(/\d(?=(\d{3})+\.)/g, $0 => `${$0},`).replace(/\.$/, '');
+}
+
+/**
+ * 阿拉伯数组转中文数字
+ #### 使用说明
+ ```
+ convertCurrency(0) 返回 '壹拾贰元壹角贰分'
+ convertCurrency(1234567809) 返回 '壹拾贰亿叁仟肆佰伍拾陆万柒仟捌佰零玖元整'
+ ```
+ * @param {number} money 金额
+ */
+export function convertCurrency(money = '') {
+  const maxNum = 999999999999999.9999; // 最大处理的数字
+
+  if (isEmpty(money)) {
+    return '';
+  }
+  if (Number(money) >= maxNum) {
+    // 超出最大处理数字
+    return money;
+  }
+
+  const cnNums = ['零', '壹', '贰', '叁', '肆', '伍', '陆', '柒', '捌', '玖'];
+  const cnIntRadice = ['', '拾', '佰', '仟'];
+  const cnIntUnits = ['', '万', '亿', '兆']; // 对应整数部分扩展单位
+  const cnDecUnits = ['角', '分', '毫', '厘']; // 对应小数部分单位
+  const cnInteger = '整'; // 整数金额时后面跟的字符
+  const cnIntLast = '元'; // 整型完以后的单位
+  let integerNum; // 金额整数部分
+  let decimalNum; // 金额小数部分
+  let chineseStr = ''; // 输出的中文金额字符串
+  let parts; // 分离金额后用的数组，预定义
+  money = parseFloat(money).toString();
+
+  if (money === '0') {
+    chineseStr = cnNums[0] + cnIntLast + cnInteger;
+    return chineseStr;
+  }
+  // 转换为字符串
+  money = money.toString();
+  if (money.indexOf('.') === -1) {
+    integerNum = money;
+    decimalNum = '';
+  } else {
+    parts = money.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 += 1) {
+      const n = integerNum.substr(i, 1);
+      const p = intLen - i - 1;
+      const q = p / 4;
+      const m = p % 4;
+      if (n === '0') {
+        zeroCount += 1;
+      } else {
+        if (zeroCount > 0) {
+          chineseStr += cnNums[0];
+        }
+        // 归零
+        zeroCount = 0;
+        chineseStr += cnNums[parseInt(n, 10)] + 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 += 1) {
+      const dn = decimalNum.substr(i, 1);
+      if (dn !== '0') {
+        chineseStr += cnNums[Number(dn)] + cnDecUnits[i];
+      }
+    }
+  }
+  if (chineseStr === '') {
+    chineseStr += cnNums[0] + cnIntLast + cnInteger;
+  } else if (decimalNum === '') {
+    chineseStr += cnInteger;
+  }
+  return chineseStr;
+}
+
+/**
+ * 格式化小数位
+ #### 使用说明
+ ```
+ formatFloat('1.2345') 返回 '1.23'
+ formatFloat('1.2345', 3) 返回 '1.235'
+ formatFloat('1', 3) 返回 '1.000'
+ ```
+ * @param {*} val 小数
+ * @param {number} [pos=2] 保留的小数位
+ */
+export function formatFloat(val: string | number, pos = 2): string {
+  let f = parseFloat(String(val));
+  if (Number.isNaN(f)) {
+    return '';
+  }
+  f = Math.round(Number(val) * Math.pow(10, pos)) / Math.pow(10, pos); // pow 幂
+  let s = f.toString();
+  let rs = s.indexOf('.');
+  if (rs < 0) {
+    rs = s.length;
+    s += '.';
+  }
+  while (s.length <= rs + pos) {
+    s += '0';
+  }
+  return s;
+}
+
+/**
+ * 向上取整
+ #### 使用说明
+ ```
+ ceil('1.23') 返回 2
+ ceil('1.234', 2) 返回 1.24
+ ceil('1.230', 2) 返回 1.23
+ ```
+ * @param {*} val
+ * @param {number} [pos=2] 保留的小数位
+ */
+export function ceil(val: string | number, pos = 0) {
+  if (isEmpty(val)) {
+    return val;
+  }
+
+  const swell = Math.pow(10, pos);
+  const swellVal = Number(val) * swell;
+  const newVal = Math.ceil(swellVal) / swell;
+
+  return newVal;
+}
+
+/**
+ * 向下取整
+ #### 使用说明
+ ```
+ floor('1.23') 返回 1
+ floor('1.234', 2) 返回 1.23
+ floor('1.230', 2) 返回 1.23
+ ```
+ * @param {*} val
+ * @param {number} [pos=2] 保留的小数位
+ */
+export function floor(val: string | number, pos = 0) {
+  if (isEmpty(val)) {
+    return val;
+  }
+
+  const swell = Math.pow(10, pos);
+  const swellVal = Number(val) * swell;
+  return Math.floor(swellVal) / swell;
+}
+
+/**
+ * 格式化货币数字
+ #### 使用说明
+ ```
+ formatMoney(1234) 返回 '12.34'
+ formatMoney(1234, { operation: 'multiply', factor: 100 }) 返回 '123400.00'
+ formatMoney(1234, { formatAsCurrency: true }) 返回 '¥12.34'
+ formatMoney(1234, { formatAsCurrency: true, currencySymbol: '$' }) 返回 '$12.34'
+ formatMoney(1234.567, { precision: 3 }) 返回 '12.346'
+ formatMoney('1,234.56', { operation: 'multiply', factor: 1 }) 返回 '1234.56'
+ ```
+ * @param value 要格式化的值
+ * @param options 格式化选项
+ * @returns 格式化后的字符串
+ */
+export function formatMoney(value: number | string | null | undefined, options?: Partial<MoneyComputeOptions>): string {
+  // 先计算值
+  const numericResult = computeMoney(value, options);
+
+  // 合并选项
+  const mergedOptions: MoneyComputeOptions = {
+    ...DEFAULT_MONEY_OPTIONS,
+    ...options
+  };
+
+  // 格式化
+  if (mergedOptions.formatter) {
+    // 使用自定义格式化函数
+    return mergedOptions.formatter(numericResult);
+  }
+
+  // 货币格式化
+  if (mergedOptions.formatAsCurrency) {
+    const formattedNumber = numericResult.toFixed(mergedOptions.precision);
+    // 如果数字超过1000，使用千分位格式化
+    const formattedWithThousands = numericResult >= 1000 ? toThousands(formattedNumber) : formattedNumber;
+    return `${mergedOptions.currencySymbol}${formattedWithThousands}`;
+  }
+
+  // 默认格式化
+  return numericResult.toFixed(mergedOptions.precision);
+}
+/**
+ * 执行货币计算
+ #### 使用说明
+ ```
+ 分转元（除法）
+ computeMoney(1234) 返回 12.34
+ 元转分（乘法）
+ computeMoney(12.34, { operation: 'multiply', factor: 100 }) 返回 1234
+ 自定义精度
+ computeMoney(1234.567, { precision: 3 }) 返回 12.346
+ 处理带有千分位的字符串
+ computeMoney('1,234.56', { operation: 'multiply', factor: 1 }) 返回 1234.56
+ 处理空值
+ computeMoney(null) 返回 0
+ ```
+ * @param value 要计算的值
+ * @param options 计算选项
+ * @returns 计算结果
+ */
+export function computeMoney(value: number | string | null | undefined, options?: Partial<MoneyComputeOptions>): number {
+  // 合并选项
+  const mergedOptions: MoneyComputeOptions = {
+    ...DEFAULT_MONEY_OPTIONS,
+    ...options
+  };
+
+  // 处理输入值
+  let numericValue: number;
+
+  // 处理可能的各种输入类型
+  if (value === null || value === undefined || value === '') {
+    return 0;
+  } else if (typeof value === 'string') {
+    // 尝试将字符串转换为数字，移除非数字字符（保留小数点和负号）
+    const cleanedStr = value.replace(/[^\d.-]/g, '');
+    numericValue = cleanedStr ? parseFloat(cleanedStr) : 0;
+  } else {
+    numericValue = value;
+  }
+
+  if (isNaN(numericValue)) {
+    return 0;
+  }
+
+  // 执行计算
+  let result: number;
+  if (mergedOptions.operation === 'multiply') {
+    result = numericValue * mergedOptions.factor;
+  } else {
+    // 防止除以0
+    result = mergedOptions.factor !== 0 ? numericValue / mergedOptions.factor : 0;
+  }
+
+  // 处理精度
+  if (mergedOptions.precision !== undefined) {
+    const multiplier = Math.pow(10, mergedOptions.precision);
+    result = Math.round(result * multiplier) / multiplier;
+  }
+
+  return result;
+}
+
+/**
+ * 将分转换为元并格式化为货币格式
+ #### 使用说明
+ ```
+ formatCentsToYuan(1234) 返回 '¥12.34'
+ formatCentsToYuan(123456) 返回 '¥1,234.56'
+ formatCentsToYuan(1234, { currencySymbol: '$' }) 返回 '$12.34'
+ formatCentsToYuan('1,234', { precision: 3 }) 返回 '¥12.340'
+ formatCentsToYuan(null) 返回 '¥0.00'
+ ```
+ * @param cents 分值
+ * @param options 格式化选项
+ * @returns 格式化后的字符串
+ */
+export function formatCentsToYuan(cents: number | string | null | undefined, options?: Partial<Omit<MoneyComputeOptions, 'operation'>>) {
+  return formatMoney(cents, {
+    operation: 'divide',
+    factor: 100,
+    formatAsCurrency: true,
+    ...options
+  });
+}

package/src/object/index.ts

@@ -0,0 +1,54 @@
+/**
+ * object处理相关
+ * @packageDocumentation
+ * @module Object
+ * @preferred
+ */
+
+/**
+ * 比较两者的值是否相等
+ #### 使用说明
+ ```
+ deepEqual({a: 10}, {a: 10}) 返回 true
+ deepEqual({a: 10}, {a: 10, b: 20}) 返回 false
+ ```
+ * @param {*} x 用来比较的值
+ * @param {*} y 另一个用来比较的值
+ */
+export function deepEqual(x, y) {
+  const ok = Object.keys,
+    tx = typeof x,
+    ty = typeof y;
+  return x && y && tx === 'object' && tx === ty
+    ? ok(x).length === ok(y).length && ok(x).every(key => deepEqual(x[key], y[key]))
+    : x === y;
+}
+function getNodePath(node, nodeValue, nodeKey, childrenKey, path: any[] = []) {
+  path.push(node);
+  if (node[nodeKey] === nodeValue) {
+    throw 'GOT IT!';
+  }
+  if (node[childrenKey] && node[childrenKey].length > 0) {
+    for (let i = 0; i < node[childrenKey].length; i++) {
+      getNodePath(node[childrenKey][i], nodeValue, nodeKey, childrenKey, path);
+    }
+  }
+  path.pop();
+}
+/**
+ * 查找树结构节点路径
+ * @param {*} nodeValue 节点值
+ * @param {string} nodeKey 节点键
+ * @param {Array} treeArray 树数据
+ * @param {string} children 子集键
+ */
+export function findNodePath(nodeValue, nodeKey, treeArray, childrenKey) {
+  const path: any[] = [];
+  try {
+    for (let i = 0; i < treeArray.length; i++) {
+      getNodePath(treeArray[i], nodeValue, nodeKey, childrenKey, path);
+    }
+  } catch (e) {
+    return path;
+  }
+}

package/src/print/index.ts

@@ -0,0 +1,102 @@
+/**
+ * print处理相关
+ * @packageDocumentation
+ * @module Print
+ * @preferred
+ */
+
+// https://juejin.im/post/5de4f87cf265da05c7722c20
+/**
+ * 获取、设置打印样式
+ * @returns
+ */
+function getStyle() {
+  const styleContent = `#print-container {
+      display: none;
+    }
+    @media print {
+      body > :not(.print-container) {
+        display: none;
+      }
+      html,
+      body {
+        display: block !important;
+      }
+      #print-container {
+        display: block;
+      }
+  }`;
+  const style = document.createElement('style');
+  style.innerHTML = styleContent;
+  return style;
+}
+
+/**
+ * 清空打印内容
+ */
+function cleanPrint() {
+  const div = document.getElementById('print-container');
+  if (div) {
+    document.querySelector('body')!.removeChild(div);
+  }
+}
+
+/**
+ * 新建DOM，将需要打印的内容填充到DOM
+ *
+ * @param {*} html
+ * @returns
+ */
+function getContainer(html) {
+  cleanPrint();
+  const container = document.createElement('div');
+  container.setAttribute('id', 'print-container');
+  container.innerHTML = html;
+  return container;
+}
+
+/**
+ * 图片完全加载后再调用打印方法
+ * @param {*} dom
+ * @returns
+ */
+function getLoadPromise(dom) {
+  let imgs = dom.querySelectorAll('img');
+  imgs = [].slice.call(imgs);
+
+  if (imgs.length === 0) {
+    return Promise.resolve();
+  }
+
+  let finishedCount = 0;
+  return new Promise((resolve) => {
+    function check() {
+      finishedCount += 1;
+      if (finishedCount === imgs.length) {
+        resolve();
+      }
+    }
+    imgs.forEach((img) => {
+      img.addEventListener('load', check);
+      img.addEventListener('error', check);
+    });
+  });
+}
+
+/**
+ * 打印指定 HTML
+ * @param {*} html
+ */
+export default function printHtml(html) {
+  const style = getStyle();
+  const container = getContainer(html);
+
+  document.body.appendChild(style);
+  document.body.appendChild(container);
+
+  getLoadPromise(container).then(() => {
+    window.print();
+    document.body.removeChild(style);
+    document.body.removeChild(container);
+  });
+}

package/src/string/index.ts

@@ -0,0 +1,189 @@
+/**
+ * string处理相关
+ * @packageDocumentation
+ * @module String
+ * @preferred
+ */
+import { isEmpty } from '../common';
+
+/**
+ * 空值处理
+ */
+export function formatEmptyValue(value: any, defaultValue = '-') {
+  if (isEmpty(value)) {
+    return defaultValue;
+  }
+  return value;
+}
+
+/**
+ * 格式化手机
+ #### 使用说明
+ * ```
+ * formatPhone('18211572781') => '182 1157 2781'
+ * formatPhone('18211572781', '-') => '182-1157-2781'
+ * ```
+ * @param {string | number} phone 手机号
+ * @param {string} [separator=' '] 连接符
+ */
+export function formatPhone(phone: string | number, separator = ' ', defaultValue = '-') {
+  if (isEmpty(phone)) {
+    return defaultValue;
+  }
+  if (phone.toString().length !== 11) {
+    return phone;
+  }
+  const val = phone.toString().replace(/[^\d]/g, '');
+  const arr = val.split('');
+  let str = '';
+  arr.forEach((v, index) => {
+    if (index === 3 || index === 7) {
+      str += separator;
+    }
+    str += v;
+  });
+  return str;
+}
+
+/**
+ * 隐藏手机号
+ #### 使用说明
+ * ```
+ * formatPhoneHide('18211572781') => '182****2781'
+ * formatPhoneHide('', '-') => '-'
+ * ```
+ * @param {string | number} phone 手机号
+ * @param {string} defaultValue 没有值放回的默认值
+ */
+export function formatPhoneHide(phone: string | number, defaultValue = '') {
+  if (isEmpty(phone)) {
+    return defaultValue;
+  }
+  if (phone.toString().length !== 11) {
+    return phone;
+  }
+  const phoneNumber = phone.toString();
+  return `${phoneNumber.substr(0, 3)}****${phoneNumber.substr(7, 11)}`;
+}
+
+/**
+ * 格式化银行卡 (4位一空格)
+ #### 使用说明
+ * ```
+ * formatBank('6282356862823568123') => '6282 3568 6282 3568 123'
+ * formatBank('', '-') => '-'
+ * ```
+ * @param {strubg | number} val 银行卡号
+ * @param {string} defaultValue 没有值放回的默认值
+ */
+export function formatBank(val: string | number, defaultValue = '') {
+  if (isEmpty(val)) {
+    return defaultValue;
+  }
+  return val.toString().replace(/\s/g, '').replace(/(.{4})/g, '$1 ');
+}
+
+/**
+ * 生成26个字母列表
+ #### 使用说明
+ * ```
+ *  generateEnglishLetters() => ['A', ..., 'Z'];
+ * ```
+ */
+export function generateEnglishLetters() {
+  const englishLettersList: string[] = [];
+  for (let i = 65; i < 91; i += 1) {
+    englishLettersList.push(String.fromCharCode(i));
+  }
+  return englishLettersList;
+}
+
+/**
+ * 驼峰式命名转短横线命名
+ *
+ * @export
+ * @param {*} [string='']
+ * @returns
+ */
+export function humpTurnDashed(string = '') {
+  const rE = /\B([A-Z])/g;
+  return string.replace(rE, '-$1').toLowerCase();
+}
+
+/**
+ * 获取指定分隔符之前的子字符串
+ * @param str - 源字符串
+ * @param delimiter - 分隔符
+ * @returns 分隔符之前的字符串
+ */
+export function subBefore(str: string, delimiter: string): string {
+  if (!str || typeof delimiter !== 'string') return '';
+  return str.substring(0, str.indexOf(delimiter));
+}
+
+/**
+ * 解析 URL 查询参数为对象
+ * @param url - URL 字符串
+ * @returns 查询参数对象
+ */
+export function getQueryMap(url: string): Record<string, string> {
+  const pattern = /^(?:(https?|ftp|rtsp|mms|ws|wss):\/\/)?/i;
+  if (!pattern.test(url)) {
+    console.error(`${url}不符合超链接规范`);
+    return {};
+  }
+
+  const queryIndex = url.indexOf('?');
+  if (queryIndex === -1) return {};
+
+  const queryString = url.slice(queryIndex + 1);
+  const params = queryString.split('&');
+  const result: Record<string, string> = {};
+
+  for (const param of params) {
+    const [key, value] = param.split('=');
+    if (key) {
+      result[key] = value || '';
+    }
+  }
+
+  return result;
+}
+
+/**
+ * 隐藏字符串中指定位置的字符
+ * @param text - 源字符串或数字
+ * @param indexes - 要隐藏的位置索引数组或位置对象数组
+ * @param mask - 掩码字符，默认为 '*'
+ * @returns 处理后的字符串
+ */
+export function hideTextAtIndex(
+  text: string | number,
+  indexes: number | { start: number; end: number } | (number | { start: number; end: number })[],
+  mask: string = '*'
+): string {
+  if (typeof text === 'number') {
+    text = text.toString();
+  }
+
+  if (!Array.isArray(indexes)) {
+    indexes = [indexes];
+  }
+
+  const chars = text.split('');
+
+  for (const index of indexes) {
+    if (typeof index === 'object' && !Array.isArray(index)) {
+      const { start, end } = index;
+      if (start >= 0 && start < end && end < chars.length) {
+        chars.fill(mask, start, end + 1);
+      }
+    } else if (typeof index === 'number' && Number.isInteger(index) && index >= 0) {
+      if (index < chars.length) {
+        chars[index] = mask;
+      }
+    }
+  }
+
+  return chars.join('');
+}