阿拉伯数字转换中文表示

博主想说

如果想要思路可以在评论说出来，我可以画图出来解释。只需要效果可以直接复制代码去用。因为实习有点忙，我又有点懒。

理论

按照图来看，千后面的单位基本都可以读作，万/十万/百万/千万 亿/十亿/百亿/千亿 兆/十兆/百兆/千兆 …

代码

下面代码还有存在一些bug的，在correct 中 的 externalStr = externalStr.replace(/(零[十百千万亿兆]){1,}/g, '零')这行代码，应该依照 other数组去生成表达式，懒得写了…

/**
 * 内部单位：比如111111，读作十一万一千一百一十一，那么十一万的内部还有十这个单位，这叫做内部单位
 * 外部单位：比如111111，读作十一万一千一百一十一，忽略掉内部的单位，那么只有个十百千万这四个单位，叫外部单位
 * 
 * 带有recursion开头的函数是处理内部单位的，不带的是处理外部单位的
 */

const theUnit = ['零', '一', '二', '三', '四', '五', '六', '七', '八', '九']
const other = ['个', '十', '百', '千', '万', '亿', '兆']
const separator = '#' ,recursionSeparatot = '&'
let str = ''

function headquarters ( number ) {
  let string = ''
  if (number !== '' && number !== null && !isNaN(number)) {
    let unitIndex = 0
    while (number !== 0) {
      const obj = splitNumber(number, unitIndex)
      string += analyse(obj['addUp'], unitIndex)
      number = obj['number']
      unitIndex += 1
    }
  }
  return string
}

// 最后矫正读法
function correct (str) {
  // 先拿出外部
  const external = str.split(separator)
  let externalStr = ''
  for (let i = external.length - 1; i > -1; i --) {
    const recursion = external[i].split(recursionSeparatot)
    let interiorStr = ''
    for (let j = recursion.length - 2; j > -1; j --) {
      interiorStr += recursion[j]
    }
    interiorStr += recursion[recursion.length - 1]
    externalStr += interiorStr
  }
  externalStr = externalStr.replace(/(零[十百千万亿兆]){1,}/g, '零')
  externalStr = externalStr.replace(/(^一十|一十$)/g, '十')
  return externalStr
}

const unitNumber = [1, 1, 1, 1, 4]
function analyse ( number, unitIndex ) {
  if (unitIndex < 4 && unitIndex > 0) {
    return theUnit[number] + other[unitIndex] + separator
  } else if (unitIndex === 0) {
    return theUnit[number] + separator
  } else {
    return recursionHeadquarters (number) + other[unitIndex] + separator
  }
}

function splitNumber ( number, unit ) {
  const cicr = unitNumber[unit > 3 ? 4 : unit]
  let addUp = 0
  for (let i = 0; i < cicr; i ++) {
    addUp += (i === 0 ? number % 10 : (number % 10) * Math.pow(10, i))
    number = Math.floor(number / 10)
  }
  return {
    number: number,
    addUp: addUp
  }
}


// 内部单位：比如111111，读作十一万一千一百一十一，那么十一万的内部还有十这个单位，这叫做内部单位
// 外部单位：比如111111，读作十一万一千一百一十一，忽略掉内部的单位，那么只有个十百千万这四个单位，叫外部单位
/**
 * recursionHeadquarters 和 headquarters内部逻辑大体上差不多
 * 但是职责上是不一样的，recursionHeadquarters负责内部单位的转换，headquarters负责外部的单位转换。
 * 区分开来的原因是为了职责单一，后面方便加上各种逻辑
 * @param {*} number 
 * @returns 
 */
function recursionHeadquarters ( number ) {
  let string = ''
  if (number !== '' && number !== null && !isNaN(number)) {
    let unitIndex = 0
    while (number !== 0) {
      const obj = splitNumber(number, unitIndex)
      string += recursionAnalyse(obj['addUp'], unitIndex)
      number = obj['number']
      unitIndex += 1
    }
  }
  return string
}

// 这里的recursionAnalyse和analyse的逻辑差不多，但是职责是不一样的。
function recursionAnalyse ( number, unitIndex ) {
  if (unitIndex < 4 && unitIndex > 0) {
    return theUnit[number] + other[unitIndex] + recursionSeparatot
  } else if (unitIndex === 0) {
    return theUnit[number] + recursionSeparatot
  } else {
    return headquarters (number) + other[unitIndex] 
  }
}

function main (number) {
  return correct(headquarters(number))
}

示例

console.log(main(23232829038001))
- 返回 二十三兆二千三百二十八亿二千九百零三万八千零一