基于JavaScript编写一个简易的数字转中文功能

//数字转中文(要支持小数，可以在扩展，小数就比较简单了)
//入参为数字，因此不考虑开头为零的情
const convertChineseNumber = (number) => {
  if (isNaN(number)) return "NAN";

  const units = ["", "万", "亿", "兆", "京", "垓"];
  const baseUnits = ["", "十", "百", "千"];
  const cNumbers = ["零", "一", "二", "三", "四", "五", "六", "七", "八", "九"];
  
  //分割四位一组，反转数组，从后往前加单位
  const numGroup = String(number)
    .replace(/\B(?=(\d{4})+$)/g, " ")  //使用前瞻运算符来处理四位一体
    .split(" ")
    .reverse();
  let result = "";
  //遍历从后往前加单位
  numGroup.forEach((numStrings, idx) => {
    //处理全零的情况，不应该带单位，由于需要间隔0的情况，保留一个零
    if (numStrings === "0000") {
      result = '零' + result
      return;
    }
    //有数的先添加大单位
    result = units[idx] + result;
    //分割四位一组的小数字，仍然是反转，从后往前加单位
    numStrings
      .split("")
      .reverse()
      .forEach((item, idx) => {
        //处理每个后面的单位，其中个位没有单位，0也没有单位
        if (idx !== 0 && item !== "0") {
          result = baseUnits[idx] + result;
        }
        //数字翻译
        result = cNumbers[Number(item)] + result;
      });
  });
  //处理结果中可能存在的中文读写问题，例如不会存在连续的零，开头不会一十
  //零后面不应该有单位，非零整数结尾不会读零
  return result
    .replace(/零+/g, "零")
    .replace(/^(一十)/, "十")
    .replace(new RegExp(`零([${units.join("")}]{1})`, "g"), "$1") //小单位处理了大单位也要处理
    .replace(/(.+)零$/, "$1")
};

//我们试验几个案例
const numbers = [
  convertChineseNumber(0),
  convertChineseNumber(1234567899),
  convertChineseNumber(101234567899),
  convertChineseNumber(100234567899),
  convertChineseNumber(101034567899),
  convertChineseNumber(101030067899),
  convertChineseNumber(101030067890),
  convertChineseNumber(101030007899),
  convertChineseNumber(100000007899),
  convertChineseNumber(100070007899),
  convertChineseNumber(100007007899),
];
console.log(numbers);

//目前来看返回结果是对的，如果感觉哪里不对，可以在填填补补就行了
[
  '零',
  '十二亿三千四百五十六万七千八百九十九',
  '一千零一十二亿三千四百五十六万七千八百九十九',
  '一千零二亿三千四百五十六万七千八百九十九',
  '一千零一十亿三千四百五十六万七千八百九十九',
  '一千零一十亿三千零六万七千八百九十九',
  '一千零一十亿三千零六万七千八百九十',
  '一千零一十亿三千万七千八百九十九',
  '一千亿零七千八百九十九',
  '一千亿七千万七千八百九十九',
  '一千亿零七百万七千八百九十九'
]

/**
 * @description 数字转中文数码
 *
 * @param {Number|String}   num     数字[正整数]
 * @param {String}          type    文本类型，lower|upper，默认upper
 *
 * @example number2text(100000000) => "壹亿元整"
 */
export const number2text = (number, type = "upper") => {
    // 配置
    const confs = {
        lower: {
            num: ["零", "一", "二", "三", "四", "五", "六", "七", "八", "九"],
            unit: ["", "十", "百", "千", "万"],
            level: ["", "万", "亿"]
        },
        upper: {
            num: ["零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖"],
            unit: ["", "拾", "佰", "仟"],
            level: ["", "万", "亿"]
        },
        decimal: {
            unit: ["分", "角"]
        },
        maxNumber: 999999999999.99
    };

    // 过滤不合法参数
    if (Number(number) > confs.maxNumber) {
        console.error(
            `The maxNumber is ${confs.maxNumber}. ${number} is bigger than it!`
        );
        return false;
    }

    const conf = confs[type];
    const numbers = String(Number(number).toFixed(2)).split(".");
    const integer = numbers[0].split("");
    const decimal = Number(numbers[1]) === 0 ? [] : numbers[1].split("");

    // 四位分级
    const levels = integer.reverse().reduce((pre, item, idx) => {
        let level = pre[0] && pre[0].length < 4 ? pre[0] : [];
        let value =
            item === "0" ? conf.num[item] : conf.num[item] + conf.unit[idx % 4];
        level.unshift(value);

        if (level.length === 1) {
            pre.unshift(level);
        } else {
            pre[0] = level;
        }

        return pre;
    }, []);

    // 整数部分
    const _integer = levels.reduce((pre, item, idx) => {
        let _level = conf.level[levels.length - idx - 1];
        let _item = item.join("").replace(/(零)\1+/g, "$1"); // 连续多个零字的部分设置为单个零字

        // 如果这一级只有一个零字，则去掉这级
        if (_item === "零") {
            _item = "";
            _level = "";

            // 否则如果末尾为零字，则去掉这个零字
        } else if (_item[_item.length - 1] === "零") {
            _item = _item.slice(0, _item.length - 1);
        }

        return pre + _item + _level;
    }, "");

    // 小数部分
    let _decimal = decimal
        .map((item, idx) => {
            const unit = confs.decimal.unit;
            const _unit = item !== "0" ? unit[unit.length - idx - 1] : "";

            return `${conf.num[item]}${_unit}`;
        })
        .join("");

    // 如果是整数，则补个整字
    return `${_integer}元` + (_decimal || "整");
};

const chineseNumbers = ['零', '一', '二', '三', '四', '五', '六', '七', '八', '九'];
const units = ['', '十', '百', '千', '万', '十万', '百万', '千万', '亿', '十亿', '百亿', '千亿', '万亿'];

let zeroFlag = false;  // 是否在零的位置

while (num > 0) {
    let part = num % 10;
    if (part === 0) {
        if (!zeroFlag) {
            str = chineseNumbers[0] + str;  // 添加“零”
            zeroFlag = true;
        }
    } else {
        str = chineseNumbers[part] + units[unitPos] + str;
        zeroFlag = false;
    }

    num = Math.floor(num / 10);  // 去除个位数字
    unitPos++;  // 移动到下一个单位
}

if (str.startsWith('一十')) {
    str = str.substring(1);
}

str = str.replace(/零$/, '');//去掉末尾的零
return str;

function handelr(str) {
    let lastW = str.lastIndexOf('万');// 获取字符串中最后一个“万”字符的位置
    let len = str.length;
    let temp='', temp2='', flagw='';//用于暂存处理后的字符串和于标记是否遇到“万亿”
    // 判断字符串中包含"万亿"改变标记状态
    if (str.indexOf('万亿') > 0) {
        flagw = true;
    }
    //遍历字符串去除多余‘万'字
    for (let i = 0; i < len; i++) {
        if (i == lastW) {
            temp = temp.concat(str[i]);
        }
        //判断是否保留第一个'万'字
        if (str[i] == '万') {
            if (!flagw) {
                continue;
            }
            flagw = false;
        }
        temp = temp.concat(str[i]);
    }
    //处理多余的'亿'字
    let len2 = temp.length;
    let lasty = temp.lastIndexOf('亿');
    for (let j = 0; j < len2; j++) {
        if (j == lasty) {
            temp2 = temp2.concat(temp[j]);
        }
        if (temp[j] == '亿') {
            continue;
        }
        temp2 = temp2.concat(temp[j]);
    }
    return temp2;// 返回最终的处理结果
}