Javascript parse float is ignoring the decimals after my comma
JavascriptParsefloatJavascript Problem Overview
Here's a simple scenario. I want to show the subtraction of two values show on my site:
//Value on my websites HTML is: "75,00"
var fullcost = parseFloat($("#fullcost").text());
//Value on my websites HTML is: "0,03"
var auctioncost = parseFloat($("#auctioncost").text());
alert(fullcost); //Outputs: 75
alert(auctioncost); //Ouputs: 0
Can anyone tell me what I'm doing wrong?
Javascript Solutions
Solution 1 - Javascript
This is "By Design". The parseFloat function will only consider the parts of the string up until in reaches a non +, -, number, exponent or decimal point. Once it sees the comma it stops looking and only considers the "75" portion.
To fix this convert the commas to decimal points.
var fullcost = parseFloat($("#fullcost").text().replace(',', '.'));
Solution 2 - Javascript
javascript's parseFloat doesn't take a locale parameter. So you will have to replace , with .
parseFloat('0,04'.replace(/,/, '.')); // 0.04
Solution 3 - Javascript
parseFloat parses according to the JavaScript definition of a decimal literal, not your locale's definition. (E.g., parseFloat is not locale-aware.) Decimal literals in JavaScript use . for the decimal point.
Solution 4 - Javascript
Why not use globalize? This is only one of the issues that you can run in to when you don't use the english language:
Globalize.parseFloat('0,04'); // 0.04
Some links on stackoverflow to look into:
Solution 5 - Javascript
As @JaredPar pointed out in his answer use parseFloat with replace
var fullcost = parseFloat($("#fullcost").text().replace(',', '.'));
Just replacing the comma with a dot will fix, Unless it's a number over the thousands like 1.000.000,00 this way will give you the wrong digit. So you need to replace the comma remove the dots.
// Remove all dot's. Replace the comma.
var fullcost = parseFloat($("#fullcost").text().replace(/\./g,'').replace(',', '.'));
By using two replaces you'll be able to deal with the data without receiving wrong digits in the output.
Solution 6 - Javascript
For anyone arriving here wondering how to deal with this problem where commas (,) and full stops (.) might be involved but the exact number format may not be known - this is how I correct a string before using parseFloat() (borrowing ideas from other answers):
function preformatFloat(float){
if(!float){
return '';
};
//Index of first comma
const posC = float.indexOf(',');
if(posC === -1){
//No commas found, treat as float
return float;
};
//Index of first full stop
const posFS = float.indexOf('.');
if(posFS === -1){
//Uses commas and not full stops - swap them (e.g. 1,23 --> 1.23)
return float.replace(/\,/g, '.');
};
//Uses both commas and full stops - ensure correct order and remove 1000s separators
return ((posC < posFS) ? (float.replace(/\,/g,'')) : (float.replace(/\./g,'').replace(',', '.')));
};
// <-- parseFloat(preformatFloat('5.200,75'))
// --> 5200.75
At the very least, this would allow parsing of British/American and European decimal formats (assuming the string contains a valid number).
Solution 7 - Javascript
Numbers in JS use a . (full stop / period) character to indicate the decimal point not a , (comma).
Solution 8 - Javascript
It is better to use this syntax to replace all the commas in a case of a million 1,234,567
var string = "1,234,567";
string = string.replace(/[^\d\.\-]/g, "");
var number = parseFloat(string);
console.log(number)
The g means to remove all commas.
Check the Jsfiddle demo here.
Solution 9 - Javascript
From my origin country the currency format is like "3.050,89 €"
parseFloat identifies the dot as the decimal separator, to add 2 values we could put it like these:
parseFloat(element.toString().replace(/\./g,'').replace(',', '.'))
Solution 10 - Javascript
In my case, I already had a period(.) and also a comma(,), so what worked for me was to replace the comma(,) with an empty string like below:
parseFloat('3,000.78'.replace(',', ''))
This is assuming that the amount from the existing database is 3,000.78. The results are: 3000.78 without the initial comma(,).
Solution 11 - Javascript
What you do wrong is feed parseFloat() with strings that represent decimal fractions in a human-oriented notation, whereas parseFloat() accepts only the standard format corresponding with the JavaScript number literals, which are region-independent, always use the dot as the decimal separator, and have no thousands separator.
Futhermore, this parseFloat() function, used in all the answers, is too generous in what it accepts as correct input, preventing the detection of what in most cases is incorrect input:
Input Result
'1Hello' 1
'1 and 2' 1
'1.2+3.4' 1.2
' 25 ' 25
In order to get a stricter and therefore better-controlled behavior, I recommend that you implement your own parsing function. Here is mine:
// Parse a decimal fraction with specified thousands
// and group separators:
function /* number */ parse_float
( /* string */ s , // string to parse
/* string */ thousep, // thousands separator, empty string if none
/* string */ decsep // decimal separator , empty string if none
)
{ var /* integer */ whole, frac ; // whole and fractinal parts
var /* integer */ wnext, fnext; // position of next char after parse
var /* integer */ fraclen ; // length of fractional part
var /* integer */ ofs ; // offset of the first digit
var /* boolean */ done ; // entire string scanned?
var /* integer */ sign ; // sign of result
var /* number */ res ; // result
/* labels */ end: { whole: {
// Check parameter types and availability:
req_param( 's' , s , 'string' );
req_param( 'thousep', thousep, 'string' );
req_param( 'decsep' , decsep , 'string' );
frac = 0;
fraclen = 0;
res = NaN;
// Account for a possible sign:
switch( s.charAt(0) )
{ case '-': sign = -1; ofs = 1; break;
case '+': sign = +1; ofs = 1; break;
default : sign = +1; ofs = 0; break;
}
[done, wnext, whole] = parse_int_ts( s, ofs, thousep );
if( isNaN( whole ) ) break end;
if( done ) break whole;
if( s.charAt( wnext ) !== decsep ) break end;
[done, fnext, frac] = parse_int( s, 0, wnext + 1 );
if( !done ) break end;
fraclen = fnext - wnext - 1;
if( fraclen === 0 ) break end;
} /* whole: */ res = ( whole + frac / Math.pow( 10, fraclen ) ) * sign;
} /* end: */ return res;
}
// Require that a value be specified and have the expected type:
function req_param( /* string */ param, /* variant */ val, /* string */ type )
{ var /* string */ errmsg;
errmsg = ''; if( val === undefined ) errmsg = 'is undefined';
else if( val === null ) errmsg = 'is null';
else if( typeof val !== type ) errmsg = `must of type \`${type}'`;
if( errmsg !== '' ) // there has been an error
{ throw new Error(`Parameter \`${param}' ${errmsg}.`); }
}
// Parse an integer with a specified thousands separator:
function /* object[] */ parse_int_ts
( /* string */ s , // input string
/* integer */ start, // start position
/* character */ sep , // thousands separator
)
// Returns an array of:
// 0: boolean -- entire string was scanned
// 1: integer -- index of next character to scan
// 2: integer -- resulting inteer
{ var /* boolean */ full;
var /* integer */ next;
var /* integer */ res;
var /* integer */ len;
var /* integer */ psep;
var /* integer */ result;
res = 0;
psep = 0;
while( true )
{ result = NaN; // mark an error
[full, next, res] = parse_int( s, res, start );
len = next - start;
if( len === 0 ) break; // nothing parsed
if( sep !== '' )
{ if( psep > 0 && len !== 3 ) break; // non-first group not 3 digits
if( psep === 0 && len > 3 ) break; // first group longer than 3 digits
}
result = res; // mark success
if( s.charAt(next) !== sep ) break;
if( full ) break;
start = next;
psep = next;
start = start + 1;
}
return [full, next, result];
}
// Parse a compact of digits beginning at position `start'
// in string `s' as an integer number:
function /* object[]*/ parse_int
( /* string */ s , // input string
/* integer */ init, // initial value
/* integer */ start // start position in `s'
)
// Returns an array of:
// 0: boolean -- entire string was scanned
// 1: integer -- index of next character to scan
// 2: integer -- result
{ const /* integer */ ASCII_0 = 48;
var /* boolean */ full; // \
var /* integer */ next; // > the return value
var /* integer */ res ; // /
var /* integer */ n, i; // string length and current position
var /* integer */ code; // character code
n = s.length;
full = true;
next = n;
res = init;
for( i = start; i < n; i += 1 )
{ code = s.charCodeAt(i);
if( code < ASCII_0 || code >= ASCII_0 + 10 )
{ next = i;
full = false;
break;
}
res = res * 10 + code - ASCII_0;
}
if( code === undefined ) res = NaN;
return [ full, next, res ];
}
And a test program that uses parse_float() to parse numbers of your format:
function test( /* string */ s )
{ var res;
res = parse_float( s, ' ', ',' );
console.log(`${(' ' + `[${s}]`).slice(-12)} => ${res}`);
}
test( '' );
test( '12' );
test( '12a' );
test( '12,' );
test( '12,345' );
test( '12 345' );
test( '123 45' );
test( '1 234 567' );
test( '12 345 56' );
test( '12345' );
test( '12 435,678' );
test( '+1,2' );
test( '-2 345' );
It writes:
[] => NaN
[12] => 12
[12a] => NaN
[12,] => NaN
[12,345] => 12.345
[12 345] => 12345
[123 45] => NaN
[1 234 567] => 1234567
[12 345 56] => NaN
[12345] => NaN
[12 435,678] => 12435.678
[+1,2] => 1.2
[-2 345] => -2345