Como Pegar o Nome de um Objeto ou Classe em JavaScript

Neste artigo você vai aprender a como pegar o nome de um objeto ou classe em JavaScript, veja os detalhes agora mesmo!

Introdução

Em JavaScript, é comum trabalhar com objetos e classes, especialmente ao criar aplicativos complexos e bem organizados.

Muitas vezes, os desenvolvedores precisam pegar o nome de um objeto ou classe para fins de depuração, registro ou manipulação dinâmica de instâncias.

Neste artigo, vamos explorar diferentes maneiras de pegar o nome de um objeto ou classe em JavaScript e discutir seus prós e contras.

Usando a propriedade constructor.name

Uma das maneiras mais simples de pegar o nome de um objeto ou classe em JavaScript é usar a propriedade constructor.name.

Todo objeto em JavaScript possui uma propriedade constructor que aponta para a função construtora que criou o objeto.

Essa função construtora, por sua vez, possui uma propriedade name que contém o nome da função ou classe.

Exemplo:

class Pessoa {
  constructor(nome) {
    this.nome = nome;
  }
}

const joao = new Pessoa('João');

console.log(joao.constructor.name); // Output: "Pessoa"

Neste exemplo, ao pegar o nome do objeto joao, obtemos “Pessoa”, que é o nome da classe que o criou.

No entanto, vale ressaltar que essa abordagem pode não funcionar em todos os casos, especialmente quando o código é minificado ou ofuscado, pois os nomes das funções e classes podem ser alterados no processo.

Usando a função Object.prototype.toString

Outra maneira de pegar o nome de um objeto ou classe é usando a função Object.prototype.toString. Essa função retorna uma representação de string do objeto, incluindo seu nome de classe.

Formação Recomendada

Formação Vibe Coding

Do Prompt ao Produto: Crie Software Real com IA

• 474 aulas
• 20 projetos
• 39h 27min

Conhecer formação

Exemplo:

class Pessoa {
  constructor(nome) {
    this.nome = nome;
  }
}

const joao = new Pessoa('João');

console.log(Object.prototype.toString.call(joao)); // Output: "[object Pessoa]"

Para extrair apenas o nome da classe do resultado, você pode usar uma expressão regular ou outras técnicas de manipulação de strings.

Usando a função Function.prototype.toString

Você também pode pegar o nome de uma classe usando a função Function.prototype.toString.

Essa função retorna a representação de string da função, incluindo seu nome.

Exemplo:

class Pessoa {
  constructor(nome) {
    this.nome = nome;
  }
}

console.log(Pessoa.toString()); // Output: "class Pessoa { ... }"

Novamente, você precisará extrair o nome da classe usando expressões regulares ou outras técnicas de manipulação de strings.

Quer aprender mais sobre React? Confira o vídeo abaixo:

Conclusão

Pegar o nome de um objeto ou classe em JavaScript pode ser útil em várias situações, como depuração, registro e manipulação dinâmica de instâncias.

Neste artigo, exploramos três maneiras de fazer isso: usando a propriedade constructor.name, a função Object.prototype.toString e a função Function.prototype.toString.

Cada abordagem tem suas vantagens e desvantagens, e a escolha da melhor opção dependerá das necessidades específicas do seu projeto e do ambiente em que seu código será executado.

Está buscando a sua primeira vaga como Programador? Confira o nosso treinamento completo clicando aqui.

Nosso principal objetivo é tornar você um dev no menor tempo possível, através de uma metodologia planejada nos mínimos detalhes, após formar muitos outros desenvolvedores.

Uma plataforma de cursos com projetos completos, comunidade de alunos e muito mais!

E quando a classe tem herança?

Aí muda o jogo, e é aqui que muita gente se ferra

O constructor.name devolve o nome da classe que REALMENTE criou o objeto, nunca o da classe pai

class Pessoa {
constructor(nome) {
this.nome = nome
}
}

class Dev extends Pessoa {}

const joao = new Dev('João')

console.log(joao.constructor.name) // "Dev"

Se você precisa do nome da classe pai, tem que subir um degrau na cadeia de protótipos

console.log(Object.getPrototypeOf(Object.getPrototypeOf(joao)).constructor.name) // "Pessoa"

Parece assustador, mas pensa assim: se você conhece herança de qualquer outra linguagem, é a mesma ideia

cada objeto aponta pro "molde" que veio antes dele, e você vai subindo até achar quem procura 🙂

Extraindo só o nome da saída:

O post acima falou em usar expressão regular, mas na prática dá pra resolver com uma fatia de string mesmo, sem regex nenhuma

const tag = Object.prototype.toString.call(joao)

console.log(nome)

O 8 é o tamanho exato de "[object ", por isso o número mágico

Quer com regex? Também funciona, escolha sua:

A fatia com slice nunca quebra, por isso eu prefiro ela

Fazendo a sua classe aparecer nessa saída:

Aqui vem o detalhe que quase ninguém conta

O Object.prototype.toString não lê o nome da sua classe, ele lê uma marca interna do objeto

E existe um jeito oficial de definir essa marca: o Symbol.toStringTag

class Pessoa {
constructor(nome) {
this.nome = nome
}

get [Symbol.toStringTag]() {
return 'Pessoa'
}
}

