Преобразование цифр в слова с помощью JavaScript

Ответ 1

Обновление: похоже, это более полезно, чем я думал. Я только что опубликовал это на npm. https://www.npmjs.com/package/num-words

Здесь более короткий код. с одним RegEx и без петель. преобразует, как вы хотели, в южно-азиатской системе нумерации

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

Ответ 2

"Обманчиво простая задача". - Potatoswatter

Действительно. Там много маленьких дьяволов, болтающихся в деталях этой проблемы. Было очень весело решить эту проблему.

РЕДАКТИРОВАТЬ: Это обновление использует гораздо более композиционный подход. Раньше была одна большая функция, которая обернула пару других проприетарных функций. Вместо этого на этот раз мы определяем общие функции многократного использования, которые могут использоваться для многих разновидностей задач. Подробнее о тех, кто посмотрел numToWords сам & hellip;

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

Вот зависимости:

Вы заметите, что они требуют, чтобы в документации не было документации, потому что их намерения сразу же ясны. chunk может быть единственным, что требует времени для переваривания, но это действительно не так уж плохо. Плюс название функции дает нам довольно хорошее представление о том, что она делает, и это, вероятно, функция, с которой мы сталкивались раньше.

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

"Значит, это лучше?"

Посмотрите, как код значительно очистился

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

Самое главное, что функции утилиты, которые мы добавили в новый код, можно использовать в других местах вашего приложения. Это означает, что в качестве побочного эффекта реализации numToWords таким образом мы получаем другие функции бесплатно. Бонусная сода!

Некоторые тесты

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

Ответ 3

Я потратил некоторое время на разработку лучшего решения для этого. Он может обрабатывать очень большие числа, но как только они получат более 16 цифр, вы передадите число в виде строки. Кое-что о пределе чисел JavaScript.

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

Ответ 4

Возможно, вы захотите попробовать рекурсивный. Он работает для чисел от 0 до 999999. Помните, что (~~) делает то же самое, что и 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): "");
}

Ответ 5

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

Ответ 6

Преобразование входной строки в число, а не сохранение ее как строки, ограничивает решение максимально допустимым значением float/integer на этом компьютере/браузере. Мой script ниже обрабатывает валюту до 1 триллиона долларов - 1 цент:-). Я могу расширить до 999 триллионов, добавив 3 или 4 строки кода.

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 ] ====================================

Ответ 7

Мне нравится результат, который я получил, который, на мой взгляд, легко читается и достаточно короткий, чтобы его можно было использовать в качестве решения.

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

Ответ 8

Это ответ на комментарий @LordZardeck к @naomik отличный ответ выше. Извините, я бы прокомментировал это напрямую, но я никогда не размещал его раньше, поэтому у меня нет привилегии сделать это, поэтому я отправляю здесь.

Во всяком случае, мне просто довелось перевести версию ES5 на более читаемую форму в прошлые выходные, поэтому я делюсь ею здесь. Это должно быть верным оригиналу (включая недавнее редактирование), и я надеюсь, что именование будет четким и точным.

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

Ответ 9

Если вам нужен Cent, вы можете использовать этот

        <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 скрипка

Здесь taka означает USD и paisa mean cent

Ответ 10

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

Это модифицированная поддержка кода для индийской рупии с 2 десятичными знаками.

Ответ 11

Другое преобразование, которое использует остатки и поддерживает разные языки:

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

Функция getNumberName зависит от языка и обрабатывает номера до 9999 (но ее легко расширить, чтобы обрабатывать большие числа):

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 обрабатывает кратные десять:

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

Наконец, примеры локали:

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

Здесь JSFiddle с тестами: https://jsfiddle.net/rcrxna7v/15/

Ответ 12

Много хороших ответов. Мне нужна была моя для индийской (Южной Азии) системы нумерации. Я изменил один из приведенных выше кодов - прикрепив его здесь, на случай, если это кому-то понадобится. В индийской системе нумерации группы после тысяч состоят из двух цифр, а не трех, как в западной системе.

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

Ответ 13

