මම පූර්ණ සංඛ්‍යාවක් මුද්‍රණය කිරීමට උත්සාහ කරමි ජාවාස්ක්‍රිප්ට් හි කොමා සමඟ . උදාහරණයක් ලෙස, මට 1234567 අංකය "1,234,567" ලෙස පෙන්වීමට අවශ්‍යයි. මම මෙය කරන්නේ කෙසේද?

මෙන්න මම එය කරන්නේ කෙසේද:

function numberWithCommas(x) {
    x = x.toString();
    var pattern = /(-?\d+)(\d{3})/;
    while (pattern.test(x))
        x = x.replace(pattern, "$1,$2");
    return x;
}

එය කිරීමට සරල හෝ වඩා අලංකාර ක්‍රමයක් තිබේද? එය පාවෙන සමඟ ද ක්‍රියා කරන්නේ නම් හොඳයි, නමුත් එය අවශ්‍ය නොවේ. කාල පරිච්ඡේද සහ කොමාව අතර තීරණය කිරීම සඳහා එය ස්ථානීය-විශේෂිත විය යුතු නොවේ.

මම කෙරීගේ පිළිතුරෙන් අදහස භාවිතා කළෙමි, නමුත් මගේ නිශ්චිත අරමුණ සඳහා සරල දෙයක් සොයමින් සිටි බැවින් එය සරල කළෙමි. මෙන්න මම කළ දේ:

function numberWithCommas(x) {
    return x.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ",");
}

function numberWithCommas(x) {
    return x.toString().replace(/\B(?<!\.\d*)(?=(\d{3})+(?!\d))/g, ",");
}

function test(x, expect) {
    const result = numberWithCommas(x);
    const pass = result === expect;
    console.log(`${pass ? "✓" : "ERROR ====>"} ${x} => ${result}`);
    return pass;
}

let failures = 0;
failures += !test(0,        "0");
failures += !test(100,      "100");
failures += !test(1000,     "1,000");
failures += !test(10000,    "10,000");
failures += !test(100000,   "100,000");
failures += !test(1000000,  "1,000,000");
failures += !test(10000000, "10,000,000");
if (failures) {
    console.log(`${failures} test(s) failed`);
} else {
    console.log("All tests passed");
}

.as-console-wrapper {
    max-height: 100% !important;
}

රීජෙක්ස් පෙනුම දෙස බලන ප්‍රකාශ 2 ක් භාවිතා කරයි:

• පේළියක ඉලක්කම් 3 ක ගුණකයක් ඇති නූලෙහි ඕනෑම ලක්ෂ්‍යයක් සොයා බැලීමට ධනාත්මක එකක්,
• එම ලක්ෂ්‍යයට ඇත්තේ හරියටම ඉලක්කම් 3 ක ගුණයක් පමණක් බව තහවුරු කර ගැනීම සඳහා negative ණාත්මක ප්‍රකාශයකි. ආදේශන ප්‍රකාශනය එහි කොමාවක් තබයි.

නිදසුනක් ලෙස, ඔබ එය සමත් වුවහොත් 123456789.01, ධනාත්මක ප්‍රකාශය සෑම ස්ථානයකම 7 හි වමට ගැලපේ ( 789ඉලක්කම් 3 ක ගුණකයක් බැවින්, ඉලක්කම් 3 කින් 678යුත් ගුණකය 567, ආදිය). 3 ණාත්මක ප්‍රකාශය මඟින් ඉලක්කම් 3 න් ගුණ කිරීමෙන් පසුව කිසිදු ඉලක්කයක් නොමැති බව පරීක්ෂා කරයි. 789එය පසු කාල පරිච්ඡේදයක් ඇති බැවින් එය හරියටම ඉලක්කම් 3 කින් ගුණ කිරීමකි, එබැවින් කොමාව එහි යයි. 678ඉලක්කම් 3 ක ගුණනයකි, නමුත් එයට 9පසුව ඇත, එබැවින් එම ඉලක්කම් 3 4 ක කණ්ඩායමක කොටසක් වන අතර කොමාව එහි නොයයි. ඒ හා සමානව567 . 456789ඉලක්කම් 6 ක් වන අතර එය 3 න් ගුණ කිරීමකි, එබැවින් කොමාව ඊට පෙර යයි. 3456783 න් ගුණ කිරීමකි, නමුත් එයට 9පසුව ඇත, එබැවින් කොමාවක් එහි නොයයි. සහ යනාදි. එම\B නූල ආරම්භයේ දී කොමාව තැබීමෙන් රීජෙක්ස් වළක්වයි.

@ Neu-දෙබොරා දශම ස්ථාන පසු ඉලක්කම් 3 ට වඩා වැඩි වේ නම් මෙම කාර්යය අනවශ්ය ස්ථානවල කොමා බව අපි සඳහන්. මෙය ගැටළුවක් නම්, ඔබට මෙම ශ්‍රිතය භාවිතා කළ හැකිය:

function numberWithCommas(x) {
    var parts = x.toString().split(".");
    parts[0] = parts[0].replace(/\B(?=(\d{3})+(?!\d))/g, ",");
    return parts.join(".");
}

function numberWithCommas(x) {
    var parts = x.toString().split(".");
    parts[0] = parts[0].replace(/\B(?=(\d{3})+(?!\d))/g, ",");
    return parts.join(".");
}

function test(x, expect) {
    const result = numberWithCommas(x);
    const pass = result === expect;
    console.log(`${pass ? "✓" : "ERROR ====>"} ${x} => ${result}`);
    return pass;
}

let failures = 0;
failures += !test(0              , "0");
failures += !test(0.123456       , "0.123456");
failures += !test(100            , "100");
failures += !test(100.123456     , "100.123456");
failures += !test(1000           , "1,000");
failures += !test(1000.123456    , "1,000.123456");
failures += !test(10000          , "10,000");
failures += !test(10000.123456   , "10,000.123456");
failures += !test(100000         , "100,000");
failures += !test(100000.123456  , "100,000.123456");
failures += !test(1000000        , "1,000,000");
failures += !test(1000000.123456 , "1,000,000.123456");
failures += !test(10000000       , "10,000,000");
failures += !test(10000000.123456, "10,000,000.123456");
if (failures) {
    console.log(`${failures} test(s) failed`);
} else {
    console.log("All tests passed");
}

.as-console-wrapper {
    max-height: 100% !important;
}

@ Tjcrowder දැන් JavaScript (lookbehind ඇති බව පෙන්වා දුන්නේ සහයෝගය තොරතුරු ), එය සාමාන්ය ලෙස ම විසඳා ගත හැකිය:

function numberWithCommas(x) {
    return x.toString().replace(/\B(?<!\.\d*)(?=(\d{3})+(?!\d))/g, ",");
}

function numberWithCommas(x) {
    return x.toString().replace(/\B(?<!\.\d*)(?=(\d{3})+(?!\d))/g, ",");
}

function test(x, expect) {
    const result = numberWithCommas(x);
    const pass = result === expect;
    console.log(`${pass ? "✓" : "ERROR ====>"} ${x} => ${result}`);
    return pass;
}

