0Pricing
TypeScript Academy · Aula

Tipos como Linguagem de Computação

Entenda o sistema de tipos como uma linguagem funcional pura.

Tipos como Linguagem de Computação é 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.

Os tipos são uma linguagem

O TypeScript tem duas linguagens lado a lado. Uma é o JavaScript no nível dos valores que você já conhece. A outra é o nível dos tipos, que é executado inteiramente durante a compilação. Neste curso, você aprenderá a programar nessa segunda linguagem.

O sistema de tipos é uma pequena linguagem funcional e pura. Você fornece tipos como entrada, e ela calcula tipos como saída. Nada disso sobrevive durante a execução.

type Greeting = "hello";
type Loud = Uppercase<Greeting>;
// Loud is "HELLO" - computed by the type system

Tipos de entrada, tipos de saída

Um tipo genérico é essencialmente uma função de tipos para tipos. O parâmetro de tipo é o argumento, e o corpo é o valor de retorno.

Abaixo, Boxed recebe um tipo T e produz um tipo de objeto que o encapsula. Pense em T como um parâmetro que você fornece.

type Boxed<T> = { value: T };

type A = Boxed<number>; // { value: number }
type B = Boxed<string>; // { value: string }

Os genéricos são funções

Compare uma função no nível dos valores com uma função no nível dos tipos. As estruturas são quase idênticas: parâmetros entram e um único resultado sai.

  • Valor: const id = (x) => x
  • Tipo: type Id<T> = T

O Id no nível dos tipos simplesmente retorna aquilo que você fornecer.

type Id<T> = T;

type X = Id<boolean>; // boolean
type Y = Id<"abc">;  // "abc"

Nenhum custo durante a execução

Tudo que está no nível dos tipos é apagado antes da execução do seu código. A saída JavaScript não contém nenhum vestígio dos cálculos de tipos. Não há custo de desempenho no programa em execução, por mais elaborados que sejam os seus tipos.

É por isso que a programação no nível dos tipos às vezes é chamada de gratuita: ela afeta apenas o compilador, nunca o pacote final.

type Pair<T> = [T, T];
const p: Pair<number> = [1, 2];
// Compiled JS is just: const p = [1, 2];
console.log(p);

Vários parâmetros

As funções no nível dos tipos podem receber vários parâmetros, assim como as funções comuns. Aqui, Merge recebe dois tipos de objeto e os combina.

Leia assim: dados A e B, retorne um objeto que tenha todas as propriedades de ambos.

type Merge<A, B> = A & B;

type User = { id: number };
type Named = { name: string };
type NamedUser = Merge<User, Named>;
// { id: number; name: string }

Valores padrão dos parâmetros

Os parâmetros de tipo podem ter valores padrão, exatamente como os argumentos padrão de funções. Se quem chama omitir o argumento, o valor padrão será usado.

type List<T = string> = T[];

type A = List;        // string[]
type B = List<number>; // number[]

Restrições funcionam como salvaguardas

Uma restrição com extends limita quais tipos podem ser passados. Ela equivale, no nível de tipos, a validar um argumento de função antes de usá-lo.

HasId aceita apenas tipos que já têm uma propriedade id, portanto o corpo pode lê-la com segurança.

type GetId<T extends { id: number }> = T["id"];

type A = GetId<{ id: number; name: string }>; // number
// GetId<{ name: string }> would be a compile error

Cálculo, não apenas anotação

Iniciantes usam tipos apenas para rotular valores. A programação em nível de tipos usa tipos para calcular respostas. O utilitário integrado ReturnType, por exemplo, inspeciona um tipo de função e extrai o tipo do resultado.

type Fn = (a: number) => string;
type R = ReturnType<Fn>; // string

type Fn2 = () => boolean;
type R2 = ReturnType<Fn2>; // boolean

Mapeamento de propriedades

Os tipos mapeados permitem transformar cada propriedade de um tipo de objeto. Isso é um laço na linguagem de tipos. Stringify transforma cada tipo de valor em string.

type Stringify<T> = { [K in keyof T]: string };

type Input = { a: number; b: boolean };
type Out = Stringify<Input>; // { a: string; b: string }

Pura e determinística

A linguagem de tipos é pura: as mesmas entradas sempre produzem o mesmo tipo de saída, sem efeitos colaterais. Não há mutação, nem IO, nem tempo. É essa pureza que torna os programas em nível de tipos previsíveis e combináveis.

Graças à pureza, você raciocina sobre tipos da mesma forma que raciocina sobre matemática: por substituição.

type Square<T extends { area: number }> = T["area"];
// Always the same result for the same input shape

Por que isso importa

Dominar essa segunda linguagem permite codificar regras que o compilador impõe gratuitamente: rotas válidas, instruções switch exaustivas, manipulação segura de cadeias de caracteres e APIs que não podem ser usadas de forma incorreta. O restante deste curso constrói esse conjunto de ferramentas.

Ideia central: um tipo é um valor na linguagem de tipos, e um genérico é uma função.

type NonEmpty<T extends unknown[]> =
  T extends [unknown, ...unknown[]] ? T : never;
// Encodes a rule: the tuple must have at least one element

Verificação rápida

Teste sua compreensão dos tipos como uma linguagem de cálculo.

Recapitulação

Você aprendeu que os tipos de TypeScript formam uma linguagem funcional pura que é executada em tempo de compilação.

  • Genéricos são funções: tipos entram, tipos saem.
  • Os parâmetros aceitam valores padrão e restrições com extends.
  • Os tipos mapeados percorrem as propriedades.
  • Tudo é apagado, portanto não há custo em tempo de execução.

A seguir, você dará a essa linguagem uma instrução condicional: os tipos condicionais.

Perguntas Frequentes

A aula “Tipos como Linguagem de Computação” é grátis?

Sim — o texto completo de “Tipos como Linguagem de Computação” é 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 “Tipos como Linguagem de Computação”?

Entenda o sistema de tipos como uma linguagem funcional pura. 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 “Tipos como Linguagem de Computação”?

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. Tipos como Linguagem de Computação
  2. Condicionais no Nível de Tipos
  3. Recursão no Nível de Tipos
  4. Tipos Condicionais Distributivos
← Voltar para TypeScript Academy