it-swarm.com.de

Wie kann ich Zahlen als Dollar-Währungszeichenfolge in JavaScript formatieren?

Ich möchte einen Preis in JavaScript formatieren.
Ich möchte eine Funktion, die eine float als Argument verwendet und eine string zurückgibt, die folgendermaßen formatiert ist:

"$ 2,500.00"

Was ist der beste Weg dies zu tun?

1511
Daniel Magliola

Ok, basierend auf dem, was Sie gesagt haben, verwende ich Folgendes:

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 möchte YUI nicht einfach dazu hinzufügen :-)). anstatt nur als Dezimaltrennzeichen zu verwenden ...

25
Daniel Magliola

Number.prototype.toFixed

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

  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)

Sie müssen lediglich das Währungssymbol hinzufügen (z. B. "$" + profits.toFixed(2)), und Sie erhalten Ihren Betrag in US-Dollar.

Benutzerdefinierte Funktion

Wenn Sie die Verwendung von , zwischen den einzelnen Ziffern benötigen, können Sie diese Funktion verwenden:

function formatMoney(n, c, d, t) {
  var c = isNaN(c = Math.abs(c)) ? 2 : c,
    d = d == undefined ? "." : d,
    t = t == undefined ? "," : t,
    s = n < 0 ? "-" : "",
    i = String(parseInt(n = Math.abs(Number(n) || 0).toFixed(c))),
    j = (j = i.length) > 3 ? j % 3 : 0;

  return s + (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) : "");
};

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 Sie immer "." und ',' können Sie sie von Ihrem Methodenaufruf weglassen, und die Methode wird für Sie als Standard festgelegt.

(123456789.12345).formatMoney(2);

Wenn in Ihrer Kultur die beiden Symbole umgedreht wurden (d. H. Europäer) und Sie die Standardwerte verwenden möchten, fügen Sie in der formatMoney-Methode die folgenden beiden Zeilen ein:

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

Benutzerdefinierte Funktion (ES6)

Wenn Sie moderne ECMAScript-Syntax verwenden können (d. H. Über Babel), können Sie stattdessen diese einfachere Funktion verwenden:

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>

1596

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 besteht darin, übereinstimmende Abschnitte durch erste Übereinstimmung und Komma, d. H. '$&,', zu ersetzen. Der Abgleich erfolgt mit Lookahead-Ansatz . Sie können den Ausdruck lesen, wenn "mit einer Zahl übereinstimmt, wenn auf eine Folge von drei Zahlensätzen (eine oder mehrere) und ein Punkt" folgt.

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 Kurzlösung

Sie können den Prototyp von Number object auch erweitern, um eine zusätzliche Unterstützung für eine beliebige Anzahl von Dezimalzahlen [0 .. n] und die Größe von Zahlengruppen [0 .. x]: hinzuzufügen.

