Objetos em JavaScript: criar, acessar e alterar

Objeto é a estrutura que guarda dados com nome: um cliente tem nome, email e cidade; um pedido tem id, total e status. Enquanto o array organiza por posição, o objeto organiza por rótulo — e é por isso que praticamente toda resposta de API chega como objeto.

A resposta curta para as duas dúvidas mais comuns: use ponto quando você sabe o nome da chave enquanto escreve o código, e colchetes quando o nome só existe em tempo de execução. E const num objeto não impede alterar as propriedades dele — impede apenas apontar o nome para outro objeto.

Uma ficha com campos nomeados, não uma gaveta por posição

Uma ficha de cliente não pede “dado zero, dado um, dado dois”. Ela tem campos com nome: nome, email, cidade. É por isso que um objeto combina com dados de negócio: você encontra a informação pelo rótulo, sem precisar lembrar em qual posição ela foi guardada.

Em JavaScript, um objeto é uma coleção de pares chave–valor. A notação de ponto usa uma chave conhecida no código; a de colchetes avalia uma expressão e descobre a chave em tempo de execução. Antes de executar o primeiro exemplo, tente ler em voz alta cada acesso como “na ficha pedido, campo total”; a saída confirma se o rótulo escolhido existe.

const cliente = {
  nome: 'Ana Souza',
  email: 'ana@exemplo.com.br',
  cidade: 'Sorocaba',
  vip: true,
};

console.log(cliente.nome);
console.log(cliente.cidade, cliente.vip);
console.log(cliente.telefone);
console.log(cliente);

A terceira linha é importante: pedir uma propriedade que não existe não é erro. O JavaScript devolve undefined e segue em frente. Isso é conveniente e é também a origem do erro mais comum da linguagem, quando alguém encadeia outro acesso logo depois.

Colchetes: quando a chave é uma variável

const pedido = {
  id: 1043,
  cliente: 'Ana Souza',
  total: 1638.8,
  status: 'pago',
};

const campo = 'status';

console.log(pedido[campo]);
console.log(pedido['total']);
console.log(pedido.campo);

pedido[campo] lê o valor da variável campo e procura a chave status. pedido.campo procura literalmente uma chave chamada campo, que não existe. Essa confusão aparece sempre que alguém escreve um filtro genérico ou uma tabela com colunas configuráveis.

Chaves que o ponto não alcança

Resposta de API raramente respeita as convenções do seu código. Chave com espaço, com hífen ou começando por dígito só é acessível por colchetes:

const respostaDaTransportadora = {
  'prazo em dias': 4,
  'valor-frete': 27.4,
  2024: 'tabela antiga',
};

console.log(respostaDaTransportadora['prazo em dias']);
console.log(respostaDaTransportadora['valor-frete']);
console.log(respostaDaTransportadora['2024']);
console.log(respostaDaTransportadora[2024]);
console.log(Object.keys(respostaDaTransportadora));

Duas coisas nessa saída. Primeiro: ['2024'] e [2024] levam à mesma propriedade, porque toda chave de objeto é string — o número é convertido antes da busca. Segundo: a chave numérica apareceu na frente das outras em Object.keys, mesmo tendo sido escrita por último. Essa ordem tem regra, e ela está detalhada em percorrer objeto em JavaScript.

Atalho de propriedade e desestruturação

Quando o nome da variável já é o nome que a chave deve ter, não repita:

const nome = 'Teclado mecânico';
const preco = 289.9;
const estoque = 12;

const produto = { nome, preco, estoque };

console.log(produto);

const { nome: nomeDoProduto, preco: precoDoProduto } = produto;
console.log(nomeDoProduto, precoDoProduto);

{ nome, preco, estoque } é a forma curta de { nome: nome, preco: preco, estoque: estoque }. A segunda parte é o caminho inverso — a desestruturação — com renomeação usando dois-pontos. Repare que : significa coisas diferentes nos dois lados: na criação ele separa chave e valor; na desestruturação ele renomeia a variável.

Chave computada na criação

Colchetes também funcionam dentro do literal, e é assim que se monta um objeto cuja chave só se sabe em tempo de execução:

const campoDoFiltro = 'categoria';
const valorDoFiltro = 'periferico';

const filtro = {
  [campoDoFiltro]: valorDoFiltro,
  [`ordenar_por_${campoDoFiltro}`]: 'asc',
};

console.log(filtro);

const filtroErrado = { campoDoFiltro: valorDoFiltro };
console.log(filtroErrado);

Sem os colchetes, o nome da variável vira a chave, literalmente. Com eles, o JavaScript avalia a expressão — inclusive um template string inteiro — e usa o resultado como nome da propriedade.

Alterar, adicionar e o que const protege

Atribuir a uma chave que existe altera; atribuir a uma que não existe cria:

const pedido = { id: 1043, status: 'aguardando', total: 1638.8 };

pedido.status = 'pago';
pedido.pagoEm = '2026-05-14';
pedido['codigo-rastreio'] = 'BR9128374LP';

console.log(pedido);

Repare que o Node imprime 'codigo-rastreio' entre aspas e as outras chaves sem — ele mostra aspas exatamente nas chaves que o ponto não alcançaria.

