Vorrei formattare un prezzo in JavaScript. Vorrei una funzione che prende a float
come argomento e restituisce un string
formato così:
"$ 2,500.00"
Qual'è il miglior modo per farlo?
Vorrei formattare un prezzo in JavaScript. Vorrei una funzione che prende a float
come argomento e restituisce un string
formato così:
"$ 2,500.00"
Qual'è il miglior modo per farlo?
Risposte:
Questa soluzione è compatibile con ogni singolo browser principale:
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)
Tutto ciò di cui hai bisogno è aggiungere il simbolo della valuta (ad es. "$" + profits.toFixed(2)
) E avrai il tuo importo in dollari.
Se è necessario l'uso di ,
ciascuna cifra, è possibile utilizzare questa funzione:
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>
Usalo così:
(123456789.12345).formatMoney(2, ".", ",");
Se utilizzerai sempre "." e ',', puoi lasciarli fuori dalla chiamata del metodo e il metodo li renderà predefiniti per te.
(123456789.12345).formatMoney(2);
Se la tua cultura ha i due simboli invertiti (ovvero europei) e desideri utilizzare i valori predefiniti, incolla le seguenti due righe nel formatMoney
metodo:
d = d == undefined ? "," : d,
t = t == undefined ? "." : t,
Se puoi usare la sintassi ECMAScript moderna (ad es. Tramite Babel), puoi invece usare questa funzione più semplice:
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>
d
e t
di essere .
e ,
rispettivamente in modo da non doverle specificare ogni volta. inoltre, raccomando di modificare l'inizio return
dell'istruzione per leggere return s + '$' + [rest]
:, altrimenti non otterrai un segno di dollaro.
Javascript ha un formattatore di numeri (parte dell'API di internazionalizzazione).
// Create our number formatter.
var formatter = new Intl.NumberFormat('en-US', {
style: 'currency',
currency: 'USD',
});
formatter.format(2500); /* $2,500.00 */
Utilizzare undefined
al posto del primo argomento ( 'en-US'
nell'esempio) per utilizzare la locale di sistema (la locale dell'utente nel caso in cui il codice sia in esecuzione in un browser). Ulteriore spiegazione del codice locale .
Ecco un elenco dei codici valuta .
Un'ultima nota che confronta questo con il più vecchio. toLocaleString
. Entrambi offrono essenzialmente la stessa funzionalità. Tuttavia, toLocaleString nelle sue precedenti incarnazioni (pre-Intl) in realtà non supporta le impostazioni locali : utilizza le impostazioni locali del sistema. Pertanto, assicurati di utilizzare la versione corretta ( MDN suggerisce di verificare l'esistenza diIntl
). Inoltre, le prestazioni di entrambi sono le stesse per un singolo elemento, ma se hai molti numeri da formattare, l'utilizzo Intl.NumberFormat
è ~ 70 volte più veloce. Ecco come usare toLocaleString
:
(2500).toLocaleString('en-US', {
style: 'currency',
currency: 'USD',
}); /* $2,500.00 */
(12345.67).toFixed(2).replace(/\d(?=(\d{3})+\.)/g, '$&,'); // 12,345.67
L'idea alla base di questa soluzione è quella di sostituire le sezioni abbinate con prima corrispondenza e virgola, ad es '$&,'
. La corrispondenza viene eseguita utilizzando l' approccio lookahead . Puoi leggere l'espressione come "abbina un numero se è seguito da una sequenza di tre set di numeri (uno o più) e un punto" .
TEST:
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/
È inoltre possibile estendere il prototipo di Number
oggetto per aggiungere ulteriore supporto a qualsiasi numero di decimali [0 .. n]
e alle dimensioni dei gruppi di numeri [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 / TEST: http://jsfiddle.net/hAfMM/435/
In questa versione super estesa puoi impostare diversi tipi di delimitatori:
/**
* 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 / TEST: http://jsfiddle.net/hAfMM/612/
.replace(/(\d)(?=(\d{3})+(?:\.\d+)?$)/g, "$1,")
.
Number.prototype.toMoney = (decimal=2) -> @toFixed(decimal).replace /(\d)(?=(\d{3})+(?:\.\d+)?$)/g, "$1,"
\.
con $
(fine riga), ad es this.toFixed(0).replace(/(\d)(?=(\d{3})+$)/g, "$1,")
.
$1,
. La corrispondenza viene eseguita utilizzando l' approccio lookahead . Puoi leggere l'espressione come "abbina un numero se è seguito da una sequenza di tre set di numeri (uno o più) e un punto" .
Dai un'occhiata all'oggetto Numero JavaScript e vedi se può aiutarti.
toLocaleString()
formatterà un numero usando il separatore di migliaia specifico per posizione. toFixed()
arrotonderà il numero a un numero specifico di cifre decimali.Per usarli allo stesso tempo, il valore deve essere cambiato di nuovo in un numero perché entrambi generano una stringa.
Esempio:
Number((someNumber).toFixed(1)).toLocaleString()
toLocaleString
che utilizza le impostazioni internazionali del sistema e una nuova (incompatibile) proveniente dall'API ECMAScript Intl. Spiegato qui . Questa risposta sembra essere intesa per la vecchia versione.
Di seguito è riportato il codice di Patrick Desjardins (alias Daok) con alcuni commenti aggiunti e alcune modifiche minori:
/*
decimal_sep: character used as deciaml separtor, it defaults to '.' when omitted
thousands_sep: char used as thousands separator, it defaults to ',' when omitted
*/
Number.prototype.toMoney = function(decimals, decimal_sep, thousands_sep)
{
var n = this,
c = isNaN(decimals) ? 2 : Math.abs(decimals), //if decimal is zero we must take it, it means user does not want to show any decimal
d = decimal_sep || '.', //if no decimal separator is passed we use the dot as default decimal separator (we MUST use a decimal separator)
/*
according to [/programming/411352/how-best-to-determine-if-an-argument-is-not-sent-to-the-javascript-function]
the fastest way to check for not defined parameter is to use typeof value === 'undefined'
rather than doing value === undefined.
*/
t = (typeof thousands_sep === 'undefined') ? ',' : thousands_sep, //if you don't want to use a thousands separator you can pass empty string as thousands_sep value
sign = (n < 0) ? '-' : '',
//extracting the absolute value of the integer part of the number and converting to string
i = parseInt(n = Math.abs(n).toFixed(c)) + '',
j = ((j = i.length) > 3) ? j % 3 : 0;
return sign + (j ? i.substr(0, j) + t : '') + i.substr(j).replace(/(\d{3})(?=\d)/g, "$1" + t) + (c ? d + Math.abs(n - i).toFixed(c).slice(2) : '');
}
e qui alcuni test:
//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));
Le modifiche minori sono:
spostato un po ' Math.abs(decimals)
da fare solo quando non lo è NaN
.
decimal_sep
non può più essere una stringa vuota (una sorta di separatore decimale è DEVE)
usiamo typeof thousands_sep === 'undefined'
come suggerito in Come meglio determinare se un argomento non viene inviato alla funzione JavaScript
(+n || 0)
non è necessario perché this
è un Number
oggetto
parseInt
si chiama sul valore assoluto della parte intera del numero. La parte INTEGER non può iniziare con ZERO a meno che non sia solo uno ZERO! E parseInt(0) === 0
ottale o decimale.
0
è considerato ottale da parseInt
. Ma in questo codice è IMPOSSIBILE parseInt
ricevere 016
come input (o qualsiasi altro valore in formato ottale), poiché l'argomento passato parseInt
viene elaborato per primo dalla Math.abs
funzione. Quindi non c'è modo parseInt
di ricevere un numero che inizia con zero a meno che non sia solo uno zero o 0.nn
(dove nn
sono i decimali). Ma entrambi 0
e 0.nn
stringhe sarebbe convertito da parseInt
in pianura zero come suppsed essere.
accounting.js è una piccola libreria JavaScript per la formattazione di numeri, denaro e valuta.
Se l'importo è un numero, diciamo -123
, quindi
amount.toLocaleString('en-US', { style: 'currency', currency: 'USD' });
produrrà la stringa "-$123.00"
.
Ecco un esempio di lavoro completo .
minimumFractionDigits: 0
Ecco il miglior formatter di js money che abbia mai visto:
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) : "");
};
È stato riformattato e preso in prestito da qui: https://stackoverflow.com/a/149099/751484
Dovrai fornire il tuo identificatore di valuta (hai usato $ sopra).
Chiamalo in questo modo (anche se nota che args è predefinito 2, virgola e punto, quindi non è necessario fornire alcun argomento se questa è la tua preferenza):
var myMoney=3543.75873;
var formattedMoney = '$' + myMoney.formatMoney(2,',','.'); // "$3,543.76"
var
dichiarazione.
Ci sono già alcune grandi risposte qui. Ecco un altro tentativo, solo per divertimento:
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];
}
E alcuni test:
formatDollar(45664544.23423) // "$45,664,544.23"
formatDollar(45) // "$45.00"
formatDollar(123) // "$123.00"
formatDollar(7824) // "$7,824.00"
formatDollar(1) // "$1.00"
Modificato: ora gestirà anche numeri negativi
i = orig.length - i - 1
nel callback. Tuttavia, un attraversamento in meno dell'array.
reduce
metodo è stato introdotto in Ecmascript 1.8 e non è supportato in Internet Explorer 8 e versioni successive.
Funziona con tutti i browser attuali
Utilizzare toLocaleString
per formattare una valuta nella sua rappresentazione sensibile alla lingua (utilizzando i codici valuta ISO 4217 ).
(2500).toLocaleString("en-GB", {style: "currency", currency: "GBP", minimumFractionDigits: 2})
Esempio di frammenti di codice Rand sudafricano per @avenmore
console.log((2500).toLocaleString("en-ZA", {style: "currency", currency: "ZAR", minimumFractionDigits: 2}))
// -> R 2 500,00
console.log((2500).toLocaleString("en-GB", {style: "currency", currency: "ZAR", minimumFractionDigits: 2}))
// -> ZAR 2,500.00
Penso che quello che vuoi sia f.nettotal.value = "$" + showValue.toFixed(2);
Numeral.js - una libreria js per una facile formattazione dei numeri di @adamwdraper
numeral(23456.789).format('$0,0.00'); // = "$23,456.79"
Ok, in base a quello che hai detto, sto usando questo:
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;
Sono aperto a suggerimenti di miglioramento (preferirei non includere YUI solo per fare questo :-)) So già che dovrei rilevare il "." invece di usarlo semplicemente come separatore decimale ...
Uso la libreria Globalize (di Microsoft):
È un ottimo progetto per localizzare numeri, valute e date e formattarli automaticamente nel modo giusto in base alle impostazioni locali dell'utente! ... e nonostante dovrebbe essere un'estensione jQuery, è attualmente una libreria indipendente al 100%. Consiglio a tutti di provarlo! :)
javascript-number-formatter (precedentemente al codice di Google )
#,##0.00
o con negazione -000.####
.# ##0,00
, #,###.##
, #'###.##
o qualsiasi tipo di simbolo non-numerazione.#,##,#0.000
o #,###0.##
sono tutti validi.##,###,##.#
o 0#,#00#.###0#
vanno tutti bene.format( "0.0000", 3.141592)
.(estratto dal suo README)
+1 a Jonathan M per aver fornito il metodo originale. Dato che si tratta esplicitamente di un formattatore di valuta, sono andato avanti e ho aggiunto il simbolo della valuta (il valore predefinito è '$') all'output e ho aggiunto una virgola predefinita come separatore delle migliaia. Se in realtà non vuoi un simbolo di valuta (o un separatore di migliaia), usa semplicemente "" (stringa vuota) come argomento.
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) : "");
};
+n || 0
è l'unica cosa che sembra un po 'strana (per me comunque).
this
è un nome variabile perfettamente utile. La conversione in n
modo da poter salvare 3 caratteri al momento della definizione potrebbe essere stata necessaria in un'era in cui la RAM e la larghezza di banda erano contate in KB, ma è semplicemente offuscata in un'era in cui il minificatore si occuperà di tutto ciò prima che colpisca mai la produzione. Le altre microottimizzazioni intelligenti sono almeno discutibili.
Esiste una porta javascript della funzione PHP "number_format".
Lo trovo molto utile in quanto è facile da usare e riconoscibile per gli sviluppatori PHP.
function number_format (number, decimals, dec_point, thousands_sep) {
var n = number, prec = decimals;
var toFixedFix = function (n,prec) {
var k = Math.pow(10,prec);
return (Math.round(n*k)/k).toString();
};
n = !isFinite(+n) ? 0 : +n;
prec = !isFinite(+prec) ? 0 : Math.abs(prec);
var sep = (typeof thousands_sep === 'undefined') ? ',' : thousands_sep;
var dec = (typeof dec_point === 'undefined') ? '.' : dec_point;
var s = (prec > 0) ? toFixedFix(n, prec) : toFixedFix(Math.round(n), prec);
//fix for IE parseFloat(0.55).toFixed(0) = 0;
var abs = toFixedFix(Math.abs(n), prec);
var _, i;
if (abs >= 1000) {
_ = abs.split(/\D/);
i = _[0].length % 3 || 3;
_[0] = s.slice(0,i + (n < 0)) +
_[0].slice(i).replace(/(\d{3})/g, sep+'$1');
s = _.join(dec);
} else {
s = s.replace('.', dec);
}
var decPos = s.indexOf(dec);
if (prec >= 1 && decPos !== -1 && (s.length-decPos-1) < prec) {
s += new Array(prec-(s.length-decPos-1)).join(0)+'0';
}
else if (prec >= 1 && decPos === -1) {
s += dec+new Array(prec).join(0)+'0';
}
return s;
}
(Blocco dei commenti dall'originale , incluso di seguito per esempi e credito ove dovuto)
// 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'
Un metodo più breve (per inserire spazio, virgola o punto) con espressione regolare?
Number.prototype.toCurrencyString=function(){
return this.toFixed(2).replace(/(\d)(?=(\d{3})+\b)/g,'$1 ');
}
n=12345678.9;
alert(n.toCurrencyString());
Non ho visto niente del genere. È piuttosto conciso e facile da capire.
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)
)
Ecco una versione con più opzioni nell'output finale per consentire la formattazione di valute diverse in diversi formati di località.
// 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)
)
La risposta di Patrick Desjardins sembra buona, ma preferisco il mio javascript semplice. Ecco una funzione che ho appena scritto per prendere un numero e restituirlo in formato valuta (meno il simbolo del dollaro)
// 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];
}
La parte principale sta inserendo i mille-separatori, che potrebbero essere fatti in questo modo:
<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)));">
V'è un built-in function
toFixed injavascript
var num = new Number(349);
document.write("$" + num.toFixed(2));
toFixed()
toFixed()
è una funzione Number
dell'oggetto e non funzionerà su var num
se fosse un String
, quindi il contesto aggiuntivo mi ha aiutato.
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;
}
Da WillMaster .
Suggerisco la classe NumberFormat dall'API di visualizzazione di Google .
Puoi fare qualcosa del genere:
var formatter = new google.visualization.NumberFormat({
prefix: '$',
pattern: '#,###,###.##'
});
formatter.formatValue(1000000); // $ 1,000,000
Spero possa essere d'aiuto.
Potrebbe essere un po 'tardi, ma ecco un metodo che ho appena elaborato per un collega per aggiungere una funzione di riconoscimento locale .toCurrencyString()
a tutti i numeri. L'internalizzazione è solo per il raggruppamento dei numeri, NON il segno di valuta - se stai producendo dollari, usa "$"
come fornito, perché $123 4567
in Giappone o Cina è lo stesso numero di USD che $1,234,567
è qui negli Stati Uniti. Se stai producendo euro / ecc., Quindi cambia il segno di valuta da "$"
.
Dichiaralo ovunque nel tuo HEAD o ovunque sia necessario, appena prima di doverlo utilizzare:
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;
}
Allora hai finito! Utilizzare (number).toCurrencyString()
ovunque sia necessario per generare il numero come valuta.
var MyNumber = 123456789.125;
alert(MyNumber.toCurrencyString()); // alerts "$123,456,789.13"
MyNumber = -123.567;
alert(MyNumber.toCurrencyString()); // alerts "$-123.57"
Come al solito, ci sono diversi modi per fare la stessa cosa, ma eviterei di usarlo Number.prototype.toLocaleString
poiché può restituire valori diversi in base alle impostazioni dell'utente.
Inoltre, non raccomando di estendere Number.prototype
- l'estensione dei prototipi di oggetti nativi è una cattiva pratica poiché può causare conflitti con il codice di altre persone (ad esempio librerie / framework / plugin) e potrebbe non essere compatibile con future implementazioni / versioni di JavaScript.
Credo che le espressioni regolari siano l'approccio migliore per il problema, ecco la mia implementazione:
/**
* 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);
}
}
modificato il 30/08/2010: aggiunta opzione per impostare il numero di cifre decimali. modificato il 23/08/2011: aggiunta opzione per impostare il numero di cifre decimali su zero.
Ecco alcune soluzioni, tutte superano la suite di test, la suite di test e il benchmark inclusi, se vuoi copiare e incollare per provare, prova This Gist .
Basarsi su https://stackoverflow.com/a/14428340/1877620 , ma correggere se non è presente un punto decimale.
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('.');
}
}
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('.');
};
}
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('.');
};
}
if (typeof Number.prototype.format === 'undefined') {
Number.prototype.format = function (precision) {
if (!isFinite(this)) {
return this.toString();
}
var a = this.toFixed(precision).split('');
a.push('.');
var i = a.indexOf('.') - 3;
while (i > 0 && a[i-1] !== '-') {
a.splice(i, 0, ',');
i -= 3;
}
a.pop();
return a.join('');
};
}
console.log('======== Demo ========')
console.log(
(1234567).format(0),
(1234.56).format(2),
(-1234.56).format(0)
);
var n = 0;
for (var i=1; i<20; i++) {
n = (n * 10) + (i % 10)/100;
console.log(n.format(2), (-n).format(2));
}
Se vogliamo un separatore di migliaia personalizzato o un separatore decimale, utilizzare replace()
:
123456.78.format(2).replace(',', ' ').replace('.', ' ');
function assertEqual(a, b) {
if (a !== b) {
throw a + ' !== ' + b;
}
}
function test(format_function) {
console.log(format_function);
assertEqual('NaN', format_function.call(NaN, 0))
assertEqual('Infinity', format_function.call(Infinity, 0))
assertEqual('-Infinity', format_function.call(-Infinity, 0))
assertEqual('0', format_function.call(0, 0))
assertEqual('0.00', format_function.call(0, 2))
assertEqual('1', format_function.call(1, 0))
assertEqual('-1', format_function.call(-1, 0))
// decimal padding
assertEqual('1.00', format_function.call(1, 2))
assertEqual('-1.00', format_function.call(-1, 2))
// decimal rounding
assertEqual('0.12', format_function.call(0.123456, 2))
assertEqual('0.1235', format_function.call(0.123456, 4))
assertEqual('-0.12', format_function.call(-0.123456, 2))
assertEqual('-0.1235', format_function.call(-0.123456, 4))
// thousands separator
assertEqual('1,234', format_function.call(1234.123456, 0))
assertEqual('12,345', format_function.call(12345.123456, 0))
assertEqual('123,456', format_function.call(123456.123456, 0))
assertEqual('1,234,567', format_function.call(1234567.123456, 0))
assertEqual('12,345,678', format_function.call(12345678.123456, 0))
assertEqual('123,456,789', format_function.call(123456789.123456, 0))
assertEqual('-1,234', format_function.call(-1234.123456, 0))
assertEqual('-12,345', format_function.call(-12345.123456, 0))
assertEqual('-123,456', format_function.call(-123456.123456, 0))
assertEqual('-1,234,567', format_function.call(-1234567.123456, 0))
assertEqual('-12,345,678', format_function.call(-12345678.123456, 0))
assertEqual('-123,456,789', format_function.call(-123456789.123456, 0))
// thousands separator and decimal
assertEqual('1,234.12', format_function.call(1234.123456, 2))
assertEqual('12,345.12', format_function.call(12345.123456, 2))
assertEqual('123,456.12', format_function.call(123456.123456, 2))
assertEqual('1,234,567.12', format_function.call(1234567.123456, 2))
assertEqual('12,345,678.12', format_function.call(12345678.123456, 2))
assertEqual('123,456,789.12', format_function.call(123456789.123456, 2))
assertEqual('-1,234.12', format_function.call(-1234.123456, 2))
assertEqual('-12,345.12', format_function.call(-12345.123456, 2))
assertEqual('-123,456.12', format_function.call(-123456.123456, 2))
assertEqual('-1,234,567.12', format_function.call(-1234567.123456, 2))
assertEqual('-12,345,678.12', format_function.call(-12345678.123456, 2))
assertEqual('-123,456,789.12', format_function.call(-123456789.123456, 2))
}
console.log('======== Testing ========');
test(Number.prototype.format);
test(Number.prototype.format1);
test(Number.prototype.format2);
test(Number.prototype.format3);
function benchmark(f) {
var start = new Date().getTime();
f();
return new Date().getTime() - start;
}
function benchmark_format(f) {
console.log(f);
time = benchmark(function () {
for (var i = 0; i < 100000; i++) {
f.call(123456789, 0);
f.call(123456789, 2);
}
});
console.log(time.format(0) + 'ms');
}
// if not using async, browser will stop responding while running.
// this will create a new thread to benchmark
async = [];
function next() {
setTimeout(function () {
f = async.shift();
f && f();
next();
}, 10);
}
console.log('======== Benchmark ========');
async.push(function () { benchmark_format(Number.prototype.format); });
next();
Number(value)
.toFixed(2)
.replace(/(\d)(?=(\d{3})+(?!\d))/g, "$1,")
Un'opzione semplice per il corretto posizionamento della virgola invertendo prima la stringa e regexp di base.
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();
};
Ho trovato questo da: accounting.js . È molto semplice e si adatta perfettamente alle mie esigenze.
// 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€
formatNumber
in javascript