Transform numbers to words in lakh / crore system

Question

I'm writing some code that converts a given number into words, here's what I have got after googling. But I think it's a bit too long for such a simple task. Two Regular Expressions and two for loops, I want something simpler.

I am trying to achieve this in as few lines of code as possible. here's what I've come up with so far:

Any suggestions?

var th = ['','thousand','million', 'billion','trillion'];
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 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) { // 0235
            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,' ');
}

Also, the above code converts to the English numbering system like Million/Billion, I need the South Asian numbering system, like in Lakhs and Crores.

Leporide

codereview.stackexchange.com – Lamellicorn

Converting a number into words isn't exactly the most straightforward of tasks but it can be done using javascript.Your Answer is this . – Wang

possible duplicate of JavaScript numbers to Words – Acrodont

Answer 1

Update: Looks like this is more useful than I thought. I've just published this on npm. https://www.npmjs.com/package/num-words

---

Here's a shorter code. with one RegEx and no loops. converts as you wanted, in south asian numbering system

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

function inWords (num) {
    if ((num = num.toString()).length > 9) return 'overflow';
    n = ('000000000' + num).substr(-9).match(/^(\d{2})(\d{2})(\d{2})(\d{1})(\d{2})$/);
    if (!n) return; var str = '';
    str += (n[1] != 0) ? (a[Number(n[1])] || b[n[1][0]] + ' ' + a[n[1][1]]) + 'crore ' : '';
    str += (n[2] != 0) ? (a[Number(n[2])] || b[n[2][0]] + ' ' + a[n[2][1]]) + 'lakh ' : '';
    str += (n[3] != 0) ? (a[Number(n[3])] || b[n[3][0]] + ' ' + a[n[3][1]]) + 'thousand ' : '';
    str += (n[4] != 0) ? (a[Number(n[4])] || b[n[4][0]] + ' ' + a[n[4][1]]) + 'hundred ' : '';
    str += (n[5] != 0) ? ((str != '') ? 'and ' : '') + (a[Number(n[5])] || b[n[5][0]] + ' ' + a[n[5][1]]) + 'only ' : '';
    return str;
}

document.getElementById('number').onkeyup = function () {
    document.getElementById('words').innerHTML = inWords(document.getElementById('number').value);
};

<span id="words"></span>
<input id="number" type="text" />

The only limitation is, you can convert maximum of 9 digits, which I think is more than sufficient in most cases..

Assort

Why do you group digits two by two? Can you explain that? Testing your function for inWords(973267430) returns **ninety seven crore thirty two lakh sixty seven thousand four hundred and thirty only **. – Brittaney

I'm not sure if I understood you, what do you mean by "Why do you group digits by two?" What else could have been done? In South Asian numbering system, the amount never goes like 100 Thousand. They call it 1 Lakh, so grouping of two makes sense. Btw, what are you expecting as an output for 973267430? – Assort

Angular 4 pipe made with this algorithm: gist.github.com/itsTeknas/97800c238937606df1250fa9ff52737a – Penninite

For those looking for Imperial conventions (using the same method) https://mcmap.net/q/181010/-transform-numbers-to-words-in-lakh-crore-system – Spenserian

here is the live example of this code helpseotools.com/text-tools/number-to-word-converter – Marbles

Whoever using this solution in React, just declare var n; inside inWords() at top. To avoid n is not defined ( if you find ) – Isomerize

Answer 2

"Deceptively simple task." – Potatoswatter

Indeed. There's many little devils hanging out in the details of this problem. It was very fun to solve tho.

EDIT: This update takes a much more compositional approach. Previously there was one big function which wrapped a couple other proprietary functions. Instead, this time we define generic reusable functions which could be used for many varieties of tasks. More about those after we take a look at numToWords itself …

// numToWords :: (Number a, String a) => a -> String
let numToWords = n => {
  let a = [
    '', 'one', 'two', 'three', 'four',
    'five', 'six', 'seven', 'eight', 'nine',
    'ten', 'eleven', 'twelve', 'thirteen', 'fourteen',
    'fifteen', 'sixteen', 'seventeen', 'eighteen', 'nineteen'
  ];
  let b = [
    '', '', 'twenty', 'thirty', 'forty',
    'fifty', 'sixty', 'seventy', 'eighty', 'ninety'
  ];
  let g = [
    '', 'thousand', 'million', 'billion', 'trillion', 'quadrillion',
    'quintillion', 'sextillion', 'septillion', 'octillion', 'nonillion'
  ];
  // this part is really nasty still
  // it might edit this again later to show how Monoids could fix this up
  let makeGroup = ([ones,tens,huns]) => {
    return [
      num(huns) === 0 ? '' : a[huns] + ' hundred ',
      num(ones) === 0 ? b[tens] : b[tens] && b[tens] + '-' || '',
      a[tens+ones] || a[ones]
    ].join('');
  };
  // "thousands" constructor; no real good names for this, i guess
  let thousand = (group,i) => group === '' ? group : `${group} ${g[i]}`;
  // execute !
  if (typeof n === 'number') return numToWords(String(n));
  if (n === '0')             return 'zero';
  return comp (chunk(3)) (reverse) (arr(n))
    .map(makeGroup)
    .map(thousand)
    .filter(comp(not)(isEmpty))
    .reverse()
    .join(' ');
};

Here are the dependencies:

You'll notice these require next to no documentation because their intents are immediately clear. chunk might be the only one that takes a moment to digest, but it's really not too bad. Plus the function name gives us a pretty good indication what it does, and it's probably a function we've encountered before.

const arr = x => Array.from(x);
const num = x => Number(x) || 0;
const str = x => String(x);
const isEmpty = xs => xs.length === 0;
const take = n => xs => xs.slice(0,n);
const drop = n => xs => xs.slice(n);
const reverse = xs => xs.slice(0).reverse();
const comp = f => g => x => f (g (x));
const not = x => !x;
const chunk = n => xs =>
  isEmpty(xs) ? [] : [take(n)(xs), ...chunk (n) (drop (n) (xs))];

"So these make it better?"

Look at how the code has cleaned up significantly

// NEW CODE (truncated)
return comp (chunk(3)) (reverse) (arr(n))
    .map(makeGroup)
    .map(thousand)
    .filter(comp(not)(isEmpty))
    .reverse()
    .join(' ');

// OLD CODE (truncated)
let grp = n => ('000' + n).substr(-3);
let rem = n => n.substr(0, n.length - 3);
let cons = xs => x => g => x ? [x, g && ' ' + g || '', ' ', xs].join('') : xs;
let iter = str => i => x => r => {
  if (x === '000' && r.length === 0) return str;
  return iter(cons(str)(fmt(x))(g[i]))
             (i+1)
             (grp(r))
             (rem(r));
};
return iter('')(0)(grp(String(n)))(rem(String(n)));

Most importantly, the utility functions we added in the new code can be used other places in your app. This means that, as a side effect of implementing numToWords in this way, we get the other functions for free. Bonus soda !

Some tests

console.log(numToWords(11009));
//=> eleven thousand nine

console.log(numToWords(10000001));
//=> ten million one 

console.log(numToWords(987));
//=> nine hundred eighty-seven

console.log(numToWords(1015));
//=> one thousand fifteen

console.log(numToWords(55111222333));
//=> fifty-five billion one hundred eleven million two hundred 
//   twenty-two thousand three hundred thirty-three

console.log(numToWords("999999999999999999999991"));
//=> nine hundred ninety-nine sextillion nine hundred ninety-nine
//   quintillion nine hundred ninety-nine quadrillion nine hundred
//   ninety-nine trillion nine hundred ninety-nine billion nine
//   hundred ninety-nine million nine hundred ninety-nine thousand
//   nine hundred ninety-one

console.log(numToWords(6000753512));
//=> six billion seven hundred fifty-three thousand five hundred
//   twelve 

Runnable demo

const arr = x => Array.from(x);
const num = x => Number(x) || 0;
const str = x => String(x);
const isEmpty = xs => xs.length === 0;
const take = n => xs => xs.slice(0,n);
const drop = n => xs => xs.slice(n);
const reverse = xs => xs.slice(0).reverse();
const comp = f => g => x => f (g (x));
const not = x => !x;
const chunk = n => xs =>
  isEmpty(xs) ? [] : [take(n)(xs), ...chunk (n) (drop (n) (xs))];

// numToWords :: (Number a, String a) => a -> String
let numToWords = n => {
  
  let a = [
    '', 'one', 'two', 'three', 'four',
    'five', 'six', 'seven', 'eight', 'nine',
    'ten', 'eleven', 'twelve', 'thirteen', 'fourteen',
    'fifteen', 'sixteen', 'seventeen', 'eighteen', 'nineteen'
  ];
  
  let b = [
    '', '', 'twenty', 'thirty', 'forty',
    'fifty', 'sixty', 'seventy', 'eighty', 'ninety'
  ];
  
  let g = [
    '', 'thousand', 'million', 'billion', 'trillion', 'quadrillion',
    'quintillion', 'sextillion', 'septillion', 'octillion', 'nonillion'
  ];
  
  // this part is really nasty still
  // it might edit this again later to show how Monoids could fix this up
  let makeGroup = ([ones,tens,huns]) => {
    return [
      num(huns) === 0 ? '' : a[huns] + ' hundred ',
      num(ones) === 0 ? b[tens] : b[tens] && b[tens] + '-' || '',
      a[tens+ones] || a[ones]
    ].join('');
  };
  
  let thousand = (group,i) => group === '' ? group : `${group} ${g[i]}`;
  
  if (typeof n === 'number')
    return numToWords(String(n));
  else if (n === '0')
    return 'zero';
  else
    return comp (chunk(3)) (reverse) (arr(n))
      .map(makeGroup)
      .map(thousand)
      .filter(comp(not)(isEmpty))
      .reverse()
      .join(' ');
};


console.log(numToWords(11009));
//=> eleven thousand nine

console.log(numToWords(10000001));
//=> ten million one 

console.log(numToWords(987));
//=> nine hundred eighty-seven

console.log(numToWords(1015));
//=> one thousand fifteen

console.log(numToWords(55111222333));
//=> fifty-five billion one hundred eleven million two hundred 
//   twenty-two thousand three hundred thirty-three

console.log(numToWords("999999999999999999999991"));
//=> nine hundred ninety-nine sextillion nine hundred ninety-nine
//   quintillion nine hundred ninety-nine quadrillion nine hundred
//   ninety-nine trillion nine hundred ninety-nine billion nine
//   hundred ninety-nine million nine hundred ninety-nine thousand
//   nine hundred ninety-one

console.log(numToWords(6000753512));
//=> six billion seven hundred fifty-three thousand five hundred
//   twelve

---

You can transpile the code using babel.js if you want to see the ES5 variant

Lakin

the number 6000753512 yields a string that starts with six billion million, which is not correct in english. – Congeal

@FranzPayer thanks for pointing out the bug. I patched the cons function accordingly. – Lakin

@naomik Would it be possible to expand the variables to meaningful names? I want to understand how this works, but I can't get past the confusing variable names. – Leanneleanor

@naomik This in great! I especially liked that you posted the ES6 source code. I should note for readers that in "en-US" 40 is spelled "forty". – Miserable

Here is a function to use with the toWords function above if you have a string with a mix of words and numbers and you want to convert all the numbers in the string to words: text = text.replace(/(\d+)/g, function (number) { return(toWords(number)) }); – Quietly

Awesome! However the function leaves an extra space at the end – Imposing

@Leanneleanor ah, somehow I never saw your comment. I'm sorry. I will try to expand this for you later today. I see a couple improvements I think I can make too ^_^ – Lakin

@HurricaneDevelopment thanks for the notice. I'll look into it later tonight or tomorrow – Lakin

@Leanneleanor I updated the answer to use some more idiomatic functional patterns. You'll be delighted to see that the readability is greatly improved. – Lakin

@naomik take/drop are the best namings for slice I've seen so far. It makes clear that slice actually consists of two functions. Actually four if you count head and tail. – Pantelleria

@ftor what about init and last too? I've never found a good way to implement those. init([1,2,3,4]) //=> [1,2,3] and last([1,2,3,4]) //=> 4 – Lakin

I added it to the number prototype like this: jsfiddle.net/mdibbets/fk6nq8xp/3 so I could use it more easely with autocomplete ^^ – Unassuming

Answer 3