const joao = new Pessoa('João')

Sacou? Você declara a marca uma vez na classe e ela passa a valer pra toda instância

O bônus disso é que essa marca é sua, você escreveu ela na mão, então ela não depende do nome da função sobreviver ao build

Bora ver isso no próximo tópico…

Como pegar o nome da VARIÁVEL, e não o da classe?

Essa pergunta aparece direto e a resposta honesta é: não dá, pelo menos não do jeito que você imagina

Nome de variável é coisa do código-fonte, ele não existe mais quando o programa está rodando

O que existe é um truque conhecido: você monta um objeto usando a variável como atalho de propriedade e lê a chave dele

const joao = new Pessoa('João')

console.log(nomeDaVariavel) // "joao"

Funciona porque { joao } é a forma curta de { joao: joao }, então o nome da variável vira uma chave de verdade

É gambiarra? É, um pouco haha

Mas pra log de debug rápido ela quebra um galho absurdo

Uma função segura que funciona em qualquer caso:

Até agora tudo funcionou porque nossos exemplos são bonitinhos

No código real chega null, chega undefined, chega objeto literal e chega objeto criado com Object.create(null), que não tem constructor nenhum

Se você fizer valor.constructor.name nesses casos, toma um belo de um TypeError

Então bora blindar isso:

function getNomeDoTipo(valor) {
if (valor === null) return 'null'
if (valor === undefined) return 'undefined'

if (valor.constructor && valor.constructor.name) {
return valor.constructor.name
}

return Object.prototype.toString.call(valor).slice(8, -1)
}

console.log(getNomeDoTipo(new Pessoa('João')))
console.log(getNomeDoTipo({}))
console.log(getNomeDoTipo(null))
console.log(getNomeDoTipo(Object.create(null)))

Repara na ordem: primeiro tenta o caminho rápido do constructor, e só cai no toString quando o objeto não tem constructor

Joga essa função no seu arquivo de utils e nunca mais pensa nisso =)

E quando o build minifica tudo?

O post já avisou que o nome pode sumir na minificação, mas fica a pergunta: e daí, o que eu faço?

O caminho é simples: pare de depender de um nome que a ferramenta de build pode renomear e declare o nome VOCÊ mesmo

class Pessoa {
static get tipo() {
return 'Pessoa'
}

constructor(nome) {
this.nome = nome
}
}

const joao = new Pessoa('João')

console.log(joao.constructor.tipo) // "Pessoa"

Como o texto ‘Pessoa’ está dentro de uma string, ele atravessa o build inteiro sem ninguém mexer

Regra de bolso que eu sigo: constructor.name é ótimo pra debug no seu terminal

agora quando o nome vira LÓGICA do sistema (salvar tipo no banco, escolher um handler, serializar), aí a string explícita é a escolha certa

Qual dos três usar em cada caso?

Pra fechar sem enrolação, um resumão pra tu escolher rápido:

E uma coisa que confunde bastante: typeof NÃO serve pra isso

console.log(typeof joao) // "object"
console.log(typeof null) // "object"

Tudo vira "object" e você fica no mesmo lugar haha

O typeof responde "que espécie de valor é esse", enquanto o constructor.name responde "quem criou esse objeto"

São perguntas diferentes, beleza?

Perguntas frequentes:

constructor.name funciona com objeto literal?

Funciona, e devolve "Object", porque todo objeto literal é criado pelo construtor Object

console.log(({ a: 1 }).constructor.name) // "Object"

Qual a diferença de constructor.name pra instanceof?

O instanceof responde sim ou não pra uma classe específica, e ele enxerga a herança inteira

já o constructor.name devolve só o nome exato de quem criou o objeto

class Dev extends Pessoa {}

const joao = new Dev('João')

console.log(joao instanceof Pessoa) // true
console.log(joao.constructor.name) // "Dev"

Se a sua decisão é "esse objeto é uma Pessoa?", use instanceof

se é "qual o nome disso pra eu logar?", use constructor.name

Dá pra pegar o nome de uma função?

Dá, é a mesma propriedade name

function somar(a, b) {
return a + b
}

console.log(somar.name) // "somar"

E o nome de uma arrow function?

A arrow pega o nome da constante em que ela foi guardada

const somar = (a, b) => a + b

console.log(somar.name) // "somar"

Mas se ela for passada solta como callback, sem nome nenhum, o name vem vazio

Onde isso salva sua pele no dia a dia:

Pra não ficar só na teoria, o uso que eu mais vejo hoje é em tratamento de erro

Quando algo estoura, você quase nunca quer o objeto inteiro no log, quer só saber QUE tipo de erro foi

class ErroDeValidacao extends Error {}

try {
throw new ErroDeValidacao('CPF inválido')
} catch (erro) {
console.log(erro.constructor.name) // "ErroDeValidacao"
console.log(erro.message)
}

Duas linhas e o seu log já diz o que aconteceu, sem stack trace gigante poluindo o terminal

O mesmo vale pra serialização (guardar o tipo junto do dado) e pra fábrica de objetos, quando você escolhe o caminho do código pelo tipo que chegou

faça o teste no seu projeto, é o tipo de detalhe pequeno que deixa o debug MUITO mais rápido