Что лучше?
Я прошу об этом только ради бритья нескольких байтов, так как я могу использовать + x вместо числа (x). Разве parsefloat делает что-то лучше?
EDIT:
Вердикт - parseFloat. Даже если использование +(x) сохранит несколько байтов, parseFloat спасет как можно больше от комбинации строк/чисел.
parseFloat/parseInt предназначен для синтаксического анализа строки, а Number/+ - для принудительного ввода значения в число. Они ведут себя по-другому. Но сначала посмотрим, где они ведут себя одинаково:
parseFloat('3'); // => 3
Number('3'); // => 3
parseFloat('1.501'); // => 1.501
Number('1.501'); // => 1.501
parseFloat('1e10'); // => 10000000000
Number('1e10'); // => 10000000000
Итак, если у вас стандартный цифровой ввод, нет никакой разницы. Однако, если ваш ввод начинается с числа, а затем содержит другие символы, parseFloat обрезает номер из строки, а Number дает NaN (а не число):
parseFloat('1x'); // => 1
Number('1x'); // => NaN
Кроме того, Number понимает шестнадцатеричный ввод, а parseFloat не выполняет:
parseFloat('0x10'); // => 0
Number('0x10'); // => 16
Но Number действует странно с пустыми строками или строками, содержащими только пробел:
parseFloat(''); // => NaN
Number(''); // => 0
parseFloat(' \r\n\t'); // => NaN
Number(' \r\n\t'); // => 0
В целом, я считаю Number более разумным, поэтому я почти всегда использую Number лично (и вы обнаружите, что многие внутренние функции JavaScript также используют Number). Если кто-то набирает '1x', я предпочитаю показывать ошибку, а не рассматривать ее так, как если бы они набрали '1'. Единственный раз, когда я делаю исключение, это когда я преобразовываю стиль в число, и в этом случае parseFloat полезно, потому что стили имеют форму типа '3px', и в этом случае я хочу отказаться от части 'px' и просто получите 3, поэтому я нахожу parseFloat полезным здесь. Но действительно, какой вы выбираете, зависит от вас и какие формы ввода вы хотите принять.
Обратите внимание, что использование унарного оператора + в точности совпадает с использованием Number как функции:
Number('0x10'); // => 16
+'0x10'; // => 16
Number('10x'); // => NaN
+'10x'; // => NaN
Number('40'); // => 40
+'40'; // => 40
Поэтому я обычно просто использую + для краткости. Пока вы знаете, что он делает, мне легко читать.
Разница в том, что происходит, когда вход не является "правильным номером". Number возвращает NaN, а parseFloat анализирует "как можно больше". Если вызываемая пустая строка Number возвращает 0, в то время как parseFloat возвращает NaN.
Например:
Number("") === 0 // also holds for false
isNaN(parseFloat("")) === true // and null
isNaN(Number("32f")) === true
parseFloat("32f") === 32
В этих примерах вы можете увидеть разницу:
Number('') = 0;
Number(false) = 0;
Number('1a') = NaN;
parseFloat('') = NaN;
parseFloat(false) = NaN;
parseFloat('1a') = 1;
parseFloat немного медленнее, потому что он ищет первое появление числа в строке, в то время как Number constuctor создает экземпляр нового номера из строк, который содержит числовые значения с пробелом или содержит ложные значения.
P.S. Если вас интересуют некоторые универсальные преобразования типов, вы можете прочитать сообщение о преобразовании типа в моем блоге: http://justsimplejs.blogspot.com/2012/08/data-type-conversion.html
Для пустой строки они отличаются.
+"" и Number("") возвращает 0, а parseFloat("") возвращает NaN.
Насколько я знаю, и это только подслушивает от коллег, поэтому может быть совершенно плохо информировано, что parseFloat происходит немного быстрее.
Хотя при дальнейших исследованиях, казалось бы, это различие в производительности зависит от браузера.
http://jsperf.com/parseint-vs-parsefloat/6
Посмотрите на эти результаты jsPerf и сделайте вызов. (он также включает в себя + x тесты)
Как отмечено в ответе @xdazz, +"" и Number("") return 0, а parseFloat("") возвращает NaN, так что снова я бы пошел с parseFloat, потому что пустая строка НЕ означает число 0, только строка с символом "0" в нем означает 0;