指定范围随机正整数

• min >= 0 && max > 0 && max >= min

/**
 * 指定范围随机取数
 * min ≤ return ≤ max
 * */
function random(min, max) {
	if (min >= 0 && max > 0 && max >= min) {
		let gab = max - min + 1;
		return Math.floor(Math.random() * gab + min);
	} else {
		return 0;
	}
}

保留几位小数(补0)

/* 
 * 保留几位小数，不足补0
 * @param numberVal 数字
 * @param option 可选参数
 * option.prec 保留几位小数(默认2位)
 * option.rule 默认round; 可选 ceil 、 floor 、 round 、 string
 * option.ins0 默认true; 是否补0
 */
// export const numDecimal = (numberVal, option = {}) => {
function numDecimal (numberVal, option = {}) {
  let _option = {prec: 2, rule: "round", ins0: true}
  Object.assign(_option, option)
  let {prec, rule, ins0} = _option

  // Math.ceil()执行向上舍入，即它总是将数值向上舍入为最接近的整数；
  // Math.floor()执行向下舍入，即(不四舍五入)它总是将数值向下舍入为最接近的整数；
  // Math.round()执行标准舍入，即它总是将数值四舍五入为最接近的整数(这也是我们在数学课上学到的舍入规则)
  // string 当字符串处理，直接舍弃
  
  let k = Math.pow(10, prec);	// 10的prec次方

  let resVal = numberVal;
  if(rule == "ceil"){
    resVal = Math.ceil(numberVal * k) / k;
  }else if (rule == "floor"){
    resVal = Math.floor(numberVal * k) / k;
  }else if (rule == "string"){
    // 不做任何数学上的处理
    resVal = resVal.toString();
  }else{
    resVal = Math.round(numberVal * k) / k;
  }

  if(ins0 === false) return resVal;

  // 补0
  resVal = resVal.toString(); // 转字符串, 准备补0

  let resValStrArray = resVal.toString().split(".");

  if(resValStrArray.length == 1){
    resVal = resVal + ".";
    for (let index = 0; index < prec; index++) {
      resVal = resVal + "0";
    }
  }

  if(resValStrArray.length > 1){
    // 存在小数，按需补0

    // prec=0 不需要保留小数，返回整数
    if(prec === 0){ return parseInt(resValStrArray[0]); }

    // resValStrArray[1].length >= prec 小数位已经超过想要保留的小数位
    if(resValStrArray[1].length >= prec){
      // console.log("够小数位")
      let keep_dVal = resValStrArray[1].slice(0, prec)
      return resValStrArray[0] + "." + keep_dVal;
    }

    // 补0
    for (let index = resValStrArray[1].length; index < prec; index++) {
      resVal = resVal + "0";
    }

  }

  return resVal;
}

// eg:
numDecimal(7899.234)  // '7899.23'
numDecimal(7899.234, {rule: "ceil"})  // '7899.24'

numDecimal(7899.9, {prec: 3, rule: "ceil"}) // '7899.900'
numDecimal(7899.9, {prec: 3, rule: "ceil", ins0: false}) // 7899.9

格式化金额

/**
 * @description 格式化金额
 * @param number：要格式化的数字
 * @param decimals：保留几位小数 默认2位
 * @param decPoint：小数点符号 默认.
 * @param thousandsSep：千分位符号 默认为,
 */
function filter_formatMoney(number, decimals = 2, decPoint = '.', thousandsSep = ',') {
  number = (number + '').replace(/[^0-9+-Ee.]/g, '')
  let n = !isFinite(+number) ? 0 : +number;	// 金额转数字
  let prec = !isFinite(+decimals) ? 0 : Math.abs(decimals);	// 保留几位小数，参数转数字，确保参数是个数字
  let sep = (typeof thousandsSep === 'undefined') ? ',' : thousandsSep; // 千分位符号
  let dec = (typeof decPoint === 'undefined') ? '.' : decPoint	// 小数点符号
  let s = '';
  
  /* 
  * 保留几位小数
  * @n 数字
  * @prec 保留几位小数
  */
  let toFixedFix = function (n, prec) {
    let k = Math.pow(10, prec);	// 10的prec次方
    // return Math.ceil(n * k) / k
    return '' + Math.floor(n * k) / k
  }
  
  s = (prec ? toFixedFix(n, prec) : '' + Math.round(n)).split('.')
  // s = (prec ? numDecimal(n, prec) : '' + Math.round(n)).toString().split('.')
  
  let re = /(-?\d+)(\d{3})/
  while (re.test(s[0])) {
    s[0] = s[0].replace(re, '$1' + sep + '$2')
  }
  if ((s[1] || '').length < prec) {
    s[1] = s[1] || ''
    s[1] += new Array(prec - s[1].length + 1).join('0')
  }
  return s.join(dec);
}

// eg:
let price = filter_formatMoney(699993.45) // '699,993.45'
parseFloat( price.toString().replace(/,/g, "") )  // 699993.45