I spent a while developing a better solution to this. It can handle very big numbers but once they get over 16 digits you have pass the number in as a string. Something about the limit of JavaScript numbers.

    function numberToEnglish( n ) {
        
        var string = n.toString(), units, tens, scales, start, end, chunks, chunksLen, chunk, ints, i, word, words, and = 'and';

        /* Remove spaces and commas */
        string = string.replace(/[, ]/g,"");

        /* Is number zero? */
        if( parseInt( string ) === 0 ) {
            return 'zero';
        }
        
        /* Array of units as words */
        units = [ '', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine', 'ten', 'eleven', 'twelve', 'thirteen', 'fourteen', 'fifteen', 'sixteen', 'seventeen', 'eighteen', 'nineteen' ];
        
        /* Array of tens as words */
        tens = [ '', '', 'twenty', 'thirty', 'forty', 'fifty', 'sixty', 'seventy', 'eighty', 'ninety' ];
        
        /* Array of scales as words */
        scales = [ '', 'thousand', 'million', 'billion', 'trillion', 'quadrillion', 'quintillion', 'sextillion', 'septillion', 'octillion', 'nonillion', 'decillion', 'undecillion', 'duodecillion', 'tredecillion', 'quatttuor-decillion', 'quindecillion', 'sexdecillion', 'septen-decillion', 'octodecillion', 'novemdecillion', 'vigintillion', 'centillion' ];
        
        /* Split user argument into 3 digit chunks from right to left */
        start = string.length;
        chunks = [];
        while( start > 0 ) {
            end = start;
            chunks.push( string.slice( ( start = Math.max( 0, start - 3 ) ), end ) );
        }
        
        /* Check if function has enough scale words to be able to stringify the user argument */
        chunksLen = chunks.length;
        if( chunksLen > scales.length ) {
            return '';
        }
        
        /* Stringify each integer in each chunk */
        words = [];
        for( i = 0; i < chunksLen; i++ ) {
            
            chunk = parseInt( chunks[i] );
            
            if( chunk ) {
                
                /* Split chunk into array of individual integers */
                ints = chunks[i].split( '' ).reverse().map( parseFloat );
            
                /* If tens integer is 1, i.e. 10, then add 10 to units integer */
                if( ints[1] === 1 ) {
                    ints[0] += 10;
                }
                
                /* Add scale word if chunk is not zero and array item exists */
                if( ( word = scales[i] ) ) {
                    words.push( word );
                }
                
                /* Add unit word if array item exists */
                if( ( word = units[ ints[0] ] ) ) {
                    words.push( word );
                }
                
                /* Add tens word if array item exists */
                if( ( word = tens[ ints[1] ] ) ) {
                    words.push( word );
                }
                
                /* Add 'and' string after units or tens integer if: */
                if( ints[0] || ints[1] ) {
                    
                    /* Chunk has a hundreds integer or chunk is the first of multiple chunks */
                    if( ints[2] || ! i && chunksLen ) {
                        words.push( and );
                    }
                
                }
                
                /* Add hundreds word if array item exists */
                if( ( word = units[ ints[2] ] ) ) {
                    words.push( word + ' hundred' );
                }
                
            }
            
        }
        
        return words.reverse().join( ' ' );
        
    }


// - - - - - Tests - - - - - -
function test(v) {
  var sep = ('string'==typeof v)?'"':'';
  console.log("numberToEnglish("+sep + v.toString() + sep+") = "+numberToEnglish(v));
}
test(2);
test(721);
test(13463);
test(1000001);
test("21,683,200,000,621,384");

Elveraelves

Hmm, your and logic is wrong for 1<=n<100 e.g. numberToEnglish(2) returns and two. Luckily it seems to work without them, just comment out // words.push( and ); -- English is quite happy with or without them. :) – Yusuk

I used this one and it worked great. The "and 2" problem I got around by changing the logic slightly if( ints[2] || (i + 1) < chunksLen ) { words.push( and ); and = ''; } This only adds one and – Anguiano

Answer 4

You might want to try it recursive. It works for numbers between 0 and 999999. Keep in mind that (~~) does the same as Math.floor

var num = "zero one two three four five six seven eight nine ten eleven twelve thirteen fourteen fifteen sixteen seventeen eighteen nineteen".split(" ");
var tens = "twenty thirty forty fifty sixty seventy eighty ninety".split(" ");

function number2words(n){
    if (n < 20) return num[n];
    var digit = n%10;
    if (n < 100) return tens[~~(n/10)-2] + (digit? "-" + num[digit]: "");
    if (n < 1000) return num[~~(n/100)] +" hundred" + (n%100 == 0? "": " " + number2words(n%100));
    return number2words(~~(n/1000)) + " thousand" + (n%1000 != 0? " " + number2words(n%1000): "");
}

Empathize

An improvement would be to add the word 'and' eg. (n%100 == 0? "": " and " + number2words(n%100)); – Keating

Hey @juan, thank you for this snippet. I have modified this a bit here => jsfiddle.net/Rohith_KP/s92fbpgm The modification will show the decimal part as a fraction. eg: 164.8 => One hundred and Sixty Four Dollars and 80/100 – Cordle

Answer 5

I like the result I got here which i think is easy to read and short enough to fit as a solution.

function NumInWords (number) {
  const first = ['','one ','two ','three ','four ', 'five ','six ','seven ','eight ','nine ','ten ','eleven ','twelve ','thirteen ','fourteen ','fifteen ','sixteen ','seventeen ','eighteen ','nineteen '];
  const tens = ['', '', 'twenty','thirty','forty','fifty', 'sixty','seventy','eighty','ninety'];
  const mad = ['', 'thousand', 'million', 'billion', 'trillion'];
  let word = '';

  for (let i = 0; i < mad.length; i++) {
    let tempNumber = number%(100*Math.pow(1000,i));
    if (Math.floor(tempNumber/Math.pow(1000,i)) !== 0) {
      if (Math.floor(tempNumber/Math.pow(1000,i)) < 20) {
        word = first[Math.floor(tempNumber/Math.pow(1000,i))] + mad[i] + ' ' + word;
      } else {
        word = tens[Math.floor(tempNumber/(10*Math.pow(1000,i)))] + '-' + first[Math.floor(tempNumber/Math.pow(1000,i))%10] + mad[i] + ' ' + word;
      }
    }

    tempNumber = number%(Math.pow(1000,i+1));
    if (Math.floor(tempNumber/(100*Math.pow(1000,i))) !== 0) word = first[Math.floor(tempNumber/(100*Math.pow(1000,i)))] + 'hunderd ' + word;
  }
    return word;
}

console.log(NumInWords(89754697976431))

And the result is :

eighty-nine trillion seven hundred fifty-four billion six hundred ninety-seven million nine hundred seventy-six thousand four hundred thirty-one

Sundial

Great answer. A previous workplace used this exact question during interviews as a frontal coding examination. Well done mate! – Thoracoplasty

"hunderd" is a typo. – Stemware

Answer 6

 <html>

<head>

    <title>HTML - Convert numbers to words using JavaScript</title>

    <script  type="text/javascript">
    	function onlyNumbers(evt) {
    var e = event || evt; // For trans-browser compatibility
    var charCode = e.which || e.keyCode;

    if (charCode > 31 && (charCode < 48 || charCode > 57))
        return false;
    return true;
}

function NumToWord(inputNumber, outputControl) {
    var str = new String(inputNumber)
    var splt = str.split("");
    var rev = splt.reverse();
    var once = ['Zero', ' One', ' Two', ' Three', ' Four', ' Five', ' Six', ' Seven', ' Eight', ' Nine'];
    var twos = ['Ten', ' Eleven', ' Twelve', ' Thirteen', ' Fourteen', ' Fifteen', ' Sixteen', ' Seventeen', ' Eighteen', ' Nineteen'];
    var tens = ['', 'Ten', ' Twenty', ' Thirty', ' Forty', ' Fifty', ' Sixty', ' Seventy', ' Eighty', ' Ninety'];

    numLength = rev.length;
    var word = new Array();
    var j = 0;

    for (i = 0; i < numLength; i++) {
        switch (i) {

            case 0:
                if ((rev[i] == 0) || (rev[i + 1] == 1)) {
                    word[j] = '';
                }
                else {
                    word[j] = '' + once[rev[i]];
                }
                word[j] = word[j];
                break;

            case 1:
                aboveTens();
                break;

            case 2:
                if (rev[i] == 0) {
                    word[j] = '';
                }
                else if ((rev[i - 1] == 0) || (rev[i - 2] == 0)) {
                    word[j] = once[rev[i]] + " Hundred ";
                }
                else {
                    word[j] = once[rev[i]] + " Hundred and";
                }
                break;

            case 3:
                if (rev[i] == 0 || rev[i + 1] == 1) {
                    word[j] = '';
                }
                else {
                    word[j] = once[rev[i]];
                }
                if ((rev[i + 1] != 0) || (rev[i] > 0)) {
                    word[j] = word[j] + " Thousand";
                }
                break;

                
            case 4:
                aboveTens();
                break;

            case 5:
                if ((rev[i] == 0) || (rev[i + 1] == 1)) {
                    word[j] = '';
                }
                else {
                    word[j] = once[rev[i]];
                }
                if (rev[i + 1] !== '0' || rev[i] > '0') {
                    word[j] = word[j] + " Lakh";
                }
                 
                break;

            case 6:
                aboveTens();
                break;

            case 7:
                if ((rev[i] == 0) || (rev[i + 1] == 1)) {
                    word[j] = '';
                }
                else {
                    word[j] = once[rev[i]];
                }
                if (rev[i + 1] !== '0' || rev[i] > '0') {
                    word[j] = word[j] + " Crore";
                }                
                break;

            case 8:
                aboveTens();
                break;

            //            This is optional. 

            //            case 9:
            //                if ((rev[i] == 0) || (rev[i + 1] == 1)) {
            //                    word[j] = '';
            //                }
            //                else {
            //                    word[j] = once[rev[i]];
            //                }
            //                if (rev[i + 1] !== '0' || rev[i] > '0') {
            //                    word[j] = word[j] + " Arab";
            //                }
            //                break;

            //            case 10:
            //                aboveTens();
            //                break;

            default: break;
        }
        j++;
    }

    function aboveTens() {
        if (rev[i] == 0) { word[j] = ''; }
        else if (rev[i] == 1) { word[j] = twos[rev[i - 1]]; }
        else { word[j] = tens[rev[i]]; }
    }

    word.reverse();
    var finalOutput = '';
    for (i = 0; i < numLength; i++) {
        finalOutput = finalOutput + word[i];
    }
    document.getElementById(outputControl).innerHTML = finalOutput;
}
    </script>

</head>

<body>

    <h1>

        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>

</body>

</html>

Intrauterine

Answer 7

I modified MC Shaman's code to fix the bug of single number having and appear before it

function numberToEnglish( n ) {
        
    var string = n.toString(), units, tens, scales, start, end, chunks, chunksLen, chunk, ints, i, word, words, and = 'and';

    /* Remove spaces and commas */
    string = string.replace(/[, ]/g,"");

    /* Is number zero? */
    if( parseInt( string ) === 0 ) {
        return 'zero';
    }
    
    /* Array of units as words */
    units = [ '', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine', 'ten', 'eleven', 'twelve', 'thirteen', 'fourteen', 'fifteen', 'sixteen', 'seventeen', 'eighteen', 'nineteen' ];
    
    /* Array of tens as words */
    tens = [ '', '', 'twenty', 'thirty', 'forty', 'fifty', 'sixty', 'seventy', 'eighty', 'ninety' ];
    
    /* Array of scales as words */
    scales = [ '', 'thousand', 'million', 'billion', 'trillion', 'quadrillion', 'quintillion', 'sextillion', 'septillion', 'octillion', 'nonillion', 'decillion', 'undecillion', 'duodecillion', 'tredecillion', 'quatttuor-decillion', 'quindecillion', 'sexdecillion', 'septen-decillion', 'octodecillion', 'novemdecillion', 'vigintillion', 'centillion' ];
    
    /* Split user argument into 3 digit chunks from right to left */
    start = string.length;
    chunks = [];
    while( start > 0 ) {
        end = start;
        chunks.push( string.slice( ( start = Math.max( 0, start - 3 ) ), end ) );
    }
    
    /* Check if function has enough scale words to be able to stringify the user argument */
    chunksLen = chunks.length;
    if( chunksLen > scales.length ) {
        return '';
    }
    
    /* Stringify each integer in each chunk */
    words = [];
    for( i = 0; i < chunksLen; i++ ) {
        
        chunk = parseInt( chunks[i] );
        
        if( chunk ) {
            
            /* Split chunk into array of individual integers */
            ints = chunks[i].split( '' ).reverse().map( parseFloat );
        
            /* If tens integer is 1, i.e. 10, then add 10 to units integer */
            if( ints[1] === 1 ) {
                ints[0] += 10;
            }
            
            /* Add scale word if chunk is not zero and array item exists */
            if( ( word = scales[i] ) ) {
                words.push( word );
            }
            
            /* Add unit word if array item exists */
            if( ( word = units[ ints[0] ] ) ) {
                words.push( word );
            }
            
            /* Add tens word if array item exists */
            if( ( word = tens[ ints[1] ] ) ) {
                words.push( word );
            }
            
            /* Add 'and' string after units or tens integer if: */
            if( ints[0] || ints[1] ) {
                
                /* Chunk has a hundreds integer or chunk is the first of multiple chunks */
                if( ints[2] || (i + 1) > chunksLen ) {
                    words.push( and );
                }

            
            }
            
            /* Add hundreds word if array item exists */
            if( ( word = units[ ints[2] ] ) ) {
                words.push( word + ' hundred' );
            }
            
        }
        
    }
    
    return words.reverse().join( ' ' );
    
}


// - - - - - Tests - - - - - -

function figure(val) {
  finalFig = numberToEnglish(val);
  document.getElementById("words").innerHTML = finalFig;
}

<span id="words"></span>
<input id="number" type="text" onkeyup=figure(this.value)  />

Preemie

five hundred and twelve thousand one hundred and twenty one for 512121. ??? – Korman

int_to_words(000011) returns 9 another answer did the same, I realise it isn't exactly what is expected but to a human that is 11 instantly – Arleenarlen

Answer 8

Update February 2021

Although this question is raised over 8 years ago with various solutions and answers, the easiest solution that can be easily updated to increase the scale by just inserting a name in the array without code modification; and also using very short code is the function below.

This solution is for the English reading of numbers (not the South-Asian System) and uses the standard US English (American way) of writing large numbers. i.e. it does not use the UK System (the UK system uses the word "and" like: "three hundred and twenty-two thousand").

Test cases are provided and also an input field.

Remember, it is "Unsigned Integers" that we are converting to words.

You can increase the scale[] array beyond Sextillion.

As the function is short, you can use it as an internal function in, say, currency conversion where decimal numbers are used and call it twice for the whole part and the fractional part.

Hope it is useful.

/********************************************************
* @function    : integerToWords()
* @purpose     : Converts Unsigned Integers to Words
*                Using String Triplet Array.
* @version     : 1.05
* @author      : Mohsen Alyafei
* @date        : 15 January 2021
* @param       : {number} [integer numeric or string]
* @returns     : {string} The wordified number string
********************************************************/
const 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","Hundred"],
      Scale = ["","Thousand","Million","Billion","Trillion","Quadrillion","Quintillion","Sextillion"];
//==================================
const integerToWords = (n = 0) => {
if (n == 0) return "Zero";                                   // check for zero
n = ("0".repeat(2*(n+="").length % 3) + n).match(/.{3}/g);   // create triplets array
if (n.length > Scale.length) return "Too Large";             // check if larger than scale array
let out= ""; return n.forEach((Triplet,pos) => {             // loop into array for each triplet
if (+Triplet) { out+=' ' +(+Triplet[0] ? Ones[+Triplet[0]]+' '+ Tens[10] : "") +
      ' ' + (+Triplet.substr(1)< 20 ? Ones[+Triplet.substr(1)] :
             Tens[+Triplet[1]] + (+Triplet[2] ? "-" : "") + Ones[+Triplet[2]]) +
      ' ' +  Scale[n.length-pos-1]; }
}),out.replace(/\s+/g,' ').trim();};                         // lazy job using trim()
//==================================








//=========================================
//             Test Cases
//=========================================
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");
r |= test("1000000000000000000","One Quintillion");
r |= test("1000000100100100100","One Quintillion One Hundred Billion One Hundred Million One Hundred Thousand One Hundred");

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

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

<input type="text" name="number" placeholder="Please enter an Integer Number" onkeyup="word.innerHTML=integerToWords(this.value)" />
<div id="word"></div>

Masked

Answer 9

TypeScript Version Based on ES2022 + Fastest

Test on Typescript Playground

Hindi Version

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 ? ' ' + 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 || 'शून्य';
  }
}

