Number em Javascript – Aprendendo JS #01

Vamos entender o que são Number em Javascript?

Diferentemente de outras linguagens, como por exemplo o Java, o Javascript não segmenta os números. Em java temos os números segmentados por byte, short, int, long, float e duble, temos apenas Number em Javascript, e o que isso nos traz de benefícios? Imagine que você cria um sistema em que haverá um contador para o número de contas criadas e utilize o short como tipo do seu campo, com o passar do tempo este projeto cresce e você tem 32.767 contas criadas, o que acontecerá quando a próxima conta for criada? Exatamente, sua aplicação terá um crash, pois o tipo short tem 16 bits e armazena números entre -32.768 e 32.767. O Youtube há alguns anos teve este problema com o vídeo do coreano louco, a empresa utilizava o tipo inteiro 32-bit para seu contador, quando o vídeo bateu 2.147.483.648 visualizações o contador deu crash, obrigando assim a Google a trocar o tipo de dado do contador de 32-bit para 64-bit.

Em javascript não temos este problema, pois, o tipo Number armazena os números sempre em 64-bit, ele utiliza 52 bits (0 à 51) para os números, 11 bits (52 à 62) para os expoentes e 1 bit (63) para armazenar os sinais.

OPA GANGNAM STYLE…
desculpe, o vídeo ainda estava rolando aqui, me empolguei!

Precisão em ponto flutuante

Porém, em Javascript temos um problema de precisão com números de ponto flutuante. – Tá vendo, meu professor de Java da faculdade disse que Javascript era uma porcaria. Calma meu jovem gafanhoto, assim como muitas outras linguagens, o Javascript segue o padrão IEEE 754. TUDO que você digita, o seu computador converte para binário afinal é o único tipo de dado que ele entende, durante o processo de conversão para binário (base 2) para que a máquina entenda e a conversão de volta deste binário para decimal (base 10) para que seja exibido para você, há uma inconsitência pela forma que o tipo binário armazena tipos de ponto flutuante.

> a = 0.2
> b = 0.1
> a == b
false
> a + b
0.30000000000000004

Mas nem tudo está perdido, como pra tudo nessa vida tem solução, conseguimos resolver este problema com a famosa gambiarrinha

> var x = (0.2 * 10 + 0.1 * 10) / 10
> x == 0.3
true
> x
0.3

Por isso devemos tomar muito cuidado quando formos trabalhar com números muito precisos em Javascript ou qualquer outra linguagem que implemente o mesmo padrão.

Métodos disponíveis

Se você tiver instalado o node em seu computador e for até seu terminal e digitar node você entrará no interpretador do node, onde poderá fazer testes de Javascript, colocando um “.” após a variável com um tipo específico de dado e apertando duas vezes ‘tab’, você pode ver uma lista dos métodos que estão disponíveis para aquele tipo de dado.

$node                                           
> a = 1
> a.
a.__defineGetter__      a.__defineSetter__      a.__lookupGetter__
a.__lookupSetter__      a.__proto__             a.constructor
a.hasOwnProperty        a.isPrototypeOf         a.propertyIsEnumerable
a.toLocaleString        a.toString              a.valueOf
a.toExponential         a.toFixed               a.toPrecision

Vou comentar aqui os 3 mais utilizados dentre eles toString(), toFixed() e toPrecision().

toFixed(number)

Vamos começar pelo toFixed(). Este método recebe um número inteiro como parâmetro e retorna uma String arredondando o número e utilizando o parâmetro como quantidade de casas decimais

> a = 1234.5678
> a.toFixed()
'1235'
> a.toFixed(1)
'1234.6'
> a.toFixed(4)
'1234.5678'
> a.toFixed(10)
'1234.5678000000'

Note que quando não possuir números o suficiente para preencher a quantidade de dígitos pedidos no método, ele completará com zeros.

toString(number)

Em toString() temos um método que sem argumento algum, apenas transforma o número para uma string, porém, ele pode receber um inteiro entre 2 e 36, onde ele irá representar o número utilizando seu parâmetro como BASE de conversão, 2 (binário), 10 (decimal), 16 (hexadecimal), etc.

> x = 1234
> x.toString()
'1234'
> x.toString(2)
'10011010010'
> x.toString(16)
'4d2'

toPrecision(number)

Com o método toPrecision() temos algo bem semelhante ao toFixed(), porém em toFixed(), o número passado como parâmetro é a quantidade de casas decimais, já em toPrecision() o valor do argumento é equivalente ao número total de dígitos (excluíndo a vírgula) que o número irá possuir.

> x = 4.1234
4.1234
> x.toPrecision(4)
'4.123'
> x.toPrecision(3)
'4.12'
> x.toPrecision()
'4.1234'

//Diferença entre toPrecision() e toFixed()
> x.toPrecision(2)
'4.1'
> x.toFixed(2)
'4.12'

Caso não seja passado nenhum parâmetro, ele se comportará como o toString()

Conclusão

Ao final desta breve explicação, pudemos ver como o javascript trata o tipo numérico, o que ele faz de diferente de outras linguagens, também pudemos ver o problema de precisão em números de ponto flutuante por causa do padrão que a linguagem utiliza, e também alguns métodos nativos.

No próximo artigo irei falar um pouco sobre o tipo String, a ideia é que eu consiga postar 1 ou 2 artigos por dia, tudo vai depender de tempo (Salve Stephen Hawking)

O que ouvi para escrever este artigo