Я изменил код MC Shaman, чтобы исправить ошибку, связанную с одним номером и появиться перед ним.

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

Ответ 14

Я изменил код @McShaman, преобразовал его в CoffeeScript и добавил документы через JSNice. Вот результат для тех, кого интересует (английский):

###
    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

Ответ 15

Хотя на этот вопрос был дан ответ - все же я хочу поделиться тем, что я недавно разработал в java script (на основе логики старой реализации С#. Net, которую я нашел в Интернете) для преобразования индийских значений валюты в слова. Он может обрабатывать до 40 цифр. Вы можете посмотреть.

Использование:   InrToWordConverter.Initialize();.   var inWords = InrToWordConverter.ConvertToWord(количество);

Реализация:

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

Ответ 16

Ниже приведены переводы из

• целое число в слово
• float to word
• деньги на слово

Тесты находятся внизу

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

Ответ 17

Вы можете проверить мою версию из github. Это не так сложно. Я тестирую это для чисел от 0 до 9999, но вы можете расширить массив, если хотите цифры для слов

Ответ 18

Это также в ответ на наомик отличный пост! К сожалению, у меня нет репутации для публикации в правильном месте, но я оставляю это здесь, если он может помочь кому-либо.

Если вам нужна английская английская форма, вам нужно внести некоторые изменения в код. Британский английский отличается от американского несколькими способами. В основном вам нужно вставить слово "и" в двух конкретных местах.

• После сотни, предполагая, что есть десятки и единицы. Например, сто десять. Одна тысяча семнадцать. НЕ Одна тысяча сто.
• В некоторых краях после тысячи, миллиона, миллиарда и т.д.. когда нет меньших единиц. Например. Тысяча и десять. Один миллион и сорок четыре. НЕ Один миллион и тысяча.

Первую ситуацию можно решить, проверив 10s и 1s в методе makeGroup и добавив "и" , когда они существуют.

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

};

Второй случай более сложный. Это эквивалентно

• добавьте "и" в "миллион, тысячу" или "миллиард", если антенультитующее число равно нулю. например.

1,100, 0 57 миллионов человек тысяч и пятьдесят семь. 5000, 0 06 пять миллионов и шесть

Я думаю, что это может быть реализовано в коде @naomik с помощью функции фильтрации, но я не смог разобраться, как это сделать. В конце концов я поселился в хакерском цикле через возвращаемый массив слов и использовал indexOf, чтобы искать экземпляры, где слово "сто" отсутствовало в конечном элементе.

Ответ 19

Я только что написал paisa.js, чтобы сделать это, и он правильно обрабатывает lakhs и кроры, можете проверить это. Ядро выглядит примерно так:

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

Ответ 20

в то время как эта система использует цикл for, она использует американский английский и является быстрой, точной и расширяемой (вы можете добавить бесконечные значения в "th" var, и они будут включены).

Эта функция захватывает 3 группы цифр в обратном направлении, чтобы он мог получить номер группы, где , как правило, отделяющие их в числовой форме. Затем каждая группа из трех чисел добавляется в массив со словом только три цифры (например, сто двадцать три). Затем он берет этот новый список массивов и снова переворачивает его, добавляя th var этого же индекса в конец строки.

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

Ответ 21

Преобразование цифр в слово на французском языке с использованием JavaScript и HTML - оригинальные французские слова

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

Ответ 22

function ntsConvert(value) {
let input = String(value).split('');
let mapData = {
	"0": "Zero",
	"1": "One",
	"2": "Two",
	"3": "Three",
	"4": "Four",
	"5": "Five",
	"6": "Six",
	"7": "Seven",
	"8": "Eight",
	"9": "Nine"
};
let output = '';
var tempArray = []
for (let i = 0; i < input.length; i++) {
	tempArray.push(mapData[input[i]])
}
output = tempArray.join(' ');
return output;
}

console.log(ntsConvert(12345)) // 'One Two Three Four Five'

Ответ 23

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

Ответ 24

Попробуйте использовать этот код с помощью JavaScript, совместимого с турецкой версией 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;


     }