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

Question

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

Answer 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 обнаруживает начальный ноль в строке, он будет анализировать число в восьмеричной базе, это изменилось в 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

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

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

Answer 2

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

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

Answer 3

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

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

в то время как

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

Answer 4

Резюме:

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

Answer 5

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

Answer 6

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

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

http://jsben.ch/

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

Answer 7

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

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 для некоторых других качеств, никогда не используйте его для преобразования чисел с плавающей запятой в целые числа.

Answer 8

parseInt() -> Парсит число в указанное переопределение.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() функция

Answer 9

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

Answer 10

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

Answer 11

      // it takes only number ,,, if found any other char then this will NaN
console.log(Number('90')); //90
console.log(+'90'); //90

// ? it findout only number
console.log(parseInt('12 slmskmksknn')); //12

Answer 12

Другой способ получить результат - использовать оператор ~

Для большинства обстоятельств

      ~~someThing === parseInt(something)

но ~~ вернет ноль для строк, которые parseInt будет принимать с завершающимися другими символами или со спецификацией базы чисел (например, шестнадцатеричной), а также вернет ноль, когда parseInt вернет NaN. Другое отличие состоит в том, что ~~, если задано bigint, возвращает bigint, к которому вы можете добавить еще один bigint, тогда как parseInt возвращает обычное число с плавающей запятой (да, действительно - он дает то же значение, что и parseFloat), если bigint большой

Однако в большинстве случаев ~~ на 30% быстрее, чем parseInt. Это только на 10% медленнее, когда что-то представляет собой строку с плавающей запятой.

Так что, если более ограниченный объем ~~ соответствует вашим потребностям, сэкономьте компьютерное время и меньше набирайте