TypeScript Academy · Aula

Literais Booleanos e Inferência de Literais

Entenda como o TypeScript amplia ou restringe a inferência de literais.

Literais Booleanos e Inferência de Literais é uma aula grátis de TypeScript Academy no CoddyKit. Esta é a aula 2 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.

Tipos literais booleanos

O tipo boolean é, na verdade, a união true | false. Cada um deles é um tipo literal booleano: um tipo que permite apenas um valor booleano específico.

let yes: true = true;
let no: false = false;
console.log(yes, no);
// yes = false; // Error: false not assignable to true

Literais booleanos em uniões

Os literais booleanos são especialmente úteis quando combinados com outros literais para modelar resultados discriminados, como um sinalizador de sucesso combinado com o formato de uma carga útil.

type Result =
  | { ok: true; value: number }
  | { ok: false; error: string };

const r: Result = { ok: true, value: 42 };
console.log(r);

Ampliação de tipos

Ao inicializar uma variável, o TypeScript decide qual tipo inferir. Às vezes, ele mantém o literal exato; outras vezes, amplia para o tipo geral. Entender isso é essencial para obter tipos previsíveis.

const exact = 'hello'; // type: 'hello' (literal)
let broad = 'hello';   // type: string (widened)
console.log(exact, broad);

Variáveis reatribuíveis usam o tipo geral

Como uma variável let pode receber uma nova atribuição, o TypeScript infere o tipo geral para permitir atribuições futuras. Uma cadeia de caracteres em let começa como string, não como o literal.

let mood = 'happy'; // inferred as string
mood = 'sad';       // allowed
mood = 'tired';     // allowed
console.log(mood);

Constantes mantêm o literal

Uma const nunca pode receber uma nova atribuição, então o TypeScript infere o tipo mais específico — o literal. Por isso, const greeting = 'hi' tem o tipo 'hi', e não string.

const greeting = 'hi'; // type: 'hi'

type Greeting = typeof greeting; // 'hi'
const other: Greeting = 'hi';
console.log(other);

Ampliação com números e booleanos

A mesma regra se aplica a números e booleanos. const mantém 42 ou true como literal; let amplia para number ou boolean.

const n = 42;   // type: 42
const b = true; // type: true
let m = 42;     // type: number
let c = true;   // type: boolean
console.log(n, b, m, c);

Por que a ampliação existe

A ampliação torna o código cotidiano mais prático. Se todo let count = 0 tivesse o tipo literal 0, você não poderia incrementá-lo. A ampliação permite que variáveis reatribuíveis funcionem naturalmente.

let count = 0; // widened to number
count = count + 1;
count = 10;
console.log('Count:', count);

Forçando um literal com anotação

Às vezes, você quer que uma variável let permaneça literal. Adicione uma anotação explícita de tipo literal, e o TypeScript a manterá restrita, permitindo ainda novas atribuições dentro dessa união.

let status: 'on' | 'off' = 'on';
status = 'off'; // allowed
console.log(status);
// status = 'paused'; // Error

Ampliação em propriedades de objetos

As propriedades de literais de objetos também são ampliadas por padrão. Mesmo em um objeto const, as propriedades mutáveis recebem o tipo geral, porque a própria propriedade pode receber uma nova atribuição.

const config = { mode: 'dark' };
// config.mode has type string, not 'dark'
config.mode = 'light';
console.log(config.mode);

Inferência de literais com funções

Os valores de retorno das funções também são inferidos. Uma função que retorna um valor literal de uma constante ainda amplia o tipo de retorno para o tipo geral, a menos que você faça uma anotação ou use tipos literais na assinatura.

function getMode(): 'dark' | 'light' {
  return 'dark';
}

const m = getMode(); // type: 'dark' | 'light'
console.log(m);

Escolhendo entre literal e geral

Regra prática: use const ou anotações literais explícitas quando precisar de valores exatos (chaves de configuração, discriminantes). Deixe o alargamento acontecer em variáveis mutáveis comuns. Saber qual comportamento ocorrerá evita erros surpreendentes de atribuição.

const KEY = 'apiUrl';     // literal 'apiUrl'
let retries = 3;          // number
let level: 'low' | 'high' = 'low'; // pinned literal
console.log(KEY, retries, level);

Verificação rápida

Teste sua compreensão sobre alargamento e inferência de literais.

Recapitulação: inferência de literais

Principais conclusões:

true e false são tipos literais; boolean equivale a true | false.
let é alargado para o tipo geral (string, number, boolean).
const mantém o tipo literal exato.
Anote com um tipo literal para fixar um let em uma união restrita.

A seguir, tornaremos a imutabilidade explícita com as const.

const literal = 'fixed'; // 'fixed'
let widened = 'fixed';   // string
let pinned: 'a' | 'b' = 'a';
console.log(literal, widened, pinned);

Perguntas Frequentes

A aula “Literais Booleanos e Inferência de Literais” é grátis?

Sim — o texto completo de “Literais Booleanos e Inferência de Literais” é 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 “Literais Booleanos e Inferência de Literais”?

Entenda como o TypeScript amplia ou restringe a inferência de literais. 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 2 de 4.

Quanto tempo leva a aula “Literais Booleanos e Inferência de Literais”?

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