The parseInt function can be used to parse strings to integers and uses this format: parseInt(string, radix);

Ex: parseInt("-10.465", 10); returns -10

To parse floating point numbers, you use parseFloat, formatted like parseFloat(string)

Ex: parseFloat("-10.465"); returns -10.465

If I use Float.parseFloat("1.4E-46"), it returns 0.0 instead of negative infinite. In the case of positive bigger number, it returns infinite.

The number 1.4E-46 is not a negative number. It is a very small positive number.

The opposite of 1.4E+46 is -1.4E+46. So if you do Float.valueOf("-1.4E+46") you will get -Infinity.

The JavaScript function parseFloat() needs an input string that meets certain requirements, including (but not limited to) the following:

• If parseFloat encounters a character other than a plus sign (+), minus sign (- U+002D HYPHEN-MINUS), numeral (0–9), decimal point (.), or exponent (e or E), it returns the value up to that character, ignoring the invalid character and characters following it.

Localized strings may contain characters that does not meet those requirements.

There should be nothing special to parsing negative numbers compared to positive number.

float f = Float.parseFloat("-1.0");

The above code should work perfectly fine.

What might be wrong with your code, is that you're trying to parse a float with the wrong decimal separator. If your locale has . as decimal separator, the above code is OK. If however your locale has , as the decimal separator, the parsing will fail (with a NumberFormatException).

So make sure you're splitting the original correctly, and that each of the parts after the split are on a valid format (e.g. with the correct decimal separator).

Update:
If you want to know how to parse a number using a specific locale, you could for instance look at this question.

Nothing strange here, this is how IEEE floating point works.

Since what you seem to be doing here is formatting a currency value, I would suggest writing a reusable function to do that so it's done consistently throughout your app.

There are several approaches, however which to use depends on the application

It's not a bug. There is nothing wrong with -0 as a value in IEEE floating point: -0 === 0, x + -0 = x, x * -0 = -0 etc. In arithmetic minus 0 works exactly the same way 0 does.

Usually I would handle the -0.00 when formatting, since only -0.00 "looks wierd", -10.20 is just an overdraft :)

res = res.toFixed(2);
if(res === '-0.00'){
  res = '0.00';
}

I suggest this article to understand IEEE floating point better: What Every Computer Scientist Should Know About Floating-Point Arithmetic

JIT issue perhaps? I found the implementation of Math.abs in the JavascriptCore source which I'm guessing is different from Nitro (ios js engine) or is perhaps marked as JIT executable.

Value MathFuncImp::call(ExecState *exec, Object &/*thisObj*/, const List &args)
{
  double arg = args[0].toNumber(exec);
  double arg2 = args[1].toNumber(exec);
  double result;

  switch (id) {
  case MathObjectImp::Abs:
    result = ( arg < 0 || arg == -0) ? (-arg) : arg;
    break;

This can be implemented directly in javascript. So you can replace your Math.abs calls with

result = ( arg < 0 || arg == -0) ? (-arg) : arg;

This will resolve the issue and be cross browser compatible.

Submitted Apple Bug: 16209709

Does anyone know how this kind of bug occurs or a better way to describe it?

Bit Flip? Memory Collision? Overflow of some sort?

It should work fine, the problem is that you're using the wrong character, an ndash – vs a hyphen -:

var x = parseInt("-2147483648");
console.log(x);

If you copy/paste that you'll see that it works now.

You second number has three decimal places and you set it toFixed(2) so it changes its value to -8985.92. When I use .toFixed(3) for it I get the first result you are looking for.