/**
 * 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 erweiterte Kurzlösung

In dieser super erweiterten Version können Sie verschiedene Begrenzertypen einstellen:

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

1136
VisioN

Intl.numberformat

Javascript hat einen Zahlenformatierer (Teil der Internationalisierungs-API).

// Create our number formatter.
var formatter = new Intl.NumberFormat('en-US', {
  style: 'currency',
  currency: 'USD',
  minimumFractionDigits: 2,
  // the default value for minimumFractionDigits depends on the currency
  // and is usually already 2
});

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

JS Geige

Verwenden Sie undefined anstelle des ersten Arguments ('en-US' im Beispiel), um das Systemgebietsschema (das Benutzergebietsschema für den Fall, dass der Code in einem Browser ausgeführt wird) zu verwenden.

Intl.NumberFormat vs Number.prototype.toLocaleString

Eine letzte Anmerkung zum Vergleich mit dem älteren .toLocaleString. Beide bieten im Wesentlichen die gleiche Funktionalität. ToLocaleString in älteren Versionen (pre-Intl) unterstützt jedoch keine Gebietsschemata : Es verwendet das Systemgebietsschema. Um sicherzustellen, dass Sie die richtige Version verwenden, empfiehlt MDN, das Vorhandensein von Intl zu überprüfen. Wenn Sie also ohnehin nach Intl suchen müssen, verwenden Sie stattdessen it? Wenn Sie sich jedoch für die Verwendung des Shims entscheiden, werden auch toLocaleString-Patches vorgenommen.

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

Einige Hinweise zur Browserunterstützung

  • Browserunterstützung ist heutzutage mit 97% Unterstützung in den USA/EU kein Thema mehr
  • In anderen Teilen der Welt (90% unterstützt) sind UC Mobile ( bleiben Sie fern von ) und Opera Mini (von Design eingeschränkt) die größten Straftäter in Bezug auf die Unterstützung.
  • Es gibt ein shim , das in älteren Browsern unterstützt wird
  • Werfen Sie einen Blick auf CanIUse für weitere Informationen
931
aross

Schauen Sie sich das JavaScript Number Objekt an und sehen Sie, ob es Ihnen helfen kann.

  • toLocaleString() formatiert eine Zahl unter Verwendung des ortsspezifischen Tausendertrennzeichens. 
  • toFixed() rundet die Zahl auf eine bestimmte Anzahl von Dezimalstellen.

Um diese gleichzeitig zu verwenden, muss der Wert des Werts wieder in eine Zahl geändert werden, da beide einen String ausgeben. 

Beispiel:

Number(someNumber.toFixed(1)).toLocaleString()
186
17 of 26

Nachfolgend finden Sie den Code Patrick Desjardins (alias Daok) mit ein paar zusätzlichen Kommentaren und geringfügigen Ä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 kleineren Änderungen sind:

  1. die Math.abs(decimals) wurde etwas verschoben, wenn sie nicht NaN ist.

  2. decimal_sep darf keine leere Zeichenfolge mehr sein (eine Art Dezimaltrennzeichen ist ein MUSS)

  3. wir verwenden typeof thousands_sep === 'undefined' wie in vorgeschlagen, um zu bestimmen, ob ein Argument nicht an die JavaScript-Funktion gesendet wird.

  4. (+n || 0) wird nicht benötigt, da this ein Number-Objekt ist

JS Fiddle

159
Marco Demaio

accounting.js ist eine kleine JavaScript-Bibliothek für die Formatierung von Zahlen, Geld und Währungen.

122
GasheK

Wenn Betrag eine Zahl ist, sagen Sie -123

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

erzeugt den String "-$123.00".

Hier ist ein komplettes Arbeits Beispiel .

107

Hier ist der beste Js-Geldformatierer, den ich je 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 von hier aus neu formatiert und ausgeliehen: https://stackoverflow.com/a/149099/751484

Sie müssen Ihren eigenen Währungsbezeichner angeben (Sie haben $ oben verwendet).

Nennen Sie es so (obwohl die Argumente standardmäßig auf 2, Komma und Punkt gesetzt sind, müssen Sie keine Argumente angeben, wenn Sie dies bevorzugen)

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

Hier gibt es bereits einige großartige Antworten. Hier ist ein weiterer Versuch, nur 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 werden auch negative Zahlen verarbeitet

72
Wayne Burkett

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

69
crush

Warum hat niemand folgendes vorgeschlagen? 

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

Funktioniert für die meisten/einige Browser:

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

60
Nick Grealy

Ich benutze die Bibliothek Globalize (von Microsoft): 

Es ist ein großartiges Projekt, Zahlen, Währungen und Datumsangaben zu lokalisieren und sie automatisch entsprechend der Ländereinstellung des Benutzers formatieren zu lassen! ... und obwohl es eine jQuery-Erweiterung sein sollte, ist es derzeit eine zu 100% unabhängige Bibliothek. Ich schlage euch alle vor, es auszuprobieren! :)

25
daveoncode

Numeral.js - Eine js-Bibliothek für die einfache Zahlenformatierung durch @adamwdraper

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

javascript-number-formatter (früher bei Google Code )

  • Kurz, schnell, flexibel und dennoch eigenständig. Nur 75 Zeilen einschließlich MIT Lizenzinformationen, Leerzeilen und Kommentaren.
  • Übernehmen Sie die Standardnummernformatierung wie #,##0.00 oder mit Negation -000.####.
  • Akzeptieren Sie ein beliebiges Länderformat wie # ##0,00, #,###.##, #'###.## oder ein beliebiges Symbol ohne Nummer.
  • Akzeptieren Sie eine beliebige Anzahl von Zifferngruppierungen. #,##,#0.000 oder #,###0.## sind alle gültig.
  • Akzeptieren Sie alle redundanten/narrensicheren Formatierungen. ##,###,##.# oder 0#,#00#.###0# sind alle in Ordnung.
  • Automatische Nummernrundung.
  • Einfache Schnittstelle, einfach Maske und Wert wie folgt angeben: format( "0.0000", 3.141592).
  • Fügen Sie der Maske ein Präfix und ein Suffix hinzu

(Auszug aus der README)

23
Goodeq

Es gibt einen Javascript-Port der PHP -Funktion "number_format".

Ich finde es sehr nützlich, da es einfach zu bedienen ist und für PHP Entwickler erkennbar 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; 
}

(Kommentarblock aus dem Original , unten für Beispiele und zur Gutschrift, falls fällig)

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

+1 an Jonathan M für die Bereitstellung der Originalmethode. Da dies explizit ein Währungsformatierer ist, habe ich das Währungssymbol (Standardeinstellung '$') zur Ausgabe hinzugefügt und ein Standardkomma als Tausendertrennzeichen hinzugefügt. Wenn Sie eigentlich kein Währungssymbol (oder Tausendertrennzeichen) wünschen, verwenden Sie einfach "" (leere Zeichenfolge) 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) : "");
};
21
XML

Eine kürzere Methode (zum Einfügen von Leerzeichen, Komma oder Punkt) 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());
20

Es gibt eine integrierte functiontoFixed in javascript 

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

Patrick Desjardins 'Antwort sieht gut aus, aber ich bevorzuge mein Javascript einfach. Hier ist eine Funktion, die ich gerade geschrieben habe, um eine Zahl zu übernehmen und im Währungsformat zurückzugeben (minus dem 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];
}
16
Tim Saylor

Ich empfehle die NumberFormat-Klasse aus Google Visualization API .

Sie können so etwas tun:

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

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

Ich hoffe, es hilft.

15
juanOS

Ich habe diesen nicht gesehen. Es ist ziemlich knapp und leicht verständlich.

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 Endausgabe, um das Formatieren verschiedener Währungen in verschiedenen Lokalitätsformaten 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)
)

15
synthet1c

Dies könnte etwas spät sein, aber hier habe ich gerade eine Methode erarbeitet, die es einem Kollegen ermöglicht, allen Zahlen eine locale-fähige .toCurrencyString()-Funktion hinzuzufügen. Die Internalisierung ist nur für die Zahlengruppierung gedacht, NICHT für das Währungszeichen. Wenn Sie Dollar ausgeben, verwenden Sie "$" wie angegeben, da $123 4567 in Japan oder China dieselbe USD-Zahl wie $1,234,567 hier in den USA ist. Wenn Sie Euro/etc ausgeben, ändern Sie das Währungszeichen in "$".

Deklarieren Sie dies irgendwo in Ihrem HEAD oder wo immer es nötig ist, 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 bist du fertig! Verwenden Sie (number).toCurrencyString() überall, um die Zahl als Währung auszugeben.

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

Der Hauptteil ist das Einfügen der Tausendertrennzeichen.

<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)));">
14
roenving
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 .

14
Bill the Lizard

Hier sind einige Lösungen, die alle die Testsuite, Testsuite und Benchmark bestehen. Wenn Sie das Kopieren und Einfügen testen möchten, versuchen Sie This Gist .

Methode 0 (RegExp)

Basis auf https://stackoverflow.com/a/14428340/1877620 , aber korrigieren, wenn kein Dezimalpunkt vorhanden ist.

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 (in Array aufteilen)

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

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 Sie ein benutzerdefiniertes Tausendertrennzeichen oder ein Dezimaltrennzeichen verwenden 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();
11
Steely Wing

Wie üblich gibt es mehrere Möglichkeiten, das Gleiche zu tun, aber ich würde die Verwendung von Number.prototype.toLocaleString vermeiden, da auf der Grundlage der Benutzereinstellungen unterschiedliche Werte zurückgegeben werden können.

Ich empfehle auch nicht, die Erweiterung von Number.prototype zu erweitern - das Erweitern von Prototypen für native Objekte ist eine schlechte Praxis, da dies zu Konflikten mit dem Code anderer Benutzer (z. B. Bibliotheken/Frameworks/Plugins) führen kann und möglicherweise nicht mit zukünftigen JavaScript-ImplementierungenVersionen kompatibel ist.

Ich glaube, dass reguläre Ausdrücke der beste Ansatz für das Problem sind. 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 30.08.2010: Option hinzugefügt, um die Anzahl der Dezimalstellen festzulegen. bearbeitet am 23.08.2011: Option hinzugefügt, um die Anzahl der Dezimalstellen auf Null zu setzen.

11
Miller Medeiros

Ich habe dies aus: accounting.js gefunden. Es ist sehr einfach und passt perfekt zu meinen Bedürfnissen.

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

11
Faysal Haque

Eine einfache Option für die korrekte Platzierung des Kommas durch Umkehren der ersten Zeichenfolge und des grundlegenden Regex.

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
troy

Das Beispiel von Patrick Desjardins (ex Daok) hat für mich gut funktioniert. Ich habe auf Coffeescript portiert, 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
9
jc00ke

Die YUI-Codebase verwendet das folgende Formmating:

format: function(nData, oConfig) {
    oConfig = oConfig || {};

    if(!YAHOO.lang.isNumber(nData)) {
        nData *= 1;
    }

    if(YAHOO.lang.isNumber(nData)) {
        var sOutput = nData + "";
        var sDecimalSeparator = (oConfig.decimalSeparator) ? oConfig.decimalSeparator : ".";
        var nDotIndex;

        // Manage decimals
        if(YAHOO.lang.isNumber(oConfig.decimalPlaces)) {
            // Round to the correct decimal place
            var nDecimalPlaces = oConfig.decimalPlaces;
            var nDecimal = Math.pow(10, nDecimalPlaces);
            sOutput = Math.round(nData*nDecimal)/nDecimal + "";
            nDotIndex = sOutput.lastIndexOf(".");

            if(nDecimalPlaces > 0) {
                // Add the decimal separator
                if(nDotIndex < 0) {
                    sOutput += sDecimalSeparator;
                    nDotIndex = sOutput.length-1;
                }
                // Replace the "."
                else if(sDecimalSeparator !== "."){
                    sOutput = sOutput.replace(".",sDecimalSeparator);
                }
                // Add missing zeros
                while((sOutput.length - 1 - nDotIndex) < nDecimalPlaces) {
                    sOutput += "0";
                }
            }
        }

        // Add the thousands separator
        if(oConfig.thousandsSeparator) {
            var sThousandsSeparator = oConfig.thousandsSeparator;
            nDotIndex = sOutput.lastIndexOf(sDecimalSeparator);
            nDotIndex = (nDotIndex > -1) ? nDotIndex : sOutput.length;
            var sNewOutput = sOutput.substring(nDotIndex);
            var nCount = -1;
            for (var i=nDotIndex; i>0; i--) {
                nCount++;
                if ((nCount%3 === 0) && (i !== nDotIndex)) {
                    sNewOutput = sThousandsSeparator + sNewOutput;
                }
                sNewOutput = sOutput.charAt(i-1) + sNewOutput;
            }
            sOutput = sNewOutput;
        }

        // Prepend prefix
        sOutput = (oConfig.prefix) ? oConfig.prefix + sOutput : sOutput;

        // Append suffix
        sOutput = (oConfig.suffix) ? sOutput + oConfig.suffix : sOutput;

        return sOutput;
    }
    // Still not a Number, just return unaltered
    else {
        return nData;
    }
}

sie müssten bearbeitet werden, da die YUI-Bibliothek konfigurierbar ist, beispielsweise wenn Sie oConfig.decimalSeparator durch "."

7
albertein

55 Antworten bittet eindeutig um eine andere

        function centsToDollaString(x){
          var cents = x + ""
          while(cents.length < 4){
            cents = "0" + cents;
          }
          var dollars = cents.substr(0,cents.length - 2)
          var decimal = cents.substr(cents.length - 2, 2)
          while(dollars.length % 3 != 0){
            dollars = "0" + dollars;
          }
          str = dollars.replace(/(\d{3})(?=\d)/g, "$1" + ",").replace(/^0*(?=.)/,"");
          return "$" + str + "." + decimal;
        }
6
jacob

@tggagne ist richtig. Meine Lösung unten ist aufgrund von Rundungsrundungen nicht gut. Und die toLocaleString-Funktion hat keine Browser-Unterstützung. Ich werde die nachstehenden Kommentare zu Archivierungszwecken überlassen, was NICHT zu tun ist. :)

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

(Alte Lösung) Verwenden Sie stattdessen eine Patrick Desjardins-Lösung.

Dies ist eine knifflige Lösung, die toLocaleString () verwendet, die seit der Javascript-Version 1.0 unterstützt wird. In diesem Beispiel wird die Währung in US-Dollar angegeben, sie kann jedoch in GBP geändert werden, indem anstelle von USD der GBP verwendet wird.

var formatMoney = function (value) {
    // Convert the value to a floating point number in case it arrives as a string.
    var numeric = parseFloat(value);
    // Specify the local currency.
    return numeric.toLocaleString('USD', { style: 'currency', currency: "USD", minimumFractionDigits: 2, maximumFractionDigits: 2 });
}

Siehe https://marcoscaceres.github.io/jsi18n/#localize_currency für weitere Details.

6
Ken Palmer

Eine Funktion zur Verarbeitung der Währungsausgabe, einschließlich Negative .

Beispielausgabe:
$ 5,23
$ 5,33

function formatCurrency(total) {
    var neg = false;
    if(total < 0) {
        neg = true;
        total = Math.abs(total);
    }
    return (neg ? "-$" : '$') + parseFloat(total, 10).toFixed(2).replace(/(\d)(?=(\d{3})+\.)/g, "$1,").toString();
}
6
Chad Kuehn

http://code.google.com/p/javascript-number-formatter/ :

  • Kurz, schnell, flexibel und dennoch eigenständig. Nur 75 Zeilen einschließlich MIT Lizenzinformationen, Leerzeilen und Kommentaren.
  • Übernehmen Sie die Standardnummernformatierung wie #, ## 0.00 oder mit Negation -000. ####.
  • Akzeptieren Sie ein beliebiges Länderformat wie # ## 0,00, #, ###. ##, # '###. ## oder ein beliebiges anderes Symbol ohne Nummer.
  • Akzeptieren Sie eine beliebige Anzahl von Zifferngruppierungen. #, ##, # 0.000 oder #, ### 0. ## sind alle gültig.
  • Akzeptieren Sie alle redundanten/narrensicheren Formatierungen. ##, ###, ##. # oder 0 #, # 00 #. ### 0 # sind alle OK.
  • Automatische Nummernrundung.
  • Einfache Schnittstelle, nur Maske und Wert wie folgt angeben: format ("0.0000", 3.141592)

UPDATE Dies ist meine selbst entwickelte pp-Dienstprogramm für die häufigsten Aufgaben:

var NumUtil = {};

/**
  Petty print 'num' wth exactly 'signif' digits.
  pp(123.45, 2) == "120"
  pp(0.012343, 3) == "0.0123"
  pp(1.2, 3) == "1.20"
*/
NumUtil.pp = function(num, signif) {
    if (typeof(num) !== "number")
        throw 'NumUtil.pp: num is not a number!';
    if (isNaN(num))
        throw 'NumUtil.pp: num is NaN!';
    if (num < 1e-15 || num > 1e15)
        return num;
    var r = Math.log(num)/Math.LN10;
    var dot = Math.floor(r) - (signif-1);
    r = r - Math.floor(r) + (signif-1);
    r = Math.round(Math.exp(r * Math.LN10)).toString();
    if (dot >= 0) {
        for (; dot > 0; dot -= 1)
            r += "0";
        return r;
    } else if (-dot >= r.length) {
        var p = "0.";
        for (; -dot > r.length; dot += 1) {
            p += "0";
        }
        return p+r;
    } else {
        return r.substring(0, r.length + dot) + "." + r.substring(r.length + dot);
    }
}