let failures = 0;
failures += !test(0,               "0");
failures += !test(0.123456,        "0.123456");
failures += !test(100,             "100");
failures += !test(100.123456,      "100.123456");
failures += !test(1000,            "1,000");
failures += !test(1000.123456,     "1,000.123456");
failures += !test(10000,           "10,000");
failures += !test(10000.123456,    "10,000.123456");
failures += !test(100000,          "100,000");
failures += !test(100000.123456,   "100,000.123456");
failures += !test(1000000,         "1,000,000");
failures += !test(1000000.123456,  "1,000,000.123456");
failures += !test(10000000,        "10,000,000");
failures += !test(10000000.123456, "10,000,000.123456");
if (failures) {
    console.log(`${failures} test(s) failed`);
} else {
    console.log("All tests passed");
}

.as-console-wrapper {
    max-height: 100% !important;
}

(?<!\.\d*)a ණාත්මක බැල්මකි, එයින් කියැවෙන්නේ තරඟයට පෙර .ශුන්‍ය හෝ ඊට වැඩි සංඛ්‍යාවක් තිබිය නොහැකි බවයි. 8 ණාත්මක බැල්ම පිටුපස අවම වශයෙන් V8 හි splitසහ joinවිසඳුමට ( සංසන්දනය ) වඩා වේගවත් වේ .

කිසිවෙකු පුදුමයට පත් නොවීම පුදුමයට කරුණකි . Number.prototype.toLocaleString . එය ජාවාස්ක්‍රිප්ට් 1.5 හි ක්‍රියාත්මක කර ඇත (එය 1999 දී හඳුන්වා දෙන ලදි) එබැවින් එයට මූලික වශයෙන් සියලුම ප්‍රධාන බ්‍රව්සර් හරහා සහාය ලැබේ.

var n = 34523453.345
n.toLocaleString()
"34,523,453.345"

ඇතුළත් කිරීම හරහා v0.12 වන විට එය Node.js හි ද ක්‍රියා කරයි Intl

මෙම ශ්‍රිතය සංඛ්‍යාවක් නොව නූලක් ලබා දෙන බව අවධානය යොමු කරන්න.

ඔබට වෙනස් දෙයක් අවශ්‍ය නම්, Numeral.js සිත්ගන්නා සුළු විය හැකිය.

var number = 1234567890; // Example number to be converted

JavaScript හි උපරිම නිඛිල අගය 9007199254740991 බව මතක තබා ගන්න

toLocaleString :

number.toLocaleString(); // "1,234,567,890"

// A more complex example: 
var number2 = 1234.56789; // floating point example
number2.toLocaleString(undefined, {maximumFractionDigits:2}) // "1,234.57"

අංක ෆෝමැට් ( සෆාරි සහාය නොදක්වයි):

var nf = new Intl.NumberFormat();
nf.format(number); // "1,234,567,890"

මා පරීක්ෂා කළ දෙයින් (අවම වශයෙන් ෆයර්ෆොක්ස්) ඒවා දෙකම කාර්ය සාධනය සම්බන්ධයෙන් අඩු හෝ වැඩි වශයෙන් සමාන වේ.

මම යෝජනා කරන්නේ phpjs.org හි අංක_ ආකෘතිය ()

function number_format(number, decimals, dec_point, thousands_sep) {
    // http://kevin.vanzonneveld.net
    // +   original by: Jonas Raoni Soares Silva (http://www.jsfromhell.com)
    // +   improved by: Kevin van Zonneveld (http://kevin.vanzonneveld.net)
    // +     bugfix by: Michael White (http://getsprink.com)
    // +     bugfix by: Benjamin Lupton
    // +     bugfix by: Allan Jensen (http://www.winternet.no)
    // +    revised by: Jonas Raoni Soares Silva (http://www.jsfromhell.com)
    // +     bugfix by: Howard Yeend
    // +    revised by: Luke Smith (http://lucassmith.name)
    // +     bugfix by: Diogo Resende
    // +     bugfix by: Rival
    // +      input by: Kheang Hok Chin (http://www.distantia.ca/)
    // +   improved by: davook
    // +   improved by: Brett Zamir (http://brett-zamir.me)
    // +      input by: Jay Klehr
    // +   improved by: Brett Zamir (http://brett-zamir.me)
    // +      input by: Amir Habibi (http://www.residence-mixte.com/)
    // +     bugfix by: Brett Zamir (http://brett-zamir.me)
    // +   improved by: Theriault
    // +   improved by: Drew Noakes
    // *     example 1: number_format(1234.56);
    // *     returns 1: '1,235'
    // *     example 2: number_format(1234.56, 2, ',', ' ');
    // *     returns 2: '1 234,56'
    // *     example 3: number_format(1234.5678, 2, '.', '');
    // *     returns 3: '1234.57'
    // *     example 4: number_format(67, 2, ',', '.');
    // *     returns 4: '67,00'
    // *     example 5: number_format(1000);
    // *     returns 5: '1,000'
    // *     example 6: number_format(67.311, 2);
    // *     returns 6: '67.31'
    // *     example 7: number_format(1000.55, 1);
    // *     returns 7: '1,000.6'
    // *     example 8: number_format(67000, 5, ',', '.');
    // *     returns 8: '67.000,00000'
    // *     example 9: number_format(0.9, 0);
    // *     returns 9: '1'
    // *    example 10: number_format('1.20', 2);
    // *    returns 10: '1.20'
    // *    example 11: number_format('1.20', 4);
    // *    returns 11: '1.2000'
    // *    example 12: number_format('1.2000', 3);
    // *    returns 12: '1.200'
    var n = !isFinite(+number) ? 0 : +number, 
        prec = !isFinite(+decimals) ? 0 : Math.abs(decimals),
        sep = (typeof thousands_sep === 'undefined') ? ',' : thousands_sep,
        dec = (typeof dec_point === 'undefined') ? '.' : dec_point,
        toFixedFix = function (n, prec) {
            // Fix for IE parseFloat(0.55).toFixed(0) = 0;
            var k = Math.pow(10, prec);
            return Math.round(n * k) / k;
        },
        s = (prec ? toFixedFix(n, prec) : Math.round(n)).toString().split('.');
    if (s[0].length > 3) {
        s[0] = s[0].replace(/\B(?=(?:\d{3})+(?!\d))/g, sep);
    }
    if ((s[1] || '').length < prec) {
        s[1] = s[1] || '';
        s[1] += new Array(prec - s[1].length + 1).join('0');
    }
    return s.join(dec);
}

යාවත්කාලීන කිරීම 02/13/14

මිනිසුන් වාර්තා කර ඇති පරිදි මෙය අපේක්ෂා කළ පරිදි ක්‍රියාත්මක නොවේ, එබැවින් මම ස්වයංක්‍රීය පරීක්ෂණ ඇතුළත් JS Fiddle එකක් කළෙමි .

යාවත්කාලීන කිරීම 26/11/2017

තරමක් වෙනස් කරන ලද නිමැවුම් සහිත ස්ටැක් ස්නිපටයක් ලෙස එම ප්‍රහේලිකාව මෙන්න:

