මුදල් මුදල් නූල් ලෙස සංයුති කරන්නේ කෙසේද?


1873

මම ජාවාස්ක්‍රිප්ට් හි මිලක් ආකෘතිකරණය කිරීමට කැමතියි. මම floatතර්කයක් ලෙස ගෙන මේ ආකාරයට stringආකෘතිගත කළ ශ්‍රිතයකට කැමතියි:

"$ 2,500.00"

මෙය කිරීමට හොඳම ක්‍රමය කුමක්ද?


8
formatNumberජාවාස්ක්‍රිප්ට් හි කිසිදු සාදන ලද කාර්යයක් නොමැත
zerkms

503
කරුණාකර, අනාගතයේ දී මෙම වාර්තාව කියවන ඕනෑම කෙනෙකුට, නෑ නෑ ගබඩා මුදල පාවෙන භාවිතා කරන්න. ඔබ නිරවද්යතාව සහ දත්ත ලිහිල් කරනු ඇත. ඔබ එය පූර්ණ සංඛ්‍යා ශතයක් (හෝ සතයක් ආදිය) ලෙස ගබඩා කර ප්‍රතිදානයට පෙර පරිවර්තනය කළ යුතුය.
පිලිප් වයිට්හවුස්

8
@ user1308743 පාවෙන දශම ස්ථාන ගබඩා නොකරයි. එය අගය, පදනම සහ ඕෆ්සෙට් භාවිතා කරමින් අංක ගබඩා කරයි. 0.01 ඇත්ත වශයෙන්ම නිරූපණය නොවේ. බලන්න: en.wikipedia.org/wiki/Floating_point#Accuracy_problems
පිලිප් වයිට්හවුස්

6
@ user1308743: ඔබ ඉතා විශාල සංඛ්‍යාවක් නියෝජනය කරන බව සිතන්න (ඔබ වාසනාවන්ත පුද්ගලයෙක් බවත් එය ඔබගේ බැංකු ගිණුමේ ශේෂය බවත් කියමු). නිරවද්‍ය iency නතාවයක් නිසා ඔබට මුදල් ලිහිල් කිරීමට අවශ්‍යද?
ereOn

168
ඉතින් කිසිවෙකු පහත සඳහන් දේ යෝජනා නොකළේ ඇයි? (2500) .toLocaleString ( "si-GB", {ශෛලිය: "මුදල්", මුදල්: "ඒ කියන්නේ GBP", minimumFractionDigits: 2}) developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/...
නික් ග්‍රීලි

Answers:


1805

Number.prototype.toFixed

මෙම විසඳුම සෑම ප්‍රධාන බ්‍රව්සරයක් සමඟම අනුකූල වේ:

  const profits = 2489.8237;

  profits.toFixed(3) //returns 2489.824 (rounds up)
  profits.toFixed(2) //returns 2489.82
  profits.toFixed(7) //returns 2489.8237000 (pads the decimals)

ඔබට අවශ්‍ය වන්නේ මුදල් සංකේතය (උදා "$" + profits.toFixed(2)) එකතු කිරීම පමණක් වන අතර ඔබේ මුදල ඩොලර් වලින් ලැබෙනු ඇත.

අභිරුචි කාර්යය

,එක් එක් ඉලක්කම් අතර භාවිතය ඔබට අවශ්‍ය නම් , ඔබට මෙම ශ්‍රිතය භාවිතා කළ හැකිය:

function formatMoney(number, decPlaces, decSep, thouSep) {
decPlaces = isNaN(decPlaces = Math.abs(decPlaces)) ? 2 : decPlaces,
decSep = typeof decSep === "undefined" ? "." : decSep;
thouSep = typeof thouSep === "undefined" ? "," : thouSep;
var sign = number < 0 ? "-" : "";
var i = String(parseInt(number = Math.abs(Number(number) || 0).toFixed(decPlaces)));
var j = (j = i.length) > 3 ? j % 3 : 0;

return sign +
	(j ? i.substr(0, j) + thouSep : "") +
	i.substr(j).replace(/(\decSep{3})(?=\decSep)/g, "$1" + thouSep) +
	(decPlaces ? decSep + Math.abs(number - i).toFixed(decPlaces).slice(2) : "");
}

document.getElementById("b").addEventListener("click", event => {
  document.getElementById("x").innerText = "Result was: " + formatMoney(document.getElementById("d").value);
});
<label>Insert your amount: <input id="d" type="text" placeholder="Cash amount" /></label>
<br />
<button id="b">Get Output</button>
<p id="x">(press button to get output)</p>

එය එසේ භාවිතා කරන්න:

(123456789.12345).formatMoney(2, ".", ",");

ඔබ සැමවිටම 'භාවිතා කිරීමට යන්නේ නම්.' සහ ',', ඔබට ඒවා ඔබගේ ක්‍රමවේදය ඇමතුමෙන් ඉවත් කළ හැකි අතර, එම ක්‍රමය ඔබ වෙනුවෙන් පෙරනිමිය හැක.

(123456789.12345).formatMoney(2);

ඔබේ සංස්කෘතියට සංකේත දෙක පෙරළී තිබේ නම් (එනම් යුරෝපීයයන්) සහ ඔබ පෙරනිමි භාවිතා කිරීමට කැමති නම්, ක්‍රමයේ පහත දැක්වෙන පේළි දෙක මත අලවන්න formatMoney:

    d = d == undefined ? "," : d, 
    t = t == undefined ? "." : t, 

අභිරුචි ශ්‍රිතය (ES6)

ඔබට නවීන ECMAScript සින්ටැක්ස් (එනම් බාබෙල් හරහා) භාවිතා කළ හැකි නම්, ඒ වෙනුවට ඔබට මෙම සරල ශ්‍රිතය භාවිතා කළ හැකිය:

function formatMoney(amount, decimalCount = 2, decimal = ".", thousands = ",") {
  try {
    decimalCount = Math.abs(decimalCount);
    decimalCount = isNaN(decimalCount) ? 2 : decimalCount;

    const negativeSign = amount < 0 ? "-" : "";

    let i = parseInt(amount = Math.abs(Number(amount) || 0).toFixed(decimalCount)).toString();
    let j = (i.length > 3) ? i.length % 3 : 0;

    return negativeSign + (j ? i.substr(0, j) + thousands : '') + i.substr(j).replace(/(\d{3})(?=\d)/g, "$1" + thousands) + (decimalCount ? decimal + Math.abs(amount - i).toFixed(decimalCount).slice(2) : "");
  } catch (e) {
    console.log(e)
  }
};
document.getElementById("b").addEventListener("click", event => {
  document.getElementById("x").innerText = "Result was: " + formatMoney(document.getElementById("d").value);
});
<label>Insert your amount: <input id="d" type="text" placeholder="Cash amount" /></label>
<br />
<button id="b">Get Output</button>
<p id="x">(press button to get output)</p>


26
පළමුව, විශිෂ්ට, සංක්ෂිප්ත කේතය. කෙසේ වෙතත්, ඔබ ඇමරිකානු වේ නම්, ඔබ පෙරනිමි අගයන් වෙනස් කළ යුතු ය dහා tවිය .හා ,ඔබ ඔවුන් සෑම අවස්ථාවකදීම නියම කිරීමට ඇති නොවන බව එසේ පිළිවෙළින්. returnකියවීමට ප්‍රකාශයේ ආරම්භය වෙනස් කිරීමට මම නිර්දේශ කරමි : return s + '$' + [rest]එසේ නොමැතිනම් ඔබට ඩොලර් ලකුණක් නොලැබෙනු ඇත.
ජේසන්

746
මෙම කේතය ලස්සන යැයි මිනිසුන් සිතන්නේ මන්දැයි විශ්වාස නැත. එය අවිනිශ්චිතය. එය මනාව වැඩ කරන බව පෙනේ, නමුත් එය ලස්සන නැත.
usr

87
මෙම ආකෘතිය මුදල් ශ්‍රිතය කුඩා ජාවාස්ක්‍රිප්ට් කේතයකින් කොහේ හරි පිටපත් කර තිබේද? ඔබට මුල් පිටපත පළ කළ නොහැකිද? C, d, i, j, n, s, t යන විචල්‍යයන් නියෝජනය කරන්නේ කුමක් සඳහාද? මෙම කේතය සෑම තැනකම නිෂ්පාදන වෙබ් අඩවි වලට පිටපත් කර ඇති බව මට උපකල්පනය කළ හැකිය.
zuallauz

260
"කවි"? අපැහැදිලි භාවය වැනි. මෙය කේත ගොල්ෆ් නොවේ; ටිකක් සුදු ඉඩක් භාවිතා කරන්න. නිසි var නම් වලට හානියක් නොවනු ඇත.
keithjgrant


1562

Intl.numberformat

ජාවාස්ක්‍රිප්ට් හි සංඛ්‍යා හැඩතල ගැන්වීමක් ඇත (ජාත්‍යන්තරකරණ API හි කොටසක්).

