0Pricing
TypeScript Academy · Aula

Asserções const e as const

Utilize as const para inferir precisamente tipos literais e de tupla

Asserções const e as const é uma aula grátis de TypeScript Academy no CoddyKit. Esta é a aula 4 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.

O que é as const?

as const é uma asserção de tipo que instrui o TypeScript a inferir os tipos literais mais específicos possíveis para uma expressão e a tornar todas as propriedades somente leitura.

const colors = ["red", "green", "blue"] as const;
// type: readonly ["red", "green", "blue"]

Impedindo o alargamento com as const

Sem as const, os valores de texto em matrizes e objetos são alargados para string. Com ele, eles permanecem como seus tipos literais.

const dir1 = { direction: "left" };
// dir1.direction: string

const dir2 = { direction: "left" } as const;
// dir2.direction: "left"

as const em literais de objeto

Cada propriedade de um objeto com as const se torna readonly e mantém seu tipo literal recursivamente.

const theme = {
  color: "dark",
  sizes: { sm: 8, md: 16 },
} as const;
// theme.color: "dark", theme.sizes.sm: 8 (all readonly)

as const para tipos de tupla

Matrizes com as const tornam-se tuplas somente leitura com tipos literais para os elementos — úteis para definir listas fixas de argumentos.

const args = [1, "hello", true] as const;
// type: readonly [1, "hello", true]

Derivando tipos união a partir de as const

Um padrão comum é definir uma matriz de valores com as const e depois derivar um tipo união dela usando typeof e acesso indexado.

const STATUSES = ["pending", "active", "done"] as const;
type Status = typeof STATUSES[number];
// type Status = "pending" | "active" | "done"

as const em argumentos de funções

Você pode usar as const diretamente ao chamar funções para preservar os tipos literais durante a chamada.

function setMode(mode: "dark" | "light") {}
setMode("dark" as const); // safe, preserves literal

Recursão de somente leitura

as const aplica Readonly recursivamente. Objetos e matrizes aninhados tornam-se somente leitura, impedindo mutações profundas.

const config = { db: { host: "localhost", port: 5432 } } as const;
// config.db.port = 5433; // Error: readonly

as const versus Object.freeze

as const é uma asserção em tempo de compilação — não oferece proteção em tempo de execução. Object.freeze atua em tempo de execução. Eles cumprem funções complementares.

const obj = Object.freeze({ x: 1 }); // runtime immutability
const obj2 = { x: 1 } as const;      // compile-time literal types

Asserções const versus anotações de tipo

Uma anotação de tipo amplia o tipo: const x: string = "hi" resulta no tipo string. as const restringe o tipo: const x = "hi" as const resulta em "hi".

const a: string = "hi"; // type: string
const b = "hi" as const; // type: "hi"

Uso prático: objetos semelhantes a enumerações

Muitos projetos usam objetos com as const como alternativa às enumerações, evitando suas armadilhas e mantendo a segurança de tipos.

const Direction = { Up: "UP", Down: "DOWN" } as const;
type Direction = typeof Direction[keyof typeof Direction];
// "UP" | "DOWN"

Recapitulação: as const

as const faz o TypeScript inferir tipos literais e tratar todas as propriedades como somente leitura. Ele é essencial para derivar tipos de união precisos de matrizes e criar objetos de configuração seguros.

Verificação rápida

O que as const faz com uma matriz?

O que você aprendeu

as const é uma ferramenta poderosa para fixar tipos literais, criar estruturas somente leitura e derivar tipos de união precisos de matrizes. Ele é fundamental para padrões avançados de TypeScript.

Perguntas Frequentes

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

Sim — o texto completo de “Asserções const e 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 e as const”?

Utilize as const para inferir precisamente tipos literais e de tupla 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 4 de 4.

Quanto tempo leva a aula “Asserções const e 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

  1. Mecânicas de ampliação e restrição de tipos
  2. Tipagem contextual: inferência a partir do contexto
  3. Verificação de propriedades excedentes e atualidade
  4. Asserções const e as const
← Voltar para TypeScript Academy