JavaScript 数字到单词

Question

我正在尝试将数字转换为英文单词，例如 1234 将变为：“一千二百三十四”。

我的策略是这样的：

• 将数字分成三位，然后将它们从右到左放入数组 (finlOutPut)。

• 将每组（finlOutPut 数组中的每个单元格）的三位数字转换为一个单词（这是 triConvert 函数的作用）。如果所有三位数字均为零，则将它们转换为 "dontAddBigSuffix"

• 从右到左，添加千、百万、十亿等。如果 finlOutPut 单元格等于 "dontAddBigSufix"（因为它只是零），则不要添加该单词并将单元格设置为 " " （什么也没有）。

它似乎工作得很好，但我在处理诸如 190000009 之类的数字时遇到了一些问题，转换为：“一亿九千万”。当有几个零时，它会以某种方式“忘记”最后的数字。

我做错了什么？错误在哪里？为什么它不能完美工作？

function update(){
    var bigNumArry = new Array('', ' thousand', ' million', ' billion', ' trillion', ' quadrillion', ' quintillion');

    var output = '';
    var numString =   document.getElementById('number').value;
    var finlOutPut = new Array();

    if (numString == '0') {
        document.getElementById('container').innerHTML = 'Zero';
        return;
    }

    if (numString == 0) {
        document.getElementById('container').innerHTML = 'messeg tell to enter numbers';
        return;
    }

    var i = numString.length;
    i = i - 1;

    //cut the number to grups of three digits and add them to the Arry
    while (numString.length > 3) {
        var triDig = new Array(3);
        triDig[2] = numString.charAt(numString.length - 1);
        triDig[1] = numString.charAt(numString.length - 2);
        triDig[0] = numString.charAt(numString.length - 3);

        var varToAdd = triDig[0] + triDig[1] + triDig[2];
        finlOutPut.push(varToAdd);
        i--;
        numString = numString.substring(0, numString.length - 3);
    }
    finlOutPut.push(numString);
    finlOutPut.reverse();

    //conver each grup of three digits to english word
    //if all digits are zero the triConvert
    //function return the string "dontAddBigSufix"
    for (j = 0; j < finlOutPut.length; j++) {
        finlOutPut[j] = triConvert(parseInt(finlOutPut[j]));
    }

    var bigScalCntr = 0; //this int mark the million billion trillion... Arry

    for (b = finlOutPut.length - 1; b >= 0; b--) {
        if (finlOutPut[b] != "dontAddBigSufix") {
            finlOutPut[b] = finlOutPut[b] + bigNumArry[bigScalCntr] + ' , ';
            bigScalCntr++;
        }
        else {
            //replace the string at finlOP[b] from "dontAddBigSufix" to empty String.
            finlOutPut[b] = ' ';
            bigScalCntr++; //advance the counter  
        }
    }

        //convert The output Arry to , more printable string 
        for(n = 0; n<finlOutPut.length; n++){
            output +=finlOutPut[n];
        }

    document.getElementById('container').innerHTML = output;//print the output
}

//simple function to convert from numbers to words from 1 to 999
function triConvert(num){
    var ones = new Array('', ' one', ' two', ' three', ' four', ' five', ' six', ' seven', ' eight', ' nine', ' ten', ' eleven', ' twelve', ' thirteen', ' fourteen', ' fifteen', ' sixteen', ' seventeen', ' eighteen', ' nineteen');
    var tens = new Array('', '', ' twenty', ' thirty', ' forty', ' fifty', ' sixty', ' seventy', ' eighty', ' ninety');
    var hundred = ' hundred';
    var output = '';
    var numString = num.toString();

    if (num == 0) {
        return 'dontAddBigSufix';
    }
    //the case of 10, 11, 12 ,13, .... 19 
    if (num < 20) {
        output = ones[num];
        return output;
    }

    //100 and more
    if (numString.length == 3) {
        output = ones[parseInt(numString.charAt(0))] + hundred;
        output += tens[parseInt(numString.charAt(1))];
        output += ones[parseInt(numString.charAt(2))];
        return output;
    }

    output += tens[parseInt(numString.charAt(0))];
    output += ones[parseInt(numString.charAt(1))];

    return output;
}   

<input type="text"
    id="number"
    size="70"
    onkeyup="update();"
    /*this code prevent non numeric letters*/ 
    onkeydown="return (event.ctrlKey || event.altKey 
                    || (47<event.keyCode && event.keyCode<58 && event.shiftKey==false) 
                    || (95<event.keyCode && event.keyCode<106)
                    || (event.keyCode==8) || (event.keyCode==9) 
                    || (event.keyCode>34 && event.keyCode<40) 
                    || (event.keyCode==46) )"/>
                    <br/>
<div id="container">Here The Numbers Printed</div>

Answer 1

你的问题已经解决了，但我发布了另一种方法仅供参考。

该代码是为了在 Node.js 上进行测试而编写的，但在浏览器中调用时这些函数应该可以正常工作。此外，这仅处理范围 [0,1000000]，但可以轻松适应更大的范围。

// actual  conversion code starts here