// Create our number formatter.
var formatter = new Intl.NumberFormat('en-US', {
  style: 'currency',
  currency: 'USD',
});

formatter.format(2500); /* $2,500.00 */

ජේ.එස්

භාවිතය undefined(පළමු තර්කය වෙනුවට 'en-US'පද්ධති ස්ථානය (කේතය බ්රවුසරයක් ධාවනය වන නඩුවේ පරිශීලක පෙදෙසිය) භාවිතා කිරීමේ උදාහරණය තුල). ස්ථාන කේතය පිළිබඳ වැඩිදුර පැහැදිලි කිරීම .

මෙන්න මුදල් කේත ලැයිස්තුවක් .

Intl.NumberFormat එදිරිව Number.prototype.toLocaleString

මෙය පැරණි දේ සමඟ සංසන්දනය කරන අවසාන සටහනකි. toLocaleString. ඔවුන් දෙදෙනාම එකම ක්‍රියාකාරීත්වයක් ලබා දෙයි. කෙසේ වෙතත්, ToLocaleString එහි පැරණි අවතාරවල (පෙර-ඉන්ටෙල්) ඇත්ත වශයෙන්ම ස්ථාන වලට සහය නොදක්වයි : එය පද්ධති පෙදෙසි භාවිතා කරයි. එමනිසා, ඔබ නිවැරදි අනුවාදය භාවිතා කරන බවට වග බලා ගන්න ( MDN හි පැවැත්ම පරීක්ෂා කිරීමට යෝජනා කරයිIntl ). එසේම, දෙකෙහිම ක්‍රියාකාරීත්වය එක් අයිතමයක් සඳහා සමාන වේ , නමුත් ඔබට ආකෘතිකරණය කිරීමට විශාල සංඛ්‍යාවක් තිබේ නම්, භාවිතා Intl.NumberFormatකිරීම ~ 70 ගුණයකින් වේගවත් වේ. භාවිතා කරන ආකාරය මෙන්න toLocaleString:

(2500).toLocaleString('en-US', {
  style: 'currency',
  currency: 'USD',
}); /* $2,500.00 */

බ්‍රව්සර් සහාය පිළිබඳ සමහර සටහන්

  • වර්තමානයේදී බ්‍රව්සර් සහාය ගෝලීය වශයෙන් 97.5%, එක්සත් ජනපදයේ 98% සහ යුරෝපා සංගමයේ 99% සහය සමඟ ගැටළුවක් නොවේ
  • ඒ නිසා එය සිම් පොසිල බ්රව්සර (8 යනු වැනි) මත මෙය තහවුරු කිරීමට, ඔබට ඇත්තටම කිරීමට අවශ්ය යුතු
  • වැඩි විස්තර සඳහා CanIUse දෙස බලන්න

92
මෙම අද්විතීය ජාවාස්ක්‍රිප්ට්, සරල හා අලංකාර විසඳුම මා සොයන දේමයි.
ගිල්හෙම් සූලාස්

10
මෙය ඡන්දය දීම ස්වදේශීයව ක්‍රියාත්මක වන මෝඩ සරල පිළිතුරකි.
ට්‍රැසිවා

17
බ්‍රව්සර් වලින් සෑහෙන ඉහළ ප්‍රමාණයක් දැන් මේ සඳහා සහාය වන බව විශ්වාසයි. මෙය තවත් බොහෝ දේ ඉහළ නැංවිය යුතුය.
flq

2
මෙය හොඳ පිළිතුරක් වන අතර එය ගතික මුදල් වටිනාකමක් සමඟ ක්‍රියා කරමි. එබැවින් යුරෝපයේ භාවිතා වන්නේ නම් එය යුරෝවට වෙනස් වී යුරෝ ලකුණ පෙන්වයි. සංග්‍රහයක් කරයි!
ස්ප්‍රෝස්

3
එය 2018 වන අතර මෙය මූලික වශයෙන් සෑම තැනකම සහය දක්වයි. මෙය නිවැරදි පිළිතුර විය යුතුය.
sarink

1348

කෙටි හා වේගවත් විසඳුම (සෑම තැනකම වැඩ කරයි!)

(12345.67).toFixed(2).replace(/\d(?=(\d{3})+\.)/g, '$&,');  // 12,345.67

මෙම විසඳුම පිටුපස ඇති අදහස වන්නේ ගැලපෙන කොටස් පළමු තරගය සහ කොමාව සමඟ ප්‍රතිස්ථාපනය කිරීමයි, එනම් '$&,'. ගැලපීම සිදු කරනුයේ බැලීමේ ප්‍රවේශයෙනි . ඔබට “සංඛ්‍යා සංඛ්‍යාවක් ගැලපෙන්නේ නම් අංක තුනක අනුපිළිවෙලක් (එකක් හෝ වැඩි ගණනක්) සහ තිතක්” ලෙස ඔබට කියවිය හැකිය .

පරීක්ෂණ:

1        --> "1.00"
12       --> "12.00"
123      --> "123.00"
1234     --> "1,234.00"
12345    --> "12,345.00"
123456   --> "123,456.00"
1234567  --> "1,234,567.00"
12345.67 --> "12,345.67"

ඩෙමෝ: http://jsfiddle.net/hAfMM/9571/


දීර් short කළ කෙටි විසඳුම

Numberඕනෑම දශම ගණනකට සහ සංඛ්‍යා [0 .. n]කාණ්ඩවල ප්‍රමාණයට අමතර සහය එක් කිරීමට ඔබට වස්තුවේ මූලාකෘතිය දිගු කළ හැකිය [0 .. x]:

/**
 * Number.prototype.format(n, x)
 * 
 * @param integer n: length of decimal
 * @param integer x: length of sections
 */
Number.prototype.format = function(n, x) {
    var re = '\\d(?=(\\d{' + (x || 3) + '})+' + (n > 0 ? '\\.' : '$') + ')';
    return this.toFixed(Math.max(0, ~~n)).replace(new RegExp(re, 'g'), '$&,');
};

1234..format();           // "1,234"
12345..format(2);         // "12,345.00"
123456.7.format(3, 2);    // "12,34,56.700"
123456.789.format(2, 4);  // "12,3456.79"

ඩෙමෝ / ටෙස්ට්: http://jsfiddle.net/hAfMM/435/


සුපිරි දිගු කෙටි විසඳුමක්

මෙම සුපිරි විස්තාරණ අනුවාදයේ දී ඔබට විවිධ පරිසීමක වර්ග සැකසිය හැකිය:

/**
 * Number.prototype.format(n, x, s, c)
 * 
 * @param integer n: length of decimal
 * @param integer x: length of whole part
 * @param mixed   s: sections delimiter
 * @param mixed   c: decimal delimiter
 */
Number.prototype.format = function(n, x, s, c) {
    var re = '\\d(?=(\\d{' + (x || 3) + '})+' + (n > 0 ? '\\D' : '$') + ')',
        num = this.toFixed(Math.max(0, ~~n));

    return (c ? num.replace('.', c) : num).replace(new RegExp(re, 'g'), '$&' + (s || ','));
};

12345678.9.format(2, 3, '.', ',');  // "12.345.678,90"
123456.789.format(4, 4, ' ', ':');  // "12 3456:7890"
12345678.9.format(0, 3, '-');       // "12-345-679"

ඩෙමෝ / ටෙස්ට්: http://jsfiddle.net/hAfMM/612/


21
මම ඇත්ත වශයෙන්ම තවත් පියවරක් ඉදිරියට ගියෙමි : .replace(/(\d)(?=(\d{3})+(?:\.\d+)?$)/g, "$1,").
kalisjoshua

4
VisioN & kalisjoshua regexp සමඟ කෝපි ස්ක්‍රිප්ට් අනුවාදය සහ දශම ස්ථානය නියම කරන ආකාරය (එබැවින් ඔබට 2 හි පෙරනිමිය අතහැර දැමිය හැකිය, නැතහොත් දශමයක් සඳහා 0 නියම කරන්න):Number.prototype.toMoney = (decimal=2) -> @toFixed(decimal).replace /(\d)(?=(\d{3})+(?:\.\d+)?$)/g, "$1,"
එරික් ඇන්ඩර්සන්

11
B අබ්බාස් ඔව්, (පේළියේ අවසානය) වෙනුවට ආදේශ \.කරන්න $, එනම් this.toFixed(0).replace(/(\d)(?=(\d{3})+$)/g, "$1,").
VisioN

2
නිත්‍ය ව්‍යාකරණ මෙහි ටිකක් සංකීර්ණයි, එබැවින් නිත්‍ය ප්‍රකාශන පිළිබඳ අත්පොත් පළමුව කියවීමට මම ඔබට යෝජනා කරමි (උදා: MDN හි ). එය පිටුපස ඇති අදහස වන්නේ ගැලපෙන කොටස් පළමු තරගය සහ කොමාව සමඟ ප්‍රතිස්ථාපනය කිරීමයි, එනම් $1,. ගැලපීම සිදු කරනුයේ බැලීමේ ප්‍රවේශයෙනි . ඔබට “සංඛ්‍යා සංඛ්‍යාවක් ගැලපෙන්නේ නම් අංක තුනක අනුපිළිවෙලක් (එකක් හෝ වැඩි ගණනක්) සහ තිතක්” ලෙස ඔබට කියවිය හැකිය .
VisioN

