Números JavaScript para Palavras

Estou tentando converter números em palavras inglesas, por exemplo 1234 se tornaria: ” mil duzentos e trinta e quatro “.

Minha tática é assim:

  • Separe os dígitos para três e coloque-os em Array ( finlOutPut ), da direita para a esquerda.

  • Converta cada grupo (cada célula na matriz finlOutPut ) de três dígitos em uma palavra (isso é o que a function triConvert faz). Se todos os três dígitos forem zero, converta-os para "dontAddBigSuffix"

  • Da direita para a esquerda, adicione milhares, milhões, bilhões, etc. Se a célula finlOutPut igual a "dontAddBigSufix" (porque era somente zeros), não adicione a palavra e configure a célula para " " (nada).

Parece funcionar muito bem, mas eu tenho alguns problemas com números como 19000000 9 , convertidos para: ” cento e noventa milhões “. De alguma forma, “esquece” os últimos números quando há alguns zeros.

O que eu fiz errado? Onde está o bug? Por que isso não funciona perfeitamente?

 
 
 

 
 function update () {
     var bigNumArry = new Matriz ('', 'mil', 'milhões', 'bilhão', 'trilhão', 'quadrilhão', 'quintilhão');

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

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

     if (numString == 0) {
         document.getElementById ('container'). innerHTML = 'messeg informa para inserir números';
         Retorna;
     }

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

     // corte o número para grupos de três dígitos e adicione-os ao 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);
         Eu--;
         numString = numString.substring (0, numString.length - 3);
     }
     finlOutPut.push (numString);
     finlOutPut.reverse ();

     // conver cada grupo de três dígitos para a palavra inglesa
     // se todos os dígitos forem zero, o triConvert
     // function retorna a string "dontAddBigSufix"
     para (j = 0; j  = 0; b--) {
         if (finlOutPut [b]! = "dontAddBigSufix") {
             finlOutPut [b] = finlOutPut [b] + bigNumArry [bigScalCntr] + ',';
             bigScalCntr ++;
         }
         outro {
             // substitua a string em finlOP [b] de "dontAddBigSufix" para Empty String.
             finlOutPut [b] = '';
             bigScalCntr ++;  // avança o contador  
         }
     }

         // convert A saída Arry para, mais string imprimível 
         para (n = 0; n <finlOutPut.length; n ++) {
             saída + = finlOutPut [n];
         }

     document.getElementById ('container'). innerHTML = output; // imprime a saída
 }

 // função simples para converter de números para palavras de 1 a 999
 função triConvert (num) {
     var ones = new Matriz ('', 'um', 'dois', 'três', 'quatro', 'cinco', 'seis', 'sete', 'oito', 'nove', 'dez', ' onze, doze, treze, quatorze, quinze, dezesseis, dezessete, dezoito, dezenove;
     var dezenas = new Matriz ('', '', 'vinte', 'trinta', 'quarenta', 'cinquenta', 'sessenta', 'setenta', 'oitenta', 'noventa');
     var cem = 'cem';
     var output = '';
     var numString = num.toString ();

     if (num == 0) {
         return 'dontAddBigSufix';
     }
     // o caso de 10, 11, 12, 13, .... 19 
     if (num <20) {
         output = uns [num];
         retorno de saída;
     }

     // 100 e mais
     if (numString.length == 3) {
         output = ones [parseInt (numString.charAt (0))] + cem;
         saída + = dezenas [parseInt (numString.charAt (1))];
         saída + = ones [parseInt (numString.charAt (2))];
         retorno de saída;
     }

     saída + = dezenas [parseInt (numString.charAt (0))];
     saída + = ones [parseInt (numString.charAt (1))];

     retorno de saída;
 }   
 

 
 

 <input type = "text"
     id = "number"
     size = "70"
     onkeyup = "update ();"
     / * este código evita letras não numéricas * / 
     onkeydown = "return (event.ctrlKey || event.altKey 
                     ||  (47 <event.keyCode && event.keyCode <58 && event.shiftKey == false) 
                     ||  (95 <event.keyCode && event.keyCode  34 && event.keyCode 
                     
Aqui os números são impressos

O JavaScript está analisando o grupo de 3 números como um número octal quando há um dígito zero à esquerda. Quando o grupo de três dígitos é todo zeros, o resultado é o mesmo se a base é octal ou decimal.

Mas quando você dá o JavaScript ‘009’ (ou ‘008’), esse é um número octal inválido, então você recebe zero de volta.

Se você tivesse passado por todo o conjunto de números de 190.000.001 a 190.000.010, você teria visto o JavaScript pular ‘…, 008’ e ‘…, 009’, mas emitir ‘oito’ para ‘…, 010’. Essa é a ‘Eureka!’ momento.

Mudança:

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

para

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

O código também continuou adicionando vírgulas depois de cada grupo diferente de zero, então eu joguei com ele e encontrei o ponto certo para adicionar a vírgula.

Velho:

 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 

Novo:

 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 

Seu problema já está resolvido, mas estou postando outra maneira de fazer isso apenas para referência.

O código foi escrito para ser testado em node.js, mas as funções devem funcionar bem quando chamadas dentro do navegador. Além disso, isso só lida com o intervalo [0,1000000], mas pode ser facilmente adaptado para intervalos maiores.

 #! /usr/bin/env node var sys=require('sys'); // 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 

Eu sei que esse problema havia sido resolvido há 3 anos. Estou postando isso ESPECIALMENTE PARA DESENVOLVEDORES INDIANOS

Depois de passar algum tempo no googling e brincar com os outros códigos eu fiz uma correção rápida e reutilizável funciona bem para números até 99,99,99,999. use: number2text(1234.56); retornará ONE THOUSAND TWO HUNDRED AND THIRTY-FOUR RUPEE AND FIFTY-SIX PAISE ONLY . apreciar !

 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; } 

Há biblioteca JS para en_US e cs_CZ .
Você pode usá-lo independente ou como módulo Node.

  • Numbers2Words
        
Here The Numbers Printed

Aqui escrevi uma solução alternativa:

1) O object contendo as constantes da string:

 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) O código atual:

 (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 ); 