var ones = ['', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine'];
var tens = ['', '', 'twenty', 'thirty', 'forty', 'fifty', 'sixty', 'seventy', 'eighty', 'ninety'];
var teens = ['ten', 'eleven', 'twelve', 'thirteen', 'fourteen', 'fifteen', 'sixteen', 'seventeen', 'eighteen', 'nineteen'];

function convert_millions(num) {
  if (num >= 1000000) {
    return convert_millions(Math.floor(num / 1000000)) + " million " + convert_thousands(num % 1000000);
  } else {
    return convert_thousands(num);
  }
}

function convert_thousands(num) {
  if (num >= 1000) {
    return convert_hundreds(Math.floor(num / 1000)) + " thousand " + convert_hundreds(num % 1000);
  } else {
    return convert_hundreds(num);
  }
}

function convert_hundreds(num) {
  if (num > 99) {
    return ones[Math.floor(num / 100)] + " hundred " + convert_tens(num % 100);
  } else {
    return convert_tens(num);
  }
}

function convert_tens(num) {
  if (num < 10) return ones[num];
  else if (num >= 10 && num < 20) return teens[num - 10];
  else {
    return tens[Math.floor(num / 10)] + " " + ones[num % 10];
  }
}

function convert(num) {
  if (num == 0) return "zero";
  else return convert_millions(num);
}

//end of conversion code

//testing code begins here

function main() {
  var cases = [0, 1, 2, 7, 10, 11, 12, 13, 15, 19, 20, 21, 25, 29, 30, 35, 50, 55, 69, 70, 99, 100, 101, 119, 510, 900, 1000, 5001, 5019, 5555, 10000, 11000, 100000, 199001, 1000000, 1111111, 190000009];
  for (var i = 0; i < cases.length; i++) {
    console.log(cases[i] + ": " + convert(cases[i]));
  }
}

main();

Answer 2

当存在前导零数字时，JavaScript 会将 3 个数字组成的组解析为八进制数。当三位数字全为零时，无论基数是八进制还是十进制，结果都是一样的。

但是当你给 JavaScript '009'（或'008'）时，这是一个无效的八进制数，所以你会得到零。

如果您浏览了从 190,000,001 到 190,000,010 的整组数字，您会看到 JavaScript 跳过“...,008”和“...,009”，但为“...,010”发出“8”。这就是“尤里卡！”片刻。

Change:

for (j = 0; j < finlOutPut.length; j++) {
    finlOutPut[j] = triConvert(parseInt(finlOutPut[j]));
}

to

for (j = 0; j < finlOutPut.length; j++) {
    finlOutPut[j] = triConvert(parseInt(finlOutPut[j],10));
}

Code 还在每个非零组后面添加逗号，所以我使用它并找到了添加逗号的正确位置。

旧：

for (b = finlOutPut.length - 1; b >= 0; b--) {
    if (finlOutPut[b] != "dontAddBigSufix") {
        finlOutPut[b] = finlOutPut[b] + bigNumArry[bigScalCntr] + ' , ';
        bigScalCntr++;
    }
    else {
        //replace the string at finlOP[b] from "dontAddBigSufix" to empty String.
        finlOutPut[b] = ' ';
        bigScalCntr++; //advance the counter  
    }
}

    //convert The output Arry to , more printable string 
    for(n = 0; n<finlOutPut.length; n++){
        output +=finlOutPut[n];
    }

新：

for (b = finlOutPut.length - 1; b >= 0; b--) {
    if (finlOutPut[b] != "dontAddBigSufix") {
        finlOutPut[b] = finlOutPut[b] + bigNumArry[bigScalCntr]; // <<<
        bigScalCntr++;
    }
    else {
        //replace the string at finlOP[b] from "dontAddBigSufix" to empty String.
        finlOutPut[b] = ' ';
        bigScalCntr++; //advance the counter  
    }
}

    //convert The output Arry to , more printable string 
    var nonzero = false; // <<<
    for(n = 0; n<finlOutPut.length; n++){
        if (finlOutPut[n] != ' ') { // <<<
            if (nonzero) output += ' , '; // <<<
            nonzero = true; // <<<
        } // <<<
        output +=finlOutPut[n];
    }

Answer 3

我知道这个问题三年前就已经解决了。我发布此特别针对印度开发者

在花了一些时间谷歌搜索和玩其他代码之后，我做了一个快速修复，可重用函数适用于高达 99,99,99,999 的数字。 use : number2text(1234.56); 将返回 1000234 RUPEE AND 56 PAISE ONLY 。享受 ！

function number2text(value) {
    var fraction = Math.round(frac(value)*100);
    var f_text  = "";

    if(fraction > 0) {
        f_text = "AND "+convert_number(fraction)+" PAISE";
    }

    return convert_number(value)+" RUPEE "+f_text+" ONLY";
}

function frac(f) {
    return f % 1;
}

function convert_number(number)
{
    if ((number < 0) || (number > 999999999)) 
    { 
        return "NUMBER OUT OF RANGE!";
    }
    var Gn = Math.floor(number / 10000000);  /* Crore */ 
    number -= Gn * 10000000; 
    var kn = Math.floor(number / 100000);     /* lakhs */ 
    number -= kn * 100000; 
    var Hn = Math.floor(number / 1000);      /* thousand */ 
    number -= Hn * 1000; 
    var Dn = Math.floor(number / 100);       /* Tens (deca) */ 
    number = number % 100;               /* Ones */ 
    var tn= Math.floor(number / 10); 
    var one=Math.floor(number % 10); 
    var res = ""; 

    if (Gn>0) 
    { 
        res += (convert_number(Gn) + " CRORE"); 
    } 
    if (kn>0) 
    { 
            res += (((res=="") ? "" : " ") + 
            convert_number(kn) + " LAKH"); 
    } 
    if (Hn>0) 
    { 
        res += (((res=="") ? "" : " ") +
            convert_number(Hn) + " THOUSAND"); 
    } 

    if (Dn) 
    { 
        res += (((res=="") ? "" : " ") + 
            convert_number(Dn) + " HUNDRED"); 
    } 


    var ones = Array("", "ONE", "TWO", "THREE", "FOUR", "FIVE", "SIX","SEVEN", "EIGHT", "NINE", "TEN", "ELEVEN", "TWELVE", "THIRTEEN","FOURTEEN", "FIFTEEN", "SIXTEEN", "SEVENTEEN", "EIGHTEEN","NINETEEN"); 
var tens = Array("", "", "TWENTY", "THIRTY", "FOURTY", "FIFTY", "SIXTY","SEVENTY", "EIGHTY", "NINETY"); 

    if (tn>0 || one>0) 
    { 
        if (!(res=="")) 
        { 
            res += " AND "; 
        } 
        if (tn < 2) 
        { 
            res += ones[tn * 10 + one]; 
        } 
        else 
        { 

            res += tens[tn];
            if (one>0) 
            { 
                res += ("-" + ones[one]); 
            } 
        } 
    }

    if (res=="")
    { 
        res = "zero"; 
    } 
    return res;
}

Answer 4

印度版

@jasonhao 的印度货币答案的更新版本

function intToEnglish(number) {

  var NS = [
    { value: 10000000, str: "Crore" },
    { value: 100000, str: "Lakh" },
    { value: 1000, str: "Thousand" },
    { value: 100, str: "Hundred" },
    { value: 90, str: "Ninety" },
    { value: 80, str: "Eighty" },
    { value: 70, str: "Seventy" },
    { value: 60, str: "Sixty" },
    { value: 50, str: "Fifty" },
    { value: 40, str: "Forty" },
    { value: 30, str: "Thirty" },
    { value: 20, str: "Twenty" },
    { value: 19, str: "Nineteen" },
    { value: 18, str: "Eighteen" },
    { value: 17, str: "Seventeen" },
    { value: 16, str: "Sixteen" },
    { value: 15, str: "Fifteen" },
    { value: 14, str: "Fourteen" },
    { value: 13, str: "Thirteen" },
    { value: 12, str: "Twelve" },
    { value: 11, str: "Eleven" },
    { value: 10, str: "Ten" },
    { value: 9, str: "Nine" },
    { value: 8, str: "Eight" },
    { value: 7, str: "Seven" },
    { value: 6, str: "Six" },
    { value: 5, str: "Five" },
    { value: 4, str: "Four" },
    { value: 3, str: "Three" },
    { value: 2, str: "Two" },
    { value: 1, str: "One" }
  ];

  var result = '';
  for (var n of NS) {
    if (number >= n.value) {
      if (number <= 99) {
        result += n.str;
        number -= n.value;
        if (number > 0) result += ' ';
      } else {
        var t = Math.floor(number / n.value);
        // console.log(t);
        var d = number % n.value;
        if (d > 0) {
          return intToEnglish(t) + ' ' + n.str + ' ' + intToEnglish(d);
        } else {
          return intToEnglish(t) + ' ' + n.str;
        }

      }
    }
  }
  return result;
}

console.log(intToEnglish(99))
console.log(intToEnglish(991199))
console.log(intToEnglish(123456799))

Answer 5

在这里，我写了一个替代解决方案：

1）包含字符串常量的对象：

var NUMBER2TEXT = {
    ones: ['', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine', 'ten', 'eleven', 'twelve', 'thirteen', 'fourteen', 'fifteen', 'sixteen', 'seventeen', 'eighteen', 'nineteen'],
    tens: ['', '', 'twenty', 'thirty', 'fourty', 'fifty', 'sixty', 'seventy', 'eighty', 'ninety'],
    sep: ['', ' thousand ', ' million ', ' billion ', ' trillion ', ' quadrillion ', ' quintillion ', ' sextillion ']
};

2）实际代码：

(function( ones, tens, sep ) {

    var input = document.getElementById( 'input' ),
        output = document.getElementById( 'output' );

    input.onkeyup = function() {
        var val = this.value,
            arr = [],
            str = '',
            i = 0;

        if ( val.length === 0 ) {
            output.textContent = 'Please type a number into the text-box.';
            return;  
        }

        val = parseInt( val, 10 );
        if ( isNaN( val ) ) {
            output.textContent = 'Invalid input.';
            return;   
        }

        while ( val ) {
            arr.push( val % 1000 );
            val = parseInt( val / 1000, 10 );   
        }

        while ( arr.length ) {
            str = (function( a ) {
                var x = Math.floor( a / 100 ),
                    y = Math.floor( a / 10 ) % 10,
                    z = a % 10;

                return ( x > 0 ? ones[x] + ' hundred ' : '' ) +
                       ( y >= 2 ? tens[y] + ' ' + ones[z] : ones[10*y + z] );
            })( arr.shift() ) + sep[i++] + str;
        }

        output.textContent = str;
    };

})( NUMBER2TEXT.ones, NUMBER2TEXT.tens, NUMBER2TEXT.sep );

现场演示： http://jsfiddle.net/j5kdG/

Answer 6

有en_US和cs_CZ的JS库。
您可以单独使用它，也可以将其作为 Node 模块使用。

• Numbers2Words

Answer 7

2022 年 2 月更新

下面包含一个简单而简短的 Javascript 函数，用于将数字（整数）转换为英语（美国系统）中的单词，并使用带有字符串的 forEach() 循环来给出正确的结果三元组数组方法。

首先使用以下方法将数字转换为字符串三元组数组：

num= ("0".repeat(2*(num+="").length%3)+num).match(/.{3}/g);

然后将字符串数组轻松解码为数字。

例如，数字 1234567 被转换为字符串三元组数组：

[ '001', '234', '567' ]

然后通过 forEach() 循环从左到右扫描每个元素。

这是一个比我 2 年前提出的使用 for 循环更好的解决方案。

如果您愿意，可以将比例数组增加到“四亿”以上。

如果输入的数字太大，则将其作为“字符串”传递。

还包括测试用例。

/********************************************************
* @function    : numToWords(number)
* @purpose     : Converts Unsigned Integers to Words
* @version     : 1.50
* @author      : Mohsen Alyafei
* @licence     : MIT
* @date        : 26 Feb 2022
* @param       : {number} [integer numeric or string]
* @returns     : {string} The wordified number string
********************************************************/


//==============================================================
function numToWords(num = 0) {
if (num == 0) return "Zero";
num= ("0".repeat(2*(num+="").length%3)+num).match(/.{3}/g);
let out="",
    T10s=["","One","Two","Three","Four","Five","Six","Seven","Eight","Nine","Ten","Eleven","Twelve","Thirteen","Fourteen","Fifteen","Sixteen","Seventeen","Eighteen","Nineteen"],
    T20s=["","","Twenty","Thirty","Forty","Fifty","Sixty","Seventy","Eighty","Ninety"],
    sclT=["","Thousand","Million","Billion","Trillion","Quadrillion"];
return num.forEach((n,i) => {
if (+n) {
 let hund=+n[0], ten=+n.substring(1), scl=sclT[num.length-i-1];
 out+=(out?" ":"")+(hund?T10s[hund]+" Hundred":"")+(hund && ten?" ":"")+(ten<20?T10s[ten]:T20s[+n[1]]+(+n[2]?"-":"")+T10s[+n[2]]);
 out+=(out && scl?" ":"")+scl;
}}),out;
}
//==============================================================









//=========================================
//             Test Code
//=========================================
var r=0; // test tracker
r |= test(0,"Zero");
r |= test(5,"Five");
r |= test(10,"Ten");
r |= test(19,"Nineteen");
r |= test(33,"Thirty-Three");
r |= test(100,"One Hundred");
r |= test(111,"One Hundred Eleven");
r |= test(890,"Eight Hundred Ninety");
r |= test(1234,"One Thousand Two Hundred Thirty-Four");
r |= test(12345,"Twelve Thousand Three Hundred Forty-Five");
r |= test(123456,"One Hundred Twenty-Three Thousand Four Hundred Fifty-Six");
r |= test(1234567,"One Million Two Hundred Thirty-Four Thousand Five Hundred Sixty-Seven");
r |= test(12345678,"Twelve Million Three Hundred Forty-Five Thousand Six Hundred Seventy-Eight");
r |= test(123456789,"One Hundred Twenty-Three Million Four Hundred Fifty-Six Thousand Seven Hundred Eighty-Nine");
r |= test(1234567890,"One Billion Two Hundred Thirty-Four Million Five Hundred Sixty-Seven Thousand Eight Hundred Ninety");
r |= test(1001,"One Thousand One");
r |= test(10001,"Ten Thousand One");
r |= test(100001,"One Hundred Thousand One");
r |= test(1000001,"One Million One");
r |= test(10000001,"Ten Million One");
r |= test(100000001,"One Hundred Million One");
r |= test(12012,"Twelve Thousand Twelve");
r |= test(120012,"One Hundred Twenty Thousand Twelve");
r |= test(1200012,"One Million Two Hundred Thousand Twelve");
r |= test(12000012,"Twelve Million Twelve");
r |= test(120000012,"One Hundred Twenty Million Twelve");
r |= test(75075,"Seventy-Five Thousand Seventy-Five");
r |= test(750075,"Seven Hundred Fifty Thousand Seventy-Five");
r |= test(7500075,"Seven Million Five Hundred Thousand Seventy-Five");
r |= test(75000075,"Seventy-Five Million Seventy-Five");
r |= test(750000075,"Seven Hundred Fifty Million Seventy-Five");
r |= test(1000,"One Thousand");
r |= test(1000000,"One Million");
r |= test(1000000000,"One Billion");
r |= test(1000000000000,"One Trillion");
r |= test("1000000000000000","One Quadrillion");

if (r==0) console.log("All Test Cases Passed.");

function test(n,should) {
let result = numToWords(n);
if (result !== should) {console.log(`${n} Output   : ${result}\n${n} Should be: ${should}`);return 1;}
}

Answer 8

<html>
<head>
<meta http-equiv="Content-Type" content="text/html;charset=utf-8"/>
<script type="text/javascript">
var th = ['', ' thousand', ' million', ' billion', ' trillion', ' quadrillion', ' quintillion'];
var dg = ['zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine'];
var tn = ['ten', 'eleven', 'twelve', 'thirteen', 'fourteen', 'fifteen', 'sixteen', 'seventeen', 'eighteen', 'nineteen'];
var tw = ['twenty', 'thirty', 'forty', 'fifty', 'sixty', 'seventy', 'eighty', 'ninety'];

function update(){
    var numString =   document.getElementById('number').value;
    if (numString == '0') {
        document.getElementById('container').innerHTML = 'Zero';
        return;
    }
    if (numString == 0) {
        document.getElementById('container').innerHTML = 'messeg tell to enter numbers';
        return;
    }

    var output = toWords(numString);
    //print the output
    document.getElementById('container').innerHTML = output;
}

function toWords(s) {
    s = s.toString();
    s = s.replace(/[\, ]/g, '');
    if (s != parseFloat(s)) return 'not a number';
    var x = s.indexOf('.');
    if (x == -1) x = s.length;
    if (x > 15) return 'too big';
    var n = s.split('');
    var str = '';
    var sk = 0;
    for (var i = 0; i < x; i++) {
        if ((x - i) % 3 == 2) {
            if (n[i] == '1') {
                str += tn[Number(n[i + 1])] + ' ';
                i++;
                sk = 1;
            } else if (n[i] != 0) {
                str += tw[n[i] - 2] + ' ';
                sk = 1;
            }
        } else if (n[i] != 0) {
            str += dg[n[i]] + ' ';
            if ((x - i) % 3 == 0) str += 'hundred ';
            sk = 1;
        }
        if ((x - i) % 3 == 1) {
            if (sk) str += th[(x - i - 1) / 3] + ' ';
            sk = 0;
        }
    }
    if (x != s.length) {
        var y = s.length;
        str += 'point ';
        for (var i = x + 1; i < y; i++) str += dg[n[i]] + ' ';
    }
    return str.replace(/\s+/g, ' ');
}
</script>

</head>
<body>

<input type="text"
    id="number"
    size="70"
    onkeyup="update();"
    /*this code prevent non numeric letters*/ 
    onkeydown="return (event.ctrlKey || event.altKey 
                    || (47<event.keyCode && event.keyCode<58 && event.shiftKey==false) 
                    || (95<event.keyCode && event.keyCode<106)
                    || (event.keyCode==8) || (event.keyCode==9) 
                    || (event.keyCode>34 && event.keyCode<40) 
                    || (event.keyCode==46) )"/>
                    <br/>
<div id="container">Here The Numbers Printed</div>
</body>
</html>

Answer 9

带有紧凑对象的版本 - 适用于从 0 到 999 的数字。

function wordify(n) {
    var word = [],
        numbers = { 1: 'One', 2: 'Two', 3: 'Three', 4: 'Four', 5: 'Five', 6: 'Six', 7: 'Seven', 8: 'Eight', 9: 'Nine', 10: 'Ten', 11: 'Eleven', 12: 'Twelve', t3: 'Thir', t5: 'Fif', t8: 'Eigh', 20: 'Twenty' },
        hundreds = 0 | (n % 1000) / 100,
        tens = 0 | (n % 100) / 10,
        ones = n % 10,
        part;

    if (n === 0) return 'Zero';
    if (hundreds) word.push(numbers[hundreds] + ' Hundred');

    if (tens === 0) {
        word.push(numbers[ones]);
    } else if (tens === 1) {
        word.push(numbers['1' + ones] || (numbers['t' + ones] || numbers[ones]) + 'teen');
    } else {
        part = numbers[tens + '0'] || (numbers['t' + tens] || numbers[tens]) + 'ty';
        word.push(numbers[ones] ? part + '-' + numbers[ones] : part);
    }
    return word.join(' ');
}

var i,
    output = document.getElementById('out');

for (i = 0; i < 1e3; i++) output.innerHTML += wordify(i) + '\n';

<pre id="out"></pre>

Answer 10

function intToEnglish(number){

var NS = [
    {value: 1000000000000000000000, str: "sextillion"},
    {value: 1000000000000000000, str: "quintillion"},
    {value: 1000000000000000, str: "quadrillion"},
    {value: 1000000000000, str: "trillion"},
    {value: 1000000000, str: "billion"},
    {value: 1000000, str: "million"},
    {value: 1000, str: "thousand"},
    {value: 100, str: "hundred"},
    {value: 90, str: "ninety"},
    {value: 80, str: "eighty"},
    {value: 70, str: "seventy"},
    {value: 60, str: "sixty"},
    {value: 50, str: "fifty"},
    {value: 40, str: "forty"},
    {value: 30, str: "thirty"},
    {value: 20, str: "twenty"},
    {value: 19, str: "nineteen"},
    {value: 18, str: "eighteen"},
    {value: 17, str: "seventeen"},
    {value: 16, str: "sixteen"},
    {value: 15, str: "fifteen"},
    {value: 14, str: "fourteen"},
    {value: 13, str: "thirteen"},
    {value: 12, str: "twelve"},
    {value: 11, str: "eleven"},
    {value: 10, str: "ten"},
    {value: 9, str: "nine"},
    {value: 8, str: "eight"},
    {value: 7, str: "seven"},
    {value: 6, str: "six"},
    {value: 5, str: "five"},
    {value: 4, str: "four"},
    {value: 3, str: "three"},
    {value: 2, str: "two"},
    {value: 1, str: "one"}
  ];

  var result = '';
  for (var n of NS) {
    if(number>=n.value){
      if(number<=20){
        result += n.str;
        number -= n.value;
        if(number>0) result += ' ';
      }else{
        var t =  Math.floor(number / n.value);
        var d = number % n.value;
        if(d>0){
          return intToEnglish(t) + ' ' + n.str +' ' + intToEnglish(d);
        }else{
          return intToEnglish(t) + ' ' + n.str;
        }

      }
    }
  }
  return result;
}

Answer 11

试试这个，将数字转换为单词

function convert(number) {

    if (number < 0) {

        console.log("Number Must be greater than zero = " + number);
        return "";
    }
    if (number > 100000000000000000000) {
        console.log("Number is out of range = " + number);
        return "";
    }
    if (!is_numeric(number)) {
        console.log("Not a number = " + number);
        return "";
    }

    var quintillion = Math.floor(number / 1000000000000000000); /* quintillion */
    number -= quintillion * 1000000000000000000;
    var quar = Math.floor(number / 1000000000000000); /* quadrillion */
    number -= quar * 1000000000000000;
    var trin = Math.floor(number / 1000000000000); /* trillion */
    number -= trin * 1000000000000;
    var Gn = Math.floor(number / 1000000000); /* billion */
    number -= Gn * 1000000000;
    var million = Math.floor(number / 1000000); /* million */
    number -= million * 1000000;
    var Hn = Math.floor(number / 1000); /* thousand */
    number -= Hn * 1000;
    var Dn = Math.floor(number / 100); /* Tens (deca) */
    number = number % 100; /* Ones */
    var tn = Math.floor(number / 10);
    var one = Math.floor(number % 10);
    var res = "";

    if (quintillion > 0) {
        res += (convert_number(quintillion) + " quintillion");
    }
    if (quar > 0) {
        res += (convert_number(quar) + " quadrillion");
    }
    if (trin > 0) {
        res += (convert_number(trin) + " trillion");
    }
    if (Gn > 0) {
        res += (convert_number(Gn) + " billion");
    }
    if (million > 0) {
        res += (((res == "") ? "" : " ") + convert_number(million) + " million");
    }
    if (Hn > 0) {
        res += (((res == "") ? "" : " ") + convert_number(Hn) + " Thousand");
    }

    if (Dn) {
        res += (((res == "") ? "" : " ") + convert_number(Dn) + " hundred");
    }


    var ones = Array("", "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine", "Ten", "Eleven", "Twelve", "Thirteen", "Fourteen", "Fifteen", "Sixteen", "Seventeen", "Eightteen", "Nineteen");
    var tens = Array("", "", "Twenty", "Thirty", "Fourty", "Fifty", "Sixty", "Seventy", "Eigthy", "Ninety");

    if (tn > 0 || one > 0) {
        if (!(res == "")) {
            res += " and ";
        }
        if (tn < 2) {
            res += ones[tn * 10 + one];
        } else {

            res += tens[tn];
            if (one > 0) {
                res += ("-" + ones[one]);
            }
        }
    }

    if (res == "") {
        console.log("Empty = " + number);
        res = "";
    }
    return res;
}
function is_numeric(mixed_var) {
    return (typeof mixed_var === 'number' || typeof mixed_var === 'string') && mixed_var !== '' && !isNaN(mixed_var);
}

Answer 12

这是一个简单的 ES6+ 数字到单词的函数。您可以简单地添加“illions”数组来扩展数字。美式英语版本。
（结尾前没有“和”）

// generic number to words

let digits  = ['','one','two','three','four', 'five','six','seven','eight','nine','ten','eleven','twelve','thirteen','fourteen','fifteen','sixteen','seventeen','eighteen','nineteen'];
let ties    = ['', '', 'twenty','thirty','forty','fifty', 'sixty','seventy','eighty','ninety'];
let illions = ['', 'thousand', 'million', 'billion', 'trillion'].reverse()

let join = (a, s) => a.filter(v => v).join(s || ' ')

let tens = s => 
    digits[s] || 
    join([ties[s[0]], digits[s[1]]], '-') // 21 -> twenty-one

let hundreds = s => 
    join(
        (s[0] !== '0' ? [digits[s[0]], 'hundred'] : [])
            .concat( tens(s.substr(1,2)) )  )

let re = '^' + '(\\d{3})'.repeat(illions.length) + '


let numberToWords = n => 
    // to filter non number or '', null, undefined, false, NaN
    isNaN(Number(n)) || !n && n !== 0 
        ? 'not a number'
        : Number(n) === 0 
            ? 'zero'  
            : Number(n) >= 10 ** (illions.length * 3)
                ? 'too big'
                : String(n)
                    .padStart(illions.length * 3, '0')
                    .match(new RegExp(re))
                    .slice(1, illions.length + 1)
                    .reduce( (a, v, i) => v === '000' ? a : join([a, hundreds(v), illions[i]]), '')


// just for this question.

let update = () => {
    let value = document.getElementById('number').value
    document.getElementById('container').innerHTML = numberToWords(value)
}

Answer 13

这是一个解决方案，可以处理任何适合字符串的整数值。我已将数字比例定义为“十亿”，因此该解决方案应精确到 999 十亿。之后你会得到诸如“一千十亿”之类的东西。

JavaScript 数字在“999999999999999”左右开始失败，因此转换函数仅适用于数字字符串。

示例：

convert("365");
//=> "three hundred sixty-five"

convert("10000000000000000000000000000230001010109");
//=> "ten thousand decillion two hundred thirty billion one million ten thousand one hundred nine"

代码：

var lt20 = ["", "one", "two", "three", "four", "five", "six", "seven","eight", "nine", "ten", "eleven", "twelve", "thirteen", "fourteen", "fifteen", "sixteen", "seventeen", "eighteen", "nineteen" ],
    tens = ["", "ten", "twenty", "thirty", "fourty", "fifty", "sixty", "seventy", "eightty", "ninety" ],
    scales = ["", "thousand", "million", "billion", "trillion", "quadrillion", "quintillion", "sextillion", "septillion", "octillion", "nonillion", "decillion" ],
    max = scales.length * 3;

function convert(val) {
    var len;

    // special cases
    if (val[0] === "-") { return "negative " + convert(val.slice(1)); }
    if (val === "0") { return "zero"; }

    val = trim_zeros(val);
    len = val.length;

    // general cases
    if (len < max) { return convert_lt_max(val); }
    if (len >= max) { return convert_max(val); }
}

function convert_max(val) {
    return split_rl(val, max)
        .map(function (val, i, arr) {
            if (i < arr.length - 1) {
                return convert_lt_max(val) + " " + scales.slice(-1);
            }
            return convert_lt_max(val);
        })
        .join(" ");
}       

function convert_lt_max(val) {
    var l = val.length;
    if (l < 4) {
        return convert_lt1000(val).trim();
    } else {
        return split_rl(val, 3)
            .map(convert_lt1000)
            .reverse()
            .map(with_scale)
            .reverse()
            .join(" ")
            .trim();
    }
}

function convert_lt1000(val) {
    var rem, l;

    val = trim_zeros(val);
    l = val.length;

    if (l === 0) { return ""; }
    if (l < 3) { return convert_lt100(val); }
    if (l === 3) { //less than 1000
        rem = val.slice(1);
        if (rem) {
            return lt20[val[0]] + " hundred " + convert_lt1000(rem);
        } else {
            return lt20[val[0]] + " hundred";
        }
    }
}

function convert_lt100(val) {
    if (is_lt20(val)) { // less than 20
        return lt20[val];
    } else if (val[1] === "0") {
        return tens[val[0]];
    } else {
        return tens[val[0]] + "-" +  lt20[val[1]];
    }
}


function split_rl(str, n) {
    // takes a string 'str' and an integer 'n'. Splits 'str' into
    // groups of 'n' chars and returns the result as an array. Works
    // from right to left.
    if (str) {
        return Array.prototype.concat
            .apply(split_rl(str.slice(0, (-n)), n), [str.slice(-n)]);
    } else {
        return [];
    }
}

function with_scale(str, i) {
    var scale;
    if (str && i > (-1)) {
        scale = scales[i];
        if (scale !== undefined) {
            return str.trim() + " " + scale;
        } else {
            return convert(str.trim());
        }
    } else {
        return "";
    }
}

function trim_zeros(val) {
    return val.replace(/^0*/, "");
}

function is_lt20(val) {
    return parseInt(val, 10) < 20;
}

Answer 14

我修改了 Šime Vidas 的帖子 - http://jsfiddle.net/j5kdG/
在适当的位置包含美元、美分、逗号和“和”。
如果需要“零美分”，或者如果为 0，则不提及美分，则有一个可选的结尾。

这个函数结构让我有点头疼，但我学到了很多。谢谢西梅。

有人可能会找到更好的方法来处理这个问题。

代码：

var str='';
var str2='';
var str3 =[];

function convertNum(inp,end){
    str2='';
    str3 = [];
    var NUMBER2TEXT = {
    ones: ['', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine', 'ten', 'eleven', 'twelve', 'thirteen', 'fourteen', 'fifteen', 'sixteen', 'seventeen', 'eighteen', 'nineteen'],
    tens: ['', '', 'twenty', 'thirty', 'forty', 'fifty', 'sixty', 'seventy', 'eighty', 'ninety'],
    sep: ['', ' thousand', ' million', ' billion', ' trillion', ' quadrillion', ' quintillion', ' sextillion']
};
(function( ones, tens, sep ) {
   var vals = inp.split("."),val,pos,postsep=' ';
   for (p in vals){
      val = vals[p], arr = [], str = '', i = 0;
      if ( val.length === 0 ) {return 'No value';}
      val = parseInt( (p==1 && val.length===1 )?val*10:val, 10 );
      if ( isNaN( val ) || p>=2) {return 'Invalid value'; }
      while ( val ) {
        arr.push( val % 1000 );
        val = parseInt( val / 1000, 10 );   
      }
      pos = arr.length;
      function trimx (strx) {
                return strx.replace(/^\s\s*/, '').replace(/\s\s*$/, '');
            }
        function seps(sepi,i){
                var s = str3.length
                if (str3[s-1][0]){
                    if (str3[s-2][1] === str3[s-1][0]){
                        str = str.replace(str3[s-2][1],'')
                    }
                }
                var temp = str.split(sep[i-2]);
                if (temp.length > 1){
                    if (trimx(temp[0]) ==='' && temp[1].length > 1 ){
                        str = temp[1];
                        } 
                    }
                return sepi + str ;
        }
      while ( arr.length  ) {
        str = (function( a ) {
            var x = Math.floor( a / 100 ),
                y = Math.floor( a / 10 ) % 10,
                z = a % 10;
                postsep = (arr.length != 0)?', ' : ' ' ;
                if ((x+y+z) === 0){
                    postsep = ' '
                }else{ 
                    if (arr.length == pos-1 && x===0 && pos > 1 ){
                        postsep = ' and ' 
                    } 
                }
               str3.push([trimx(str)+"",trimx(sep[i])+""]);
                return  (postsep)+( x > 0 ? ones[x] + ' hundred ' + (( x == 0 && y >= 0 || z >0 )?' and ':' ') : ' ' ) +                  
                   ( y >= 2 ? tens[y] + ((z===0)?' ':'-') + ones[z] : ones[10*y + z] ); 
        })( arr.shift() ) +seps( sep[i++] ,i ) ;             
      }
      if (p==0){ str2 += str + ' dollars'}
      if (p==1 && !end){str2 += (str!='')?' and '+ str + ' cents':'' } 
      if (p==1 && end ){str2 += ' and ' + ((str==='')?'zero':str) + ' cents '} 
   }
})( NUMBER2TEXT.ones , NUMBER2TEXT.tens , NUMBER2TEXT.sep );

Answer 15

这是法语的解决方案
这是 @gandil 回复的一个分支，

<html>
<head>
<meta http-equiv="Content-Type" content="text/html;charset=utf-8"/>
<script type="text/javascript">
var th = ['', ' mille', ' millions', ' milliards', ' billions', ' mille-billions', ' trillion'];
var dg = ['zéro', 'un', 'deux', 'trois', 'quatre', 'cinq', 'six', 'sept', 'huit', 'neuf'];
var tn = ['dix', 'onze', 'douze', 'treize', 'quatorze', 'quinze', 'seize', 'dix-sept', 'dix-huit', 'dix-neuf'];
var tw = ['vingt', 'trente', 'quarante', 'cinquante', 'soixante', 'soixante-dix', 'quatre-vingts', 'quatre-vingt-dix'];

function update(){
    var numString =   document.getElementById('number').value;
    if (numString == '0') {
        document.getElementById('container').innerHTML = 'Zéro';
        return;
    }
    if (numString == 0) {
        document.getElementById('container').innerHTML = 'messeg tell to enter numbers';
        return;
    }

    var output = toWords(numString);
    //output.split('un mille').join('msille ');
    //output.replace('un cent', 'cent ');
    //print the output
    //if(output.length == 4){output = 'sss';}
    document.getElementById('container').innerHTML = output;
}

function toWords(s) {

    s = s.toString();
    s = s.replace(/[\, ]/g, '');
    if (s != parseFloat(s)) return 'not a number';
    var x = s.indexOf('.');
    if (x == -1) x = s.length;
    if (x > 15) return 'too big';
    var n = s.split('');
    var str = '';
    var sk = 0;
    for (var i = 0; i < x; i++) {
        if ((x - i) % 3 == 2) {
            if (n[i] == '1') {
                str += tn[Number(n[i + 1])] + ' ';
                i++;
                sk = 1;
            } else if (n[i] != 0) {
                str += tw[n[i] - 2] + ' ';
                sk = 1;
            }
        } else if (n[i] != 0) {
            str += dg[n[i]] + ' ';
            //if((dg[n[i]] == 'un') && ((x - i) / 3 == 1)){str = 'cent ';}
            if ((x - i) % 3 == 0) {str += 'cent ';}
            sk = 1;
        }
        if ((x - i) % 3 == 1) {
            //test
            if((x - i - 1) / 3 == 1){
                var long = str.length;
                subs = str.substr(long-3);
                if(subs.search("un")!= -1){
                    //str += 'OK';
                    str = str.substr(0, long-4);
                }

            }




            //test
            if (sk) str += th[(x - i - 1) / 3] + ' ';
            sk = 0;


        }
    }
    if (x != s.length) {
        var y = s.length;
        str += 'point ';
        for (var i = x + 1; i < y; i++) str += dg[n[i]] + ' ';
    }
    //if(str.length == 4){}
    str.replace(/\s+/g, ' ');
    return str.split('un cent').join('cent ');
    //return str.replace('un cent', 'cent ');
}
</script>

</head>
<body>

<input type="text"
       id="number"
       size="70"
       onkeyup="update();"
/*this code prevent non numeric letters*/
onkeydown="return (event.ctrlKey || event.altKey
|| (47<event.keyCode && event.keyCode<58 && event.shiftKey==false)
|| (95<event.keyCode && event.keyCode<106)
|| (event.keyCode==8) || (event.keyCode==9)
|| (event.keyCode>34 && event.keyCode<40)
|| (event.keyCode==46) )"/>
<br/>
<div id="container">Here The Numbers Printed</div>
</body>
</html>

我希望它会有所帮助

Answer 16

INDONESIAN DEVELOPER 的一个小代码片段，用于将数值转换为口头拼写（手动最小化，仅 576 字节，需要 ES6+）...

const terbilang=(x,nol='---',min='minus')=>{const S=['','satu','dua','tiga','empat','lima','enam','tujuh','delapan','sembilan'],K=['','ribu','juta','miliar','triliun','kuadriliun'],s=[];if(!x)return nol;if(x<0){if(min)s=[min];x=-x}for(let k=0;x;k++){let g=x%1e3;if(g===1&&k===1)s.unshift('seribu');else{let u=g>99?[(g>199?S[g/100|0]+' ':'se')+'ratus']:[];if(g%=100){if(g>9&&g<20)u.push(g<11?'sepuluh':(g<12?'se':S[g%10]+' ')+'belas');else{if(g>19)u.push(S[g/10|0]+' puluh');if(g%=10)u.push(S[g])}}k&&u.push(K[k]);s.unshift(u.join(' '))}x=Math.floor(x/1e3)}return s.join(' ')};

Answer 17

function toWords(...x) {
    let space = /\s/g;
    let digit = /\d/g;
    let trio = /.../g;
    let unit = ' one two three four five six seven eight nine ten eleven twelve thirteen fourteen fifteen sixteen seventeen eighteen nineteen'.split(space);
    let ten = '  twenty thirty forty fifty sixty seventy eighty ninety'.split(space);
    let scale = ' thousand million billion trillion quadrillion quintillion sextillion septillion octillion nonillion decillion'.split(space);
    let d = digit.test(x) ? String(x).match(digit) : ['0'];
    while (d.length % 3) d.unshift('0');
    d = d.join('').match(trio).map(function verbose(string) {
        let number = Number(string);
        return (number < 20) ?
            unit[number] :
            (number < 100) ?
            [ten[Number(string.slice(0, -1))], verbose(string.slice(-1))].filter(Boolean).join('-') :
            [verbose(string.slice(0, -2)), 'hundred', verbose(string.slice(-2))].filter(Boolean).join(' ');
    }).reverse().map(function(v, i, a) {
        return v ? [v, scale[i]].filter(Boolean).join(' ') : v;
    }).reverse().filter(Boolean).join(', ');
    return d ? d : 'zero';
}
toWords('14,702,000,583,690,010');
// 'fourteen quadrillion, seven hundred two trillion, five hundred eighty-three million, six hundred ninety thousand, ten'

Answer 18

我想指出的是，对于 x11-x19 之间的值（其中 x >= 1），原始逻辑会失败。例如，118 返回“一百八”。这是因为这些数字是通过 triConvert() 中的以下代码处理的：

//100 and more
if (numString.length == 3) {
    output = ones[parseInt(numString.charAt(0))] + hundred;
    output += tens[parseInt(numString.charAt(1))];
    output += ones[parseInt(numString.charAt(2))];
    return output;
}

这里，代表十位数的字符用于索引 tens[] 数组，该数组的索引 [1 处有一个空字符串]，因此 118 实际上变成了 108。

最好先处理数百个（如果有的话），然后通过相同的逻辑运行个数和十个。而不是：

//the case of 10, 11, 12 ,13, .... 19 
if (num < 20) {
    output = ones[num];
    return output;
}

//100 and more
if (numString.length == 3) {
    output = ones[parseInt(numString.charAt(0))] + hundred;
    output += tens[parseInt(numString.charAt(1))];
    output += ones[parseInt(numString.charAt(2))];
    return output;
}

output += tens[parseInt(numString.charAt(0))];
output += ones[parseInt(numString.charAt(1))];

return output;

我建议：

// 100 and more
if ( numString.length == 3 ) 
 {
   output  = hundreds[ parseInt( numString.charAt(0) ) ] + hundred ;
   num = num % 100 ;
   numString = num.toString() ;
 }

if ( num < 20 )  
 {
   output += ones[num] ;
 }
else 
 { // 20-99 
   output += tens[ parseInt( numString.charAt(0) ) ] ;
   output += '-' + ones[ parseInt( numString.charAt(1) ) ] ;  
 }

 return output;

在我看来，建议的代码既更短又更清晰，但我可能有偏见;-)

Answer 19

来源：http://javascript.about.com/library/bltoword.htm
我发现的最小脚本：

  <script type="text/javascript" src="toword.js">
    var words = toWords(12345);
    console.log(words);
  </script>

享受吧！

Answer 20

我尝试了穆罕默德的解决方案，但遇到了一些问题并且想要使用小数，所以我做了一些更改并转换为咖啡脚本和角度。请记住，js和coffeescript不是我的强项，所以要小心使用。

$scope.convert = (number, upper=0) ->
number = +number
# console.log "inside convert and the number is:  " + number

if number < 0
    # console.log 'Number Must be greater than zero = ' + number
    return ''

if number > 100000000000000000000
    # console.log 'Number is out of range = ' + number
    return ''
if isNaN(number)
    console.log("NOT A NUMBER")
    alert("Not a number = ")
    return ''
else
    console.log "at line 88 number is:  " + number
    quintillion = Math.floor(number / 1000000000000000000)
    ### quintillion ###

    number -= quintillion * 1000000000000000000
    quar = Math.floor(number / 1000000000000000)
    # console.log "at line 94 number is:  " + number

    ### quadrillion ###

    number -= quar * 1000000000000000
    trin = Math.floor(number / 1000000000000)
    # console.log "at line 100 number is:  " + number

    ### trillion ###
    number -= trin * 1000000000000
    Gn = Math.floor(number / 1000000000)
    # console.log "at line 105 number is:  " + number

    ### billion ###

    number -= Gn * 1000000000
    million = Math.floor(number / 1000000)
    # console.log "at line 111 number is:  " + number

    ### million ###

    number -= million * 1000000
    Hn = Math.floor(number / 1000)
    # console.log "at line 117 number is:  " + number

    ### thousand ###

    number -= Hn * 1000
    Dn = Math.floor(number / 100)
    # console.log "at line 123 number is:  " + number

    ### Tens (deca) ###

    number = number % 100
    # console.log "at line 128 number is:  " + number

    ### Ones ###
    tn      = Math.floor(number / 10)
    one     = Math.floor(number % 10)
    # tn = Math.floor(number / 1)
    change  = Math.round((number % 1) * 100)
    res     = ''
    # console.log "before ifs"
    if quintillion > 0
        res += $scope.convert(quintillion) + ' Quintillion'
    if quar > 0
        res += $scope.convert(quar) + ' Quadrillion'
    if trin > 0
        res += $scope.convert(trin) + ' Trillion'
    if Gn > 0
        res += $scope.convert(Gn) + ' Billion'
    if million > 0
        res += (if res == '' then '' else ' ') + $scope.convert(million) + ' Million'
    if Hn > 0
        res += (if res == '' then '' else ' ') + $scope.convert(Hn) + ' Thousand'
    if Dn
        res += (if res == '' then '' else ' ') + $scope.convert(Dn) + ' Hundred'
    # console.log "the result is:  " + res
    ones = Array('', 'One', 'Two', 'Three', 'Four', 'Five', 'Six', 'Seven', 'Eight', 'Nine', 'Ten', 'Eleven', 'Twelve', 'Thirteen', 'Fourteen', 'Fifteen', 'Sixteen', 'Seventeen', 'Eightteen', 'Nineteen')
    tens = Array('', '', 'Twenty', 'Thirty', 'Fourty', 'Fifty', 'Sixty', 'Seventy', 'Eigthy', 'Ninety')
    # console.log "the result at 161 is:  " + res
    if tn > 0 or one > 0
        if !(res == '')
            # res += ' and '
            res += ' '
            # console.log "the result at 164 is:  " + res
        if tn < 2
            res += ones[tn * 10 + one]
            # console.log "the result at 168is:  " + res
        else
            res += tens[tn]
            if one > 0
                res += '-' + ones[one]
            # console.log "the result at 173 is:  " + res
    if change > 0
        if res == ''
            res =  change + "/100"
        else
            res += ' and ' + change + "/100"

    if res == ''
        console.log 'Empty = ' + number
        res = ''
    if +upper == 1
        res = res.toUpperCase()
    $scope.newCheck.amountInWords = res
    return res

$scope.is_numeric = (mixed_var) ->;
# console.log“混合变量是：”+mixed_var
(typeof mix_var == 'number' 或 typeof mix_var == 'string') and mix_var != '' and !isNaN(mixed_var)

Answer 21

这是我的另一个版本，其中包含一些单元测试。

请勿将其与大于 Number.MAX_SAFE_INTEGER 的数字一起使用。

describe("English Numerals Converter", function () {
  assertNumeral(0, "zero");
  assertNumeral(1, "one");
  assertNumeral(2, "two");
  assertNumeral(3, "three");
  assertNumeral(4, "four");
  assertNumeral(5, "five");
  assertNumeral(6, "six");
  assertNumeral(7, "seven");
  assertNumeral(8, "eight");
  assertNumeral(9, "nine");
  assertNumeral(10, "ten");
  assertNumeral(11, "eleven");
  assertNumeral(12, "twelve");
  assertNumeral(13, "thirteen");
  assertNumeral(14, "fourteen");
  assertNumeral(15, "fifteen");
  assertNumeral(16, "sixteen");
  assertNumeral(17, "seventeen");
  assertNumeral(18, "eighteen");
  assertNumeral(19, "nineteen");
  assertNumeral(20, "twenty");
  assertNumeral(21, "twenty-one");
  assertNumeral(22, "twenty-two");
  assertNumeral(23, "twenty-three");
  assertNumeral(30, "thirty");
  assertNumeral(37, "thirty-seven");
  assertNumeral(40, "forty");
  assertNumeral(50, "fifty");
  assertNumeral(60, "sixty");
  assertNumeral(70, "seventy");
  assertNumeral(80, "eighty");
  assertNumeral(90, "ninety");
  assertNumeral(99, "ninety-nine");
  assertNumeral(100, "one hundred");
  assertNumeral(101, "one hundred and one");
  assertNumeral(102, "one hundred and two");
  assertNumeral(110, "one hundred and ten");
  assertNumeral(120, "one hundred and twenty");
  assertNumeral(121, "one hundred and twenty-one");
  assertNumeral(199, "one hundred and ninety-nine");
  assertNumeral(200, "two hundred");
  assertNumeral(999, "nine hundred and ninety-nine");
  assertNumeral(1000, "one thousand");
  assertNumeral(1001, "one thousand and one");
  assertNumeral(1011, "one thousand and eleven");
  assertNumeral(1111, "one thousand and one hundred and eleven");
  assertNumeral(9999, "nine thousand and nine hundred and ninety-nine");
  assertNumeral(10000, "ten thousand");
  assertNumeral(20000, "twenty thousand");
  assertNumeral(21000, "twenty-one thousand");
  assertNumeral(90000, "ninety thousand");
  assertNumeral(90001, "ninety thousand and one");
  assertNumeral(90100, "ninety thousand and one hundred");
  assertNumeral(90901, "ninety thousand and nine hundred and one");
  assertNumeral(90991, "ninety thousand and nine hundred and ninety-one");
  assertNumeral(90999, "ninety thousand and nine hundred and ninety-nine");
  assertNumeral(91000, "ninety-one thousand");
  assertNumeral(99999, "ninety-nine thousand and nine hundred and ninety-nine");
  assertNumeral(100000, "one hundred thousand");
  assertNumeral(999000, "nine hundred and ninety-nine thousand");
  assertNumeral(1000000, "one million");
  assertNumeral(10000000, "ten million");
  assertNumeral(100000000, "one hundred million");
  assertNumeral(1000000000, "one billion");
  assertNumeral(1000000000000, "one trillion");
  assertNumeral(1000000000000000, "one quadrillion");
  assertNumeral(1000000000000000000, "one quintillion");
  assertNumeral(1000000000000000000000, "one sextillion");

  assertNumeral(-1, "minus one");
  assertNumeral(-999, "minus nine hundred and ninety-nine");

  function assertNumeral(number, numeral) {
    it(number + " is " + numeral, function () {
      expect(convert(number)).toBe(numeral);
    });
  }
});


function convert(n) {
  let NUMERALS = [
    {value: 1000000000000000000000, str: "sextillion"},
    {value: 1000000000000000000, str: "quintillion"},
    {value: 1000000000000000, str: "quadrillion"},
    {value: 1000000000000, str: "trillion"},
    {value: 1000000000, str: "billion"},
    {value: 1000000, str: "million"},
    {value: 1000, str: "thousand"},
    {value: 100, str: "hundred"},
    {value: 90, str: "ninety"},
    {value: 80, str: "eighty"},
    {value: 70, str: "seventy"},
    {value: 60, str: "sixty"},
    {value: 50, str: "fifty"},
    {value: 40, str: "forty"},
    {value: 30, str: "thirty"},
    {value: 20, str: "twenty"},
    {value: 19, str: "nineteen"},
    {value: 18, str: "eighteen"},
    {value: 17, str: "seventeen"},
    {value: 16, str: "sixteen"},
    {value: 15, str: "fifteen"},
    {value: 14, str: "fourteen"},
    {value: 13, str: "thirteen"},
    {value: 12, str: "twelve"},
    {value: 11, str: "eleven"},
    {value: 10, str: "ten"},
    {value: 9, str: "nine"},
    {value: 8, str: "eight"},
    {value: 7, str: "seven"},
    {value: 6, str: "six"},
    {value: 5, str: "five"},
    {value: 4, str: "four"},
    {value: 3, str: "three"},
    {value: 2, str: "two"},
    {value: 1, str: "one"}
  ];

  if (n < 0) {
    return "minus " + convert(-n);
  } else if (n === 0) {
    return "zero";
  } else {
    let result = "";
    for (let numeral of NUMERALS) {
      if (n >= numeral.value) {
        if (n < 100) {
          result += numeral.str;
          n -= numeral.value;
          if (n > 0) result += "-";
        } else {
          let times = Math.floor(n / numeral.value);
          result += convert(times) + " " + numeral.str;
          n -= numeral.value * times;
          if (n > 0) result += " and ";
        }
      }
    }
    return result;
  }
}

Answer 22

<script src="http://www.ittutorials.in/js/demo/numtoword.js" type="text/javascript"></script>
    HTML - Convert numbers to words using JavaScript</h1>
<input id="Text1" type="text" onkeypress="return onlyNumbers(this.value);" onkeyup="NumToWord(this.value,'divDisplayWords');"
    maxlength="9" style="background-color: #efefef; border: 2px solid #CCCCC; font-size: large" />
<br />
<br />
<div id="divDisplayWords" style="font-size: 13; color: Teal; font-family: Arial;">
</div>

Answer 23

我想，我有更简单、更容易理解的解决方案；它通过对数字进行切片，最多可达 990 亿卢比。

function convert_to_word(num, ignore_ten_plus_check) {

var ones = [];
var tens = [];
var ten_plus = [];
ones["1"] = "one";
ones["2"] = "two";
ones["3"] = "three";
ones["4"] = "four";
ones["5"] = "five";
ones["6"] = "six";
ones["7"] = "seven";
ones["8"] = "eight";
ones["9"] = "nine";

ten_plus["10"] = "ten";
ten_plus["11"] = "eleven";
ten_plus["12"] = "twelve";
ten_plus["13"] = "thirteen";
ten_plus["14"] = "fourteen";
ten_plus["15"] = "fifteen";
ten_plus["16"] = "sixteen";
ten_plus["17"] = "seventeen";
ten_plus["18"] = "eighteen";
ten_plus["19"] = "nineteen";

tens["1"] = "ten";
tens["2"] = "twenty";
tens["3"] = "thirty";
tens["4"] = "fourty";
tens["5"] = "fifty";
tens["6"] = "sixty";
tens["7"] = "seventy";
tens["8"] = "eighty";
tens["9"] = "ninety";   

    var len = num.length;

    if(ignore_ten_plus_check != true && len >= 2) {
        var ten_pos = num.slice(len - 2, len - 1);
        if(ten_pos == "1") {
            return ten_plus[num.slice(len - 2, len)];
        } else if(ten_pos != 0) {
            return tens[num.slice(len - 2, len - 1)] + " " + ones[num.slice(len - 1, len)];
        }
    }

    return ones[num.slice(len - 1, len)];

}

function get_rupees_in_words(str, recursive_call_count) {
  if(recursive_call_count > 1) {
        return "conversion is not feasible";
    }
    var len = str.length;
    var words = convert_to_word(str, false);
    if(len == 2 || len == 1) {
    if(recursive_call_count == 0) {
        words = words +" rupees";
    }
        return words;
    }
    if(recursive_call_count == 0) {
        words = " and " + words +" rupees";
    }



var hundred = convert_to_word(str.slice(0, len-2), true);
  words = hundred != undefined ? hundred + " hundred " + words : words;
    if(len == 3) {
        return words;
    }

var thousand = convert_to_word(str.slice(0, len-3), false);
words = thousand != undefined ? thousand  + " thousand " + words : words;
if(len <= 5) {
    return words;
}

var lakh = convert_to_word(str.slice(0, len-5), false);
words =  lakh != undefined ? lakh + " lakh " + words : words;
if(len <= 7) {
    return words;
}

recursive_call_count = recursive_call_count + 1;
return get_rupees_in_words(str.slice(0, len-7), recursive_call_count) + " crore " + words;
}

请查看我的代码笔

Answer 24

如果有人想用西班牙语（en español）执行此操作，这是我基于 Hardik 的

function num2str(num, moneda) {
    moneda = moneda || (num !== 1 ? "pesos" : "peso");
    var fraction = Math.round(__cf_frac(num) * 100);
    var f_text = " (" + pad(fraction, 2) + "/100 M.N.)";


    return __cf_convert_number(num) + " " + moneda + f_text;
}

function __cf_frac(f) {
    return f % 1;
}

function __cf_convert_number(number) {
    if ((number < 0) || (number > 999999999)) {
        throw Error("N\u00famero fuera de rango");
    }
    var millon = Math.floor(number / 1000000);
    number -= millon * 1000000;
    var cientosDeMiles = Math.floor(number / 100000);
    number -= cientosDeMiles * 100000;
    var miles = Math.floor(number / 1000);
    number -= miles * 1000;
    var centenas = Math.floor(number / 100);
    number = number % 100;
    var tn = Math.floor(number / 10);
    var one = Math.floor(number % 10);
    var res = "";

    var cientos = Array("", "cien", "doscientos", "trescientos", "cuatrocientos", "quinientos", "seiscientos", "setecientos", "ochocientos", "novecientos");
    if (millon > 0) {
        res += (__cf_convert_number(millon) + (millon === 1 ? " mill\u00f3n" : " millones"));
    }
    if (cientosDeMiles > 0) {
        res += (((res == "") ? "" : " ") +
            cientos[cientosDeMiles] + (miles > 0 || centenas > 0 || tn > 0 || one < 0 ? (cientosDeMiles == 1 ? "to " : " ") : ""));
    }
    if (miles > 0) {
        res += (((res == "") ? "" : " ") +
            __cf_convert_number(miles) + " mil");
    }
    if (centenas) {
        res += (((res == "") ? "" : " ") +
            cientos[centenas] + (tn > 0 || one > 0 ? (centenas > 1 ? " " : "to ") : ""));
    }


    var ones = Array("", "un", "dos", "tres", "cuatro", "cinco", "seis", "siete", "ocho", "nueve", "diez", "once", "doce", "trece", "catorce", "quince", "dieciseis", "diecisiete", "dieciocho", "diecinueve");
    var tens = Array("", "", "veinte", "treinta", "cuarenta", "cincuenta", "sesenta", "setenta", "ochenta", "noventa");

    if (tn > 0 || one > 0) {
        if (tn < 2) {
            res += ones[tn * 10 + one];
        }
        else {
            if (tn === 2 && one > 0)
                res += "veinti" + ones[one];
            else {
                res += tens[tn];
                if (one > 0) {
                    res += (" y " + ones[one]);
                }
            }
        }
    }

    if (res == "") {
        res = "cero";
    }
    return res.replace("  ", " ");
}

function pad(num, largo, char) {
    char = char || '0';
    num = num + '';
    return num.length >= largo ? num : new Array(largo - num.length + 1).join(char) + num;
}

结果的代码：

num2str(123456789)
"ciento veintitres millones cuatrocientos cincuenta y seis mil setecientos ochenta y nueve pesos (00/100 M.N.)"

Answer 25

我在这里提供了我的解决方案，使用单循环字符串三元组 (SLST) 方法将数字转换为等效的英语单词，该方法我已在 Code Review 中发布并通过插图进行了详细解释。

使用JavaScript 中的单循环字符串三元组

这个概念简单且易于编码，而且非常高效和快速。与本文中描述的其他替代方法相比，该代码非常短。

该概念还允许转换非常不同的大数字，因为它不依赖于使用语言的数字/数学函数，因此避免了任何限制。

如果需要，可以通过在“Decillion”之后添加更多比例名称来增加比例数组。

下面提供了一个示例测试函数，以生成 1 到 1099 之间的数字为例。

提供完整的精美版本，可以在刻度和数字之间添加单词“and”和逗号，以与英国和美国的数字拼写方式保持一致。

希望这有用。

/************************************************************/
function NumToWordsInt(NumIn) {
/************************************************************
* Convert Integer Numbers to English Words
* Using the Single Loop String Triplets Method
* @Param : {Number}  The number to be converted
*                    For large numbers use a string
* @Return: {String}  Wordified Number (Number in English Words)
* @Author: Mohsen Alyafei 10 July 2019
* @Notes : Call separately for whole and for fractional parts.
*          Scale Array may be increased by adding more scale
*          names if required after Decillion.
/************************************************************/
  
 if (NumIn==0) return "Zero";
 var  Ones  = ["", "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine", "Ten", "Eleven", "Twelve", "Thirteen", "Fourteen", "Fifteen", "Sixteen", "Seventeen", "Eighteen", "Nineteen"],
      Tens  = ["", "", "Twenty", "Thirty", "Forty", "Fifty", "Sixty", "Seventy", "Eighty", "Ninety"],
      Scale = ["", "Thousand", "Million", "Billion", "Trillion", "Quadrillion", "Quintillion", "Sextillion", "Septillion", "Octillion", "Nonillion", "Decillion"],
      N1, N2, Sep, j, i, h, Trplt, tns="", NumAll = "";
 NumIn += "";                                            // Make NumIn a String
//----------------- code starts -------------------
 NumIn = "0".repeat(NumIn.length * 2 % 3) + NumIn;       //Create shortest string triplets 0 padded
 j = 0;                                                  //Start with the highest triplet from LH
    for (i = NumIn.length / 3 - 1; i >= 0; i--) {        //Loop thru number of triplets from LH most
      Trplt = NumIn.substring(j, j + 3);                 //Get a triplet number starting from LH
      if (Trplt !="000") {                               //Skip empty trplets
        Sep = Trplt[2] !="0" ? "-":" ";                  //Dash only for 21 to 99
        N1 = Number(Trplt[0]);                           //Get Hundreds digit
        N2 = Number(Trplt.substr(1));                    //Get 2 lowest digits (00 to 99) 
        tns = N2 > 19 ? Tens[Number(Trplt[1])] + Sep + Ones[Number(Trplt[2])] : Ones[N2];
        NumAll += ((h = N1>0 ? Ones[N1] + " Hundred": "") + " " + tns).trim() + " " + Scale[i]+ " "; 
      }
      j += 3;                                            //Next lower triplets (move to RH)
    }
//----------------- code Ends --------------------
 return NumAll.trim();                                   //Return trimming excess spaces if any
}



// ----------------- test sample -----------------
console.log(NumToWordsInt(67123))
console.log(NumToWordsInt(120003123))
console.log(NumToWordsInt(123999))
console.log(NumToWordsInt(789123))
console.log(NumToWordsInt(100178912))
console.log(NumToWordsInt(777))
console.log(NumToWordsInt(999999999))
console.log(NumToWordsInt(45))

Answer 26

我知道这个问题已经得到解答，但在看到这个问题之前我一直在研究这个问题。没有在其他答案中发现一些小错误。支持高达vigintillion。

const num_text = num => {
    const ones = {1: "one", 2: "two", 3: "three", 4: "four", 5: "five", 6: "six", 7: "seven", 8: "eight", 9: "nine"}, _tens = ["ten", "eleven", "twelve", "thirteen", "fourteen", "fifteen", "sixteen", "seventeen", "eighteen", "nineteen"], tens = {2: "twenty", 3: "thirty", 4: "forty", 5: "fifty", 6: "sixty", 7: "seventy", 8: "eighty", 9: "ninety"}, above_tens = ["thousand", "million", "billion", "trillion", "quadrillion", "quintillion", "sextillion", "septillion", "octillion", "nonillion", "decillion", "undecillion", "duodecillion", "tredecillion", "quattuordecillion", "quindecillion", "sexdecillion", "septendecillion", "octodecillion", "novemdecillion", "vigintillion"]; 

    var result = []; 

    if (/^0+$/g.test(num)) return "zero"; 

    num = num.replace(/^0+/g, "").split(/(?=(?:...)*$)/); 
    
    for (var count = 0; count < num.length; count++){
        var _result = "", _num = num[count]; 
        
        _num = _num.replace(/^0+/g, ""); 
        if (_num.length == 3){
            _result += ones[_num[0]] + " hundred"; 
            _num = _num.substring(1, 3).replace(/^0+/g, ""); 
            if (_num.length > 0) _result += " and "; 
        }
        if (_num.length == 1){
            _result += ones[_num]; 
        }else if (_num.length == 2){
            if (_num[0] == "1"){
                _result += _tens[_num[1]]; 
            }else if (/.0/g.test(_num)){
                _result += tens[_num[0]]; 
            }else{
                _result += tens[_num[0]] + " " + ones[_num[1]]; 
            }
        }
        
        if (_result != ""){
            if (num.length - count - 2 >= 0) _result += " " + above_tens[num.length - count - 2]; 
            result.push(_result); 
        }
    }

    if (result[result.length - 1].includes("and") || result.length == 1) return result.join(", "); 
    return result.slice(0, result.length - 1).join(", ") + " and " + result[result.length - 1]; 
}

<input id="input">
<button onclick="document.getElementById('result').innerHTML = num_text(document.getElementById('input').value)">Convert</button>
<div id="result"></div>

Answer 27

https://stackoverflow.com/a/69243038/8784402

基于 ES2022 + 最快的 TypeScript 版本

在 Typescript Playground 上测试

印地语版本

class N2WHindi {
  // "शून्य"
  private static readonly zeroTo99: string[] =
    '|एक|दो|तीन|चार|पाँच|छः|सात|आठ|नौ|दश|ग्यारह|बारह|तेरह|चौदह|पन्द्रह|सोलह|सत्रह|अठारह|उन्नीस|बीस|इक्कीस|बाईस|तेईस|चौबीस|पच्चीस|छब्बीस|सत्ताईस|अट्ठाईस|उनतीस|तीस|इकतीस|बत्तीस|तैंतीस|चौंतीस|पैंतीस|छत्तीस|सैंतीस|अड़तीस|उनतालीस|चालीस|इकतालीस|बयालीस|तैंतालीस|चौवालीस|पैंतालीस|छियालीस|सैंतालीस|अड़तालीस|उनचास|पचास|इक्यावन|बावन|तिरपन|चौवन|पचपन|छप्पन|सत्तावन|अट्ठावन|उनसठ|साठ|इकसठ|बासठ|तिरसठ|चौंसठ|पैंसठ|छियासठ|सड़सठ|अड़सठ|उनहत्तर|सत्तर|इकहत्तर|बहत्तर|तिहत्तर|चौहत्तर|पचहत्तर|छिहत्तर|सतहत्तर|अठहत्तर|उन्यासी|अस्सी|इक्यासी|बयासी|तिरासी|चौरासी|पचासी|छियासी|सत्तासी|अट्ठासी|नवासी|नब्बे|इक्यानबे|बानबे|तिरानबे|चौरानबे|पंचानबे|छियानबे|सत्तानबे|अट्ठानबे|निन्यान्बे'.split(
      '|'
    );

  private static readonly place: string[] = 'हज़ार|लाख|करोड़|अरब|खरब|नील'.split('|');

  public static convert(x: string): string {
    let n: number = x.length;
    x = n == 0 ? '00' : n == 1 || n % 2 == 0 ? '0' + x : x;
    n = x.length;
    let r: string = N2WHindi.zeroTo99[x.charCodeAt((n -= 2)) * 10 + x.charCodeAt(n + 1) - 528];
    if (n > 0) {
      const v: string = N2WHindi.zeroTo99[x.charCodeAt((n -= 1)) - 48];
      if (v) r = v + ' सौ ' + r;
    }
    for (let i = 0; n > 0; i++) {
      const v: string = N2WHindi.zeroTo99[x.charCodeAt((n -= 2)) * 10 + x.charCodeAt(n + 1) - 528];
      if (v) r = v + ' ' + N2WHindi.place[i] + (r ? ' ' + r : '');
    }
    return r;
  }
}

印度语 英语版本

class N2WIndian {
  private static readonly zeroTo99: string[] = [];
  private static readonly place: string[] = 'Thousand|Lakh|Crore|Arab|Kharab|Nil'.split('|');

  static {
    const ones: string[] =
      '|One|Two|Three|Four|Five|Six|Seven|Eight|Nine|Ten|Eleven|Twelve|Thirteen|Fourteen|Fifteen|Sixteen|Seventeen|Eighteen|Nineteen'.split(
        '|'
      );

    const tens: string[] = '||Twenty|Thirty|Forty|Fifty|Sixty|Seventy|Eighty|Ninety'.split('|');

    for (let i = 0; i < 100; i++) {
      const t: number = Math.floor(i / 10);
      const o: number = i % 10;
      N2WIndian.zeroTo99.push(t < 2 ? ones[i] : tens[t] + (o ? ' ' + ones[o] : ''));
    }
  }

  public static convert(x: string): string {
    let n: number = x.length;
    x = n == 0 ? '00' : n == 1 || n % 2 == 0 ? '0' + x : x;
    n = x.length;
    let r = N2WIndian.zeroTo99[x.charCodeAt((n -= 2)) * 10 + x.charCodeAt(n + 1) - 528];
    if (n >= 1) {
      const v: string = N2WIndian.zeroTo99[x.charCodeAt((n -= 1)) - 48];
      if (v) r = v + ' Hundred ' + r;
    }
    for (let i = 0; n > 0; i++) {
      const v: string = N2WIndian.zeroTo99[x.charCodeAt((n -= 2)) * 10 + x.charCodeAt(n + 1) - 528];
      if (v) r = v + ' ' + N2WIndian.place[i] + (r ? ' ' + r : '');
    }
    return r;
  }
}

国际版本

class N2WIntl {
  private static readonly zeroTo999: string[] = [];

  private static readonly place =
    '|Thousand|Million|Billion|Trillion|Quadrillion|Quintillion|Sextillion|Septillion|Octillion|Nonillion|Decillion|Undecillion|Duodecillion|Tredecillion|Quattuordecillion|Quindecillion|Sedecillion|Septendecillion|Octodecillion|Novendecillion|Vigintillion|Unvigintillion|Duovigintillion|Tresvigintillion|Quattuorvigintillion|Quinvigintillion|Sesvigintillion|Septemvigintillion|Octovigintillion|Novemvigintillion|Trigintillion|Untrigintillion|Duotrigintillion|Trestrigintillion|Quattuortrigintillion|Quintrigintillion|Sestrigintillion|Septentrigintillion|Octotrigintillion|Noventrigintillion|Quadragintillion'.split(
      '|'
    );

  static {
    const ones =
      '|One|Two|Three|Four|Five|Six|Seven|Eight|Nine|Ten|Eleven|Twelve|Thirteen|Fourteen|Fifteen|Sixteen|Seventeen|Eighteen|Nineteen'.split(
        '|'
      );
    const tens = '||Twenty|Thirty|Forty|Fifty|Sixty|Seventy|Eighty|Ninety'.split('|');
    for (let i = 0; i < 100; i++) {
      const t = Math.floor(i / 10);
      const o = i % 10;
      N2WIntl.zeroTo999[i] = t < 2 ? ones[i] : tens[t] + (o == 0 ? '' : ' ' + ones[o]);
    }
    for (let i = 100; i < 1000; i++) {
      const h = Math.floor(i / 100);
      const t = Math.floor(i / 10) % 10;
      const o = i % 10;
      const r = N2WIntl.zeroTo999[h] + ' Hundred';
      N2WIntl.zeroTo999[i] = t == 0 && o == 0 ? r : r + ' ' + N2WIntl.zeroTo999[t * 10 + o];
    }
  }

  public static convert(x: string): string {
    let n = x.length;
    x = n == 0 ? '000' : ((n % 3 === 1) ? '00' : (n % 3 === 2) ? '0' : '') + x;
    n = x.length;
    let r: string = '';
    for (let i = 0; n > 0; i++) {
      const v: string =
        N2WIntl.zeroTo999[x.charCodeAt((n -= 3)) * 100 + x.charCodeAt(n + 1) * 10 + x.charCodeAt(n + 2) - 5328];
      if (v) r = v + (i ? ' ' + N2WIntl.place[i] : '') + (r ? ' ' + r : '');

    }
    return r;
  }
}

const test = () => {
  {
    let n = 5000000;
    const test: string = '1234567890';
    const t0 = performance.now();
    while (n-- > 0) {
      N2WHindi.convert(test);
    }
    const t1 = performance.now();
    console.log('1234567890 to 5 Million times: ' + (t1 - t0) + 'ms');
    console.log('10^15 -1 :\n' + '9'.repeat(15) + '\n' + N2WHindi.convert('9'.repeat(15)));
  }

  {
    let n = 5000000;
    const test: string = '1234567890';
    const t0 = performance.now();
    while (n-- > 0) {
      N2WIndian.convert(test);
    }
    const t1 = performance.now();
    console.log('1234567890 to 5 Million times: ' + (t1 - t0) + 'ms');
    console.log('10^15 -1 :\n' + '9'.repeat(15) + '\n' + N2WIndian.convert('9'.repeat(15)));
  }

  {
    let n = 5000000;
    const test: string = '1234567890';
    const t0 = performance.now();
    while (n-- > 0) {
      N2WIntl.convert(test);
    }
    const t1 = performance.now();
    console.log('1234567890 to 5 Million times: ' + (t1 - t0) + 'ms');
    console.log('10^126 -1 :\n' + '9'.repeat(126) + '\n' + N2WIntl.convert('9'.repeat(126)));
  }
};

test();

货币转换示例

const [r, p] = "23.54".split('.');
console.log(`${N2WHindi.convert(r)} रुपया और ${N2WHindi.convert(p)} पैसा`)
console.log(`${N2WIndian.convert(r)} Rupees and ${N2WIndian.convert(p)} Paisa`)
console.log(`${N2WIntl.convert(r)} Dollars and ${N2WIntl.convert(p)} Cents`)

Answer 28

这就是我解决这个问题并负责英语和法语等多种语言的方法

    // les nombres en lettres en francais et en anglais de 0 a 99 et les classes (centaine, milliers, ...)
const en_numbers = ["zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten", "eleven", "twelve", "thirteen", "fourteen", "fifteen", "sixteen", "seventeen", "eighteen", "nineteen", "twenty", "twenty-one", "twenty-two", "twenty-three", "twenty-four", "twenty-five", "twenty-six", "twenty-seven", "twenty-eight", "twenty-nine", "thirty", "thirty-one", "thirty-two", "thirty-three", "thirty-four", "thirty-five", "thirty-six", "thirty-seven", "thirty-eight", "thirty-nine", "forty", "forty-one", "forty-two", "forty-three", "forty-four", "forty-five", "forty-six", "forty-seven", "forty-eight", "forty-nine", "fifty", "fifty-one", "fifty-two", "fifty-three", "fifty-four", "fifty-five", "fifty-six", "fifty-seven", "fifty-eight", "fifty-nine", "sixty", "sixty-one", "sixty-two", "sixty-three", "sixty-four", "sixty-five", "sixty-six", "sixty-seven", "sixty-eight", "sixty-nine", "seventy", "seventy-one", "seventy-two", "seventy-three", "seventy-four", "seventy-five", "seventy-six", "seventy-seven", "seventy-eight", "seventy-nine", "eighty", "eighty-one", "eighty-two", "eighty-three", "eighty-four", "eighty-five", "eighty-six", "eighty-seven", "eighty-eight", "eighty-nine", "ninety", "ninety-one", "ninety-two", "ninety-three", "ninety-four", "ninety-five", "ninety-six", "ninety-seven", "ninety-eight", "ninety-nine"];
const fr_numbers = ["zéro", "un", "deux", "trois", "quatre", "cinq", "six", "sept", "huit", "neuf", "dix", "onze", "douze", "treize", "quatorze", "quinze", "seize", "dix-sept", "dix-huit", "dix-neuf", "vingt", "vingt-et-un", "vingt-deux", "vingt-trois", "vingt-quatre", "vingt-cinq", "vingt-six", "vingt-sept", "vingt-huit", "vingt-neuf", "trente", "trente-et-un", "trente-deux", "trente-trois", "trente-quatre", "trente-cinq", "trente-six", "trente-sept", "trente-huit", "trente-neuf", "quarante", "quarante-et-un", "quarante-deux", "quarante-trois", "quarante-quatre", "quarante-cinq", "quarante-six", "quarante-sept", "quarante-huit", "quarante-neuf", "cinquante", "cinquante-et-un", "cinquante-deux", "cinquante-trois", "cinquante-quatre", "cinquante-cinq", "cinquante-six", "cinquante-sept", "cinquante-huit", "cinquante-neuf", "soixante", "soixante-et-un", "soixante-deux", "soixante-trois", "soixante-quatre", "soixante-cinq", "soixante-six", "soixante-sept", "soixante-huit", "soixante-neuf", "soixante-dix", "soixante-et-onze", "soixante-douze", "soixante-treize", "soixante-quatorze", "soixante-quinze", "soixante-seize", "soixante-dix-sept", "soixante-dix-huit", "soixante-dix-neuf", "quatre-vingts", "quatre-vingt-un", "quatre-vingt-deux", "quatre-vingt-trois", "quatre-vingt-quatre", "quatre-vingt-cinq", "quatre-vingt-six", "quatre-vingt-sept", "quatre-vingt-huit", "quatre-vingt-neuf", "quatre-vingt-dix", "quatre-vingt-onze", "quatre-vingt-douze", "quatre-vingt-treize", "quatre-vingt-quatorze", "quatre-vingt-quinze", "quatre-vingt-seize", "quatre-vingt-dix-sept", "quatre-vingt-dix-huit", "quatre-vingt-dix-neuf"];
const en_chunks = ['hundred', 'thousand', 'million', 'billion']; // Extend as needed
const fr_chunks = ['cent', 'mille', 'million', 'milliard']; // Extend as needed

// fonction qui convertis les nombres de 0 a 999 en lettres en francais ou en anglais donc prend en paramettre le nombre et la langue
function hundredToWords(number, lang) {
    number = ''+ number;
    var words = '';

    if (number.length > 2) {
        if (lang === 'fr') {
          if (parseInt(number[0]) > 1) {
            words += fr_numbers[number[0]] + ' ' + fr_chunks[0] + ' ';
          }
          if (parseInt(number[0]) === 1) {
            words +=  fr_chunks[0] + ' ';
          }
          number = parseInt(number) - parseInt(number[0])*100;
        }
        if (lang === 'en') {
          if (parseInt(number[0]) > 1) {
            words += en_numbers[number[0]] + ' ' + en_chunks[0] + ' ';
          }
          if (parseInt(number[0]) === 1) {
            words +=  en_chunks[0] + ' ';
          }
          number = parseInt(number) - parseInt(number[0])*100;
        }
    }
    
    number = ''+number;
    if (number.length > 0 && number.length <= 2) {
        if (parseInt(number) > 0) {
            if (lang === 'fr') {
                words += fr_numbers[parseInt(number)];
            }
            if (lang === 'en') {
                words += en_numbers[parseInt(number)];
            }
        }
    }
    return words;
}
// fonction qui converti tous les nombre de 0 a 999 999 999 999 en lettre en francais ou en anglais
function numberToWords(number, lang) {
    // la langue par defaut est le francais
    if (lang != 'fr' && lang != 'en') { lang = 'fr'}

    if (number === 0) {
        if (lang === 'en') {
           return en_numbers[0];
        }
        if (lang === 'fr') {
           return fr_numbers[0];
        }
    }

    var words = '';
    var milliard = Math.floor(number/1000000000)
    number = number - (milliard*1000000000);
    if (milliard >= 1) {
        if (lang === 'fr') {
            words += hundredToWords(milliard, lang) + ' ' + fr_chunks[3] + ' ';
        }
        if (lang === 'en') {
            words += hundredToWords(milliard, lang) + ' ' + en_chunks[3] + ' ';
        }
    }

    var million = Math.floor(number/1000000)
    number = number - (million*1000000);
    if (million >= 1) {
        if (lang === 'fr') {
            words += hundredToWords(million, lang) + ' ' + fr_chunks[2] + ' ';
        }
        if (lang === 'en') {
            words += hundredToWords(million, lang) + ' ' + en_chunks[2] + ' ';
        }
    }

    var mille = Math.floor(number/1000)
    number = number - (mille*1000);
    if (mille >= 1) {
        if (mille === 1) {
            if (lang === 'fr') {
                words += fr_chunks[1] + ' ';
            }
            if (lang === 'en') {
                words += en_chunks[1] + ' ';
            }
        }else{
            if (lang === 'fr') {
                words += hundredToWords(mille, lang) + ' ' + fr_chunks[1] + ' ';
            }
            if (lang === 'en') {
                words += hundredToWords(mille, lang) + ' ' + en_chunks[1] + ' ';
            }
        }
    }

    if (number >= 1) {
        if (lang === 'fr') {
            words += hundredToWords(number, lang);
        }
        if (lang === 'en') {
            words += hundredToWords(number, lang);
        }
    }

    return words;
}

Answer 29

我认为这会对你有帮助

    aTens = [ "Twenty", "Thirty", "Forty", "Fifty", "Sixty", "Seventy","Eighty", "Ninety"];

    aOnes = [ "Zero", "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine", "Ten", "Eleven", "Twelve", "Thirteen", "Fourteen", "Fifteen", "Sixteen", "Seventeen", "Eighteen", "Nineteen" ];
    var aUnits = "Thousand";
    function convertnumbertostring(){
       var num=prompt('','enter the number');
       var j=6;
       if(num.length<j){
       var y = ConvertToWords(num);
       alert(y);
       }else{
          alert('Enter the number of 5 letters')
       }
    };
    function ConvertToHundreds(num)
    {
       var cNum, nNum;
       var cWords = "";
       if (num > 99) {
          /* Hundreds. */
          cNum = String(num);
          nNum = Number(cNum.charAt(0));
          cWords += aOnes[nNum] + " Hundred";
          num %= 100;
          if (num > 0){
             cWords += " and "
          }
       }

       if (num > 19) {
          /* Tens. */
          cNum = String(num);
          nNum = Number(cNum.charAt(0));
          cWords += aTens[nNum - 2];
          num %= 10;
          if (num > 0){
             cWords += "-";
          }
       }
       if (num > 0) {
          /* Ones and teens. */
          nNum = Math.floor(num);
          cWords += aOnes[nNum];
       }
       return(cWords);

    }
    function ConvertToWords(num)
    {
       var cWords;
       for (var i = 0; num > 0; i++) { 
           if (num % 1000 > 0) {
              if (i != 0){
                 cWords = ConvertToHundreds(num) + " " + aUnits + " " + cWords;
              }else{
                 cWords = ConvertToHundreds(num) + " ";
              }        
           }
           num = (num / 1000);
       }
         return(cWords);
    }