Wie kann ich formatieren Zahlen als Währung Zeichenfolge in JavaScript?

StackOverflow https://stackoverflow.com/questions/149055

  •  02-07-2019
  •  | 
  •  

Frage

Ich möchte einen Preis in JavaScript zu formatieren.
Ich möchte eine Funktion, die eine float als Argument und gibt eine string wie folgt formatiert: 

"$ 2,500.00"

Was ist der beste Weg, dies zu tun?

War es hilfreich?

Lösung 12

Ok, auf das, was Sie gesagt haben, ich verwende diese: 

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;

Ich bin offen für Verbesserungsvorschläge (ich würde es vorziehen, nicht nur schließen YUI dieses zu tun :-)) Ich weiß schon, sollte ich das sein Erkennen „“ statt nur als Dezimaltrennzeichen ...

Andere Tipps

Number.prototype.toFixed

Diese Lösung ist kompatibel mit jedem einzelnen großen Browser: 

  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)

Alles, was Sie brauchen, ist das Währungssymbol hinzuzufügen (z "$" + profits.toFixed(2)) und Sie werden Ihre Menge in Dollar.

Benutzerdefinierte Funktion

Wenn Sie die Verwendung von , zwischen jeder Ziffer benötigen, können Sie diese Funktion verwenden: 

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>

Verwenden Sie es wie folgt: 

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

Wenn du gehst immer verwenden ‚‘ und ‚‘, Sie können sie lassen Sie Ihren Methodenaufruf und die Methode sie für Sie Standard. 

(123456789.12345).formatMoney(2);

Wenn Ihre Kultur hat die beiden Symbole gekippt (das heißt die Europäer) und Sie möchten die Standardeinstellungen verwenden, fügen Sie einfach über die folgenden zwei Zeilen in der formatMoney Methode: 

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

Benutzerdefinierte Funktion (ES6)

Wenn Sie moderne ECMAScript-Syntax (das heißt durch Babel) verwenden können, können Sie diese einfachere Funktion verwenden, anstatt: 

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>

Kurze und schnelle Lösung (funktioniert überall!) 

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

Die Idee hinter dieser Lösung wird abgestimmt Abschnitte mit erster Übereinstimmung und Komma ersetzt, d.h. '$&,'. Der Abgleich erfolgt mit Look-Ahead-Ansatz . Sie können den Ausdruck als lesen „eine Reihe übereinstimmen, wenn sie durch eine Folge von drei Zahlensätzen (ein oder mehr) und ein Punkt gefolgt ist“.

TESTS: 

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"

DEMO: http://jsfiddle.net/hAfMM/9571/

Erweiterte kurze Lösung