2
@ JuliendePrabère කරුණාකර මෙම ප්‍රවේශය සමඟ ක්‍රියා නොකරන දිගු සංඛ්‍යාවක් සඳහා උදාහරණයක් දෙන්න.
VisioN

254

ජාවාස්ක්‍රිප්ට් අංක වස්තුව දෙස බලා එය ඔබට උදව් කළ හැකිදැයි බලන්න.

  • toLocaleString() ස්ථාන නිශ්චිත දහස් බෙදුම්කරු භාවිතා කරමින් අංකයක් සංයුති කරනු ඇත.
  • toFixed() නිශ්චිත දශම ස්ථාන ගණනකට සංඛ්‍යාව වට කරයි.

මේවා එකවර භාවිතා කිරීමට නම්, එහි වර්ගය නැවත අංකයකට වෙනස් කළ යුතුය.

උදාහරණයක්:

Number((someNumber).toFixed(1)).toLocaleString()

2
ස්තූතියි! මෙම අදහස මත පදනම්ව මට කෙටි හා සරල එකක් සෑදීමට හැකි විය! (සහ දේශීයකරණය) විශිෂ්ටයි.
ඩැනියෙල් මැග්ලියෝලා

7
ඇත්තටම ඔබට පුළුවන්. එනම් ඩොලර් සඳහා: '$' + (අගය + 0.001) .ටොකොලේස්ට්‍රිං () පෙත්ත (0, -1)
සැප්ට්‍රි

6
පෙනෙන ආකාරයට එය විශිෂ්ටයි, නමුත් මේ වන විට බ්‍රවුසරයේ සහය එතරම් නැත
acorncom

2
toLocaleStringපද්ධති පෙදෙසි භාවිතා කරන පැරණි අනුවාදයක් සහ ECMAScript Intl API වෙතින් එන නව (නොගැලපෙන) එකක් ඇති බවට සැලකිලිමත් විය යුතුය . මෙහි පැහැදිලි කර ඇත . මෙම පිළිතුර පැරණි අනුවාදය සඳහා අදහස් කර ඇති බව පෙනේ.
aross

2
මෙය එතරම් ඉහළින් ඡන්දය ප්‍රකාශ කළේ ඇයිදැයි විශ්වාස නැත, නමුත් මෙය OP ඉල්ලා සිටින දේ නොකරයි. නිදසුනක් ලෙස, මුදල් හැඩතල ගැන්වීම සඳහා අපේක්ෂිත හැසිරීම නොව එය 10000හැරෙනු ඇත . "10,000""10,000.00"
බුරාක්

162

පහත දැක්වෙන්නේ පැට්‍රික් ඩෙස්ජාර්ඩින්ස් (නොහොත් ඩාවොක්) කේතය ටිකක් අදහස් එකතු කිරීම සහ සුළු වෙනස්කම් කිහිපයක් සමඟ ය:

/* 
decimal_sep: character used as deciaml separtor, it defaults to '.' when omitted
thousands_sep: char used as thousands separator, it defaults to ',' when omitted
*/
Number.prototype.toMoney = function(decimals, decimal_sep, thousands_sep)
{ 
   var n = this,
   c = isNaN(decimals) ? 2 : Math.abs(decimals), //if decimal is zero we must take it, it means user does not want to show any decimal
   d = decimal_sep || '.', //if no decimal separator is passed we use the dot as default decimal separator (we MUST use a decimal separator)

   /*
   according to [/programming/411352/how-best-to-determine-if-an-argument-is-not-sent-to-the-javascript-function]
   the fastest way to check for not defined parameter is to use typeof value === 'undefined' 
   rather than doing value === undefined.
   */   
   t = (typeof thousands_sep === 'undefined') ? ',' : thousands_sep, //if you don't want to use a thousands separator you can pass empty string as thousands_sep value

   sign = (n < 0) ? '-' : '',

   //extracting the absolute value of the integer part of the number and converting to string
   i = parseInt(n = Math.abs(n).toFixed(c)) + '', 

   j = ((j = i.length) > 3) ? j % 3 : 0; 
   return sign + (j ? i.substr(0, j) + t : '') + i.substr(j).replace(/(\d{3})(?=\d)/g, "$1" + t) + (c ? d + Math.abs(n - i).toFixed(c).slice(2) : ''); 
}

මෙහි පරීක්ෂණ කිහිපයක්:

//some tests (do not forget parenthesis when using negative numbers and number with no decimals)
alert(123456789.67392.toMoney() + '\n' + 123456789.67392.toMoney(3) + '\n' + 123456789.67392.toMoney(0) + '\n' + (123456).toMoney() + '\n' + (123456).toMoney(0) + '\n' + 89.67392.toMoney() + '\n' + (89).toMoney());

//some tests (do not forget parenthesis when using negative numbers and number with no decimals)
alert((-123456789.67392).toMoney() + '\n' + (-123456789.67392).toMoney(-3));

සුළු වෙනස්කම් නම්:

  1. Math.abs(decimals)කළ යුතු දේ මඳක් ඉදිරියට ගෙන ගියේ නැති විට පමණි NaN.

  2. decimal_sep තවදුරටත් හිස් නූලක් විය නොහැක (යම් ආකාරයක දශම බෙදුම්කරුවෙකු තිබිය යුතුය)

  3. ජාවාස්ක්‍රිප්ට් ශ්‍රිතයට තර්කයක් යවා නොමැතිද යන්න තීරණය කරන්නේ කෙසේද යන්න තීරණයtypeof thousands_sep === 'undefined' කර ඇති ආකාරයට අපි භාවිතා කරමු

  4. (+n || 0)අවශ්ය නොවන නිසා thisකියන්නේ Numberවස්තුව

ජේ.එස්


8
ඔබට parseInt හි රේඩික්ස් ලෙස '10' භාවිතා කිරීමට අවශ්‍ය විය හැකිය. එසේ නොමැතිනම්, '0' සමඟ ආරම්භ වන ඕනෑම අංකයක් අෂ්ටක අංක භාවිතා කරයි.
sohtimsso1970

3
@ sohtimsso1970: ප්‍රමාද වූ ප්‍රතිචාරයට කණගාටුයි, නමුත් ඔබට තවත් කරුණු පැහැදිලි කළ හැකිද? අංකයක් අෂ්ටක ලෙස අර්ථ දැක්විය හැකි ස්ථානයක් මා දකින්නේ නැත. මෙම parseIntසංඛ්යාව වන පූර්ණ කොටසක් නිරපේක්ෂ අගය මත ලෙස හැඳින්වේ. INTEGER කොටස ZERO සමඟ ආරම්භ කළ නොහැක. සහ parseInt(0) === 0අෂ්ටක හෝ දශම.
මාකෝ ඩෙමියෝ

උදාහරණයක් ලෙස උත්සාහ කරන්න: parseInt ("016") ... 14 නැවත ලබා දෙයි, parseInt උපකල්පනය කරන්නේ එය අෂ්ට කේතනය කර ඇති බවයි.
ට්රැකර් 1

4
@ ට්රැකර් 1: ආරම්භ වන අංකයක් 0අෂ්ටක ලෙස සලකන බව මම තේරුම් ගතිමි parseInt. නමුත් මෙම කේතය දී දුන්නෙ parseIntලබා ගැනීමට 016සඳහා සම්මත කරන ලද තර්කය නිසා, ආදාන (හෝ වෙනත් ඕනෑම octal ෆෝමැට් අගය) ලෙස parseIntවිසින් සකස් 1 වන වන Math.absකාර්යය. එබැවින් parseIntශුන්‍යයෙන් ආරම්භ වන සංඛ්‍යාවක් ලබා ගැනීමට ක්‍රමයක් නැත, එය ශුන්‍යයක් හෝ 0.nn( nnදශමයන් ඇති තැන) මිස . නමුත් දෙකම 0සහ 0.nnනූල් parseIntසරල ZERO බවට පරිවර්තනය කරනු ලැබේ.
මාකෝ ඩෙමියෝ

මෙම ශ්‍රිතය වැරදියි:> (2030) .ටෝමනි (0, '.', ''); <"2 03 0"
ඇන්ටන් පී රොබුල්

125

මුදල අංකය නම්, කියන්න -123නම්,

amount.toLocaleString('en-US', { style: 'currency', currency: 'USD' });

නූල නිපදවනු ඇත "-$123.00".

මෙන්න සම්පූර්ණ වැඩ කරන උදාහරණයකි .


7
මෙම පිළිතුර මා සඳහා බොහෝ දුරට තිබුනද, එය ළඟම ඇති සතයට වට කර ගැනීමට මට අවශ්‍ය විය. මෙය මා භාවිතා කළේ amount.toLocaleString ('en-GB', {style:'rency ', මුදල්:' GBP ', උපරිමFractionDigits: 2});
නිකෝ

