Verificação de tipo string em JavaScript: guia completo

Treinador Online de Python para Iniciantes

Aprenda Python facilmente sem sobrecarga teórica. Resolva tarefas práticas com verificação automática e escreva código diretamente no navegador.

Start Course

«É uma string?» — a pergunta que atormenta todo desenvolvedor JavaScript

Você está escrevendo código e de repente para. A variável deveria conter uma string, mas e se veio um null? Ou um número? Ou, pior ainda, undefined?

Familiar? Se sim, você não está sozinho. A pergunta «Check if a variable is a string in JavaScript» é uma das mais populares no Stack Overflow, com dezenas de milhares de visualizações. E não é por acaso: JavaScript é uma linguagem de tipagem dinâmica, e erros relacionados a tipos acontecem até com desenvolvedores experientes.

Neste artigo, vamos abordar todas as formas possíveis de verificar se uma variável é uma string. Você aprenderá:

Por que typeof é seu melhor amigo (mas nem sempre)
Quando instanceof falha
Como funciona o método «atirador de elite» Object.prototype.toString
E o que fazer se você estiver usando bibliotecas

Vamos lá! 🚀

Método nº1: typeof — o clássico do gênero

A maneira mais simples e rápida é o operador typeof. Ele retorna uma string com o nome do tipo:

const name = "Alice";const age = 25;const isAdmin = true;

console.log(typeof name);    // "string"console.log(typeof age);     // "number"console.log(typeof isAdmin); // "boolean"

A verificação de string fica assim:

if (typeof variable === "string") {  console.log("Sim, é uma string!");}

Vantagens:

Funciona rapidamente
Não requer importação
Legível

Desvantagens:

Não diferencia a primitiva "string" do objeto new String("string")
Para null, retorna "object" (erro histórico do JavaScript)

A propósito, sobre null — é um bug conhecido da linguagem que não será corrigido para não quebrar sites antigos. Então typeof null === "object" é normal.

E o new String()?

Em JavaScript, existem dois tipos de strings: primitivas (comuns) e objetos (criados com new String()). Na prática, você quase nunca usará new String(), mas é bom saber sobre ele:

const primitiveString = "Olá";const objectString = new String("Olá");

console.log(typeof primitiveString); // "string"console.log(typeof objectString);    // "object"

Se no seu código alguém (ou algo) passar uma string objeto, o typeof vai te enganar. Mas não se preocupe: em projetos reais, isso é raro.

Método nº2: instanceof — para strings objeto

O operador instanceof verifica se um objeto é uma instância de uma determinada classe:

const str = new String("Teste");console.log(str instanceof String); // true

const str2 = "Teste";console.log(str2 instanceof String); // false — porque é uma primitiva

Como você pode ver, instanceof não funciona com strings primitivas. Por isso, é usado raramente — apenas se você tem certeza de que está trabalhando com objetos.

Quando pode ser útil? Se você está escrevendo uma biblioteca que aceita tanto primitivas quanto objetos. Mas para 99% dos casos, typeof é suficiente.

Método nº3: Object.prototype.toString.call() — o soldado universal

Este método é um verdadeiro atirador de elite. Funciona para qualquer tipo de dado e nunca erra:

function isString(value) {  return Object.prototype.toString.call(value) === "[object String]";}

console.log(isString("Olá"));        // trueconsole.log(isString(new String("Olá"))); // trueconsole.log(isString(123));             // falseconsole.log(isString(null));            // falseconsole.log(isString(undefined));       // false