Qual é a diferença entre parseInt () e Number ()?

Como parseInt()e Number()se comportam de maneira diferente ao converter seqüências de caracteres em números?

Bem, eles são semanticamente diferente , o Numberconstrutor chamado como função executa tipo de conversão e parseIntexecuta a análise , por exemplo:

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

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

Lembre-se de que, se parseIntdetectar um zero inicial na string, ele analisará o número na base octal, isso foi alterado no ECMAScript 5, a nova versão do padrão, mas levará muito tempo para entrar nas implementações do navegador (é uma incompatibilidade com o ECMAScript 3) também parseIntignorará os caracteres finais que não correspondem a nenhum dígito da base usada atualmente.

O Numberconstrutor não detecta octais:

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

Mas ele pode lidar com números em notação hexadecimal, assim como parseInt:

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

Além disso, um construto amplamente usado para realizar a conversão de tipos numéricos, é o Operador Unário +(p. 72) , é equivalente a usar o Numberconstrutor como uma função:

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

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

os dois primeiros oferecerão melhor desempenho, pois retornam um primitivo em vez de um objeto.

Se você está procurando desempenho, provavelmente os melhores resultados serão obtidos com a mudança à direita bit a bit "10">>0. Também multiplique ( "10" * 1) ou não ( ~~"10"). Todos eles são muito mais rápidos Numbere parseInt. Eles ainda têm "feature" retornando 0 para não argumento de número. Aqui estão os testes de desempenho .

Encontrei dois links de desempenho comparados entre várias formas de conversão stringpara 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

Uma pequena diferença é o que eles convertem undefinedou null,

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

enquanto

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

Resumo:

parseInt():

• Pega uma string como primeiro argumento, a raiz (Um inteiro que é a base de um sistema numérico, por exemplo, decimal 10 ou binário 2) como segundo argumento
• A função retorna um número inteiro, se o primeiro caractere não puder ser convertido em um número NaNserá retornado.
• Se a parseInt()função encontrar um valor não numérico, ela cortará o restante da string de entrada e analisará apenas a parte até o valor não numérico.
• Se a raiz for undefinedou 0, JS assumirá o seguinte:
  • Se a sequência de entrada começar com "0x" ou "0X", a raiz é 16 (hexadecimal), o restante da sequência é analisado em um número.
  • Se o valor de entrada começar com 0, o radical pode ser 8 (octal) ou 10 (decimal). Qual raiz escolhida depende da implementação do mecanismo JS. ES5especifica que 10 deve ser usado então. No entanto, isso não é suportado por todos os navegadores, portanto , sempre especifique radix se seus números puderem começar com um 0.
  • Se o valor de entrada começar com qualquer número, a raiz será 10

Number():

• O Number()construtor pode converter qualquer entrada de argumento em um número. Se o Number()construtor não puder converter a entrada em um número, NaNserá retornado.
• O Number()construtor também pode lidar com números hexadecimais, eles precisam começar 0x.

Exemplo:

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

Eu sempre uso parseInt, mas cuidado com os zeros à esquerda que o forçarão ao modo octal .

parseInt() -> Analisa um número no redix especificado.

Number()-> Converte o valor especificado em seu equivalente numérico ou NaN, caso contrário.

Portanto, para converter algum valor não numérico em número, devemos sempre usar a função Number ().

por exemplo.

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

Existem várias maiúsculas e minúsculas nas parseInt()funções, pois faz a conversão redix, portanto, devemos evitar o uso da função parseInt () para fins de coerção.

Agora, para verificar o clima, o valor fornecido é Numérico ou não, devemos usar a isNaN()função nativa

parseInt converte em um número inteiro, ou seja, retira decimais. O número não converte em número inteiro.

É uma boa idéia ficar longe de parseInt e usar Number e Math.round, a menos que você precise de hex ou octal. Ambos podem usar strings. Por que ficar longe disso?

parseInt(0.001, 10)
0

parseInt(-0.0000000001, 10)
-1

parseInt(0.0000000001, 10)
1

parseInt(4000000000000000000000, 10)
4

Abate completamente números realmente grandes ou muito pequenos. Curiosamente, funciona normalmente se essas entradas são uma string.

parseInt("-0.0000000001", 10)
0

parseInt("0.0000000001", 10)
0

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

Em vez de me arriscar a encontrar bugs com essa e outras dicas mencionadas, eu evitaria o parseInt, a menos que você precise analisar algo diferente da base 10. Number, Math.round, Math.foor e .toFixed (0) podem faça o mesmo que o parseInt pode ser usado sem esses tipos de erros.

Se você realmente deseja ou precisa usar o parseInt para outras qualidades, nunca o use para converter flutuadores em ints.