JS将阿拉伯数字转为中文书写

1. 不重复造轮子

这个问题并不小众，在网上搜索就能找到很多现成的解决方案，比如 js将数字转换成中文字符的实例代码如下：

var _change = {
    ary0:["零", "一", "二", "三", "四", "五", "六", "七", "八", "九"],
    ary1:["", "十", "百", "千"],
    ary2:["", "万", "亿", "兆"],
    init:function (name) {
        this.name = name;
    },
    strrev:function () {
        var ary = []
        for (var i = this.name.length; i >= 0; i--) {
            ary.push(this.name[i])
        }
        return ary.join("");
    }, //倒转字符串。
    pri_ary:function () {
        var $this = this
        var ary = this.strrev();
        var zero = ""
        var newary = ""
        var i4 = -1
        for (var i = 0; i < ary.length; i++) {
            if (i % 4 == 0) { //首先判断万级单位，每隔四个字符就让万级单位数组索引号递增
                i4++;
                newary = this.ary2[i4] + newary; //将万级单位存入该字符的读法中去，它肯定是放在当前字符读法的末尾，所以首先将它叠加入$r中，
                zero = ""; //在万级单位位置的“0”肯定是不用的读的，所以设置零的读法为空

            }
//关于0的处理与判断。
            if (ary[i] == '0') { //如果读出的字符是“0”，执行如下判断这个“0”是否读作“零”
                switch (i % 4) {
                    case 0:
                        break;
//如果位置索引能被4整除，表示它所处位置是万级单位位置，这个位置的0的读法在前面就已经设置好了，所以这里直接跳过
                    case 1:
                    case 2:
                    case 3:
                        if (ary[i - 1] != '0') {
                            zero = "零"
                        }
                        ; //如果不被4整除，那么都执行这段判断代码：如果它的下一位数字（针对当前字符串来说是上一个字符，因为之前执行了反转）也是0，那么跳过，否则读作“零”
                        break;

                }

                newary = zero + newary;
                zero = '';
            }
            else { //如果不是“0”
                newary = this.ary0[parseInt(ary[i])] + this.ary1[i % 4] + newary; //就将该当字符转换成数值型,并作为数组ary0的索引号,以得到与之对应的中文读法，其后再跟上它的的一级单位（空、十、百还是千）最后再加上前面已存入的读法内容。
            }

        }
        if (newary.indexOf("零") == 0) {
            newary = newary.substr(1)
        }//处理前面的0
        return newary;
    }
}

//创建class类
function change() {
    this.init.apply(this, arguments);
}
change.prototype = _change

//创建实例
var k = new change("00102040");
alert(k.pri_ary());

试了一下，效果不错：

2. 知其然，知其所以然

可是读了一遍，发现 —— 似乎有点问题，于是我将var k = new change("00102040")中的00102040换了一下，结果就凌乱了：

上图是转换001002040的结果，出现了亿零，主要问题在处理多余的零这部分，还应该处理多余的单位：

if (newary.indexOf("零") == 0) {
    newary = newary.substr(1)
}//处理前面的0

3. 修改和思考

最后我修改了代码，如下：

var _change = {
    // 数字与中文映射
    ary0:["零", "一", "二", "三", "四", "五", "六", "七", "八", "九"],
    // 每四位以内的单位
    ary1:["", "十", "百", "千"],
    // 四位以上的单位
    ary2:["", "万", "亿", "兆"],
    init:function (name) {
        this.name = name;
    },
    strrev:function () {
        var ary = [];
        for (var i = this.name.length; i >= 0; i--) {
            ary.push(this.name[i]);
        }
        return ary.join("");
    }, //倒转字符串。
    isUnit: function(ary) {
        var retVal = false;
        var cur = ary[0];
        if(this.ary2.indexOf(cur) > 0) {
            retVal = true;
        }
        return retVal;
    },// 检查是否时ary2中的单位
    pri_ary:function () {
        var $this = this;
        // 反转后再逐位处理
        var ary = this.strrev();
        // 是否读零
        var zero = "";
        // 缓存结果
        var newary = "";
        // 万级单位数组索引
        var i4 = -1;
        for (var i = 0; i < ary.length; i++) {
            // 首先判断万级单位，每隔四个字符就让万级单位数组索引号递增
            if (i % 4 == 0) {
                i4++;
                // 将万级单位存入该字符的读法中去，它肯定是放在当前字符读法的末尾，所以首先将它叠加入$r中，
                newary = this.ary2[i4] + newary;
                // 在万级单位位置的“0”肯定是不用的读的，所以设置零的读法为空
                zero = "";
            }
            //关于0的处理与判断。
            //如果读出的字符是“0”，执行如下判断这个“0”是否读作“零”
            if (ary[i] == '0') {
                switch (i % 4) {
                    case 0:
                        break;
                    // 如果位置索引能被4整除，表示它所处位置是万级单位位置，
                    // 这个位置的0的读法在前面就已经设置好了，所以这里直接跳过
                    case 1:
                    case 2:
                    case 3:
                        // 如果不被4整除，那么都执行这段判断代码：
                        // 如果它的下一位数字（针对当前字符串来说是上一个字符，因为之前执行了反转）也是0，
                        // 那么跳过，否则读作“零”
                        if (ary[i - 1] != '0') {
                            zero = "零";
                        }
                        break;

                }

                newary = zero + newary;
                zero = '';
            }
            else {
                // 如果不是“0”，就将该当字符转换成数值型，
                // 并作为数组ary0的索引号，以得到与之对应的中文读法，
                // 其后再跟上它的的一级单位（空、十、百还是千）最后再加上前面已存入的读法内容。
                newary = this.ary0[parseInt(ary[i])] + this.ary1[i % 4] + newary;
            }

        }
        // 用while处理最前面的零和单位（前面没有数字则不需要单位）
        while (newary.indexOf("零") == 0 || this.isUnit(newary)) {
            newary = newary.substr(1);
        }
        return newary;
    }
}

//创建class类
function change() {
    this.init.apply(this, arguments);
}
change.prototype = _change;

//创建实例
var k = new change("0000030010002040");
alert(k.pri_ary());

执行结果：

这段代码通过原型链实现了继承。基于原型链创建了change的class类，change通过prototype继承了_change的属性和方法（公有），通过在实例化时在自己本身调用init方法初始化私有的name属性。对父类_change的改变会影响子类，对子类的属性添加、覆盖只能写在change类的定义中。

function change() {
    this.aryG = ['hello', 'word'];
    _change.ary2.push('万亿');
    this.init.apply(this, arguments);
}

修改代码，在change()类中增加一个属性aryG，父类的ary2中增加一个单位万亿，则由下图可以看到，增加的单位“万亿”对父类_change和子类change都生效了，而arrG是子类中才有。