ඉහත කේතය ඔබට අවශ්‍ය ඉලක්කම් ගණනට රවුම් කරයි. උදාහරණය බලන්න සහ ආදාන කොටුවේ 1.237 ටයිප් කරන්න.
ඩැනියෙල් බාබලස්

3
සෆාරි හි වැඩ කරන බවක් නොපෙනේ. එය කිසිදු හැඩතල ගැන්වීමකින් තොරව අංකයක් ලෙස යවයි.
ලාන්ස් ඇන්ඩර්සන්

1
ඇවැත්නි, මෙය ඇත්තෙන්ම විශිෂ්ට පිළිතුරකි. ඉහළට විය යුතුය.
ඊතන්

2
කිසියම් හේතුවක් නිසා ඔබට ශත අවශ්‍ය නොවන්නේ නම්, ඔබට මේ සමඟ දශම නිරවද්‍යතාව වෙනස් කළ හැකිය:minimumFractionDigits: 0
හොරාසියෝ

124

account.js යනු අංකය, මුදල් සහ මුදල් ආකෘතිකරණය සඳහා ඉතා කුඩා ජාවාස්ක්‍රිප්ට් පුස්තකාලයකි.


... මුදල් සංකේතයක් සම්මත කිරීමට මතක තබා ගන්න, එසේ නොමැති නම් එය IE7 සහ IE8 වල දෝෂ වේ, IE9 දෙයාකාරයෙන්ම හොඳයි
දෛශික

2
IE7 / IE8 දෝෂය සවි කර ඇති බව පෙනේ.
මැට් ෂාෆර්

2
මෙය විශිෂ්ට පුස්තකාලයක් වන අතර, මුදල් සංකේතය සම්මත කර ගැනීම හොඳ අදහසකි, මන්ද සියලු මුදල් විස්තර තනි ක්‍රියාකාරී ඇමතුම / සැකසුම් තුළ
අඩංගු වන හෙයිනි

2
මම කැමතියි ඔබට ආපසු හැරවීම කළ හැකිය - ආකෘතිගත කරන ලද මුදල් නූලක් පසු කර සංඛ්‍යාත්මක අගය ලබා ගන්න.
නීල් මොන්රෝ

2
account.js මෑතකදී නඩත්තු කළ බවක් නොපෙනේ. මෑත වෙනස්වීම් සහිත එක් දෙබලක github.com/nashdot/accounting-js
RationalDev GoFundMonica ට කැමතියි

103

මෙන්න මම දැක ඇති හොඳම ජාවාස්ක්‍රිප්ට් මුදල් ආකෘති පත්‍රය:

Number.prototype.formatMoney = function(decPlaces, thouSeparator, decSeparator) {
    var n = this,
        decPlaces = isNaN(decPlaces = Math.abs(decPlaces)) ? 2 : decPlaces,
        decSeparator = decSeparator == undefined ? "." : decSeparator,
        thouSeparator = thouSeparator == undefined ? "," : thouSeparator,
        sign = n < 0 ? "-" : "",
        i = parseInt(n = Math.abs(+n || 0).toFixed(decPlaces)) + "",
        j = (j = i.length) > 3 ? j % 3 : 0;
    return sign + (j ? i.substr(0, j) + thouSeparator : "") + i.substr(j).replace(/(\d{3})(?=\d)/g, "$1" + thouSeparator) + (decPlaces ? decSeparator + Math.abs(n - i).toFixed(decPlaces).slice(2) : "");
};

එය නැවත ආකෘතිකරණය කර ණයට ගත්තේ මෙතැනින්: https://stackoverflow.com/a/149099/751484

ඔබට ඔබේම මුදල් නිර්මාණකරුවෙකු සැපයීමට සිදුවේ (ඔබ ඉහත භාවිතා කළේ $).

එය මේ ආකාරයට අමතන්න (ආර්ග්ස් පෙරනිමිය 2, කොමාව සහ කාල පරිච්ඡේදය දක්වා ඇති බව සලකන්න, එබැවින් ඔබේ මනාපය නම් ඔබට කිසිදු ආරුක්කු සැපයීමට අවශ්‍ය නොවේ):

var myMoney=3543.75873;
var formattedMoney = '$' + myMoney.formatMoney(2,',','.'); // "$3,543.76"

ගෝලීය සං sign ාව ගැන විමසිල්ලෙන් සිටින්න, i, j
hacklikecrack

6
ckhacklikecrack, සියලු විචල්යයන් දේශීය වේ; ඔවුන් varප්‍රකාශයේ ඉන්නවා.
ජොනතන් එම්

3
කණගාටුයි, ඔව්, ඔබ තර්ක නැවත ප්‍රකාශ කළත්. ඉන්ඩෙන්ටේෂන්! ;)
හැක් ලයික්ක්‍රැක්

විචල්ය නම් බිහිසුණු ලෙස භාවිතා කිරීම!
සර්ජ් සාගන්

78

දැනටමත් මෙහි විශිෂ්ට පිළිතුරු කිහිපයක් තිබේ. විනෝදය සඳහා තවත් උත්සාහයක් මෙන්න:

function formatDollar(num) {
    var p = num.toFixed(2).split(".");
    return "$" + p[0].split("").reverse().reduce(function(acc, num, i, orig) {
        return  num=="-" ? acc : num + (i && !(i % 3) ? "," : "") + acc;
    }, "") + "." + p[1];
}

සහ සමහර පරීක්ෂණ:

formatDollar(45664544.23423) // "$45,664,544.23"
formatDollar(45) // "$45.00"
formatDollar(123) // "$123.00"
formatDollar(7824) // "$7,824.00"
formatDollar(1) // "$1.00"

සංස්කරණය කරන ලදි: දැන් එය negative ණ සංඛ්‍යා ද හසුරුවනු ඇත


කවි. දීප්තිමත්. ඔබ reduceRight () උත්සාහ කර developer.mozilla.org/en/JavaScript/Reference/Global_Objects/... වූකලී තුරන් යුතු ()?
ස්ටීව්

1
Te ස්ටීව් - ඔබ හරි, නමුත් ඔබට නැවත ඇමතුම වැනි දෙයක් කිරීමට අවශ්‍යයි i = orig.length - i - 1. තවමත්, අරාවෙහි එක් අඩු ගමන් මාර්ගයක්.
වේන්

11
reduceඅනුකූලතාව පිළිබඳ නොවේ: මෙම ක්‍රමය එක්ස්මස්ක්‍රිප්ට් 1.8 හි හඳුන්වා දී ඇති අතර ඉන්ටර්නෙට් එක්ස්ප්ලෝරර් 8 සහ ඊට පහළින් සහය නොදක්වයි.
බ්ලේස්

La බ්ලේස් පැවසූ පරිදි, මෙම ක්‍රමය IE 8 හෝ ඊට පහළින් ක්‍රියා නොකරනු ඇත.
rsbarro

ඔව්, එය ඇත්ත වශයෙන්ම නිවැරදි ය. පිළිතුරෙහි සඳහන් කර ඇති පරිදි, මෙය විනෝදය සඳහා පමණි. එසේම, එය negative ණ සංඛ්‍යා හොඳින් හැසිරවිය යුතුය.
වේන්

77

සියලුම වර්තමාන බ්‍රව්සර් සඳහා ක්‍රියා කරයි

toLocaleStringභාෂාවක් සංවේදී නිරූපණයක් තුළ මුදල් සංයුති කිරීමට භාවිතා කරන්න ( ISO 4217 මුදල් කේත භාවිතා කරමින් ).

(2500).toLocaleString("en-GB", {style: "currency", currency: "GBP", minimumFractionDigits: 2}) 

උදාහරණය @avenmore සඳහා දකුණු අප්‍රිකානු රැන්ඩ් කේත ස්නිපට

console.log((2500).toLocaleString("en-ZA", {style: "currency", currency: "ZAR", minimumFractionDigits: 2}))
// -> R 2 500,00
console.log((2500).toLocaleString("en-GB", {style: "currency", currency: "ZAR", minimumFractionDigits: 2}))
// -> ZAR 2,500.00


1
ක්‍රෝම් 24, අයිඊ 11 සහ ඔපෙරා 15 වැනි බ්‍රව්සර් ඉතා සුළු සංඛ්‍යාවක් පමණක් 'ස්ථාන' සහ 'විකල්ප' තර්ක සඳහා සහය දක්වයි. ෆයර්ෆොක්ස්, සෆාරි සහ වෙනත් පැරණි අනුවාදයන් තවමත් එයට සහාය නොදක්වයි.
VisioN

3
එකඟ විය, එය සියලු බ්‍රව්සර් හරහා (තවමත්) පූර්ණ සහය නොදක්වයි, නමුත් එය තවමත් විසඳුමකි. (සහ වඩාත්ම වලංගු විසඳුම, එය ඉදිරියට සහාය නොදක්වන බ්‍රව්සර් සමඟ අනුකූල වන අතර එය ජාවාස්ක්‍රිප්ට් ඒපී හි ලේඛනගත ලක්ෂණයකි.)
නික් ග්‍රීලි