/** Append leading zeros up to 2 digits. */
NumUtil.align2 = function(v) {
    if (v < 10)
        return "0"+v;
    return ""+v;
}
/** Append leading zeros up to 3 digits. */
NumUtil.align3 = function(v) {
    if (v < 10)
        return "00"+v;
    else if (v < 100)
        return "0"+v;
    return ""+v;
}

NumUtil.integer = {};

/** Round to integer and group by 3 digits. */
NumUtil.integer.pp = function(num) {
    if (typeof(num) !== "number") {
        console.log("%s", new Error().stack);
        throw 'NumUtil.integer.pp: num is not a number!';
    }
    if (isNaN(num))
        throw 'NumUtil.integer.pp: num is NaN!';
    if (num > 1e15)
        return num;
    if (num < 0)
        throw 'Negative num!';
    num = Math.round(num);
    var group = num % 1000;
    var integ = Math.floor(num / 1000);
    if (integ === 0) {
        return group;
    }
    num = NumUtil.align3(group);
    while (true) {
        group = integ % 1000;
        integ = Math.floor(integ / 1000);
        if (integ === 0)
            return group + " " + num;
        num = NumUtil.align3(group) + " " + num;
    }
    return num;
}

NumUtil.currency = {};

/** Round to coins and group by 3 digits. */
NumUtil.currency.pp = function(amount) {
    if (typeof(amount) !== "number")
        throw 'NumUtil.currency.pp: amount is not a number!';
    if (isNaN(amount))
        throw 'NumUtil.currency.pp: amount is NaN!';
    if (amount > 1e15)
        return amount;
    if (amount < 0)
        throw 'Negative amount!';
    if (amount < 1e-2)
        return 0;
    var v = Math.round(amount*100);
    var integ = Math.floor(v / 100);
    var frac = NumUtil.align2(v % 100);
    var group = integ % 1000;
    integ = Math.floor(integ / 1000);
    if (integ === 0) {
        return group + "." + frac;
    }
    amount = NumUtil.align3(group);
    while (true) {
        group = integ % 1000;
        integ = Math.floor(integ / 1000);
        if (integ === 0)
            return group + " " + amount + "." + frac;
        amount = NumUtil.align3(group) + " " + amount;
    }
    return amount;
}
5
gavenkoa