Indian English Version

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 ? ' ' + 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 || 'Zero';
  }
}

International Version

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 = '';
    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 || 'Zero';
  }
}

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

Example

N2WHindi.convert('122356')
'एक लाख बाईस हज़ार तीन सौ छप्पन'

N2WIndian.convert('122356')
'One Lakh Twenty Two Thousand Three Hundred Fifty Six'

N2WIntl.convert('122356')
'One Hundred Twenty Two Thousand Three Hundred Fifty Six'

Example to convert currency

const [r, p] = "23.54".split('.');

`${N2WHindi.convert(r)} रुपया और ${N2WHindi.convert(p)} पैसा`
'तेईस रुपया और चौवन पैसा'

`${N2WIndian.convert(r)} Rupees and ${N2WIndian.convert(p)} Paisa`
'Twenty Three Rupees and Fifty Four Paisa'

`${N2WIntl.convert(r)} Dollars and ${N2WIntl.convert(p)} Cents`
'Twenty Three Dollars and Fifty Four Cents'

Ching

this doesnt handle decimal points – Audsley

@Audsley yes, but If you convert into string and and split by . (decimal) then convert both to number name then join – Ching

Answer 10

Converting the input string into a number rather than keeping it as a string, limits the solution to the maximum allowed float / integer value on that machine/browser. My script below handles currency up to 1 Trillion dollars - 1 cent :-). I can be extended to handle up to 999 Trillions by adding 3 or 4 lines of code.

var ones = ["","One","Two","Three","Four","Five","Six","Seven","Eight",
            "Nine","Ten","Eleven","Twelve","Thirteen","Fourteen",
            "Fifteen","Sixteen","Seventeen","Eighteen","Nineteen"]; 

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


function words999(n999)   {    // n999 is an integer less than or equal to 999.
//
// Accept any 3 digit int incl 000 & 999 and return words.
// 

    var words = ''; var Hn = 0; var n99 = 0;

    Hn = Math.floor(n999 / 100);                  // # of hundreds in it

    if (Hn > 0)   {                               // if at least one 100

      words = words99(Hn) + " Hundred";           // one call for hundreds
    }

    n99 = n999 - (Hn * 100);                      // subtract the hundreds.

    words += ((words == '')?'':' ') + words99(n99); // combine the hundreds with tens & ones.

    return words;
}                            // function words999( n999 )

function words99(n99)   {    // n99 is an integer less than or equal to 99.
//
// Accept any 2 digit int incl 00 & 99 and return words.
// 

    var words = ''; var Dn = 0; var Un = 0;

    Dn = Math.floor(n99 / 10);           // # of tens

    Un = n99 % 10;                       // units

    if (Dn > 0 || Un > 0) {

      if (Dn < 2) {

        words += ones[Dn * 10 + Un];     // words for a # < 20

      } else {

        words += tens[Dn];

        if (Un > 0) words += "-" + ones[Un];
      }
    }                               // if ( Dn > 0 || Un > 0 )

    return words;
}                                   // function words99( n99 )

function getAmtInWords(id1, id2) {  // use numeric value of id1 to populate text in id2 
//
// Read numeric amount field and convert into word amount
// 

    var t1 = document.getElementById(id1).value;

    var t2 = t1.trim();

    amtStr = t2.replace(/,/g,'');        // $123,456,789.12 = 123456789.12

    dotPos = amtStr.indexOf('.');        // position of dot before cents, -ve if it doesn't exist.

    if (dotPos > 0) {

      dollars = amtStr.slice(0,dotPos);  // 1234.56 = 1234
      cents   = amtStr.slice(dotPos+1);  // 1234.56 = .56

    } else if (dotPos == 0) {

      dollars = '0';
      cents   = amtStr.slice(dotPos+1);  // 1234.56 = .56

    } else {

      dollars = amtStr.slice(0);         // 1234 = 1234
      cents   = '0'; 
    }

    t1      = '000000000000' + dollars;  // to extend to trillion, use 15 zeros
    dollars =  t1.slice(-12);            // and -15 here.

    billions  = Number(dollars.substr(0,3));
    millions  = Number(dollars.substr(3,3));
    thousands = Number(dollars.substr(6,3));
    hundreds  = Number(dollars.substr(9,3));

    t1 = words999(billions);    bW = t1.trim();   // Billions  in words

    t1 = words999(millions);    mW = t1.trim();   // Millions  in words

    t1 = words999(thousands);   tW = t1.trim();   // Thousands in words

    t1 = words999(hundreds);    hW = t1.trim();   // Hundreds  in words

    t1 = words99(cents);        cW = t1.trim();   // Cents     in words

    var totAmt = '';

    if (bW != '')   totAmt += ((totAmt != '') ? ' '  : '') + bW + ' Billion';
    if (mW != '')   totAmt += ((totAmt != '') ? ' '  : '') + mW + ' Million';
    if (tW != '')   totAmt += ((totAmt != '') ? ' '  : '') + tW + ' Thousand';
    if (hW != '')   totAmt += ((totAmt != '') ? ' '  : '') + hW + ' Dollars';

    if (cW != '')   totAmt += ((totAmt != '') ? ' and ' : '') + cW + ' Cents';

//  alert('totAmt = ' + totAmt);    // display words in a alert

    t1 = document.getElementById(id2).value;

    t2 = t1.trim();

    if (t2 == '')  document.getElementById(id2).value = totAmt;

    return false;
}                        // function getAmtInWords( id1, id2 )

// ======================== [ End Code ] ====================================

Coley

Answer 11

If you need with Cent then you may use this one

        <script>
            var iWords = ['zero', ' one', ' two', ' three', ' four', ' five', ' six', ' seven', ' eight', ' nine'];
            var ePlace = ['ten', ' eleven', ' twelve', ' thirteen', ' fourteen', ' fifteen', ' sixteen', ' seventeen', ' eighteen', ' nineteen'];
            var tensPlace = ['', ' ten', ' twenty', ' thirty', ' forty', ' fifty', ' sixty', ' seventy', ' eighty', ' ninety'];
            var inWords = [];

            var numReversed, inWords, actnumber, i, j;

            function tensComplication() {
            if (actnumber[i] == 0) {
                inWords[j] = '';
            } else if (actnumber[i] == 1) {
                inWords[j] = ePlace[actnumber[i - 1]];
            } else {
                inWords[j] = tensPlace[actnumber[i]];
            }
            }

            function convertAmount() {
                var numericValue = document.getElementById('bdt').value;
                numericValue = parseFloat(numericValue).toFixed(2);

                var amount = numericValue.toString().split('.');
                var taka = amount[0];
                var paisa = amount[1];
                document.getElementById('container').innerHTML = convert(taka) +" taka and "+ convert(paisa)+" paisa only";
            }
            function convert(numericValue) {
            inWords = []
            if(numericValue == "00" || numericValue =="0"){
                return 'zero';
            }
            var obStr = numericValue.toString();
            numReversed = obStr.split('');
            actnumber = numReversed.reverse();


            if (Number(numericValue) == 0) {
                document.getElementById('container').innerHTML = 'BDT Zero';
                return false;
            }

            var iWordsLength = numReversed.length;
            var finalWord = '';
            j = 0;
            for (i = 0; i < iWordsLength; i++) {
                switch (i) {
                    case 0:
                        if (actnumber[i] == '0' || actnumber[i + 1] == '1') {
                            inWords[j] = '';
                        } else {
                            inWords[j] = iWords[actnumber[i]];
                        }
                        inWords[j] = inWords[j] + '';
                        break;
                    case 1:
                        tensComplication();
                        break;
                    case 2:
                        if (actnumber[i] == '0') {
                            inWords[j] = '';
                        } else if (actnumber[i - 1] !== '0' && actnumber[i - 2] !== '0') {
                            inWords[j] = iWords[actnumber[i]] + ' hundred';
                        } else {
                            inWords[j] = iWords[actnumber[i]] + ' hundred';
                        }
                        break;
                    case 3:
                        if (actnumber[i] == '0' || actnumber[i + 1] == '1') {
                            inWords[j] = '';
                        } else {
                            inWords[j] = iWords[actnumber[i]];
                        }
                        if (actnumber[i + 1] !== '0' || actnumber[i] > '0') {
                            inWords[j] = inWords[j] + ' thousand';
                        }
                        break;
                    case 4:
                        tensComplication();
                        break;
                    case 5:
                        if (actnumber[i] == '0' || actnumber[i + 1] == '1') {
                            inWords[j] = '';
                        } else {
                            inWords[j] = iWords[actnumber[i]];
                        }
                        if (actnumber[i + 1] !== '0' || actnumber[i] > '0') {
                            inWords[j] = inWords[j] + ' lakh';
                        }
                        break;
                    case 6:
                        tensComplication();
                        break;
                    case 7:
                        if (actnumber[i] == '0' || actnumber[i + 1] == '1') {
                            inWords[j] = '';
                        } else {
                            inWords[j] = iWords[actnumber[i]];
                        }
                        inWords[j] = inWords[j] + ' crore';
                        break;
                    case 8:
                        tensComplication();
                        break;
                    default:
                        break;
                }
                j++;
            }


            inWords.reverse();
            for (i = 0; i < inWords.length; i++) {
                finalWord += inWords[i];
            }
            return finalWord;
            }

        </script>

        <input type="text" name="bdt" id="bdt" />
        <input type="button" name="sr1" value="Click Here" onClick="convertAmount()"/>

        <div id="container"></div>

js fiddle

Here taka mean USD and paisa mean cent

Fryd

Answer 12

This is in response to @LordZardeck's comment to @naomik's excellent answer above. Sorry, I would've commented directly but I've never posted before so I don't have the privilege to do so, so I am posting here instead.

Anyhow, I just happened to translate the ES5 version to a more readable form this past weekend so I'm sharing it here. This should be faithful to the original (including the recent edit) and I hope the naming is clear and accurate.

function int_to_words(int) {
  if (int === 0) return 'zero';

  var ONES  = ['','one','two','three','four','five','six','seven','eight','nine','ten','eleven','twelve','thirteen','fourteen','fifteen','sixteen','seventeen','eighteen','nineteen'];
  var TENS  = ['','','twenty','thirty','fourty','fifty','sixty','seventy','eighty','ninety'];
  var SCALE = ['','thousand','million','billion','trillion','quadrillion','quintillion','sextillion','septillion','octillion','nonillion'];

  // Return string of first three digits, padded with zeros if needed
  function get_first(str) {
    return ('000' + str).substr(-3);
  }

  // Return string of digits with first three digits chopped off
  function get_rest(str) {
    return str.substr(0, str.length - 3);
  }

  // Return string of triplet convereted to words
  function triplet_to_words(_3rd, _2nd, _1st) {
    return (_3rd == '0' ? '' : ONES[_3rd] + ' hundred ') + (_1st == '0' ? TENS[_2nd] : TENS[_2nd] && TENS[_2nd] + '-' || '') + (ONES[_2nd + _1st] || ONES[_1st]);
  }

  // Add to words, triplet words with scale word
  function add_to_words(words, triplet_words, scale_word) {
    return triplet_words ? triplet_words + (scale_word && ' ' + scale_word || '') + ' ' + words : words;
  }

  function iter(words, i, first, rest) {
    if (first == '000' && rest.length === 0) return words;
    return iter(add_to_words(words, triplet_to_words(first[0], first[1], first[2]), SCALE[i]), ++i, get_first(rest), get_rest(rest));
  }

  return iter('', 0, get_first(String(int)), get_rest(String(int)));
}

Superior

wow, I'm sorry to have missed this post when it was made. Thank you so much for doing this. – Lakin

console.log(int_to_words(000011)) returns 9 – Arleenarlen

Answer 13