1
මම මේකට කැමතියි. එය ඉන්දියානු ඉලක්කම් කාණ්ඩකරණය සමඟ ක්‍රියා කිරීම ගැන සතුටුයි.
එම්එස්සී

7
මෙය 2017 වන විට සම්පුර්ණයෙන්ම සහය දක්වන අතර එකම නිවැරදි පිළිතුර විය යුතුය
Evgeny

1
නවතම හා විශාලතම :) FF69, Chrome76, ආදිය "R 2 500,00" යනු අප මෙහි භාවිතා කරන දේ නොවේ, එය "R 2,500.00" විය යුතුය, en-GB හා සමාන වේ.
avenmore

70

මම හිතන්නේ ඔබට අවශ්‍ය දේ f.nettotal.value = "$" + showValue.toFixed(2);


works මෙම ක්‍රියාව තලා දැමුවද එය තවදුරටත් බදු ක්ෂේත්‍රයට ගණනය කිරීම් සිදු නොකරයිද?
රොකෝ ද ටකෝ

11
ඔබ එයට $ ලකුණක් එකතු කළ පසු, එය තවදුරටත් අංකයක් නොව නූලකි.
පොඩි කරන්න

මෙම විකල්පය දහස් ගණනක් අතර කොමාව තබා නැත. :-(
සයිමන් ඊස්ට්

29

Numeral.js - @adamwdraper විසින් පහසු අංක ආකෘතිකරණය සඳහා js පුස්තකාලයක්

numeral(23456.789).format('$0,0.00'); // = "$23,456.79"

: මෙම දෙබලක Numbro Numeral.js අතහැර දමා පෙනේ ලෙස වඩාත් ආදරය ලබා ගැනීමට පෙනේ github.com/foretagsplatsen/numbro
RationalDev GoFundMonica කැමති

Numeral.js නැවත ක්‍රියාත්මක වේ.
adamwdraper

27

හරි, ඔබ කී දේ මත පදනම්ව, මම මෙය භාවිතා කරමි:

var DecimalSeparator = Number("1.2").toLocaleString().substr(1,1);

var AmountWithCommas = Amount.toLocaleString();
var arParts = String(AmountWithCommas).split(DecimalSeparator);
var intPart = arParts[0];
var decPart = (arParts.length > 1 ? arParts[1] : '');
decPart = (decPart + '00').substr(0,2);

return '£ ' + intPart + DecimalSeparator + decPart;

වැඩිදියුණු කිරීමේ යෝජනා සඳහා මම විවෘතව සිටිමි (මෙය සිදු කිරීම සඳහා යූඅයි ඇතුළත් නොකිරීමට මම කැමතියි :-)) මම දැනටමත් දන්නවා "මම" හඳුනාගත යුතු බව. එය දශම බෙදුම්කරු ලෙස භාවිතා කරනවා වෙනුවට ...


8
ඔබේ අනුවාදය දශම සංඛ්‍යා දෙකකට නිසියාකාරව නොගැලපෙන බව සලකන්න. උදාහරණයක් ලෙස, 3.706 ආකෘතිගත කරනු ලබන්නේ "£ 3.70" ලෙස මිස "£ 3.71" ලෙස නොවේ.
අටෙස් ගෝරල්

මගේ විශේෂ නඩුව ගේ හරි මම දැනටමත් බොහෝ ඉලක්කම් 2 මම දශම 2 විසින් අදාල කරුණ නිවැරදි කිරීමට අවශ්ය හේතුව කිසිදු දශම හෝ පමණක් 1. ප්රමාණයක් සඳහා ඇති සමඟ වැඩ කරනවා ඇති මුදල සිට ඔව්, ඒ
දානියෙල් Magliola

26

මම පුස්තකාලය භාවිතා කරන්නේ ගෝලීයකරණය (මයික්‍රොසොෆ්ට් වෙතින්):

අංක, මුදල් සහ දිනයන් දේශීයකරණය කිරීම සහ පරිශීලක පෙදෙසට අනුව ඒවා ස්වයංක්‍රීයව නිවැරදිව ආකෘතිකරණය කිරීම විශිෂ්ට ව්‍යාපෘතියකි! ... එය jQuery දිගුවක් විය යුතු වුවත්, එය දැනට 100% ස්වාධීන පුස්තකාලයකි. එය අත්හදා බැලීමට මම ඔබ සැමට යෝජනා කරමි! :)


3
ඇවැත්නි, මෙය තවත් ඉහළට නොගන්නේ මන්ද? සියලු ආකාරයේ හැඩතල ගැන්වීම් සඳහා විශාල ප්‍රමිතිගත පුස්තකාලයක්. නිවැරදි ගෝලීයකරණය සමඟ කර්මාන්ත සම්මත හැඩතල ගැන්වීමේ පරාමිතීන්. නියම පිළිතුර !!
pbarranis

එය තවමත් ඇල්ෆා අවධිය ලෙස සැලකේ, එබැවින් ප්‍රවේශමෙන් භාවිතා කරන්න, නමුත් විශිෂ්ට සොයා ගැනීමක්.
නීල් මොන්රෝ

1
තවදුරටත් ඇල්ෆා (හෝ බීටා) හි නොමැත. සෆාරි නව ප්‍රමිතිය සපුරාලන තෙක් සහ IE <11 මිය යන තෙක් අපි බලා සිටින අතරතුර මෙය ඉතා ප්‍රයෝජනවත් බව පෙනේ.
ගයි ෂල්නාට්

25

javascript-number-formatter (කලින් ගූගල් කේතයේ )

  • කෙටි, වේගවත්, නම්‍යශීලී නමුත් තනිවම. MIT බලපත්‍ර තොරතුරු, හිස් රේඛා සහ අදහස් ඇතුළුව පේළි 75 ක් පමණි.
  • #,##0.00ප්‍රතික්ෂේප කිරීම වැනි හෝ සම්මත සංඛ්‍යා ආකෘතිකරණය පිළිගන්න -000.####.
  • වැනි ඕනෑම රටක ආකෘතිය පිළිගන්න # ##0,00, #,###.##, #'###.##හෝ අංක නොවන සංකේතය ඕනෑම ආකාරයේ.
  • ඉලක්කම් කාණ්ඩකරණයේ ඕනෑම සංඛ්‍යාවක් පිළිගන්න. #,##,#0.000හෝ #,###0.##සියල්ල වලංගු වේ.
  • අතිරික්ත / මෝඩ-ඔප්පු ආකෘතිකරණය පිළිගන්න. ##,###,##.#නැත්නම් 0#,#00#.###0#ඔක්කොම හරි.
  • ස්වයංක්‍රීය අංක රවුම් කිරීම.
  • සරල අතුරුමුහුණතක්, මේ වගේ වෙස්මුහුණු සහ අගය සපයන්න : format( "0.0000", 3.141592).
  • වෙස් මුහුණ සමඟ උපසර්ගයක් සහ උපසර්ගයක් ඇතුළත් කරන්න

(එහි README වෙතින් උපුටා ගැනීමකි)


24

මුල් ක්‍රමය සැපයීම සඳහා ජොනතන් එම් වෙත +1 කරන්න. මෙය පැහැදිලිවම මුදල් හැඩතල ගැන්වීමක් බැවින්, මම ඉදිරියට ගොස් මුදල් සංකේතය (පෙරනිමියෙන් '$') ප්‍රතිදානයට එකතු කර දහස් සංඛ්‍යාත බෙදුම්කරු ලෙස පෙරනිමි කොමාව එක් කළෙමි. ඔබට ඇත්ත වශයෙන්ම මුදල් සංකේතයක් (හෝ දහස් ගණනක් බෙදුම්කරු) අවශ්‍ය නොවන්නේ නම්, ඒ සඳහා ඔබේ තර්කය ලෙස "" (හිස් නූල) භාවිතා කරන්න.

Number.prototype.formatMoney = function(decPlaces, thouSeparator, decSeparator, currencySymbol) {
    // check the args and supply defaults:
    decPlaces = isNaN(decPlaces = Math.abs(decPlaces)) ? 2 : decPlaces;
    decSeparator = decSeparator == undefined ? "." : decSeparator;
    thouSeparator = thouSeparator == undefined ? "," : thouSeparator;
    currencySymbol = currencySymbol == undefined ? "$" : currencySymbol;

    var n = this,
        sign = n < 0 ? "-" : "",
        i = parseInt(n = Math.abs(+n || 0).toFixed(decPlaces)) + "",
        j = (j = i.length) > 3 ? j % 3 : 0;

    return sign + currencySymbol + (j ? i.substr(0, j) + thouSeparator : "") + i.substr(j).replace(/(\d{3})(?=\d)/g, "$1" + thouSeparator) + (decPlaces ? decSeparator + Math.abs(n - i).toFixed(decPlaces).slice(2) : "");
};