function number_format(number, decimals, dec_point, thousands_sep) {
    // http://kevin.vanzonneveld.net
    // +   original by: Jonas Raoni Soares Silva (http://www.jsfromhell.com)
    // +   improved by: Kevin van Zonneveld (http://kevin.vanzonneveld.net)
    // +     bugfix by: Michael White (http://getsprink.com)
    // +     bugfix by: Benjamin Lupton
    // +     bugfix by: Allan Jensen (http://www.winternet.no)
    // +    revised by: Jonas Raoni Soares Silva (http://www.jsfromhell.com)
    // +     bugfix by: Howard Yeend
    // +    revised by: Luke Smith (http://lucassmith.name)
    // +     bugfix by: Diogo Resende
    // +     bugfix by: Rival
    // +      input by: Kheang Hok Chin (http://www.distantia.ca/)
    // +   improved by: davook
    // +   improved by: Brett Zamir (http://brett-zamir.me)
    // +      input by: Jay Klehr
    // +   improved by: Brett Zamir (http://brett-zamir.me)
    // +      input by: Amir Habibi (http://www.residence-mixte.com/)
    // +     bugfix by: Brett Zamir (http://brett-zamir.me)
    // +   improved by: Theriault
    // +   improved by: Drew Noakes
    // *     example 1: number_format(1234.56);
    // *     returns 1: '1,235'
    // *     example 2: number_format(1234.56, 2, ',', ' ');
    // *     returns 2: '1 234,56'
    // *     example 3: number_format(1234.5678, 2, '.', '');
    // *     returns 3: '1234.57'
    // *     example 4: number_format(67, 2, ',', '.');
    // *     returns 4: '67,00'
    // *     example 5: number_format(1000);
    // *     returns 5: '1,000'
    // *     example 6: number_format(67.311, 2);
    // *     returns 6: '67.31'
    // *     example 7: number_format(1000.55, 1);
    // *     returns 7: '1,000.6'
    // *     example 8: number_format(67000, 5, ',', '.');
    // *     returns 8: '67.000,00000'
    // *     example 9: number_format(0.9, 0);
    // *     returns 9: '1'
    // *    example 10: number_format('1.20', 2);
    // *    returns 10: '1.20'
    // *    example 11: number_format('1.20', 4);
    // *    returns 11: '1.2000'
    // *    example 12: number_format('1.2000', 3);
    // *    returns 12: '1.200'
    var n = !isFinite(+number) ? 0 : +number, 
        prec = !isFinite(+decimals) ? 0 : Math.abs(decimals),
        sep = (typeof thousands_sep === 'undefined') ? ',' : thousands_sep,
        dec = (typeof dec_point === 'undefined') ? '.' : dec_point,
        toFixedFix = function (n, prec) {
            // Fix for IE parseFloat(0.55).toFixed(0) = 0;
            var k = Math.pow(10, prec);
            return Math.round(n * k) / k;
        },
        s = (prec ? toFixedFix(n, prec) : Math.round(n)).toString().split('.');
    if (s[0].length > 3) {
        s[0] = s[0].replace(/\B(?=(?:\d{3})+(?!\d))/g, sep);
    }
    if ((s[1] || '').length < prec) {
        s[1] = s[1] || '';
        s[1] += new Array(prec - s[1].length + 1).join('0');
    }
    return s.join(dec);
}

var exampleNumber = 1;
function test(expected, number, decimals, dec_point, thousands_sep)
{
    var actual = number_format(number, decimals, dec_point, thousands_sep);
    console.log(
        'Test case ' + exampleNumber + ': ' +
        '(decimals: ' + (typeof decimals === 'undefined' ? '(default)' : decimals) +
        ', dec_point: "' + (typeof dec_point === 'undefined' ? '(default)' : dec_point) + '"' +
        ', thousands_sep: "' + (typeof thousands_sep === 'undefined' ? '(default)' : thousands_sep) + '")'
    );
    console.log('  => ' + (actual === expected ? 'Passed' : 'FAILED') + ', got "' + actual + '", expected "' + expected + '".');
    exampleNumber++;
}

test('1,235',    1234.56);
test('1 234,56', 1234.56, 2, ',', ' ');
test('1234.57',  1234.5678, 2, '.', '');
test('67,00',    67, 2, ',', '.');
test('1,000',    1000);
test('67.31',    67.311, 2);
test('1,000.6',  1000.55, 1);
test('67.000,00000', 67000, 5, ',', '.');
test('1',        0.9, 0);
test('1.20',     '1.20', 2);
test('1.2000',   '1.20', 4);
test('1.200',    '1.2000', 3);

.as-console-wrapper {
  max-height: 100% !important;
}

මෙය ike mikez302 හි පිළිතුරේ විචලනයකි, නමුත් දශම සංඛ්‍යා සමඟ ආධාරක ලෙස වෙනස් කර ඇත (@ නියු-රාගේ ප්‍රතිපෝෂණය අනුව අංක විත්කොමාස් (12345.6789) -> "12,345.6789" වෙනුවට "12,345.6,789"

function numberWithCommas(n) {
    var parts=n.toString().split(".");
    return parts[0].replace(/\B(?=(\d{3})+(?!\d))/g, ",") + (parts[1] ? "." + parts[1] : "");
}

function formatNumber (num) {
    return num.toString().replace(/(\d)(?=(\d{3})+(?!\d))/g, "$1,")
}

print(formatNumber(2665));      // 2,665
print(formatNumber(102665));    // 102,665
print(formatNumber(111102665)); // 111,102,665

නිත්‍ය ප්‍රකාශනය භාවිතා කිරීම

function toCommas(value) {
    return value.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ",");
}
console.log(toCommas(123456789)); // 123,456,789

console.log(toCommas(1234567890)); // 1,234,567,890
console.log(toCommas(1234)); // 1,234

ToLocaleString භාවිතා කිරීම ()

var number = 123456.789;

// request a currency format
console.log(number.toLocaleString('de-DE', { style: 'currency', currency: 'EUR' }));
// → 123.456,79 €

// the Japanese yen doesn't use a minor unit
console.log(number.toLocaleString('ja-JP', { style: 'currency', currency: 'JPY' }))
// → ￥123,457

// limit to three significant digits
console.log(number.toLocaleString('en-IN', { maximumSignificantDigits: 3 }));
// → 1,23,000

ref MDN: Number.prototype.toLocaleString ()

Intl.NumberFormat () භාවිතා කිරීම

var number = 123456.789;

console.log(new Intl.NumberFormat('de-DE', { style: 'currency', currency: 'EUR' }).format(number));
// expected output: "123.456,79 €"

// the Japanese yen doesn't use a minor unit
console.log(new Intl.NumberFormat('ja-JP', { style: 'currency', currency: 'JPY' }).format(number));
// expected output: "￥123,457"

// limit to three significant digits
console.log(new Intl.NumberFormat('en-IN', { maximumSignificantDigits: 3 }).format(number));

// expected output: "1,23,000"

ref Intl.NumberFormat

ඩෙමෝ මෙතැනින්

<script type="text/javascript">
  // Using Regular expression
  function toCommas(value) {
    return value.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ",");
  }

  function commas() {
    var num1 = document.myform.number1.value;

    // Using Regular expression
    document.getElementById('result1').value = toCommas(parseInt(num1));
    // Using toLocaleString()

    document.getElementById('result2').value = parseInt(num1).toLocaleString('ja-JP', {
      style: 'currency',
      currency: 'JPY'
    });

    // Using Intl.NumberFormat()
    document.getElementById('result3').value = new Intl.NumberFormat('ja-JP', {
      style: 'currency',
      currency: 'JPY'
    }).format(num1);
  }
</script>
<FORM NAME="myform">
  <INPUT TYPE="text" NAME="number1" VALUE="123456789">
  <br>
  <INPUT TYPE="button" NAME="button" Value="=>" onClick="commas()">
  <br>Using Regular expression
  <br>
  <INPUT TYPE="text" ID="result1" NAME="result1" VALUE="">
  <br>Using toLocaleString()
  <br>
  <INPUT TYPE="text" ID="result2" NAME="result2" VALUE="">
  <br>Using Intl.NumberFormat()
  <br>
  <INPUT TYPE="text" ID="result3" NAME="result3" VALUE="">