var inWords = function(totalRent){
//console.log(totalRent);
var a = ['','one ','two ','three ','four ', 'five ','six ','seven ','eight ','nine ','ten ','eleven ','twelve ','thirteen ','fourteen ','fifteen ','sixteen ','seventeen ','eighteen ','nineteen '];
var b = ['', '', 'twenty','thirty','forty','fifty', 'sixty','seventy','eighty','ninety'];
var number = parseFloat(totalRent).toFixed(2).split(".");
var num = parseInt(number[0]);
var digit = parseInt(number[1]);
//console.log(num);
if ((num.toString()).length > 9)  return 'overflow';
var n = ('000000000' + num).substr(-9).match(/^(\d{2})(\d{2})(\d{2})(\d{1})(\d{2})$/);
var d = ('00' + digit).substr(-2).match(/^(\d{2})$/);;
if (!n) return; var str = '';
str += (n[1] != 0) ? (a[Number(n[1])] || b[n[1][0]] + ' ' + a[n[1][1]]) + 'crore ' : '';
str += (n[2] != 0) ? (a[Number(n[2])] || b[n[2][0]] + ' ' + a[n[2][1]]) + 'lakh ' : '';
str += (n[3] != 0) ? (a[Number(n[3])] || b[n[3][0]] + ' ' + a[n[3][1]]) + 'thousand ' : '';
str += (n[4] != 0) ? (a[Number(n[4])] || b[n[4][0]] + ' ' + a[n[4][1]]) + 'hundred ' : '';
str += (n[5] != 0) ? (a[Number(n[5])] || b[n[5][0]] + ' ' + a[n[5][1]]) + 'Rupee ' : '';
str += (d[1] != 0) ? ((str != '' ) ? "and " : '') + (a[Number(d[1])] || b[d[1][0]] + ' ' + a[d[1][1]]) + 'Paise ' : 'Only!';
console.log(str);
return str;
}

This is modified code supports for Indian Rupee with 2 decimal place.

Destructible

Answer 14

Below are the translations from

• integer to word
• float to word
• money to word

Test cases are at the bottom

var ONE_THOUSAND = Math.pow(10, 3);
var ONE_MILLION = Math.pow(10, 6);
var ONE_BILLION = Math.pow(10, 9);
var ONE_TRILLION = Math.pow(10, 12);
var ONE_QUADRILLION = Math.pow(10, 15);
var ONE_QUINTILLION = Math.pow(10, 18);

function integerToWord(integer) {
  var prefix = '';
  var suffix = '';

  if (!integer){ return "zero"; }
  
  if(integer < 0){
    prefix = "negative";
    suffix = integerToWord(-1 * integer);
    return prefix + " " + suffix;
  }
  if(integer <= 90){
    switch (integer) {
      case integer < 0:
        prefix = "negative";
        suffix = integerToWord(-1 * integer);
        return prefix + " "  + suffix;
      case 1: return "one";
      case 2: return "two";
      case 3: return "three";
      case 4:  return "four";
      case 5: return "five";
      case 6: return "six";
      case 7: return "seven";
      case 8: return "eight";
      case 9: return "nine";
      case 10: return "ten";
      case 11: return "eleven";
      case 12: return "twelve";
      case 13: return "thirteen";
      case 14: return "fourteen";
      case 15: return "fifteen";
      case 16: return "sixteen";
      case 17: return "seventeen";
      case 18: return "eighteen";
      case 19: return "nineteen";
      case 20: return "twenty";
      case 30: return "thirty";
      case 40: return "forty";
      case 50: return "fifty";
      case 60: return "sixty";
      case 70: return "seventy";
      case 80: return "eighty";
      case 90: return "ninety";
      default: break;
    }
  }

  if(integer < 100){
    prefix = integerToWord(integer - integer % 10);
    suffix = integerToWord(integer % 10);
    return prefix + "-"  + suffix;
  }

  if(integer < ONE_THOUSAND){
    prefix = integerToWord(parseInt(Math.floor(integer / 100), 10) )  + " hundred";
    if (integer % 100){ suffix = " and "  + integerToWord(integer % 100); }
    return prefix + suffix;
  }

  if(integer < ONE_MILLION){
    prefix = integerToWord(parseInt(Math.floor(integer / ONE_THOUSAND), 10))  + " thousand";
    if (integer % ONE_THOUSAND){ suffix = integerToWord(integer % ONE_THOUSAND); }
  }
  else if(integer < ONE_BILLION){
    prefix = integerToWord(parseInt(Math.floor(integer / ONE_MILLION), 10))  + " million";
    if (integer % ONE_MILLION){ suffix = integerToWord(integer % ONE_MILLION); }
  }
  else if(integer < ONE_TRILLION){
    prefix = integerToWord(parseInt(Math.floor(integer / ONE_BILLION), 10))  + " billion";
    if (integer % ONE_BILLION){ suffix = integerToWord(integer % ONE_BILLION); }
  }
  else if(integer < ONE_QUADRILLION){
    prefix = integerToWord(parseInt(Math.floor(integer / ONE_TRILLION), 10))  + " trillion";
    if (integer % ONE_TRILLION){ suffix = integerToWord(integer % ONE_TRILLION); }
  }
  else if(integer < ONE_QUINTILLION){
    prefix = integerToWord(parseInt(Math.floor(integer / ONE_QUADRILLION), 10))  + " quadrillion";
    if (integer % ONE_QUADRILLION){ suffix = integerToWord(integer % ONE_QUADRILLION); }
  } else {
    return '';
  }
  return prefix + " "  + suffix;
}

function moneyToWord(value){
  var decimalValue = (value % 1);
  var integer = value - decimalValue;
  decimalValue = Math.round(decimalValue * 100);
  var decimalText = !decimalValue? '': integerToWord(decimalValue) + ' cent' + (decimalValue === 1? '': 's');
  var integerText= !integer? '': integerToWord(integer) + ' dollar' + (integer === 1? '': 's');
  return (
    integer && !decimalValue? integerText:
    integer && decimalValue? integerText + ' and ' + decimalText:
    !integer && decimalValue? decimalText:
    'zero cents'
  );
}

function floatToWord(value){
  var decimalValue = (value % 1);
  var integer = value - decimalValue;
  decimalValue = Math.round(decimalValue * 100);
  var decimalText = !decimalValue? '':
    decimalValue < 10? "point o' " + integerToWord(decimalValue):
    decimalValue % 10 === 0? 'point ' + integerToWord(decimalValue / 10):
    'point ' + integerToWord(decimalValue);
  return (
    integer && !decimalValue? integerToWord(integer):
    integer && decimalValue? [integerToWord(integer),  decimalText].join(' '):
    !integer && decimalValue? decimalText:
    integerToWord(0)
  );
}

// test
(function(){
  console.log('integerToWord ==================================');
  for(var i = 0; i < 101; ++i){
    console.log('%s=%s', i, integerToWord(i));
  }
  console.log('floatToWord ====================================');
  i = 131;
  while(i--){
    console.log('%s=%s', i / 100, floatToWord(i / 100));
  }
  console.log('moneyToWord ====================================');
  for(i = 0; i < 131; ++i){
    console.log('%s=%s', i / 100, moneyToWord(i / 100));
  }
}());

Snapshot

Answer 15

Another conversion that uses remainders and supports different languages:

function numberToWords(number) {
  var result = [];

  var fraction = number.toFixed(2).split('.');
  var integer_part = parseInt(fraction[0]);
  // var fractional_part = parseInt(fraction[1]); -- not handled here

  var previousNumber = null;
  for (var i = 0; i < fraction[0].length; i++) {
    var reminder = Math.floor(integer_part % 10);
    integer_part /= 10;
    var name = getNumberName(reminder, i, fraction[0].length, previousNumber);
    previousNumber = reminder;
    if (name)
      result.push(name);
  }

  result.reverse();
  return result.join(' ');
}

The getNumberName function is language-dependent and handles numbers up to 9999 (but it is easy to extend it to handle larger numbers):

function getNumberName(number, power, places, previousNumber) {
  var result = "";
  if (power == 1) {
    result = handleTeensAndTys(number, previousNumber);
  } else if (power == 0 && places != 1 || number == 0) {
    // skip number that was handled in teens and zero
  } else {
    result = locale.numberNames[number.toString()] + locale.powerNames[power.toString()];
  }

  return result;
}

handleTeensAndTys handles multiples of ten:

function handleTeensAndTys(number, previousNumber) {
  var result = "";
  if (number == 1) { // teens
    if (previousNumber in locale.specialTeenNames) {
      result = locale.specialTeenNames[previousNumber];    
    } else if (previousNumber in locale.specialTyNames) {
      result = locale.specialTyNames[previousNumber] + locale.teenSuffix;
    } else {
      result = locale.numberNames[previousNumber] + locale.teenSuffix;    
    }
  } else if (number == 0) { // previousNumber was not handled in teens
    result = locale.numberNames[previousNumber.toString()];
  } else { // other tys
    if (number in locale.specialTyNames) {
      result = locale.specialTyNames[number];
    } else {
      result = locale.numberNames[number];
    }
    result += locale.powerNames[1];
    if (previousNumber != 0) {
      result += " " + locale.numberNames[previousNumber.toString()];
    }
  }
  return result;
}

Finally, locale examples:

var locale = { // English
  numberNames: {1: "one", 2: "two", 3: "three", 4: "four", 5: "five", 6: "six", 7: "seven", 8: "eight", 9: "nine" },
  powerNames: {0: "", 1: "ty", 2: " hundred", 3: " thousand" },
  specialTeenNames: {0: "ten", 1: "eleven", 2: "twelve" },
  specialTyNames: {2: "twen", 3: "thir", 5: "fif" },
  teenSuffix: "teen"
};

var locale = { // Estonian
  numberNames: {1: "üks", 2: "kaks", 3: "kolm", 4: "neli", 5: "viis", 6: "kuus", 7: "seitse", 8: "kaheksa", 9: "üheksa"},
  powerNames: {0: "", 1: "kümmend", 2: "sada", 3: " tuhat" },
  specialTeenNames: {0: "kümme"},
  specialTyNames: {},
  teenSuffix: "teist"
};

Here's a JSFiddle with tests: https://jsfiddle.net/rcrxna7v/15/

Carlile

Answer 16

Function that will work with decimal values also

function amountToWords(amountInDigits){
    // American Numbering System
    var th = ['','thousand','million', 'billion','trillion'];

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

      return toWords(amountInDigits);
  }

<input type="text" name="number" placeholder="Number OR Amount" onkeyup="word.innerHTML=amountToWords(this.value)" />
<div id="word"></div>

Valerianaceous

Answer 17

I modified @McShaman's code, converted it to CoffeeScript, and added docs via JSNice. Here's the result, for those interested (English):

###
    Convert an integer to an English string equivalent
    @param {Integer} number the integer to be converted
    @return {String} the English number equivalent
###
inWords = (number) ->
    ###
        @property {Array}
    ###
    englishIntegers = [
        ""
        "one "
        "two "
        "three "
        "four "
        "five "
        "six "
        "seven "
        "eight "
        "nine "
        "ten "
        "eleven "
        "twelve "
        "thirteen "
        "fourteen "
        "fifteen "
        "sixteen "
        "seventeen "
        "eighteen "
        "nineteen "
    ]

    ###
        @property {Array}
    ###
    englishIntegerTens = [
        ""
        ""
        "twenty"
        "thirty"
        "forty"
        "fifty"
        "sixty"
        "seventy"
        "eighty"
        "ninety"
    ]

    ###
        @property {Array}
    ###
    englishIntegerThousands = [
        "thousand"
        "million"
        ""
    ]
    number = number.toString()
    return "" if number.length > 9

    ###
        @property {string}
    ###
    number = ("000000000" + number).substr(-9)

    ###
      @property {(Array.<string>|null)}
      ###
    number = number.match(/.{3}/g)

    ###
        @property {string}
    ###
    convertedWords = ""

    ###
        @property {number}
    ###
    i = 0
    while i < englishIntegerThousands.length

        ###
            @property {string}
        ###
        currentNumber = number[i]

        ###
            @property {string}
        ###
        tempResult = ""
        tempResult += (if convertedWords isnt "" then " " + englishIntegerThousands[i] + " " else "")
        tempResult += (if currentNumber[0] isnt 0 then englishIntegers[Number(currentNumber[0])] + "hundred " else "")

        ###
            @property {string}
        ###
        currentNumber = currentNumber.substr(1)
        tempResult += (if currentNumber isnt 0 then ((if tempResult isnt "" then "and " else "")) + (englishIntegers[Number(currentNumber)] or englishIntegerTens[currentNumber[0]] + " " + englishIntegers[currentNumber[1]]) else "")
        convertedWords += tempResult
        i++
    convertedWords

Erratum

Answer 18

