0Pricing
TypeScript Academy · Aula

A Palavra-chave as para Asserções de Tipo

Substitua deliberadamente os tipos inferidos usando as.

A Palavra-chave as para Asserções de Tipo é uma aula grátis de TypeScript Academy no CoddyKit. Esta é a aula 1 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 é uma asserção de tipo

Uma asserção de tipo diz ao compilador: “confie em mim, sei que este valor é do tipo T”. Você usa a palavra-chave as: value as Type. Isso altera a forma como o verificador de tipos interpreta o valor, não o valor em si.

const raw: unknown = 'hello world';
const text = raw as string;
console.log(text.toUpperCase());

A sintaxe de as

Escreva a expressão, depois as e, por fim, o tipo de destino. Também existe uma sintaxe antiga com colchetes angulares, mas as é a opção preferida porque funciona em qualquer lugar, inclusive em arquivos JSX/TSX.

const value: unknown = 42;
const n = value as number;
console.log(n + 8);

Asserções não alteram a execução

Isto é fundamental: as asserções são uma instrução que existe apenas em tempo de compilação. Elas são removidas quando o código é executado. Não ocorre conversão nem validação — se você fizer uma asserção incorreta, o valor em tempo de execução não será alterado e poderá causar um comportamento inesperado.

const v: unknown = 'not a number';
const n = v as number; // compiles, but v is still a string
console.log(typeof n); // 'string' at runtime!

Quando as asserções são válidas

O TypeScript só permite asserções diretas entre tipos que têm sobreposição — quando um pode ser atribuído ao outro. Você pode fazer uma asserção de unknown para string ou ampliar/restringir dentro de uma relação entre tipos.

const u: unknown = 'ok';
const s = u as string; // valid: unknown overlaps everything
const broad = s as string | number; // valid widening
console.log(s, broad);

Asserções diretas inválidas

Se dois tipos não tiverem nenhuma sobreposição, o TypeScript rejeitará uma asserção direta por considerá-la provavelmente um erro. Por exemplo, fazer uma asserção direta de string para number é bloqueado.

const s = 'hello';
// const n = s as number; // Error: neither type sufficiently overlaps
console.log('Direct unrelated assertions are blocked');

Restringindo uma união com as

Um uso válido comum é fazer uma asserção de um valor de união para um de seus membros quando você tem um conhecimento que falta ao compilador. Use com moderação — uma verificação em tempo de execução geralmente é mais segura.

type Shape = { kind: 'circle'; r: number } | { kind: 'square'; s: number };
const data: Shape = { kind: 'circle', r: 5 };
const circle = data as { kind: 'circle'; r: number };
console.log(circle.r);

Fazendo asserções de tipos de elementos do DOM

Um uso clássico no mundo real: as consultas do DOM retornam um tipo abrangente, como HTMLElement | null. Quando você sabe qual é o elemento específico, faça uma asserção para acessá-lo com suas propriedades específicas.

// document.getElementById returns HTMLElement | null
// const input = document.getElementById('email') as HTMLInputElement;
// console.log(input.value);
console.log('Assert HTMLElement to HTMLInputElement for .value');

Por que as asserções do DOM são necessárias

As APIs do DOM não podem saber qual elemento concreto você obterá, portanto retornam tipos gerais. Fazer uma asserção para o subtipo específico (por exemplo, HTMLInputElement) libera propriedades como value ou checked.

// const canvas = document.querySelector('#c') as HTMLCanvasElement;
// const ctx = canvas.getContext('2d');
console.log('querySelector returns Element | null; assert to specialize');

Asserções com const são um caso especial

Você já viu as const. É uma asserção especial que torna um valor somente leitura em profundidade, com tipos literais. É a única asserção sempre segura, pois apenas restringe o tipo.

const tuple = [1, 2, 3] as const;
// type: readonly [1, 2, 3]
console.log(tuple.length);

Asserções contornam a segurança

Como as asserções dizem ao compilador para parar de verificar, elas transferem a responsabilidade para você. Uma asserção incorreta pode ocultar um erro real de tipo até que ele cause uma falha em tempo de execução. Use-as somente quando realmente souber mais do que o compilador.

const data: unknown = { id: 1 };
const user = data as { id: number; name: string };
// name does not exist at runtime
console.log(user.name); // undefined, no compile error

Prefira refinar a fazer asserções

Quando possível, prefira o refinamento em tempo de execução (guardas de tipo) às asserções. O refinamento comprova o tipo; a asserção apenas o afirma. Reserve as para casos que o refinamento não consegue expressar, como a especialização de elementos do DOM.

function safe(v: unknown): number {
  if (typeof v === 'number') return v; // proven
  return 0;
}
console.log(safe(10), safe('x'));

Verificação rápida

Verifique sua compreensão das asserções de tipo.

Recapitulação: asserções com as

Você aprendeu que:

  • value as Type diz ao compilador para tratar um valor como um determinado tipo.
  • As asserções existem apenas em tempo de compilação — não há conversão nem verificação em tempo de execução.
  • Elas só são permitidas entre tipos com sobreposição.
  • Usos válidos comuns: restringir unknown e especializar tipos de elementos do DOM. Prefira o refinamento quando possível.

Em seguida, o operador de asserção de não nulidade.

const raw: unknown = 'data';
const s = raw as string;
console.log(s.length);

Perguntas Frequentes

A aula “A Palavra-chave as para Asserções de Tipo” é grátis?

Sim — o texto completo de “A Palavra-chave as para Asserções de Tipo” é 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 “A Palavra-chave as para Asserções de Tipo”?

Substitua deliberadamente os tipos inferidos usando as. 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 1 de 4.

Quanto tempo leva a aula “A Palavra-chave as para Asserções de Tipo”?

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. A Palavra-chave as para Asserções de Tipo
  2. Operador de Asserção de Não Nulidade
  3. Asserções Duplas e Seus Riscos
  4. Asserções versus Guardas de Tipo
← Voltar para TypeScript Academy