Sie können auch den Prototyp Number Objekt zusätzliche Unterstützung einer beliebigen Anzahl von Dezimalstellen hinzufügen [0 .. n] und der Größe der Anzahl Gruppen [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"

DEMO / TESTS: http://jsfiddle.net/hAfMM/435/

Super verlängerte kurze Lösung

In diesem Super erweiterte Version Sie können verschiedene Trennzeichen-Typen festgelegt: 

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

DEMO / TESTS: http://jsfiddle.net/hAfMM/612/

Intl.numberformat

Javascript hat eine Reihe Formatierer (Teil der Internationalisierungs API). 

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

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

JS Geige

Verwenden undefined anstelle des ersten Arguments ('en-US' im Beispiel) das Systemgebietsschema zu verwenden (das Benutzergebietsschema, falls der Code in einem Browser ausgeführt wird).

Intl.NumberFormat vs Number.prototype.toLocaleString

Eine letzte Bemerkung dies den älteren .toLocaleString zu vergleichen. Beide bieten im Wesentlichen die gleiche Funktionalität. Allerdings toLocaleString in seinen älteren Inkarnationen (pre-Intl) nicht tatsächlich unterstützen locales : sie nutzt das Systemgebietsschema. Daher sollten Sie, dass Sie die richtige Version verwenden ( MDN schlägt vor, für die Existenz von Intl zu überprüfen). Auch ist die Leistung sowohl das gleiche für einen Single Artikel, aber wenn Sie eine Menge von Zahlen Format haben, Intl.NumberFormat Verwendung ist ~ 70-mal schneller. Hier ist, wie toLocaleString zu verwenden: 

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

Einige Hinweise auf die Browserunterstützung

  • Browser-Unterstützung ist nicht länger ein Problem heute mit 97% Unterstützung in den USA / EU
  • Bei anderen Teilen der Welt (92% unterstützt), die größten Übeltäter in Bezug auf die Unterstützung sind UC Mobile ( bleiben Sie weg von diesem ) und Opera Mini (verkrüppelte nach Design)
  • Es ist ein Shim es auf älteren Browsern zu unterstützen
  • Haben Sie einen Blick auf CanIUse für weitere Informationen

Werfen Sie einen Blick auf die JavaScript Nummer Objekt und sehen, ob es Ihnen helfen kann.

  • toLocaleString() formatiert eine Zahl mit standortspezifischen Tausendertrennzeichen.
  • toFixed() wird die Zahl auf eine bestimmte Anzahl von Dezimalstellen gerundet werden soll.

Um diese zur gleichen Zeit zu verwenden, muss der Wert dieser Art müssen eine Nummer geändert zurück, weil sie einen String beide ausgegeben.

Beispiel: 

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

Im Folgenden finden Sie die Patrick Desjardins (alias Daok) Code mit einem bisschen Kommentar hinzugefügt und einigen kleineren Änderungen: 

/* 
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 [https://stackoverflow.com/questions/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) : ''); 
}

und hier einige Tests: 

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

Die geringfügigen Änderungen sind:

  1. bewegt, um die Math.abs(decimals) ein bisschen nur getan werden, wenn nicht NaN.

  2. decimal_sep kann nicht mehr leere Zeichenkette (a irgendeine Art von Dezimaltrennzeichen ist ein Muss)

  3. Wir verwenden typeof thousands_sep === 'undefined' wie in Wie man am besten, um zu bestimmen, ob ein Argument nicht an die JavaScript-Funktion gesendet wird

  4. (+n || 0) ist nicht erforderlich, weil this ein Number Objekt ist

JS Fiddle

accounting.js ist eine kleine JavaScript-Bibliothek für Zahl, Geld und Währung Formatierung.

Wenn die Menge eine Zahl ist, sagen -123, dann 

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

wird die Zeichenfolge "-$123.00" erzeugen.

Hier ist eine komplette Arbeits Beispiel .

Hier ist der beste js Geld Formatierer ich gesehen habe: 

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

Es wurde neu formatiert und lieh sich von hier: https://stackoverflow.com/a/149099/751484

Sie müssen werden Ihre eigene Währung Bezeichner liefern (Sie $ oben verwendet).

Nennen Sie es wie folgt aus (obwohl beachten Sie, dass die args standardmäßig auf 2, Komma, und Zeit, so dass Sie brauchen keine Argumente zu liefern, wenn das Ihre Präferenz ist): 

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

Es gibt bereits einige tolle Antworten hier. Hier ist ein weiterer Versuch, nur so zum Spaß: 

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

Und einige Tests: 

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

Editiert: jetzt wird es auch negative Zahlen verarbeiten

Ich denke, was Sie wollen, ist f.nettotal.value = "$" + showValue.toFixed(2);

Also, warum hat niemand vorgeschlagen, die folgenden? 

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

Arbeiten für die meisten / einige Browser:

https://developer.mozilla.org/en -US / docs / Web / JavaScript / Reference / Global_Objects / Anzahl / toLocaleString # Browser_Compatibility

Numeral.js - eine js Bibliothek für die einfache Zahlenformatierung von @adamwdraper 

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

Ich verwende die Bibliothek Globalize (von Microsoft):

Es ist ein großes Projekt Zahlen, Währungen und Daten zu lokalisieren und sie automatisch den richtigen Weg nach dem Benutzergebietsschema formatiert zu haben! ... und obwohl es eine jQuery-Erweiterung sein soll, ist es derzeit eine 100% unabhängige Bibliothek. Ich schlage vor, Sie alle, es auszuprobieren! :)

Javascript-number-Formatierer (früher unter Google Code )

  • Kurz, schnell, flexibel noch Standalone. Nur 75 Zeilen einschließlich MIT-Lizenz Info, Leerzeilen und Kommentare.
  • Akzeptieren Standardzahlenformatierung wie #,##0.00 oder mit Negation -000.####.
  • Akzeptieren jedes Land Format wie # ##0,00, #,###.##, #'###.## oder jede Art von nicht-Nummerierung Symbol.
  • Nehmen Sie alle Zahlen von Zifferngruppierung. #,##,#0.000 oder #,###0.## sind alle gültig.
  • Nehmen Sie jede redundante / todsichere Formatierung. ##,###,##.# oder 0#,#00#.###0# sind alle in Ordnung.
  • Auto Zahl gerundet wird.
  • Einfache Schnittstelle, liefern nur Maske & Wert wie folgt aus:. format( "0.0000", 3.141592)
  • Fügen Sie einen Präfix & Suffix mit der Maske

(Auszug aus seiner Readme)

Es ist ein Javascript-Port der PHP-Funktion "number_format".

Ich finde es sehr nützlich, da es einfach zu bedienen und erkennbar für PHP-Entwickler ist. 

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

(Kommentar Block von des ursprünglichen , auch weiter unten für Beispiele & Kredit, in dem durch ) 

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

1 zu Jonathan M für die ursprüngliche Methode bereitstellt. Da dies ausdrücklich eine Währung Formatierer ist, ging ich weiter und fügte hinzu, das Währungssymbol (Standard: ‚$‘) an den Ausgang, und hinzugefügt Separator einen Standard Komma als Tausender. Wenn Sie nicht wirklich ein Währungssymbol wollen (oder Tausendertrennzeichen), benutzen Sie einfach „“ (leere Zeichenkette) als Argument dafür. 

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

Ein kürzeres Verfahren (zum Einfügen Leerzeichen, Kommas oder Punktes) mit regulärem Ausdruck? 

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

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

Patrick Desjardins ‘Antwort sieht gut aus, aber ich ziehe mein Javascript einfach. Hier ist eine Funktion, die ich schrieb nur eine Nummer in nehmen und bringen Sie es in Währungsformat (minus das Dollarzeichen) 

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

Es gibt einen eingebauten in function toFixed in javascript 

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

Der Hauptteil ist die tausend Separatoren eingesetzt wird, dass wie dies geschehen könnte: 

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

Ich schlage vor, die Number Klasse von Google Visualization API .

Sie können etwas tun: 

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

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

Ich hoffe, es hilft.

Haben nicht dieses gesehen. Es ist ziemlich übersichtlich und leicht zu verstehen. 

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

Hier ist eine Version mit mehr Optionen in der endgültigen Ausgabe Formatierung verschiedene Währungen in verschiedenen Formaten Ort zu ermöglichen. 

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

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

Von WillMaster .

Dies könnte ein wenig spät, aber hier ist eine Methode, die ich für einen Mitarbeiter nur aufgearbeitet, wobei eine locale-aware .toCurrencyString() Funktion auf alle Zahlen zu addieren. Die Internalisierung ist für Nummer Gruppierung, nicht die Währung Zeichen - wenn Sie Dollar sind ausgeben, verwendet "$" wie geliefert, weil $123 4567 in Japan oder China die gleiche Anzahl von USD ist als $1,234,567 hier in den USA ist. Wenn Sie Euro sind die Ausgabe / etc., Dann die Währung Vorzeichen wechseln von "$".

Erklären Sie diese überall in Ihrem Kopf oder wo auch immer notwendig, kurz bevor Sie es verwenden müssen: 

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

Dann sind Sie fertig! Verwenden Sie (number).toCurrencyString() überall müssen Sie die Ausgabe der Zahl als Währung. 

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

Wie in der Regel gibt es mehrere Möglichkeiten, das gleiche tun, aber ich würde mit Number.prototype.toLocaleString vermeiden, da sie unterschiedliche Werte auf der Basis der Benutzereinstellungen zurückkehren können.

Ich empfehle auch nicht die Number.prototype erstreckt - erstreckt native Objekte Prototypen eine schlechte Praxis ist, da es Konflikte mit anderen Menschen Code führen kann (zB Bibliotheken / Frameworks / plugins) und kann nicht mit zukünftigen JavaScript-Implementierungen / Versionen kompatibel sein.

Ich glaube, dass Reguläre Ausdrücke der beste Ansatz für das Problem, hier ist meine Implementierung: 

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

bearbeitet am 2010.08.30. Hinzugefügt Option Anzahl der Dezimalstellen festlegen bearbeitet am 2011.08.23. Hinzugefügt Option Anzahl der Dezimalstellen auf Null zu setzen

Hier einige Lösungen, die alle den Test-Suite, Test-Suite und Benchmark enthalten sind, wenn Sie kopieren möchten, und fügen Sie ihn zu testen, versuchen Sie Dieser Gist .

Methode 0 (RegExp)

Base auf https://stackoverflow.com/a/14428340/1877620 , aber fix, wenn es keine dezimal Punkt. 

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

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

Methode 2 (Split Array) 

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

Methode 3 (Loop) 

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

Verwendungsbeispiel 

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

Separator

Wenn wir individuelle Tausender-Trennzeichen oder Dezimalzeichen möchten, verwenden Sie replace(): 

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

Testsuite 

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

Benchmark 

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

Ich fand dies aus: accounting.js . Es ist sehr einfach und passt perfekt zu meinem Bedürfnis. 

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

Eine einfache Möglichkeit für die richtige Platzierung Komma durch den Zeichenfolge ersten und grundlegenden regexp rückgängig zu machen. 

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

Patrick Desjardins (ex Daok) s Beispiel gut für mich gearbeitet. Ich portiert zu Coffeescript, wenn jemand interessiert ist. 

Number.prototype.toMoney = (decimals = 2, decimal_separator = ".", thousands_separator = ",") ->
    n = this
    c = if isNaN(decimals) then 2 else Math.abs decimals
    sign = if n < 0 then "-" else ""
    i = parseInt(n = Math.abs(n).toFixed(c)) + ''
    j = if (j = i.length) > 3 then j % 3 else 0
    x = if j then i.substr(0, j) + thousands_separator else ''
    y = i.substr(j).replace(/(\d{3})(?=\d)/g, "$1" + thousands_separator)
    z = if c then decimal_separator + Math.abs(n - i).toFixed(c).slice(2) else ''
    sign + x + y + z
Lizenziert unter: CC-BY-SA mit Zuschreibung
Nicht verbunden mit StackOverflow
scroll top