JavaScript: Métodos Utilitários em JavaScript

Última atualização: 2026-10-13

Já vimos as conversões de tipos — agora vamos aprender um lote de métodos utilitários que você vai usar no dia a dia. Pense neles como uma faca suíça — cada um é simples, mas vai fazer falta quando precisar.

Métodos de array relacionados：Array.isArray() Number.isNaN() Math.trunc parseFloat Number() toString parseInt toFixed typeof array

1. Métodos Utilitários Essenciais

Fazem parsing de números a partir do início de uma string, parando no primeiro caractere não numérico:

<script>
console.log(parseInt("42px"));      // 42
console.log(parseInt("3.14"));      // 3 (apenas parte inteira)
console.log(parseFloat("3.14"));    // 3.14
console.log(parseFloat("3.14abc")); // 3.14
console.log(parseInt("abc42"));     // NaN (não começa com número)
</script>

O segundo argumento de parseInt especifica a base numérica:

<script>
console.log(parseInt("FF", 16));  // 255 (hexadecimal)
console.log(parseInt("10", 2));   // 2 (binário)
</script>

Armadilha: Sem a base, strings começando com 0x são interpretadas como hexadecimal. Sempre passe 10 como segundo argumento.

(2) isNaN vs Number.isNaN

<script>
console.log(isNaN("hello"));         // true (Number("hello") → NaN, depois true)
console.log(Number.isNaN("hello"));  // false ("hello" em si não é NaN)
console.log(isNaN(undefined));       // true
console.log(Number.isNaN(undefined));// false
</script>

Conclusão: Use Number.isNaN() — ele não converte tipos silenciosamente.

(3) toFixed

Controla casas decimais, retorna uma string:

<script>
console.log((3.14159).toFixed(2));  // "3.14"
console.log((3.1).toFixed(4));      // "3.1000" (preenchido com zeros)
console.log((3.145).toFixed(2));    // "3.14" ou "3.15" (problema de precisão de ponto flutuante, arredondamento não garantido)
</script>

Note que toFixed retorna uma string — use Number() para converter de volta para cálculos.

(4) toString

Converte um número para string, com suporte opcional a base numérica:

<script>
console.log((255).toString());      // "255"
console.log((255).toString(16));    // "ff"
console.log((8).toString(2));       // "1000"
console.log((100).toString(8));     // "144"
</script>

Booleanos e arrays também têm toString:

<script>
console.log(true.toString());       // "true"
console.log([1,2,3].toString());    // "1,2,3"
</script>

(5) Number.isInteger

Verifica se um valor é um inteiro:

<script>
console.log(Number.isInteger(5));      // true
console.log(Number.isInteger(5.0));    // true (5.0 é apenas 5)
console.log(Number.isInteger(5.5));    // false
console.log(Number.isInteger("5"));    // false (uma string não é um inteiro)
console.log(Number.isInteger(NaN));    // false
</script>

(6) Math.trunc e Math.sign

Math.trunc simplesmente corta a parte decimal (sem arredondar):

<script>
console.log(Math.trunc(4.9));    // 4
console.log(Math.trunc(-4.9));   // -4
console.log(Math.trunc(4.1));    // 4
</script>

Math.sign retorna o sinal de um número:

<script>
console.log(Math.sign(5));       // 1
console.log(Math.sign(-5));      // -1
console.log(Math.sign(0));       // 0
console.log(Math.sign(-0));      // -0
console.log(Math.sign(NaN));     // NaN
</script>

(7) Limitações do typeof

typeof geralmente funciona para verificação de tipos, mas há algumas pegadinhas clássicas:

<script>
console.log(typeof 42);           // "number"  ✅
console.log(typeof "hello");      // "string"  ✅
console.log(typeof true);         // "boolean" ✅
console.log(typeof undefined);    // "undefined" ✅
console.log(typeof null);         // "object"  ❌ Isso é um bug histórico!
console.log(typeof []);           // "object"  ❌ Arrays também são objetos
console.log(typeof {});           // "object"  ✅
console.log(typeof function(){}); // "function" ✅
</script>

typeof null === "object" é um "bug veterano" do JavaScript — existe desde 1995 e nunca pode ser corrigido. Use value === null para verificar null. Use Array.isArray() para verificar arrays.

▶ Exemplo: Calculadora de Preços

▶ Exemplo: Ferramenta de Validação de Entrada

▶ Exemplo: typeof e Verificação de Tipos

Métodos de array relacionados：Array.isArray() Number.isNaN() Math.trunc parseFloat Number() toString parseInt toFixed typeof array

❓ Perguntas Frequentes

📖 Resumo

• parseInt(str, radix) analisa inteiros; especifique radix. parseFloat(str) analisa floats
• isNaN(value) verifica NaN — NaN === NaN é false, use Number.isNaN para verificação estrita
• Conversão explícita: Number(value), String(value), Boolean(value) são mais seguros
• num.toFixed(digits) retorna string com casas decimais especificadas, ótimo para exibição de moeda
• Verificação de tipo: typeof para primitivos, Array.isArray() para arrays, Object.prototype.toString.call() para detecção precisa

📝 Exercícios

1. Escreva uma função parseNumeroPortugues(str) que faça parsing de strings como "3,5 reais" → 3.5, "100 pessoas" → 100, "cerca de 200" → 200 (usando parseFloat). Trate o caso em que texto puro retorna NaN.
2. Escreva uma função formatarMoeda(valor) que receba um número e retorne uma string com separador de milhar e duas casas decimais, ex: 1234567.89 → "1.234.567,89" (dica: use toFixed e toString com métodos de array).
3. Escreva uma função obterTipo(valor) que complemente as falhas do typeof: retorne null para null, array para arrays, e o resultado do typeof nos demais casos.

Equipe Técnica Web-Tutorial

Uma plataforma de tutoriais mantida por diversos desenvolvedores. Cada tutorial é escrito e revisado por profissionais da área correspondente. Trabalhamos para manter nosso conteúdo preciso e confiável — se encontrar algum problema, avise-nos.

Sobre Nós