E o objeto foi declarado com const. A fronteira é esta:

const pedido = { id: 1043, status: 'aguardando' };

pedido.status = 'pago';
console.log(pedido);

pedido = { id: 1044, status: 'novo' };

Mudar por dentro: permitido. Trocar o objeto inteiro: erro. É o mesmo comportamento que a lição de variáveis em JavaScript explica com let, var e Object.freeze.

Remover propriedade: delete contra = undefined

Não são a mesma coisa, e a diferença aparece em qualquer código que percorre as chaves:

const cliente = { nome: 'Ana Souza', cpf: '000.000.000-00', cidade: 'Sorocaba' };

cliente.cidade = undefined;
console.log(cliente);
console.log('cidade' in cliente, Object.keys(cliente).length);

delete cliente.cpf;
console.log(cliente);
console.log('cpf' in cliente, Object.keys(cliente).length);

cidade continua existindo depois de receber undefined — o operador in confirma, e ela ainda conta em Object.keys. cpf, depois do delete, sumiu de verdade.

Objeto dentro de objeto

Estrutura aninhada é a regra em dado de e-commerce, e cada nível é uma chance de o acesso falhar:

const pedido = {
  id: 1043,
  cliente: {
    nome: 'Ana Souza',
    endereco: { cidade: 'Sorocaba', uf: 'SP', cep: '18010-000' },
  },
};

console.log(pedido.cliente.endereco.cidade);
console.log(pedido.cliente.endereco.complemento);
console.log(pedido.entrega?.transportadora?.nome);
console.log(pedido.entrega.transportadora.nome);

A segunda linha mostra que uma chave faltando num objeto que existe devolve undefined em paz. A quarta mostra o que acontece quando o objeto do meio não existe. O ?. da terceira linha curto-circuita a expressão inteira e devolve undefined em vez de quebrar — o diagnóstico completo está em TypeError: Cannot read properties of undefined.

Copiar e mesclar com spread

const padrao = { frete: 27.4, embalagemPresente: false, prazoEmDias: 6 };
const escolhaDoCliente = { embalagemPresente: true };

const opcoes = { ...padrao, ...escolhaDoCliente };
console.log(opcoes);
console.log(padrao);

const original = { cliente: 'Ana', endereco: { cidade: 'Sorocaba' } };
const copia = { ...original };
copia.endereco.cidade = 'Campinas';
console.log(original.endereco.cidade, copia.endereco.cidade);

const copiaFunda = structuredClone(original);
copiaFunda.endereco.cidade = 'Recife';
console.log(original.endereco.cidade, copiaFunda.endereco.cidade);

As duas primeiras linhas mostram o padrão de configuração: o objeto da direita sobrescreve o da esquerda, e o padrao não foi tocado. A terceira mostra o limite do spread: ele copia só o primeiro nível, então copia recebeu a mesma referência de endereco — mudar a cidade pela cópia mudou as duas, e por isso os dois nomes imprimem Campinas. A quarta linha é o contraste: structuredClone duplicou também o objeto de dentro, e a cidade nova ficou presa na cópia enquanto o original seguiu como estava.

Método e getter

Uma função guardada numa propriedade é um método, e dentro dele this aponta para o objeto que fez a chamada:

const carrinho = {
  itens: [
    { nome: 'Teclado mecânico', preco: 289.9 },
    { nome: 'Mouse sem fio', preco: 149.9 },
  ],
  total() {
    return this.itens.reduce((soma, item) => soma + item.preco, 0);
  },
  get quantidade() {
    return this.itens.length;
  },
};

console.log(carrinho.total().toFixed(2));
console.log(carrinho.quantidade);

quantidade é um getter: acessa como propriedade, executa como função. Note que total foi escrito com function implícito e não como arrow — método de objeto nunca é arrow, pelo motivo que a lição de funções em JavaScript demonstra com o this undefined.

Erros comuns: o ponto na chave numérica

Chave que começa por dígito com notação de ponto não é um acesso que falha: é código que nem chega a rodar.

const faturamento = {
  2024: 890400,
  2025: 1240900,
};

console.log(faturamento.2024);

A mensagem parece falar de parêntese, e é isso que despista. O motor leu faturamento, encontrou um ponto seguido de dígito, tentou interpretar .2024 como parte de um número decimal e perdeu o fio da meada — daí a reclamação sobre a lista de argumentos. O objeto está correto; o acesso é que precisa ser faturamento[2024].

O primo desse erro é a chave com hífen, que produz uma mensagem ainda mais enganosa:

const cabecalhos = { 'content-type': 'application/json' };

console.log(cabecalhos.content-type);

O motor leu cabecalhos.content menos type — uma subtração entre uma propriedade e uma variável que não existe. Nada indica que o problema é a chave. Sempre que aparecer um is not defined com o nome que vem depois de um hífen, o acesso é por colchetes.

Ponto ou colchetes, na prática

Objetos ficam mais úteis quando você precisa percorrer as chaves — contar, somar, transformar. É o assunto de percorrer objeto em JavaScript, a próxima lição da trilha de JavaScript. E quando os objetos viram uma lista, as receitas estão em array de objetos. O guia completo de JavaScript mostra a sequência de estudo.