Intl.NumberFormat

var number = 3500;
alert(new Intl.NumberFormat().format(number));
// → "3,500" if in US English locale

oder phpjs.com/functions/number_format

4
iBet7o

https://developer.mozilla.org/de-de/docs/Web/JavaScript/Reference/Global_Objects/NumberFormat

Dieses Beispiel zeigt einige Abweichungen bei lokalisierten Zahlenformaten. Um das Format der Sprache zu erhalten, die in der Benutzeroberfläche Ihrer Anwendung verwendet wird, geben Sie diese Sprache (und möglicherweise einige Ausweichsprachen) mit dem Argument locales an:

var number = 123456.789;

// Deutsch verwendet Komma als Dezimaltrennzeichen und Punkt für Tausende console.log (neues Intl.NumberFormat ('de-DE'). format (number)); // → 123.456.789

// Arabisch verwendet in den meisten arabischsprachigen Ländern echte arabische Ziffern console.log (new Intl.NumberFormat ('ar-EG'). format (number)); // → ١٢٣٤٥٦ ٫ ٧٨٩

// Indien verwendet Tausende/lakh/crore-Separatoren console.log (neu Intl.NumberFormat ('en-IN'). Format (number));

4
Mohamed.Abdo

Der Code von Jonathan M sieht für mich zu kompliziert aus, daher schrieb ich ihn um und erhielt etwa 30% für FF v30 und 60% für Chrome v35 ( http://jsperf.com/number-formating2 )

Number.prototype.formatNumber = function(decPlaces, thouSeparator, decSeparator) {
    decPlaces = isNaN(decPlaces = Math.abs(decPlaces)) ? 2 : decPlaces;
    decSeparator = decSeparator == undefined ? "." : decSeparator;
    thouSeparator = thouSeparator == undefined ? "," : thouSeparator;

    var n = this.toFixed(decPlaces);
    if (decPlaces) {
        var i = n.substr(0, n.length - (decPlaces + 1));
        var j = decSeparator + n.substr(-decPlaces);
    } else {
        i = n;
        j = '';
    }

    function reverse(str) {
        var sr = '';
        for (var l = str.length - 1; l >= 0; l--) {
            sr += str.charAt(l);
        }
        return sr;
    }

    if (parseInt(i)) {
        i = reverse(reverse(i).replace(/(\d{3})(?=\d)/g, "$1" + thouSeparator));
    }
    return i+j;
};

Verwendungszweck:

var sum = 123456789.5698;
var formatted = '$' + sum.formatNumber(2,',','.'); // "$123,456,789.57"
4
Tom

Hier ist die kurze und beste Zahl, um Zahlen in Währungsformate zu konvertieren: 

function toCurrency(amount){
    return amount.replace(/(\d)(?=(\d\d\d)+(?!\d))/g, "$1,");
}

// usage: toCurrency(3939920.3030);

Prost! Anunay

4
Anunay

Diese Antwort erfüllt die folgenden Kriterien:

  • Hängt nicht von einer externen Abhängigkeit ab.
  • Unterstützt die Lokalisierung.
  • Hat Tests/Beweise.
  • Verwendet einfache und beste Kodierungsmethoden (keine komplizierten regulären Ausdrücke, verwendet Standard-Kodierungsmuster).

Dieser Code basiert auf Konzepten aus anderen Antworten. Die Ausführungsgeschwindigkeit sollte hier zu den besseren gehören, wenn dies ein Problem ist.

var decimalCharacter = Number("1.1").toLocaleString().substr(1,1);
var defaultCurrencyMarker = "$";
function formatCurrency(number, currencyMarker) {
    if (typeof number != "number")
        number = parseFloat(number, 10);

    // if NaN is passed in or comes from the parseFloat, set it to 0.
    if (isNaN(number))
        number = 0;

    var sign = number < 0 ? "-" : "";
    number = Math.abs(number);  // so our signage goes before the $ symbol.

    var integral = Math.floor(number);
    var formattedIntegral = integral.toLocaleString();

    // IE returns "##.00" while others return "##"
    formattedIntegral = formattedIntegral.split(decimalCharacter)[0];

    var decimal = Math.round((number - integral) * 100);
    return sign + (currencyMarker || defaultCurrencyMarker) +
        formattedIntegral  +
        decimalCharacter +
        decimal.toString() + (decimal < 10 ? "0" : "");
}

Diese Tests funktionieren nur auf einem US-amerikanischen Locale-Computer. Diese Entscheidung wurde aus Gründen der Vereinfachung getroffen, da dies zu fehlerhaften Eingaben (schlechte Autolokalisierung) führen kann, die zu Problemen bei der Ausgabe führen.

var tests = [
    // [ input, expected result ]
    [123123, "$123,123.00"],    // no decimal
    [123123.123, "$123,123.12"],    // decimal rounded down
    [123123.126, "$123,123.13"],    // decimal rounded up
    [123123.4, "$123,123.40"],  // single decimal
    ["123123", "$123,123.00"],  // repeat subset of the above using string input.
    ["123123.123", "$123,123.12"],
    ["123123.126", "$123,123.13"],
    [-123, "-$123.00"]  // negatives
];

for (var testIndex=0; testIndex < tests.length; testIndex++) {
    var test = tests[testIndex];
    var formatted = formatCurrency(test[0]);
    if (formatted == test[1]) {
        console.log("Test passed, \"" + test[0] + "\" resulted in \"" + formatted + "\"");
    } else {
        console.error("Test failed. Expected \"" + test[1] + "\", got \"" + formatted + "\"");
    }
}
4
Joseph Lennox

In JavaScript gibt es keine Entsprechung zu "formatNumber". Sie können es selbst schreiben oder eine Bibliothek finden, die dies bereits tut.

Das könnte funktionieren:

function format_currency(v, number_of_decimals, decimal_separator, currency_sign){
  return (isNaN(v)? v : currency_sign + parseInt(v||0).toLocaleString() + decimal_separator + (v*1).toFixed(number_of_decimals).slice(-number_of_decimals));
}

Keine Schleifen, keine Regex, keine Arrays, keine exotischen Bedingungen.

3

Hier ist eine Implementierung von mootools 1.2 aus dem von XMLilley bereitgestellten Code ...

Number.implement('format', function(decPlaces, thouSeparator, decSeparator){
decPlaces = isNaN(decPlaces = Math.abs(decPlaces)) ? 2 : decPlaces;
decSeparator = decSeparator === undefined ? '.' : decSeparator;
thouSeparator = thouSeparator === undefined ? ',' : thouSeparator;

var num = this,
    sign = num < 0 ? '-' : '',
    i = parseInt(num = Math.abs(+num || 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(num - i).toFixed(decPlaces).slice(2) : '');
});
3
Kirk Bentley

Schneller mit Regex?

Number.prototype.toMonetaryString=function(){var n=this.toFixed(2),m;
// var=this.toFixed(2).replace(/\./,','); for comma separator
// with a space for thousands separator
  while ((m=n.replace(/(\d)(\d\d\d)\b/g,'$1 $2'))!=n) n=m; 
  return m;
}
String.prototype.fromMonetaryToNumber=function(s){
  return this.replace(/[^\d-]+/g,'')/100;
}   
3

Minimalistischer Ansatz, der den ursprünglichen Anforderungen gerade gerecht wird:

function formatMoney(n) {
    return "$ " + (Math.round(n * 100) / 100).toLocaleString();
}

@Daniel Magliola: Du hast recht, das obige war eine hastige, unvollständige Implementierung. Hier ist die korrigierte Implementierung:

function formatMoney(n) {
    return "$ " + n.toLocaleString().split(".")[0] + "."
        + n.toFixed(2).split(".")[1];
}
3
Ates Goral

toLocaleString ist gut, funktioniert aber nicht mit allen Browsern. Normalerweise verwende ich „CurrencyFormatter.js“ ( https://osrec.github.io/currencyFormatter.js/ ). Es ist ziemlich leicht und enthält alle Währungs- und Gebietsschema-Definitionen. Es ist auch gut für das Formatieren ungewöhnlich formatierter Währungen, wie z. B. der INR (die Zahlen in Lakhs und Crores usw. zusammenfasst). Auch keine Abhängigkeiten!

OSREC.CurrencyFormatter.format(2534234, { currency: 'INR' }); // Returns ₹ 25,34,234.00

OSREC.CurrencyFormatter.format(2534234, { currency: 'EUR' }); // Returns 2.534.234,00 €

OSREC.CurrencyFormatter.format(2534234, { currency: 'EUR', locale: 'fr' }); // Returns 2 534 234,00 €

3
James Eames

Warum fügst du nicht noch eine Antwort hinzu? Ich habe dies stark auf die Antwort von VisioN gestützt.

function format (val) {
  val = (+val).toLocaleString();
  val = (+val).toFixed(2);
  val += "";
  return val.replace(/(\d)(?=(\d{3})+(?:\.\d+)?$)/g, "$1" + format.thousands);
}
(function (isUS) {
  format.decimal =   isUS ? "." : ",";
  format.thousands = isUS ? "," : ".";
}(("" + (+(0.00).toLocaleString()).toFixed(2)).indexOf(".") > 0));

Ich habe mit Eingaben getestet:

[   ""
  , "1"
  , "12"
  , "123"
  , "1234"
  , "12345"
  , "123456"
  , "1234567"
  , "12345678"
  , "123456789"
  , "1234567890"
  , ".12"
  , "1.12"
  , "12.12"
  , "123.12"
  , "1234.12"
  , "12345.12"
  , "123456.12"
  , "1234567.12"
  , "12345678.12"
  , "123456789.12"
  , "1234567890.12"
  , "1234567890.123"
  , "1234567890.125"
].forEach(function (item) {
  console.log(format(item));
});

Und bekam diese Ergebnisse:

0.00
1.00
12.00
123.00
1,234.00
12,345.00
123,456.00
1,234,567.00
12,345,678.00
123,456,789.00
1,234,567,890.00
0.12
1.12
12.12
123.12
1,234.12
12,345.12
123,456.12
1,234,567.12
12,345,678.12
123,456,789.12
1,234,567,890.12
1,234,567,890.12
1,234,567,890.13

Nur zum Spaß.

2
kalisjoshua

viele der Antworten hatten hilfreiche Ideen, aber keine davon konnte meine Bedürfnisse erfüllen ... Ich habe alle Ideen verwendet und dieses Beispiel erstellt:

function Format_Numb( fmt){
    var decimals = isNaN(decimals) ? 2 : Math.abs(decimals);
    if(typeof decSgn==="undefined") decSgn = ".";
    if(typeof kommaSgn==="undefined") kommaSgn= ",";

    var s3digits=/(\d{1,3}(?=(\d{3})+(?=[.]|$))|(?:[.]\d*))/g;
    var dflt_nk="00000000".substring(0,decimals);

    //--------------------------------
    // handler for pattern: "%m"
    var _f_money= function( v_in){
                var v=v_in.toFixed(decimals);
                var add_nk=",00";
                var arr=    v.split(".");
                return     arr[0].toString().replace(s3digits, function ($0) {
                                    return ($0.charAt(0)==".")
                                        ? ((add_nk=""),(kommaSgn + $0.substring(1)))
                                        : ($0 + decSgn);
                        })
                        + (    (decimals > 0)
                                ?    (    kommaSgn
                                        + (
                                            (arr.length > 1)
                                            ? arr[1]
                                            : dflt_nk
                                        )
                                    )
                                :    ""                    
                        );
    }

    // handler for pattern: "%<len>[.<prec>]f"
    var _f_flt= function( v_in,l,prec){
        var v=(typeof prec !== "undefined") ? v_in.toFixed(prec):v_in;
        return ((typeof l !== "undefined")&&( (l=l-v.length) > 0))
                ?(Array(l+1).join(" ") + v)
                :v;
    }

    // handler for pattern: "%<len>x"
    var _f_hex= function( v_in,l,flUpper){
        var v=    Math.round(v_in).toString(16);
        if(flUpper)    v=v.toUpperCase();
        return ((typeof l !== "undefined")&&( (l=l-v.length) > 0))
                ?(Array(l+1).join("0") + v)
                :v;        
    }

    //...can be extended..., just add the function, f.e.:    var _f_octal= function( v_in,...){
    //--------------------------------

    if( typeof(fmt)!=="undefined"){
        //...can be extended..., just add the char,f.e."O":    MFX -> MFXO
        var rpatt=/(?:%([^%"MFX]*)([MFX]))|(?:"([^"]*)")|("|%%)/gi;
        var _qu=    "\"";
        var _mask_qu=    "\\\"";
        var str=    fmt.toString().replace( rpatt,function($0,$1,$2,$3,$4){
                                var f;
                                if(typeof $1 !== "undefined"){
                                    switch($2.toUpperCase()){
                                        case "M":    f= "_f_money(v)";    break;
                                        case "F":    var    n_Dig0,n_Dig1;
                                                var    re_flt=/^(?:(\d))*(?:[.](\d))*$/;
                                                $1.replace(re_flt,function($0,$1,$2){
                                                    n_Dig0=$1;
                                                    n_Dig1=$2;
                                                });
                                                f= "_f_flt(v," + n_Dig0 + "," + n_Dig1 + ")";    break;
                                        case "X":    var    n_Dig="undefined";
                                                var    re_flt=/^(\d*)$/;
                                                $1.replace(re_flt,function($0){
                                                    if($0!="")n_Dig=$0;
                                                });
                                                f= "_f_hex(v," + n_Dig + "," + ($2=="X") + ")";    break;
                                        //...can be extended..., f.e.:    case "O":
                                    }
                                    return "\"+"+f+"+\"";
                                } else if(typeof $3 !== "undefined"){
                                    return _mask_qu + $3 + _mask_qu;
                                } else {
                                    return ($4==_qu)?_mask_qu:$4.charAt(0);
                                }
                            });
        var cmd=        "return function(v){"
                +        "if(typeof v === \"undefined\")return \"\";"    //null returned as empty string
                +        "if(!v.toFixed)return v.toString();"        //not numb returned as string
                +        "return \"" + str + "\";"
                +    "}";

        //...can be extended..., just add the function name in the 2 places:
        return new Function( "_f_money,_f_flt,_f_hex", cmd)(_f_money,_f_flt,_f_hex);
    }
}

Zuerst brauchte ich eine C-style -Format-String-Definition, die flexible sein sollte, aber sehr einfach zu bedienen ist, und ich definierte sie folgendermaßen: Muster:

%[<len>][.<prec>]f        float, example "%f", "%8.2d", "%.3f"
%m                        money
%[<len>]x                 hexadecimal lower case, example "%x", "%8x"
%[<len>]X                 hexadecimal upper case, example "%X", "%8X"

da es nicht nötig ist, andere als Euro für mich zu formatieren, habe ich nur "% m" .. implementiert. Es ist jedoch einfach, dies zu erweitern ... Wie in C ist der Formatstring ein String, der die Muster enthält. fe für Euro: "% m €" (gibt Strings wie "8.129,33 €" zurück)

Neben der Flexibilität brauchte ich eine sehr schnelle Lösung für die Tabellenverarbeitung. Das bedeutet, dass bei der Verarbeitung von Tausenden von Zellen die Verarbeitung der Formatzeichenfolge nicht mehr als einmal durchgeführt werden darf. Ein Aufruf wie "format (value, fmt)" ist für mich nicht akzeptabel, aber dies muss in zwei Schritten aufgeteilt werden:

// var formatter = Format_Numb( "%m €");  
//simple example for Euro...

//   but we use a complex example: 

var formatter = Format_Numb("a%%%3mxx \"zz\"%8.2f°\"  >0x%8X<");

// formatter is now a function, which can be used more than once (this is an example, that can be tested:) 

var v1= formatter( 1897654.8198344); 

var v2= formatter( 4.2); 

... (and thousands of rows)

_F_money umfasst auch den regulären Ausdruck;

Drittens ist ein Aufruf wie "format (value, fmt)" nicht zulässig, weil: Obwohl es möglich sein sollte, verschiedene Objektgruppen (z. B. Zellen einer Spalte) mit verschiedenen Masken zu formatieren, möchte ich dies nicht etwas, um Formatstrings am Verarbeitungspunkt zu behandeln. An dieser Stelle möchte ich nur Formatierungen verwenden, wie in

for (var-Zelle in Zellen) {do_something (cell.col.formatter ( cell.value)); }

Welches Format - vielleicht ist es in einem Ini definiert, in einer XML-Datei für jede Spalte oder irgendwo anders ..., aber Analyse- und Einstellungsformate oder der Umgang mit Internationalisierung wird an einem ganz anderen Ort verarbeitet, und dort habe ich Sie möchten das Formatierungsprogramm der Sammlung zuweisen, ohne über Leistungsprobleme nachzudenken:

col.formatter = Format_Numb (_getFormatForColumn (...));

Viertens wollte ich eine "tolerante" Lösung, also vorbei an f.e. Ein String anstelle einer Zahl sollte einfach den String zurückgeben, "null" sollte jedoch einen leeren String zurückgeben.

(Auch die Formatierung von "% 4.2f" darf nicht zu stark sein, wenn der Wert zu groß ist.)

Und zu guter Letzt - es sollte lesbar und leicht erweiterbar sein, OHNE dass es irgendwelche Auswirkungen auf die Leistung hat ....__ Wenn zum Beispiel jemand "Oktalwerte" benötigt, beziehen Sie sich bitte auf die Zeilen mit "..." kann erweitert werden ... "- Ich denke, das sollte eine sehr einfache Aufgabe sein.

Mein allgemeiner Fokus lag auf der Leistung. Jede "Verarbeitungsroutine" (z. B. _f_money) kann optimiert oder mit anderen Ideen in diesem oder anderen Threads ausgetauscht werden, ohne dass die "Vorbereitungsroutinen" (Analyse von Formatzeichenfolgen und Erstellen der Funktionen), die nur einmal verarbeitet werden müssen, und zwar darin Sinn ist nicht so leistungskritisch wie die Konvertierungsaufrufe von Tausenden von Zahlen.

Für alle, die Zahlenmethoden bevorzugen:

Number.prototype.format_euro=( function(formatter){
    return function(){ return formatter(this); }})
    (Format_Numb( "%m €"));

var v_euro= (8192.3282).format_euro(); //results: 8.192,33 €

Number.prototype.format_hex= (function(formatter){
    return function(){ return formatter(this); }})
    (Format_Numb( "%4x"));

var v_hex= (4.3282).format_hex();

Obwohl ich etwas getestet habe, kann es viele Fehler im Code geben. Es ist also kein fertiges Modul, sondern nur eine Idee und ein Ausgangspunkt für Nicht-js-Experten wie mich ... Der Code enthält viele und wenig modifizierte Ideen aus vielen Stackoverflow-Posts; Entschuldigung, ich kann nicht alle referenzieren, aber vielen Dank an alle Experten.

2
user2807653

Ich wollte eine Vanilla-Javascript-Lösung, die den Dezimalanteil automatisch zurückgab.

function formatDollar(amount) {
    var dollar = Number(amount).toLocaleString("us", "currency");
    //decimals
    var arrAmount = dollar.split(".");
    if (arrAmount.length==2) {
        var decimal = arrAmount[1];
        if (decimal.length==1) {
            arrAmount[1] += "0";
        }
    }
    if (arrAmount.length==1) {
        arrAmount.Push("00");
    }

    return "$" + arrAmount.join(".");
}


console.log(formatDollar("1812.2");
2

Es fiel mir schwer, eine einfache Bibliothek zu finden, die mit Datum und Währung arbeitet. Deshalb habe ich meine erstellt: https://github.com/dericeira/slimFormatter.js

So einfach ist das:

var number = slimFormatter.currency(2000.54);
2
Daniel Campos

Kaffeeskript für Patricks beliebte Antwort oben:

Number::formatMoney = (decimalPlaces, decimalChar, thousandsChar) ->  
  n = this  
  c = decimalPlaces  
  d = decimalChar  
  t = thousandsChar  
  c = (if isNaN(c = Math.abs(c)) then 2 else c)  
  d = (if d is undefined then "." else d)  
  t = (if t is undefined then "," else t)  
  s = (if n < 0 then "-" else "")  
  i = parseInt(n = Math.abs(+n or 0).toFixed(c)) + ""  
  j = (if (j = i.length) > 3 then j % 3 else 0)  
  s + (if j then i.substr(0, j) + t else "") + i.substr(j).replace(/(\d{3})(?=\d)/g, "$1" + t) + (if c then d + Math.abs(n - i).toFixed(c).slice(2) else "")  
2
DanielEli
String.prototype.toPrice = function () {
    var v;
    if (/^\d+(,\d+)$/.test(this))
        v = this.replace(/,/, '.');
    else if (/^\d+((,\d{3})*(\.\d+)?)?$/.test(this))
        v = this.replace(/,/g, "");
    else if (/^\d+((.\d{3})*(,\d+)?)?$/.test(this))
        v = this.replace(/\./g, "").replace(/,/, ".");
    var x = parseFloat(v).toFixed(2).toString().split("."),
    x1 = x[0],
    x2 = ((x.length == 2) ? "." + x[1] : ".00"),
    exp = /^([0-9]+)(\d{3})/;
    while (exp.test(x1))
        x1 = x1.replace(exp, "$1" + "," + "$2");
    return x1 + x2;
}

alert("123123".toPrice()); //123,123.00
alert("123123,316".toPrice()); //123,123.32
alert("12,312,313.33213".toPrice()); //12,312,313.33
alert("123.312.321,32132".toPrice()); //123,312,321.32
2

Ich mag die kürzeste Antwort von VisionN, außer wenn ich sie für eine Zahl ohne Dezimalpunkt ändern muss (123 US-Dollar anstelle von 123, - US-Dollar), funktioniert sie nicht. Deshalb muss ich anstelle von Copy/Paste die arkane Syntax des JavaScript-Regex dekodieren.

Hier ist die ursprüngliche Lösung

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

Ich mache es ein bisschen länger:

var re = /\d(?=(\d{3})+\.)/g;
var subst = '$&,';
n.toFixed(2).replace(re, subst);

Re Teil hier (Suchteil in String ersetzen) bedeutet

  1. Finde alle Ziffern (\d)
  2. Gefolgt von (?= ...) (Lookahead)
  3. Eine oder mehrere Gruppen (...)+
  4. Mit genau 3 Stellen (\d{3})
  5. Mit einem Punkt enden (\.)
  6. Mach es für alle Vorkommen (g)

Subst Teil bedeutet hier

  1. Jedes Mal, wenn es eine Übereinstimmung gibt, ersetzen Sie diese durch sich selbst ($&) gefolgt von einem Komma.

Während wir string.replace verwenden, bleibt der andere Text in der Zeichenfolge derselbe und nur gefundene Ziffern (diejenigen, auf die 3,6,9 folgt, usw.) erhalten ein zusätzliches Komma.

Also in einer Zahl 1234567.89 Ziffern 1 und 4 die Bedingung ( 1 23 4 567.89) erfüllen und durch " 1, " und " ersetzt werden 4, ", was zu 1.234.567.89 führt.

Wenn wir den Dezimalpunkt in Dollar nicht benötigen (d. H. 123 anstelle von 123,00 $), können wir den Regex folgendermaßen ändern:

var re2 = /\d(?=(\d{3})+$)/g;

Es basiert auf dem Zeilenende ($) anstelle eines Punkts (\.) und der letzte Ausdruck wird (beachten Sie auch toFixed(0)):

n.toFixed(0).replace(/\d(?=(\d{3})+$)/g, '$&,');

Dieser Ausdruck wird geben

1234567.89 -> 1,234,567

Anstelle des Zeilenendes ($) in der Regex oben können Sie auch eine Word-Grenze (\b) wählen.

Meine Entschuldigung im Voraus, wenn ich einen Teil der Regex-Behandlung falsch interpretiert habe.

2
mp31415

Ich möchte dazu beitragen:

function toMoney(amount) {
    neg = amount.charAt(0);
    amount= amount.replace(/\D/g, '');
    amount= amount.replace(/\./g  , '');
    amount= amount.replace(/\-/g, '');

    var numAmount = new Number(amount); 
    amount= numAmount .toFixed(0).replace(/./g, function(c, i, a) {
        return i > 0 && c !== "," && (a.length - i) % 3 === 0 ? "." + c : c;
    });

    if(neg == '-')
        return neg+amount;
    else
        return amount;
}

Auf diese Weise können Sie Zahlen in ein Textfeld konvertieren, in das Sie nur Zahlen einfügen möchten (betrachten Sie dieses Szenario).

Dies wird ein Textfeld bereinigen, in dem es sich nur um Zahlen handeln soll, selbst wenn Sie eine Zeichenfolge mit Zahlen und Buchstaben oder einem beliebigen Zeichen einfügen.

<html>
<head>
<script language=="Javascript">
function isNumber(evt) {    
    var theEvent = evt || window.event;
    var key = theEvent.keyCode || theEvent.which;
    key = String.fromCharCode(key);
    if (key.length == 0) return;
    var regex = /^[0-9\-\b]+$/;
    if (!regex.test(key)) {
        theEvent.returnValue = false;
        if (theEvent.preventDefault) theEvent.preventDefault();
    }
}
function toMoney(amount) {
    neg = amount.charAt(0);
    amount= amount.replace(/\D/g, '');
    amount= amount.replace(/\./g  , '');
    amount= amount.replace(/\-/g, '');

    var numAmount = new Number(amount); 
    amount= numAmount .toFixed(0).replace(/./g, function(c, i, a) {
        return i > 0 && c !== "," && (a.length - i) % 3 === 0 ? "." + c : c;
    });

    if(neg == '-')
        return neg+amount;
    else
        return amount;
}
function clearText(inTxt, newTxt, outTxt) {
    inTxt = inTxt.trim();
    newTxt = newTxt.trim();
    if(inTxt == '' || inTxt == newTxt) 
        return outTxt;

    return inTxt;   
}

function fillText(inTxt, outTxt) {
    inTxt = inTxt.trim();
    if(inTxt != '') 
        outTxt = inTxt;

    return outTxt;
}
</script>
</head>
<body>
$ <input name=reca2 id=reca2 type=text value="0" onFocus="this.value = clearText(this.value, '0', '');" onblur="this.value = fillText(this.value, '0'); this.value = toMoney(this.value);" onKeyPress="isNumber(event);" style="width:80px;" />
</body>
</html>
function getMoney(A){
    var a = new Number(A);
    var b = a.toFixed(2); //get 12345678.90
    a = parseInt(a); // get 12345678
    b = (b-a).toPrecision(2); //get 0.90
    b = parseFloat(b).toFixed(2); //in case we get 0.0, we pad it out to 0.00
    a = a.toLocaleString();//put in commas - IE also puts in .00, so we'll get 12,345,678.00
    //if IE (our number ends in .00)
    if(a < 1 && a.lastIndexOf('.00') == (a.length - 3))
    {
        a=a.substr(0, a.length-3); //delete the .00
    }
    return a+b.substr(1);//remove the 0 from b, then return a + b = 12,345,678.90
}
alert(getMoney(12345678.9));

Das funktioniert in FF und IE

Number(value)
        .toFixed(2)
        .replace(/(\d)(?=(\d{3})+(?!\d))/g, "$1,")

1
Adam Pery

Es gibt bereits gute Antworten. Hier ist ein einfacher Versuch zum Spaß:

function currencyFormat(no) {
  var ar = (+no).toFixed(2).split('.');
  return [
      numberFormat(ar[0]|0),
      '.', 
      ar[1]
  ].join('');
}


function numberFormat(no) {
  var str = no + '';
  var ar = [];
  var i  = str.length -1;

  while( i >= 0 ) {
    ar.Push( (str[i-2]||'') + (str[i-1]|| '')+ (str[i]|| ''));
    i= i-3;
  }
  return ar.reverse().join(',');  
}

Das laufen einige Beispiele

console.log(
  currencyFormat(1),
  currencyFormat(1200),
  currencyFormat(123),
  currencyFormat(9870000),
  currencyFormat(12345),
  currencyFormat(123456.232)
)
1
rab

Hier ist ein einfacher Formatierer in Vanilla JS:

function numberFormatter (num) {
        console.log(num)
    var wholeAndDecimal = String(num.toFixed(2)).split(".");
    console.log(wholeAndDecimal)
    var reversedWholeNumber = Array.from(wholeAndDecimal[0]).reverse();
    var formattedOutput = [];

    reversedWholeNumber.forEach( (digit, index) => {
        formattedOutput.Push(digit);
        if ((index + 1) % 3 === 0 && index < reversedWholeNumber.length - 1) {
            formattedOutput.Push(",");
        }
    })

    formattedOutput = formattedOutput.reverse().join('') + "." + wholeAndDecimal[1];

    return formattedOutput;

}
1
meetalexjohnson

Ich mag es einfach:

function formatPriceUSD(price) {
    var strPrice = price.toFixed(2).toString();
    var a = strPrice.split('');

    if (price > 1000000000)
        a.splice(a.length - 12, 0, ',');

    if (price > 1000000)
        a.splice(a.length - 9, 0, ',');

    if (price > 1000)
        a.splice(a.length - 6, 0, ',');

    return '$' + a.join("");
}
1
Tomas Kubes

Weil jedes Problem eine einzeilige Lösung verdient:

Number.prototype.formatCurrency = function() { return this.toFixed(2).toString().split(/[-.]/).reverse().reduceRight(function (t, c, i) { return (i == 2) ? '-' + t : (i == 1) ? t + c.replace(/(\d)(?=(\d{3})+$)/g, '$1,') : t + '.' + c; }, '$'); }

Dies lässt sich leicht für verschiedene Ländereinstellungen ändern. Ändern Sie einfach "$ 1" in "$ 1". und '.' zu ',' wechseln, und. in Zahlen und das Währungssymbol kann durch Ändern des '$' am Ende geändert werden.

Wenn Sie über ES6 verfügen, können Sie die Funktion einfach mit Standardwerten deklarieren:

Number.prototype.formatCurrency = function(thou = ',', dec = '.', sym = '$') { return this.toFixed(2).toString().split(/[-.]/).reverse().reduceRight(function (t, c, i) { return (i == 2) ? '-' + t : (i == 1) ? t + c.replace(/(\d)(?=(\d{3})+$)/g, '$1' + thou) : t + dec + c; }, sym); }

console.log((4215.57).formatCurrency())
$4,215.57
console.log((4216635.57).formatCurrency('.', ','))
$4.216.635,57
console.log((4216635.57).formatCurrency('.', ',', "\u20AC"))
€4.216.635,57

Oh und es funktioniert auch für negative Zahlen:

console.log((-6635.574).formatCurrency('.', ',', "\u20AC"))
-€6.635,57
console.log((-1066.507).formatCurrency())
-$1,066.51

Und natürlich brauchen Sie kein Währungssymbol

console.log((1234.586).formatCurrency(',','.',''))
1,234.59
console.log((-7890123.456).formatCurrency(',','.',''))
-7,890,123.46
console.log((1237890.456).formatCurrency('.',',',''))
1.237.890,46
0
Nick

Hier ist meins...

function thousandCommas(num) {
  num = num.toString().split('.');
  var ints = num[0].split('').reverse();
  for (var out=[],len=ints.length,i=0; i < len; i++) {
    if (i > 0 && (i % 3) === 0) out.Push(',');
    out.Push(ints[i]);
  }
  out = out.reverse() && out.join('');
  if (num.length === 2) out += '.' + num[1];
  return out;
}
0
mendezcode