</FORM>

කාර්ය සාධනය

http://jsben.ch/sifRd

Intl.NumberFormat

ස්වදේශීය JS ශ්‍රිතය. IE11, Edge, නවතම සෆාරි, ක්‍රෝම්, ෆයර්ෆොක්ස්, ඔපෙරා, iOS හි සෆාරි සහ ඇන්ඩ්‍රොයිඩ් හි ක්‍රෝම් සහාය දක්වයි.

var number = 3500;

console.log(new Intl.NumberFormat().format(number));
// → '3,500' if in US English locale

ඔවුන්ගේ පිළිතුරු සඳහා සැමට ස්තූතියි. වඩාත් “එක්-ප්‍රමාණයට ගැළපෙන-සියල්ල” විසඳුමක් ලබා දීම සඳහා මම සමහර පිළිතුරු වලින් ඉවත් කර ඇත්තෙමි.

පළමු ස්නිපටය PHP හි number_format()සංඛ්‍යා මූලාකෘතියට අනුකරණය කරන ශ්‍රිතයක් එක් කරයි . මම අංකයක් සංයුති කරන්නේ නම්, මට සාමාන්‍යයෙන් දශම ස්ථාන අවශ්‍ය වේ, එම නිසා ශ්‍රිතය පෙන්වීමට දශම ස්ථාන ගණන ගනී. සමහර රටවල් කොමාව දශම ලෙස ද දශම දහස් ගණනක් බෙදුම්කරු ලෙස ද භාවිතා කරයි, එම නිසා මෙම බෙදුම්කරුවන් සැකසීමට ශ්‍රිතය ඉඩ දෙයි.

Number.prototype.numberFormat = function(decimals, dec_point, thousands_sep) {
    dec_point = typeof dec_point !== 'undefined' ? dec_point : '.';
    thousands_sep = typeof thousands_sep !== 'undefined' ? thousands_sep : ',';

    var parts = this.toFixed(decimals).split('.');
    parts[0] = parts[0].replace(/\B(?=(\d{3})+(?!\d))/g, thousands_sep);

    return parts.join(dec_point);
}

ඔබ මෙය පහත පරිදි භාවිතා කරනු ඇත:

var foo = 5000;
console.log(foo.numberFormat(2)); // us format: 5,000.00
console.log(foo.numberFormat(2, ',', '.')); // european format: 5.000,00

ගණිත මෙහෙයුම් සඳහා අංකය නැවත ලබා ගැනීමට මට බොහෝ විට අවශ්‍ය බව මට පෙනී ගියේය, නමුත් parseFloat 5,000 සිට 5 දක්වා පරිවර්තනය කරයි, හුදෙක් පූර්ණ සංඛ්‍යා අගයන්හි පළමු අනුක්‍රමය ගනී. ඒ නිසා මම මගේම පාවෙන පරිවර්තන ශ්‍රිතයක් නිර්මාණය කර එය String මූලාකෘතියට එකතු කළෙමි.

String.prototype.getFloat = function(dec_point, thousands_sep) {
    dec_point = typeof dec_point !== 'undefined' ? dec_point : '.';
    thousands_sep = typeof thousands_sep !== 'undefined' ? thousands_sep : ',';

    var parts = this.split(dec_point);
    var re = new RegExp("[" + thousands_sep + "]");
    parts[0] = parts[0].replace(re, '');

    return parseFloat(parts.join(dec_point));
}

දැන් ඔබට කාර්යයන් දෙකම පහත පරිදි භාවිතා කළ හැකිය:

var foo = 5000;
var fooString = foo.numberFormat(2); // The string 5,000.00
var fooFloat = fooString.getFloat(); // The number 5000;

console.log((fooString.getFloat() + 1).numberFormat(2)); // The string 5,001.00

මෙම ප්‍රශ්නයට ලැබී ඇති පිළිතුරු ගණන ගැන මා තුළ පැහැදීමක් ඇත. මම කොල්කාගේ පිළිතුරට කැමතියි :

n.toLocaleString()

නමුත් අවාසනාවකට මෙන්, ස්පා Spanish ් like වැනි සමහර ප්‍රදේශවල, 10,000 ට අඩු සංඛ්‍යා සඳහා අපේක්ෂිත පරිදි එය ක්‍රියාත්මක නොවේ (IMHO):

Number(1000).toLocaleString('ES-es')

ලබා දෙයි 1000සහ නැත1.000 .

සියළුම බ්‍රව්සර්වල 10000 ට අඩු සංඛ්‍යා මත වැඩ නොකිරීමට toLocaleString බලන්න .

එබැවින් නිවැරදි දහස් සංඛ්‍යාත බෙදුම්කරුගේ චරිතය තෝරාගෙන එලියාස් සමාරියාගේ පිළිතුර භාවිතා කිරීමට මට සිදු විය :

n.toString().replace(/\B(?=(\d{3})+(?!\d))/g, Number(10000).toLocaleString().substring(2, 3))

මෙය භාවිතා කරන ,හෝ .දහස් ගණනක් බෙදුම්කරු ලෙස භාවිතා කරන ස්ථාන දෙකටම එක් ලයිනර් ලෙස හොඳින් ක්‍රියා කරන අතර සෑම අවස්ථාවකම 1,000 සිට වැඩ කිරීමට පටන් ගනී.

Number(1000).toString().replace(/\B(?=(\d{3})+(?!\d))/g, Number(10000).toLocaleString().substring(2, 3))

ලබා දෙයි 1.000ස්පා Spanish ් loc ස්ථානීය සන්දර්භයක් සමඟ .

අංකයක් සංයුති කර ඇති ආකාරය පිළිබඳ නිරපේක්ෂ පාලනයක් ලබා ගැනීමට ඔබට අවශ්‍ය නම්, ඔබට පහත සඳහන් දෑ ද උත්සාහ කළ හැකිය:

let number   = 1234.567
let decimals = 2
let decpoint = '.' // Or Number(0.1).toLocaleString().substring(1, 2)
let thousand = ',' // Or Number(10000).toLocaleString().substring(2, 3)

let n = Math.abs(number).toFixed(decimals).split('.')
n[0] = n[0].split('').reverse().map((c, i, a) =>
  i > 0 && i < a.length && i % 3 == 0 ? c + thousand : c
).reverse().join('')
let final = (Math.sign(number) < 0 ? '-' : '') + n.join(decpoint)

console.log(final)

ලබා දෙයි 1,234.57 .

මේ සඳහා නිත්‍ය ප්‍රකාශනයක් අවශ්‍ය නොවේ. එය ක්‍රියාත්මක වන්නේ toFixedපළමුවෙන් සංඛ්‍යාව අපේක්ෂිත දශම ප්‍රමාණයට ගැලපීමෙන් වන අතර , එකක් තිබේ නම් එය දශම ලක්ෂ්‍යය වටා බෙදයි .. වම් පැත්ත ආපසු හරවන ලද ඉලක්කම් සමූහයක් බවට හරවනු ලැබේ. ආරම්භයේ සිට සෑම ඉලක්කම් තුනකටම බෙදුම්කරුවෙකු දහස් ගණනක් එකතු කරන අතර ප්‍රති result ලය නැවත ආපසු හැරේ. අවසාන ප්‍රති result ලය වන්නේ කොටස් දෙක ඒකාබද්ධ වීමයි. ආදාන අංකයේ ලකුණ ඉවත් කරනු ලැබේMath.abs පළමුව අවශ්‍ය නම් නැවත තබන්න.

