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

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

Ну, они семантически разные , 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

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

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

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

Я нашел две ссылки выполнения сравнения между несколькими способами преобразования 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

Одно из отличий второстепенного что они превращают в undefinedили null,

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

пока

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

Резюме:

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

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

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()функций, так как они выполняют преобразование с помощью редиксов, поэтому мы должны избегать использования функции parseInt () для целей приведения.

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

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

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