0Pricing
TypeScript Academy · Aula

Mecânicas de ampliação e restrição de tipos

Aprenda como TypeScript amplia tipos e quando impedir isso

Mecânicas de ampliação e restrição de tipos é 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 é o alargamento de tipos?

O alargamento de tipos ocorre quando o TypeScript infere um tipo mais amplo do que aquele que você escreveu. A atribuição let x = "hello" é alargada para string, e não para o tipo literal "hello".

let x = "hello"; // inferred: string, not "hello"
let y = 42;       // inferred: number, not 42

Alargamento com let versus const

As variáveis declaradas com const mantêm seu tipo literal porque não podem ser reatribuídas. let é alargado para o tipo base.

const a = "world"; // type: "world"
let   b = "world"; // type: string

Impedindo o alargamento com anotações de tipo

Anotar explicitamente uma variável let impede o alargamento e fixa o tipo literal.

let direction: "left" | "right" = "left";
// direction = "up"; // Error: not assignable

Estreitamento com typeof

O TypeScript estreita um tipo união dentro das verificações com typeof, fornecendo um tipo preciso nesse ramo.

function format(val: string | number) {
  if (typeof val === "string") {
    return val.toUpperCase(); // val: string here
  }
  return val.toFixed(2);     // val: number here
}

Estreitamento com verificações de igualdade

As verificações de igualdade com valores literais também estreitam o tipo dentro do ramo.

type Direction = "left" | "right" | "up";
function handle(dir: Direction) {
  if (dir === "left") {
    console.log("Going left"); // dir: "left"
  }
}

Análise do fluxo de controle

O TypeScript acompanha as atribuições pelo fluxo de controle, estreitando o tipo após cada ramo.

function process(x: string | null) {
  if (x === null) return;
  // x is string here — TypeScript knows null is ruled out
  console.log(x.length);
}

Alargamento em literais de objeto

Os valores das propriedades de literais de objeto também são alargados, a menos que você use as const.

const config = { mode: "dark" };
// config.mode: string (widened)

const config2 = { mode: "dark" } as const;
// config2.mode: "dark" (literal)

Frescor e alargamento

Quando você atribui um literal de objeto diretamente a uma variável tipada, o TypeScript aplica a verificação de propriedades excedentes — mas, depois que o objeto é alargado para uma variável nomeada, essa verificação deixa de ser aplicada.

interface Options { timeout: number; }
const opts = { timeout: 3000, retry: true };
// No error — widened type, excess property check skipped
const o: Options = opts;

Estreitamento com o operador in

O operador in estreita tipos união de objetos verificando se uma propriedade existe.

type Cat = { meow(): void };
type Dog = { bark(): void };
function speak(animal: Cat | Dog) {
  if ("meow" in animal) animal.meow();
  else animal.bark();
}

Estreitamento com funções de asserção

As funções de asserção usam tipos de retorno asserts condition para estreitar o tipo após a chamada.

function assertString(val: unknown): asserts val is string {
  if (typeof val !== "string") throw new Error("Expected string");
}
const x: unknown = "hi";
assertString(x);
x.toUpperCase(); // OK — narrowed to string

Recapitulação: alargamento versus estreitamento

O alargamento amplia os tipos inferidos para oferecer flexibilidade; o estreitamento refina um tipo amplo, tornando-o preciso dentro de um ramo condicional. Entender ambos ajuda você a escrever TypeScript mais seguro.

Verificação rápida

Qual declaração impede o alargamento para o tipo base?

O que você aprendeu

Agora você entende o alargamento de tipos, que amplia os tipos inferidos pelo TypeScript, e o estreitamento, que produz tipos precisos por meio de verificações condicionais. Use as const para impedir o alargamento e verificações do fluxo de controle para estreitar uniões com segurança.

Perguntas Frequentes

A aula “Mecânicas de ampliação e restrição de tipos” é grátis?

Sim — o texto completo de “Mecânicas de ampliação e restrição de tipos” é 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 “Mecânicas de ampliação e restrição de tipos”?

Aprenda como TypeScript amplia tipos e quando impedir isso 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 “Mecânicas de ampliação e restrição de tipos”?

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