එය එක් ලයිනර් එකක් නොව වැඩි කාලයක් හා පහසුවෙන් ශ්‍රිතයක් බවට පත් නොවේ. පැහැදිලිකම සඳහා විචල්‍යයන් එකතු කර ඇති නමුත් ඒවා කල්තියා දැනගත හොත් ඒවා අපේක්ෂිත අගයන් මගින් ආදේශ කළ හැකිය. toLocaleStringදශම ලක්ෂ්‍යය සඳහා නිවැරදි අක්ෂර සොයා ගැනීමට සහ වර්තමාන පෙදෙස සඳහා දහස් සංඛ්‍යාත බෙදුම්කරු සොයා ගැනීමට ඔබට භාවිතා කළ හැකි ප්‍රකාශන භාවිතා කළ හැකිය (ඒවාට වඩාත් නවීන ජාවාස්ක්‍රිප්ට් අවශ්‍ය බව මතක තබා ගන්න.)

මම හිතන්නේ මෙය කරන කෙටිම නිත්‍ය ප්‍රකාශනය මෙයයි:

/\B(?=(\d{3})+\b)/g

"123456".replace(/\B(?=(\d{3})+\b)/g, ",")

මම එය අංක කිහිපයකින් පරීක්ෂා කළ අතර එය ක්‍රියාත්මක විය.

Number.prototype.toLocaleString()එය සියලු බ්‍රව්සර් (සෆාරි) විසින් දේශීයව ලබා දුන්නේ නම් නියමයි .

මම අනෙක් සියලුම පිළිතුරු පරික්ෂා කළ නමුත් කිසිවෙකු එය පොලිෆිල් කරන බවක් නොපෙනුණි. මෙන්න ඒ දෙසට යොමු කිරීමකි, එය ඇත්ත වශයෙන්ම පළමු පිළිතුරු දෙකේ එකතුවකි; නම් toLocaleStringඑය චාරිත්රයක් කාර්යය භාවිතා නොවේ නම් වැඩ එය, එය භාවිතා කරයි.

var putThousandsSeparators;

putThousandsSeparators = function(value, sep) {
  if (sep == null) {
    sep = ',';
  }
  // check if it needs formatting
  if (value.toString() === value.toLocaleString()) {
    // split decimals
    var parts = value.toString().split('.')
    // format whole numbers
    parts[0] = parts[0].replace(/\B(?=(\d{3})+(?!\d))/g, sep);
    // put them back together
    value = parts[1] ? parts.join('.') : parts[0];
  } else {
    value = value.toLocaleString();
  }
  return value;
};

alert(putThousandsSeparators(1234567.890));

බ්‍රව්සරයේ Intlවස්තුව භාවිතයෙන් දහස් සංඛ්‍යාත බෙදුම්කරු ජාත්‍යන්තර හිතකාමී ලෙස ඇතුළත් කළ හැකිය :

Intl.NumberFormat().format(1234);
// returns "1,234" if the user's locale is en_US, for example

වැඩි විස්තර සඳහා අංක ෆෝමැට් පිළිබඳ එම්ඩීඑන් ලිපිය බලන්න , ඔබට ස්ථානීය හැසිරීම හෝ පෙරනිමිය පරිශීලකයාගේ නියම කළ හැකිය. මෙය දේශීය වෙනස්කම් වලට ගරු කරන නිසා මෙය තව ටිකක් මෝඩකමකි; බොහෝ රටවල් ඉලක්කම් වෙන් කිරීම සඳහා කාල පරිච්ඡේද භාවිතා කරන අතර කොමාව මඟින් දශමයන් දක්වයි.

Intl.NumberFormat තවමත් සියලුම බ්‍රව්සර් වල නොමැත, නමුත් එය නවතම Chrome, Opera, සහ IE වල ක්‍රියා කරයි. ෆයර්ෆොක්ස් හි ඊළඟ නිකුතුව එයට සහාය විය යුතුය. වෙබ්කිට් ක්‍රියාත්මක කිරීම සඳහා කාලරාමුවක් ඇති බවක් නොපෙනේ.

ඔබේ මුදල් අවශ්‍යතාවය සංයුති කිරීමට ඔබට මෙම ක්‍රියා පටිපාටිය භාවිතා කළ හැකිය.

var nf = new Intl.NumberFormat('en-US', {
  style: 'currency',
  currency: 'USD',
  minimumFractionDigits: 2,
  maximumFractionDigits: 2
});
nf.format(123456.789); // ‘$123,456.79’

වැඩි විස්තර සඳහා ඔබට මෙම සබැඳියට පිවිසිය හැකිය.

https://www.justinmccandless.com/post/formatting-currency-in-javascript/

ඔබ මුදල් වටිනාකම් සමඟ ගනුදෙනු කරන්නේ නම් සහ බොහෝ හැඩතල ගැන්වීම් කරන්නේ නම්, ඉතා සුළු අවස්ථා සහ ප්‍රාදේශීයකරණයන් හසුරුවන කුඩා ගිණුම්කරණය එකතු කිරීම වටී :

// Default usage:
accounting.formatMoney(12345678); // $12,345,678.00

// European formatting (custom symbol and separators), could also use options object as second param:
accounting.formatMoney(4999.99, "€", 2, ".", ","); // €4.999,99

// Negative values are formatted nicely, too:
accounting.formatMoney(-500000, "£ ", 0); // £ -500,000

// Simple `format` string allows control of symbol position [%v = value, %s = symbol]:
accounting.formatMoney(5318008, { symbol: "GBP",  format: "%v %s" }); // 5,318,008.00 GBP

පහත කේතය වර්‍ග ස්කෑන් භාවිතා කරයි, එබැවින් රීජෙක්ස් නොමැත.

function commafy( num){
  var parts = (''+(num<0?-num:num)).split("."), s=parts[0], L, i=L= s.length, o='';
  while(i--){ o = (i===0?'':((L-i)%3?'':',')) 
                  +s.charAt(i) +o }
  return (num<0?'-':'') + o + (parts[1] ? '.' + parts[1] : ''); 
}

එය යහපත් කාර්ය සාධනයක් පෙන්වයි: http://jsperf.com/number-formatting-with-commas/5

2015.4.26: අංක <0 වන විට ගැටළුව විසඳීම සඳහා සුළු විසඳුමක්. Https://jsfiddle.net/runsun/p5tqqvs3/ බලන්න

බෙදුම්කරුවන් දහසක් සඳහා කොමාව ඇතුළත් කරන සරල ශ්‍රිතයක් මෙන්න. එය RegEx එකකට වඩා අරාව ශ්‍රිත භාවිතා කරයි.

/**
 * Format a number as a string with commas separating the thousands.
 * @param num - The number to be formatted (e.g. 10000)
 * @return A string representing the formatted number (e.g. "10,000")
 */
var formatNumber = function(num) {
    var array = num.toString().split('');
    var index = -3;
    while (array.length + index > 0) {
        array.splice(index, 0, ',');
        // Decrement by 4 since we just added another unit to the array.
        index -= 4;
    }
    return array.join('');
};

උදාහරණ සමඟ CodeSandbox සබැඳිය: https://codesandbox.io/s/p38k63w0vq

ඉන්දියාව සඳහා මුදල් ආකෘතිය හැසිරවීමට මෙම කේතය භාවිතා කරන්න. වෙනත් රටක මුදල් හැසිරවීම සඳහා රට කේතය වෙනස් කළ හැකිය.

