В чем разница между parseInt() и Number()?

Как parseInt() и Number() вести себя по-разному при преобразовании строк в числа?

Ответ 1

Ну, они семантически разные, конструктор Number называемый как функция, выполняет преобразование типов, а parseInt выполняет разбор, например:

// parsing:
parseInt("20px");       // 20
parseInt("10100", 2);   // 20
parseInt("2e1");        // 2

// type conversion
Number("20px");       // NaN
Number("2e1");        // 20, exponential notation

Имейте в виду, что если parseInt обнаруживает parseInt ноль в строке, он будет анализировать число в восьмеричной базе, это изменилось на ECMAScript 5, новой версии стандарта, но потребуется много времени для реализации браузеров ( это несовместимость с ECMAScript 3), также parseInt будет игнорировать конечные символы, которые не соответствуют какой-либо цифре используемой базы.

Конструктор Number не определяет восьмеричные значения:

Number("010");         // 10
parseInt("010");       // 8, implicit octal
parseInt("010", 10);   // 10, decimal radix used

Но он может обрабатывать числа в шестнадцатеричной системе, как и parseInt:

Number("0xF");   // 15
parseInt("0xF"); //15

Кроме того, широко используемая конструкция для преобразования числового типа является оператором Unary + (стр. 72), она эквивалентна использованию конструктора Number как функции:

+"2e1";   // 20
+"0xF";   // 15
+"010";   // 10

Ответ 2

typeof parseInt("123") => number
typeof Number("123") => number
typeof new Number("123") => object (Number primitive wrapper object)

первые два будут давать вам лучшую производительность, поскольку он возвращает примитив вместо объекта.

Ответ 3

Если вы ищете производительность, то, вероятно, лучшие результаты вы получите с побитным правым сдвигом "10">>0. Также умножьте ("10" * 1) или нет (~~"10"). Все они намного быстрее Number и parseInt. У них даже есть функция, возвращающая 0 для аргумента number. Вот Тесты производительности.

Ответ 4

Я обнаружил, что сравнение производительности между несколькими способами преобразования string в int.

parseInt(str,10)    
parseFloat(str)
str << 0
+str
str*1 
str-0
Number(str)

http://jsben.ch/#/zGJHM

http://phrogz.net/js/string_to_number.html

Ответ 5

Я всегда использую parseInt, но будьте осторожны с ведущими нулями, которые заставят его в восьмеричном режиме.

Ответ 6

Одно незначительное отличие состоит в том, что они конвертируют undefined или null,

Number() Or Number(null) // returns 0

в то время как

parseInt() Or parseInt(null) // returns NaN

Ответ 7

Резюме:

parseInt():

Принимает строку в качестве первого аргумента, основание (целое число, которое является основой системы счисления, например, десятичная 10 или двоичная 2) в качестве второго аргумента
Функция возвращает целое число, если первый символ не может быть преобразован в число NaN.
Если функция parseInt() встречает не числовое значение, она обрезает оставшуюся часть входной строки и анализирует только часть до не числового значения.
Если основание равно undefined или 0, JS примет следующее:
- Если входная строка начинается с "0x" или "0X", основание равно 16 (шестнадцатеричное), остаток строки разбирается в число.
- Если входное значение начинается с 0, основание может быть 8 (восьмеричное) или 10 (десятичное). Выбор радиуса зависит от реализации движка JS. ES5 указывает, что тогда следует использовать 10. Однако это поддерживается не всеми браузерами, поэтому всегда указывайте основание, если ваши числа могут начинаться с 0.
- Если входное значение начинается с любого числа, основание будет 10

Number():

Конструктор Number() может преобразовать любой входной аргумент в число. Если конструктор Number() не может преобразовать ввод в число, будет возвращено NaN.
Конструктор Number() также может обрабатывать шестнадцатеричные числа, они должны начинаться с 0x.

Пример:

console.log(parseInt('0xF', 16));  // 15

// z is no number, it will only evaluate 0xF, therefore 15 is logged
console.log(parseInt('0xFz123', 16));

// because the radix is 10, A is considered a letter not a number (like in Hexadecimal)
// Therefore, A will be cut off the string and 10 is logged
console.log(parseInt('10A', 10));  // 10

// first character isnot a number, therefore parseInt will return NaN
console.log(parseInt('a1213', 10));


console.log('\n');


// start with 0X, therefore Number will interpret it as a hexadecimal value
console.log(Number('0x11'));

// Cannot be converted to a number, NaN will be returned, notice that
// the number constructor will not cut off a non number part like parseInt does
console.log(Number('123A'));

// scientific notation is allowed
console.log(Number('152e-1'));  // 15.21

Ответ 8

parseInt преобразует в целое число, т.е. разбивает десятичные числа. Число не преобразуется в целое число.

Ответ 9

parseInt() → Парширует число до указанного redix. Number() → Преобразует указанное значение в его числовой эквивалент или NaN, если он этого не сделает.

Следовательно, для преобразования некоторого нечислового значения в число мы всегда должны использовать функцию Number().

например.

Number("")//0
parseInt("")//NaN

Number("123")//123
parseInt("123")//123

Number("123ac") //NaN,as it is a non numeric string
parsInt("123ac") //123,it parse decimal number outof string

Number(true)//1
parseInt(true) //NaN

существуют различные угловые аргументы для функций parseInt() поскольку они выполняют преобразование redix, поэтому нам следует избегать использования функции parseInt() для целей конвертации. Теперь, чтобы проверить погоду, предоставленное значение является числовым или нет, мы должны использовать собственную isNaN()

Ответ 10

Это хорошая идея держаться подальше от parseInt и использовать Number и Math.round, если вам не нужен hex или восьмеричный. Оба могут использовать строки. Зачем держаться подальше от этого?

parseInt(0.001, 10)
0

parseInt(-0.0000000001, 10)
-1

parseInt(0.0000000001, 10)
1

parseInt(4000000000000000000000, 10)
4

Это полностью мясники действительно больших или очень маленьких чисел. Как ни странно, он работает нормально, если эти входные данные являются строкой.

parseInt("-0.0000000001", 10)
0

parseInt("0.0000000001", 10)
0

parseInt("4000000000000000000000", 10)
4e+21

Вместо того, чтобы рисковать, чтобы найти ошибки с этим и другими упомянутыми людьми, я бы просто избегал parseInt, если вам не нужно анализировать что-то кроме базы 10. Number, Math.round, Math.foor и .toFixed(0 ) все могут выполнять одни и те же действия, для которых можно использовать parseInt, не имея подобных ошибок.

Если вы действительно хотите или должны использовать parseInt для некоторых других качеств, никогда не используйте его для преобразования чисел с плавающей точкой в целые.