Cheat Sheet de TypeScript
Última atualização
Tipos básicos
Os tipos primitivos e como anotar variáveis.
| Operação | Sintaxe |
|---|---|
| String | let name: string = "Ada"; |
| Número | let age: number = 25; |
| Booleano | let ok: boolean = true; |
| Array de T | let xs: number[] = [1, 2, 3]; |
| Array genérico | let xs: Array<string> = []; |
| Tupla | let pair: [string, number] = ["a", 1]; |
| Any (sem tipagem) | let x: any = 1; |
| Unknown (any seguro) | let x: unknown = JSON.parse(s); |
| Void (sem retorno) | function log(): void { … } |
| Never (nunca retorna) | function fail(): never { throw … } |
| Null / undefined | let n: null = null; |
Inferência e anotações de tipo
Quando deixar o TS inferir e quando anotar.
| Operação | Sintaxe |
|---|---|
| Inferido pelo valor | let count = 0; // number |
| Anotação explícita | let count: number = 0; |
| Parâmetro de função | function add(a: number, b: number) { … } |
| Tipo de retorno | function add(a: number, b: number): number { … } |
| Arrow function | const sq = (x: number): number => x * x; |
| Asserção de tipo | const el = input as HTMLInputElement; |
| Asserção const (literal) | const dirs = ["up", "down"] as const; |
| Asserção de não-nulo | el!.focus(); |
Interfaces
Descreve o formato de um objeto.
| Operação | Sintaxe |
|---|---|
| Declarar | interface User { id: number; name: string; } |
| Propriedade opcional | interface User { age?: number; } |
| Propriedade readonly | interface User { readonly id: number; } |
| Assinatura de método | interface Logger { log(msg: string): void; } |
| Estender outra interface | interface Admin extends User { role: string; } |
| Assinatura de índice | interface Map { [key: string]: number; } |
| Implementar em uma classe | class Db implements Logger { … } |
Type aliases e uniões
Nomeie um tipo e combine tipos com | e &.
| Operação | Sintaxe |
|---|---|
| Type alias | type ID = string | number; |
| Alias de objeto | type User = { id: number; name: string }; |
| Tipo união | type Status = "idle" | "loading" | "done"; |
| Tipo interseção | type Admin = User & { role: string }; |
| Tipo literal | type Yes = "yes"; |
| Anulável | type Maybe<T> = T | null | undefined; |
| Alias de função | type Handler = (e: Event) => void; |
Funções
Parâmetros tipados, retornos e sobrecargas.
| Operação | Sintaxe |
|---|---|
| Parâmetro opcional | function greet(name?: string) { … } |
| Parâmetro padrão | function greet(name = "friend") { … } |
| Parâmetros rest | function sum(...ns: number[]): number { … } |
| Tipo de função | let fn: (a: number) => number; |
| Interface chamável | interface Fn { (x: number): number; } |
| Assinaturas de sobrecarga | function f(x: string): string; function f(x: number): number; function f(x: any) { return x; } |
| Retorno void ignorado | const cb: () => void = () => 42; // ok |
Classes
Classes com modificadores de acesso e propriedades de parâmetro.
| Operação | Sintaxe |
|---|---|
| Declarar uma classe | class User { name: string; } |
| Construtor | constructor(name: string) { this.name = name; } |
| Propriedade de parâmetro | constructor(public name: string) {} |
| Public / private / protected | private id: number; |
| Campo readonly | readonly id: number; |
| Membro estático | static count = 0; |
| Getter / setter | get name() { return this._name; } |
| Herança | class Admin extends User { … } |
| Classe abstrata | abstract class Shape { abstract area(): number; } |
Generics
Tipos reutilizáveis parametrizados por outros tipos.
| Operação | Sintaxe |
|---|---|
| Função genérica | function id<T>(x: T): T { return x; } |
| Chamar com tipo explícito | id<string>("hi"); |
| Interface genérica | interface Box<T> { value: T; } |
| Alias genérico | type Pair<A, B> = [A, B]; |
| Classe genérica | class Stack<T> { items: T[] = []; } |
| Restrição com extends | function len<T extends { length: number }>(x: T) { return x.length; } |
| Parâmetro de tipo padrão | interface Box<T = string> { value: T; } |
| Operador keyof | type K = keyof User; // "id" | "name" |
| Acesso por índice | type Name = User["name"]; |
Narrowing
Refine uma união para um único tipo em tempo de execução.
| Operação | Sintaxe |
|---|---|
| Verificação com typeof | if (typeof x === "string") { … } |
| Verificação com instanceof | if (e instanceof Error) { … } |
| Operador in | if ("name" in obj) { … } |
| Narrowing por igualdade | if (status === "done") { … } |
| Por veracidade | if (value) { … } |
| Type guard customizado | function isUser(x: any): x is User { return "id" in x; } |
| União discriminada | type Shape = { kind: "sq"; size: number } | { kind: "ci"; r: number }; |
| Exaustividade com never | const _: never = shape; |
Enums
Conjuntos nomeados de constantes.
| Operação | Sintaxe |
|---|---|
| Enum numérico | enum Direction { Up, Down, Left, Right } |
| Enum de strings | enum Status { Idle = "IDLE", Done = "DONE" } |
| Usar um valor | let d: Direction = Direction.Up; |
| Const enum (inline) | const enum Color { Red, Green, Blue } |
| União de literais (moderno) | type Status = "idle" | "done"; |
Utility types
Helpers embutidos que transformam tipos existentes.
| Operação | Sintaxe |
|---|---|
| Todas as props opcionais | Partial<User> |
| Todas as props obrigatórias | Required<User> |
| Todas as props readonly | Readonly<User> |
| Selecionar subconjunto de chaves | Pick<User, "id" | "name"> |
| Omitir uma ou mais chaves | Omit<User, "password"> |
| Objeto com chaves dadas | Record<string, number> |
| Excluir de uma união | Exclude<"a" | "b" | "c", "a"> |
| Manter apenas de uma união | Extract<"a" | "b", "a" | "c"> |
| Remover null / undefined | NonNullable<string | null> |
| Tipo de retorno | ReturnType<typeof fn> |
| Tupla de parâmetros | Parameters<typeof fn> |
| Tipo da promise resolvida | Awaited<Promise<string>> |
Módulos
Importe e exporte entre arquivos.
| Operação | Sintaxe |
|---|---|
| Export nomeado | export function add(a: number, b: number) { … } |
| Export padrão | export default class User { … } |
| Re-exportar | export { User } from "./user"; |
| Import nomeado | import { add } from "./math"; |
| Import padrão | import User from "./user"; |
| Import apenas de tipo | import type { User } from "./user"; |
| Importar tudo | import * as math from "./math"; |
| Referência triple-slash | /// <reference types="node" /> |
Essenciais do tsconfig
As flags do compilador que valem a pena conhecer.
| Opção | Efeito |
|---|---|
"strict": true | Ativa todas as verificações do modo estrito (recomendado). |
"target": "ES2022" | Versão de JavaScript que o tsc emite. |
"module": "ESNext" | Sistema de módulos na saída emitida. |
"moduleResolution": "bundler" | Resolve módulos como os bundlers modernos. |
"jsx": "react-jsx" | Habilita JSX para React 17+. |
"esModuleInterop": true | Imports padrão mais limpos a partir de CommonJS. |
"skipLibCheck": true | Pula a checagem de tipos em node_modules (mais rápido). |
"noEmit": true | Apenas verificação de tipos — o bundler emite a saída. |
A sintaxe de TypeScript que você mais usa, em uma única página. Este cheat sheet de TypeScript é uma referência rápida para o dia a dia em TS: tipos básicos, interfaces, type aliases, generics, uniões, narrowing e os utility types embutidos.
Tudo aqui é TypeScript padrão que compila com tsc e roda em qualquer lugar onde JavaScript moderno funciona. Copie o que precisar ou teste qualquer trecho ao vivo no playground de TypeScript, sem instalar nada.
Perguntas frequentes sobre o cheat sheet de TypeScript
Este cheat sheet de TypeScript é grátis?
Sim. Este cheat sheet de TypeScript é totalmente grátis, sem necessidade de cadastro. Salve nos favoritos e volte sempre que precisar consultar um tipo, uma interface ou um utility type.
Qual a diferença entre interface e type alias?
Ambos podem descrever o formato de um objeto e, na maioria dos casos do dia a dia, são intercambiáveis. Interfaces podem ser reabertas e estendidas entre arquivos (declaration merging), o que é útil para tipos de bibliotecas. Type aliases podem nomear uniões, interseções, tuplas e mapped types — formatos que você não consegue expressar com
interface. Regra prática: use interface para formatos de objeto públicos e type para uniões, tuplas e tipos calculados.Qual a diferença entre any e unknown?
any desativa totalmente a checagem de tipos — o compilador deixa você fazer qualquer coisa com ele. unknown é seguro: você precisa restringi-lo (com typeof, instanceof ou um type guard) antes de usar. Prefira unknown para valores vindos de fontes externas como JSON.parse ou fetch — ele força você a validar antes de usar.Preciso aprender JavaScript antes de TypeScript?
Sim — TypeScript é JavaScript com um sistema de tipos por cima, então toda habilidade em JS é aproveitada. Se você ainda está fortalecendo os fundamentos (arrays, objetos, async/await), o cheat sheet de JavaScript é um bom ponto de partida e o curso grátis de JavaScript da Coddy cobre o mesmo conteúdo de forma interativa.
Posso praticar TypeScript online?
Sim. Abra o playground de TypeScript para rodar qualquer trecho deste cheat sheet no seu navegador — sem instalar nada. Quando quiser estrutura, aprenda pelo landing de JavaScript e aplique os tipos desta página por cima.
Recursos relacionados
Mais folhas de consulta