ශ්‍රිත ප්‍රකාශනයේ එම විචල්‍යයන් දැනටමත් ප්‍රකාශයට පත් කර ඇති බැවින් පළමු var තරමක් අමුතු ය. ඒ හැර, ස්තූතියි!
පොහොසත් බ්‍රැඩ්ෂෝ

2
ඔයා හරි. එය ජොනතන් එම් ගේ මුල් පිටපතෙන් මා ගෙන ආ දෝෂයකි, එහිදී ඒවා සියල්ලම එකම විචල්‍ය ප්‍රකාශනයක් ලෙස දම්වැල් දමා ඇත. ඒවා සරල පැවරුම් විය යුතුය. සවි කිරීම.
XML

මේ කාරණය සඳහා, මම සිතන්නේ මෙය බොහෝ විට අකාලයේ ප්‍රශස්තිකරණය කර ඇති අතර කියවීමේ හැකියාව සඳහා නැවත සකස් කළ යුතුය. නමුත් මගේ ඉලක්කය වූයේ OP හි කේතය වැඩි දියුණු කිරීම මිස එය මූලික වශයෙන් වෙනස් කිරීම නොවේ.
XML

එය එතරම් නරක නැත - +n || 0එය ටිකක් අමුතු යැයි පෙනෙන එකම දෙයයි (කෙසේ වෙතත් මට).
පොහොසත් බ්‍රැඩ්ෂෝ

2
thisයනු ඉතා ප්‍රයෝජනවත් විචල්‍ය නමකි. nකේබී හි RAM සහ කලාප පළල ගණනය කරන ලද යුගයකදී ඔබට එය අර්ථ දැක්වීමේ වේලාවට අක්ෂර 3 ක් ඉතිරි කර ගත හැකි විය හැකි නමුත් එය හුදෙක් නිශ්ශබ්දතාවයට පත්වන්නේ එය නිෂ්පාදනයට පැමිණීමට පෙර මිනිෆයර් ඒ සියල්ල බලා ගන්නා යුගයක ය. අනෙක් දක්ෂ ක්ෂුද්‍ර ප්‍රශස්තිකරණය අවම වශයෙන් විවාදාත්මක ය.
XML

22

නිත්‍ය ප්‍රකාශනය සමඟ කෙටි ක්‍රමයක් (අවකාශය, කොමාව හෝ ලක්ෂ්‍යය ඇතුළු කිරීම සඳහා)?

    Number.prototype.toCurrencyString=function(){
        return this.toFixed(2).replace(/(\d)(?=(\d{3})+\b)/g,'$1 ');
    }

    n=12345678.9;
    alert(n.toCurrencyString());

21

PHP ශ්‍රිතයේ "number_format" හි ජාවාස්ක්‍රිප්ට් පෝට් එකක් ඇත.

PHP සංවර්ධකයින්ට භාවිතා කිරීමට පහසු සහ හඳුනාගත හැකි බැවින් එය ඉතා ප්‍රයෝජනවත් බව මට පෙනේ.

function number_format (number, decimals, dec_point, thousands_sep) {
    var n = number, prec = decimals;

    var toFixedFix = function (n,prec) {
        var k = Math.pow(10,prec);
        return (Math.round(n*k)/k).toString();
    };

    n = !isFinite(+n) ? 0 : +n;
    prec = !isFinite(+prec) ? 0 : Math.abs(prec);
    var sep = (typeof thousands_sep === 'undefined') ? ',' : thousands_sep;
    var dec = (typeof dec_point === 'undefined') ? '.' : dec_point;

    var s = (prec > 0) ? toFixedFix(n, prec) : toFixedFix(Math.round(n), prec); 
    //fix for IE parseFloat(0.55).toFixed(0) = 0;

    var abs = toFixedFix(Math.abs(n), prec);
    var _, i;

    if (abs >= 1000) {
        _ = abs.split(/\D/);
        i = _[0].length % 3 || 3;

        _[0] = s.slice(0,i + (n < 0)) +
               _[0].slice(i).replace(/(\d{3})/g, sep+'$1');
        s = _.join(dec);
    } else {
        s = s.replace('.', dec);
    }

    var decPos = s.indexOf(dec);
    if (prec >= 1 && decPos !== -1 && (s.length-decPos-1) < prec) {
        s += new Array(prec-(s.length-decPos-1)).join(0)+'0';
    }
    else if (prec >= 1 && decPos === -1) {
        s += dec+new Array(prec).join(0)+'0';
    }
    return s; 
}

( මුල් පිටුවෙන් අදහස් දැක්වීමේ කොටස , නිදසුන් සඳහා පහත ඇතුළත් කර ඇති අතර ණය ලැබිය යුතු තැන)

// Formats a number with grouped thousands
//
// version: 906.1806
// discuss at: http://phpjs.org/functions/number_format
// +   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)
// *     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'

මෙය එක් නිවැරදි ශ්‍රිතයක් පමණි:> number_format (2030, 0, '.', '') <'2 030' නියමයි! ස්තූතියි
ඇන්ටන් පී රොබුල්

20

මේ වගේ දෙයක් දැකලා නැහැ. එය ඉතා සංක්ෂිප්ත හා තේරුම් ගැනීමට පහසුය.

function moneyFormat(price, sign = '$') {
  const pieces = parseFloat(price).toFixed(2).split('')
  let ii = pieces.length - 3
  while ((ii-=3) > 0) {
    pieces.splice(ii, 0, ',')
  }
  return sign + pieces.join('')
}

console.log(
  moneyFormat(100),
  moneyFormat(1000),
  moneyFormat(10000.00),
  moneyFormat(1000000000000000000)
)

විවිධ ස්ථානීය ආකෘතීන් තුළ විවිධ මුදල් ආකෘතිකරණය කිරීමට ඉඩ දීම සඳහා අවසාන නිමැවුමේ තවත් විකල්පයන් සහිත අනුවාදයක් මෙන්න.

// higher order function that takes options then a price and will return the formatted price
const makeMoneyFormatter = ({
  sign = '$',
  delimiter = ',',
  decimal = '.',
  append = false,
  precision = 2,
  round = true,
  custom
} = {}) => value => {
  
  const e = [1, 10, 100, 1000, 10000, 100000, 1000000, 10000000]
  
  value = round
    ? (Math.round(value * e[precision]) / e[precision])
    : parseFloat(value)
  
  const pieces = value
    .toFixed(precision)
    .replace('.', decimal)
    .split('')
  
  let ii = pieces.length - (precision ? precision + 1 : 0)
  
  while ((ii-=3) > 0) {
    pieces.splice(ii, 0, delimiter)
  }
  
  if (typeof custom === 'function') {
    return custom({
      sign,
      float: value, 
      value: pieces.join('') 
    })
  }
  
  return append
    ? pieces.join('') + sign
    : sign + pieces.join('')
}

// create currency converters with the correct formatting options
const formatDollar = makeMoneyFormatter()
const formatPound = makeMoneyFormatter({ 
  sign: '£',
  precision: 0
})
const formatEuro = makeMoneyFormatter({
  sign: '€',
  delimiter: '.',
  decimal: ',',
  append: true
})

const customFormat = makeMoneyFormatter({
  round: false,
  custom: ({ value, float, sign }) => `SALE:$${value}USD`
})

console.log(
  formatPound(1000),
  formatDollar(10000.0066),
  formatEuro(100000.001),
  customFormat(999999.555)
)


