JavaScript числа в слова - PullRequest
Новая
       44

JavaScript числа в слова

30 голосов
/ 03 апреля 2011

Я пытаюсь преобразовать числа в английские слова, например 1234 станет: " одна тысяча двести тридцать четыре ".

Моя тактика идеткак это:

  • Разделите цифры на три и поместите их в массив (finlOutPut) справа налево.

  • Конвертируйте каждоегруппа (каждая ячейка в массиве finlOutPut) из трех цифр в слове (это то, что делает функция triConvert).Если все три цифры равны нулю, преобразуйте их в "dontAddBigSuffix"

  • справа налево, добавьте тысячу, миллион, миллиард и т. Д. .Если ячейка finlOutPut равна "dontAddBigSufix" (потому что это были только нули), не добавляйте слово и не устанавливайте для ячейки значение " " (ничего).

Кажетсяработать довольно хорошо, но у меня есть некоторые проблемы с числами, такими как 19000000 9 , преобразованными в: " сто девяносто миллионов ".Каким-то образом он «забывает» последние цифры, когда есть несколько нулей.

Что я сделал не так?Где ошибка?Почему не работает идеально? 

<html>
<head>
<meta http-equiv="Content-Type" content="text/html;charset=utf-8"/>

<script type="text/javascript">
function update(){
    var bigNumArry = new Array('', ' thousand', ' million', ' billion', ' trillion', ' quadrillion', ' quintillion');

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    return output;
}   
</script>

</head>
<body>

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

Ответы [ 21 ]

1 голос
/ 05 апреля 2011

Вот решение, которое будет обрабатывать любое целочисленное значение в строке. Я определил числовые шкалы до «дециллиона», поэтому это решение должно быть точным до 999 дециллионов. После чего вы получаете такие вещи, как «тысяча дециллионов» и т. Д.

Числа JavaScript начинают давать сбой в районе «999999999999999», поэтому функция преобразования работает только со строками чисел.

Примеры: 

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

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

Код: 

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

function convert(val) {
    var len;

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

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

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

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

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

function convert_lt1000(val) {
    var rem, l;

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

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

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


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

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

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

function is_lt20(val) {
    return parseInt(val, 10) < 20;
}
0 голосов
/ 18 ноября 2017

Это простая функция ES6 + число в слова.Вы можете просто добавить массив 'illions', чтобы расширить цифры.Американская английская версия.(без 'и' до конца) 

// generic number to words

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

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

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

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

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

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


// just for this question.

let update = () => {
    let value = document.getElementById('number').value
    document.getElementById('container').innerHTML = numberToWords(value)
}
0 голосов
/ 05 июля 2017 
<script src="http://www.ittutorials.in/js/demo/numtoword.js" type="text/javascript"></script>
    HTML - Convert numbers to words using JavaScript</h1>
<input id="Text1" type="text" onkeypress="return onlyNumbers(this.value);" onkeyup="NumToWord(this.value,'divDisplayWords');"
    maxlength="9" style="background-color: #efefef; border: 2px solid #CCCCC; font-size: large" />
<br />
<br />
<div id="divDisplayWords" style="font-size: 13; color: Teal; font-family: Arial;">
</div>
0 голосов
/ 28 ноября 2016

это решение для французского языка это ответвление @gandil 

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

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

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

function toWords(s) {

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

            }




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


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

</head>
<body>

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

надеюсь, это поможет

0 голосов
/ 30 марта 2016

Вот еще одна моя версия с некоторыми юнит-тестами.

Не используйте его с числами, большими Number.MAX_SAFE_INTEGER. 

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

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

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


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

  if (n < 0) {
    return "minus " + convert(-n);
  } else if (n === 0) {
    return "zero";
  } else {
    let result = "";
    for (let numeral of NUMERALS) {
      if (n >= numeral.value) {
        if (n < 100) {
          result += numeral.str;
          n -= numeral.value;
          if (n > 0) result += "-";
        } else {
          let times = Math.floor(n / numeral.value);
          result += convert(times) + " " + numeral.str;
          n -= numeral.value * times;
          if (n > 0) result += " and ";
        }
      }
    }
    return result;
  }
}
0 голосов
/ 02 марта 2016

Я думаю, это поможет вам 

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

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

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

    }
    function ConvertToWords(num)
    {
       var cWords;
       for (var i = 0; num > 0; i++) { 
           if (num % 1000 > 0) {
              if (i != 0){
                 cWords = ConvertToHundreds(num) + " " + aUnits + " " + cWords;
              }else{
                 cWords = ConvertToHundreds(num) + " ";
              }        
           }
           num = (num / 1000);
       }
         return(cWords);
    }
0 голосов
/ 01 февраля 2016

Я попробовал решение Мухаммеда, но у меня были некоторые проблемы, и я хотел использовать десятичные дроби, поэтому я внес некоторые изменения и преобразовал их в coffeescript и angular. Пожалуйста, имейте в виду, что js и coffeescript не являются моими сильными сторонами, поэтому используйте их с осторожностью. 

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

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

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

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

    ### quadrillion ###

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

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

    ### billion ###

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

    ### million ###

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

    ### thousand ###

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

    ### Tens (deca) ###

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

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

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

$ scope.is_numeric = (mixed_var) -> # console.log "mixed var is:" + mixed_var (typeof mixed_var == 'number' или typeof mixed_var == 'string') и mixed_var! = '' и! isNaN (mixed_var)

0 голосов
/ 24 августа 2018

Я думаю, у меня есть решение, которое проще и легче понять; он идет путем нарезки номера, он работает до 99 крор. 

function convert_to_word(num, ignore_ten_plus_check) {

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

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

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

    var len = num.length;

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

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

}

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



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

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

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

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

Пожалуйста, проверьте мой код ручки

0 голосов
/ 05 декабря 2013

Я хотел бы отметить, что исходная логика не работает для значений между x11-x19, где x> = 1. Например, 118 возвращает «сто восемь».Это потому, что эти числа обрабатываются следующим кодом в triConvert (): 

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

здесь, символ, представляющий цифру десятков, используется для индексации массива tens[], который имеет пустую строку в индексе[1], поэтому 118 становятся 108.

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

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

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

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

return output;

Я бы предложил: 

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

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

 return output;

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

0 голосов
/ 20 сентября 2018

Если кто-то захочет сделать это, но на испанском (en español), вот мой код, основанный на

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


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

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

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

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


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

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

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

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

Результат: 

num2str(123456789)
"ciento veintitres millones cuatrocientos cincuenta y seis mil setecientos ochenta y nueve pesos (00/100 M.N.)"
Страница:
Добро пожаловать на сайт PullRequest, где вы можете задавать вопросы и получать ответы от других членов сообщества.

Нет похожих вопросов

...