Though, this question has been answered - still I want to share something I recently developed in java script (based on the logic of an old C#. Net implementation I found in Internet) for converting Indian currency values to Words. It can handle up to 40 digits. You can have a look.

Usage: InrToWordConverter.Initialize();. var inWords = InrToWordConverter.ConvertToWord(amount);

Implementation:

htPunctuation = {};
listStaticSuffix = {};
listStaticPrefix = {};
listHelpNotation = {};

var InrToWordConverter = function () {

};

InrToWordConverter.Initialize = function () {
    InrToWordConverter.LoadStaticPrefix();
    InrToWordConverter.LoadStaticSuffix();
    InrToWordConverter.LoadHelpofNotation();
};

InrToWordConverter.ConvertToWord = function (value) {
    value = value.toString();

    if (value) {
        var tokens = value.split(".");
        var rsPart = "";
        var psPart = "";
        if (tokens.length === 2) {
            rsPart = String.trim(tokens[0]) || "0";
            psPart = String.trim(tokens[1]) || "0";
        }
        else if (tokens.length === 1) {
            rsPart = String.trim(tokens[0]) || "0";
            psPart = "0";
        }
        else {
            rsPart = "0";
            psPart = "0";
        }

        htPunctuation = {};
        var rsInWords = InrToWordConverter.ConvertToWordInternal(rsPart) || "Zero";
        var psInWords = InrToWordConverter.ConvertToWordInternal(psPart) || "Zero";

        var result = "Rupees " + rsInWords + "and " + psInWords + " Paise.";
        return result;
    }
};

InrToWordConverter.ConvertToWordInternal = function (value) {
    var convertedString = "";
    if (!(value.toString().length > 40))
    {
        if (InrToWordConverter.IsNumeric(value.toString()))
        {
            try
            {
                var strValue = InrToWordConverter.Reverse(value);
                switch (strValue.length)
                {
                    case 1:
                        if (parseInt(strValue.toString()) > 0) {
                            convertedString = InrToWordConverter.GetWordConversion(value);
                        }
                        else {
                            convertedString = "Zero ";
                        }
                        break;
                    case 2:
                        convertedString = InrToWordConverter.GetWordConversion(value);
                        break;
                    default:
                        InrToWordConverter.InsertToPunctuationTable(strValue);
                        InrToWordConverter.ReverseHashTable();
                        convertedString = InrToWordConverter.ReturnHashtableValue();
                        break;
                }
            }
            catch (exception) {
                convertedString = "Unexpected Error Occured <br/>";
            }
        }
        else {
            convertedString = "Please Enter Numbers Only, Decimal Values Are not supported";
        }
    }
    else {
        convertedString = "Please Enter Value in Less Then or Equal to 40 Digit";
    }
    return convertedString;
};

InrToWordConverter.IsNumeric = function (valueInNumeric) {
    var isFine = true;
    valueInNumeric = valueInNumeric || "";
    var len = valueInNumeric.length;
    for (var i = 0; i < len; i++) {
        var ch = valueInNumeric[i];
        if (!(ch >= '0' && ch <= '9')) {
            isFine = false;
            break;
        }
    }
    return isFine;
};

InrToWordConverter.ReturnHashtableValue = function () {
    var strFinalString = "";
    var keysArr = [];
    for (var key in htPunctuation) {
        keysArr.push(key);
    }
    for (var i = keysArr.length - 1; i >= 0; i--) {
        var hKey = keysArr[i];
        if (InrToWordConverter.GetWordConversion((htPunctuation[hKey]).toString()) !== "") {
            strFinalString = strFinalString + InrToWordConverter.GetWordConversion((htPunctuation[hKey]).toString()) + InrToWordConverter.StaticPrefixFind((hKey).toString());
        }
    }
    return strFinalString;
};

InrToWordConverter.ReverseHashTable = function () {
    var htTemp = {};
    for (var key in htPunctuation) {
        var item = htPunctuation[key];
        htTemp[key] = InrToWordConverter.Reverse(item.toString());
    }
    htPunctuation = {};
    htPunctuation = htTemp;
};

InrToWordConverter.InsertToPunctuationTable = function (strValue) {
    htPunctuation[1] = strValue.substr(0, 3).toString();
    var j = 2;
    for (var i = 3; i < strValue.length; i = i + 2) {
        if (strValue.substr(i).length > 0) {
            if (strValue.substr(i).length >= 2) {
                htPunctuation[j] = strValue.substr(i, 2).toString();
            }
            else {
                htPunctuation[j] = strValue.substr(i, 1).toString();
            }
        }
        else {
            break;
        }
        j++;

    }
};

InrToWordConverter.Reverse = function (strValue) {
    var reversed = "";
    for (var i in strValue) {
        var ch = strValue[i];
        reversed = ch + reversed;
    }
    return reversed;
};

InrToWordConverter.GetWordConversion = function (inputNumber) {
    var toReturnWord = "";
    if (inputNumber.length <= 3 && inputNumber.length > 0) {
        if (inputNumber.length === 3) {
            if (parseInt(inputNumber.substr(0, 1)) > 0) {
                toReturnWord = toReturnWord + InrToWordConverter.StaticSuffixFind(inputNumber.substr(0, 1)) + "Hundred ";
            }

            var tempString = InrToWordConverter.StaticSuffixFind(inputNumber.substr(1, 2));

            if (tempString === "")
            {
                toReturnWord = toReturnWord + InrToWordConverter.StaticSuffixFind(inputNumber.substr(1, 1) + "0");
                toReturnWord = toReturnWord + InrToWordConverter.StaticSuffixFind(inputNumber.substr(2, 1));
            }
            toReturnWord = toReturnWord + tempString;
        }
        if (inputNumber.length === 2)
        {
            var tempString = InrToWordConverter.StaticSuffixFind(inputNumber.substr(0, 2));
            if (tempString === "")
            {
                toReturnWord = toReturnWord + InrToWordConverter.StaticSuffixFind(inputNumber.substr(0, 1) + "0");
                toReturnWord = toReturnWord + InrToWordConverter.StaticSuffixFind(inputNumber.substr(1, 1));
            }
            toReturnWord = toReturnWord + tempString;
        }
        if (inputNumber.length === 1)
        {
            toReturnWord = toReturnWord + InrToWordConverter.StaticSuffixFind(inputNumber.substr(0, 1));
        }

    }
    return toReturnWord;
};

InrToWordConverter.StaticSuffixFind = function (numberKey) {
    var valueFromNumber = "";
    for (var key in listStaticSuffix) {
        if (String.trim(key.toString()) === String.trim(numberKey)) {
            valueFromNumber = listStaticSuffix[key].toString();
            break;
        }
    }
    return valueFromNumber;
};

InrToWordConverter.StaticPrefixFind = function (numberKey) {
    var valueFromNumber = "";
    for (var key in listStaticPrefix) {
        if (String.trim(key) === String.trim(numberKey)) {
            valueFromNumber = listStaticPrefix[key].toString();
            break;
        }
    }
    return valueFromNumber;
};

InrToWordConverter.StaticHelpNotationFind = function (numberKey) {
    var helpText = "";
    for (var key in listHelpNotation) {
        if (String.trim(key.toString()) === String.trim(numberKey)) {
            helpText = listHelpNotation[key].toString();
            break;
        }
    }
    return helpText;
};

InrToWordConverter.LoadStaticPrefix = function () {
    listStaticPrefix[2] = "Thousand ";
    listStaticPrefix[3] = "Lac ";
    listStaticPrefix[4] = "Crore ";
    listStaticPrefix[5] = "Arab ";
    listStaticPrefix[6] = "Kharab ";
    listStaticPrefix[7] = "Neel ";
    listStaticPrefix[8] = "Padma ";
    listStaticPrefix[9] = "Shankh ";
    listStaticPrefix[10] = "Maha-shankh ";
    listStaticPrefix[11] = "Ank ";
    listStaticPrefix[12] = "Jald ";
    listStaticPrefix[13] = "Madh ";
    listStaticPrefix[14] = "Paraardha ";
    listStaticPrefix[15] = "Ant ";
    listStaticPrefix[16] = "Maha-ant ";
    listStaticPrefix[17] = "Shisht ";
    listStaticPrefix[18] = "Singhar ";
    listStaticPrefix[19] = "Maha-singhar ";
    listStaticPrefix[20] = "Adant-singhar ";
};

InrToWordConverter.LoadStaticSuffix = function () {
    listStaticSuffix[1] = "One ";
    listStaticSuffix[2] = "Two ";
    listStaticSuffix[3] = "Three ";
    listStaticSuffix[4] = "Four ";
    listStaticSuffix[5] = "Five ";
    listStaticSuffix[6] = "Six ";
    listStaticSuffix[7] = "Seven ";
    listStaticSuffix[8] = "Eight ";
    listStaticSuffix[9] = "Nine ";
    listStaticSuffix[10] = "Ten ";
    listStaticSuffix[11] = "Eleven ";
    listStaticSuffix[12] = "Twelve ";
    listStaticSuffix[13] = "Thirteen ";
    listStaticSuffix[14] = "Fourteen ";
    listStaticSuffix[15] = "Fifteen ";
    listStaticSuffix[16] = "Sixteen ";
    listStaticSuffix[17] = "Seventeen ";
    listStaticSuffix[18] = "Eighteen ";
    listStaticSuffix[19] = "Nineteen ";
    listStaticSuffix[20] = "Twenty ";
    listStaticSuffix[30] = "Thirty ";
    listStaticSuffix[40] = "Fourty ";
    listStaticSuffix[50] = "Fifty ";
    listStaticSuffix[60] = "Sixty ";
    listStaticSuffix[70] = "Seventy ";
    listStaticSuffix[80] = "Eighty ";
    listStaticSuffix[90] = "Ninty ";
};

InrToWordConverter.LoadHelpofNotation = function () {
    listHelpNotation[2] = "=1,000 (3 Trailing Zeros)";
    listHelpNotation[3] = "=1,00,000 (5 Trailing Zeros)";
    listHelpNotation[4] = "=1,00,00,000 (7 Trailing Zeros)";
    listHelpNotation[5] = "=1,00,00,00,000 (9 Trailing Zeros)";
    listHelpNotation[6] = "=1,00,00,00,00,000 (11 Trailing Zeros)";
    listHelpNotation[7] = "=1,00,00,00,00,00,000 (13 Trailing Zeros)";
    listHelpNotation[8] = "=1,00,00,00,00,00,00,000 (15 Trailing Zeros)";
    listHelpNotation[9] = "=1,00,00,00,00,00,00,00,000 (17 Trailing Zeros)";
    listHelpNotation[10] = "=1,00,00,00,00,00,00,00,00,000 (19 Trailing Zeros)";
    listHelpNotation[11] = "=1,00,00,00,00,00,00,00,00,00,000 (21 Trailing Zeros)";
    listHelpNotation[12] = "=1,00,00,00,00,00,00,00,00,00,00,000 (23 Trailing Zeros)";
    listHelpNotation[13] = "=1,00,00,00,00,00,00,00,00,00,00,00,000 (25 Trailing Zeros)";
    listHelpNotation[14] = "=1,00,00,00,00,00,00,00,00,00,00,00,00,000 (27 Trailing Zeros)";
    listHelpNotation[15] = "=1,00,00,00,00,00,00,00,00,00,00,00,00,00,000 (29 Trailing Zeros)";
    listHelpNotation[16] = "=1,00,00,00,00,00,00,00,00,00,00,00,00,00,00,000 (31 Trailing Zeros)";
    listHelpNotation[17] = "=1,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,000 (33 Trailing Zeros)";
    listHelpNotation[18] = "=1,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,000 (35 Trailing Zeros)";
    listHelpNotation[19] = "=1,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,000 (37 Trailing Zeros)";
    listHelpNotation[20] = "=1,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,000 (39 Trailing Zeros)";
};
    if (!String.trim) {
    String.trim = function (str) {
        var result = "";
        var firstNonWhiteSpaceFound = false;
        var startIndex = -1;
        var endIndex = -1;
        if (str) {
            for (var i = 0; i < str.length; i++) {
                if (firstNonWhiteSpaceFound === false) {
                    if (str[i] === ' ' || str[i] === '\t') {
                        continue;
                    }
                    else {
                        firstNonWhiteSpaceFound = true;
                        startIndex = i;
                        endIndex = i;
                    }
                }
                else {
                    if (str[i] === ' ' || str[i] === '\t') {
                        continue;
                    }
                    else {
                        endIndex = i;
                    }
                }
            }
            if (startIndex !== -1 && endIndex !== -1) {
                result = str.slice(startIndex, endIndex + 1);
            }
        }
        return result;
    };
}

Teufert

You forgot to paste in the link properly. – Flowering

Answer 19

Try this code with a Turkish currency compliant JavaScript

function dene() {
         var inpt = document.getElementById("tar1").value;
         var spt = inpt.split('');
         spt.reverse();

         var tek = ["", "Bir", "İki", "Üç", "Dört", "Beş", "Altı", "Yedi", "Sekiz", "Dokuz"];
         var onlu = ["", "On", "Yirmi", "Otuz", "Kırk", "Elli", "Atmış", "Yetmiş", "Seksen", "Doksan"];
         var Yuz = ["", "Yüz", "İkiYüz", "Üçyüz", "DörtYüz", "BeşYüz", "AltıYüz", "YediYüz", "SekizYüz", "DokuzYüz"];
         var ska = ["", "", "", "", "Bin", "Milyon", "Milyar", "Trilyon", "Katrilyon", "Kentilyon"];
         var i, j;
         var bas3 = "";
         var bas6 = "";
         var bas9 = "";
         var bas12 = "";
         var total;

               for(i = 0; i < 1; i++) {

                      bas3 += Yuz[spt[i+2]] + onlu[spt[i+1]] + tek[spt[i]];
                      bas6 += Yuz[spt[i+5]] + onlu[spt[i+4]] + tek[spt[i+3]] + ska[4];
                      bas9 += Yuz[spt[i+8]] + onlu[spt[i+7]] + tek[spt[i+6]] + ska[5];
                      bas12 += Yuz[spt[i+11]] + onlu[spt[i+10]] + tek[spt[i+9]] + ska[6];


                   if(inpt.length < 4) {
                       bas6 = '';
                       bas9 = '';
                   }
                   if(inpt.length > 6 && inpt.slice(5, 6) == 0) {
                     bas6 = bas6.replace(/Bin/g, '');
                   }
                   if(inpt.length < 7) {
                       bas9 = '';
                   } 
                   if(inpt.length > 9 && inpt.slice(1,3) == 000){
                       bas9 = bas9.replace(/Milyon/g, '');
                   }

                   if(inpt.length < 10) {
                    bas12 = '';
                 }
             }

         total = bas12 + bas9 + bas6 + bas3;
         total = total.replace(NaN, '');
         total = total.replace(undefined, '');

        document.getElementById('demo').innerHTML = 
            total;


     }

Numerator

Sorry, this does not answer the question – Falsity

Answer 20

Lot of good answers. I needed mine for Indian (South Asian) numbering system. I modified one of the codes above - attaching it here, in case, someone else needs this. In the Indian numbering system, groups after thousands are in in 2 digits, not 3 as in the western system.

var IS_SOUTH_ASIAN = true;
function int_to_words(int) {
  if (int === 0) return 'zero';

  var ONES_WORD  = ['','one','two','three','four','five','six','seven','eight','nine','ten','eleven','twelve','thirteen','fourteen','fifteen','sixteen','seventeen','eighteen','nineteen'];
  var TENS_WORD  = ['','','twenty','thirty','fourty','fifty','sixty','seventy','eighty','ninety'];
  var SCALE_WORD_WESTERN = ['','thousand','million','billion','trillion','quadrillion','quintillion','sextillion','septillion','octillion','nonillion'];
  var SCALE_WORD_SOUTH_ASIAN = ['','thousand','lakh','crore','arab','kharab','neel','padma','shankh','***','***'];

  var GROUP_SIZE = (typeof IS_SOUTH_ASIAN != "undefined" && IS_SOUTH_ASIAN) ? 2 : 3;
  var SCALE_WORD = (typeof IS_SOUTH_ASIAN != "undefined" && IS_SOUTH_ASIAN) ? SCALE_WORD_SOUTH_ASIAN : SCALE_WORD_WESTERN;


  // Return string of first three digits, padded with zeros if needed
  function get_first_3(str) {
    return ('000' + str).substr(-(3));
  }
  function get_first(str) { //-- Return string of first GROUP_SIZE digits, padded with zeros if needed, if group size is 2, make it size 3 by prefixing with a '0'
    return (GROUP_SIZE == 2 ? '0' : '') + ('000' + str).substr(-(GROUP_SIZE));
  }


  // Return string of digits with first three digits chopped off
  function get_rest_3(str) {
    return str.substr(0, str.length - 3);
  }
  function get_rest(str) { // Return string of digits with first GROUP_SIZE digits chopped off
    return str.substr(0, str.length - GROUP_SIZE);
  }

  // Return string of triplet convereted to words
  function triplet_to_words(_3rd, _2nd, _1st) {
    return  (_3rd == '0' ? '' : ONES_WORD[_3rd] + ' hundred ') + 
            (_1st == '0' ? TENS_WORD[_2nd] : TENS_WORD[_2nd] && TENS_WORD[_2nd] + '-' || '') + 
            (ONES_WORD[_2nd + _1st] || ONES_WORD[_1st]);  //-- 1st one returns one-nineteen - second one returns one-nine
  }

  // Add to result, triplet words with scale word
  function add_to_result(result, triplet_words, scale_word) {
    return triplet_words ? triplet_words + (scale_word && ' ' + scale_word || '') + ' ' + result : result;
  }

  function recurse (result, scaleIdx, first, rest) {
    if (first == '000' && rest.length === 0) return result;
    var newResult = add_to_result (result, triplet_to_words (first[0], first[1], first[2]), SCALE_WORD[scaleIdx]);
    return recurse (newResult, ++scaleIdx, get_first(rest), get_rest(rest));
  }

  return recurse ('', 0, get_first_3(String(int)), get_rest_3(String(int)));
}

Element

Answer 21

while this system does use a for loop, It uses US english and is fast, accurate, and expandable(you can add infinite values to the "th" var and they will be included).

This function grabs the 3 groups of numbers backwards so it can get the number groups where a , would normally separate them in the numeric form. Then each group of three numbers is added to an array with the word form of just the 3 numbers(ex: one hundred twenty three). It then takes that new array list, and reverses it again, while adding the th var of the same index to the end of the string.

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

function numberToWord(number){
  var text = "";
  var size = number.length;

  var textList = [];
  var textListCount = 0;

  //get each 3 digit numbers
  for(var i = number.length-1; i >= 0; i -= 3){
    //get 3 digit group
    var num = 0;
    if(number[(i-2)]){num += number[(i-2)];}
    if(number[(i-1)]){num += number[(i-1)];}
    if(number[i]){num += number[i];}

    //remove any extra 0's from begining of number
    num = Math.floor(num).toString();

    if(num.length == 1 || num < 20){
      //if one digit or less than 20
      textList[textListCount] = ones[num];
    }else if(num.length == 2){
      //if 2 digits and greater than 20
      textList[textListCount] = tens[num[0]]+ones[num[1]];
    }else if(num.length == 3){
      //if 3 digits
      textList[textListCount] = ones[num[0]]+tens[10]+tens[num[1]]+ones[num[2]];
    }

    textListCount++;

  }

  //add the list of 3 digit groups to the string
  for(var i = textList.length-1; i >= 0; i--){
    if(textList[i] !== ''){text += textList[i]+th[i];} //skip if the number was 0
  }

  return text;
}

Decimal

Answer 22

This is also in response to naomik's excellent post! Unfortunately I don't have the rep to post in the correct place but I leave this here in case it can help anyone.

If you need British English written form you need to make some adaptions to the code. British English differs from the American in a couple of ways. Basically you need to insert the word 'and' in two specific places.

1. After a hundred assuming there are tens and ones. E.g One hundred and ten. One thousand and seventeen. NOT One thousand one hundred and.
2. In certain edges, after a thousand, a million, a billion etc. when there are no smaller units. E.g. One thousand and ten. One million and forty four. NOT One million and one thousand.

The first situation can be addressed by checking for 10s and 1s in the makeGroup method and appending 'and' when they exist.

makeGroup = ([ones,tens,huns]) => {
var adjective = this.num(ones) ? ' hundred and ' : this.num(tens) ? ' hundred and ' : ' hundred';
return [
  this.num(huns) === 0 ? '' : this.a[huns] + adjective,
  this.num(ones) === 0 ? this.b[tens] : this.b[tens] && this.b[tens] + '-' || '',
  this.a[tens+ones] || this.a[ones]
].join('');

};

The second case is more complicated. It is equivalent to

• add 'and' to 'a million, a thousand', or 'a billion' if the antepenultimate number is zero. e.g.

1,100,057 one million one hundred thousand and fifty seven. 5,000,006 five million and six

I think this could be implemented in @naomik's code through the use of a filter function but I wasn't able to work out how. In the end I settled on hackily looping through the returned array of words and using indexOf to look for instances where the word 'hundred' was missing from the final element.

Curly

Answer 23

I've just written paisa.js to do this, and it handles lakhs and crores correctly as well, can check it out. The core looks a bit like this:

const regulars = [
  {
    1: 'one', 2: 'two', 3: 'three', 4: 'four', 5: 'five', 6: 'six', 7: 'seven', 8: 'eight', 9: 'nine'
  },
  {
    2: 'twenty', 3: 'thirty', 4: 'forty', 5: 'fifty', 6: 'sixty', 7: 'seventy', 8: 'eighty', 9: 'ninety'
  }
]

const exceptions = {
  10: 'ten',
  11: 'eleven',
  12: 'twelve',
  13: 'thirteen',
  14: 'fourteen',
  15: 'fifteen',
  16: 'sixteen',
  17: 'seventeen',
  18: 'eighteen',
  19: 'nineteen'
}

const partInWords = (part) => {
  if (parseInt(part) === 0) return
  const digits = part.split('')
  const words = []
  if (digits.length === 3) {
    words.push([regulars[0][digits.shift()], 'hundred'].join(' '))
  }
  if (exceptions[digits.join('')]) {
    words.push(exceptions[digits.join('')])
  } else {
    words.push(digits.reverse().reduce((memo, el, i) => {
      memo.unshift(regulars[i][el])
      return memo
    }, []).filter(w => w).join(' '))
  }
  return words.filter(w => w.trim().length).join(' and ')
}

Adel

Answer 24

My solution is based on Juan Gaitán's solution for Indian currency, works up to crores.

function valueInWords(value) {
    let ones = ['', 'one', 'two', 'three', 'four',
            'five', 'six', 'seven', 'eight', 'nine',
            'ten', 'eleven', 'twelve', 'thirteen', 'fourteen',
            'fifteen', 'sixteen', 'seventeen', 'eighteen', 'nineteen'];   
    let tens = ['twenty','thirty', 'forty','fifty', 'sixty', 'seventy', 'eighty', 'ninety'];
    let digit = 0;   
    if (value < 20) return ones[value];   
    if (value < 100) {     
        digit = value % 10; //remainder     
        return tens[Math.floor(value/10)-2] + " " + (digit > 0 ? ones[digit] : "");   
    }
    if (value < 1000) {    
         return ones[Math.floor(value/100)] + " hundred " + (value % 100 > 0 ? valueInWords(value % 100) : "");   
    }   
    if (value < 100000) {     
        return valueInWords(Math.floor(value/1000)) + " thousand " + (value % 1000 > 0 ? valueInWords(value % 1000) : "");   
    }   
    if (value < 10000000) {     
        return valueInWords(Math.floor(value/100000)) + " lakh " + (value % 100000 > 0 ? valueInWords(value % 100000) : "");   
    }   
    return valueInWords(Math.floor(value/10000000)) + " crore " + (value % 10000000 > 0 ? valueInWords(value % 10000000) : ""); 
}

Problem

Answer 25

    function numberToEnglish( n ) {
        
        var string = n.toString(), units, tens, scales, start, end, chunks, chunksLen, chunk, ints, i, word, words, and = 'and';

        /* Remove spaces and commas */
        string = string.replace(/[, ]/g,"");

        /* Is number zero? */
        if( parseInt( string ) === 0 ) {
            return 'zero';
        }
        
        /* Array of units as words */
        units = [ '', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine', 'ten', 'eleven', 'twelve', 'thirteen', 'fourteen', 'fifteen', 'sixteen', 'seventeen', 'eighteen', 'nineteen' ];
        
        /* Array of tens as words */
        tens = [ '', '', 'twenty', 'thirty', 'forty', 'fifty', 'sixty', 'seventy', 'eighty', 'ninety' ];
        
        /* Array of scales as words */
        scales = [ '', 'thousand', 'million', 'billion', 'trillion', 'quadrillion', 'quintillion', 'sextillion', 'septillion', 'octillion', 'nonillion', 'decillion', 'undecillion', 'duodecillion', 'tredecillion', 'quatttuor-decillion', 'quindecillion', 'sexdecillion', 'septen-decillion', 'octodecillion', 'novemdecillion', 'vigintillion', 'centillion' ];
        
        /* Split user argument into 3 digit chunks from right to left */
        start = string.length;
        chunks = [];
        while( start > 0 ) {
            end = start;
            chunks.push( string.slice( ( start = Math.max( 0, start - 3 ) ), end ) );
        }
        
        /* Check if function has enough scale words to be able to stringify the user argument */
        chunksLen = chunks.length;
        if( chunksLen > scales.length ) {
            return '';
        }
        
        /* Stringify each integer in each chunk */
        words = [];
        for( i = 0; i < chunksLen; i++ ) {
            
            chunk = parseInt( chunks[i] );
            
            if( chunk ) {
                
                /* Split chunk into array of individual integers */
                ints = chunks[i].split( '' ).reverse().map( parseFloat );
            
                /* If tens integer is 1, i.e. 10, then add 10 to units integer */
                if( ints[1] === 1 ) {
                    ints[0] += 10;
                }
                
                /* Add scale word if chunk is not zero and array item exists */
                if( ( word = scales[i] ) ) {
                    words.push( word );
                }
                
                /* Add unit word if array item exists */
                if( ( word = units[ ints[0] ] ) ) {
                    words.push( word );
                }
                
                /* Add tens word if array item exists */
                if( ( word = tens[ ints[1] ] ) ) {
                    words.push( word );
                }
                
                /* Add 'and' string after units or tens integer if: */
                if( ints[0] || ints[1] ) {
                    
                    /* Chunk has a hundreds integer or chunk is the first of multiple chunks */
                    if( ints[2] || ! i && chunksLen ) {
                        words.push( and );
                    }
                
                }
                
                /* Add hundreds word if array item exists */
                if( ( word = units[ ints[2] ] ) ) {
                    words.push( word + ' hundred' );
                }
                
            }
            
        }
        
        return words.reverse().join( ' ' );
        
    }


// - - - - - Tests - - - - - -
function test(v) {
  var sep = ('string'==typeof v)?'"':'';
  console.log("numberToEnglish("+sep + v.toString() + sep+") = "+numberToEnglish(v));
}
test(2);
test(721);
test(13463);
test(1000001);
test("21,683,200,000,621,384");

Tenure

While this code may provide a solution to the question, it's better to add context as to why/how it works. This can help future users learn, and apply that knowledge to their own code. You are also likely to have positive feedback from users in the form of upvotes, when the code is explained. – Griz

Answer 26

For those who are looking for imperial/english naming conventions.

Based on @Salman's answer

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

function inWords (num) {
    if ((num = num.toString()).length > 12) return 'overflow';
    n = ('00000000000' + num).substr(-12).match(/^(\d{3})(\d{3})(\d{3})(\d{1})(\d{2})$/);
    if (!n) return; var str = '';
    str += (n[1] != 0) ? (Number(n[1]) > 99 ? this.a[Number(n[1][0])] + 'hundred ' : '') + (a[Number(n[1])] || b[n[1][1]] + ' ' + a[n[1][2]]) + 'billion ' : '';
    str += (n[2] != 0) ? (Number(n[2]) > 99 ? this.a[Number(n[2][0])] + 'hundred ' : '') + (a[Number(n[2])] || b[n[2][1]] + ' ' + a[n[2][2]]) + 'million ' : '';
    str += (n[3] != 0) ? (Number(n[3]) > 99 ? this.a[Number(n[3][0])] + 'hundred ' : '') + (a[Number(n[3])] || b[n[3][1]] + ' ' + a[n[3][2]]) + 'thousand ' : '';
    str += (n[4] != 0) ? (a[Number(n[4])] || b[n[4][0]] + ' ' + a[n[4][1]]) + 'hundred ' : '';
     str += (Number(n[5]) !== 0) ? ((str !== '') ? 'and ' : '') +
                (this.a[Number(n[5])] || this.b[n[5][0]] + ' ' +
                    this.a[n[5][1]]) + '' : '';
    return str;
}

document.getElementById('number').onkeyup = function () {
    document.getElementById('words').innerHTML = inWords(document.getElementById('number').value);
};

<span id="words"></span>
<input id="number" type="text" />

Spenserian

Answer 27

Cleanest and easiest approach that came to mind:

const numberText = {
  1: 'one',
  2: 'two',
  3: 'three',
  4: 'four',
  5: 'five',
  6: 'six',
  7: 'seven',
  8: 'eight',
  9: 'nine',
  10: 'ten',
  11: 'eleven',
  12: 'twelve',
  13: 'thirteen',
  14: 'fourteen',
  15: 'fifteen',
  16: 'sixteen',
  17: 'seventeen',
  18: 'eighteen',
  19: 'nineteen',
  20: 'twenty',
  30: 'thirty',
  40: 'forty',
  50: 'fifty',
  60: 'sixty',
  70: 'seventy',
  80: 'eighty',
  90: 'ninety',
  100: 'hundred',
  1000: 'thousand',
}

const numberValues = Object.keys(numberText)
  .map((val) => Number(val))
  .sort((a, b) => b - a)

const convertNumberToEnglishText = (n) => {
  if (n === 0) return 'zero'
  if (n < 0) return 'negative ' + convertNumberToEnglishText(-n)

  let num = n
  let text = ''

  for (const numberValue of numberValues) {
    const count = Math.trunc(num / numberValue)

    if (count < 1) continue

    if (numberValue >= 100) text += convertNumberToEnglishText(count) + ' '

    text += numberText[numberValue] + ' '
    num -= count * numberValue
  }

  if (num !== 0) throw Error('Something went wrong!')

  return text.trim()
}

Honeydew

Answer 28

Probably the simplest one I got and used was from Ben E. I made modifications to his code since it would only return for example 'Five Hundred' when you try to convert 500,000.00. I just added a line of conditional code to fix it. Also added the provision for giving out the last two decimal places. I'm now using it to convert the amount to words when printing checks. Here was my revision added to it:

if (Math.floor((number%(100*Math.pow(1000,i))/Math.pow(1000,i))) == 0) {
    word = first[Math.floor(tempNumber/(100*Math.pow(1000,i)))] + 'Hundred ' + mad[i] 
        + ' ' + word;
} else {

I'm having a hard time pasting the code here but let me know if you need any clarifications

Wail

Answer 29

answared by @pramod kharade

simplified

function NumToWord(inputNumber) {
    var str = new String(inputNumber)
    var splt = str.split("");
    var rev = splt.reverse();
    var once = ['Zero', ' One', ' Two', ' Three', ' Four', ' Five', ' Six', ' Seven', ' Eight', ' Nine'];
    var twos = ['Ten', ' Eleven', ' Twelve', ' Thirteen', ' Fourteen', ' Fifteen', ' Sixteen', ' Seventeen', ' Eighteen', ' Nineteen'];
    var tens = ['', 'Ten', ' Twenty', ' Thirty', ' Forty', ' Fifty', ' Sixty', ' Seventy', ' Eighty', ' Ninety'];

    numLength = rev.length;
    var word = new Array();
    var j = 0;

    for (i = 0; i < numLength; i++) {
        switch (i) {

            case 0:
                if ((rev[i] == 0) || (rev[i + 1] == 1)) {
                    word[j] = '';
                }
                else {
                    word[j] = '' + once[rev[i]];
                }
                word[j] = word[j];
                break;

            case 1:
                aboveTens();
                break;

            case 2:
                if (rev[i] == 0) {
                    word[j] = '';
                }
                else if ((rev[i - 1] == 0) || (rev[i - 2] == 0)) {
                    word[j] = once[rev[i]] + " Hundred ";
                }
                else {
                    word[j] = once[rev[i]] + " Hundred and";
                }
                break;

            case 3:
                if (rev[i] == 0 || rev[i + 1] == 1) {
                    word[j] = '';
                }
                else {
                    word[j] = once[rev[i]];
                }
                if ((rev[i + 1] != 0) || (rev[i] > 0)) {
                    word[j] = word[j] + " Thousand";
                }
                break;

                
            case 4:
                aboveTens();
                break;

            case 5:
                if ((rev[i] == 0) || (rev[i + 1] == 1)) {
                    word[j] = '';
                }
                else {
                    word[j] = once[rev[i]];
                }
                if (rev[i + 1] !== '0' || rev[i] > '0') {
                    word[j] = word[j] + " Lakh";
                }
                 
                break;

            case 6:
                aboveTens();
                break;

            case 7:
                if ((rev[i] == 0) || (rev[i + 1] == 1)) {
                    word[j] = '';
                }
                else {
                    word[j] = once[rev[i]];
                }
                if (rev[i + 1] !== '0' || rev[i] > '0') {
                    word[j] = word[j] + " Crore";
                }                
                break;

            case 8:
                aboveTens();
                break;


            default: break;
        }
        j++;
    }

    function aboveTens() {
        if (rev[i] == 0) { word[j] = ''; }
        else if (rev[i] == 1) { word[j] = twos[rev[i - 1]]; }
        else { word[j] = tens[rev[i]]; }
    }

    word.reverse();
    var finalOutput = '';
    for (i = 0; i < numLength; i++) {
        finalOutput = finalOutput + word[i];
    }
return finalOutput;
}

console.log(NumToWord(123))
console.log(NumToWord(12345678))
console.log(NumToWord(12334543))
console.log(NumToWord(6789876123))

Looney

Answer 30

Convertirlos en Español

class Converter {
constructor() {
    this.unit = ['CERO', 'UN', 'DOS', 'TRES', 'CUATRO', 'CINCO', 'SEIS', 'SIETE', 'OCHO', 'NUEVE'];
    this.units = ['CERO', 'UNO', 'DOS', 'TRES', 'CUATRO', 'CINCO', 'SEIS', 'SIETE', 'OCHO', 'NUEVE'];
    this.tenToSixteen = ['DIEZ', 'ONCE', 'DOCE', 'TRECE', 'CATORCE', 'QUINCE', 'DIECISEIS'];
    this.tens = ['TREINTA', 'CUARENTA', 'CINCUENTA', 'SESENTA', 'SETENTA', 'OCHENTA', 'NOVENTA'];
    this.monedaSingular = " PESO";
    this.monedaPlural = " PESOS";
    this.monedaMillon = " DE PESOS";
    this.centavoSingular = " CENTAVO"
    this.centavoPlural = " CENTAVOS"
    this.elMessage = document.getElementById('message');
    this.addListener();
}

addListener() {
    let elInput = document.getElementById('field-number');
    elInput.addEventListener('keyup', () => {
        if (elInput.value !== '') {
            this.convertToText(elInput.value);
        } else {
            this.elMessage.innerText = '';
        }
    });
}
convertToText(number) {
    number = this.deleteZerosLeft(number);
    if (!this.validateNumber(number)) {
        this.elMessage.innerText = 'Sólo se aceptan números enteros positivos.';
        return;
    }
    let num = number;
    number = number.split(".")[0];
    let entero = this.getName(number);
    let moneda;
    if (parseInt(number) == 1) {
        //this.elMessage.innerText = 
        moneda = entero + this.monedaSingular;
    } else {
        moneda = entero + this.monedaPlural;
    }
    if (num.indexOf('.') >= 0) {
        let d = num.split(".")[1];
        d = this.getName(d);
        if (parseInt(d) == 0) {
            moneda = moneda;
        } else if (parseInt(d) == 1) {
            moneda = moneda + " CON " + d + " " + this.centavoSingular;
        } else {
            moneda = moneda + " CON " + d + " " + this.centavoPlural;
        }
    }
    this.elMessage.innerText = moneda;
}

// Elimina los ceros a la izquierda
deleteZerosLeft(number) {
    let i = 0;
    let isZero = true;
    for (i = 0; i < number.length; i++) {
        if (number.charAt(i) != 0) {
            isZero = false;
            break;
        }
    }
    return isZero ? '0' : number.substr(i);
}

validateNumber(number) {
    // Validar que la cadena sea un número y que no esté vacía
    if (isNaN(number) || number === '') {
        return false;
    }
    // Validar que el número no sea negativo
    if (number.indexOf('-') >= 0) {
        return false;
    }
    return true;
}

getName(number) {
    number = this.deleteZerosLeft(number);

    if (number.length === 1) {
        return this.getUnits(number);
    }
    if (number.length === 2) {
        return this.getTens(number);
    }
    if (number.length === 3) {
        return this.getHundreds(number);
    }
    if (number.length < 7) {
        return this.getThousands(number);
    }
    if (number.length < 13) {
        return this.getPeriod(number, 6, 'MILLON');
    }
    if (number.length < 19) {
        return this.getPeriod(number, 12, 'BILLON');
    }
    return 'Número demasiado grande.';
}

getUnits(number) {
    let numberInt = parseInt(number);
    return this.unit[numberInt];
}

getTens(number) {
    // Obtener las unidades
    let units = number.charAt(1);

    if (number < 17) {
        return this.tenToSixteen[number - 10];
    }
    if (number < 20) {
        return 'DIECI' + this.getUnits(units);
    }
    // Nombres especiales
    switch (number) {
        case '20':
            return 'VEINTE';
        case '22':
            return 'VEINTIDOS';
        case '23':
            return 'VEINTITRES';
        case '26':
            return 'VEINTISEIS';
    }
    if (number < 30) {
        return 'VEINTI' + this.getUnits(units);
    }
    let name = this.tens[number.charAt(0) - 3];
    if (units > 0) {
        name += ' Y ' + this.getUnits(units);
    }
    return name;
}

getHundreds(number) {
    let name = '';
    // Obtener las centenas
    let hundreds = number.charAt(0);
    // Obtener las decenas y unidades
    let tens = number.substr(1);

    if (number == 100) {
        return 'CIEN';
    }
    // Nombres especiales
    switch(hundreds) {
        case '1':
            name = 'CIENTO';
            break;
        case '5':
            name = 'QUINIENTOS';
            break;
        case '7':
            name = 'SETECIENTOS';
            break;
        case '9':
            name = 'NOVECIENTOS';
    }
    if (name === '') {
        name = this.getUnits(hundreds) + 'CIENTOS';
    }
    if (tens > 0) {
        name += ' ' + this.getName(tens);
    }
    return name;
}

getThousands(number) {
    let name = 'MIL';
    // Obtener cuantos dígitos están en los miles
    let thousandsLength = number.length - 3;
    // Obtener los miles
    let thousands = number.substr(0, thousandsLength);
    // Obtener las centenas, decenas y unidades
    let hundreds = number.substr(thousandsLength);

    if (thousands > 1) {
        // Se reemplaza la palabra uno por un en numeros como 21000, 31000, 41000, etc.
        name = this.getName(thousands).replace('UNO', 'UN') + ' MIL';
    }
    if (hundreds > 0) {
        name += ' ' + this.getName(hundreds);
    }
    return name;
}

// Obtiene periodos, por ejemplo: millones, billones, etc.
getPeriod(number, digitsToTheRight, periodName) {
    let name = 'UN ' + periodName;
    // Obtener cuantos dígitos están dentro del periodo
    let periodLength = number.length - digitsToTheRight;
    // Obtener los dítos del periodo
    let periodDigits = number.substr(0, periodLength);
    // Obtener los digitos previos al periodo
    let previousDigits = number.substr(periodLength);

    if (periodDigits > 1) {
        name = this.getName(periodDigits).replace('UNO', 'UN') + ' ' + periodName.replace('Ó', 'O') + 'ES';
    }
    if (previousDigits > 0) {
        name += ' ' + this.getName(previousDigits);
    }
    return name;
}

}

new Converter();

Klausenburg

Answer 31

const numToWordObj = {
  0: 'zero',
  1: 'one',
  2: 'two',
  3: 'three',
  4: 'four',
  5: 'five',
  6: 'six',
  7: 'seven',
  8: 'eight',
  9: 'nine',
  10: 'ten',
  11: 'eleven',
  12: 'twelve',
  13: 'thirteen',
  14: 'fourteen',
  15: 'fifteen',
  16: 'sixteen',
  17: 'seventeen',
  18: 'eighteen',
  19: 'nineteen',
  20: 'twenty',
  30: 'thirty',
  40: 'forty',
  50: 'fifty',
  60: 'sixty',
  70: 'seventy',
  80: 'eighty',
  90: 'ninety'
};
const placement = {
  100: ' hundred',
  1000: ' thousand',
  1000000: ' million',
  1000000000000: ' trillion'
};

const numToWord = (num) => {
  const limiter = (val) => num < val;
  const limiterIndex = Object.keys(placement).findIndex(limiter);
  const limiterKey = Object.keys(placement)[limiterIndex];
  const limiterVal = Object.values(placement)[limiterIndex - 1];
  const limiterMod = Object.keys(placement)[limiterIndex - 1];

  if (numToWordObj[num]) {
    return numToWordObj[num];
  }
  if (num < 100) {
    let whole = Math.floor(num / 10) * 10;
    let part = num % 10;
    return numToWordObj[whole] + ' ' + numToWordObj[part];
  }

  if (num < limiterKey) {

    let whole = Math.floor(num / limiterMod);
    let part = num % limiterMod;
    if (part === 0) {
      return numToWord(whole) + limiterVal;
    } else {
      return numToWord(whole) + limiterVal + ' and ' + numToWord(part);
    }
  }
};

// console.log(numToWord(99));
console.log(numToWord(100));
console.log(numToWord(1000));
console.log(numToWord(10000));
console.log(numToWord(1000010000));
console.log(numToWord(888888));
// console.log(numToWord(0));

Spectroheliograph

Welcome to Stackoverflow! I suppose, when answering to a question that has 32 answers already, it is useful to point why your solution is something new or more useful, compared to the others. Please use Edit button and try to add some explanation. Best regards – Perlite

Answer 32

i take another code, i fortgotten where is, sorry. but i need convert number into words with nodejs, but in spanish. my code can read 6 digits, its work good, i hope that you help.

function humanize(num){
    var ones = ['', 'uno', 'dos', 'tres', 'cuatro', 'cinco', 'seis', 'siete', 'ocho', 'nueve',
                'diez', 'once', 'doce', 'trece', 'catorce', 'quince', 'dieciseis',
                'dieceisiete', 'dieciocho', 'diecinueve'];
    var tens = ['', '', 'veinte', 'treinta', 'cuarenta', 'cincuenta', 'sesenta', 'setenta', 'ochenta',
                'noventa'];
  
    var numString = num.toString();
  
    if (num < 0) throw new Error('Negative numbers are not supported.');
  
    if (num === 0) return '';
  
    //the case of 1 - 20
    if (num < 20) {
      return ones[num];
    }
  
    if (numString.length === 2) {
    
                if(ones[numString[1]]==0){
                  
                   return tens[numString[0]] + '  ' + ones[numString[1]];
              }else{
                 return tens[numString[0]] + ' y ' + ones[numString[1]];
               }
        
    } //fin de 2 cifras
  
    //100 and more
    if (numString.length == 3) {
      if (numString[1] === '0' && numString[2] === '0'){

           if(numString[0] === '1') {
            return 'cien';
           }else if(numString[0] === '5'){
            return 'Quinientos';
           }else if(numString[0] === '9'){
            return 'Novecientos';
           }else if(numString[0] === '7'){
            return 'Setecientos';
           }else{
            return ones[numString[0]] + 'cientos';
           }

      }else{
      
           if(numString[0]=='1'){
             return  'ciento ' + humanize(+(numString[1] + numString[2]));
          }else if(numString[0]=='5'){
             return 'quinientos ' + humanize(+(numString[1] + numString[2]));
          }else if(numString[0]=='9'){
             return  ' novecientos ' + humanize(+(numString[1] + numString[2]));
          }else if(numString[0]=='7'){
            return  ' Setecientos ' + humanize(+(numString[1] + numString[2]));
         }else{
             return ones[numString[0]] + 'cientos ' + humanize(+(numString[1] + numString[2]));
          }
      
    
      }
       
    }//fin de 3 cifras
    
  




    if (numString.length === 4) {
        var end = +(numString[1] + numString[2] + numString[3]);
      
       if (end === 0){

            if(numString[0] === '1'){
                return 'Mil';
            }else{
                return ones[numString[0]] + ' mil';
            }
            

       } 

      if (end < 100){
      
      if(numString[1]==0){
            if(numString[0]==1){
                 return 'Un mil '+ humanize(end);
             }else{
              return ones[numString[0]] + ' mil, ' + humanize(end);
              }
        }else{
          return ones[numString[0]] + ' mil y ' + humanize(end);
         }
      } 
      
      if(numString[0]==1){
       return  'Un mil ' + humanize(end);
      }else{
         return ones[numString[0]] + ' mil ' + humanize(end);
      }
   
    }//fin de 4 cifras
    
    
    






    
    //revisar valores de 5 cifras
    if (numString.length === 5) {
      var end = +( numString[2] + numString[3]+ numString[4]);
      if (end === 0){
          if(numString[1]==0){
            let valor=numString[0]+''+numString[1];
            return ones[valor] + ' mil';
          }
      } 
      
        
      
      if (end < 100){
        if(numString[2]==0){
           
                let valor=numString[0]+''+numString[1];
                if(parseInt(valor) <20){
                    return ones[valor] +' mil, ' + humanize(end);
                }else{

                    if(numString[1]!=0){

                        if(numString[1]==1){
                            return tens[numString[0]] +' y un mil ' + humanize(end);
                        }else{
                            return tens[numString[0]] +' y '+ ones[numString[1]]+' mil ' + humanize(end);
                        }
                       

                    }else{
                        return tens[numString[0]] +' mil, ' + humanize(end);
                    }
                   
                }
            
           }else{
              return ones[numString[0]] + ' mil y ' + humanize(end);
           }
      }
      
  
      
      
      let valor=numString[0]+''+numString[1];
      if(parseFloat(valor) <20){
          return ones[valor] + ' mil ' + humanize(end);
      }else{
          
          if(numString[1]==0){
             return tens[numString[0]] + ' ' + ones[numString[1]] + ' mil, ' + humanize(end);
          }else{
                  if(numString[1]==1){
                    return tens[numString[0]] + ' y un mil, ' + humanize(end);
                  }else{
                    return tens[numString[0]] + ' y ' + ones[numString[1]] + ' mil, ' + humanize(end);
                  }
          }
       
      } 
    }//fin de 5 cifras


        if(numString.length === 6){

            let inicio_texto= humanize(numString[0]+numString[1]+numString[2]);

            let valor_cola=parseInt(numString[3])+parseInt(numString[4])+parseInt(numString[5]);

            if(valor_cola >0){
                return inicio_texto+ ' mil, ' + humanize(numString[3]+numString[4]+numString[5]);
            }else{
                return inicio_texto+ ' mil';
            }
           
            
        }//fin de 6 cifras

  }//fin de convertir de letras a numeros

Rebozo

Answer 33

Here in my country Arab/Kharab is not conventional and I needed to handle upto 13 digits. Hope this helps other developers.

function numWords(input) {
    var a = ['','one ','two ','three ','four ', 'five ','six ','seven ','eight ','nine ','ten ','eleven ','twelve ','thirteen ','fourteen ','fifteen ','sixteen ','seventeen ','eighteen ','nineteen '];
    var b = ['', '', 'twenty ','thirty ','forty ','fifty ', 'sixty ','seventy ','eighty ','ninety '];

    var num = parseInt(input);
    if (isNaN(num)) return 'Invalid number';
    if (num === 0) return 'zero';
    if (num.toString().length > 13) return 'overflow';

    function convert(n) {
        if (n < 20) return a[n];
        else if (n < 100) return b[Math.floor(n / 10)] + (n % 10 ? " " + a[n % 10] : "");
        else return a[Math.floor(n / 100)] + "hundred " + (n % 100 ? convert(n % 100) : "");
    }

    function convertLargeNumber(n) {
        if (n >= 10000000) return convertLargeNumber(Math.floor(n / 10000000)) + "crore " + convertLargeNumber(n % 10000000);
        else if (n >= 100000) return convert(Math.floor(n / 100000)) + "lakh " + convertLargeNumber(n % 100000);
        else if (n >= 1000) return convert(Math.floor(n / 1000)) + "thousand " + convertLargeNumber(n % 1000);
        else return convert(n);
    }

    let words = convertLargeNumber(num);

    return capitalizeFirstLetter(words.trim());
}

function capitalizeFirstLetter(string) {
    return string.charAt(0).toUpperCase() + string.slice(1);
}

Eta

Answer 34

 var units = ["", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine"];
var tens = ["", "", "twenty", "thirty", "forty", "fifty", "sixty", "seventy", "eighty", "ninety"];



function convert7digitIntoWords(num) {
    var remainder = num % 1000000
    var hun = num - remainder;
    var div = Math.floor(num / 100000);
    if (remainder !== 0)
        return (convert2digitIntoWords(div) + " lakhs " + convert5digitIntoWords(remainder % 100000))
    else
        return (convert2digitIntoWords(div) + " lakhs ")
}

function convert6digitIntoWords(num) {
    var remainder = num % 100000
    var hun = num - remainder;
    var div = Math.floor(num / 100000);
    if (remainder !== 0)
        return (units[div] + " lakh " + convert5digitIntoWords(remainder))
    else
        return (units[div] + " lakh ")
}

function convert5digitIntoWords(num) {
    var remainder = num % 10000
    var hun = num - remainder;
    var div = Math.floor(num / 1000);
    if (remainder !== 0)
        return (convert2digitIntoWords(div) + " thousand " + convert3digitIntoWords(remainder % 1000))
    else
        return (convert2digitIntoWords(div) + " thousand")
}

function convert4digitIntoWords(num) {
    var remainder = num % 1000
    var hun = num - remainder;
    var div = Math.floor(num / 1000);
    if (remainder !== 0)
        return (units[div] + " thousand " + convert3digitIntoWords(remainder))
    else
        return (units[div] + " thousand")
}


function convert3digitIntoWords(num) {
    var remainder = num % 100
    var hun = num - remainder;
    var div = Math.floor(num / 100);
    if (remainder !== 0)
        return (units[div] + " hundred " + convert2digitIntoWords(remainder))
    else
        return (units[div] + " hundred ")
}

function convert2digitIntoWords(num) {
    var remainder = num % 10;
    var div = Math.floor(num / 10);
    return (tens[div] + " " + convertNumIntoWords(remainder));
}

function convertNumIntoWords(num) {

    switch (("" + num).length) {
        case 1:
            return units[num];
        case 2:
            return convert2digitIntoWords(num);
        case 3:
            return convert3digitIntoWords(num)
        case 4:
            return convert4digitIntoWords(num)
        case 5:
            return convert5digitIntoWords(num)
        case 6:
            return convert6digitIntoWords(num)
        case 7:
            return convert7digitIntoWords(num)
        default:
            return "cannot be converted"
    }
}

console.log(convertNumIntoWords(3445125));

Ejaculate

Answer 35

Convert digits to word in French language using JavaScript and html - original French words

        <html>
            <head>
                <title>Number to word</title>
    
                <script>
                    function toWords() {
                        var s = document.getElementById('value').value;
                        var th = ['','mille','million', 'milliard','billion'];
                        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-vingt','quatre-vingt-dix'];
                    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) { 
                                if(s!=21 && s!=31 && s!=41 && s!=51 && s!=61 && s!=71 && s!=72 && s!=73 && s!=74 && s!=75 && s!=76 && s!=100 && s!=91 && s!=92 && s!=93 && s!=94 && s!=95 && s!=96){
                                if(s==20 || s==30 || s==40 || s==50 || s==60 || s==70 || s==80 || s==90){
                                str += tw[n[i]-2] + ' ';} // for not to display hyphens for 20,30...90 
                                else{
                                str += tw[n[i]-2] + '-';}
                                sk=1;
                                }
                            }
                        } else if (n[i]!=0) {
                            if(s!=21 && s!=31 && s!=41 && s!=51 && s!=61 && s!=71 && s!=72 && s!=73 && s!=74 && s!=75 && s!=76 && s!=100 && s!=91 && s!=92 && s!=93 && s!=94 && s!=95 && s!=96){
    
                            str += dg[n[i]] +' ';
                            if ((x-i)%3==0) str += 'hundert ';  // for start from 101 - 
    
                            sk=1;
                            }
                        }
                        if ((x-i)%3==1) {
                            if(s!=21 && s!=31 && s!=41 && s!=51 && s!=61 && s!=71 && s!=72 && s!=73 && s!=74 && s!=75 && s!=76 && s!=100 && s!=91 && s!=92 && s!=93 && s!=94 && s!=95 && s!=96){
                            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]] +' ';
                        str += 'virgule ';
                         var counter=0;
                         for (var i=x+1; i<y; i++){
                            if ((y-i)%3==2) { 
                                                if (n[i] == '1') {
                                                                str += tn[Number(n[i+1])] + ' ';
                                                                i++;
                                                                counter=1;
                                                } else if (n[i]!=0) {
                                                                str += tw[n[i]-2] + '-';
                                                                counter=1;
                                                }
                                            }else if (n[i]!=0) { // 0235
                                                str += dg[n[i]] +' ';
                                            }
                         }
    
                    }
    
                    if (s!=21 && s!=31 && s!=41 && s!=51 && s!=61 && s!=71 && s!=72 && s!=73 && s!=74 && s!=75 && s!=76 && s!=100 && s!=91 && s!=92 && s!=93 && s!=94 && s!=95 && s!=96){
                    document.getElementById("demo").innerHTML = str.replace(/\s+/g,' ')
    
                    }
                    else if (s==21){
                    str = 'vingt-et-un'
                    document.getElementById("demo").innerHTML = str;
                    }//alert(str.replace(/\s+/g,' '));
                    else if (s==31){
                    str = 'trente-et-un'
                    document.getElementById("demo").innerHTML = str;}
                    else if (s==41){
                    str = 'quarante-et-un'
                    document.getElementById("demo").innerHTML = str;}
                    else if (s==51){
                    str = 'cinquante-et-un'
                    document.getElementById("demo").innerHTML = str;}
                    else if (s==61){
                    str = 'soixante-et-un'
                    document.getElementById("demo").innerHTML = str;}
                    else if (s==71){
                    str = 'soixante-et-onze'
                    document.getElementById("demo").innerHTML = str;}
                    else if (s==72){
                    str = 'soixante-douze'
                    document.getElementById("demo").innerHTML = str;}
                    else if (s==73){
                    str = 'soixante-treize'
                    document.getElementById("demo").innerHTML = str;}
                    else if (s==74){
                    str = 'soixante-quatorze'
                    document.getElementById("demo").innerHTML = str;}
                    else if (s==75){
                    str = 'soixante-quinze'
                    document.getElementById("demo").innerHTML = str;}
                    else if (s==76){
                    str = 'soixante-seize'
                    document.getElementById("demo").innerHTML = str;}
                    else if (s==100){
                    str = 'cent'
                    document.getElementById("demo").innerHTML = str;}
                    else if (s==91){
                    str = 'quatre-vingt-onze'
                    document.getElementById("demo").innerHTML = str;}
                    else if (s==92){
                    str = 'quatre-vingt-douze'
                    document.getElementById("demo").innerHTML = str;}
                    else if (s==93){
                    str = 'quatre-vingt-treize'
                    document.getElementById("demo").innerHTML = str;}
                    else if (s==94){
                    str = 'quatre-vingt-quatorze'
                    document.getElementById("demo").innerHTML = str;}   
                    else if (s==95){
                    str = 'quatre-vingt-quinze'
                    document.getElementById("demo").innerHTML = str;}   
                    else if (s==96){
                    str = 'quatre-vingt-seize'
                    document.getElementById("demo").innerHTML = str;}               
                }
            </script>
        </head>
        <body>
            <p>Enter only numbers (max 15 digits) : </p>
            <input type="text" name="value" id='value' /><br>
            <input type="button" value="submit" onclick="toWords()" />
            <p id="demo"></p>
            <p id="demo1"></p>
        </body>
    </html> 

Orthogonal

Debugging this is a nightmare. Please consider providing readable variable names and comments. – Tarpley