let amount =350256.95
var formatter = new Intl.NumberFormat('en-IN', {
  minimumFractionDigits: 2,
});

// Use it.

formatter.format(amount);

ප්‍රතිදානය:

3,50,256.95

ඔබට Intl.NumberFormat ඉදිකිරීම්කරු ද භාවිතා කළ හැකිය . මෙන්න ඔබට එය කළ හැකි ආකාරය.

 resultNumber = new Intl.NumberFormat('en-IN', { maximumSignificantDigits: 3 }).format(yourNumber); 

මෙම තනතුරට බාධා කිරීමට පෙර මම මෙය ලිවීය. රීජෙක්ස් නොමැති අතර ඔබට ඇත්ත වශයෙන්ම කේතය තේරුම් ගත හැකිය.

$(function(){
  
  function insertCommas(s) {

    // get stuff before the dot
    var d = s.indexOf('.');
    var s2 = d === -1 ? s : s.slice(0, d);

    // insert commas every 3 digits from the right
    for (var i = s2.length - 3; i > 0; i -= 3)
      s2 = s2.slice(0, i) + ',' + s2.slice(i);

    // append fractional part
    if (d !== -1)
      s2 += s.slice(d);

    return s2;

  }
  
  
  $('#theDudeAbides').text( insertCommas('1234567.89012' ) );
  
  
});

<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.11.1/jquery.min.js"></script>

<div id="theDudeAbides"></div>

var formatNumber = function (number) {
  var splitNum;
  number = Math.abs(number);
  number = number.toFixed(2);
  splitNum = number.split('.');
  splitNum[0] = splitNum[0].replace(/\B(?=(\d{3})+(?!\d))/g, ",");
  return splitNum.join(".");
}

සංස්කරණය කරන්න: ශ්‍රිතය ක්‍රියාත්මක වන්නේ ධන සංඛ්‍යා සමඟ පමණි. නිදර්ශනය සඳහා:

var number = -123123231232;
formatNumber(number)

ප්‍රතිදානය: "123,123,231,232"

නමුත් ඉහත toLocaleString()ක්‍රමයට ප්‍රශ්නයට පිළිතුරු සැපයීම ගැටළුව විසඳයි.

var number = 123123231232;
    number.toLocaleString()

ප්‍රතිදානය: "123,123,231,232"

ප්‍රීති වන්න!

JQuery සම්පූර්ණයෙන්ම සංවේදී විකල්පයක් සමඟ ප්‍රතිස්ථාපනය කරන එකම පිළිතුර මගේ පිළිතුරයි:

function $(dollarAmount)
{
    const locale = 'en-US';
    const options = { style: 'currency', currency: 'USD' };
    return Intl.NumberFormat(locale, options).format(dollarAmount);
}

මෙම විසඳුම කොමාව එකතු කරනවා පමණක් නොව, $(1000.9999)ඔබට ඩොලර් 1,001.00 ක් වැනි මුදලක් ඇතුළත් කළහොත් එය ළඟම ඇති සතයටද වටේ. මීට අමතරව, ඔබ ආදානය කරන අගය ආරක්ෂිතව අංකයක් හෝ නූලක් විය හැකිය; කමක් නැහැ.

ඔබ මුදල් සමඟ ගනුදෙනු කරන්නේ නම්, නමුත් ප්‍රමාණයෙන් පෙන්වන ප්‍රමුඛ ඩොලර් ලකුණක් අවශ්‍ය නොවන්නේ නම්, ඔබට මෙම ශ්‍රිතය එකතු කළ හැකිය, එය පෙර ශ්‍රිතය භාවිතා කළ නමුත් ඉවත් කරයි $:

function no$(dollarAmount)
{
    return $(dollarAmount).replace('$','');
}

ඔබ කරන්නේ නම් නෑ මුදල් සමඟ ගනුදෙනු කිරීම සහ අවශ්යතා හැඩතල දශම විවිධ ඇත, මෙහි වඩාත් බහුකාර්ය කි්රයාකාරීත්වයන්:

function addCommas(number, minDecimalPlaces = 0, maxDecimalPlaces = Math.max(3,minDecimalPlaces))
{
    const options = {};
    options.maximumFractionDigits = maxDecimalPlaces;
    options.minimumFractionDigits = minDecimalPlaces;
    return Intl.NumberFormat('en-US',options).format(number);
}

ඉන්ටර්නෙට් එක්ස්ප්ලෝරර් හි සමහර පැරණි අනුවාද වල මෙම කේතය ක්‍රියා නොකිරීම සම්පූර්ණයෙන්ම හිතාමතා ය. නවීන ප්‍රමිතීන්ට අනුබල නොදී මට එය අල්ලා ගත හැකි ඕනෑම වේලාවක IE බිඳ දැමීමට උත්සාහ කරමි.

අදහස් දැක්වීමේ කොටසෙහි අධික ප්‍රශංසාව මාතෘකාවෙන් බැහැරව සලකන බව කරුණාවෙන් මතක තබා ගන්න. ඒ වෙනුවට, මට ඉහළ ඡන්ද වලින් ස්නානය කරන්න.

මට නම්, හොඳම පිළිතුර සමහර සාමාජිකයන් පැවසූ පරිදි toLocaleString භාවිතා කිරීමයි. ඔබට '$' සංකේතය ඇතුළත් කිරීමට අවශ්‍ය නම් ලන්ගාජේ එකතු කර විකල්ප ටයිප් කරන්න. මෙක්සිකානු පෙසෝස් වෙත අංකයක් සංයුති කිරීම සඳහා මෙන්න සහ උදාහරණය

var n = 1234567.22
alert(n.toLocaleString("es-MX",{style:"currency", currency:"MXN"}))

කෙටිමඟ

1234567.22.toLocaleString("es-MX",{style:"currency", currency:"MXN"})

මට uKolka ගේ පිළිතුර වැඩිදියුණු කිරීමට උත්සාහ කළ හැකි අතර යම් කාලයක් ඉතිරි කර ගැනීමට අන් අයට උදව් කළ හැකිය.

Numeral.js භාවිතා කරන්න .

document.body.textContent = numeral(1234567).format('0,0');

<script src="//cdnjs.cloudflare.com/ajax/libs/numeral.js/1.4.5/numeral.min.js"></script>

ඔබ යා යුත්තේ Number.prototype.toLocaleString () සමඟ වන අතර එහි බ්‍රව්සරයේ ගැළපුම ගැටළුවක් නොවේ නම් පමණි .

විකල්ප ක්‍රමයක්, දශම, විවිධ බෙදුම්කරුවන් සහ නිෂේධන සඳහා සහාය වීම.

var number_format = function(number, decimal_pos, decimal_sep, thousand_sep) {
    var ts      = ( thousand_sep == null ? ',' : thousand_sep )
        , ds    = ( decimal_sep  == null ? '.' : decimal_sep )
        , dp    = ( decimal_pos  == null ? 2   : decimal_pos )

        , n     = Math.floor(Math.abs(number)).toString()

        , i     = n.length % 3 
        , f     = ((number < 0) ? '-' : '') + n.substr(0, i)
    ;

    for(;i<n.length;i+=3) {
        if(i!=0) f+=ts;
        f+=n.substr(i,3);
    }

    if(dp > 0) 
        f += ds + parseFloat(number).toFixed(dp).split('.')[1]

    return f;
}