Demonstração ao vivo: http://jsfiddle.net/j5kdG/

Tente isso, converta o número em palavras

 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); } 

Aqui está uma solução que irá lidar com qualquer valor inteiro que caiba em uma string. Eu defini escalas numéricas de até “decillion”, então esta solução deve ser precisa até 999 decillion. Depois disso, você recebe coisas como “mil decillions” e assim por diante.

Os números JavaScript começam a falhar em torno de “999999999999999”, portanto, a function de conversão funciona apenas com strings de números.

Exemplos:

 convert("365"); //=> "three hundred sixty-five" convert("10000000000000000000000000000230001010109"); //=> "ten thousand decillion two hundred thirty billion one million ten thousand one hundred nine" 

Código:

 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; } 
 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; } 

Versão indiana

Versão atualizada da resposta de @jasonhao para moeda indiana

  function intToEnglish(number){ var NS = [ {value: 10000000, str: "Cror"}, {value: 100000, str: "Lakhs"}, {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< =90){ 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; } 

Eu modifiquei a postagem do Šime Vidas – http://jsfiddle.net/j5kdG/ Para include dólares, centavos, vírgulas e “e” nos lugares apropriados. Há um final opcional se requer “zero cents” ou nenhuma menção de centavos se 0.

Esta estrutura de function fez a minha cabeça um pouco, mas aprendi montes. Obrigado Sime.

Alguém pode encontrar uma maneira melhor de processar isso.

Código:

 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 ); 

Eu gostaria de salientar que a lógica original falha por valores entre x11-x19, onde x> = 1. Por exemplo, 118 retorna “cento e oito”. Isso ocorre porque esses números são processados ​​pelo seguinte código em 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; } 

aqui, o caractere que representa o dígito das dezenas é usado para indexar o array tens[] , que tem uma string vazia no índice [1], então 118 se torna 108 em efeito.

Pode ser melhor lidar com as centenas (se houver alguma), depois executar as e as dezenas através da mesma lógica. Ao invés de:

 //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; 

Eu sugeriria:

 // 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; 

Parece-me que o código sugerido é mais curto e mais claro, mas eu posso ser tendencioso 😉

Fonte: http://javascript.about.com/library/bltoword.htm O script mais pequeno que encontrei:

   

Apreciar!

Eu tentei a solução de Muhammad, mas tive alguns problemas e queria usar decimais, então fiz algumas alterações e converti para o café e para o ângulo. Por favor, tenha em mente que js e coffeescript não são meus trajes fortes, então use com cuidado.

 $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 “var variado é:” + mixed_var (tipo de mixed_var == ‘número’ ou tipo de mixed_var == ‘string’) e mixed_var! = ” e! isNaN (mixed_var )

Aqui está outra versão minha com alguns testes de unidade.

Não use com números maiores que 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; } } 

this is the solution for french language it’s a fork for @gandil response

        
Here The Numbers Printed

i hope it will help

  HTML - Convert numbers to words using JavaScript  

This is a simple ES6+ number to words function. You can simply add ‘illions’ array to extend digits. American English version. (no ‘and’ before the end)

 // 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) } 

I think, I have solution that’s simpler and easier to understand; it goes by slicing the number, it works up to 99 lakhs crore.

 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; } 

Please check out my code pen

I think this will help you

  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 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); }