The internal workings are not that different, as @James Allardic already answered. There is a difference though. Using parseFloat, a (trimmed) string starting with one or more numeric characters followed by alphanumeric characters can convert to a Number, with Number that will not succeed. As in:
parseFloat('3.23abc'); //=> 3.23
Number('3.23abc'); //=> NaN
In both conversions, the input string is trimmed, by the way:
parseFloat(' 3.23abc '); //=> 3.23
Number(' 3.23 '); //=> 3.23
The internal workings are not that different, as @James Allardic already answered. There is a difference though. Using parseFloat, a (trimmed) string starting with one or more numeric characters followed by alphanumeric characters can convert to a Number, with Number that will not succeed. As in:
parseFloat('3.23abc'); //=> 3.23
Number('3.23abc'); //=> NaN
In both conversions, the input string is trimmed, by the way:
parseFloat(' 3.23abc '); //=> 3.23
Number(' 3.23 '); //=> 3.23
No. Both will result in the internal ToNumber(string) function being called.
From ES5 section 15.7.1 (The Number Constructor Called as a Function):
When
Numberis called as a function rather than as a constructor, it performs a type conversion...Returns a Number value (not a Number object) computed by
ToNumber(value)if value was supplied, else returns+0.
From ES5 section 15.1.2.3 (parseFloat (string)):
... If neither
trimmedStringnor any prefix oftrimmedStringsatisfies the syntax of aStrDecimalLiteral(see 9.3.1) ...
And 9.3.1 is the section titled "ToNumber Applied to the String Type", which is what the first quote is referring to when it says ToNumber(value).
Update (see comments)
By calling the Number constructor with the new operator, you will get an instance of the Number object, rather than a numeric literal. For example:
typeof new Number(10); //object
typeof Number(10); //number
This is defined in section 15.7.2 (The Number Constructor):
When
Numberis called as part of anewexpression it is a constructor: it initialises the newly created object.
The advantage of using Number() instead of parseInt or parseFloat - JavaScript - SitePoint Forums | Web Development & Design Community
javascript - What is the difference between Number.parseFloat() or parseFloat()? - Stack Overflow
Difference parseInt() and parseFloat()
parseFloat alternative?
Videos
They are the exact same function. They don't only behave the same. They are the exact same function object.
To expand on that, Number.parseFloat() was created in ECMAScript 2015, as part of an effort to modularize globals [because global functions with no namespace makes me sad :(]
parseFloat vs. Number.parseFloat
- https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/parseFloat
- https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/parseFloat
parseFloat === Number.parseFloat // => true
--
parseFloat is accessible via the Global scope as of ES2015
parseFloat
From MDN: its purpose is modularization of globals
--
Number.parseFloat is available via a method on the Number object (also since ES2015).
In either case, the behavior for both function calls is identical. Both will type coerce the input into a Number if possible (e.g.: parseFloat('67') // => 67) or return NaN if the parsed input wasn't able to be coerced.
The difference between parseFloat and Number
parseFloat()/parseInt() is for parsing a string, while Number()/+ is for coercing a value to a number. They behave differently. But first let's look at where they behave the same:
parseFloat('3'); // => 3
Number('3'); // => 3
parseFloat('1.501'); // => 1.501
Number('1.501'); // => 1.501
parseFloat('1e10'); // => 10000000000
Number('1e10'); // => 10000000000
So as long as you have standard numeric input, there's no difference. However, if your input starts with a number and then contains other characters, parseFloat truncates the number out of the string, while Number gives NaN (not a number):
parseFloat('1x'); // => 1
Number('1x'); // => NaN
In addition, Number understands hexadecimal input while parseFloat does not:
parseFloat('0x10'); // => 0
Number('0x10'); // => 16
But Number acts weird with empty strings or strings containing only white space:
parseFloat(''); // => NaN
Number(''); // => 0
parseFloat(' \r\n\t'); // => NaN
Number(' \r\n\t'); // => 0
On the whole, I find Number to be more reasonable, so I almost always use Number personally (and you'll find that a lot of the internal JavaScript functions use Number as well). If someone types '1x' I prefer to show an error rather than treat it as if they had typed '1'. The only time I really make an exception is when I am converting a style to a number, in which case parseFloat is helpful because styles come in a form like '3px', in which case I want to drop the 'px' part and just get the 3, so I find parseFloat helpful here. But really which one you choose is up to you and which forms of input you want to accept.
Note that using the unary + operator is exactly the same as using Number as a function:
Number('0x10'); // => 16
+'0x10'; // => 16
Number('10x'); // => NaN
+'10x'; // => NaN
Number('40'); // => 40
+'40'; // => 40
So I usually just use + for short. As long as you know what it does, I find it easy to read.
In these examples you can see the difference:
Number('') = 0;
Number(false) = 0;
Number('1a') = NaN;
parseFloat('') = NaN;
parseFloat(false) = NaN;
parseFloat('1a') = 1;
parseFloat is a bit slower because it searches for first appearance of a number in a string, while the Number constuctor creates a new number instance from strings that contains numeric values with whitespace or that contains falsy values.