Ign ජිග්නේෂ් සංගානිගේ සමහර නිවැරදි කිරීම්, ඔහුගේ අදහස ඉහළ නැංවීමට අමතක නොකරන්න.

මෙම ගැටළුව හා සම්බන්ධ සියලු ගැටළු මෙම කාර්යය විසින් බලා ගනු ඇතැයි මම සිතමි.

function commaFormat(inputString) {
    inputString = inputString.toString();
    var decimalPart = "";
    if (inputString.indexOf('.') != -1) {
        //alert("decimal number");
        inputString = inputString.split(".");
        decimalPart = "." + inputString[1];
        inputString = inputString[0];
        //alert(inputString);
        //alert(decimalPart);

    }
    var outputString = "";
    var count = 0;
    for (var i = inputString.length - 1; i >= 0 && inputString.charAt(i) != '-'; i--) {
        //alert("inside for" + inputString.charAt(i) + "and count=" + count + " and outputString=" + outputString);
        if (count == 3) {
            outputString += ",";
            count = 0;
        }
        outputString += inputString.charAt(i);
        count++;
    }
    if (inputString.charAt(0) == '-') {
        outputString += "-";
    }
    //alert(outputString);
    //alert(outputString.split("").reverse().join(""));
    return outputString.split("").reverse().join("") + decimalPart;
}

අනාගත ගූගල්කරුවන් සඳහා (හෝ අනිවාර්යයෙන්ම 'ගූග්ලර්ස්' නොවේ):

ඉහත සඳහන් කළ විසඳුම් සියල්ලම පුදුමාකාරය, කෙසේ වෙතත්, RegExp එවැනි තත්වයක් තුළ භාවිතා කිරීම ඉතා නරක දෙයක් විය හැකිය.

ඉතින්, ඔව්, ඔබට යෝජිත විකල්ප කිහිපයක් භාවිතා කිරීමට හෝ ප්‍රාථමික නමුත් ප්‍රයෝජනවත් යමක් ලිවීමට පවා හැකිය:

const strToNum = str => {

   //Find 1-3 digits followed by exactly 3 digits & a comma or end of string
   let regx = /(\d{1,3})(\d{3}(?:,|$))/;
   let currStr;

   do {
       currStr = (currStr || str.split(`.`)[0])
           .replace( regx, `$1,$2`)
   } while (currStr.match(regx)) //Stop when there's no match & null's returned

   return ( str.split(`.`)[1] ) ?
           currStr.concat(`.`, str.split(`.`)[1]) :
           currStr;

};

strToNum(`123`) // => 123
strToNum(`123456`) // => 123,456
strToNum(`-1234567.0987`) // => -1,234,567.0987

මෙහි භාවිතා වන regexp තරමක් සරල වන අතර, එම කාර්යය ඉටු කිරීම සඳහා ගතවන වාර ගණන හරියටම ලූපය වෙත යනු ඇත.

ඔබට එය වඩාත් හොඳින් ප්‍රශස්තිකරණය කළ හැකිය, "ඩ්‍රයිෆයි" කේතය සහ යනාදිය.

තවම,

(-1234567.0987).toLocaleString();

(බොහෝ අවස්ථාවන්හිදී) වඩා හොඳ තේරීමක් වනු ඇත.

කාරණය ක්‍රියාත්මක කිරීමේ වේගයෙහි හෝ හරස් බ්‍රව්සරයේ අනුකූලතාවයේ නොවේ.

ප්‍රති result ල අංකය පරිශීලකයාට පෙන්වීමට ඔබ කැමති අවස්ථාවන්හිදී, .toLocaleString () ක්‍රමය මඟින් ඔබේ වෙබ් අඩවියේ හෝ යෙදුමේ පරිශීලකයා සමඟ එකම භාෂාව කථා කිරීමට සුපිරි බලයක් ලබා දෙයි (ඇයගේ / ඔහුගේ භාෂාව කුමක් වුවත්).

ECMAScript ප්‍රලේඛනයට අනුව මෙම ක්‍රමය 1999 දී හඳුන්වා දෙන ලද අතර, එයට හේතුව අන්තර්ජාලය යම් අවස්ථාවක දී ලොව පුරා සිටින පුද්ගලයින් සම්බන්ධ කරනු ඇතැයි යන බලාපොරොත්තුව බව මම විශ්වාස කරමි, එබැවින් සමහර “අභ්‍යන්තරකරණ” මෙවලම් අවශ්‍ය විය.

