TypeScript Academy · Aula

Asserções const com as const

Congele objetos e matrizes em tipos literais profundamente somente para leitura.

Asserções const com as const é uma aula grátis de TypeScript Academy no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de TypeScript Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de TypeScript Academy inclui 4 aulas no total.

A asserção as const

Uma asserção const, escrita como as const, instrui o TypeScript a inferir o tipo mais específico e profundamente readonly possível para um valor. As propriedades de objetos tornam-se literais e imutáveis; os vetores tornam-se tuplas somente leitura.

const point = { x: 10, y: 20 } as const;
// type: { readonly x: 10; readonly y: 20 }
console.log(point.x, point.y);

Sem as const

Sem a asserção, as propriedades dos objetos são alargadas. { x: 10 } infere x: number e é mutável. Compare isso com a cena anterior para ver o que as const altera.

const a = { x: 10 };       // x: number, mutable
const b = { x: 10 } as const; // x: 10, readonly
a.x = 99; // allowed
console.log(a.x, b.x);

Fixando propriedades como literais

as const transforma cada propriedade de texto em seu tipo literal. Isso é extremamente útil para objetos de configuração cujas chaves e valores precisam permanecer exatos.

const config = {
  env: 'production',
  retries: 3
} as const;
// env: 'production', retries: 3
console.log(config.env, config.retries);

readonly impede mutações

Como as const torna as propriedades readonly, o compilador bloqueia reatribuições. O valor é imutável no nível dos tipos, protegendo-o contra alterações acidentais.

const settings = { mode: 'dark' } as const;
console.log(settings.mode);
// settings.mode = 'light'; // Error: readonly property

Asserções const em vetores

Quando aplicado a um vetor, as const produz uma tupla somente leitura de tipos literais. O comprimento é fixo e cada elemento mantém seu valor exato.

const colors = ['red', 'green', 'blue'] as const;
// type: readonly ['red', 'green', 'blue']
console.log(colors[0], colors.length);

Nenhuma mutação em vetores somente leitura

Uma tupla somente leitura rejeita métodos de mutação, como push, ou atribuições por índice. Os dados ficam protegidos, exatamente como você precisa em tabelas de consulta fixas.

const days = ['Mon', 'Tue', 'Wed'] as const;
console.log(days.join(', '));
// days.push('Thu'); // Error: push does not exist on readonly tuple

Derivando uma união com typeof arr[number]

Um padrão poderoso: use um vetor readonly e derive uma união dos tipos de seus elementos com typeof arr[number]. Você escreve os valores uma vez e obtém uma união literal sem esforço adicional.

const ROLES = ['admin', 'editor', 'viewer'] as const;
type Role = typeof ROLES[number];
// 'admin' | 'editor' | 'viewer'
const r: Role = 'editor';
console.log(r);

Fonte única da verdade

Isso mantém seu vetor em tempo de execução e seu tipo sincronizados. Adicione um valor ao vetor, e a união será atualizada automaticamente — não há listas duplicadas para manter.

const SIZES = ['S', 'M', 'L', 'XL'] as const;
type Size = typeof SIZES[number];

function pick(s: Size): void {
  console.log('Picked', s);
}
pick('M');

Asserções const em tuplas

Para tuplas cujos tipos de elementos são diferentes, as const preserva tanto os tipos exatos quanto a ordem, produzindo uma tupla somente leitura precisa.

const pair = [1, 'one'] as const;
// type: readonly [1, 'one']
console.log(pair[0], pair[1]);

Comportamento de somente leitura profunda

as const é aplicado profundamente. Objetos e vetores aninhados também se tornam somente leitura, com tipos literais até o nível mais interno.

const data = {
  name: 'app',
  tags: ['a', 'b']
} as const;
// tags is readonly ['a', 'b']
console.log(data.name, data.tags[1]);

Asserções const para enumerações

Um objeto const combinado com uma união derivada é uma alternativa leve a enum. Você obtém valores literais em tempo de execução e um tipo exato, sem nenhum código adicional gerado.

const Status = {
  Idle: 'idle',
  Active: 'active'
} as const;
type Status = typeof Status[keyof typeof Status];
const s: Status = Status.Active;
console.log(s);

Verificação rápida

Teste sua compreensão das asserções const.

Recapitulação: as const

Você aprendeu que as const:

Infere o tipo literal mais específico e profundamente readonly.
Transforma as propriedades de objetos em campos literais somente leitura.
Transforma vetores em tuplas somente leitura de literais.
Permite derivar uniões com typeof arr[number], mantendo valores e tipos sincronizados.

A seguir, combinaremos literais em uniões expressivas.

const LEVELS = ['low', 'mid', 'high'] as const;
type Level = typeof LEVELS[number];
const chosen: Level = 'mid';
console.log(chosen);

Perguntas Frequentes

A aula “Asserções const com as const” é grátis?

Sim — o texto completo de “Asserções const com as const” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de TypeScript Academy, atualize para CoddyKit PRO. O curso de TypeScript Academy inclui 4 aulas no total.

O que vou aprender em “Asserções const com as const”?

Congele objetos e matrizes em tipos literais profundamente somente para leitura. Você pratica TypeScript Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar TypeScript Academy?

Nenhuma experiência prévia é necessária. TypeScript Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “Asserções const com as const”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de TypeScript Academy?

Sim. Cada aula de TypeScript Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

Tipos Literais de Texto e Números
Literais Booleanos e Inferência de Literais
Asserções const com as const
Combinando Literais em Uniões

← Voltar para TypeScript Academy