නියම කේත ස්නිපටය, ස්තූතියි. කෙසේ වෙතත්, ප්‍රවේශම් වන්න, එය IE මත ක්‍රියා නොකරනු ඇති බැවින් පෙරනිමි පරාමිතීන් සහාය නොදක්වන අතර <IE11 හි "const" සහ "let" සහය නොදක්වයි. නිවැරදි කිරීමට මෙය භාවිතා කරන්න: + moneyFormat: ශ්‍රිතය (මිල, ලකුණ) {+ if (! ලකුණ) ලකුණ = '$'; + කෑලි = parseFloat (මිල) .TOFixed (2) .split ('') + var ii = pieces.length - 3
Charlie Dalsass

කරදරයක් නැත @ චාර්ලි ඩල්සාස්. නිෂ්පාදන කේතය සඳහා එය ES5 වෙත සම්පාදනය කිරීමට බාබල් භාවිතා කිරීම නිර්දේශ කරමි.
synthet1c

නමුත් යුරෝ මුදල් කරන්නේ කෙසේද? යුරෝ 1.000,00?

UmYumYumYum වඩාත් නම්‍යශීලී වීමට ඉඩ දීම සඳහා වැඩි ආකෘතිකරණ විකල්පයන් සහිත සම්පූර්ණ උදාහරණයක් මම එකතු කළෙමි.
synthet1c

18

පැට්‍රික් ඩෙස්ජාර්ඩින්ස්ගේ පිළිතුර හොඳ පෙනුමක් ඇති නමුත් මම කැමතියි මගේ ජාවාස්ක්‍රිප්ට් සරලයි. මෙන්න මම දැන් ලියා ඇති අංකයක් ගෙන එය මුදල් ආකෘතියෙන් ආපසු ලබා දීමට (ඩොලර් ලකුණ us ණ)

// Format numbers to two decimals with commas
function formatDollar(num) {
    var p = num.toFixed(2).split(".");
    var chars = p[0].split("").reverse();
    var newstr = '';
    var count = 0;
    for (x in chars) {
        count++;
        if(count%3 == 1 && count != 1) {
            newstr = chars[x] + ',' + newstr;
        } else {
            newstr = chars[x] + newstr;
        }
    }
    return newstr + "." + p[1];
}

බ්‍රව්සරයේ මෙන්ම පැරණි නෝඩ් අනුවාදයේද වැඩ කිරීමට මට යමක් අවශ්‍ය විය. මෙය පරිපූර්ණව ක්‍රියාත්මක විය. ස්තූතියි
n8jadams

17

ප්‍රධාන කොටස වන්නේ බෙදුම්කරුවන් දහසක් ඇතුළත් කිරීමයි, එය මේ ආකාරයෙන් කළ හැකිය:

<script type="text/javascript">
function ins1000Sep(val){
  val = val.split(".");
  val[0] = val[0].split("").reverse().join("");
  val[0] = val[0].replace(/(\d{3})/g,"$1,");
  val[0] = val[0].split("").reverse().join("");
  val[0] = val[0].indexOf(",")==0?val[0].substring(1):val[0];
  return val.join(".");
}
function rem1000Sep(val){
  return val.replace(/,/g,"");
}
function formatNum(val){
  val = Math.round(val*100)/100;
  val = (""+val).indexOf(".")>-1 ? val + "00" : val + ".00";
  var dec = val.indexOf(".");
  return dec == val.length-3 || dec == 0 ? val : val.substring(0,dec+3);
}
</script>

<button onclick="alert(ins1000Sep(formatNum(12313231)));">

Ins1000Sep () වෙත negative ණ අගයන් ඇතුළත් කරන අතරතුර මට වැරදි සංඛ්‍යා ප්‍රතිදානයක් ලැබේ.
පීටර්

16

බිල්ට් function ටෝ ෆික්ස්ඩ් ඇතjavascript

var num = new Number(349);
document.write("$" + num.toFixed(2));

මෙම පිළිතුර අතිරික්තයක් ලෙස පෙනේ. ක්‍රෂ්ගේ පිළිතුර දැනටමත් මානසිකවtoFixed()
ඉයන් ඩන්

3
toFixed()Numberවස්තුවක ශ්‍රිතයක් වන අතර var numඑය එසේ නම් එය ක්‍රියා නොකරනු ඇත String, එබැවින් අතිරේක සන්දර්භය මට උදව් විය.
timborden

15
function CurrencyFormatted(amount)
{
    var i = parseFloat(amount);
    if(isNaN(i)) { i = 0.00; }
    var minus = '';
    if(i < 0) { minus = '-'; }
    i = Math.abs(i);
    i = parseInt((i + .005) * 100);
    i = i / 100;
    s = new String(i);
    if(s.indexOf('.') < 0) { s += '.00'; }
    if(s.indexOf('.') == (s.length - 2)) { s += '0'; }
    s = minus + s;
    return s;
}

විල්මාස්ටර් වෙතින් .


කුඩා හා සරල. ඔබට ස්තුතියි.
කොනර් සිම්සන්

1
සරල, නමුත් 1,000 කට කොමාව නැත
aron

15

ගූගල් දෘශ්‍යකරණ API වෙතින් අංක ෆෝමැට් පන්තිය මම යෝජනා කරමි .

ඔබට මේ වගේ දෙයක් කළ හැකිය:

var formatter = new google.visualization.NumberFormat({
    prefix: '$',
    pattern: '#,###,###.##'
});

formatter.formatValue(1000000); // $ 1,000,000

එය උපකාරී වේ යැයි මම බලාපොරොත්තු වෙමි.


14

මෙය ටිකක් ප්‍රමාද විය හැකිය, නමුත් මෙන්න මම .toCurrencyString()සියලු සංඛ්‍යා වලට ස්ථාන දැන ගැනීමේ ශ්‍රිතයක් එක් කිරීම සඳහා සහායකයකු වෙනුවෙන් වැඩ කළ ක්‍රමයක් . අභ්‍යන්තරකරණය යනු අංක කාණ්ඩ කිරීම සඳහා පමණි, මුදල් ලකුණ නොවේ - ඔබ ඩොලර් ප්‍රතිදානය කරන්නේ "$"නම්, සැපයූ පරිදි භාවිතා කරන්න , මන්ද $123 4567ජපානයේ හෝ චීනයේ $1,234,567එක්සත් ජනපදයේ මෙන් ඇමරිකානු ඩොලර් ගණන සමාන වේ. ඔබ යුරෝ / යනාදිය ප්‍රතිදානය කරන්නේ නම්, මුදල් ලකුණ වෙනස් කරන්න "$".

මෙය භාවිතා කිරීමට පෙර ඔබේ හිසෙහි හෝ අවශ්‍ය ඕනෑම තැනක මෙය ප්‍රකාශ කරන්න:

  Number.prototype.toCurrencyString = function(prefix, suffix) {
    if (typeof prefix === 'undefined') { prefix = '$'; }
    if (typeof suffix === 'undefined') { suffix = ''; }
    var _localeBug = new RegExp((1).toLocaleString().replace(/^1/, '').replace(/\./, '\\.') + "$");
    return prefix + (~~this).toLocaleString().replace(_localeBug, '') + (this % 1).toFixed(2).toLocaleString().replace(/^[+-]?0+/,'') + suffix;
  }

එහෙනම් ඔයා ඉවරයි! (number).toCurrencyString()ඔබට මුදල් මුදල් ලෙස ප්‍රතිදානය කිරීමට අවශ්‍ය ඕනෑම තැනක භාවිතා කරන්න .

var MyNumber = 123456789.125;
alert(MyNumber.toCurrencyString()); // alerts "$123,456,789.13"
MyNumber = -123.567;
alert(MyNumber.toCurrencyString()); // alerts "$-123.57"

12

සාමාන්‍යයෙන්, එකම දේ කිරීමට විවිධ ක්‍රම තිබේ, නමුත් Number.prototype.toLocaleStringපරිශීලක සැකසුම් මත පදනම්ව විවිධ අගයන් ආපසු ලබා දිය හැකි බැවින් මම භාවිතා කිරීමෙන් වැළකී සිටිමි .

මම ද දීර්ඝ නිර්දේශ කරන්නේ නැහැ Number.prototypeඑය අනෙක් අය කේතය සමඟ ගැටුම් ඇති විය හැක (උදා: පුස්තකාල / රාමුව / ප්ලගින) සහ අනාගත JavaScript ක්රියාත්මක කිරිමේදි / සංස්කරණ සමග අනුකූල විය නොහැකි බැවින් දේශීය වස්තූන් මූලාදර්ශවල දීර්ඝ නරක පුරුදු වේ -.

නිත්‍ය ප්‍රකාශන යනු ගැටළුව සඳහා හොඳම ප්‍රවේශය බව මම විශ්වාස කරමි, මෙන්න මගේ ක්‍රියාත්මක කිරීම:

/**
 * Converts number into currency format
 * @param {number} number   Number that should be converted.
 * @param {string} [decimalSeparator]    Decimal separator, defaults to '.'.
 * @param {string} [thousandsSeparator]    Thousands separator, defaults to ','.
 * @param {int} [nDecimalDigits]    Number of decimal digits, defaults to `2`.
 * @return {string} Formatted string (e.g. numberToCurrency(12345.67) returns '12,345.67')
 */
function numberToCurrency(number, decimalSeparator, thousandsSeparator, nDecimalDigits){
    //default values
    decimalSeparator = decimalSeparator || '.';
    thousandsSeparator = thousandsSeparator || ',';
    nDecimalDigits = nDecimalDigits == null? 2 : nDecimalDigits;

    var fixed = number.toFixed(nDecimalDigits), //limit/add decimal digits
        parts = new RegExp('^(-?\\d{1,3})((?:\\d{3})+)(\\.(\\d{'+ nDecimalDigits +'}))?$').exec( fixed ); //separate begin [$1], middle [$2] and decimal digits [$4]

    if(parts){ //number >= 1000 || number <= -1000
        return parts[1] + parts[2].replace(/\d{3}/g, thousandsSeparator + '$&') + (parts[4] ? decimalSeparator + parts[4] : '');
    }else{
        return fixed.replace('.', decimalSeparator);
    }
}

2010/08/30 දින සංස්කරණය කරන ලදි: දශම සංඛ්‍යා ගණන සැකසීමට විකල්පයක් එක් කරන ලදි. 2011/08/23 දින සංස්කරණය කරන ලදි: දශම සංඛ්‍යා ගණන ශුන්‍යයට සැකසීමට විකල්පයක් එක් කරන ලදි.


ToLocaleString හි කාරණය වන්නේ එය පරිශීලකයාගේ සැකසුම් සමඟ ගැලපීමයි.
ජෝශප් ලෙනොක්ස්

11

මෙන්න විසඳුම් කිහිපයක්, සියල්ලම පරීක්ෂණ කට්ටලය පසුකර, පරීක්ෂණ කට්ටලය සහ මිණුම් ලකුණ ඇතුළත් කර ඇත, ඔබට පිටපත් කිරීමට හා ඇලවීමට අවශ්‍ය නම්, මෙම සාරාංශය උත්සාහ කරන්න .

ක්රමය 0 (RegExp)

Https://stackoverflow.com/a/14428340/1877620 මත පදනම් වූ නමුත් දශම ලක්ෂ්‍යයක් නොමැති නම් නිවැරදි කරන්න.

if (typeof Number.prototype.format === 'undefined') {
    Number.prototype.format = function (precision) {
        if (!isFinite(this)) {
            return this.toString();
        }

        var a = this.toFixed(precision).split('.');
        a[0] = a[0].replace(/\d(?=(\d{3})+$)/g, '$&,');
        return a.join('.');
    }
}

ක්රමය 1

if (typeof Number.prototype.format === 'undefined') {
    Number.prototype.format = function (precision) {
        if (!isFinite(this)) {
            return this.toString();
        }

        var a = this.toFixed(precision).split('.'),
            // skip the '-' sign
            head = Number(this < 0);

        // skip the digits that's before the first thousands separator 
        head += (a[0].length - head) % 3 || 3;

        a[0] = a[0].slice(0, head) + a[0].slice(head).replace(/\d{3}/g, ',$&');
        return a.join('.');
    };
}

ක්රමය 2 (අරා වලට බෙදීම)

if (typeof Number.prototype.format === 'undefined') {
    Number.prototype.format = function (precision) {
        if (!isFinite(this)) {
            return this.toString();
        }

        var a = this.toFixed(precision).split('.');

        a[0] = a[0]
            .split('').reverse().join('')
            .replace(/\d{3}(?=\d)/g, '$&,')
            .split('').reverse().join('');

        return a.join('.');
    };
}

ක්රමය 3 (ලූප්)

if (typeof Number.prototype.format === 'undefined') {
    Number.prototype.format = function (precision) {
        if (!isFinite(this)) {
            return this.toString();
        }

        var a = this.toFixed(precision).split('');
        a.push('.');

        var i = a.indexOf('.') - 3;
        while (i > 0 && a[i-1] !== '-') {
            a.splice(i, 0, ',');
            i -= 3;
        }

        a.pop();
        return a.join('');
    };
}

භාවිත උදාහරණය

console.log('======== Demo ========')
console.log(
    (1234567).format(0),
    (1234.56).format(2),
    (-1234.56).format(0)
);
var n = 0;
for (var i=1; i<20; i++) {
    n = (n * 10) + (i % 10)/100;
    console.log(n.format(2), (-n).format(2));
}

බෙදුම්කරු

අපට අභිරුචි දහස් බෙදුම්කරු හෝ දශම බෙදුම්කරු අවශ්‍ය නම්, භාවිතා කරන්න replace():

123456.78.format(2).replace(',', ' ').replace('.', ' ');

පරීක්ෂණ කට්ටලය

function assertEqual(a, b) {
    if (a !== b) {
        throw a + ' !== ' + b;
    }
}

function test(format_function) {
    console.log(format_function);
    assertEqual('NaN', format_function.call(NaN, 0))
    assertEqual('Infinity', format_function.call(Infinity, 0))
    assertEqual('-Infinity', format_function.call(-Infinity, 0))

    assertEqual('0', format_function.call(0, 0))
    assertEqual('0.00', format_function.call(0, 2))
    assertEqual('1', format_function.call(1, 0))
    assertEqual('-1', format_function.call(-1, 0))
    // decimal padding
    assertEqual('1.00', format_function.call(1, 2))
    assertEqual('-1.00', format_function.call(-1, 2))
    // decimal rounding
    assertEqual('0.12', format_function.call(0.123456, 2))
    assertEqual('0.1235', format_function.call(0.123456, 4))
    assertEqual('-0.12', format_function.call(-0.123456, 2))
    assertEqual('-0.1235', format_function.call(-0.123456, 4))
    // thousands separator
    assertEqual('1,234', format_function.call(1234.123456, 0))
    assertEqual('12,345', format_function.call(12345.123456, 0))
    assertEqual('123,456', format_function.call(123456.123456, 0))
    assertEqual('1,234,567', format_function.call(1234567.123456, 0))
    assertEqual('12,345,678', format_function.call(12345678.123456, 0))
    assertEqual('123,456,789', format_function.call(123456789.123456, 0))
    assertEqual('-1,234', format_function.call(-1234.123456, 0))
    assertEqual('-12,345', format_function.call(-12345.123456, 0))
    assertEqual('-123,456', format_function.call(-123456.123456, 0))
    assertEqual('-1,234,567', format_function.call(-1234567.123456, 0))
    assertEqual('-12,345,678', format_function.call(-12345678.123456, 0))
    assertEqual('-123,456,789', format_function.call(-123456789.123456, 0))
    // thousands separator and decimal
    assertEqual('1,234.12', format_function.call(1234.123456, 2))
    assertEqual('12,345.12', format_function.call(12345.123456, 2))
    assertEqual('123,456.12', format_function.call(123456.123456, 2))
    assertEqual('1,234,567.12', format_function.call(1234567.123456, 2))
    assertEqual('12,345,678.12', format_function.call(12345678.123456, 2))
    assertEqual('123,456,789.12', format_function.call(123456789.123456, 2))
    assertEqual('-1,234.12', format_function.call(-1234.123456, 2))
    assertEqual('-12,345.12', format_function.call(-12345.123456, 2))
    assertEqual('-123,456.12', format_function.call(-123456.123456, 2))
    assertEqual('-1,234,567.12', format_function.call(-1234567.123456, 2))
    assertEqual('-12,345,678.12', format_function.call(-12345678.123456, 2))
    assertEqual('-123,456,789.12', format_function.call(-123456789.123456, 2))
}

console.log('======== Testing ========');
test(Number.prototype.format);
test(Number.prototype.format1);
test(Number.prototype.format2);
test(Number.prototype.format3);

මිණුම් ලකුණ

function benchmark(f) {
    var start = new Date().getTime();
    f();
    return new Date().getTime() - start;
}

function benchmark_format(f) {
    console.log(f);
    time = benchmark(function () {
        for (var i = 0; i < 100000; i++) {
            f.call(123456789, 0);
            f.call(123456789, 2);
        }
    });
    console.log(time.format(0) + 'ms');
}

// if not using async, browser will stop responding while running.
// this will create a new thread to benchmark
async = [];
function next() {
    setTimeout(function () {
        f = async.shift();
        f && f();
        next();
    }, 10);
}

console.log('======== Benchmark ========');
async.push(function () { benchmark_format(Number.prototype.format); });
next();

ඔබේ ක්‍රමයෙන් වැඩි දියුණු කර ඇත. ; var a = Math.round (fullNumber / 10) * 10 / ගුණකය; if (String (a) .indexOf ('.') <1) {a + = '.00'; String a = String (a) .split ('.'), toFixed භාවිතා නොකරන්න, එය දෝෂ සහිතය.
vee

console.log (parseFloat ('4.835'). toFixed (2)); > 4.83 console.log (parseFloat ('54 .835 '). ToFixed (2)); > 54.84 console.log (parseFloat ('454.835'). ToFixed (2)); > 454.83 console.log (parseFloat ('8454.835'). ToFixed (2)); > 8454.83 මෙම අගයේ දශම සියල්ලම විය යුතුය .84 නොවේ .83
vee


10

පළමු හා මූලික රීජෙක්ස්ප් එක ආපසු හරවා නිසි කොමා ස්ථානගත කිරීම සඳහා සරල විකල්පයකි.

String.prototype.reverse = function() {
    return this.split('').reverse().join('');
};

Number.prototype.toCurrency = function( round_decimal /*boolean*/ ) {       
     // format decimal or round to nearest integer
     var n = this.toFixed( round_decimal ? 0 : 2 );

     // convert to a string, add commas every 3 digits from left to right 
     // by reversing string
     return (n + '').reverse().replace( /(\d{3})(?=\d)/g, '$1,' ).reverse();
};

10

මම මෙය සොයාගත්තේ: account.js . එය ඉතා පහසු සහ මගේ අවශ්‍යතාවයට හොඳින් ගැලපේ.

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

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

// Negative values can be formatted nicely:
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

// Euro currency symbol to the right
accounting.formatMoney(5318008, {symbol: "€", precision: 2, thousand: ".", decimal : ",", format: "%v%s"}); // 1.008,00€ 


$('#price').val( accounting.formatMoney(OOA, { symbol: "€", precision: 2,thousand: ".", decimal :",",format: "%v%s" } ) );- 1.000,00 E පෙන්වන්න
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.