අද අන්තර්ජාලය අප සියල්ලන්ම සම්බන්ධ කරයි, එබැවින් ලෝකය යනු අපට සිතාගත හැකි වඩාත් සංකීර්ණ ක්‍රමයක් බව මතක තබා ගැනීම වැදගත්ය (සහ (/ පාහේ) අප සියල්ලන්ම මෙහි සිටින බව, අන්තර්ජාලය තුළ.

නිසැකවම, මිනිසුන්ගේ විවිධත්වය සලකා බැලීමේදී, සෑම කෙනෙකුටම පරිපූර්ණ යූඑක්ස් සහතික කිරීම කළ නොහැක්කේ අප විවිධ භාෂා කථා කරන නිසා, විවිධ දේ අගය කරන නිසා ය. හරියටම මේ නිසා, හැකි තරම් දේශීයකරණය කිරීමට උත්සාහ කිරීම ඊටත් වඩා වැදගත් ය. .

එබැවින්, දිනය, වේලාව, අංක ආදිය නිරූපණය කිරීම සඳහා යම් නිශ්චිත ප්‍රමිතීන් ඇති බවත්, අවසාන පරිශීලකයා විසින් කැමති ආකෘතියෙන් ඒවා ප්‍රදර්ශනය කිරීමට අපට මෙවලමක් ඇති බවත් සලකන විට එය දුර්ලභ හා වගකීම් විරහිත නොවේ. එම මෙවලම භාවිතා කරන්න (විශේෂයෙන් අපට මෙම දත්ත පරිශීලකයාට පෙන්වීමට අවශ්‍ය අවස්ථාවන්හිදී)?

මට නම්, .toLocaleString () වෙනුවට RegExp භාවිතා කිරීම ජාවාස්ක්‍රිප්ට් සමඟ ඔරලෝසු යෙදුමක් නිර්මාණය කිරීම හා එය එලෙස තදින් කේතනය කිරීම වැනි ය. එබැවින් එය ප්‍රාග් වේලාව පමණක් පෙන්වනු ඇත (එය බෙහෙවින් නිෂ් less ල වනු ඇත ප්‍රාග් වල ජීවත් නොවන පුද්ගලයින්)

new Date();

අවසාන පරිශීලකයාගේ ඔරලෝසුව අනුව දත්ත ආපසු ලබා දීමයි.

මගේ “ සත්‍ය ” නිත්‍ය ප්‍රකාශන-එකම විසඳුම _{ආදරය කරන්නන් සඳහා} පමණි

ඉහත උද්යෝගිමත් ක්රීඩකයන් ඔබට පෙනේද? සමහර විට ඔබට එයින් ගොල්ෆ් කළ හැකිය. මෙන්න මගේ ආ roke ාතය.

n => `${n}`.replace(/(?<!\.\d+)\B(?=(\d{3})+\b)/g, " ").replace(/(?<=\.(\d{3})+)\B/g, " ")

_{සඳහා භාවිත කරන්නේ  තුනී SPACE වූ දහස් ගණනක් (U + 2009) වෙන්කර, ලෙස ඒකක ක්රමයකි කරන්න පවසයි අට වන සංස්කරණය (2006) ඔවුන්ගේ ප්රකාශන "යන උප පොලිස් පරීක්ෂක සඟරාවෙන්: ඒකක ජාත්යන්තර පද්ධතිය (උප පොලිස් පරීක්ෂක) " (බලන්න §5.3 .4.). නවවන සංස්කරණය (2019) යෝජනා කරන්නේ ඒ සඳහා ඉඩක් භාවිතා කිරීමට ය (§5.4.4 බලන්න.). කොමාව ඇතුළුව ඔබට අවශ්‍ය ඕනෑම දෙයක් භාවිතා කළ හැකිය.}

බලන්න.

const integer_part_only = n => `${n}`.replace(/(?<!\.\d+)\B(?=(\d{3})+\b)/g, " I ");
const fractional_part_only = n => `${n}`.replace(/(?<=\.(\d{3})+)\B/g, " F ");
const both = n => fractional_part_only(integer_part_only(n));

function demo(number) { // I’m using Chrome 74.
	console.log(`${number}
		→ "${integer_part_only(number)}" (integer part only)
		→ "${fractional_part_only(number)}" (fractional part only)
		→ "${both(number)}" (both)
	`);
}
demo(Math.random() * 10e5);
demo(123456789.01234567);
demo(123456789);
demo(0.0123456789);

එය ක්‍රියාත්මක වන්නේ කෙසේද?

පූර්ණ සංඛ්‍යාවක් සඳහා

.replace(/(?<!\.\d+)\B(?=(\d{3})+\b)/g, " I ")

• .replace(……, " I ") “මම” දමන්න
  • /……/g එක් එක්
    • \B යාබද ඉලක්කම් දෙකක අතර
      • (?=……)දකුණු කොටස වන _{ධනාත්මක ලූකහීඩ්}
        • (\d{3})+ ඉලක්කම් තුනක කුට්ටි එකක් හෝ වැඩි ගණනක්
        • \b කාල පරිච්ඡේදයක්, නූල් අවසානය, සහ සෙටෙරා වැනි ඉලක්කම් නොවන,
      • (?<!……)වම් කොටස ඇති අය _{බැහැරව නෙගටිව් ලුක්බෙහින්ඩ්}
        • \.\d+ ඉලක්කම් වලින් පසුව තිතක් (“දශම බෙදුම්කරුවෙකු ඇත”).

දශම කොටසකට

.replace(/(?<=\.(\d{3})+)\B/g, " F ")

• .replace(……, " F ") “F” දමන්න
  • /……/g එක් එක්
    • \B යාබද ඉලක්කම් දෙකක අතර
      • (?<=……)වම් කොටස ඇති _{ධනාත්මක} පෙනුම
        • \. දශම බෙදුම්කරු
        • (\d{3})+ ඉන්පසු ඉලක්කම් තුනක කුට්ටි එකක් හෝ වැඩි ගණනක්.

චරිත පන්ති සහ මායිම්

\d

ඕනෑම අංකයකට ගැලපේ (අරාබි ඉලක්කම්). සමාන වේ [0-9].

උදාහරණයක් වශයෙන්,

• /\d/හෝ /[0-9]/තරග 2දී B2 is the suite number.

\b

එය තරග සීමාව වචනය . අක්‍ෂරයක් සහ අවකාශයක් අතර වැනි වචන අක්‍ෂරයක් වෙනත් වචන අක්‍ෂරයකින් අනුගමනය නොකිරීමට හෝ ඊට පෙර නොපැමිණෙන ස්ථානය මෙයයි. ගැලපෙන වචන සීමාවක් තරඟයට ඇතුළත් නොවන බව සලකන්න. වෙනත් වචන වලින් කිවහොත්, ගැලපෙන වචන මායිමක දිග ශුන්‍ය වේ.

උදාහරණ:

• /\bm/මෙම තරග mදී moon;
• /oo\b/ooin සමඟ නොගැලපේ moon, මන්ද ooඑය අනුගමනය කරන්නේ nවචන අක්‍ෂරයකි;
• /oon\b/oonin ට ගැලපේ moon, මන්ද යත්, නූලෙහි oonඅවසානය වන අතර, ඒ අනුව වචන අක්‍ෂරයක් අනුගමනය නොකරයි;
• /\w\b\w/ කිසි විටෙකත් කිසිම දෙයකට නොගැලපේ, මන්ද වචන අක්‍ෂරයකට වචන නොවන සහ වචන අක්‍ෂර යන දෙකම අනුගමනය කළ නොහැක.

\B

එය තරග වචනය නොවන සීමාව . මෙය පෙර සහ ඊළඟ අක්ෂර එකම වර්ගයට අයත් ස්ථානයකි: එක්කෝ දෙකම වචන විය යුතුය, නැතහොත් දෙකම වචන නොවන විය යුතුය. අකුරු දෙකක් අතර හෝ අවකාශ දෙකක් අතර වැනි. නූලක ආරම්භය හා අවසානය වචන නොවන ලෙස සැලකේ. ගැළපෙන වචන මායිමට සමානව, ගැලපෙන වචන නොවන මායිම ද තරඟයට ඇතුළත් නොවේ.

උදාහරණයක් වශයෙන්,

• /\Bon/තරග onදී at noon;
• /ye\B/තරග yeදී possibly yesterday.

බ්‍රව්සර් අනුකූලතාව

• https://caniuse.com/#feat=js-regexp-lookbehind

1-ලයිනර් සහ තනි regex රුචිකත්වයක් දක්වයි, නමුත් ඕනෑම කෙනෙකුට සඳහා නොවේ භේදය (භාවිතා කිරීමට අවශ්ය), මෙතන හැන්ඩ්ල් (නොසලකා හැරීම්) දශම ස්ථාන වෙනත් පිළිතුරු සිට regex ක වැඩි දියුණු අනුවාදය වේ:

    var formatted = (x+'').replace(/(\..*)$|(\d)(?=(\d{3})+(?!\d))/g, (digit, fract) => fract || digit + ',');

රීජෙක්ස් මුලින්ම උපස්ථරයකට ගැලපේ. සහ එය තමා විසින්ම ප්‍රතිස්ථාපනය කරයි ("බිඳීම"), ඉන්පසු ඕනෑම අංකයකට ගැලපෙන අතර ඉන් පසුව ඉලක්කම් 3 ක ගුණනයකින් පසුව "," දමයි.

උදාහරණයක් ලෙස, x = 12345678.12345678 මඟින් ආකෘතිගත = '12, 345,678.12345678 'ලබා දෙනු ඇත.

මම tofixed එකතු Aki143S විසඳුම. මෙම විසඳුම මඟින් දහස් ගණනක් බෙදුම්කරුවන් සඳහා තිත් සහ නිරවද්‍යතාව සඳහා කොමාව භාවිතා කරයි.

function formatNumber( num, fixed ) { 
    var decimalPart;

    var array = Math.floor(num).toString().split('');
    var index = -3; 
    while ( array.length + index > 0 ) { 
        array.splice( index, 0, '.' );              
        index -= 4;
    }

    if(fixed > 0){
        decimalPart = num.toFixed(fixed).split(".")[1];
        return array.join('') + "," + decimalPart; 
    }
    return array.join(''); 
};

උදාහරණ;

formatNumber(17347, 0)  = 17.347
formatNumber(17347, 3)  = 17.347,000
formatNumber(1234563.4545, 3)  = 1.234.563,454