function toNonExponential(input: number | string | bigint): string {
  if (typeof input === 'bigint') {
    return input.toString();
  }

  let dataStr = typeof input === 'string' ? input : input.toString();

  if (isNaN(Number(dataStr))) {
    throw new Error('Input must be a number, a bigint or a string that can be converted to a number');
  }

  if (dataStr.indexOf('e') !== -1) {
    const [numberPart, exponentPart] = dataStr.split('e');
    let [base, decimal = ''] = numberPart.split('.');
    let exponent = Number(exponentPart);
    if (exponent >= 0) {
      return base + decimal.padEnd(exponent + 1, '0');
    } else {
      const decimalPointPos = base.length + exponent;
      if (decimalPointPos <= 0) {
        return '0.' + base.padStart(-exponent, '0') + decimal;
      } else {
        return base.slice(0, decimalPointPos) + '.' + base.slice(decimalPointPos) + decimal;
      }
    }
  } else {
    return dataStr;
  }
}

/**
 * 十进制数字转为任意进制数字字符串
 * @param {String} number 要转为字符串
 * @param {String|Number} radix 可选，取值范围为 2~36，要转成数字字符串的进制，默认为10
 * @return {String}
 */
function NumberToString(number, radix = 10) {
  return number.toString(radix)
}

/**
 * 任意进制转换
 * @param {String} number 要转换的数字字符串
 * @param {String|Number} fromAadix 可选，取值范围为 2~36，当前数字字符串的进制，默认为10
 * @param {String|Number} toRadix 可选，取值范围为 2~36，要转成数字字符串的进制，默认为10
 * @return {String}
 */
 function conversionNumberSystems(number, fromAadix = 10, toRadix = 10) {
  let tenNumber = parseInt(number, fromAadix) // 先转成十进制
  return tenNumber.toString(toRadix) // 转为目标进制
}

/**
 * 字符串转为十进制数字
 * @param {String} numStr 要转为十进制数字的字符串
 * @param {String|Number} radix 可选，取值范围为 2~36，numStr 当前的进制，默认为10
 * @return {Number}
 */
function StringToNumber(numStr, radix = 10) {
  return parseInt(numStr, radix)
}

function toFixed(value: number | string, decimals = 0): string {
  if (isNaN(Number(value))) return 0
  let result = Number(`${Math.round(Number(`${value}e${decimals}`))}e-${decimals}`);
  return result.toFixed(decimals);
};

toFixed(1.555, 2);

function toCut(value: number | string, decimals = 0): string {
  if (isNaN(Number(value))) return 0
  let result = Number(`${Math.floor(Number(`${value}e${decimals}`))}e-${decimals}`);
  return result.toFixed(decimals);
};

toCut(0.245, 2) // 0.24
toCut(-0.245, 2) // -0.25

const replenishZero = (num, len, zero = 0) => num.toString().padStart(len, zero)
replenishZero(8, 2) // 08

/**
 * 数字转为 万 亿 的缩略写法
 * @param {Number | String} num 等待转格式的数字
 * @param {Number} fixed 保留位数(四舍五入形式)
 */
export function setNumChinese(num, fixed = false) {
  if (!num && num !== 0 && num !== '') return num
  if (typeof(num) !== 'number' && typeof(num) !== 'string') return num
  let _num = num - 0
  let result = '', unit = ''
  // K M B的格式
  if (_num <= 9999) result = _num
  else if (_num <= 99999999) {
    result = _num / 10000
    unit = '万'
  } else {
    result = _num / 100000000
    unit = '亿'
  }
  let _result
  if (fixed !== false) _result = result.toFixed(fixed) + unit
  else _result = result + unit
  return _result
}

/**
 * 数字转为 123,234,234,000的格式
 * @param {Number | String} num 等待转格式的参数
 * 这里本来是使用 toLocaleString 方法，但部分安卓手机不支持
 */
export function setNumFormat(numString) {
  if (!numString && numString !== 0 && numString !== '') return numString
  if (typeof(numString) !== 'number' && typeof(numString) !== 'string') return numString
  numString = numString + ''
  var regForm = /(\d{1,3})(?=(\d{3})+(?:$|\.))/g; // 正则
  var int = numString.replace(regForm,"$1,").split('.')[0] // 整数部分
  var decimals = numString.split('.')[1] // 小数部分
  if (decimals) int = int + '.' + decimals
  return int
}

/**
 * 数字转为 K M B 的缩略写法
 * @param {Number | String} num 等待转格式的数字
 * @param {Number} fixed 保留位数(四舍五入形式)
 */
export function setNumKMB(num, fixed = null) {
  if (!num && num !== 0 && num !== '') return num
  if (typeof(num) !== 'number' && typeof(num) !== 'string') return num
  let _num = num - 0
  let result = '', unit = ''
  // K M B的格式
  if (_num <= 999) result = _num
  else if (_num <= 999999) {
    result = _num / 1000
    unit = 'K'
  } else if (_num <= 999999999) {
    result = _num / 1000000
    unit = 'M'
  } else if (_num <= 999999999999) {
    result = _num / 1000000000
    unit = 'B'
  } else {
    result = _num / 1000000000000
    unit = 'T'
  }
  let _result
  if (fixed !== null) _result = result.toFixed(fixed) + unit
  else _result = result + unit
  return _result
}